pushwork 2.0.0-preview.2 → 2.0.0-preview.4

package/dist/pushwork.js

@@ -33,44 +33,35 @@ 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.heads = heads;
 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}`);
     }
@@ -93,29 +84,15 @@ async function init(opts) {
             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", ...(title ? { title } : {}) },
-                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();
@@ -137,36 +114,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");
     }
@@ -174,6 +151,22 @@ 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;
@@ -181,77 +174,89 @@ async function url(cwd) {
 async function sync(cwd, opts = {}) {
     if (opts.nuclear) {
         await nuclearizeRepo(cwd);
+        await publishCurrentTree(cwd);
+        return;
     }
     await commitWorkdir(cwd, { online: true });
 }
 /**
- * Re-create every Automerge doc this repo references — every UnixFileEntry,
- * every folder/directory doc, and (when in branches mode) the BranchesDoc —
- * 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.
+ * Open an online repo, subscribe the root folder and every file leaf so the
+ * network adapter announces them to peers, then wait for the local heads to
+ * settle. No decode/diff/encode — used after nuclearizeRepo, where every doc
+ * is freshly created locally and the server has nothing to merge in.
+ */
+async function publishCurrentTree(cwd) {
+    const root = path.resolve(cwd);
+    const config = await (0, config_js_1.readConfig)(root);
+    dlog("publish root=%s", root);
+    const repo = await (0, repo_js_1.openRepo)(config.backend, (0, config_js_1.storageDir)(root), { offline: false });
+    try {
+        const shape = await (0, index_js_1.resolveShape)(config.shape);
+        const folderHandle = await repo.find(config.rootUrl);
+        const tree = await shape.decode({ repo, root: folderHandle });
+        // Touch every leaf so the network adapter knows to push it.
+        for (const [, fileUrl] of (0, index_js_1.flattenLeaves)(tree)) {
+            await repo.find(fileUrl);
+        }
+        stampLastSyncAt(folderHandle);
+        await (0, repo_js_1.waitForSync)(folderHandle, {
+            minMs: 3000,
+            idleMs: 1500,
+            maxMs: 15000,
+        });
+        dlog("publish complete");
+    }
+    finally {
+        await repo.shutdown();
+    }
+}
+/**
+ * Re-create every UnixFileEntry doc this repo references with a fresh URL,
+ * then rewrite the existing folder doc's leaves to point at the new file
+ * URLs. The folder doc URL itself is preserved so anyone holding it keeps
+ * tracking this repo. Offline; the next sync publishes the new file docs
+ * and the rewritten folder doc 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.
+ * The previous file-doc URLs are orphaned from this repo's perspective.
+ * Anyone holding one of those URLs directly continues to work from it;
+ * this client just stops referencing them.
  */
 async function nuclearizeRepo(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;
-    dlog("nuclear root=%s branches=%s current=%s", root, config.branches, branchName);
+    dlog("nuclear root=%s rootUrl=%s", root, config.rootUrl);
     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 oldRootHandle = await repo.find(config.rootUrl);
+        const folderHandle = await repo.find(config.rootUrl);
         const title = path.basename(root) || undefined;
-        const rebuildFolder = async (oldFolderUrl, folderTitle) => {
-            const oldFolder = await repo.find(oldFolderUrl);
-            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, automerge_repo_1.parseAutomergeUrl)(fileUrl).heads) {
-                    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.
-            return shape.encode({ repo, tree: newTree, title: folderTitle });
-        };
-        let newRootUrl;
-        if (config.branches && (0, branches_js_1.isBranchesDoc)(oldRootHandle.doc())) {
-            const oldDoc = oldRootHandle.doc();
-            const newBranches = {};
-            for (const [name, oldFolderUrl] of Object.entries(oldDoc.branches)) {
-                newBranches[name] = await rebuildFolder(oldFolderUrl, title);
-                dlog("nuclear rebuilt branch %s → %s", name, newBranches[name]);
-            }
-            const newRoot = repo.create({
-                "@patchwork": {
-                    type: "branches",
-                    ...(title ? { title } : {}),
-                },
-                branches: newBranches,
+        const oldTree = await shape.decode({ repo, root: folderHandle });
+        // 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,
             });
-            newRootUrl = newRoot.url;
-        }
-        else {
-            newRootUrl = await rebuildFolder(config.rootUrl, title);
-        }
-        dlog("nuclear new rootUrl=%s", newRootUrl);
-        await (0, config_js_1.writeConfig)(root, { ...config, rootUrl: newRootUrl });
+            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);
+        }
+        // Mutate the existing folder doc in place — same URL, new file leaves.
+        await shape.encode({
+            repo,
+            tree: newTree,
+            previousRoot: folderHandle,
+            title,
+        });
     }
     finally {
         await repo.shutdown();
@@ -263,28 +268,13 @@ async function save(cwd) {
 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);
@@ -296,25 +286,23 @@ async function commitWorkdir(cwd, { online }) {
             await shape.encode({ repo, tree: newTree, previousRoot: folderHandle });
         }
         if (online) {
-            // Always stamp lastSyncAt on a sync, regardless of whether the
-            // 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 });
-            }
+            // After peer changes have settled, refresh the folder doc so its
+            // pinned (artifact) leaves reference each file doc's current
+            // heads. Bare URLs already track current heads implicitly.
+            const refreshed = await refreshFolderPins(repo, folderHandle, shape, config.artifactDirectories);
+            // Always stamp lastSyncAt — a sync is also a checkpoint that
+            // "we reconciled with the server at this time" — and let any
+            // resulting changes flush.
+            stampLastSyncAt(folderHandle);
+            await (0, repo_js_1.waitForSync)(folderHandle, {
+                idleMs: 1500,
+                maxMs: refreshed ? 10000 : 5000,
+            });
         }
         const finalTree = await shape.decode({ repo, root: folderHandle });
         await materializeTree(repo, root, finalTree);
@@ -324,21 +312,71 @@ async function commitWorkdir(cwd, { online }) {
         await repo.shutdown();
     }
 }
+/**
+ * List the current Automerge heads for the root folder doc and every file
+ * leaf it references. Offline; never contacts a sync server.
+ *
+ * `pathspec` filters results: exact match, or prefix match against a folder
+ * (e.g. "src" or "src/" matches "src/index.ts"). Pass "/" to show only the
+ * root folder doc.
+ */
+async function heads(cwd, pathspec) {
+    const root = path.resolve(cwd);
+    const config = await (0, config_js_1.readConfig)(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 folderHandle = await repo.find(config.rootUrl);
+        const tree = await shape.decode({ repo, root: folderHandle });
+        const out = [];
+        const matches = (p) => matchesPathspec(p, pathspec);
+        if (matches("/")) {
+            out.push({
+                path: "/",
+                url: config.rootUrl,
+                heads: folderHandle.heads() ?? [],
+            });
+        }
+        for (const [posixPath, fileUrl] of (0, index_js_1.flattenLeaves)(tree)) {
+            if (!matches(posixPath))
+                continue;
+            const handle = await repo.find(fileUrl);
+            out.push({
+                path: posixPath,
+                url: fileUrl,
+                heads: handle.heads() ?? [],
+            });
+        }
+        out.sort((a, b) => a.path.localeCompare(b.path));
+        return out;
+    }
+    finally {
+        await repo.shutdown();
+    }
+}
+function matchesPathspec(path, spec) {
+    if (!spec)
+        return true;
+    if (spec === "/")
+        return path === "/";
+    const trimmed = spec.endsWith("/") ? spec.slice(0, -1) : spec;
+    if (path === trimmed)
+        return true;
+    return path.startsWith(trimmed + "/");
+}
 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();
@@ -347,12 +385,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);
@@ -381,309 +417,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;
-        });
-        // Switch to the new branch. The deep clone has identical content to the
-        // source, so the working tree on disk is already correct — we just
-        // update .pushwork/branch.
-        await (0, branches_js_1.writeBranchFile)(root, name);
-        dlog("createBranch switched to %s", name);
-        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);
@@ -692,13 +438,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),
                 });
             }
         }
@@ -710,35 +456,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);
@@ -751,13 +494,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 {
@@ -769,118 +512,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 };
+    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 showStashes(cwd) {
-    return (0, stash_js_1.listStashes)(path.resolve(cwd));
-}
-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`);
-        }
-        const stranded = !!currentName && !doc.branches[currentName];
-        // Refuse if the working dir has uncommitted changes against the current
-        // branch. The user can `pushwork save` to commit, or `pushwork cut` +
-        // `pushwork paste` to carry the changes across the switch.
-        if (currentName && !stranded) {
-            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\` to commit, or \`pushwork cut\` + \`pushwork switch ${name}\` + \`pushwork paste\` to carry them across.`);
-            }
-        }
-        // Materialize from the new branch.
-        const newFolder = await repo.find(doc.branches[name]);
-        const tree = await shape.decode({ repo, root: newFolder });
-        // Stranded: the current branch is gone, so we have no reference for a
-        // dirty check. Auto-cut working changes against the destination branch,
-        // materialize, then auto-paste so the user's work survives the switch.
-        let strandedStashId = null;
-        if (stranded) {
-            const newFiles = await readFileBytes(repo, tree);
-            const ig = await (0, ignore_js_1.loadIgnore)(root);
-            const fsFiles = await (0, fs_tree_js_1.walkDir)(root, ig);
-            const entries = [];
-            for (const [p, bytes] of fsFiles) {
-                const prev = newFiles.get(p);
-                if (!prev) {
-                    entries.push({ path: p, kind: "added", contentBase64: (0, stash_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) });
-                }
-            }
-            for (const [p] of newFiles) {
-                if (!fsFiles.has(p))
-                    entries.push({ path: p, kind: "deleted" });
-            }
-            if (entries.length > 0) {
-                entries.sort((a, b) => a.path.localeCompare(b.path));
-                const stash = await (0, stash_js_1.appendStash)(root, {
-                    name: `stranded-from-${currentName}`,
-                    branch: currentName,
-                    entries,
-                });
-                strandedStashId = stash.id;
-                process.stderr.write(`warning: branch "${currentName}" no longer exists; auto-cut ${entries.length} entr${entries.length === 1 ? "y" : "ies"} as stash #${stash.id} and will auto-paste after switch\n`);
-            }
-            else {
-                process.stderr.write(`warning: branch "${currentName}" no longer exists; switching (working tree already matches "${name}")\n`);
-            }
-        }
-        await materializeTree(repo, root, tree);
-        await (0, branches_js_1.writeBranchFile)(root, name);
-        dlog("switch → %s", name);
-        if (strandedStashId != null) {
-            const stash = await (0, stash_js_1.takeStash)(root, String(strandedStashId));
-            if (stash) {
-                for (const entry of stash.entries) {
-                    const target = path.join(root, fromPosix(entry.path));
-                    if (entry.kind === "deleted") {
-                        try {
-                            await fs.unlink(target);
-                        }
-                        catch {
-                            // already gone
-                        }
-                        await pruneEmptyDirs(root, path.dirname(fromPosix(entry.path)));
-                    }
-                    else if (entry.contentBase64 != null) {
-                        const bytes = (0, stash_js_1.decodeBytes)(entry.contentBase64);
-                        await (0, fs_tree_js_1.writeFileAtomic)(target, bytes);
-                    }
-                }
-                dlog("stranded auto-paste applied stash #%d (%d entries)", stash.id, stash.entries.length);
-            }
-        }
-    }
-    finally {
-        await repo.shutdown();
-    }
+async function showSnarfs(cwd) {
+    return (0, snarf_js_1.listSnarfs)(path.resolve(cwd));
 }
 function stampLastSyncAt(handle) {
     handle.change((d) => {
@@ -938,17 +578,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) => {
@@ -989,6 +625,34 @@ async function pushFiles(repo, fsFiles, previous, artifactDirs) {
     dlog("pushFiles done: %d created, %d updated, %d unchanged", created, updated, unchanged);
     return root;
 }
+/**
+ * Re-pin every artifact leaf in the folder doc to its file doc's current
+ * heads. Bare (non-artifact) URLs are left as-is since they already track
+ * current heads implicitly. Returns true if any leaf URL was rewritten.
+ */
+async function refreshFolderPins(repo, folderHandle, shape, artifactDirs) {
+    const tree = await shape.decode({ repo, root: folderHandle });
+    const refreshed = (0, index_js_1.newDir)();
+    let changed = false;
+    for (const [posixPath, currentUrl] of (0, index_js_1.flattenLeaves)(tree)) {
+        const segments = posixPath.split("/").filter(Boolean);
+        let finalUrl = currentUrl;
+        if ((0, index_js_1.isInArtifactDir)(posixPath, artifactDirs)) {
+            const handle = await repo.find((0, index_js_1.stripHeads)(currentUrl));
+            const repinned = (0, index_js_1.pinUrl)(handle);
+            if (repinned !== currentUrl) {
+                finalUrl = repinned;
+                changed = true;
+            }
+        }
+        (0, index_js_1.setFileAt)(refreshed, segments, finalUrl);
+    }
+    if (changed) {
+        dlog("refreshFolderPins: re-pinned artifacts to current heads");
+        await shape.encode({ repo, tree: refreshed, previousRoot: folderHandle });
+    }
+    return changed;
+}
 async function readFileBytes(repo, tree) {
     const out = new Map();
     for (const [posixPath, fileUrl] of (0, index_js_1.flattenLeaves)(tree)) {