@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/src/git/target-placement.js

@@ -0,0 +1,255 @@
+import { resolve } from "node:path";
+import { acquireSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
+import { gitObjectId, gitObjectIdForSnapshot, gitRefLocator, mintSnapshotId } from "./identity.js";
+import { currentBranch } from "./observe.js";
+import { commonGitDirectory, GitPlumbingError, readRef, registeredWorktrees, runGit, } from "./repository.js";
+import { captureWorkspaceTree, withPrivateGitIndex } from "./workspace.js";
+export function observeTargetHead(repository, target) {
+    const value = readRef(repository, target);
+    return value === null ? null : mintSnapshotId(value);
+}
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function nulPaths(bytes) {
+    const fields = bytes.toString("utf8").split("\0");
+    if (fields.at(-1) !== "")
+        throw new Error("Git path output is not NUL terminated");
+    return [...new Set(fields.slice(0, -1))].sort();
+}
+function gitPaths(repository, path, args) {
+    return nulPaths(runGit(repository, ["-C", path, ...args]));
+}
+function commitTree(repository, snapshot) {
+    return gitObjectId(runGit(repository, ["show", "-s", "--format=%T", gitObjectIdForSnapshot(snapshot)])
+        .toString("utf8")
+        .trim(), "commit tree");
+}
+function pathsOverlap(left, right) {
+    return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+function intersection(left, right) {
+    return left.filter((candidate) => right.some((path) => pathsOverlap(candidate, path))).sort();
+}
+function failurePaths(error) {
+    if (!(error instanceof GitPlumbingError))
+        return [];
+    const paths = new Set();
+    for (const match of error.stderr.toString("utf8").matchAll(/(?:Entry|Untracked working tree file) '([^']+)'/gu)) {
+        paths.add(match[1]);
+    }
+    return [...paths].sort();
+}
+function checkoutRefusal(contractId, target, path, reason, error) {
+    const paths = failurePaths(error);
+    if (paths.length === 0)
+        throw error;
+    return { kind: "checkout-not-followable", contractId, target: target.target, path, reason, paths };
+}
+function indexMatchesTreeOnPaths(repository, path, tree, paths) {
+    return gitPaths(repository, path, ["diff-index", "--cached", "--name-only", "-z", tree, "--", ...paths]).length === 0;
+}
+function workspaceMatchesTreeOnPaths(repository, path, tree, workspaceTree, paths) {
+    return gitPaths(repository, path, ["diff", "--name-only", "-z", tree, workspaceTree, "--", ...paths]).length === 0;
+}
+function sourceWorktree(repository) {
+    return resolve(runGit(repository, ["rev-parse", "--show-toplevel"]).toString("utf8").trim());
+}
+function ordinaryPrecheck(repository, contractId, target, path) {
+    const predecessor = gitObjectIdForSnapshot(target.expectedOid);
+    const candidate = gitObjectIdForSnapshot(target.newOid);
+    try {
+        withPrivateGitIndex((environment) => {
+            runGit(repository, ["-C", path, "read-tree", "-i", `--index-output=${environment.GIT_INDEX_FILE}`, "-m", predecessor, candidate]);
+        });
+    }
+    catch (error) {
+        return checkoutRefusal(contractId, target, path, "staged", error);
+    }
+    const changed = gitPaths(repository, path, ["diff", "--name-only", "-z", predecessor, candidate]);
+    const dirty = gitPaths(repository, path, ["diff-files", "--name-only", "-z"]);
+    const conflicts = intersection(changed, dirty);
+    if (conflicts.length > 0) {
+        return {
+            kind: "checkout-not-followable",
+            contractId,
+            target: target.target,
+            path,
+            reason: "conflict",
+            paths: conflicts,
+        };
+    }
+    const additions = gitPaths(repository, path, ["diff", "--name-only", "--diff-filter=A", "-z", predecessor, candidate]);
+    const untracked = gitPaths(repository, path, ["ls-files", "--others", "-z"]);
+    const collisions = intersection(additions, untracked);
+    if (collisions.length > 0) {
+        return {
+            kind: "checkout-not-followable",
+            contractId,
+            target: target.target,
+            path,
+            reason: "untracked",
+            paths: collisions,
+        };
+    }
+    try {
+        runGit(repository, ["-C", path, "read-tree", "--dry-run", "-m", "-u", predecessor, candidate]);
+    }
+    catch (error) {
+        const reason = error instanceof GitPlumbingError && /untracked working tree file/iu.test(error.stderr.toString("utf8"))
+            ? "untracked"
+            : "conflict";
+        return checkoutRefusal(contractId, target, path, reason, error);
+    }
+    return null;
+}
+export async function acquireTargetPlacementFence(repository, target) {
+    const locator = gitRefLocator(target);
+    return acquireSqliteTransactionLock({
+        path: resolve(commonGitDirectory(repository), "keiyaku", "locks", "target-placement", `${locator}.sqlite`),
+        mode: "immediate",
+    });
+}
+export function prepareTargetPlacement(repository, state, target) {
+    if (state.coordinates.target !== target.target || state.delivery?.data.integration.snapshot !== target.newOid) {
+        throw new Error("placement state does not match its offered target movement");
+    }
+    const worktrees = registeredWorktrees(repository)
+        .filter((worktree) => worktree.branch === target.target)
+        .sort((left, right) => left.path.localeCompare(right.path));
+    const hereSource = state.coordinates.workspace === "here" ? sourceWorktree(repository) : null;
+    if (hereSource !== null) {
+        const branch = currentBranch(repository, hereSource);
+        if (branch !== target.target) {
+            return {
+                kind: "refused",
+                refusal: {
+                    kind: "workspace-not-on-target",
+                    contractId: state.id,
+                    target: target.target,
+                    branch,
+                },
+            };
+        }
+    }
+    const arms = [];
+    for (const worktree of worktrees) {
+        const kind = hereSource !== null && resolve(worktree.path) === hereSource ? "here" : "ordinary";
+        if (kind === "ordinary") {
+            const refusal = ordinaryPrecheck(repository, state.id, target, worktree.path);
+            if (refusal !== null)
+                return { kind: "refused", refusal };
+        }
+        arms.push({ kind, path: worktree.path });
+    }
+    if (hereSource !== null && !arms.some((arm) => arm.kind === "here")) {
+        throw new Error("targeted here workspace is not a registered checkout of its target");
+    }
+    return { kind: "prepared", placement: { target, arms } };
+}
+export function followTargetPlacement(repository, prepared) {
+    const effects = [];
+    const lag = [];
+    const predecessor = gitObjectIdForSnapshot(prepared.target.expectedOid);
+    const candidate = gitObjectIdForSnapshot(prepared.target.newOid);
+    for (const arm of prepared.arms) {
+        try {
+            if (arm.kind === "here")
+                runGit(repository, ["-C", arm.path, "read-tree", candidate]);
+            else
+                runGit(repository, ["-C", arm.path, "read-tree", "-m", "-u", predecessor, candidate]);
+            effects.push({ kind: "target-checkout", path: arm.path, target: prepared.target.target, action: "followed" });
+        }
+        catch (error) {
+            lag.push({
+                kind: "target-checkout-retained",
+                path: arm.path,
+                target: prepared.target.target,
+                diagnostic: diagnostic(error),
+            });
+        }
+    }
+    return { effects, lag };
+}
+function recoveryLag(path, target, detail) {
+    return { kind: "target-checkout-retained", path, target, diagnostic: detail };
+}
+function recoverCheckout(input) {
+    const { repository, path, predecessor, candidate, predecessorTree, candidateTree } = input;
+    const changedPaths = gitPaths(repository, path, ["diff", "--name-only", "-z", predecessorTree, candidateTree]);
+    if (changedPaths.length === 0)
+        return "complete";
+    const workspaceTree = captureWorkspaceTree(repository, path).tree;
+    const candidateIndex = indexMatchesTreeOnPaths(repository, path, candidateTree, changedPaths);
+    const candidateWorkspace = workspaceMatchesTreeOnPaths(repository, path, candidateTree, workspaceTree, changedPaths);
+    if (candidateIndex && candidateWorkspace)
+        return "complete";
+    if (workspaceTree === candidateTree) {
+        runGit(repository, ["-C", path, "read-tree", gitObjectIdForSnapshot(candidate)]);
+        return "recovered";
+    }
+    const predecessorIndex = indexMatchesTreeOnPaths(repository, path, predecessorTree, changedPaths);
+    if (predecessorIndex && candidateWorkspace) {
+        runGit(repository, [
+            "-C",
+            path,
+            "read-tree",
+            "-i",
+            "-m",
+            gitObjectIdForSnapshot(predecessor),
+            gitObjectIdForSnapshot(candidate),
+        ]);
+        return "recovered";
+    }
+    const predecessorWorkspace = workspaceMatchesTreeOnPaths(repository, path, predecessorTree, workspaceTree, changedPaths);
+    if (!predecessorIndex || !predecessorWorkspace)
+        return "retained";
+    runGit(repository, [
+        "-C",
+        path,
+        "read-tree",
+        "-m",
+        "-u",
+        gitObjectIdForSnapshot(predecessor),
+        gitObjectIdForSnapshot(candidate),
+    ]);
+    return "recovered";
+}
+export function recoverTargetPlacement(repository, state) {
+    const target = state.coordinates.target;
+    const delivery = state.delivery;
+    if (state.terminal?.kind !== "claimed" || target === undefined || delivery === null)
+        return { effects: [], lag: [] };
+    if (readRef(repository, target) !== delivery.data.integration.snapshot)
+        return { effects: [], lag: [] };
+    const candidateTree = commitTree(repository, delivery.data.integration.snapshot);
+    const predecessorTree = commitTree(repository, delivery.data.integration.predecessor);
+    const worktrees = registeredWorktrees(repository)
+        .filter((worktree) => worktree.branch === target)
+        .sort((left, right) => left.path.localeCompare(right.path));
+    const effects = [];
+    const lag = [];
+    for (const worktree of worktrees) {
+        try {
+            const recovery = recoverCheckout({
+                repository,
+                path: worktree.path,
+                predecessor: delivery.data.integration.predecessor,
+                candidate: delivery.data.integration.snapshot,
+                predecessorTree,
+                candidateTree,
+            });
+            if (recovery === "retained") {
+                lag.push(recoveryLag(worktree.path, target, "target checkout entries are neither predecessor nor candidate"));
+                continue;
+            }
+            if (recovery === "recovered") {
+                effects.push({ kind: "target-checkout", path: worktree.path, target, action: "recovered" });
+            }
+        }
+        catch (error) {
+            lag.push(recoveryLag(worktree.path, target, diagnostic(error)));
+        }
+    }
+    return { effects, lag };
+}

package/build/src/git/tender.d.ts

@@ -0,0 +1,48 @@
+import type { Preparation } from "../core/decide.js";
+import type { ContractCoordinates, ContractId, SnapshotId } from "../core/facts/types.js";
+import { type GitObjectId } from "./identity.js";
+import { type GitRepository } from "./repository.js";
+import { captureWorkspaceTree } from "./workspace.js";
+export type TenderCaptureCoordinates = Readonly<{
+    contractId: ContractId;
+    coordinates: ContractCoordinates;
+}>;
+export type TenderCaptureRefusal = Readonly<{
+    kind: "worktree-missing";
+    contractId: ContractId;
+}>;
+export type WorkspaceDirtyDelta = Readonly<{
+    staged: readonly string[];
+    unstaged: readonly string[];
+    untracked: readonly string[];
+    shortStat: Readonly<{
+        filesChanged: number;
+        insertions: number;
+        deletions: number;
+    }>;
+}>;
+export type DirtyWorkspaceRefusal = Readonly<{
+    kind: "dirty-workspace";
+    contractId: ContractId;
+    staged: readonly string[];
+    unstaged: readonly string[];
+    untracked: readonly string[];
+    submodules: readonly string[];
+    shortStat: WorkspaceDirtyDelta["shortStat"];
+}>;
+export type TenderCapture = Readonly<{
+    tree: GitObjectId;
+    head: SnapshotId;
+    dirty: boolean;
+    changes: ReturnType<typeof captureWorkspaceTree>["changes"];
+}>;
+/** Capture the complete workspace tree through Git's private index mechanics. */
+export declare function captureTender(repository: GitRepository, input: TenderCaptureCoordinates): Preparation<TenderCapture, TenderCaptureRefusal>;
+export declare function dirtyTenderRefusal(repository: GitRepository, contractId: ContractId, tender: TenderCapture): DirtyWorkspaceRefusal;
+export declare function dirtyTenderDelta(repository: GitRepository, tender: TenderCapture): WorkspaceDirtyDelta | undefined;
+/** Materialize the tender tree when it contains admitted dirty workspace bytes. */
+export declare function materializeTenderSnapshot(repository: GitRepository, tender: TenderCapture, input: Readonly<{
+    contractId: ContractId;
+    title: string;
+    message?: string;
+}>): SnapshotId;

package/build/src/git/tender.js

@@ -0,0 +1,82 @@
+import { existsSync } from "node:fs";
+import { gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
+import { registeredWorktreePaths, runGit, runGitWithEnvironment } from "./repository.js";
+import { captureWorkspaceTree, deliveryWorktreePath } from "./workspace.js";
+function workspaceExists(repository, workspace, path) {
+    return workspace === "here"
+        || (existsSync(path) && registeredWorktreePaths(repository).includes(path));
+}
+function workspaceFor(repository, id, workspace) {
+    return workspace === "worktree" ? deliveryWorktreePath(repository, id) : repository.effectiveCwd;
+}
+/** Capture the complete workspace tree through Git's private index mechanics. */
+export function captureTender(repository, input) {
+    const workspace = workspaceFor(repository, input.contractId, input.coordinates.workspace);
+    if (!workspaceExists(repository, input.coordinates.workspace, workspace)) {
+        return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
+    }
+    return { kind: "prepared", data: captureWorkspaceTree(repository, workspace) };
+}
+function dirtyShortStat(repository, tender) {
+    const fields = runGit(repository, [
+        "diff",
+        "--numstat",
+        "-z",
+        gitObjectIdForSnapshot(tender.head),
+        tender.tree,
+    ]).toString("utf8").split("\0");
+    if (fields.at(-1) !== "")
+        throw new Error("Git numstat output is not NUL terminated");
+    let filesChanged = 0;
+    let insertions = 0;
+    let deletions = 0;
+    for (let index = 0; index < fields.length - 1; index += 1) {
+        const field = fields[index];
+        const [added, deleted, path, extra] = field.split("\t");
+        if (added === undefined || deleted === undefined || path === undefined || extra !== undefined) {
+            throw new Error("Git numstat output is malformed");
+        }
+        if (path.length === 0) {
+            if (fields[index + 1] === undefined || fields[index + 2] === undefined) {
+                throw new Error("Git rename numstat output is missing paths");
+            }
+            index += 2;
+        }
+        filesChanged += 1;
+        insertions += added === "-" ? 0 : Number.parseInt(added, 10);
+        deletions += deleted === "-" ? 0 : Number.parseInt(deleted, 10);
+    }
+    return { filesChanged, insertions, deletions };
+}
+export function dirtyTenderRefusal(repository, contractId, tender) {
+    return {
+        kind: "dirty-workspace",
+        contractId,
+        ...tender.changes,
+        shortStat: dirtyShortStat(repository, tender),
+    };
+}
+export function dirtyTenderDelta(repository, tender) {
+    if (!tender.dirty)
+        return undefined;
+    const { staged, unstaged, untracked } = tender.changes;
+    return { staged, unstaged, untracked, shortStat: dirtyShortStat(repository, tender) };
+}
+function commitMessage(contractId, title, message) {
+    const subject = message ?? `${contractId}: ${title}`;
+    return `${subject}\n\nKeiyaku-Contract: ${contractId}\n`;
+}
+/** Materialize the tender tree when it contains admitted dirty workspace bytes. */
+export function materializeTenderSnapshot(repository, tender, input) {
+    if (!tender.dirty)
+        return tender.head;
+    const commit = runGitWithEnvironment(repository, ["commit-tree", tender.tree, "-p", gitObjectIdForSnapshot(tender.head)], commitMessage(input.contractId, input.title, input.message), {
+        GIT_AUTHOR_NAME: "Keiyaku",
+        GIT_AUTHOR_EMAIL: "keiyaku@localhost",
+        GIT_COMMITTER_NAME: "Keiyaku",
+        GIT_COMMITTER_EMAIL: "keiyaku@localhost",
+        GIT_AUTHOR_DATE: "Thu, 01 Jan 1970 00:00:00 +0000",
+        GIT_COMMITTER_DATE: "Thu, 01 Jan 1970 00:00:00 +0000",
+    }).toString("utf8").trim();
+    return mintSnapshotId(commit);
+}

package/build/src/git/terminal-seal.d.ts

@@ -0,0 +1,24 @@
+import type { ContractState, SnapshotId } from "../core/facts/types.js";
+import { type GitObjectId } from "./identity.js";
+import { type GitOid, type GitRepository } from "./repository.js";
+export type UnsealedBytes = Readonly<{
+    kind: "unsealed-bytes";
+    path: string;
+    paths: readonly string[];
+    head?: SnapshotId;
+}>;
+export type TerminalSealExpectations = Readonly<{
+    heads: readonly SnapshotId[];
+    trees: readonly GitObjectId[];
+    treeBySnapshot: ReadonlyMap<SnapshotId, GitObjectId>;
+}>;
+export type TerminalSealObject = Readonly<{
+    kind: "present";
+    type: string;
+    bytes: Buffer;
+}> | Readonly<{
+    kind: "missing";
+}>;
+export declare function terminalSealSnapshots(state: ContractState): readonly SnapshotId[];
+export declare function terminalSealExpectations(state: ContractState, objects: ReadonlyMap<GitOid, TerminalSealObject>): TerminalSealExpectations;
+export declare function unsealedBytes(repository: GitRepository, path: string, expected: TerminalSealExpectations): UnsealedBytes | null;

package/build/src/git/terminal-seal.js

@@ -0,0 +1,87 @@
+import { gitObjectId, gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
+import { runGit } from "./repository.js";
+import { captureWorkspaceTree } from "./workspace.js";
+export function terminalSealSnapshots(state) {
+    return [...new Set([
+            state.coordinates.start,
+            ...(state.delivery === null ? [] : [
+                state.delivery.data.tenderSnapshot,
+                state.delivery.data.integration.snapshot,
+            ]),
+        ])];
+}
+function commitMetadata(snapshot, result) {
+    if (result === undefined || result.kind === "missing") {
+        throw new Error(`terminal seal commit is missing: ${snapshot}`);
+    }
+    if (result.type !== "commit")
+        throw new Error(`terminal seal snapshot is not a commit: ${snapshot}`);
+    const headerEnd = result.bytes.indexOf("\n\n");
+    if (headerEnd < 0)
+        throw new Error(`terminal seal commit has no headers: ${snapshot}`);
+    const headers = result.bytes.subarray(0, headerEnd).toString("ascii").split("\n");
+    const treeHeader = headers[0];
+    if (treeHeader === undefined || !treeHeader.startsWith("tree ")) {
+        throw new Error(`terminal seal commit has no root tree: ${snapshot}`);
+    }
+    return {
+        tree: gitObjectId(treeHeader.slice("tree ".length), "terminal seal tree"),
+        parents: headers
+            .filter((header) => header.startsWith("parent "))
+            .map((header) => mintSnapshotId(header.slice("parent ".length))),
+    };
+}
+export function terminalSealExpectations(state, objects) {
+    const snapshots = terminalSealSnapshots(state);
+    const metadata = new Map(snapshots.map((snapshot) => [
+        snapshot,
+        commitMetadata(snapshot, objects.get(gitObjectIdForSnapshot(snapshot))),
+    ]));
+    const treeBySnapshot = new Map([...metadata].map(([snapshot, commit]) => [snapshot, commit.tree]));
+    if (state.delivery === null) {
+        return { heads: [state.coordinates.start], trees: [...treeBySnapshot.values()], treeBySnapshot };
+    }
+    const tender = state.delivery.data.tenderSnapshot;
+    const tenderMetadata = metadata.get(tender);
+    if (tenderMetadata === undefined)
+        throw new Error(`terminal seal metadata was not resolved: ${tender}`);
+    const [tenderParent] = tenderMetadata.parents;
+    return {
+        heads: [...new Set([
+                state.coordinates.start,
+                ...(tenderParent === undefined ? [] : [tenderParent]),
+                tender,
+                state.delivery.data.integration.snapshot,
+            ])],
+        trees: [...treeBySnapshot.values()],
+        treeBySnapshot,
+    };
+}
+function changedPaths(repository, left, right) {
+    const fields = runGit(repository, ["diff", "--name-only", "-z", left, right]).toString("utf8").split("\0");
+    if (fields.at(-1) !== "")
+        throw new Error("Git tree diff paths are not NUL terminated");
+    return fields.slice(0, -1).sort();
+}
+export function unsealedBytes(repository, path, expected) {
+    const workspace = captureWorkspaceTree(repository, path);
+    const headIsSealed = expected.heads.includes(workspace.head);
+    if (workspace.changes.submodules.length > 0) {
+        return {
+            kind: "unsealed-bytes",
+            path,
+            paths: workspace.changes.submodules,
+            ...(headIsSealed ? {} : { head: workspace.head }),
+        };
+    }
+    if (headIsSealed && expected.trees.includes(workspace.tree))
+        return null;
+    const alternatives = expected.trees.map((tree) => changedPaths(repository, tree, workspace.tree));
+    alternatives.sort((left, right) => left.length - right.length || left.join("\0").localeCompare(right.join("\0")));
+    return {
+        kind: "unsealed-bytes",
+        path,
+        paths: alternatives[0] ?? [],
+        ...(headIsSealed ? {} : { head: workspace.head }),
+    };
+}

package/build/src/git/tree.d.ts

@@ -0,0 +1,34 @@
+export type TreeEntry = Readonly<{
+    mode: string;
+    type: string;
+    oid: string;
+}>;
+export type TreeChange = Readonly<{
+    oid: string;
+    mode?: string;
+    type?: string;
+}> | null;
+type MutableTreeNode = Readonly<{
+    files: Map<string, TreeChange>;
+    directories: Map<string, MutableTreeNode>;
+}>;
+type TreeUpdate = Readonly<{
+    root: MutableTreeNode;
+    nodePaths: readonly string[];
+}>;
+export type PreparedTree = Readonly<{
+    oid: string;
+    records: string;
+}>;
+export declare function validPath(path: string): void;
+export declare function treeUpdate(changes: ReadonlyMap<string, TreeChange>): TreeUpdate;
+export declare function parseTreeObject(bytes: Buffer, oidBytes: number): Map<string, TreeEntry>;
+export declare function prepareTreeUpdate(input: Readonly<{
+    update: TreeUpdate;
+    bases: ReadonlyMap<string, ReadonlyMap<string, TreeEntry>>;
+    oidBytes: number;
+}>): Readonly<{
+    root: string;
+    trees: readonly PreparedTree[];
+}>;
+export {};

package/build/src/git/tree.js

@@ -0,0 +1,116 @@
+import { createHash } from "node:crypto";
+import { gitObjectId } from "./identity.js";
+export function validPath(path) {
+    if (path.length === 0 || path.startsWith("/") || path.endsWith("/") || path.includes("\0")
+        || path.split("/").some((part) => part.length === 0 || part === "." || part === ".."))
+        throw new Error(`invalid Git path: ${path}`);
+}
+function addEntry(root, path, change) {
+    validPath(path);
+    const parts = path.split("/");
+    let node = root;
+    for (const part of parts.slice(0, -1)) {
+        if (node.files.has(part))
+            throw new Error(`Git path is both file and directory: ${path}`);
+        let child = node.directories.get(part);
+        if (child === undefined) {
+            child = { files: new Map(), directories: new Map() };
+            node.directories.set(part, child);
+        }
+        node = child;
+    }
+    const name = parts.at(-1);
+    if (name === undefined || node.directories.has(name)) {
+        throw new Error(`Git path is both file and directory: ${path}`);
+    }
+    node.files.set(name, change);
+}
+function nodePaths(node, path = "", result = []) {
+    result.push(path);
+    for (const [name, child] of node.directories) {
+        nodePaths(child, path.length === 0 ? name : `${path}/${name}`, result);
+    }
+    return result;
+}
+export function treeUpdate(changes) {
+    const root = { files: new Map(), directories: new Map() };
+    for (const [path, change] of changes)
+        addEntry(root, path, change);
+    return { root, nodePaths: nodePaths(root) };
+}
+function entryType(mode) {
+    return mode === "040000" || mode === "40000" ? "tree" : mode === "160000" ? "commit" : "blob";
+}
+export function parseTreeObject(bytes, oidBytes) {
+    const entries = new Map();
+    let offset = 0;
+    while (offset < bytes.length) {
+        const modeEnd = bytes.indexOf(0x20, offset);
+        const nameEnd = modeEnd < 0 ? -1 : bytes.indexOf(0, modeEnd + 1);
+        if (modeEnd < 0 || nameEnd < 0 || nameEnd + 1 + oidBytes > bytes.length) {
+            throw new Error("malformed Git tree object");
+        }
+        const rawMode = bytes.subarray(offset, modeEnd).toString("ascii");
+        const mode = rawMode === "40000" ? "040000" : rawMode;
+        const name = bytes.subarray(modeEnd + 1, nameEnd).toString("utf8");
+        if (name.length === 0 || entries.has(name))
+            throw new Error("malformed Git tree object");
+        const oid = bytes.subarray(nameEnd + 1, nameEnd + 1 + oidBytes).toString("hex");
+        gitObjectId(oid, `tree entry ${name}`);
+        entries.set(name, { mode, type: entryType(mode), oid });
+        offset = nameEnd + 1 + oidBytes;
+    }
+    return entries;
+}
+function sortName(name, type) {
+    return Buffer.concat([Buffer.from(name), Buffer.from([type === "tree" ? 0x2f : 0])]);
+}
+function objectId(entries, oidBytes) {
+    const sorted = [...entries].sort((left, right) => sortName(left[0], left[1].type).compare(sortName(right[0], right[1].type)));
+    const parts = sorted.flatMap(([name, entry]) => [
+        Buffer.from(`${entry.mode === "040000" ? "40000" : entry.mode} ${name}\0`),
+        Buffer.from(entry.oid, "hex"),
+    ]);
+    const bytes = Buffer.concat(parts);
+    const algorithm = oidBytes === 20 ? "sha1" : oidBytes === 32 ? "sha256" : null;
+    if (algorithm === null)
+        throw new Error(`unsupported Git object ID width: ${oidBytes * 2}`);
+    return createHash(algorithm).update(`tree ${bytes.length}\0`).update(bytes).digest("hex");
+}
+function record(name, change) {
+    gitObjectId(change.oid, `tree entry ${name}`);
+    const mode = change.mode ?? "100644";
+    const type = change.type ?? (mode === "160000" ? "commit" : "blob");
+    return `${mode} ${type} ${change.oid}\t${name}\n`;
+}
+function prepareNode(node, path, bases, oidBytes, prepared) {
+    const entries = new Map(bases.get(path) ?? []);
+    for (const [name, change] of node.files) {
+        if (change === null) {
+            entries.delete(name);
+            continue;
+        }
+        entries.set(name, {
+            oid: change.oid,
+            mode: change.mode ?? "100644",
+            type: change.type ?? (change.mode === "160000" ? "commit" : "blob"),
+        });
+    }
+    for (const [name, child] of node.directories) {
+        const prior = entries.get(name);
+        if (prior !== undefined && prior.type !== "tree") {
+            throw new Error(`Git path is both file and directory: ${name}`);
+        }
+        const childPath = path.length === 0 ? name : `${path}/${name}`;
+        const oid = prepareNode(child, childPath, bases, oidBytes, prepared);
+        entries.set(name, { mode: "040000", type: "tree", oid });
+    }
+    const oid = objectId(entries, oidBytes);
+    prepared.push({ oid, records: [...entries].map(([name, entry]) => record(name, entry)).join("") });
+    return oid;
+}
+export function prepareTreeUpdate(input) {
+    const trees = [];
+    const root = prepareNode(input.update.root, "", input.bases, input.oidBytes, trees);
+    return { root, trees };
+}

package/build/src/git/workspace.d.ts

@@ -0,0 +1,21 @@
+import type { ContractId, SnapshotId } from "../core/facts/types.js";
+import { type GitObjectId } from "./identity.js";
+import { type GitRepository } from "./repository.js";
+export type WorkspaceChanges = Readonly<{
+    staged: readonly string[];
+    unstaged: readonly string[];
+    untracked: readonly string[];
+    submodules: readonly string[];
+}>;
+export type WorkspaceTree = Readonly<{
+    tree: GitObjectId;
+    head: SnapshotId;
+    dirty: boolean;
+    changes: WorkspaceChanges;
+}>;
+export declare function deliveryWorktreePath(repository: GitRepository, contract: ContractId): string;
+export declare function withPrivateGitIndex<Value>(action: (environment: Readonly<{
+    GIT_INDEX_FILE: string;
+}>) => Value): Value;
+/** Capture tracked and untracked workspace bytes without changing its real index. */
+export declare function captureWorkspaceTree(repository: GitRepository, workspace: string): WorkspaceTree;