pushwork 2.0.0-a.sub.1 → 2.0.0-preview

package/dist/pushwork.js

@@ -0,0 +1,918 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteBranchFile = void 0;
+exports.init = init;
+exports.clone = clone;
+exports.url = url;
+exports.sync = sync;
+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;
+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 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);
+    if (await (0, config_js_1.configExists)(root)) {
+        throw new Error(`pushwork already initialized at ${root}`);
+    }
+    const artifactDirs = normalizeDirs(opts.artifactDirectories ?? DEFAULT_ARTIFACT_DIRECTORIES);
+    dlog("init artifactDirs=%o", artifactDirs);
+    await fs.mkdir((0, config_js_1.pushworkDir)(root), { recursive: true });
+    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 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 tree = await pushFiles(repo, fsFiles, undefined, artifactDirs);
+        const folderUrl = await shape.encode({ repo, tree });
+        dlog("init encoded folder=%s", folderUrl);
+        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,
+            backend: opts.backend,
+            shape: opts.shape,
+            artifactDirectories: artifactDirs,
+            branches: useBranches,
+        });
+        dlog("init complete: rootUrl=%s", rootUrl);
+        return rootUrl;
+    }
+    finally {
+        await repo.shutdown();
+    }
+}
+async function clone(opts) {
+    if (!(0, automerge_repo_1.isValidAutomergeUrl)(opts.url)) {
+        throw new Error(`invalid automerge URL: ${opts.url}`);
+    }
+    const root = path.resolve(opts.dir);
+    dlog("clone url=%s root=%s backend=%s shape=%s", opts.url, root, opts.backend, opts.shape);
+    await fs.mkdir(root, { recursive: true });
+    if (await (0, config_js_1.configExists)(root)) {
+        throw new Error(`pushwork already initialized at ${root}`);
+    }
+    const artifactDirs = normalizeDirs(opts.artifactDirectories ?? DEFAULT_ARTIFACT_DIRECTORIES);
+    await fs.mkdir((0, config_js_1.pushworkDir)(root), { recursive: true });
+    const online = opts.online ?? true;
+    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);
+        if (online) {
+            await (0, repo_js_1.waitForSync)(rootHandle, { 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);
+            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})`);
+        }
+        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,
+            backend: opts.backend,
+            shape: opts.shape,
+            artifactDirectories: artifactDirs,
+            branches: useBranches,
+        });
+        dlog("clone complete");
+    }
+    finally {
+        await repo.shutdown();
+    }
+}
+async function url(cwd) {
+    const config = await (0, config_js_1.readConfig)(path.resolve(cwd));
+    return config.rootUrl;
+}
+async function sync(cwd) {
+    await commitWorkdir(cwd, { online: true });
+}
+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);
+    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 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 newTree = await pushFiles(repo, fsFiles, previousFiles, config.artifactDirectories);
+        const changed = !sameTree(previousTree, newTree);
+        dlog("commit tree changed: %s", changed);
+        if (changed) {
+            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 });
+            }
+        }
+        const finalTree = await shape.decode({ repo, root: folderHandle });
+        await materializeTree(repo, root, finalTree);
+        dlog("commit complete");
+    }
+    finally {
+        await repo.shutdown();
+    }
+}
+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 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 };
+    }
+    finally {
+        await repo.shutdown();
+    }
+}
+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 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 out = [];
+        for (const [p, bytes] of fsFiles) {
+            if (limitToPath && p !== limitToPath)
+                continue;
+            const prev = previousFiles.get(p);
+            if (!prev) {
+                out.push({ path: p, kind: "added", after: bytes });
+            }
+            else if (!(0, fs_tree_js_1.byteEq)(prev.bytes, bytes)) {
+                out.push({ path: p, kind: "modified", before: prev.bytes, after: bytes });
+            }
+        }
+        for (const [p, prev] of previousFiles) {
+            if (limitToPath && p !== limitToPath)
+                continue;
+            if (!fsFiles.has(p))
+                out.push({ path: p, kind: "deleted", before: prev.bytes });
+        }
+        return out;
+    }
+    finally {
+        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.
+ */
+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)");
+    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 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 entries = [];
+        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) });
+            }
+            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 previousFiles) {
+            if (!fsFiles.has(p))
+                entries.push({ path: p, kind: "deleted" });
+        }
+        if (entries.length === 0) {
+            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, {
+            name: opts.name,
+            branch: branchName,
+            entries,
+        });
+        // Reset working tree to the branch's 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 };
+    }
+    finally {
+        await repo.shutdown();
+    }
+}
+/**
+ * Apply a stash on top of the current working tree, then remove the stash
+ * entry. Refuses if the working tree has uncommitted changes (caller can
+ * `pushwork save` or `pushwork cut` first).
+ */
+async function pasteStash(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.
+    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 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 dirty = computeDiff(previousFiles, fsFiles);
+        if (dirty.added.length || dirty.modified.length || dirty.deleted.length) {
+            throw new Error("refusing to paste: working tree has uncommitted changes. run `pushwork save` or `pushwork cut` first.");
+        }
+    }
+    finally {
+        await repo.shutdown();
+    }
+    const stash = await (0, stash_js_1.takeStash)(root, selector);
+    if (!stash) {
+        throw new Error(selector
+            ? `no stash matches "${selector}"`
+            : "nothing to paste: no stashes");
+    }
+    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("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));
+}
+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();
+    }
+}
+function stampLastSyncAt(handle) {
+    handle.change((d) => {
+        d.lastSyncAt = Date.now();
+    });
+}
+function normalizeDirs(dirs) {
+    const seen = new Set();
+    const out = [];
+    for (const d of dirs) {
+        const norm = (0, index_js_1.normalizeArtifactDir)(d);
+        if (!norm || seen.has(norm))
+            continue;
+        seen.add(norm);
+        out.push(norm);
+    }
+    return out;
+}
+function computeDiff(previous, current) {
+    const added = [];
+    const modified = [];
+    const deleted = [];
+    for (const [p, bytes] of current) {
+        const prev = previous.get(p);
+        if (!prev)
+            added.push(p);
+        else if (!(0, fs_tree_js_1.byteEq)(prev.bytes, bytes))
+            modified.push(p);
+    }
+    for (const p of previous.keys()) {
+        if (!current.has(p))
+            deleted.push(p);
+    }
+    added.sort();
+    modified.sort();
+    deleted.sort();
+    return { added, modified, deleted };
+}
+async function pushFiles(repo, fsFiles, previous, artifactDirs) {
+    const root = (0, index_js_1.newDir)();
+    let created = 0;
+    let updated = 0;
+    let unchanged = 0;
+    for (const [posixPath, bytes] of fsFiles) {
+        const segments = posixPath.split("/").filter(Boolean);
+        const isArtifact = (0, index_js_1.isInArtifactDir)(posixPath, artifactDirs);
+        const fresh = (0, index_js_1.makeFileEntry)(posixPath, bytes, isArtifact);
+        const prev = previous?.get(posixPath);
+        let baseUrl;
+        if (prev && (0, fs_tree_js_1.byteEq)(prev.bytes, bytes)) {
+            // Unchanged path: keep the existing file-doc URL. For artifacts
+            // we'll re-pin from the current heads below.
+            baseUrl = (0, index_js_1.stripHeads)(prev.url);
+            unchanged++;
+        }
+        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
+            // 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) => {
+                if (!(0, index_js_1.contentEquals)(d.content, fresh.content)) {
+                    if (typeof d.content === "string" &&
+                        typeof fresh.content === "string") {
+                        Automerge.updateText(d, ["content"], fresh.content);
+                    }
+                    else {
+                        d.content = fresh.content;
+                    }
+                }
+                if (d.extension !== fresh.extension)
+                    d.extension = fresh.extension;
+                if (d.mimeType !== fresh.mimeType)
+                    d.mimeType = fresh.mimeType;
+                if (d.name !== fresh.name)
+                    d.name = fresh.name;
+                if (!d["@patchwork"])
+                    d["@patchwork"] = { type: "file" };
+            });
+            baseUrl = refreshUrl;
+            updated++;
+            dlog("pushFiles updated %s url=%s artifact=%s bytes=%d", posixPath, baseUrl, isArtifact, bytes.length);
+        }
+        else {
+            // New path: create a fresh file doc.
+            const handle = repo.create(fresh);
+            baseUrl = handle.url;
+            created++;
+            dlog("pushFiles created %s url=%s artifact=%s bytes=%d", posixPath, baseUrl, isArtifact, bytes.length);
+        }
+        const finalUrl = isArtifact
+            ? (0, index_js_1.pinUrl)(await repo.find(baseUrl))
+            : baseUrl;
+        (0, index_js_1.setFileAt)(root, segments, finalUrl);
+    }
+    dlog("pushFiles done: %d created, %d updated, %d unchanged", created, updated, unchanged);
+    return root;
+}
+async function readFileBytes(repo, tree) {
+    const out = new Map();
+    for (const [posixPath, fileUrl] of (0, index_js_1.flattenLeaves)(tree)) {
+        const handle = await repo.find(fileUrl);
+        out.set(posixPath, {
+            url: fileUrl,
+            bytes: (0, index_js_1.contentToBytes)(handle.doc().content),
+        });
+    }
+    return out;
+}
+async function materializeTree(repo, root, tree) {
+    const desired = new Map();
+    for (const [posixPath, fileUrl] of (0, index_js_1.flattenLeaves)(tree)) {
+        const handle = await repo.find(fileUrl);
+        desired.set(posixPath, (0, index_js_1.contentToBytes)(handle.doc().content));
+    }
+    dlog("materialize desired: %d files", desired.size);
+    const ig = await (0, ignore_js_1.loadIgnore)(root);
+    const present = await (0, fs_tree_js_1.walkDir)(root, ig);
+    let written = 0;
+    let removed = 0;
+    for (const [posixPath, bytes] of desired) {
+        if ((0, fs_tree_js_1.byteEq)(present.get(posixPath), bytes))
+            continue;
+        await (0, fs_tree_js_1.writeFileAtomic)(path.join(root, fromPosix(posixPath)), bytes);
+        written++;
+    }
+    for (const posixPath of present.keys()) {
+        if (desired.has(posixPath))
+            continue;
+        try {
+            await fs.unlink(path.join(root, fromPosix(posixPath)));
+            removed++;
+        }
+        catch {
+            // already gone
+        }
+        await pruneEmptyDirs(root, path.dirname(fromPosix(posixPath)));
+    }
+    dlog("materialize done: %d written, %d removed", written, removed);
+}
+const fromPosix = (p) => p.split("/").join(path.sep);
+async function pruneEmptyDirs(root, relDir) {
+    let dir = relDir;
+    while (dir && dir !== "." && dir !== path.sep) {
+        const full = path.join(root, dir);
+        try {
+            const entries = await fs.readdir(full);
+            if (entries.length > 0)
+                return;
+            await fs.rmdir(full);
+        }
+        catch {
+            return;
+        }
+        dir = path.dirname(dir);
+    }
+}
+function sameTree(a, b) {
+    const av = (0, index_js_1.flattenLeaves)(a);
+    const bv = (0, index_js_1.flattenLeaves)(b);
+    if (av.size !== bv.size)
+        return false;
+    for (const [k, v] of av) {
+        if (bv.get(k) !== v)
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=pushwork.js.map