@astrosheep/keiyaku 4.0.1 → 4.0.2

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

@@ -1,11 +1,12 @@
+import { lstat } from "node:fs/promises";
 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);
+import { commonGitDirectory, consumeGitStdout, GitPlumbingError, readRef, registeredWorktrees, runGit, } from "./repository.js";
+import { captureWorkspaceTree } from "./workspace.js";
+export async function observeTargetHead(repository, target) {
+    const value = await readRef(repository, target);
     return value === null ? null : mintSnapshotId(value);
 }
 function diagnostic(error) {
@@ -17,115 +18,198 @@ function nulPaths(bytes) {
         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]));
+async function gitPaths(repository, path, args) {
+    return nulPaths(await runGit(repository, ["-C", path, ...args]));
 }
-function commitTree(repository, snapshot) {
-    return gitObjectId(runGit(repository, ["show", "-s", "--format=%T", gitObjectIdForSnapshot(snapshot)])
+function literalPath(path) {
+    return `:(literal)${path}`;
+}
+async function commitTree(repository, snapshot) {
+    return gitObjectId((await 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 checkoutRefusal(contractId, target, path, reason, paths) {
+    return { kind: "checkout-not-followable", contractId, target: target.target, path, reason, paths };
 }
-function intersection(left, right) {
-    return left.filter((candidate) => right.some((path) => pathsOverlap(candidate, path))).sort();
+async function changedPaths(repository, path, predecessor, candidate, filter) {
+    return await gitPaths(repository, path, [
+        "diff",
+        "--name-only",
+        "--no-renames",
+        ...(filter === undefined ? [] : [`--diff-filter=${filter}`]),
+        "-z",
+        predecessor,
+        candidate,
+    ]);
 }
-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();
+async function dryRunRefusal(input, scopes) {
+    const { repository, contractId, target, path, predecessor, candidate } = input;
+    const changed = await changedPaths(repository, path, predecessor, candidate);
+    const pathspecs = changed.map(literalPath);
+    if (pathspecs.length === 0)
+        return checkoutRefusal(contractId, target, path, "conflict", []);
+    const staged = await gitPaths(repository, path, [
+        "diff",
+        "--cached",
+        "--name-only",
+        "-z",
+        predecessor,
+        "--",
+        ...pathspecs,
+    ]);
+    if (staged.length > 0)
+        return checkoutRefusal(contractId, target, path, "staged", staged);
+    const dirty = await gitPaths(repository, path, ["diff-files", "--name-only", "-z", "--", ...pathspecs]);
+    if (dirty.length > 0)
+        return checkoutRefusal(contractId, target, path, "conflict", dirty);
+    const unmerged = await gitPaths(repository, path, ["diff", "--name-only", "--diff-filter=U", "-z", "--", ...pathspecs]);
+    if (unmerged.length > 0)
+        return checkoutRefusal(contractId, target, path, "conflict", unmerged);
+    return await untrackedRefusalWithinScopes(input, scopes, false)
+        ?? checkoutRefusal(contractId, target, path, "conflict", []);
 }
-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 };
+async function physicalScope(worktree, candidatePath) {
+    const components = candidatePath.split("/");
+    for (let index = 0; index < components.length; index += 1) {
+        const scope = components.slice(0, index + 1).join("/");
+        let stat;
+        try {
+            stat = await lstat(resolve(worktree, ...components.slice(0, index + 1)));
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT" || code === "ENOTDIR")
+                return null;
+            throw error;
+        }
+        if (!stat.isDirectory())
+            return { path: scope, kind: "leaf" };
+        if (index + 1 === components.length)
+            return { path: scope, kind: "directory" };
+    }
+    return null;
 }
-function indexMatchesTreeOnPaths(repository, path, tree, paths) {
-    return gitPaths(repository, path, ["diff-index", "--cached", "--name-only", "-z", tree, "--", ...paths]).length === 0;
+async function candidateEntryIsBlob(repository, path, candidate, candidatePath) {
+    const output = await runGit(repository, ["-C", path, "ls-tree", "-z", candidate, "--", literalPath(candidatePath)]);
+    const records = output.toString("utf8").split("\0").filter((record) => record.length > 0);
+    if (records.length !== 1)
+        throw new Error(`candidate path has no unique Git entry: ${candidatePath}`);
+    const separator = records[0].indexOf("\t");
+    if (separator < 0)
+        throw new Error(`candidate path has a malformed Git entry: ${candidatePath}`);
+    const fields = records[0].slice(0, separator).split(" ");
+    return fields[1] === "blob";
 }
-function workspaceMatchesTreeOnPaths(repository, path, tree, workspaceTree, paths) {
-    return gitPaths(repository, path, ["diff", "--name-only", "-z", tree, workspaceTree, "--", ...paths]).length === 0;
+async function destructionScopes(repository, path, candidate, writes) {
+    const scopes = new Map();
+    for (const write of writes) {
+        const scope = await physicalScope(path, write);
+        if (scope === null)
+            continue;
+        if (scope.kind === "directory" && !(await candidateEntryIsBlob(repository, path, candidate, write)))
+            continue;
+        scopes.set(scope.path, scope);
+    }
+    return [...scopes.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
-function sourceWorktree(repository) {
-    return resolve(runGit(repository, ["rev-parse", "--show-toplevel"]).toString("utf8").trim());
+function untrackedArgs(ignored) {
+    return [
+        "ls-files",
+        "--others",
+        ...(ignored ? ["--ignored"] : []),
+        "--exclude-standard",
+        "--directory",
+        "--no-empty",
+        "-z",
+    ];
 }
-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]);
-        });
+async function untrackedRefusalWithinScopes(input, scopes, ignored) {
+    const { repository, contractId, target, path } = input;
+    const args = untrackedArgs(ignored);
+    const leaves = scopes.filter((scope) => scope.kind === "leaf");
+    if (leaves.length > 0) {
+        const collisions = await gitPaths(repository, path, [
+            ...args,
+            "--",
+            ...leaves.map((scope) => literalPath(scope.path)),
+        ]);
+        if (collisions.length > 0)
+            return checkoutRefusal(contractId, target, path, "untracked", collisions);
     }
-    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,
+    for (const scope of scopes) {
+        if (scope.kind !== "directory")
+            continue;
+        let found = false;
+        await consumeGitStdout(repository, [
+            "-C",
             path,
-            reason: "untracked",
-            paths: collisions,
-        };
+            ...args,
+            "--",
+            literalPath(scope.path),
+        ], (chunk) => {
+            if (chunk.length > 0)
+                found = true;
+        });
+        if (found)
+            return checkoutRefusal(contractId, target, path, "untracked", [scope.path]);
     }
+    return null;
+}
+async function indexMatchesTreeOnPaths(repository, path, tree, paths) {
+    return (await gitPaths(repository, path, ["diff-index", "--cached", "--name-only", "-z", tree, "--", ...paths])).length === 0;
+}
+async function workspaceMatchesTreeOnPaths(repository, path, tree, workspaceTree, paths) {
+    return (await gitPaths(repository, path, ["diff", "--name-only", "-z", tree, workspaceTree, "--", ...paths])).length === 0;
+}
+async function sourceWorktree(repository) {
+    return resolve((await runGit(repository, ["rev-parse", "--show-toplevel"])).toString("utf8").trim());
+}
+async function ordinaryPrecheck(repository, contractId, target, path) {
+    const predecessor = gitObjectIdForSnapshot(target.expectedOid);
+    const candidate = gitObjectIdForSnapshot(target.newOid);
+    const observation = { repository, contractId, target, path, predecessor, candidate };
+    let dryRunFailed = false;
     try {
-        runGit(repository, ["-C", path, "read-tree", "--dry-run", "-m", "-u", predecessor, candidate]);
+        await 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);
+        if (!(error instanceof GitPlumbingError))
+            throw error;
+        dryRunFailed = true;
     }
-    return null;
+    const writes = await changedPaths(repository, path, predecessor, candidate, "ACMRT");
+    const scopes = await destructionScopes(repository, path, candidate, writes);
+    if (dryRunFailed)
+        return await dryRunRefusal(observation, scopes);
+    return await untrackedRefusalWithinScopes(observation, scopes, true);
 }
 export async function acquireTargetPlacementFence(repository, target) {
     const locator = gitRefLocator(target);
-    return acquireSqliteTransactionLock({
+    return await 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)
+/** Observe whether registered target checkouts can follow a predecessor-to-candidate movement. */
+export async function observeTargetPlacement(repository, input) {
+    const target = {
+        target: input.coordinates.target,
+        expectedOid: input.predecessor,
+        newOid: input.candidate,
+    };
+    const worktrees = (await 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;
+    const hereSource = input.coordinates.workspace === "here" ? await sourceWorktree(repository) : null;
     if (hereSource !== null) {
-        const branch = currentBranch(repository, hereSource);
+        const branch = await currentBranch(repository, hereSource);
         if (branch !== target.target) {
             return {
                 kind: "refused",
                 refusal: {
                     kind: "workspace-not-on-target",
-                    contractId: state.id,
+                    contractId: input.contractId,
                     target: target.target,
                     branch,
                 },
@@ -136,7 +220,7 @@ export function prepareTargetPlacement(repository, state, target) {
     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);
+            const refusal = await ordinaryPrecheck(repository, input.contractId, target, worktree.path);
             if (refusal !== null)
                 return { kind: "refused", refusal };
         }
@@ -145,9 +229,45 @@ export function prepareTargetPlacement(repository, state, target) {
     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 } };
+    return { kind: "ready", arms };
+}
+/** Adjudicate the complete post-Verification audit target answer without placing. */
+export async function adjudicateAuditTarget(repository, input) {
+    const ref = input.coordinates.target;
+    const expected = input.predecessor;
+    try {
+        const head = await observeTargetHead(repository, ref);
+        if (head !== expected)
+            return { kind: "moved", ref, expected, observed: head };
+        const follow = await observeTargetPlacement(repository, input);
+        const observed = await observeTargetHead(repository, ref);
+        if (observed !== expected)
+            return { kind: "moved", ref, expected, observed };
+        return follow.kind === "refused"
+            ? { kind: "refused", refusal: follow.refusal }
+            : { kind: "placeable", ref, head: expected };
+    }
+    catch (error) {
+        if (!(error instanceof GitPlumbingError))
+            throw error;
+        return { kind: "failed", diagnostic: error.message };
+    }
+}
+export async 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 observation = await observeTargetPlacement(repository, {
+        contractId: state.id,
+        coordinates: { ...state.coordinates, target: target.target },
+        predecessor: target.expectedOid,
+        candidate: target.newOid,
+    });
+    return observation.kind === "refused"
+        ? observation
+        : { kind: "prepared", placement: { target, arms: observation.arms } };
 }
-export function followTargetPlacement(repository, prepared) {
+export async function followTargetPlacement(repository, prepared) {
     const effects = [];
     const lag = [];
     const predecessor = gitObjectIdForSnapshot(prepared.target.expectedOid);
@@ -155,9 +275,9 @@ export function followTargetPlacement(repository, prepared) {
     for (const arm of prepared.arms) {
         try {
             if (arm.kind === "here")
-                runGit(repository, ["-C", arm.path, "read-tree", candidate]);
+                await runGit(repository, ["-C", arm.path, "read-tree", candidate]);
             else
-                runGit(repository, ["-C", arm.path, "read-tree", "-m", "-u", predecessor, candidate]);
+                await 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) {
@@ -174,23 +294,23 @@ export function followTargetPlacement(repository, prepared) {
 function recoveryLag(path, target, detail) {
     return { kind: "target-checkout-retained", path, target, diagnostic: detail };
 }
-function recoverCheckout(input) {
+async function recoverCheckout(input) {
     const { repository, path, predecessor, candidate, predecessorTree, candidateTree } = input;
-    const changedPaths = gitPaths(repository, path, ["diff", "--name-only", "-z", predecessorTree, candidateTree]);
+    const changedPaths = await 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);
+    const workspaceTree = (await captureWorkspaceTree(repository, path)).tree;
+    const candidateIndex = await indexMatchesTreeOnPaths(repository, path, candidateTree, changedPaths);
+    const candidateWorkspace = await workspaceMatchesTreeOnPaths(repository, path, candidateTree, workspaceTree, changedPaths);
     if (candidateIndex && candidateWorkspace)
         return "complete";
     if (workspaceTree === candidateTree) {
-        runGit(repository, ["-C", path, "read-tree", gitObjectIdForSnapshot(candidate)]);
+        await runGit(repository, ["-C", path, "read-tree", gitObjectIdForSnapshot(candidate)]);
         return "recovered";
     }
-    const predecessorIndex = indexMatchesTreeOnPaths(repository, path, predecessorTree, changedPaths);
+    const predecessorIndex = await indexMatchesTreeOnPaths(repository, path, predecessorTree, changedPaths);
     if (predecessorIndex && candidateWorkspace) {
-        runGit(repository, [
+        await runGit(repository, [
             "-C",
             path,
             "read-tree",
@@ -201,10 +321,10 @@ function recoverCheckout(input) {
         ]);
         return "recovered";
     }
-    const predecessorWorkspace = workspaceMatchesTreeOnPaths(repository, path, predecessorTree, workspaceTree, changedPaths);
+    const predecessorWorkspace = await workspaceMatchesTreeOnPaths(repository, path, predecessorTree, workspaceTree, changedPaths);
     if (!predecessorIndex || !predecessorWorkspace)
         return "retained";
-    runGit(repository, [
+    await runGit(repository, [
         "-C",
         path,
         "read-tree",
@@ -215,23 +335,23 @@ function recoverCheckout(input) {
     ]);
     return "recovered";
 }
-export function recoverTargetPlacement(repository, state) {
+export async 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)
+    if (await 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)
+    const candidateTree = await commitTree(repository, delivery.data.integration.snapshot);
+    const predecessorTree = await commitTree(repository, delivery.data.integration.predecessor);
+    const worktrees = (await 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({
+            const recovery = await recoverCheckout({
                 repository,
                 path: worktree.path,
                 predecessor: delivery.data.integration.predecessor,

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

@@ -6,6 +6,7 @@ import { captureWorkspaceTree } from "./workspace.js";
 export type TenderCaptureCoordinates = Readonly<{
     contractId: ContractId;
     coordinates: ContractCoordinates;
+    place?: string;
 }>;
 export type TenderCaptureRefusal = Readonly<{
     kind: "worktree-missing";
@@ -34,15 +35,15 @@ export type TenderCapture = Readonly<{
     tree: GitObjectId;
     head: SnapshotId;
     dirty: boolean;
-    changes: ReturnType<typeof captureWorkspaceTree>["changes"];
+    changes: Awaited<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;
+export declare function captureTender(repository: GitRepository, input: TenderCaptureCoordinates): Promise<Preparation<TenderCapture, TenderCaptureRefusal>>;
+export declare function dirtyTenderRefusal(repository: GitRepository, contractId: ContractId, tender: TenderCapture): Promise<DirtyWorkspaceRefusal>;
+export declare function dirtyTenderDelta(repository: GitRepository, tender: TenderCapture): Promise<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;
+}>): Promise<SnapshotId>;

package/build/src/git/tender.js

@@ -1,82 +1,63 @@
-import { existsSync } from "node:fs";
+import { access } from "node:fs/promises";
 import { gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
-import { registeredWorktreePaths, runGit, runGitWithEnvironment } from "./repository.js";
-import { captureWorkspaceTree, deliveryWorktreePath } from "./workspace.js";
-function workspaceExists(repository, workspace, path) {
+import { decodeGitNumstat, registeredWorktreePaths, runGit, runGitWithEnvironment } from "./repository.js";
+import { captureWorkspaceTree, worktreePath } from "./workspace.js";
+async function workspaceExists(repository, workspace, path) {
+    const exists = await access(path).then(() => true, () => false);
     return workspace === "here"
-        || (existsSync(path) && registeredWorktreePaths(repository).includes(path));
+        || (exists && (await registeredWorktreePaths(repository)).includes(path));
 }
-function workspaceFor(repository, id, workspace) {
-    return workspace === "worktree" ? deliveryWorktreePath(repository, id) : repository.effectiveCwd;
+function workspaceFor(repository, input) {
+    if (input.coordinates.workspace === "here")
+        return repository.effectiveCwd;
+    return input.place === undefined ? undefined : worktreePath(repository, input.place);
 }
 /** 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)) {
+export async function captureTender(repository, input) {
+    const workspace = workspaceFor(repository, input);
+    if (workspace === undefined || !(await workspaceExists(repository, input.coordinates.workspace, workspace))) {
         return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
     }
-    return { kind: "prepared", data: captureWorkspaceTree(repository, workspace) };
+    return { kind: "prepared", data: await captureWorkspaceTree(repository, workspace) };
 }
-function dirtyShortStat(repository, tender) {
-    const fields = runGit(repository, [
+async function dirtyShortStat(repository, tender) {
+    return decodeGitNumstat(await 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) {
+export async function dirtyTenderRefusal(repository, contractId, tender) {
     return {
         kind: "dirty-workspace",
         contractId,
         ...tender.changes,
-        shortStat: dirtyShortStat(repository, tender),
+        shortStat: await dirtyShortStat(repository, tender),
     };
 }
-export function dirtyTenderDelta(repository, tender) {
+export async function dirtyTenderDelta(repository, tender) {
     if (!tender.dirty)
         return undefined;
     const { staged, unstaged, untracked } = tender.changes;
-    return { staged, unstaged, untracked, shortStat: dirtyShortStat(repository, tender) };
+    return { staged, unstaged, untracked, shortStat: await 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) {
+export async 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), {
+    const commit = (await 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();
+    })).toString("utf8").trim();
     return mintSnapshotId(commit);
 }

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

@@ -21,4 +21,4 @@ export type TerminalSealObject = Readonly<{
 }>;
 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;
+export declare function unsealedBytes(repository: GitRepository, path: string, expected: TerminalSealExpectations): Promise<UnsealedBytes | null>;

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

@@ -57,14 +57,14 @@ export function terminalSealExpectations(state, objects) {
         treeBySnapshot,
     };
 }
-function changedPaths(repository, left, right) {
-    const fields = runGit(repository, ["diff", "--name-only", "-z", left, right]).toString("utf8").split("\0");
+async function changedPaths(repository, left, right) {
+    const fields = (await 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);
+export async function unsealedBytes(repository, path, expected) {
+    const workspace = await captureWorkspaceTree(repository, path);
     const headIsSealed = expected.heads.includes(workspace.head);
     if (workspace.changes.submodules.length > 0) {
         return {
@@ -76,7 +76,9 @@ export function unsealedBytes(repository, path, expected) {
     }
     if (headIsSealed && expected.trees.includes(workspace.tree))
         return null;
-    const alternatives = expected.trees.map((tree) => changedPaths(repository, tree, workspace.tree));
+    const alternatives = [];
+    for (const tree of expected.trees)
+        alternatives.push(await changedPaths(repository, tree, workspace.tree));
     alternatives.sort((left, right) => left.length - right.length || left.join("\0").localeCompare(right.join("\0")));
     return {
         kind: "unsealed-bytes",