@coderook/cli 0.31.13 → 0.32.0

package/dist/cbx/src/local/repository.js

@@ -0,0 +1,324 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = exports.DEFAULT_LINE = exports.FORMAT_LINE = exports.STORE_DIRECTORY = void 0;
+exports.lineNameProblem = lineNameProblem;
+/**
+ * A local history: the `.cbx/` folder at the top of a project.
+ *
+ *   .cbx/format          "cbx-local 1", so a later layout can tell an older one
+ *   .cbx/objects/        the object store (see store.ts)
+ *   .cbx/lines/<name>    the id of the newest save on each line of work
+ *   .cbx/state.json      which line the folder is on
+ *   .cbx/config.json     the author name saves carry, and later the remotes
+ *   .cbx/index.json      what each file looked like when it was last read
+ *   .cbx/lock            present while something is writing
+ *
+ * A save is a JSON object naming a tree, its parents and who made it; its id
+ * is the digest of those bytes. A tree lists every file with its size, digest,
+ * whether it runs, and the objects its bytes are split into. Nothing in a save
+ * or a tree depends on the machine it was made on, so two people who make the
+ * same save from the same files get the same id.
+ */
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const store_js_1 = require("./store.js");
+exports.STORE_DIRECTORY = ".cbx";
+exports.FORMAT_LINE = "cbx-local 1";
+exports.DEFAULT_LINE = "main";
+/**
+ * Line names are file names under `.cbx/lines`, so they are held to what is
+ * safe as one on every platform: letters, digits, `.`, `_` and `-`, not
+ * starting with a dot, and not something Windows reserves.
+ */
+function lineNameProblem(name) {
+    if (!name)
+        return "a line needs a name";
+    if (name.length > 100)
+        return "that name is longer than 100 characters";
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(name)) {
+        return "use letters, digits, '.', '_' and '-', starting with a letter or digit";
+    }
+    if (name.endsWith(".") || name.includes(".."))
+        return "that name has a stray dot";
+    if (/^(con|prn|aux|nul|com\d|lpt\d)(\.|$)/i.test(name)) {
+        return "Windows reserves that name";
+    }
+    if (name.endsWith(".partial"))
+        return "names ending .partial are how cbx marks unfinished writes";
+    return null;
+}
+async function writeAtomically(target, contents) {
+    const partial = `${target}.partial`;
+    await (0, promises_1.writeFile)(partial, contents);
+    await (0, promises_1.rename)(partial, target);
+}
+async function exists(where) {
+    try {
+        await (0, promises_1.stat)(where);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+class Repository {
+    root;
+    directory;
+    objects;
+    constructor(root) {
+        this.root = root;
+        this.directory = node_path_1.default.join(root, exports.STORE_DIRECTORY);
+        this.objects = new store_js_1.ObjectStore(node_path_1.default.join(this.directory, "objects"));
+    }
+    /** Start a history in `root`. Refuses a folder that already has one. */
+    static async init(root, line = exports.DEFAULT_LINE) {
+        const problem = lineNameProblem(line);
+        if (problem)
+            throw new Error(`Cannot name a line "${line}": ${problem}.`);
+        const full = node_path_1.default.resolve(root);
+        const directory = node_path_1.default.join(full, exports.STORE_DIRECTORY);
+        if (await exists(directory)) {
+            throw new Error(`${full} already has a history (${exports.STORE_DIRECTORY}/).`);
+        }
+        await (0, promises_1.mkdir)(node_path_1.default.join(directory, "objects"), { recursive: true });
+        await (0, promises_1.mkdir)(node_path_1.default.join(directory, "lines"), { recursive: true });
+        await (0, promises_1.writeFile)(node_path_1.default.join(directory, "format"), `${exports.FORMAT_LINE}\n`);
+        await (0, promises_1.writeFile)(node_path_1.default.join(directory, "state.json"), JSON.stringify({ line }));
+        await (0, promises_1.writeFile)(node_path_1.default.join(directory, "config.json"), "{}");
+        return new Repository(full);
+    }
+    /** The history `from` is inside, looking upward; null when there is none. */
+    static async find(from) {
+        let at = node_path_1.default.resolve(from);
+        for (;;) {
+            const directory = node_path_1.default.join(at, exports.STORE_DIRECTORY);
+            if (await exists(node_path_1.default.join(directory, "format"))) {
+                const format = (await (0, promises_1.readFile)(node_path_1.default.join(directory, "format"), "utf8")).trim();
+                if (format !== exports.FORMAT_LINE) {
+                    throw new Error(`${directory} is in a format this cbx does not read (${format}). Update cbx.`);
+                }
+                return new Repository(at);
+            }
+            const parent = node_path_1.default.dirname(at);
+            if (parent === at)
+                return null;
+            at = parent;
+        }
+    }
+    static async open(from) {
+        const found = await Repository.find(from);
+        if (!found) {
+            throw new Error(`No history here. Run \`cbx init\` in the project folder to start one.`);
+        }
+        return found;
+    }
+    /* ---- lines and state ------------------------------------------------ */
+    async currentLine() {
+        const state = JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(this.directory, "state.json"), "utf8"));
+        return state.line;
+    }
+    async setCurrentLine(line) {
+        await writeAtomically(node_path_1.default.join(this.directory, "state.json"), JSON.stringify({ line }));
+    }
+    /** The newest save on `line`, or null for a line with nothing saved yet. */
+    async lineTip(line) {
+        if (lineNameProblem(line))
+            return null;
+        try {
+            const id = (await (0, promises_1.readFile)(node_path_1.default.join(this.directory, "lines", line), "utf8")).trim();
+            return store_js_1.DIGEST.test(id) ? id : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async setLineTip(line, id) {
+        const problem = lineNameProblem(line);
+        if (problem)
+            throw new Error(`Cannot name a line "${line}": ${problem}.`);
+        await writeAtomically(node_path_1.default.join(this.directory, "lines", line), `${id}\n`);
+    }
+    async lineExists(line) {
+        return !lineNameProblem(line) && (await exists(node_path_1.default.join(this.directory, "lines", line)));
+    }
+    async lines() {
+        const names = await (0, promises_1.readdir)(node_path_1.default.join(this.directory, "lines")).catch(() => []);
+        const found = [];
+        for (const name of names.sort()) {
+            const tip = await this.lineTip(name);
+            if (tip)
+                found.push({ name, tip });
+        }
+        return found;
+    }
+    /** The save the folder was last saved or switched to, or null before the first. */
+    async head() {
+        return this.lineTip(await this.currentLine());
+    }
+    /* ---- config --------------------------------------------------------- */
+    async config() {
+        try {
+            return JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(this.directory, "config.json"), "utf8"));
+        }
+        catch {
+            return {};
+        }
+    }
+    async setConfig(change) {
+        const next = { ...(await this.config()), ...change };
+        await writeAtomically(node_path_1.default.join(this.directory, "config.json"), JSON.stringify(next, null, 2));
+    }
+    /**
+     * Who a save says made it: the history's own setting, then CBX_AUTHOR,
+     * then the account name on this machine. Only ever written into the save.
+     */
+    async author() {
+        const configured = (await this.config()).author?.trim();
+        if (configured)
+            return configured;
+        const fromEnvironment = process.env.CBX_AUTHOR?.trim();
+        if (fromEnvironment)
+            return fromEnvironment;
+        try {
+            return node_os_1.default.userInfo().username || "unknown";
+        }
+        catch {
+            return "unknown";
+        }
+    }
+    /* ---- saves and trees ------------------------------------------------ */
+    async readSave(id) {
+        const record = await this.objects.getJson(id);
+        if (record.format !== "cbx-save")
+            throw new Error(`${id.slice(0, 10)} is not a save.`);
+        return { ...record, id };
+    }
+    async readTree(id) {
+        const tree = await this.objects.getJson(id);
+        if (tree.format !== "cbx-tree")
+            throw new Error(`${id.slice(0, 10)} is not a tree.`);
+        return tree;
+    }
+    async writeSave(record) {
+        /* Keys in a fixed order, so the same save is the same bytes everywhere. */
+        const canonical = {
+            format: "cbx-save",
+            version: 1,
+            tree: record.tree,
+            parents: record.parents,
+            line: record.line,
+            message: record.message,
+            author: record.author,
+            created: record.created,
+        };
+        const id = await this.objects.putJson(canonical);
+        return { ...canonical, id };
+    }
+    async writeTree(files) {
+        const sorted = [...files].sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+        const tree = {
+            format: "cbx-tree",
+            version: 1,
+            files: sorted.map((file) => ({
+                path: file.path,
+                size: file.size,
+                sha256: file.sha256,
+                executable: file.executable,
+                chunks: file.chunks,
+            })),
+        };
+        return this.objects.putJson(tree);
+    }
+    /**
+     * The save a name refers to.
+     *
+     * A line name, a line name followed by `~N` for N saves back along first
+     * parents, or at least four characters of a save id. Ambiguous or unknown
+     * names are refused with the reason.
+     */
+    async resolve(name) {
+        const back = /^(.*?)~(\d*)$/.exec(name);
+        const base = back ? back[1] : name;
+        const steps = back ? Number(back[2] || "1") : 0;
+        let id = null;
+        if (base === "" || base === "HEAD") {
+            id = await this.head();
+            if (!id)
+                throw new Error("Nothing has been saved on this line yet.");
+        }
+        else if (await this.lineExists(base)) {
+            id = await this.lineTip(base);
+        }
+        else if (/^[0-9a-f]{4,64}$/.test(base)) {
+            const candidates = [];
+            for (const candidate of await this.objects.matching(base)) {
+                try {
+                    await this.readSave(candidate);
+                    candidates.push(candidate);
+                }
+                catch {
+                    /* A tree or a piece of a file, not a save. */
+                }
+            }
+            if (candidates.length > 1) {
+                throw new Error(`"${base}" could be any of ${candidates.length} saves; give more of it.`);
+            }
+            id = candidates[0] ?? null;
+        }
+        if (!id)
+            throw new Error(`No line or save called "${base}".`);
+        let save = await this.readSave(id);
+        for (let step = 0; step < steps; step += 1) {
+            const parent = save.parents[0];
+            if (!parent)
+                throw new Error(`"${name}" goes back further than the line does.`);
+            save = await this.readSave(parent);
+        }
+        return save;
+    }
+    /* ---- the index ------------------------------------------------------ */
+    async readIndex() {
+        try {
+            const raw = JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(this.directory, "index.json"), "utf8"));
+            return new Map(Object.entries(raw));
+        }
+        catch {
+            return new Map();
+        }
+    }
+    async writeIndex(index) {
+        await writeAtomically(node_path_1.default.join(this.directory, "index.json"), JSON.stringify(Object.fromEntries(index)));
+    }
+    /* ---- the lock ------------------------------------------------------- */
+    /**
+     * Run `work` while holding `.cbx/lock`.
+     *
+     * Two saves at once would each move the line to their own save and one
+     * would be lost. A lock left behind by a crash is not cleared by guessing:
+     * the message names the file so a person can remove it.
+     */
+    async locked(work) {
+        const lock = node_path_1.default.join(this.directory, "lock");
+        let handle;
+        try {
+            handle = await (0, promises_1.open)(lock, "wx");
+        }
+        catch {
+            throw new Error(`Another cbx command is using this history. If none is running, delete ${lock} and try again.`);
+        }
+        await handle.write(`${process.pid}\n`);
+        await handle.close();
+        try {
+            return await work();
+        }
+        finally {
+            await this.objects.release();
+            await (0, promises_1.rm)(lock, { force: true });
+        }
+    }
+}
+exports.Repository = Repository;

package/dist/cbx/src/local/snapshot.js

@@ -0,0 +1,338 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inLanes = inLanes;
+exports.listFolder = listFolder;
+exports.storeFile = storeFile;
+exports.readFolder = readFolder;
+exports.contentsOf = contentsOf;
+exports.checkout = checkout;
+exports.sameFile = sameFile;
+exports.writeEntriesInto = writeEntriesInto;
+/**
+ * Between a folder and a tree: reading one into the other, and back.
+ *
+ * Which files count is decided the way CodeRook decides it — the folder's
+ * ignore rules, read by `readRules` and walked by `surveyFiles` — so a local
+ * save and a save sent to CodeRook hold the same files.
+ */
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const worktree_js_1 = require("../core/worktree.js");
+const chunking_js_1 = require("../shared/chunking.js");
+const safe_path_js_1 = require("../shared/safe_path.js");
+const READ_SIZE = 8 * 1024 * 1024;
+/*
+  How close to now a modification time has to be before it is not trusted.
+
+  A file written in the same instant the index records it can be written
+  again without its time moving, and the index would then vouch for bytes
+  that are no longer there. Git calls these racily clean. Anything this
+  recent is simply read again next time.
+*/
+const RACY_WINDOW_MS = 2_000;
+/*
+  How many files are worked on at once.
+
+  One at a time, a save of twenty thousand small files took seventy-seven
+  seconds, almost all of it waiting on the disk between one small request and
+  the next. Files over eight megabytes get far fewer lanes, because each one
+  holds up to forty megabytes while it is being cut.
+*/
+const SMALL_LANES = 16;
+const LARGE_LANES = 2;
+/** Run `work` over `items`, `count` at a time. */
+async function inLanes(items, count, work) {
+    let at = 0;
+    const lane = async () => {
+        while (at < items.length) {
+            const item = items[at];
+            at += 1;
+            await work(item);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(count, items.length) }, () => lane()));
+}
+/** The files the rules would save, with what `stat` says about each. */
+async function listFolder(root) {
+    const rules = await (0, worktree_js_1.readRules)(root);
+    const found = await (0, worktree_js_1.surveyFiles)(root, rules);
+    const files = [];
+    await inLanes(found, SMALL_LANES, async (one) => {
+        try {
+            const info = await (0, promises_1.stat)(node_path_1.default.join(root, one.path));
+            files.push({ path: one.path, size: info.size, mtimeMs: info.mtimeMs, mode: info.mode });
+        }
+        catch {
+            /* Gone since the walk; it is not in the folder any more. */
+        }
+    });
+    return files.sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
+}
+function executableFrom(mode, previous) {
+    /* Windows has no execute bit to read, so whatever was saved last stands. */
+    if (process.platform === "win32")
+        return previous?.executable ?? false;
+    return (mode & 0o100) !== 0;
+}
+/** A file's digest, streamed so a large one is never held whole. */
+async function digestFile(full, size) {
+    /*
+      Read whole when small. A stream asks for its full window up front, and
+      an eight megabyte window per file turned hashing twenty thousand small
+      files into forty-five seconds of allocating memory nobody used.
+    */
+    if (size <= READ_SIZE)
+        return (0, node_crypto_1.createHash)("sha256").update(await (0, promises_1.readFile)(full)).digest("hex");
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    for await (const block of (0, node_fs_1.createReadStream)(full, { highWaterMark: READ_SIZE })) {
+        hash.update(block);
+    }
+    return hash.digest("hex");
+}
+/**
+ * Read a file into the store: its digest, and the objects its bytes become.
+ *
+ * Under eight megabytes a file is one object. Above, it is cut where its
+ * content says to, with the same profile a CodeRook upload uses for a file
+ * that size, so an edit in the middle of a large asset stores the pieces
+ * around the edit and reuses the rest.
+ */
+async function storeFile(repository, full, size) {
+    const profile = (0, chunking_js_1.profileForFileSize)(size);
+    if (!profile) {
+        const bytes = await (0, promises_1.readFile)(full);
+        const digest = await repository.objects.put(bytes);
+        return { sha256: digest, chunks: bytes.length ? [digest] : [] };
+    }
+    const whole = (0, node_crypto_1.createHash)("sha256");
+    const chunks = [];
+    let pending = Buffer.alloc(0);
+    for await (const piece of (0, node_fs_1.createReadStream)(full, { highWaterMark: READ_SIZE })) {
+        const block = piece;
+        whole.update(block);
+        pending = pending.length ? Buffer.concat([pending, block]) : Buffer.from(block);
+        let from = 0;
+        for (const cut of (0, chunking_js_1.cutPoints)(pending, profile)) {
+            chunks.push(await repository.objects.put(Buffer.from(pending.subarray(from, cut))));
+            from = cut;
+        }
+        pending = pending.subarray(from);
+    }
+    if (pending.length)
+        chunks.push(await repository.objects.put(Buffer.from(pending)));
+    return { sha256: whole.digest("hex"), chunks };
+}
+/**
+ * What the folder holds now.
+ *
+ * With `store` the bytes of every changed file go into the object store and
+ * each entry carries its objects, ready to become a tree. Without, files are
+ * only hashed, which is all a status or a diff needs, and nothing is written.
+ * Either way a file whose size and time match the index is not read at all.
+ */
+async function readFolder(repository, options) {
+    const index = await repository.readIndex();
+    const previous = new Map(options.previous?.files.map((file) => [file.path, file]) ?? []);
+    const listed = await listFolder(repository.root);
+    const files = new Map();
+    const next = new Map();
+    const racyBefore = Date.now() - RACY_WINDOW_MS;
+    let done = 0;
+    const one = async (file) => {
+        const full = node_path_1.default.join(repository.root, file.path);
+        const known = index.get(file.path);
+        let sha256;
+        let chunks = [];
+        const unchanged = known &&
+            known.size === file.size &&
+            known.mtimeMs === file.mtimeMs &&
+            (!options.store || known.chunks.length > 0 || file.size === 0);
+        if (unchanged) {
+            sha256 = known.sha256;
+            chunks = known.chunks;
+        }
+        else if (options.store) {
+            ({ sha256, chunks } = await storeFile(repository, full, file.size));
+        }
+        else {
+            sha256 = await digestFile(full, file.size);
+        }
+        files.set(file.path, {
+            path: file.path,
+            size: file.size,
+            sha256,
+            executable: executableFrom(file.mode, previous.get(file.path)),
+            chunks,
+        });
+        if (file.mtimeMs < racyBefore) {
+            next.set(file.path, { size: file.size, mtimeMs: file.mtimeMs, sha256, chunks });
+        }
+        done += 1;
+        options.progress?.(done, listed.length, file.path);
+    };
+    const large = (file) => (0, chunking_js_1.profileForFileSize)(file.size) !== null;
+    await Promise.all([
+        inLanes(listed.filter((file) => !large(file)), SMALL_LANES, one),
+        inLanes(listed.filter(large), LARGE_LANES, one),
+    ]);
+    /* Nothing may name an object that is not on disk yet. */
+    if (options.store)
+        await repository.objects.flush();
+    options.progress?.(listed.length, listed.length, "");
+    return { files, index: next };
+}
+/** A tree entry's bytes, put back together from the store and checked. */
+async function contentsOf(repository, entry) {
+    const pieces = [];
+    for (const chunk of entry.chunks)
+        pieces.push(await repository.objects.get(chunk));
+    const contents = Buffer.concat(pieces);
+    if (contents.length !== entry.size ||
+        (0, node_crypto_1.createHash)("sha256").update(contents).digest("hex") !== entry.sha256) {
+        throw new Error(`${entry.path} in the history does not match its record.`);
+    }
+    return contents;
+}
+/**
+ * Write one tree entry into the folder.
+ *
+ * Assembled beside the file and renamed over it, so a failure part-way
+ * leaves the old file rather than half of the new one. Pieces are streamed to
+ * disk one at a time, and the digest is checked before the rename.
+ */
+async function writeEntry(repository, root, entry, folders) {
+    /* Refuses `..`, absolute paths, `.git` and `.cbx`; see safe_path.ts. */
+    const full = (0, safe_path_js_1.inside)(root, entry.path);
+    /* Each folder made once, however many files land in it. */
+    const folder = node_path_1.default.dirname(full);
+    let making = folders.get(folder);
+    if (!making) {
+        making = (0, promises_1.mkdir)(folder, { recursive: true });
+        folders.set(folder, making);
+    }
+    await making;
+    const partial = `${full}.${(0, node_crypto_1.randomBytes)(6).toString("hex")}.cbx-partial`;
+    const finish = async () => {
+        if (process.platform !== "win32") {
+            await (0, promises_1.chmod)(partial, entry.executable ? 0o755 : 0o644);
+        }
+        /* Replaces what is there in one step; removing it first left a gap. */
+        await (0, promises_1.rename)(partial, full);
+    };
+    if (entry.chunks.length <= 1) {
+        const raw = entry.chunks.length ? await repository.objects.get(entry.chunks[0]) : Buffer.alloc(0);
+        if (raw.length !== entry.size || (0, node_crypto_1.createHash)("sha256").update(raw).digest("hex") !== entry.sha256) {
+            throw new Error(`${entry.path} in the history does not match its record.`);
+        }
+        /*
+          Nothing there yet, so nothing to leave half-replaced: written straight
+          to its name, which is a third of the cost of writing beside it and
+          renaming. An interrupted write leaves a file that no longer matches,
+          which the next status reports and a restore puts right.
+        */
+        try {
+            await (0, promises_1.writeFile)(full, raw, { flag: "wx", mode: entry.executable ? 0o755 : 0o644 });
+            return;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        try {
+            await (0, promises_1.writeFile)(partial, raw);
+            await finish();
+        }
+        catch (error) {
+            await (0, promises_1.rm)(partial, { force: true });
+            throw error;
+        }
+        return;
+    }
+    const handle = await (0, promises_1.open)(partial, "w");
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    let written = 0;
+    try {
+        for (const chunk of entry.chunks) {
+            const raw = await repository.objects.get(chunk);
+            hash.update(raw);
+            await handle.write(raw, 0, raw.length, written);
+            written += raw.length;
+        }
+        await handle.close();
+        if (written !== entry.size || hash.digest("hex") !== entry.sha256) {
+            throw new Error(`${entry.path} in the history does not match its record.`);
+        }
+        await finish();
+    }
+    catch (error) {
+        await handle.close().catch(() => undefined);
+        await (0, promises_1.rm)(partial, { force: true });
+        throw error;
+    }
+}
+/** Remove folders this left empty, stopping at the root or the first one in use. */
+async function pruneEmpty(root, from) {
+    let at = node_path_1.default.dirname(from);
+    const base = node_path_1.default.resolve(root);
+    while (at.startsWith(base + node_path_1.default.sep)) {
+        try {
+            if ((await (0, promises_1.readdir)(at)).length)
+                return;
+            await (0, promises_1.rmdir)(at);
+        }
+        catch {
+            return;
+        }
+        at = node_path_1.default.dirname(at);
+    }
+}
+/**
+ * Make the folder's files match `to`, where they are currently `from`.
+ *
+ * Only what differs is touched: a file identical in both is left exactly as
+ * it is, and a file in neither — anything the history does not hold — is
+ * never looked at. `only`, when given, limits the change to those paths.
+ */
+async function checkout(repository, from, to, only) {
+    const target = new Map(to.files.map((file) => [file.path, file]));
+    const written = [];
+    const removed = [];
+    const changed = to.files.filter((entry) => {
+        if (only && !only(entry.path))
+            return false;
+        return !sameFile(from.get(entry.path), entry);
+    });
+    const folders = new Map();
+    await inLanes(changed, SMALL_LANES, async (entry) => {
+        await writeEntry(repository, repository.root, entry, folders);
+        written.push(entry.path);
+    });
+    written.sort();
+    for (const file of from.keys()) {
+        if (target.has(file) || (only && !only(file)))
+            continue;
+        const full = (0, safe_path_js_1.inside)(repository.root, file);
+        await (0, promises_1.rm)(full, { force: true });
+        await pruneEmpty(repository.root, full);
+        removed.push(file);
+    }
+    return { written, removed };
+}
+/** Whether two entries hold the same file, bytes and execute bit alike. */
+function sameFile(left, right) {
+    return (!!left && !!right && left.sha256 === right.sha256 && left.executable === right.executable);
+}
+/**
+ * Write entries into a folder other than the project: the scratch tree a
+ * push sends from. Nothing there is checked against unsaved work, because
+ * nothing there is anybody's work.
+ */
+async function writeEntriesInto(repository, root, entries) {
+    const folders = new Map();
+    await inLanes(entries, SMALL_LANES, (entry) => writeEntry(repository, root, entry, folders));
+}