diff --git a/treemanifest/__init__.py b/treemanifest/__init__.py
--- a/treemanifest/__init__.py
+++ b/treemanifest/__init__.py
@@ -508,62 +508,9 @@
     def read(self):
         return self._treemanifest
 
-    def write(self, transaction, link, p1, p2, added, removed):
-        if not util.safehasattr(transaction, 'treedatapack'):
-            mfl = self._manifestlog
-            opener = mfl._opener
-            ui = self._manifestlog.ui
-            packpath = shallowutil.getlocalpackpath(
-                    opener.vfs.base,
-                    'manifests')
-            transaction.treedatapack = mutabledatapack(
-                    ui,
-                    packpath)
-            transaction.treehistpack = mutablehistorypack(
-                    ui,
-                    packpath)
-            def finalize(tr):
-                tr.treedatapack.close()
-                tr.treehistpack.close()
-                mfl.datastore.markforrefresh()
-            def abort(tr):
-                tr.treedatapack.abort()
-                tr.treehistpack.abort()
-            def writepending(tr):
-                finalize(tr)
-                transaction.treedatapack = mutabledatapack(
-                        ui,
-                        packpath)
-                transaction.treehistpack = mutablehistorypack(
-                        ui,
-                        packpath)
-                # re-register to write pending changes so that a series
-                # of writes are correctly flushed to the store.  This
-                # happens during amend.
-                tr.addpending('treepack', writepending)
-            transaction.addfinalize('treepack', finalize)
-            transaction.addabort('treepack', abort)
-            transaction.addpending('treepack', writepending)
-
-        dpack = transaction.treedatapack
-        hpack = transaction.treehistpack
-
-        newtree = self._treemanifest
-        p1tree = self._manifestlog[p1].read()
-        newtreeiter = newtree.finalize(p1tree)
-
-        node = None
-        for nname, nnode, ntext, np1text, np1, np2 in newtreeiter:
-            # Not using deltas, since there aren't any other trees in
-            # this pack it could delta against.
-            dpack.add(nname, nnode, revlog.nullid, ntext)
-            hpack.add(nname, nnode, np1, np2, revlog.nullid, '')
-            if nname == "":
-                node = nnode
-
-        if node is not None:
-            self._manifestlog.addmemtree(node, newtree, p1, p2)
-        return node
+    def write(self, tr, link, p1, p2, added, removed):
+        return _writeclientmanifest(
+            self._treemanifest, tr, self._manifestlog, p1, p2)
 
 def serverreposetup(repo):
     extensions.wrapfunction(manifest.manifestrevlog, 'addgroup',
@@ -652,6 +599,56 @@
 
     return n
 
+def _writeclientmanifest(newtree, tr, tmfl, p1node, p2node):
+    if not util.safehasattr(tr, 'treedatapack'):
+        opener = tmfl._opener
+        ui = tmfl.ui
+        packpath = shallowutil.getlocalpackpath(opener.vfs.base, 'manifests')
+        tr.treedatapack = mutabledatapack(ui, packpath)
+        tr.treehistpack = mutablehistorypack(ui, packpath)
+
+        def finalize(tr):
+            tr.treedatapack.close()
+            tr.treehistpack.close()
+            tmfl.datastore.markforrefresh()
+
+        def abort(tr):
+            tr.treedatapack.abort()
+            tr.treehistpack.abort()
+
+        def writepending(tr):
+            finalize(tr)
+            tr.treedatapack = mutabledatapack(ui, packpath)
+            tr.treehistpack = mutablehistorypack(ui, packpath)
+
+            # re-register to write pending changes so that a series
+            # of writes are correctly flushed to the store.  This
+            # happens during amend.
+            tr.addpending('treepack', writepending)
+
+        tr.addfinalize('treepack', finalize)
+        tr.addabort('treepack', abort)
+        tr.addpending('treepack', writepending)
+
+    dpack = tr.treedatapack
+    hpack = tr.treehistpack
+
+    p1tree = tmfl[p1node].read()
+    newtreeiter = newtree.finalize(p1tree)
+
+    node = None
+    for nname, nnode, ntext, np1text, np1, np2 in newtreeiter:
+        # Not using deltas, since there aren't any other trees in
+        # this pack it could delta against.
+        dpack.add(nname, nnode, revlog.nullid, ntext)
+        hpack.add(nname, nnode, np1, np2, revlog.nullid, '')
+        if nname == "":
+            node = nnode
+
+    if node is not None:
+        tmfl.addmemtree(node, newtree, p1node, p2node)
+    return node
+
 @command('debuggentrees', [
     ('s', 'skip-allowed-roots', None,
      _('skips the check for only generating on allowed roots')),