@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/git/target-placement.d.ts

@@ -0,0 +1,92 @@
+import { type HeldSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
+import type { ContractId, ContractState, SnapshotId } from "../core/facts/types.js";
+import type { RefOperation } from "../core/facts/offer.js";
+import { type GitRepository } from "./repository.js";
+export type WorkspaceNotOnTargetRefusal = Readonly<{
+    kind: "workspace-not-on-target";
+    contractId: ContractId;
+    target: string;
+    branch: string | null;
+}>;
+export type CheckoutNotFollowableRefusal = Readonly<{
+    kind: "checkout-not-followable";
+    contractId: ContractId;
+    target: string;
+    path: string;
+    reason: "staged" | "conflict" | "untracked";
+    paths: readonly string[];
+}>;
+export type TargetPlacementRefusal = CheckoutNotFollowableRefusal | WorkspaceNotOnTargetRefusal;
+export type TargetCheckoutEffect = Readonly<{
+    kind: "target-checkout";
+    path: string;
+    target: string;
+    action: "followed" | "recovered";
+}>;
+export type TargetCheckoutLag = Readonly<{
+    kind: "target-checkout-retained";
+    path: string;
+    target: string;
+    diagnostic: string;
+}>;
+export type TargetPlacementPhysicalResult = Readonly<{
+    effects: readonly TargetCheckoutEffect[];
+    lag: readonly TargetCheckoutLag[];
+}>;
+type FollowArm = Readonly<{
+    kind: "ordinary" | "here";
+    path: string;
+}>;
+export type PreparedTargetPlacement = Readonly<{
+    target: RefOperation;
+    arms: readonly FollowArm[];
+}>;
+export type TargetPlacementPreparation = Readonly<{
+    kind: "prepared";
+    placement: PreparedTargetPlacement;
+}> | Readonly<{
+    kind: "refused";
+    refusal: TargetPlacementRefusal;
+}>;
+export declare function observeTargetHead(repository: GitRepository, target: string): Promise<SnapshotId | null>;
+export declare function acquireTargetPlacementFence(repository: GitRepository, target: string): Promise<HeldSqliteTransactionLock>;
+export type TargetedContractCoordinates = ContractState["coordinates"] & Readonly<{
+    target: string;
+}>;
+export type TargetPlacementObservationInput = Readonly<{
+    contractId: ContractId;
+    coordinates: TargetedContractCoordinates;
+    predecessor: SnapshotId;
+    candidate: SnapshotId;
+}>;
+export type TargetPlacementObservation = Readonly<{
+    kind: "ready";
+    arms: readonly FollowArm[];
+}> | Readonly<{
+    kind: "refused";
+    refusal: TargetPlacementRefusal;
+}>;
+/** Observe whether registered target checkouts can follow a predecessor-to-candidate movement. */
+export declare function observeTargetPlacement(repository: GitRepository, input: TargetPlacementObservationInput): Promise<TargetPlacementObservation>;
+export type AuditTargetAnswer = Readonly<{
+    kind: "placeable";
+    ref: string;
+    head: SnapshotId;
+}> | Readonly<{
+    kind: "moved";
+    ref: string;
+    expected: SnapshotId;
+    observed: SnapshotId | null;
+}> | Readonly<{
+    kind: "refused";
+    refusal: TargetPlacementRefusal;
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+/** Adjudicate the complete post-Verification audit target answer without placing. */
+export declare function adjudicateAuditTarget(repository: GitRepository, input: TargetPlacementObservationInput): Promise<AuditTargetAnswer>;
+export declare function prepareTargetPlacement(repository: GitRepository, state: ContractState, target: RefOperation): Promise<TargetPlacementPreparation>;
+export declare function followTargetPlacement(repository: GitRepository, prepared: PreparedTargetPlacement): Promise<TargetPlacementPhysicalResult>;
+export declare function recoverTargetPlacement(repository: GitRepository, state: ContractState): Promise<TargetPlacementPhysicalResult>;
+export {};

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

@@ -0,0 +1,375 @@
+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, 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) {
+    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();
+}
+async function gitPaths(repository, path, args) {
+    return nulPaths(await runGit(repository, ["-C", path, ...args]));
+}
+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 checkoutRefusal(contractId, target, path, reason, paths) {
+    return { kind: "checkout-not-followable", contractId, target: target.target, path, reason, paths };
+}
+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,
+    ]);
+}
+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", []);
+}
+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;
+}
+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";
+}
+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 untrackedArgs(ignored) {
+    return [
+        "ls-files",
+        "--others",
+        ...(ignored ? ["--ignored"] : []),
+        "--exclude-standard",
+        "--directory",
+        "--no-empty",
+        "-z",
+    ];
+}
+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);
+    }
+    for (const scope of scopes) {
+        if (scope.kind !== "directory")
+            continue;
+        let found = false;
+        await consumeGitStdout(repository, [
+            "-C",
+            path,
+            ...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 {
+        await runGit(repository, ["-C", path, "read-tree", "--dry-run", "-m", "-u", predecessor, candidate]);
+    }
+    catch (error) {
+        if (!(error instanceof GitPlumbingError))
+            throw error;
+        dryRunFailed = true;
+    }
+    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 await acquireSqliteTransactionLock({
+        path: resolve(commonGitDirectory(repository), "keiyaku", "locks", "target-placement", `${locator}.sqlite`),
+        mode: "immediate",
+    });
+}
+/** 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 = input.coordinates.workspace === "here" ? await sourceWorktree(repository) : null;
+    if (hereSource !== null) {
+        const branch = await currentBranch(repository, hereSource);
+        if (branch !== target.target) {
+            return {
+                kind: "refused",
+                refusal: {
+                    kind: "workspace-not-on-target",
+                    contractId: input.contractId,
+                    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 = await ordinaryPrecheck(repository, input.contractId, 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: "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 async 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")
+                await runGit(repository, ["-C", arm.path, "read-tree", candidate]);
+            else
+                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) {
+            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 };
+}
+async function recoverCheckout(input) {
+    const { repository, path, predecessor, candidate, predecessorTree, candidateTree } = input;
+    const changedPaths = await gitPaths(repository, path, ["diff", "--name-only", "-z", predecessorTree, candidateTree]);
+    if (changedPaths.length === 0)
+        return "complete";
+    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) {
+        await runGit(repository, ["-C", path, "read-tree", gitObjectIdForSnapshot(candidate)]);
+        return "recovered";
+    }
+    const predecessorIndex = await indexMatchesTreeOnPaths(repository, path, predecessorTree, changedPaths);
+    if (predecessorIndex && candidateWorkspace) {
+        await runGit(repository, [
+            "-C",
+            path,
+            "read-tree",
+            "-i",
+            "-m",
+            gitObjectIdForSnapshot(predecessor),
+            gitObjectIdForSnapshot(candidate),
+        ]);
+        return "recovered";
+    }
+    const predecessorWorkspace = await workspaceMatchesTreeOnPaths(repository, path, predecessorTree, workspaceTree, changedPaths);
+    if (!predecessorIndex || !predecessorWorkspace)
+        return "retained";
+    await runGit(repository, [
+        "-C",
+        path,
+        "read-tree",
+        "-m",
+        "-u",
+        gitObjectIdForSnapshot(predecessor),
+        gitObjectIdForSnapshot(candidate),
+    ]);
+    return "recovered";
+}
+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 (await readRef(repository, target) !== delivery.data.integration.snapshot)
+        return { effects: [], lag: [] };
+    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 = await 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,49 @@
+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;
+    place?: string;
+}>;
+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: Awaited<ReturnType<typeof captureWorkspaceTree>>["changes"];
+}>;
+/** Capture the complete workspace tree through Git's private index mechanics. */
+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;
+}>): Promise<SnapshotId>;

package/build/src/git/tender.js

@@ -0,0 +1,63 @@
+import { access } from "node:fs/promises";
+import { gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
+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"
+        || (exists && (await registeredWorktreePaths(repository)).includes(path));
+}
+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 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: await captureWorkspaceTree(repository, workspace) };
+}
+async function dirtyShortStat(repository, tender) {
+    return decodeGitNumstat(await runGit(repository, [
+        "diff",
+        "--numstat",
+        "-z",
+        gitObjectIdForSnapshot(tender.head),
+        tender.tree,
+    ]));
+}
+export async function dirtyTenderRefusal(repository, contractId, tender) {
+    return {
+        kind: "dirty-workspace",
+        contractId,
+        ...tender.changes,
+        shortStat: await dirtyShortStat(repository, tender),
+    };
+}
+export async function dirtyTenderDelta(repository, tender) {
+    if (!tender.dirty)
+        return undefined;
+    const { staged, unstaged, untracked } = tender.changes;
+    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 async function materializeTenderSnapshot(repository, tender, input) {
+    if (!tender.dirty)
+        return tender.head;
+    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();
+    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): Promise<UnsealedBytes | null>;