@claudexor/workspace 4.8.2 → 5.0.1

package/dist/object-materialize.js

@@ -0,0 +1,467 @@
+import { copyFileSync, existsSync, lstatSync, mkdtempSync, readlinkSync, renameSync, rmSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { classifyGitFailure, diskProgress, gitObserved, GitOperationError, proofStallMs, } from "./git-observed.js";
+import { withDisposableScratch } from "./cleanup-fault.js";
+import { lstatPresent } from "./fs-presence.js";
+import { SCRATCH_INDEX_CONFIG, STAT_TRUST_OFF } from "./git-run.js";
+import { markedEntries } from "./git-snapshot.js";
+import { parseRawRecords } from "./object-compose.js";
+import { aliasJudge, byFold, foldsOnto, occupiedPaths } from "./object-occupied.js";
+import { sparseCheckoutRefusal } from "./object-sparse.js";
+import { assertSpaceFor } from "./object-transfer.js";
+const GIT_FAULT_REFUSAL = {
+    capture_space_insufficient: "space_insufficient",
+    capture_git_stalled: "git_stalled",
+    capture_git_signal: "git_signal",
+};
+/** The typed refusal of a Git child's failure on an object path. */
+export function gitFaultRefusalCode(code) {
+    return GIT_FAULT_REFUSAL[code] ?? "git_failed";
+}
+/** A Git child's typed failure, or a filesystem fault as one (its scratch: a full disk). */
+function gitOrFilesystemFault(error) {
+    if (error instanceof GitOperationError)
+        return error;
+    const errno = error?.code;
+    if (typeof errno !== "string")
+        return null;
+    return new GitOperationError(errno === "ENOSPC" || errno === "EDQUOT" ? "capture_space_insufficient" : "capture_failed", error.message);
+}
+export { proofStallMs } from "./git-observed.js";
+/** How `read-tree -m -u` refuses before its first write (its checks run first;
+ * object-path Git speaks the C locale). It only names the refusal: whether the
+ * checkout wrote anything is measured (`wroteAny`), since a path name in a
+ * partial checkout's message can read like a refusal. */
+const REFUSED_BEFORE_WRITE = /not uptodate|would be overwritten|would be removed|would lose untracked|Cannot merge|index\.lock|failed to unpack tree|Refusing to remove/i;
+/** What lstat sees at `path` (a checkout replaces a file it writes, so its
+ * identity changes; nothing is re-hashed through a filter). */
+function stamp(worktree, path) {
+    try {
+        const stat = lstatSync(join(worktree, path), { bigint: true, throwIfNoEntry: false });
+        return stat
+            ? `${stat.mode}:${stat.size}:${stat.ino}:${stat.mtimeNs}:${stat.ctimeNs}`
+            : "absent";
+    }
+    catch (error) {
+        return `error:${error.code ?? "unknown"}`;
+    }
+}
+/** What lstat sees at `paths` in bytes (what a refresh reads at most). */
+function diskBytes(worktree, paths) {
+    let bytes = 0;
+    for (const path of paths) {
+        try {
+            bytes += lstatSync(join(worktree, path), { throwIfNoEntry: false })?.size ?? 0;
+        }
+        catch {
+            // Unreadable here: Git will say so when it gets there.
+        }
+    }
+    return bytes;
+}
+/**
+ * Refuse a checkout that cannot fit, before its first write: it would stop partway,
+ * and its take-back needs space too. A replaced file makes room just before its
+ * new content is written, so each path needs only what it grows by; a filter can
+ * change sizes, which the margin of `assertSpaceFor` covers. Returns the new bytes.
+ */
+async function assertWriteFits(worktree, records, git) {
+    const written = records.filter((record) => /^(?:100|120)/.test(record.newMode));
+    if (written.length === 0)
+        return 0;
+    const listed = await git(["cat-file", "--batch-check=%(objectname) %(objectsize)"], "cat-file --batch-check (checkout)", { input: `${[...new Set(written.map((record) => record.newOid))].join("\n")}\n` });
+    const sizes = new Map(listed.stdout
+        .split("\n")
+        .map((line) => line.split(" "))
+        .filter(([, size]) => size && /^\d+$/.test(size))
+        .map(([oid, size]) => [oid, Number(size)]));
+    let total = 0;
+    let growth = 0;
+    for (const record of written) {
+        const size = sizes.get(record.newOid) ?? 0;
+        total += size;
+        growth += Math.max(0, size - diskBytes(worktree, [record.src]));
+    }
+    assertSpaceFor(worktree, growth, "the checkout");
+    return total;
+}
+function refusal(code, message, paths = []) {
+    const sorted = [...new Set(paths)].sort();
+    return {
+        code,
+        message: message.slice(0, 4_000),
+        paths: sorted.slice(0, 200),
+        pathCount: sorted.length,
+    };
+}
+/** The refusal of a write over what Git does not track, naming it. */
+function occupiedRefusal(worktree, records) {
+    const occupied = occupiedPaths(worktree, records);
+    return occupied.length === 0
+        ? null
+        : refusal("delivery_path_occupied", `a path this operation writes holds what Git does not track (an ignored file, for one), and writing would destroy it; nothing was written: ${occupied.slice(0, 20).join(", ")}`, occupied);
+}
+/** The same refusals for a dry run: what a checkout from `from` to `to` would answer
+ * here before writing (a path holding what Git does not track, or one outside the
+ * sparse-checkout patterns). */
+export async function occupiedByWrite(worktree, from, to, env = {}) {
+    const listed = await gitObserved(worktree, ["diff-tree", "-r", "--raw", "-z", "--no-renames", "--no-abbrev", from, to], { env, label: "diff-tree --raw (dry run)" });
+    const records = parseRawRecords(listed.stdout);
+    return (occupiedRefusal(worktree, records) ??
+        (await sparseCheckoutRefusal(worktree, records.map((record) => record.src), "delivery", env)));
+}
+/**
+ * Write `to` over a worktree that holds `from` (rev 11 C): a two-tree
+ * `read-tree -m -u` that refuses "not uptodate" when a path it must change no
+ * longer holds `from` (a live preimage recheck) and streams big blobs to disk.
+ * It runs with the sparse-checkout patterns off: with them on, Git reapplies them
+ * to every entry and deletes a clean file outside them that holds no skip-worktree
+ * mark (a conflict resolved there), a path this write never addressed. Off, only
+ * the paths `from` and `to` differ in move; every other entry keeps its file, and its
+ * mark unless Git itself clears it (Git clears the skip-worktree mark of a present
+ * file when it reads a sparse checkout's index). What Git does not track is refused
+ * first: a file at a path `to` adds (ignored, so outside `from`) would be
+ * overwritten, and no revert could bring it back. So is an addressed path outside
+ * the patterns: a snapshot's `add -A` skips it, so neither a take-back nor a revert
+ * could tell what it holds. A write that cannot fit refuses too, with nothing
+ * written. Afterwards every written path is proven by content, the way `git status`
+ * compares it (Git's clean conversion through an index), not by a stat refresh.
+ * Its temporary index's scratch goes last, never replacing the outcome.
+ */
+export function materializeTree(input) {
+    return withDisposableScratch((held) => writeTree(input, held));
+}
+async function writeTree(input, held) {
+    const env = { GIT_OPTIONAL_LOCKS: "0" };
+    // A checkout writes files without stdout: disk activity is its progress.
+    const progress = diskProgress(input.worktree);
+    // The real index keeps the user's form, but no stat shortcut decides for it either.
+    const git = (args, label, extra = {}) => gitObserved(input.worktree, [...(held.dir ? SCRATCH_INDEX_CONFIG : STAT_TRUST_OFF), ...args], {
+        env,
+        label,
+        progress,
+        ...extra,
+    });
+    let records;
+    let paths;
+    let writtenBytes;
+    const before = new Map();
+    try {
+        if (input.index === "temporary")
+            held.dir = mkdtempSync(join(tmpdir(), "claudexor-materialize-"));
+        records = parseRawRecords((await git(["diff-tree", "-r", "--raw", "-z", "--no-renames", "--no-abbrev", input.from, input.to], "diff-tree --raw")).stdout);
+        if (records.length === 0)
+            return { ok: true, changed: 0, treeMutated: false };
+        paths = records.map((record) => record.src);
+        const blocked = occupiedRefusal(input.worktree, records) ??
+            (await sparseCheckoutRefusal(input.worktree, paths, "delivery", env));
+        if (blocked)
+            return { ok: false, treeMutated: false, refusal: blocked };
+        writtenBytes = await assertWriteFits(input.worktree, records, git);
+        if (held.dir)
+            await seedScratchIndex(input, held.dir, records, env, git);
+        // The real index keeps the user's assume-unchanged marks, so its refresh
+        // compares an entry whose stat moved by content, mark or not (the checkout
+        // stat-checks a marked entry it replaces): an unchanged file is not "not uptodate".
+        // Git drops the mark of an entry whose file changed, a local edit the user keeps
+        // out of commits: those marks are put back. A marked name stdin cannot carry
+        // back keeps the plain refresh, where a stale mark refuses before writing.
+        const marks = held.dir ? null : await markedEntries(input.worktree, env);
+        const refresh = marks && marks.unnamed === 0 ? "--really-refresh" : "--refresh";
+        await git(["update-index", "-q", refresh], `update-index ${refresh}`, {
+            allowFailure: true,
+            stallMs: proofStallMs(diskBytes(input.worktree, paths)),
+        });
+        if (refresh === "--really-refresh" && marks && marks.assumed.length > 0)
+            await git(["update-index", "--assume-unchanged", "-z", "--stdin"], "update-index --assume-unchanged", { input: marks.assumed.map((path) => `${path}\0`).join("") });
+        for (const path of paths)
+            before.set(path, stamp(input.worktree, path));
+    }
+    catch (error) {
+        const fault = gitOrFilesystemFault(error);
+        if (!fault)
+            throw error;
+        // Nothing has been written yet: the fault is the whole answer.
+        return {
+            ok: false,
+            treeMutated: false,
+            refusal: refusal(gitFaultRefusalCode(fault.code), fault.message),
+        };
+    }
+    let moved;
+    try {
+        moved = await git(["read-tree", "--no-sparse-checkout", "-m", "-u", input.from, input.to], "read-tree -m -u", { allowFailure: true, stallMs: proofStallMs(writtenBytes) });
+    }
+    catch (error) {
+        if (!(error instanceof GitOperationError))
+            throw error;
+        // A stalled or killed checkout: part of `to` may have reached the target.
+        return {
+            ok: false,
+            treeMutated: true,
+            refusal: refusal(gitFaultRefusalCode(error.code), error.message, paths),
+        };
+    }
+    if (moved.code !== 0) {
+        const stderr = moved.stderr.trim();
+        const wrote = await wroteAny(input, before, env);
+        if (!wrote && REFUSED_BEFORE_WRITE.test(stderr))
+            return {
+                ok: false,
+                treeMutated: false,
+                refusal: refusal("delivery_target_changed", `the target changed under paths this operation writes: ${stderr}`, paths),
+            };
+        return {
+            ok: false,
+            treeMutated: wrote,
+            refusal: refusal(gitFaultRefusalCode(classifyGitFailure(stderr)), `${wrote ? "the checkout stopped partway" : "the checkout failed before writing"}: ${stderr}`, paths),
+        };
+    }
+    let mismatched;
+    try {
+        mismatched = await contentMismatches(input.worktree, records, env);
+    }
+    catch (error) {
+        const fault = gitOrFilesystemFault(error);
+        if (!fault)
+            throw error;
+        return {
+            ok: false,
+            treeMutated: true,
+            unproven: paths,
+            refusal: refusal(gitFaultRefusalCode(fault.code), `the written paths could not be proven: ${fault.message}`, paths),
+        };
+    }
+    if (mismatched.length > 0) {
+        return {
+            ok: false,
+            treeMutated: true,
+            unproven: mismatched,
+            refusal: refusal("delivery_content_mismatch", "written paths do not hold the delivered content after checkout conversion", mismatched),
+        };
+    }
+    return { ok: true, changed: records.length, treeMutated: true };
+}
+/**
+ * Point `GIT_INDEX_FILE` at a scratch index holding `from` that keeps the stat
+ * cache of the user's index, so the refresh before the checkout costs what
+ * `git status` costs instead of re-hashing every tracked file. The user's
+ * index path is resolved first (`--git-path index` honours `GIT_INDEX_FILE`);
+ * only that file is read, never its lock, and it is copied whole under a
+ * private name before use. A user's index that cannot seed (none yet,
+ * unmerged, unreadable) leaves a plain read of `from`. The paths this checkout
+ * replaces or removes are then re-added without stat data, so the refresh
+ * compares exactly those by content through the target's own conversion, as
+ * an index without any stat cache did: a path that does not hold `from` stays
+ * "not uptodate" and the checkout refuses before writing. A re-added entry carries
+ * none of the user's assume-unchanged or skip-worktree marks, and the scratch
+ * trusts no stat shortcut (`SCRATCH_INDEX_CONFIG`): with `core.ignoreStat` every
+ * re-added entry would be assume-valid, its content never compared.
+ */
+async function seedScratchIndex(input, scratch, records, env, git) {
+    const located = await git(["rev-parse", "--path-format=absolute", "--git-path", "index"], "rev-parse index", { allowFailure: true });
+    const userIndex = located.code === 0 ? located.stdout.trim() : "";
+    const scratchIndex = join(scratch, "index");
+    env["GIT_INDEX_FILE"] = scratchIndex;
+    let seeded = false;
+    if (userIndex && existsSync(userIndex)) {
+        try {
+            copyFileSync(userIndex, `${scratchIndex}.copy`);
+            renameSync(`${scratchIndex}.copy`, scratchIndex);
+            seeded =
+                (await git(["read-tree", "-m", input.from], "read-tree -m (seed)", { allowFailure: true }))
+                    .code === 0;
+        }
+        catch {
+            seeded = false;
+        }
+    }
+    if (!seeded) {
+        rmSync(scratchIndex, { force: true });
+        await git(["read-tree", input.from], "read-tree (seed)");
+    }
+    const replaced = records.filter((record) => record.oldMode !== "000000");
+    if (replaced.length > 0)
+        await git(["update-index", "-z", "--index-info"], "update-index --index-info", {
+            input: replaced
+                .map((record) => `${record.oldMode} ${record.oldOid}\t${record.src}\0`)
+                .join(""),
+        });
+}
+/**
+ * After a failed checkout: did it write anything? Every path it would write
+ * must be as lstat saw it just before (type, mode, size, inode, times), and a
+ * real index must still be `from`. Nothing is re-hashed: a filter that does not
+ * round-trip would make an untouched file look written. A measurement that
+ * cannot run counts as written.
+ */
+async function wroteAny(input, before, env) {
+    try {
+        for (const [path, was] of before)
+            if (stamp(input.worktree, path) !== was)
+                return true;
+        if (input.index === "temporary")
+            return false;
+        const index = await gitObserved(input.worktree, ["write-tree"], { env, label: "write-tree" });
+        return index.stdout.trim() !== input.from;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Written paths whose content differs from their entries, compared as `git status`
+ * compares them: with the blob in the index, so a committed CRLF blob keeps its CR
+ * (`hash-object` loads no index and would call it changed). A private copy of the
+ * index the checkout just moved keeps every other path's stat cache; the written
+ * paths are re-added without stat data or the user's marks, so the refresh reads
+ * exactly those, whatever `core.ignoreStat` or a filesystem monitor would answer
+ * (`SCRATCH_INDEX_CONFIG`). A filter that does not round-trip still reads as different.
+ */
+async function indexProofMismatches(worktree, records, env, bytes) {
+    if (records.length === 0)
+        return [];
+    const located = await gitObserved(worktree, ["rev-parse", "--path-format=absolute", "--git-path", "index"], { env, label: "rev-parse index (proof)", allowFailure: true });
+    const moved = located.code === 0 ? located.stdout.trim() : "";
+    const scratch = mkdtempSync(join(tmpdir(), "claudexor-proof-"));
+    const proofEnv = { ...env, GIT_INDEX_FILE: join(scratch, "index") };
+    const git = (args, label, extra = {}) => gitObserved(worktree, [...SCRATCH_INDEX_CONFIG, ...args], {
+        env: proofEnv,
+        label,
+        ...extra,
+    });
+    try {
+        if (moved && existsSync(moved))
+            copyFileSync(moved, proofEnv.GIT_INDEX_FILE);
+        await git(["update-index", "--add", "-z", "--index-info"], "update-index --index-info (proof)", {
+            input: records
+                .map((record) => `${record.newMode} ${record.newOid}\t${record.src}\0`)
+                .join(""),
+        });
+        await git(["update-index", "-q", "--refresh"], "update-index --refresh (proof)", {
+            stallMs: proofStallMs(bytes),
+        });
+        const listed = await git(["diff-files", "--name-only", "-z"], "diff-files (proof)");
+        const different = new Set(listed.stdout.split("\0").filter(Boolean));
+        return records.filter((record) => different.has(record.src)).map((record) => record.src);
+    }
+    finally {
+        rmSync(scratch, { recursive: true, force: true });
+    }
+}
+/**
+ * One `--stdin-paths` line naming `path` exactly. Git reads a line that starts
+ * with `"` as a C-quoted name and strips a trailing CR, so such names (and any
+ * with control characters) are quoted the way Git's unquote_c_style reads them;
+ * every other name, backslashes included, is taken verbatim.
+ */
+function stdinPathLine(path) {
+    if (!/^"|[\x00-\x1f\x7f]/.test(path))
+        return path;
+    const escapes = {
+        '"': '\\"',
+        "\\": "\\\\",
+        "\n": "\\n",
+        "\r": "\\r",
+        "\t": "\\t",
+    };
+    let quoted = '"';
+    for (const char of path) {
+        if (escapes[char])
+            quoted += escapes[char];
+        else if (/[\x00-\x1f\x7f]/.test(char))
+            quoted += `\\${char.charCodeAt(0).toString(8).padStart(3, "0")}`;
+        else
+            quoted += char;
+    }
+    return `${quoted}"`;
+}
+/** Paths whose worktree content or mode differs from the tree just written; a path
+ * that cannot be looked at throws, and its caller refuses the write as unproven. */
+async function contentMismatches(worktree, records, env) {
+    const mismatched = [];
+    const hashed = [];
+    let hashedBytes = 0;
+    // Symlinks checked out as plain files holding their target (core.symlinks=false).
+    const linkFiles = [];
+    // On a filesystem that folds case, a removed path can read as the file written
+    // under its other spelling: one entry, not a survivor (a hard link is no alias).
+    const removedThere = [];
+    const boolConfig = async (key) => (await gitObserved(worktree, ["config", "--bool", key], {
+        env,
+        label: `config ${key}`,
+        allowFailure: true,
+    })).stdout.trim() !== "false";
+    const fileMode = await boolConfig("core.fileMode");
+    const symlinks = await boolConfig("core.symlinks");
+    for (const record of records) {
+        const path = join(worktree, record.src);
+        // Only ENOENT and ENOTDIR say a path is gone: any other error (an I/O error, a
+        // parent that can no longer be searched) leaves the write unproven, never a
+        // removal proven by not looking.
+        const stat = lstatPresent(path);
+        if (record.status === "D") {
+            if (stat && !stat.isDirectory())
+                removedThere.push(record.src);
+            continue;
+        }
+        if (record.newMode === "160000")
+            continue; // a gitlink is another repository's commit
+        if (!stat) {
+            mismatched.push(record.src);
+            continue;
+        }
+        if (record.newMode === "120000") {
+            if (!symlinks) {
+                // Git writes the link target's exact bytes, unconverted, as a plain file.
+                if (stat.isFile())
+                    linkFiles.push(record);
+                else
+                    mismatched.push(record.src);
+                continue;
+            }
+            const blob = await gitObserved(worktree, ["cat-file", "blob", record.newOid], {
+                env,
+                label: "cat-file blob",
+            });
+            if (!stat.isSymbolicLink() || readlinkSync(path) !== blob.stdout)
+                mismatched.push(record.src);
+            continue;
+        }
+        if (!stat.isFile()) {
+            mismatched.push(record.src);
+            continue;
+        }
+        if (fileMode && ((stat.mode & 0o100) !== 0) !== (record.newMode === "100755")) {
+            mismatched.push(record.src);
+            continue;
+        }
+        hashed.push(record);
+        hashedBytes += stat.size;
+    }
+    if (removedThere.length > 0) {
+        const judge = aliasJudge(worktree);
+        const written = byFold(records.filter((record) => record.status !== "D").map((r) => r.src));
+        for (const path of removedThere)
+            if (!foldsOnto(judge, written, path))
+                mismatched.push(path);
+    }
+    mismatched.push(...(await indexProofMismatches(worktree, hashed, env, hashedBytes)));
+    // Link files hold their target's exact bytes, unconverted, one line each on stdin.
+    for (let index = 0; index < linkFiles.length; index += 500) {
+        const chunk = linkFiles.slice(index, index + 500);
+        const out = await gitObserved(worktree, ["hash-object", "--no-filters", "--stdin-paths"], {
+            env,
+            label: "hash-object --stdin-paths",
+            input: `${chunk.map((record) => stdinPathLine(record.src)).join("\n")}\n`,
+        });
+        const oids = out.stdout.trim().split("\n");
+        chunk.forEach((record, at) => {
+            if (oids[at] !== record.newOid)
+                mismatched.push(record.src);
+        });
+    }
+    return mismatched;
+}
+//# sourceMappingURL=object-materialize.js.map

package/dist/object-materialize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-materialize.js","sourceRoot":"","sources":["../src/object-materialize.ts"],"names":[],"mappings":"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"}

package/dist/object-occupied.d.ts

@@ -0,0 +1,27 @@
+import type { RawRecord } from "./object-compose.js";
+/**
+ * Whether two tree paths name one directory entry through the filesystem's folding
+ * of their spelling: they differ only by case, lstat finds one inode for both, and
+ * they are not both spelled exactly as entries on disk. A hard link is an entry of
+ * its own, spelled exactly, so two of its names never count as one. Directory
+ * listings are read once, and only for such a prospective alias.
+ */
+export declare function aliasJudge(worktree: string): (path: string, other: string) => boolean;
+/** Paths keyed by their folded spelling. */
+export declare function byFold(paths: Iterable<string>): Map<string, string[]>;
+/** Whether `path` is one of `paths` under another spelling (see {@link aliasJudge}). */
+export declare function foldsOnto(judge: (path: string, other: string) => boolean, folded: ReadonlyMap<string, readonly string[]>, path: string): boolean;
+/**
+ * What a checkout from one tree to another would destroy without Git knowing:
+ * `read-tree -m -u` writes a path the first tree does not name over whatever is
+ * there, and removes a file or symlink standing where it needs a directory. A
+ * snapshot leaves ignored files out of that tree, so such a file is the user's and
+ * no revert could bring it back. For each added path, one lstat of it and of each
+ * parent it does not share with another; a directory holding what stays is only
+ * walked when a file is about to take its name. A directory the path merely enters
+ * loses nothing, and neither do the entries the same checkout removes. Only ENOENT
+ * and ENOTDIR are absence: a path that cannot be looked at is thrown, so the write
+ * and its dry run both refuse instead of reading it as free.
+ */
+export declare function occupiedPaths(worktree: string, records: readonly RawRecord[]): string[];
+//# sourceMappingURL=object-occupied.d.ts.map

package/dist/object-occupied.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-occupied.d.ts","sourceRoot":"","sources":["../src/object-occupied.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAgBrD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAuBrF;AAED,4CAA4C;AAC5C,wBAAgB,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAIrE;AAED,wFAAwF;AACxF,wBAAgB,SAAS,CACvB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EAC/C,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,EAC9C,IAAI,EAAE,MAAM,GACX,OAAO,CAET;AAaD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,EAAE,CAsCvF"}

package/dist/object-occupied.js

@@ -0,0 +1,131 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { lstatPresent } from "./fs-presence.js";
+const ABSENT_MODE = "000000";
+/** For the alias judge only: a path it cannot look at is no alias (the exemption is denied). */
+const lstatOrNull = (path) => {
+    try {
+        return lstatPresent(path);
+    }
+    catch {
+        return undefined;
+    }
+};
+/** A name as a volume that folds case reads it (normalization included). */
+const fold = (path) => path.normalize("NFC").toLowerCase();
+/**
+ * Whether two tree paths name one directory entry through the filesystem's folding
+ * of their spelling: they differ only by case, lstat finds one inode for both, and
+ * they are not both spelled exactly as entries on disk. A hard link is an entry of
+ * its own, spelled exactly, so two of its names never count as one. Directory
+ * listings are read once, and only for such a prospective alias.
+ */
+export function aliasJudge(worktree) {
+    const listings = new Map();
+    const listing = (dir) => {
+        if (!listings.has(dir)) {
+            try {
+                listings.set(dir, new Set(readdirSync(join(worktree, dir))));
+            }
+            catch {
+                listings.set(dir, null);
+            }
+        }
+        return listings.get(dir);
+    };
+    const spelledExactly = (path) => {
+        const parts = path.split("/");
+        return parts.every((part, at) => listing(parts.slice(0, at).join("/"))?.has(part) === true);
+    };
+    return (path, other) => {
+        if (path === other || fold(path) !== fold(other))
+            return false;
+        const one = lstatOrNull(join(worktree, path));
+        const two = lstatOrNull(join(worktree, other));
+        if (!one || !two || one.dev !== two.dev || one.ino !== two.ino)
+            return false;
+        return !(spelledExactly(path) && spelledExactly(other));
+    };
+}
+/** Paths keyed by their folded spelling. */
+export function byFold(paths) {
+    const map = new Map();
+    for (const path of paths)
+        map.set(fold(path), [...(map.get(fold(path)) ?? []), path]);
+    return map;
+}
+/** Whether `path` is one of `paths` under another spelling (see {@link aliasJudge}). */
+export function foldsOnto(judge, folded, path) {
+    return (folded.get(fold(path)) ?? []).some((other) => judge(path, other));
+}
+/** What a directory holds that is not on its way out, as tree paths (empty ones hold nothing). */
+function survivors(worktree, dir, removed) {
+    const found = [];
+    for (const entry of readdirSync(join(worktree, dir), { withFileTypes: true })) {
+        const path = `${dir}/${entry.name}`;
+        if (entry.isDirectory())
+            found.push(...survivors(worktree, path, removed));
+        else if (!removed.has(path))
+            found.push(path);
+    }
+    return found;
+}
+/**
+ * What a checkout from one tree to another would destroy without Git knowing:
+ * `read-tree -m -u` writes a path the first tree does not name over whatever is
+ * there, and removes a file or symlink standing where it needs a directory. A
+ * snapshot leaves ignored files out of that tree, so such a file is the user's and
+ * no revert could bring it back. For each added path, one lstat of it and of each
+ * parent it does not share with another; a directory holding what stays is only
+ * walked when a file is about to take its name. A directory the path merely enters
+ * loses nothing, and neither do the entries the same checkout removes. Only ENOENT
+ * and ENOTDIR are absence: a path that cannot be looked at is thrown, so the write
+ * and its dry run both refuse instead of reading it as free.
+ */
+export function occupiedPaths(worktree, records) {
+    const removed = new Set(records.filter((record) => record.newMode === ABSENT_MODE).map((record) => record.src));
+    // Parents already looked at: a real directory is entered; anything else stops the walk.
+    const parents = new Map();
+    const occupied = new Set();
+    /** On a filesystem that folds case, a path about to go can answer for a new spelling. */
+    const judge = aliasJudge(worktree);
+    const leaving = byFold(removed);
+    const isLeaving = (path) => foldsOnto(judge, leaving, path);
+    const enterable = (parent) => {
+        const known = parents.get(parent);
+        if (known)
+            return known === "enter";
+        const cut = parent.lastIndexOf("/");
+        const reachable = cut <= 0 || enterable(parent.slice(0, cut));
+        let answer = "stop";
+        if (reachable) {
+            const stat = lstatPresent(join(worktree, parent));
+            if (stat?.isDirectory())
+                answer = "enter";
+            else if (stat && !removed.has(parent) && !isLeaving(parent))
+                occupied.add(parent);
+        }
+        parents.set(parent, answer);
+        return answer === "enter";
+    };
+    for (const record of records) {
+        if (record.oldMode !== ABSENT_MODE)
+            continue;
+        const cut = record.src.lastIndexOf("/");
+        if (cut > 0 && !enterable(record.src.slice(0, cut)))
+            continue;
+        const stat = lstatPresent(join(worktree, record.src));
+        if (!stat)
+            continue;
+        if (stat.isDirectory()) {
+            // A gitlink's own directory stays; a file taking its name would remove it.
+            if (record.newMode !== "160000")
+                for (const path of survivors(worktree, record.src, removed))
+                    occupied.add(path);
+        }
+        else if (!isLeaving(record.src))
+            occupied.add(record.src);
+    }
+    return [...occupied];
+}
+//# sourceMappingURL=object-occupied.js.map