pushwork 1.2.3 → 1.2.4

package/dist/pushwork.js

@@ -0,0 +1,726 @@
+"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.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.cutWorkdir = cutWorkdir;
+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 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 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 online = opts.online ?? true;
+    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}`);
+    }
+    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 title = path.basename(root) || undefined;
+        const tree = await pushFiles(repo, fsFiles, undefined, artifactDirs);
+        const folderUrl = await shape.encode({ repo, tree, title });
+        dlog("init encoded folder=%s title=%s", folderUrl, title);
+        const folderHandle = await repo.find(folderUrl);
+        if (online) {
+            await (0, repo_js_1.waitForSync)(folderHandle, { minMs: 3000, idleMs: 1500, maxMs: 15000 });
+            stampLastSyncAt(folderHandle);
+            await (0, repo_js_1.waitForSync)(folderHandle, { idleMs: 1500, maxMs: 10000 });
+        }
+        await (0, config_js_1.writeConfig)(root, {
+            version: config_js_1.CONFIG_VERSION,
+            rootUrl: folderUrl,
+            backend: opts.backend,
+            shape: opts.shape,
+            artifactDirectories: artifactDirs,
+        });
+        dlog("init complete: rootUrl=%s", folderUrl);
+        return folderUrl;
+    }
+    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);
+        let folderHandle = await repo.find(opts.url);
+        if (online) {
+            await (0, repo_js_1.waitForSync)(folderHandle, { idleMs: 1500, maxMs: 15000 });
+        }
+        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 });
+            }
+            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: storedUrl,
+            backend: opts.backend,
+            shape: opts.shape,
+            artifactDirectories: artifactDirs,
+        });
+        dlog("clone complete");
+    }
+    finally {
+        await repo.shutdown();
+    }
+}
+function asBranchesDoc(doc) {
+    if (!doc || typeof doc !== "object")
+        return null;
+    const meta = doc["@patchwork"];
+    if (!meta || typeof meta !== "object")
+        return null;
+    if (meta.type !== "branches")
+        return null;
+    const branches = doc.branches;
+    if (!branches || typeof branches !== "object")
+        return null;
+    return {
+        title: meta.title,
+        branches: branches,
+    };
+}
+async function url(cwd) {
+    const config = await (0, config_js_1.readConfig)(path.resolve(cwd));
+    return config.rootUrl;
+}
+async function sync(cwd, opts = {}) {
+    if (opts.nuclear) {
+        await nuclearizeRepo(cwd);
+        await publishCurrentTree(cwd);
+        return;
+    }
+    await commitWorkdir(cwd, { online: true });
+}
+/**
+ * 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.
+ *
+ * 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);
+    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 folderHandle = await repo.find(config.rootUrl);
+        const title = path.basename(root) || undefined;
+        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,
+            });
+            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();
+    }
+}
+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);
+    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 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 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) {
+            await (0, repo_js_1.waitForSync)(folderHandle, {
+                minMs: 3000,
+                idleMs: 1500,
+                maxMs: 15000,
+            });
+            // 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);
+        dlog("commit complete");
+    }
+    finally {
+        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 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 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 { 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 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 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();
+    }
+}
+/**
+ * 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);
+    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 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 entries = [];
+        for (const [p, bytes] of fsFiles) {
+            const prev = previousFiles.get(p);
+            if (!prev) {
+                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, snarf_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 snarf = await (0, snarf_js_1.appendSnarf)(root, {
+            name: opts.name,
+            entries,
+        });
+        // Reset working tree to the saved state.
+        await materializeTree(repo, root, previousTree);
+        dlog("cut complete id=%d entries=%d", snarf.id, entries.length);
+        return { id: snarf.id, entries: entries.length };
+    }
+    finally {
+        await repo.shutdown();
+    }
+}
+/**
+ * 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 pasteSnarf(cwd, selector) {
+    const root = path.resolve(cwd);
+    const config = await (0, config_js_1.readConfig)(root);
+    // 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 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 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 snarf = await (0, snarf_js_1.takeSnarf)(root, selector);
+    if (!snarf) {
+        throw new Error(selector
+            ? `no snarf matches "${selector}"`
+            : "nothing to paste: no snarfs");
+    }
+    for (const entry of snarf.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, snarf_js_1.decodeBytes)(entry.contentBase64);
+            await (0, fs_tree_js_1.writeFileAtomic)(target, bytes);
+        }
+    }
+    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 showSnarfs(cwd) {
+    return (0, snarf_js_1.listSnarfs)(path.resolve(cwd));
+}
+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 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.
+            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;
+}
+/**
+ * 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)) {
+        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