# 
# patch "commands.cc"
#  from [958cd3bbc982aef81f63b90b24dcebaddf135166]
#    to [3631712a17c33704a410a734fe2492c899b8ba6e]
# 
# patch "database.cc"
#  from [221715fff7bde7114e97c033876cfd103d9e84ce]
#    to [ab5914166d2a27c9c3f04f18594cc600e3c95f00]
# 
# patch "database.hh"
#  from [90a982ae9ae9e6ef58d778958e64735ba93b5029]
#    to [6d54b527c19ca83ea17c04c733cc6f90b1e4722a]
# 
# patch "database_check.cc"
#  from [924b949941d72064a292451e72c28bfb2e80755c]
#    to [56b4ee811e023ae71548557652e1da4410429ffd]
# 
# patch "diff_patch.cc"
#  from [c080a1bd6428d24243c0fc224414be6eb0fb7949]
#    to [ef0c0571db4382835b2fa73475bd23cbe6a6ea33]
# 
# patch "manifest.cc"
#  from [3d231ab4795853b737dc33a8dcb2dd4d50361fbc]
#    to [aefd8d086360ea7349a541e2dfc0f4f7c28d9913]
# 
# patch "netsync.cc"
#  from [98bb94f9c22a40bc6f826cad62737a7f9bfb9a04]
#    to [af29d63f695bfb5b0ade7e9d50e098773266f211]
# 
# patch "packet.cc"
#  from [d5c6132eb05a5c5f64c504e465d825bf8a7e17d0]
#    to [9be11d1e7653a454735d1e0f06be94d9816d6fdb]
# 
# patch "rcs_import.cc"
#  from [4e0b292289773a83cad888d88a347d0423f1ad69]
#    to [60f5ef2fcd089c3f6bde86d3dcca879dabe58d5b]
# 
# patch "revision.cc"
#  from [588fd8a7bcde43a46f0bde1dd1d13e9e77cf25a1]
#    to [38aee4ec6634d7e11d7d5db73e1ad5d4349f7de9]
# 
# patch "transforms.cc"
#  from [92b2495dcc4067794d6b3cd58c0f30f865a08a28]
#    to [1d167b91aac0a32e6336692122db4b3a575a1a24]
# 
# patch "transforms.hh"
#  from [bb010dc3df990b38ddb900d652d55cc13b4ff423]
#    to [19f4be0e47d83830cc4a4d7279a2a24a54ce2e3d]
# 
# patch "vocab.hh"
#  from [17d5f1d1a5d0cbd5c7edb41ba42e8023273b0e99]
#    to [8748cf40dd076dd813dbdab8d722b6da167218f0]
# 
# patch "vocab_terms.hh"
#  from [45c113192d19c5615f5d9822d76c686c8a301849]
#    to [b515f4fd2882a1f6d26273c9af4c28664b43bce0]
# 
--- commands.cc
+++ commands.cc
@@ -1495,8 +1495,7 @@
   boost::shared_ptr<change_set> cs(new change_set());
 
   string log_message("");
-  base64< gzip< data > > gz_dat;
-  base64< gzip< delta > > gz_del;
+  delta del;
   file_path pth(idx(args, 1)());
 
   transaction_guard guard(app.db);
@@ -1514,24 +1513,23 @@
 
   // fetch the new file input
   string s = get_stdin();
-  pack(data(s), gz_dat);    
-  new_fdata = file_data(gz_dat);  
+  new_fdata = file_data(s);
   calculate_ident(new_fdata, new_fid);
 
   // diff and store the file edge
   old_fid = manifest_entry_id(i);
   app.db.get_file_version(old_fid, old_fdata);
-  diff(old_fdata.inner(), new_fdata.inner(), gz_del);    
+  diff(old_fdata.inner(), new_fdata.inner(), del);    
   dbw.consume_file_delta(old_fid, new_fid, 
-                         file_delta(gz_del));
+                         file_delta(del));
 
   // diff and store the manifest edge
   new_man = old_man;
   new_man[pth] = new_fid;
   calculate_ident(new_man, new_mid);
-  diff(old_man, new_man, gz_del);
+  diff(old_man, new_man, del);
   dbw.consume_manifest_delta(old_mid, new_mid, 
-                             manifest_delta(gz_del));
+                             manifest_delta(del));
 
   // build and store a changeset and revision
   cs->apply_delta(pth, old_fid, new_fid);
@@ -1566,12 +1564,9 @@
 CMD(fload, "debug", "", "load file contents into db")
 {
   string s = get_stdin();
-  base64< gzip< data > > gzd;
 
-  pack(data(s), gzd);
-
   file_id f_id;
-  file_data f_data(gzd);
+  file_data f_data(s);
   
   calculate_ident (f_data, f_id);
   
@@ -1586,7 +1581,6 @@
 
   file_id anc_id(idx(args, 0)()), left_id(idx(args, 1)()), right_id(idx(args, 2)());
   file_data anc, left, right;
-  data anc_unpacked, left_unpacked, right_unpacked;
 
   N(app.db.file_version_exists (anc_id),
   F("ancestor file id does not exist"));
@@ -1601,15 +1595,11 @@
   app.db.get_file_version(left_id, left);
   app.db.get_file_version(right_id, right);
 
-  unpack(left.inner(), left_unpacked);
-  unpack(anc.inner(), anc_unpacked);
-  unpack(right.inner(), right_unpacked);
-
   vector<string> anc_lines, left_lines, right_lines, merged_lines;
 
-  split_into_lines(anc_unpacked(), anc_lines);
-  split_into_lines(left_unpacked(), left_lines);
-  split_into_lines(right_unpacked(), right_lines);
+  split_into_lines(anc.inner()(), anc_lines);
+  split_into_lines(left.inner()(), left_lines);
+  split_into_lines(right.inner()(), right_lines);
   N(merge3(anc_lines, left_lines, right_lines, merged_lines), F("merge failed"));
   copy(merged_lines.begin(), merged_lines.end(), ostream_iterator<string>(cout, "\n"));
   
@@ -1692,9 +1682,7 @@
       file_data dat;
       L(F("dumping file %s\n") % ident);
       app.db.get_file_version(ident, dat);
-      data unpacked;
-      unpack(dat.inner(), unpacked);
-      cout.write(unpacked().data(), unpacked().size());
+      cout.write(dat.inner()().data(), dat.inner()().size());
     }
   else if (idx(args, 0)() == "manifest")
     {
@@ -1721,9 +1709,7 @@
         }
 
       L(F("dumping manifest %s\n") % ident);
-      data unpacked;
-      unpack(dat.inner(), unpacked);
-      cout.write(unpacked().data(), unpacked().size());
+      cout.write(dat.inner()().data(), dat.inner()().size());
     }
 
   else if (idx(args, 0)() == "revision")
@@ -1750,9 +1736,7 @@
         }
 
       L(F("dumping revision %s\n") % ident);
-      data unpacked;
-      unpack(dat.inner(), unpacked);
-      cout.write(unpacked().data(), unpacked().size());
+      cout.write(dat.inner()().data(), dat.inner()().size());
     }
   else 
     throw usage(name);
@@ -2140,7 +2124,7 @@
   app.db.get_manifest(m_old_id, m_old);
   app.db.get_manifest(m_new_id, m_new);
 
-  base64< gzip<delta> > del;
+  delta del;
   diff(m_old, m_new, del);
   pw.consume_manifest_delta(m_old_id, m_new_id, 
                             manifest_delta(del));
@@ -2161,7 +2145,7 @@
 
   app.db.get_file_version(f_old_id, f_old_data);
   app.db.get_file_version(f_new_id, f_new_data);
-  base64< gzip<delta> > del;
+  delta del;
   diff(f_old_data.inner(), f_new_data.inner(), del);
   pw.consume_file_delta(f_old_id, f_new_id, file_delta(del));  
 }
@@ -2611,7 +2595,7 @@
             L(F("inserting manifest delta %s -> %s\n") 
               % edge_old_manifest(edge) 
               % rs.new_manifest);
-            base64< gzip<delta> > del;
+            delta del;
             diff(m_old, m_new, del);
             dbw.consume_manifest_delta(edge_old_manifest(edge), 
                                        rs.new_manifest, 
@@ -2641,7 +2625,7 @@
                 L(F("inserting delta %s -> %s\n") 
                   % delta_entry_src(i) % delta_entry_dst(i));
                 file_data old_data;
-                base64< gzip<data> > new_data;
+                data new_data;
                 app.db.get_file_version(delta_entry_src(i), old_data);
                 read_localized_data(delta_entry_path(i), new_data, app.lua);
                 // sanity check
@@ -2650,7 +2634,7 @@
                 N(tid == delta_entry_dst(i).inner(),
                   F("file '%s' modified during commit, aborting")
                   % delta_entry_path(i));
-                base64< gzip<delta> > del;
+                delta del;
                 diff(old_data.inner(), new_data, del);
                 dbw.consume_file_delta(delta_entry_src(i), 
                                        delta_entry_dst(i), 
@@ -2659,7 +2643,7 @@
             else
               {
                 L(F("inserting full version %s\n") % delta_entry_dst(i));
-                base64< gzip<data> > new_data;
+                data new_data;
                 read_localized_data(delta_entry_path(i), new_data, app.lua);
                 // sanity check
                 hexenc<id> tid;
@@ -2733,7 +2717,7 @@
             {
               file_data dat;
               app.db.get_file_version(delta_entry_dst(i), dat);
-              unpack(dat.inner(), unpacked);
+              unpacked = dat.inner();
             }
           else
             {
@@ -2762,35 +2746,31 @@
       else
         {
           file_data f_old;
-          gzip<data> decoded_old;
-          data decompressed_old, decompressed_new;
+          data data_old, data_new;
           vector<string> old_lines, new_lines;
           
           app.db.get_file_version(delta_entry_src(i), f_old);
-          decode_base64(f_old.inner(), decoded_old);
-          decode_gzip(decoded_old, decompressed_old);
+          data_old = f_old.inner();
           
           if (new_is_archived)
             {
               file_data f_new;
-              gzip<data> decoded_new;
               app.db.get_file_version(delta_entry_dst(i), f_new);
-              decode_base64(f_new.inner(), decoded_new);
-              decode_gzip(decoded_new, decompressed_new);
+              data_new = f_new.inner();
             }
           else
             {
               read_localized_data(delta_entry_path(i), 
-                                  decompressed_new, app.lua);
+                                  data_new, app.lua);
             }
 
-          if (guess_binary(decompressed_new()) || 
-              guess_binary(decompressed_old()))
+          if (guess_binary(data_new()) || 
+              guess_binary(data_old()))
             cout << "# " << delta_entry_path(i) << " is binary\n";
           else
             {
-              split_into_lines(decompressed_old(), old_lines);
-              split_into_lines(decompressed_new(), new_lines);
+              split_into_lines(data_old(), old_lines);
+              split_into_lines(data_new(), new_lines);
               make_diff(delta_entry_path(i)(), 
                         delta_entry_path(i)(), 
                         old_lines, new_lines,
@@ -3311,7 +3291,7 @@
     apply_change_set(anc_man, *anc_to_left, tmp);
     apply_change_set(tmp, *left_to_merged, merged_man);
     calculate_ident(merged_man, merged_rev.new_manifest);
-    base64< gzip<delta> > left_mdelta, right_mdelta;
+    delta left_mdelta, right_mdelta;
     diff(left_man, merged_man, left_mdelta);
     diff(right_man, merged_man, right_mdelta);
     if (left_mdelta().size() < right_mdelta().size())
--- database.cc
+++ database.cc
@@ -858,7 +858,7 @@
 
 void 
 database::get(hexenc<id> const & ident,
-              base64< gzip<data> > & dat,
+              data & dat,
               string const & table)
 {
   results res;
@@ -868,17 +868,20 @@
 
   // consistency check
   base64<gzip<data> > rdata(res[0][0]);
+  data rdata_unpacked;
+  unpack(rdata, rdata_unpacked);
+
   hexenc<id> tid;
-  calculate_ident(rdata, tid);
+  calculate_ident(rdata_unpacked, tid);
   I(tid == ident);
 
-  dat = rdata;
+  dat = rdata_unpacked;
 }
 
 void 
 database::get_delta(hexenc<id> const & ident,
                     hexenc<id> const & base,
-                    base64< gzip<delta> > & del,
+                    delta & del,
                     string const & table)
 {
   I(ident() != "");
@@ -887,12 +890,14 @@
   fetch(res, one_col, one_row,
         "SELECT delta FROM '%q' WHERE id = '%q' AND base = '%q'", 
         table.c_str(), ident().c_str(), base().c_str());
-  del = res[0][0];
+
+  base64<gzip<delta> > del_packed = res[0][0];
+  unpack(del_packed, del);
 }
 
 void 
 database::put(hexenc<id> const & ident,
-              base64< gzip<data> > const & dat,
+              data const & dat,
               string const & table)
 {
   // consistency check
@@ -900,22 +905,29 @@
   hexenc<id> tid;
   calculate_ident(dat, tid);
   I(tid == ident);
+
+  base64<gzip<data> > dat_packed;
+  pack(dat, dat_packed);
   
   execute("INSERT INTO '%q' VALUES('%q', '%q')", 
-          table.c_str(), ident().c_str(), dat().c_str());
+          table.c_str(), ident().c_str(), dat_packed().c_str());
 }
 void 
 database::put_delta(hexenc<id> const & ident,
                     hexenc<id> const & base,
-                    base64<gzip<delta> > const & del,
+                    delta const & del,
                     string const & table)
 {
   // nb: delta schema is (id, base, delta)
   I(ident() != "");
   I(base() != "");
+
+  base64<gzip<delta> > del_packed;
+  pack(del, del_packed);
+  
   execute("INSERT INTO '%q' VALUES('%q', '%q', '%q')", 
           table.c_str(), 
-          ident().c_str(), base().c_str(), del().c_str());
+          ident().c_str(), base().c_str(), del_packed().c_str());
 }
 
 // static ticker cache_hits("vcache hits", "h", 1);
@@ -924,22 +936,21 @@
 {
   size_t capacity;
   size_t use;
-  std::map<hexenc<id>, base64< gzip<data> > > cache;  
+  std::map<hexenc<id>, data> cache;  
 
   version_cache() : capacity(constants::db_version_cache_sz), use(0) 
   {
     srand(time(NULL));
   }
 
-  void put(hexenc<id> const & ident,
-           base64< gzip<data> > const & dat)
+  void put(hexenc<id> const & ident, data const & dat)
   {
     while (!cache.empty() 
            && use + dat().size() > capacity)
       {      
         std::string key = (F("%08.8x%08.8x%08.8x%08.8x%08.8x") 
                            % rand() % rand() % rand() % rand() % rand()).str();
-        std::map<hexenc<id>, base64< gzip<data> > >::const_iterator i;
+        std::map<hexenc<id>, data>::const_iterator i;
         i = cache.lower_bound(hexenc<id>(key));
         if (i == cache.end())
           {
@@ -959,15 +970,14 @@
 
   bool exists(hexenc<id> const & ident)
   {
-    std::map<hexenc<id>, base64< gzip<data> > >::const_iterator i;
+    std::map<hexenc<id>, data>::const_iterator i;
     i = cache.find(ident);
     return i != cache.end();
   }
 
-  bool get(hexenc<id> const & ident,
-           base64< gzip<data> > & dat)
+  bool get(hexenc<id> const & ident, data & dat)
   {
-    std::map<hexenc<id>, base64< gzip<data> > >::const_iterator i;
+    std::map<hexenc<id>, data>::const_iterator i;
     i = cache.find(ident);
     if (i == cache.end())
       return false;
@@ -982,7 +992,7 @@
 
 void 
 database::get_version(hexenc<id> const & ident,
-                      base64< gzip<data> > & dat,
+                      data & dat,
                       string const & data_table,
                       string const & delta_table)
 {
@@ -1086,17 +1096,17 @@
 
       I(found_root);
       I(root() != "");
-      base64< gzip<data> > begin_packed;
       data begin;      
 
       if (vcache.exists(root))
         {
-          I(vcache.get(root, begin_packed));
+          I(vcache.get(root, begin));
         }
       else
-        get(root, begin_packed, data_table);
+        {
+          get(root, begin, data_table);
+        }
 
-      unpack(begin_packed, begin);
       hexenc<id> curr = root;
 
       boost::shared_ptr<delta_applicator> app = new_piecewise_applicator();
@@ -1112,18 +1122,14 @@
           if (!vcache.exists(curr))
             {
               string tmp;
-              base64< gzip<data> > tmp_packed;
               app->finish(tmp);
-              pack(data(tmp), tmp_packed);
-              vcache.put(curr, tmp_packed);
+              vcache.put(curr, tmp);
             }
 
 
           L(F("following delta %s -> %s\n") % curr % nxt);
-          base64< gzip<delta> > del_packed;
-          get_delta(nxt, curr, del_packed, delta_table);
           delta del;
-          unpack(del_packed, del);
+          get_delta(nxt, curr, del, delta_table);
           apply_delta (app, del());
           
           app->next();
@@ -1132,12 +1138,11 @@
 
       string tmp;
       app->finish(tmp);
-      data end(tmp);
+      dat = data(tmp);
 
       hexenc<id> final;
-      calculate_ident(end, final);
+      calculate_ident(dat, final);
       I(final == ident);
-      pack(end, dat);
     }
   vcache.put(ident, dat);
 }
@@ -1155,13 +1160,13 @@
 void 
 database::put_version(hexenc<id> const & old_id,
                       hexenc<id> const & new_id,
-                      base64< gzip<delta> > const & del,
+                      delta const & del,
                       string const & data_table,
                       string const & delta_table)
 {
 
-  base64< gzip<data> > old_data, new_data;
-  base64< gzip<delta> > reverse_delta;
+  data old_data, new_data;
+  delta reverse_delta;
   
   get_version(old_id, old_data, data_table, delta_table);
   patch(old_data, del, new_data);
@@ -1182,11 +1187,11 @@
 void 
 database::put_reverse_version(hexenc<id> const & new_id,
                               hexenc<id> const & old_id,
-                              base64< gzip<delta> > const & reverse_del,
+                              delta const & reverse_del,
                               string const & data_table,
                               string const & delta_table)
 {
-  base64< gzip<data> > old_data, new_data;
+  data old_data, new_data;
   
   get_version(new_id, new_data, data_table, delta_table);
   patch(new_data, reverse_del, old_data);
@@ -1260,7 +1265,7 @@
 database::get_file_version(file_id const & id,
                            file_data & dat)
 {
-  base64< gzip<data> > tmp;
+  data tmp;
   get_version(id.inner(), tmp, "files", "file_deltas");
   dat = tmp;
 }
@@ -1269,7 +1274,7 @@
 database::get_manifest_version(manifest_id const & id,
                                manifest_data & dat)
 {
-  base64< gzip<data> > tmp;
+  data tmp;
   get_version(id.inner(), tmp, "manifests", "manifest_deltas");
   dat = tmp;
 }
@@ -1404,14 +1409,19 @@
         "SELECT data FROM revisions WHERE id = '%q'",
         id.inner()().c_str());
 
-  dat = revision_data(res[0][0]);
+  base64<gzip<data> > rdat_packed;
+  rdat_packed = base64<gzip<data> >(res[0][0]);
+  data rdat;
+  unpack(rdat_packed, rdat);
 
   // verify that we got a revision with the right id
   {
     revision_id tmp;
-    calculate_ident(dat, tmp);
+    calculate_ident(rdat, tmp);
     I(id == tmp);
   }
+
+  dat = rdat;
 }
 
 void 
@@ -1430,11 +1440,14 @@
   calculate_ident(d, tmp);
   I(tmp == new_id);
 
+  base64<gzip<data> > d_packed;
+  pack(d.inner(), d_packed);
+
   transaction_guard guard(*this);
 
   execute("INSERT INTO revisions VALUES('%q', '%q')", 
           new_id.inner()().c_str(), 
-          d.inner()().c_str());
+          d_packed().c_str());
 
   for (edge_map::const_iterator e = rev.edges.begin();
        e != rev.edges.end(); ++e)
--- database.hh
+++ database.hh
@@ -102,34 +102,34 @@
   void get_ids(std::string const & table, std::set< hexenc<id> > & ids); 
 
   void get(hexenc<id> const & new_id,
-           base64< gzip<data> > & dat,
+           data & dat,
            std::string const & table);
   void get_delta(hexenc<id> const & ident,
                  hexenc<id> const & base,
-                 base64< gzip<delta> > & del,
+                 delta & del,
                  std::string const & table);
   void get_version(hexenc<id> const & id,
-                   base64< gzip<data> > & dat,
+                   data & dat,
                    std::string const & data_table,
                    std::string const & delta_table);
   
   void put(hexenc<id> const & new_id,
-           base64< gzip<data> > const & dat,
+           data const & dat,
            std::string const & table);
   void drop(hexenc<id> const & base,
             std::string const & table);
   void put_delta(hexenc<id> const & id,
                  hexenc<id> const & base,
-                 base64< gzip<delta> > const & del,
+                 delta const & del,
                  std::string const & table);
   void put_version(hexenc<id> const & old_id,
                    hexenc<id> const & new_id,
-                   base64< gzip<delta> > const & del,
+                   delta const & del,
                    std::string const & data_table,
                    std::string const & delta_table);
   void put_reverse_version(hexenc<id> const & new_id,
                            hexenc<id> const & old_id,
-                           base64< gzip<delta> > const & reverse_del,
+                           delta const & reverse_del,
                            std::string const & data_table,
                            std::string const & delta_table);
 
@@ -174,11 +174,11 @@
   friend class transaction_guard;
   friend void rcs_put_raw_file_edge(hexenc<id> const & old_id,
                                     hexenc<id> const & new_id,
-                                    base64< gzip<delta> > const & del,
+                                    delta const & del,
                                     database & db);
   friend void rcs_put_raw_manifest_edge(hexenc<id> const & old_id,
                                         hexenc<id> const & new_id,
-                                        base64< gzip<delta> > const & del,
+                                        delta const & del,
                                         database & db);
 
 public:
--- database_check.cc
+++ database_check.cc
@@ -105,8 +105,6 @@
        i != files.end(); ++i) 
     {
       L(F("checking file %s\n") % *i);
-      file_data data;
-      app.db.get_file_version(*i, data);
       checked_files[*i].found = true;
       ++ticks;
     }
@@ -130,22 +128,8 @@
        i != manifests.end(); ++i) 
     {
       L(F("checking manifest %s\n") % *i);
-      manifest_data data;
-      app.db.get_manifest_version(*i, data);
       checked_manifests[*i].found = true;
 
-      manifest_map man;
-      read_manifest_map(data, man);
-
-      for (manifest_map::const_iterator entry = man.begin(); entry != man.end();
-           ++entry)
-        {
-          checked_files[manifest_entry_id(entry)].manifest_refs++;
-
-          if (!checked_files[manifest_entry_id(entry)].found)
-            checked_manifests[*i].missing_files++;
-        }
-
       ++ticks;
     }
 
@@ -168,50 +152,7 @@
        i != revisions.end(); ++i) 
     {
       L(F("checking revision %s\n") % *i);
-      revision_data data;
-      app.db.get_revision(*i, data);
       checked_revisions[*i].found = true;
-
-      revision_set rev;
-      read_revision_set(data, rev);
-
-      checked_manifests[rev.new_manifest].revision_refs++;
-
-      if (!checked_manifests[rev.new_manifest].found) 
-        checked_revisions[*i].missing_manifests++;
-
-      if (checked_manifests[rev.new_manifest].missing_files > 0) 
-        checked_revisions[*i].incomplete_manifests++;
-
-      for (edge_map::const_iterator edge = rev.edges.begin(); 
-           edge != rev.edges.end(); ++edge)
-        {
-          // ignore [] -> [...] manifests
-
-          if (!null_id(edge_old_manifest(edge)))
-            {
-              checked_manifests[edge_old_manifest(edge)].revision_refs++;
-
-              if (!checked_manifests[edge_old_manifest(edge)].found)
-                checked_revisions[*i].missing_manifests++;
-
-              if (checked_manifests[edge_old_manifest(edge)].missing_files > 0)
-                checked_revisions[*i].incomplete_manifests++;
-            }
-            
-          // ignore [] -> [...] revisions
-
-          // delay checking parents until we've processed all revisions
-          if (!null_id(edge_old_revision(edge))) 
-            {
-              checked_revisions[edge_old_revision(edge)].revision_refs++;
-              checked_revisions[*i].parents.insert(edge_old_revision(edge));
-            }
-
-          // also check that change_sets applied to old manifests == new
-          // manifests (which might be a merge)
-        }
-      
       ++ticks;
     }
 
--- diff_patch.cc
+++ diff_patch.cc
@@ -484,7 +484,7 @@
   L(F("recording successful merge of %s <-> %s into %s\n")
     % left_ident % right_ident % merged_ident);
 
-  base64< gzip<delta> > merge_delta;
+  delta merge_delta;
   transaction_guard guard(app.db);
 
   diff(left_data.inner(), merged_data.inner(), merge_delta);  
@@ -548,9 +548,9 @@
   anc_encoding = this->get_file_encoding(anc_path, anc_man);
   right_encoding = this->get_file_encoding(right_path, right_man);
     
-  unpack(left_data.inner(), left_unpacked);
-  unpack(ancestor_data.inner(), ancestor_unpacked);
-  unpack(right_data.inner(), right_unpacked);
+  left_unpacked = left_data.inner();
+  ancestor_unpacked = ancestor_data.inner();
+  right_unpacked = right_data.inner();
 
   split_into_lines(left_unpacked(), left_encoding, left_lines);
   split_into_lines(ancestor_unpacked(), anc_encoding, ancestor_lines);
@@ -562,18 +562,18 @@
              merged_lines))
     {
       hexenc<id> tmp_id;
-      base64< gzip<data> > packed_merge;
+      file_data merge_data;
       string tmp;
       
       L(F("internal 3-way merged ok\n"));
       join_lines(merged_lines, tmp);
       calculate_ident(data(tmp), tmp_id);
       file_id merged_fid(tmp_id);
-      pack(data(tmp), packed_merge);
+      merge_data = file_data(tmp);
 
       merged_id = merged_fid;
       record_merge(left_id, right_id, merged_fid, 
-                   left_data, packed_merge);
+                   left_data, merge_data);
 
       return true;
     }
@@ -589,16 +589,16 @@
                           right_unpacked, merged_unpacked))
     {
       hexenc<id> tmp_id;
-      base64< gzip<data> > packed_merge;
+      file_data merge_data;
 
       L(F("lua merge3 hook merged ok\n"));
       calculate_ident(merged_unpacked, tmp_id);
       file_id merged_fid(tmp_id);
-      pack(merged_unpacked, packed_merge);
+      merge_data = file_data(merged_unpacked);
 
       merged_id = merged_fid;
       record_merge(left_id, right_id, merged_fid, 
-                   left_data, packed_merge);
+                   left_data, merge_data);
       return true;
     }
 
@@ -631,8 +631,8 @@
   this->get_version(left_path, left_id, left_data);
   this->get_version(right_path, right_id, right_data);
     
-  unpack(left_data.inner(), left_unpacked);
-  unpack(right_data.inner(), right_unpacked);
+  left_unpacked = left_data.inner();
+  right_unpacked = right_data.inner();
 
   P(F("help required for 2-way merge\n"));
   P(F("[    left] %s\n") % left_path);
@@ -643,16 +643,16 @@
                           left_unpacked, right_unpacked, merged_unpacked))
     {
       hexenc<id> tmp_id;
-      base64< gzip<data> > packed_merge;
+      file_data merge_data;
       
       L(F("lua merge2 hook merged ok\n"));
       calculate_ident(merged_unpacked, tmp_id);
       file_id merged_fid(tmp_id);
-      pack(merged_unpacked, packed_merge);
+      merge_data = file_data(merged_unpacked);
       
       merged_id = merged_fid;
       record_merge(left_id, right_id, merged_fid, 
-                   left_data, packed_merge);
+                   left_data, merge_data);
       return true;
     }
   
@@ -690,7 +690,7 @@
     app.db.get_file_version(ident, dat);
   else
     {
-      base64< gzip<data> > tmp;
+      data tmp;
       file_id fid;
       N(file_exists (path),
         F("file %s does not exist in working copy") % path);
--- manifest.cc
+++ manifest.cc
@@ -140,11 +140,7 @@
 read_manifest_map(manifest_data const & dat,
                   manifest_map & man)
 {  
-  gzip<data> decoded;
-  data decompressed;
-  decode_base64(dat.inner(), decoded);
-  decode_gzip(decoded, decompressed);
-  read_manifest_map(decompressed, man);
+  read_manifest_map(dat.inner(), man);
 }
 
 
@@ -167,14 +163,7 @@
        man.end(),
        ostream_iterator<manifest_entry>(sstr));
 
-  data raw;
-  gzip<data> compressed;
-  base64< gzip<data> > encoded;
-
-  raw = sstr.str();
-  encode_gzip(raw, compressed);
-  encode_base64(compressed, encoded);
-  dat = manifest_data(encoded);
+  dat = manifest_data(sstr.str());
 }
 
 void 
--- netsync.cc
+++ netsync.cc
@@ -1847,8 +1847,7 @@
           revision_data mdat;
           data dat;
           app.db.get_revision(revision_id(hitem), mdat);
-          unpack(mdat.inner(), dat);
-          out = dat();
+          out = mdat.inner()();
         }
       else
         {
@@ -1862,8 +1861,7 @@
           manifest_data mdat;
           data dat;
           app.db.get_manifest_version(manifest_id(hitem), mdat);
-          unpack(mdat.inner(), dat);
-          out = dat();
+          out = mdat.inner()();
         }
       else
         {
@@ -1877,8 +1875,7 @@
           file_data fdat;
           data dat;
           app.db.get_file_version(file_id(hitem), fdat);
-          unpack(fdat.inner(), dat);
-          out = dat();
+          out = fdat.inner()();
         }
       else
         {
@@ -2343,8 +2340,8 @@
             this->app.db.get_file_version(fbase, base_fdat);
             this->app.db.get_file_version(fident, ident_fdat);      
             string tmp;     
-            unpack(base_fdat.inner(), base_dat);
-            unpack(ident_fdat.inner(), ident_dat);
+            base_dat = base_fdat.inner();
+            ident_dat = ident_fdat.inner();
             compute_delta(base_dat(), ident_dat(), tmp);
             del = delta(tmp);
           }
@@ -2367,8 +2364,8 @@
             this->app.db.get_manifest_version(mbase, base_mdat);
             this->app.db.get_manifest_version(mident, ident_mdat);
             string tmp;
-            unpack(base_mdat.inner(), base_dat);
-            unpack(ident_mdat.inner(), ident_dat);
+            base_dat = base_mdat.inner();
+            ident_dat = ident_mdat.inner();
             compute_delta(base_dat(), ident_dat(), tmp);
             del = delta(tmp);
           }
@@ -2493,9 +2490,7 @@
             boost::shared_ptr< pair<revision_data, revision_set > > 
               rp(new pair<revision_data, revision_set>());
             
-            base64< gzip<data> > packed;
-            pack(data(dat), packed);
-            rp->first = revision_data(packed);
+            rp->first = revision_data(dat);
             read_revision_set(dat, rp->second);
             ancestry.insert(std::make_pair(rid, rp));
             if (cert_refinement_done())
@@ -2513,9 +2508,7 @@
           L(F("manifest version '%s' already exists in our database\n") % hitem);
         else
           {
-            base64< gzip<data> > packed_dat;
-            pack(data(dat), packed_dat);
-            this->dbw.consume_manifest_data(mid, manifest_data(packed_dat));
+            this->dbw.consume_manifest_data(mid, manifest_data(dat));
             manifest_map man;
             read_manifest_map(data(dat), man);
             analyze_manifest(man);
@@ -2530,9 +2523,7 @@
           L(F("file version '%s' already exists in our database\n") % hitem);
         else
           {
-            base64< gzip<data> > packed_dat;
-            pack(data(dat), packed_dat);
-            this->dbw.consume_file_data(fid, file_data(packed_dat));
+            this->dbw.consume_file_data(fid, file_data(dat));
           }
       }
       break;
@@ -2566,20 +2557,18 @@
     case manifest_item:
       {
         manifest_id src_manifest(hbase), dst_manifest(hident);
-        base64< gzip<delta> > packed_del;
-        pack(del, packed_del);
         if (reverse_delta_requests.find(id_pair)
             != reverse_delta_requests.end())
           {
             reverse_delta_requests.erase(id_pair);
             this->dbw.consume_manifest_reverse_delta(src_manifest, 
                                                      dst_manifest,
-                                                     manifest_delta(packed_del));
+                                                     manifest_delta(del));
           }
         else
           this->dbw.consume_manifest_delta(src_manifest, 
                                            dst_manifest,
-                                           manifest_delta(packed_del));
+                                           manifest_delta(del));
         
       }
       break;
@@ -2587,20 +2576,18 @@
     case file_item:
       {
         file_id src_file(hbase), dst_file(hident);
-        base64< gzip<delta> > packed_del;
-        pack(del, packed_del);
         if (reverse_delta_requests.find(id_pair)
             != reverse_delta_requests.end())
           {
             reverse_delta_requests.erase(id_pair);
             this->dbw.consume_file_reverse_delta(src_file, 
                                                  dst_file,
-                                                 file_delta(packed_del));
+                                                 file_delta(del));
           }
         else
           this->dbw.consume_file_delta(src_file, 
                                        dst_file,
-                                       file_delta(packed_del));
+                                       file_delta(del));
       }
       break;
       
--- packet.cc
+++ packet.cc
@@ -601,7 +601,7 @@
         {
           file_id confirm;
           file_data old_dat;
-          base64< gzip<data> > new_dat;
+          data new_dat;
           pimpl->app.db.get_file_version(old_id, old_dat);
           patch(old_dat.inner(), del.inner(), new_dat);
           calculate_ident(file_data(new_dat), confirm);
@@ -645,7 +645,7 @@
         {
           file_id confirm;
           file_data new_dat;
-          base64< gzip<data> > old_dat;
+          data old_dat;
           pimpl->app.db.get_file_version(new_id, new_dat);
           patch(new_dat.inner(), del.inner(), old_dat);
           calculate_ident(file_data(old_dat), confirm);
@@ -706,7 +706,7 @@
         {
           manifest_id confirm;
           manifest_data old_dat;
-          base64< gzip<data> > new_dat;
+          data new_dat;
           pimpl->app.db.get_manifest_version(old_id, old_dat);
           patch(old_dat.inner(), del.inner(), new_dat);
           calculate_ident(manifest_data(new_dat), confirm);
@@ -750,7 +750,7 @@
         {
           manifest_id confirm;
           manifest_data new_dat;
-          base64< gzip<data> > old_dat;
+          data old_dat;
           pimpl->app.db.get_manifest_version(new_id, new_dat);
           patch(new_dat.inner(), del.inner(), old_dat);
           calculate_ident(manifest_data(old_dat), confirm);
@@ -1359,20 +1359,16 @@
     packet_writer pw(oss);
 
     // an fdata packet
-    base64< gzip<data> > gzdata;
-    pack(data("this is some file data"), gzdata);
-    file_data fdata(gzdata);
+    file_data fdata("this is some file data");
     file_id fid;
     calculate_ident(fdata, fid);
     pw.consume_file_data(fid, fdata);
 
     // an fdelta packet    
-    base64< gzip<data> > gzdata2;
-    pack(data("this is some file data which is not the same as the first one"), gzdata2);
-    file_data fdata2(gzdata2);
+    file_data fdata2("this is some file data which is not the same as the first one");
     file_id fid2;
     calculate_ident(fdata2, fid);
-    base64< gzip<delta> > del;
+    delta del;
     diff(fdata.inner(), fdata2.inner(), del);
     pw.consume_file_delta(fid, fid2, file_delta(del));
 
@@ -1408,7 +1404,7 @@
                          file_id(hexenc<id>("54f373ed07b4c5a88eaa93370e1bbac02dc432a8"))));
     write_manifest_map(mm2, mdata2);
     calculate_ident(mdata2, mid2);
-    base64< gzip<delta> > del2;
+    delta del2;
     diff(mdata.inner(), mdata2.inner(), del2);
     pw.consume_manifest_delta(mid, mid2, manifest_delta(del));
     
--- rcs_import.cc
+++ rcs_import.cc
@@ -393,7 +393,7 @@
 void 
 rcs_put_raw_file_edge(hexenc<id> const & old_id,
                       hexenc<id> const & new_id,
-                      base64< gzip<delta> > const & del,
+                      delta const & del,
                       database & db)
 {
   if (old_id == new_id)
@@ -419,7 +419,7 @@
 void 
 rcs_put_raw_manifest_edge(hexenc<id> const & old_id,
                           hexenc<id> const & new_id,
-                          base64< gzip<delta> > const & del,
+                          delta const & del,
                           database & db)
 {
   if (old_id == new_id)
@@ -458,7 +458,7 @@
     global_pieces.build_string(next_lines, tmp);
     next_data = tmp;
   }
-  base64< gzip<delta> > del;
+  delta del;
   diff(curr_data, next_data, del);
   calculate_ident(next_data, next_id);
   rcs_put_raw_file_edge(next_id, curr_id, del, db);
@@ -571,7 +571,6 @@
     I(r.deltas.find(r.admin.head) != r.deltas.end());
 
     hexenc<id> id; 
-    base64< gzip<data> > packed;
     data dat(r.deltatexts.find(r.admin.head)->second->text);
     calculate_ident(dat, id);
     file_id fid = id;
@@ -580,9 +579,7 @@
 
     if (! db.file_version_exists (fid))
       {
-        pack(dat, packed);
-        file_data fdat = packed;
-        db.put_file(fid, fdat); 
+        db.put_file(fid, dat); 
       }
         
     {
@@ -1083,7 +1080,7 @@
       // tree version, which can be constructed from the 'newer' child. so
       // the delta should run from child (new) -> parent (old).
       
-      base64< gzip<delta> > del;              
+      delta del;
       diff(child, parent, del);
       rcs_put_raw_manifest_edge(parent_mid.inner(),
                                 child_mid.inner(),
@@ -1102,7 +1099,7 @@
       // from temporally new -> temporally old. so the delta should go from
       // parent (new) -> child (old)
       
-      base64< gzip<delta> > del;              
+      delta del;
       diff(parent, child, del);
       rcs_put_raw_manifest_edge(child_mid.inner(),
                                 parent_mid.inner(),                             
--- revision.cc
+++ revision.cc
@@ -1699,9 +1699,7 @@
 read_revision_set(revision_data const & dat,
                   revision_set & rev)
 {
-  data unpacked;
-  unpack(dat.inner(), unpacked);
-  read_revision_set(unpacked, rev);
+  read_revision_set(dat.inner(), rev);
   rev.check_sane();
 }
 
@@ -1723,9 +1721,7 @@
   rev.check_sane();
   data d;
   write_revision_set(rev, d);
-  base64< gzip<data> > packed;
-  pack(d, packed);
-  dat = revision_data(packed);
+  dat = revision_data(d);
 }
 
 #ifdef BUILD_UNIT_TESTS
--- transforms.cc
+++ transforms.cc
@@ -123,69 +123,33 @@
 void 
 diff(data const & olddata,
      data const & newdata,
-     base64< gzip<delta> > & del)
+     delta & del)
 {
   string unpacked;
   compute_delta(olddata(), newdata(), unpacked);
-  pack(delta(unpacked), del);
+  del = delta(unpacked);
 }
 
 void 
 patch(data const & olddata,
-      base64< gzip<delta> > const & del,
+      delta const & del,
       data & newdata)
 {
-  delta unpacked;
-  unpack(del, unpacked);
   string result;
-  apply_delta(olddata(), unpacked(), result);
+  apply_delta(olddata(), del(), result);
   newdata = result;
 }
 
 void 
 diff(manifest_map const & oldman,
      manifest_map const & newman,
-     base64< gzip<delta> > & del)
+     delta & del)
 {
   string xd;
   compute_delta(oldman, newman, xd);
-  pack(delta(xd), del);
+  del = delta(xd);
 }
 
-void 
-diff(base64< gzip<data> > const & olddata,
-     base64< gzip<data> > const & newdata,
-     base64< gzip<delta> > & del)
-{
-  gzip<data> olddata_decoded;
-  gzip<data> newdata_decoded;
-
-  decode_base64(olddata, olddata_decoded);
-  decode_base64(newdata, newdata_decoded);
-
-  data olddata_decompressed;
-  data newdata_decompressed;
-
-  decode_gzip(olddata_decoded, olddata_decompressed);
-  decode_gzip(newdata_decoded, newdata_decompressed);
-
-  diff(olddata_decompressed,
-       newdata_decompressed,
-       del);
-}
-
-void 
-patch(base64< gzip<data> > const & olddata,
-      base64< gzip<delta> > const & del,
-      base64< gzip<data> > & newdata)
-{
-  data olddata_unpacked, newdata_unpacked;
-  unpack(olddata, olddata_unpacked);
-  patch(olddata_unpacked, del, newdata_unpacked);
-  pack(newdata_unpacked, newdata);
-}
-
-
 // identifier (a.k.a. sha1 signature) calculation
 
 void 
@@ -286,9 +250,7 @@
                      revision_id & ident)
 {
   hexenc<id> tmp;
-  data unpacked;
-  unpack(dat.inner(), unpacked);
-  calculate_ident(unpacked, tmp);
+  calculate_ident(dat.inner(), tmp);
   ident = tmp;
 }
 
--- transforms.hh
+++ transforms.hh
@@ -94,23 +94,16 @@
 
 void diff(data const & olddata,
           data const & newdata,
-          base64< gzip<delta> > & del);
+          delta & del);
 
 void diff(manifest_map const & oldman,
           manifest_map const & newman,
-          base64< gzip<delta> > & del);
+          delta & del);
 
-void diff(base64< gzip<data> > const & old_data,
-          base64< gzip<data> > const & new_data,
-          base64< gzip<delta> > & delta);
-
 void patch(data const & olddata,
-           base64< gzip<delta> > const & del,
+           delta const & del,
            data & newdata);
 
-void patch(base64< gzip<data> > const & old_data,
-           base64< gzip<delta> > const & delta,
-           base64< gzip<data> > & new_data);
 
 // version (a.k.a. sha1 fingerprint) calculation
 
--- vocab.hh
+++ vocab.hh
@@ -115,12 +115,12 @@
 typedef    epoch< hexenc<id> >     epoch_id;
 typedef    epoch< hexenc<data> > epoch_data;
 
-typedef revision< base64< gzip<data> > >   revision_data;
-typedef manifest< base64< gzip<data> > >   manifest_data;
-typedef     file< base64< gzip<data> > >       file_data;
+typedef revision< data >   revision_data;
+typedef manifest< data >   manifest_data;
+typedef     file< data >       file_data;
 
-typedef manifest< base64< gzip<delta> > >  manifest_delta;
-typedef     file< base64< gzip<delta> > >      file_delta;
+typedef manifest< delta >  manifest_delta;
+typedef     file< delta >      file_delta;
 
 typedef std::pair<var_domain, var_name> var_key;
 
--- vocab_terms.hh
+++ vocab_terms.hh
@@ -63,15 +63,22 @@
 
 EXTERN template class                   gzip<data>;
 EXTERN template class           base64< gzip<data> >;
-EXTERN template class revision< base64< gzip<data> > >;
-EXTERN template class manifest< base64< gzip<data> > >;
-EXTERN template class     file< base64< gzip<data> > >;
+//EXTERN template class revision< base64< gzip<data> > >;
+//EXTERN template class manifest< base64< gzip<data> > >;
+//EXTERN template class     file< base64< gzip<data> > >;
 
+EXTERN template class revision< data >;
+EXTERN template class manifest< data >;
+EXTERN template class     file< data >;
+
 EXTERN template class                   gzip<delta>;
 EXTERN template class           base64< gzip<delta> >;
-EXTERN template class manifest< base64< gzip<delta> > >;
-EXTERN template class     file< base64< gzip<delta> > >;
+//EXTERN template class manifest< base64< gzip<delta> > >;
+//EXTERN template class     file< base64< gzip<delta> > >;
 
+EXTERN template class manifest< delta >;
+EXTERN template class     file< delta >;
+
 EXTERN template class         arc4<rsa_priv_key>;
 EXTERN template class base64< arc4<rsa_priv_key> >;
 EXTERN template class base64< rsa_pub_key >;