pushwork 2.0.0-preview → 2.0.0-preview.3

package/dist/pushwork.js

@@ -33,43 +33,34 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteBranchFile = void 0;
 exports.init = init;
 exports.clone = clone;
 exports.url = url;
 exports.sync = sync;
+exports.nuclearizeRepo = nuclearizeRepo;
 exports.save = save;
 exports.status = status;
 exports.diff = diff;
-exports.listBranches = listBranches;
-exports.currentBranch = currentBranch;
-exports.createBranch = createBranch;
-exports.previewMerge = previewMerge;
-exports.mergeBranch = mergeBranch;
 exports.cutWorkdir = cutWorkdir;
-exports.pasteStash = pasteStash;
-exports.showStashes = showStashes;
-exports.switchBranch = switchBranch;
+exports.pasteSnarf = pasteSnarf;
+exports.showSnarfs = showSnarfs;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const Automerge = __importStar(require("@automerge/automerge"));
 const automerge_repo_1 = require("@automerge/automerge-repo");
 const config_js_1 = require("./config.js");
-const branches_js_1 = require("./branches.js");
-Object.defineProperty(exports, "deleteBranchFile", { enumerable: true, get: function () { return branches_js_1.deleteBranchFile; } });
 const ignore_js_1 = require("./ignore.js");
 const fs_tree_js_1 = require("./fs-tree.js");
 const log_js_1 = require("./log.js");
 const repo_js_1 = require("./repo.js");
-const stash_js_1 = require("./stash.js");
+const snarf_js_1 = require("./snarf.js");
 const index_js_1 = require("./shapes/index.js");
 const dlog = (0, log_js_1.log)("pushwork");
 const DEFAULT_ARTIFACT_DIRECTORIES = ["dist"];
 async function init(opts) {
     const root = path.resolve(opts.dir);
-    const useBranches = opts.branches ?? true;
     const online = opts.online ?? true;
-    dlog("init root=%s backend=%s shape=%s branches=%s online=%s", root, opts.backend, opts.shape, useBranches, online);
+    dlog("init root=%s backend=%s shape=%s online=%s", root, opts.backend, opts.shape, online);
     if (await (0, config_js_1.configExists)(root)) {
         throw new Error(`pushwork already initialized at ${root}`);
     }
@@ -82,38 +73,25 @@ async function init(opts) {
         const ig = await (0, ignore_js_1.loadIgnore)(root);
         const fsFiles = await (0, fs_tree_js_1.walkDir)(root, ig);
         dlog("init walked %d files", fsFiles.size);
+        const title = path.basename(root) || undefined;
         const tree = await pushFiles(repo, fsFiles, undefined, artifactDirs);
-        const folderUrl = await shape.encode({ repo, tree });
-        dlog("init encoded folder=%s", folderUrl);
+        const folderUrl = await shape.encode({ repo, tree, title });
+        dlog("init encoded folder=%s title=%s", folderUrl, title);
         const folderHandle = await repo.find(folderUrl);
         if (online) {
             await (0, repo_js_1.waitForSync)(folderHandle, { minMs: 3000, idleMs: 1500, maxMs: 15000 });
             stampLastSyncAt(folderHandle);
             await (0, repo_js_1.waitForSync)(folderHandle, { idleMs: 1500, maxMs: 10000 });
         }
-        let rootUrl = folderUrl;
-        if (useBranches) {
-            const branchesHandle = repo.create({
-                "@patchwork": { type: "branches" },
-                branches: { [branches_js_1.DEFAULT_BRANCH]: folderUrl },
-            });
-            if (online) {
-                await (0, repo_js_1.waitForSync)(branchesHandle, { minMs: 1500, idleMs: 1500, maxMs: 10000 });
-            }
-            rootUrl = branchesHandle.url;
-            dlog("init wrapped in BranchesDoc=%s", rootUrl);
-            await (0, branches_js_1.writeBranchFile)(root, branches_js_1.DEFAULT_BRANCH);
-        }
         await (0, config_js_1.writeConfig)(root, {
             version: config_js_1.CONFIG_VERSION,
-            rootUrl,
+            rootUrl: folderUrl,
             backend: opts.backend,
             shape: opts.shape,
             artifactDirectories: artifactDirs,
-            branches: useBranches,
         });
-        dlog("init complete: rootUrl=%s", rootUrl);
-        return rootUrl;
+        dlog("init complete: rootUrl=%s", folderUrl);
+        return folderUrl;
     }
     finally {
         await repo.shutdown();
@@ -135,36 +113,36 @@ async function clone(opts) {
     const repo = await (0, repo_js_1.openRepo)(opts.backend, (0, config_js_1.storageDir)(root), { offline: !online });
     try {
         const shape = await (0, index_js_1.resolveShape)(opts.shape);
-        const rootHandle = await repo.find(opts.url);
+        let folderHandle = await repo.find(opts.url);
         if (online) {
-            await (0, repo_js_1.waitForSync)(rootHandle, { idleMs: 1500, maxMs: 15000 });
+            await (0, repo_js_1.waitForSync)(folderHandle, { idleMs: 1500, maxMs: 15000 });
         }
-        const docType = (0, branches_js_1.detectDocType)(rootHandle.doc());
-        dlog("clone detected docType=%s", docType);
-        let useBranches = false;
-        let folderHandle = rootHandle;
-        if (docType === "branches") {
-            useBranches = true;
-            const branchName = opts.branch ?? branches_js_1.DEFAULT_BRANCH;
-            folderHandle = await (0, branches_js_1.resolveEffectiveRoot)(repo, rootHandle, branchName);
+        let storedUrl = opts.url;
+        const branchesDoc = asBranchesDoc(folderHandle.doc());
+        if (branchesDoc) {
+            if (!opts.onBranchesDoc) {
+                throw new Error(`URL ${opts.url} is a legacy branches doc; pushwork no longer supports branches. Provide an onBranchesDoc callback (or use the CLI, which will prompt you to pick a branch).`);
+            }
+            const branches = Object.entries(branchesDoc.branches).map(([name, url]) => ({ name, url }));
+            const chosenUrl = await opts.onBranchesDoc({
+                title: branchesDoc.title,
+                branches,
+            });
+            dlog("clone branches doc → chose %s", chosenUrl);
+            folderHandle = await repo.find(chosenUrl);
             if (online) {
                 await (0, repo_js_1.waitForSync)(folderHandle, { idleMs: 1500, maxMs: 15000 });
             }
-            await (0, branches_js_1.writeBranchFile)(root, branchName);
-            dlog("clone branch=%s folder=%s", branchName, folderHandle.url);
-        }
-        else if (opts.branch) {
-            throw new Error(`--branch passed but root doc is not a branches doc (type=${docType})`);
+            storedUrl = chosenUrl;
         }
         const tree = await shape.decode({ repo, root: folderHandle });
         await materializeTree(repo, root, tree);
         await (0, config_js_1.writeConfig)(root, {
             version: config_js_1.CONFIG_VERSION,
-            rootUrl: opts.url,
+            rootUrl: storedUrl,
             backend: opts.backend,
             shape: opts.shape,
             artifactDirectories: artifactDirs,
-            branches: useBranches,
         });
         dlog("clone complete");
     }
@@ -172,41 +150,93 @@ async function clone(opts) {
         await repo.shutdown();
     }
 }
+function asBranchesDoc(doc) {
+    if (!doc || typeof doc !== "object")
+        return null;
+    const meta = doc["@patchwork"];
+    if (!meta || typeof meta !== "object")
+        return null;
+    if (meta.type !== "branches")
+        return null;
+    const branches = doc.branches;
+    if (!branches || typeof branches !== "object")
+        return null;
+    return {
+        title: meta.title,
+        branches: branches,
+    };
+}
 async function url(cwd) {
     const config = await (0, config_js_1.readConfig)(path.resolve(cwd));
     return config.rootUrl;
 }
-async function sync(cwd) {
+async function sync(cwd, opts = {}) {
+    if (opts.nuclear) {
+        await nuclearizeRepo(cwd);
+    }
     await commitWorkdir(cwd, { online: true });
 }
+/**
+ * Re-create every Automerge doc this repo references — every UnixFileEntry
+ * and the folder/directory doc — with brand-new URLs and no shared history
+ * with the originals. Updates `config.json` to point at the new root.
+ * Offline; the next sync publishes the new docs to the server.
+ *
+ * Use sparingly: this orphans the previous URLs from this repo's perspective.
+ * Anyone who had cloned the old URL keeps working from those docs; this
+ * client just stops referencing them.
+ */
+async function nuclearizeRepo(cwd) {
+    const root = path.resolve(cwd);
+    const config = await (0, config_js_1.readConfig)(root);
+    dlog("nuclear root=%s", root);
+    const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: true });
+    try {
+        const shape = await (0, index_js_1.resolveShape)(config.shape);
+        const oldFolder = await repo.find(config.rootUrl);
+        const title = path.basename(root) || undefined;
+        const oldTree = await shape.decode({ repo, root: oldFolder });
+        // For each leaf: read content, create a fresh UnixFileEntry doc.
+        const newTree = (0, index_js_1.newDir)();
+        for (const [posixPath, fileUrl] of (0, index_js_1.flattenLeaves)(oldTree)) {
+            const bare = (0, index_js_1.stripHeads)(fileUrl);
+            const oldFileHandle = await repo.find(bare);
+            const oldDoc = oldFileHandle.doc();
+            const newFileHandle = repo.create({
+                "@patchwork": { type: "file" },
+                name: oldDoc.name,
+                extension: oldDoc.extension,
+                mimeType: oldDoc.mimeType,
+                content: oldDoc.content,
+            });
+            let finalUrl = newFileHandle.url;
+            if ((0, index_js_1.isInArtifactDir)(posixPath, config.artifactDirectories)) {
+                finalUrl = (0, index_js_1.pinUrl)(newFileHandle);
+            }
+            (0, index_js_1.setFileAt)(newTree, posixPath.split("/").filter(Boolean), finalUrl);
+        }
+        // Encode without previousRoot → fresh folder/directory doc URL.
+        const newRootUrl = await shape.encode({ repo, tree: newTree, title });
+        dlog("nuclear new rootUrl=%s", newRootUrl);
+        await (0, config_js_1.writeConfig)(root, { ...config, rootUrl: newRootUrl });
+    }
+    finally {
+        await repo.shutdown();
+    }
+}
 async function save(cwd) {
     await commitWorkdir(cwd, { online: false });
 }
 async function commitWorkdir(cwd, { online }) {
     const root = path.resolve(cwd);
     const config = await (0, config_js_1.readConfig)(root);
-    const branchName = config.branches ? await (0, branches_js_1.readBranchFile)(root) : null;
-    dlog("commit online=%s root=%s branch=%s", online, root, branchName);
+    dlog("commit online=%s root=%s", online, root);
     const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), {
         offline: !online,
     });
     try {
         const shape = await (0, index_js_1.resolveShape)(config.shape);
-        const rootHandle = await repo.find(config.rootUrl);
-        // In branches mode + online, touch every branch's folder doc so the
-        // network adapter announces them. Without this, a branch created
-        // offline (`pushwork branch X`) is never pushed to the server, even
-        // though its entry is in the BranchesDoc.
-        const otherBranchHandles = [];
-        if (online && config.branches && (0, branches_js_1.isBranchesDoc)(rootHandle.doc())) {
-            const doc = rootHandle.doc();
-            for (const [name, url] of Object.entries(doc.branches)) {
-                if (name === branchName)
-                    continue;
-                otherBranchHandles.push(await repo.find(url));
-            }
-        }
-        const folderHandle = await (0, branches_js_1.resolveEffectiveRoot)(repo, rootHandle, branchName);
+        const folderHandle = await repo.find(config.rootUrl);
         const previousTree = await shape.decode({ repo, root: folderHandle });
         const previousFiles = await readFileBytes(repo, previousTree);
         const ig = await (0, ignore_js_1.loadIgnore)(root);
@@ -222,21 +252,11 @@ async function commitWorkdir(cwd, { online }) {
             // working tree changed — a sync is also a checkpoint that "we
             // reconciled with the server at this time."
             stampLastSyncAt(folderHandle);
-            // Wait for the current branch's folder, the BranchesDoc itself
-            // (when in branches mode), and any other branch folder docs to
-            // flush. The maxMs is generous so a brand-new offline-created
-            // branch reliably propagates.
             await (0, repo_js_1.waitForSync)(folderHandle, {
                 minMs: 3000,
                 idleMs: 1500,
                 maxMs: 15000,
             });
-            if (config.branches) {
-                await (0, repo_js_1.waitForSync)(rootHandle, { idleMs: 1500, maxMs: 10000 });
-            }
-            for (const h of otherBranchHandles) {
-                await (0, repo_js_1.waitForSync)(h, { idleMs: 1500, maxMs: 10000 });
-            }
         }
         const finalTree = await shape.decode({ repo, root: folderHandle });
         await materializeTree(repo, root, finalTree);
@@ -249,18 +269,16 @@ async function commitWorkdir(cwd, { online }) {
 async function status(cwd) {
     const root = path.resolve(cwd);
     const config = await (0, config_js_1.readConfig)(root);
-    const branchName = config.branches ? await (0, branches_js_1.readBranchFile)(root) : null;
     const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: true });
     try {
         const shape = await (0, index_js_1.resolveShape)(config.shape);
-        const rootHandle = await repo.find(config.rootUrl);
-        const folderHandle = await (0, branches_js_1.resolveEffectiveRoot)(repo, rootHandle, branchName);
+        const folderHandle = await repo.find(config.rootUrl);
         const previousTree = await shape.decode({ repo, root: folderHandle });
         const previousFiles = await readFileBytes(repo, previousTree);
         const ig = await (0, ignore_js_1.loadIgnore)(root);
         const fsFiles = await (0, fs_tree_js_1.walkDir)(root, ig);
         const diff = computeDiff(previousFiles, fsFiles);
-        return { branch: branchName, diff };
+        return { diff };
     }
     finally {
         await repo.shutdown();
@@ -269,12 +287,10 @@ async function status(cwd) {
 async function diff(cwd, limitToPath) {
     const root = path.resolve(cwd);
     const config = await (0, config_js_1.readConfig)(root);
-    const branchName = config.branches ? await (0, branches_js_1.readBranchFile)(root) : null;
     const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: true });
     try {
         const shape = await (0, index_js_1.resolveShape)(config.shape);
-        const rootHandle = await repo.find(config.rootUrl);
-        const folderHandle = await (0, branches_js_1.resolveEffectiveRoot)(repo, rootHandle, branchName);
+        const folderHandle = await repo.find(config.rootUrl);
         const previousTree = await shape.decode({ repo, root: folderHandle });
         const previousFiles = await readFileBytes(repo, previousTree);
         const ig = await (0, ignore_js_1.loadIgnore)(root);
@@ -303,304 +319,19 @@ async function diff(cwd, limitToPath) {
         await repo.shutdown();
     }
 }
-async function listBranches(cwd) {
-    const root = path.resolve(cwd);
-    const config = await (0, config_js_1.readConfig)(root);
-    if (!config.branches) {
-        throw new Error("pushwork repo has no branches");
-    }
-    const current = await (0, branches_js_1.readBranchFile)(root);
-    const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: true });
-    try {
-        const rootHandle = await repo.find(config.rootUrl);
-        const doc = rootHandle.doc();
-        if (!(0, branches_js_1.isBranchesDoc)(doc)) {
-            throw new Error(`root doc at ${config.rootUrl} is not a branches doc`);
-        }
-        return { current, names: (0, branches_js_1.listBranchNames)(doc) };
-    }
-    finally {
-        await repo.shutdown();
-    }
-}
-async function currentBranch(cwd) {
-    const root = path.resolve(cwd);
-    const config = await (0, config_js_1.readConfig)(root);
-    if (!config.branches)
-        return null;
-    return (0, branches_js_1.readBranchFile)(root);
-}
-async function createBranch(cwd, name) {
-    if (!name)
-        throw new Error("branch name is required");
-    if (name.includes("/") || name.includes("\\")) {
-        throw new Error("branch name may not contain slashes");
-    }
-    const root = path.resolve(cwd);
-    const config = await (0, config_js_1.readConfig)(root);
-    if (!config.branches)
-        throw new Error("pushwork repo has no branches");
-    const currentName = await (0, branches_js_1.readBranchFile)(root);
-    if (!currentName)
-        throw new Error("no current branch is set");
-    const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: true });
-    try {
-        const shape = await (0, index_js_1.resolveShape)(config.shape);
-        const rootHandle = await repo.find(config.rootUrl);
-        const doc = rootHandle.doc();
-        if (!(0, branches_js_1.isBranchesDoc)(doc)) {
-            throw new Error(`root doc at ${config.rootUrl} is not a branches doc`);
-        }
-        if (doc.branches[name]) {
-            throw new Error(`branch "${name}" already exists`);
-        }
-        const sourceUrl = doc.branches[currentName];
-        if (!sourceUrl) {
-            throw new Error(`current branch "${currentName}" not found in branches doc`);
-        }
-        const sourceHandle = await repo.find(sourceUrl);
-        // Clone the folder doc.
-        const clonedFolder = repo.clone(sourceHandle);
-        dlog("createBranch %s cloned folder %s → %s", name, sourceUrl, clonedFolder.url);
-        // Deep-clone every file doc the source folder references, then rewrite
-        // the cloned folder's leaves to point at the new file URLs. Without
-        // this step both branches would alias the same UnixFileEntry docs and
-        // editing one branch would silently mutate the other.
-        const sourceTree = await shape.decode({ repo, root: sourceHandle });
-        const fileUrlRemap = new Map();
-        for (const [, fileUrl] of (0, index_js_1.flattenLeaves)(sourceTree)) {
-            const bare = (0, index_js_1.stripHeads)(fileUrl);
-            if (fileUrlRemap.has(bare))
-                continue;
-            const orig = await repo.find(bare);
-            const cloned = repo.clone(orig);
-            fileUrlRemap.set(bare, cloned.url);
-            dlog("createBranch cloned file %s → %s", bare, cloned.url);
-        }
-        const newTree = (0, index_js_1.newDir)();
-        for (const [posixPath, fileUrl] of (0, index_js_1.flattenLeaves)(sourceTree)) {
-            const bare = (0, index_js_1.stripHeads)(fileUrl);
-            const remappedBare = fileUrlRemap.get(bare);
-            if (!remappedBare)
-                continue;
-            const parsed = (0, automerge_repo_1.parseAutomergeUrl)(fileUrl);
-            // Preserve heads-pinning if the source URL was pinned.
-            let finalUrl = remappedBare;
-            if (parsed.heads) {
-                const newHandle = await repo.find(remappedBare);
-                finalUrl = (0, index_js_1.pinUrl)(newHandle);
-            }
-            const segments = posixPath.split("/").filter(Boolean);
-            (0, index_js_1.setFileAt)(newTree, segments, finalUrl);
-        }
-        await shape.encode({ repo, tree: newTree, previousRoot: clonedFolder });
-        rootHandle.change((d) => {
-            d.branches[name] = clonedFolder.url;
-        });
-        return clonedFolder.url;
-    }
-    finally {
-        await repo.shutdown();
-    }
-}
-/**
- * Apply changes from `source` branch onto the current branch.
- *
- * For each path:
- * - In both branches: their UnixFileEntry docs share Automerge history (deep
- *   cloned at branch creation), so we Automerge-merge source's content into
- *   target's. Concurrent edits are CRDT-merged inside each file doc.
- * - Only in source: deep-clone the source's file doc into a new doc and add
- *   it to target's folder. Editing on either branch afterward stays isolated.
- * - Only in target: untouched. We don't propagate deletions from source — the
- *   user can do that explicitly.
- *
- * Refuses if the working tree has uncommitted changes against the current
- * branch (run `pushwork save` first). Offline only — propagation happens on
- * the next `pushwork sync`.
- */
-/**
- * Compute what `merge <source>` would do without mutating any docs or the
- * working tree. For paths in both branches we apply the merge to a *clone*
- * of the target's file doc to learn the merged bytes; for paths only in
- * source we just read source's bytes.
- */
-async function previewMerge(cwd, source) {
-    if (!source)
-        throw new Error("source branch name is required");
-    const root = path.resolve(cwd);
-    const config = await (0, config_js_1.readConfig)(root);
-    if (!config.branches)
-        throw new Error("pushwork repo has no branches");
-    const targetName = await (0, branches_js_1.readBranchFile)(root);
-    if (!targetName)
-        throw new Error("no current branch is set");
-    if (source === targetName) {
-        throw new Error(`cannot merge "${source}" into itself`);
-    }
-    const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: true });
-    try {
-        const shape = await (0, index_js_1.resolveShape)(config.shape);
-        const rootHandle = await repo.find(config.rootUrl);
-        const branchesDoc = rootHandle.doc();
-        if (!(0, branches_js_1.isBranchesDoc)(branchesDoc)) {
-            throw new Error(`root doc at ${config.rootUrl} is not a branches doc`);
-        }
-        if (!branchesDoc.branches[source]) {
-            throw new Error(`source branch "${source}" does not exist`);
-        }
-        const targetFolder = await repo.find(branchesDoc.branches[targetName]);
-        const sourceFolder = await repo.find(branchesDoc.branches[source]);
-        const tTree = await shape.decode({ repo, root: targetFolder });
-        const sTree = await shape.decode({ repo, root: sourceFolder });
-        const tLeaves = (0, index_js_1.flattenLeaves)(tTree);
-        const sLeaves = (0, index_js_1.flattenLeaves)(sTree);
-        const entries = [];
-        for (const [posixPath, sUrl] of sLeaves) {
-            const tUrl = tLeaves.get(posixPath);
-            const sBare = (0, index_js_1.stripHeads)(sUrl);
-            const sHandle = await repo.find(sBare);
-            if (!tUrl) {
-                entries.push({
-                    path: posixPath,
-                    kind: "added",
-                    after: (0, index_js_1.contentToBytes)(sHandle.doc().content),
-                });
-                continue;
-            }
-            const tBare = (0, index_js_1.stripHeads)(tUrl);
-            if (tBare === sBare)
-                continue;
-            const tHandle = await repo.find(tBare);
-            const before = (0, index_js_1.contentToBytes)(tHandle.doc().content);
-            // Compute merge result without touching the target doc.
-            const merged = Automerge.merge(Automerge.clone(tHandle.doc()), Automerge.clone(sHandle.doc()));
-            const after = (0, index_js_1.contentToBytes)(merged.content);
-            if ((0, fs_tree_js_1.byteEq)(before, after))
-                continue;
-            entries.push({ path: posixPath, kind: "merged", before, after });
-        }
-        entries.sort((a, b) => a.path.localeCompare(b.path));
-        return { source, target: targetName, entries };
-    }
-    finally {
-        await repo.shutdown();
-    }
-}
-async function mergeBranch(cwd, source) {
-    if (!source)
-        throw new Error("source branch name is required");
-    const root = path.resolve(cwd);
-    const config = await (0, config_js_1.readConfig)(root);
-    if (!config.branches)
-        throw new Error("pushwork repo has no branches");
-    const targetName = await (0, branches_js_1.readBranchFile)(root);
-    if (!targetName)
-        throw new Error("no current branch is set");
-    if (source === targetName) {
-        throw new Error(`cannot merge "${source}" into itself`);
-    }
-    dlog("merge source=%s target=%s", source, targetName);
-    const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: true });
-    try {
-        const shape = await (0, index_js_1.resolveShape)(config.shape);
-        const rootHandle = await repo.find(config.rootUrl);
-        const branchesDoc = rootHandle.doc();
-        if (!(0, branches_js_1.isBranchesDoc)(branchesDoc)) {
-            throw new Error(`root doc at ${config.rootUrl} is not a branches doc`);
-        }
-        if (!branchesDoc.branches[source]) {
-            throw new Error(`source branch "${source}" does not exist`);
-        }
-        const targetUrl = branchesDoc.branches[targetName];
-        const sourceUrl = branchesDoc.branches[source];
-        const targetFolder = await repo.find(targetUrl);
-        const sourceFolder = await repo.find(sourceUrl);
-        // Refuse on dirty working tree (mirror switchBranch policy).
-        const tFiles = await readFileBytes(repo, await shape.decode({ repo, root: targetFolder }));
-        const ig = await (0, ignore_js_1.loadIgnore)(root);
-        const fsFiles = await (0, fs_tree_js_1.walkDir)(root, ig);
-        const dirty = computeDiff(tFiles, fsFiles);
-        if (dirty.added.length || dirty.modified.length || dirty.deleted.length) {
-            throw new Error(`refusing to merge: working tree has uncommitted changes on branch "${targetName}". run \`pushwork save\` first.`);
-        }
-        const tTree = await shape.decode({ repo, root: targetFolder });
-        const sTree = await shape.decode({ repo, root: sourceFolder });
-        const tLeaves = (0, index_js_1.flattenLeaves)(tTree);
-        const sLeaves = (0, index_js_1.flattenLeaves)(sTree);
-        const merged = [];
-        const added = [];
-        // For paths in both: merge file docs in place.
-        for (const [posixPath, sUrl] of sLeaves) {
-            const tUrl = tLeaves.get(posixPath);
-            if (!tUrl)
-                continue;
-            const tBare = (0, index_js_1.stripHeads)(tUrl);
-            const sBare = (0, index_js_1.stripHeads)(sUrl);
-            if (tBare === sBare) {
-                // Same file doc identity (shared) — already in sync, nothing to do.
-                continue;
-            }
-            const tHandle = await repo.find(tBare);
-            const sHandle = await repo.find(sBare);
-            tHandle.update((d) => Automerge.merge(d, Automerge.clone(sHandle.doc())));
-            merged.push(posixPath);
-            dlog("merge merged file at %s (%s ← %s)", posixPath, tBare, sBare);
-        }
-        // For paths only in source: deep-clone source's file doc, add to target's folder.
-        const newLeaves = new Map();
-        for (const [posixPath, sUrl] of sLeaves) {
-            if (tLeaves.has(posixPath))
-                continue;
-            const sBare = (0, index_js_1.stripHeads)(sUrl);
-            const sHandle = await repo.find(sBare);
-            const cloned = repo.clone(sHandle);
-            let finalUrl = cloned.url;
-            const parsed = (0, automerge_repo_1.parseAutomergeUrl)(sUrl);
-            if (parsed.heads) {
-                finalUrl = (0, index_js_1.pinUrl)(cloned);
-            }
-            newLeaves.set(posixPath, finalUrl);
-            added.push(posixPath);
-            dlog("merge added %s url=%s", posixPath, finalUrl);
-        }
-        if (newLeaves.size > 0) {
-            // Build a tree for the encode call: existing target leaves + new ones.
-            const nextTree = (0, index_js_1.newDir)();
-            for (const [p, url] of tLeaves) {
-                (0, index_js_1.setFileAt)(nextTree, p.split("/").filter(Boolean), url);
-            }
-            for (const [p, url] of newLeaves) {
-                (0, index_js_1.setFileAt)(nextTree, p.split("/").filter(Boolean), url);
-            }
-            await shape.encode({ repo, tree: nextTree, previousRoot: targetFolder });
-        }
-        // Materialize current branch (target) onto disk to reflect the merge.
-        const finalTree = await shape.decode({ repo, root: targetFolder });
-        await materializeTree(repo, root, finalTree);
-        merged.sort();
-        added.sort();
-        return { source, target: targetName, merged, added };
-    }
-    finally {
-        await repo.shutdown();
-    }
-}
 /**
- * Capture the working tree's changes against the current branch's saved
- * state into a local stash, then reset the working tree to the saved state.
- * Stashes live in `.pushwork/stash.json` and are never synced.
+ * Capture the working tree's changes against the saved state into a local
+ * snarf, then reset the working tree to the saved state. Snarfs live in
+ * `.pushwork/snarf/` and are never synced.
  */
 async function cutWorkdir(cwd, opts = {}) {
     const root = path.resolve(cwd);
     const config = await (0, config_js_1.readConfig)(root);
-    const branchName = config.branches ? await (0, branches_js_1.readBranchFile)(root) : null;
-    dlog("cut root=%s branch=%s name=%s", root, branchName, opts.name ?? "(unnamed)");
+    dlog("cut root=%s name=%s", root, opts.name ?? "(unnamed)");
     const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: true });
     try {
         const shape = await (0, index_js_1.resolveShape)(config.shape);
-        const rootHandle = await repo.find(config.rootUrl);
-        const folderHandle = await (0, branches_js_1.resolveEffectiveRoot)(repo, rootHandle, branchName);
+        const folderHandle = await repo.find(config.rootUrl);
         const previousTree = await shape.decode({ repo, root: folderHandle });
         const previousFiles = await readFileBytes(repo, previousTree);
         const ig = await (0, ignore_js_1.loadIgnore)(root);
@@ -609,13 +340,13 @@ async function cutWorkdir(cwd, opts = {}) {
         for (const [p, bytes] of fsFiles) {
             const prev = previousFiles.get(p);
             if (!prev) {
-                entries.push({ path: p, kind: "added", contentBase64: (0, stash_js_1.encodeBytes)(bytes) });
+                entries.push({ path: p, kind: "added", contentBase64: (0, snarf_js_1.encodeBytes)(bytes) });
             }
             else if (!(0, fs_tree_js_1.byteEq)(prev.bytes, bytes)) {
                 entries.push({
                     path: p,
                     kind: "modified",
-                    contentBase64: (0, stash_js_1.encodeBytes)(bytes),
+                    contentBase64: (0, snarf_js_1.encodeBytes)(bytes),
                 });
             }
         }
@@ -627,35 +358,32 @@ async function cutWorkdir(cwd, opts = {}) {
             throw new Error("nothing to cut: working tree clean");
         }
         entries.sort((a, b) => a.path.localeCompare(b.path));
-        const stash = await (0, stash_js_1.appendStash)(root, {
+        const snarf = await (0, snarf_js_1.appendSnarf)(root, {
             name: opts.name,
-            branch: branchName,
             entries,
         });
-        // Reset working tree to the branch's saved state.
+        // Reset working tree to the saved state.
         await materializeTree(repo, root, previousTree);
-        dlog("cut complete id=%d entries=%d", stash.id, entries.length);
-        return { id: stash.id, entries: entries.length };
+        dlog("cut complete id=%d entries=%d", snarf.id, entries.length);
+        return { id: snarf.id, entries: entries.length };
     }
     finally {
         await repo.shutdown();
     }
 }
 /**
- * Apply a stash on top of the current working tree, then remove the stash
+ * Apply a snarf on top of the current working tree, then remove the snarf
  * entry. Refuses if the working tree has uncommitted changes (caller can
  * `pushwork save` or `pushwork cut` first).
  */
-async function pasteStash(cwd, selector) {
+async function pasteSnarf(cwd, selector) {
     const root = path.resolve(cwd);
     const config = await (0, config_js_1.readConfig)(root);
-    const branchName = config.branches ? await (0, branches_js_1.readBranchFile)(root) : null;
-    // Check the working tree is clean against the current branch state.
+    // Check the working tree is clean against the saved state.
     const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: true });
     try {
         const shape = await (0, index_js_1.resolveShape)(config.shape);
-        const rootHandle = await repo.find(config.rootUrl);
-        const folderHandle = await (0, branches_js_1.resolveEffectiveRoot)(repo, rootHandle, branchName);
+        const folderHandle = await repo.find(config.rootUrl);
         const previousTree = await shape.decode({ repo, root: folderHandle });
         const previousFiles = await readFileBytes(repo, previousTree);
         const ig = await (0, ignore_js_1.loadIgnore)(root);
@@ -668,13 +396,13 @@ async function pasteStash(cwd, selector) {
     finally {
         await repo.shutdown();
     }
-    const stash = await (0, stash_js_1.takeStash)(root, selector);
-    if (!stash) {
+    const snarf = await (0, snarf_js_1.takeSnarf)(root, selector);
+    if (!snarf) {
         throw new Error(selector
-            ? `no stash matches "${selector}"`
-            : "nothing to paste: no stashes");
+            ? `no snarf matches "${selector}"`
+            : "nothing to paste: no snarfs");
     }
-    for (const entry of stash.entries) {
+    for (const entry of snarf.entries) {
         const target = path.join(root, fromPosix(entry.path));
         if (entry.kind === "deleted") {
             try {
@@ -686,57 +414,15 @@ async function pasteStash(cwd, selector) {
             await pruneEmptyDirs(root, path.dirname(fromPosix(entry.path)));
         }
         else if (entry.contentBase64 != null) {
-            const bytes = (0, stash_js_1.decodeBytes)(entry.contentBase64);
+            const bytes = (0, snarf_js_1.decodeBytes)(entry.contentBase64);
             await (0, fs_tree_js_1.writeFileAtomic)(target, bytes);
         }
     }
-    dlog("paste complete id=%d entries=%d", stash.id, stash.entries.length);
-    return { id: stash.id, name: stash.name, entries: stash.entries.length };
-}
-async function showStashes(cwd) {
-    return (0, stash_js_1.listStashes)(path.resolve(cwd));
+    dlog("paste complete id=%d entries=%d", snarf.id, snarf.entries.length);
+    return { id: snarf.id, name: snarf.name, entries: snarf.entries.length };
 }
-async function switchBranch(cwd, name) {
-    if (!name)
-        throw new Error("branch name is required");
-    const root = path.resolve(cwd);
-    const config = await (0, config_js_1.readConfig)(root);
-    if (!config.branches)
-        throw new Error("pushwork repo has no branches");
-    const currentName = await (0, branches_js_1.readBranchFile)(root);
-    const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: true });
-    try {
-        const shape = await (0, index_js_1.resolveShape)(config.shape);
-        const rootHandle = await repo.find(config.rootUrl);
-        const doc = rootHandle.doc();
-        if (!(0, branches_js_1.isBranchesDoc)(doc)) {
-            throw new Error(`root doc at ${config.rootUrl} is not a branches doc`);
-        }
-        if (!doc.branches[name]) {
-            throw new Error(`branch "${name}" does not exist`);
-        }
-        // Refuse if the working dir has uncommitted changes against the current branch.
-        if (currentName) {
-            const folderHandle = await (0, branches_js_1.resolveEffectiveRoot)(repo, rootHandle, currentName);
-            const previousTree = await shape.decode({ repo, root: folderHandle });
-            const previousFiles = await readFileBytes(repo, previousTree);
-            const ig = await (0, ignore_js_1.loadIgnore)(root);
-            const fsFiles = await (0, fs_tree_js_1.walkDir)(root, ig);
-            const d = computeDiff(previousFiles, fsFiles);
-            if (d.added.length || d.modified.length || d.deleted.length) {
-                throw new Error(`refusing to switch: working tree has uncommitted changes on branch "${currentName}". run \`pushwork save\` first.`);
-            }
-        }
-        // Materialize from the new branch.
-        const newFolder = await repo.find(doc.branches[name]);
-        const tree = await shape.decode({ repo, root: newFolder });
-        await materializeTree(repo, root, tree);
-        await (0, branches_js_1.writeBranchFile)(root, name);
-        dlog("switch → %s", name);
-    }
-    finally {
-        await repo.shutdown();
-    }
+async function showSnarfs(cwd) {
+    return (0, snarf_js_1.listSnarfs)(path.resolve(cwd));
 }
 function stampLastSyncAt(handle) {
     handle.change((d) => {
@@ -794,17 +480,13 @@ async function pushFiles(repo, fsFiles, previous, artifactDirs) {
         }
         else if (prev) {
             // Changed path: mutate the existing file doc in place. This keeps
-            // the file URL stable within a branch and avoids the propagation
+            // the file URL stable across edits and avoids the propagation
             // race where a brand-new file doc URL is referenced by the folder
             // before its bytes have reached the sync server.
             //
             // For string content (text files) we use Automerge.updateText so
             // concurrent character-level edits merge correctly. Bytes and
             // ImmutableString are atomic — last writer wins on the field.
-            //
-            // Branch isolation is enforced separately: `createBranch` deep
-            // clones every file doc the source branch references, so two
-            // branches never share a UnixFileEntry doc identity.
             const refreshUrl = (0, index_js_1.stripHeads)(prev.url);
             const handle = await repo.find(refreshUrl);
             handle.change((d) => {