@astrosheep/keiyaku 4.1.1 → 4.1.2

package/build/src/git/reconcile.js

@@ -2,15 +2,15 @@ import { access, mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { acquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { CANDIDATE_PIN_REF_NAMESPACE, commonGitDirectory, DELIVERY_REF_NAMESPACE, isKeiyakuOwnedRef, readRef, registeredWorktreePaths, writeCommit, worktreeGitDirectory, } from "./repository.js";
-import { GitPlumbingError, runGit } from "./process.js";
-import { contractLocator, contractPhysicalName, gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
+import { CANDIDATE_PIN_REF_NAMESPACE, commonGitDirectory, DELIVERY_REF_NAMESPACE, registeredWorktreePaths, worktreeGitDirectory, } from "./repository.js";
+import { runGit } from "./process.js";
+import { contractLocator, contractPhysicalName, gitObjectIdForSnapshot } from "./identity.js";
 import { observeContractAt } from "./observe.js";
 import { acquireTargetPlacementFence, recoverTargetPlacement, } from "./target-placement.js";
-import { runCreateHooks, runDestroyHooks } from "./hooks.js";
+import { runCreateHooks } from "./hooks.js";
 import { followManagedWorktree, worktreePath } from "./workspace.js";
-import { collectableScratchWorktrees } from "./scratch.js";
-import { terminalSealExpectations as decodeTerminalSealExpectations, terminalSealSnapshots, observeTerminalWorkspace, } from "./terminal-seal.js";
+import { removeCollectableScratchWorktrees } from "./scratch.js";
+import { reconcileTerminalManagedWorktree, removeRef, updateRef } from "./terminal-reconcile.js";
 const pathExists = (path) => access(path).then(() => true, () => false);
 function deliveryRefFor(contract) {
     return `${DELIVERY_REF_NAMESPACE}/${contractPhysicalName(contract)}`;
@@ -25,52 +25,9 @@ function missingPlaceLag(repository) {
         diagnostic: `managed Contract is unappointed: ${join(repository.commonDirectory, "keiyaku", "places.json")}`,
     };
 }
-async function updateRef(repository, ref, desired) {
-    const before = await readRef(repository, ref);
-    if (before === desired)
-        return { kind: "ref", name: ref, action: "unchanged", before, after: desired };
-    await runGit(repository, [
-        "update-ref",
-        "--no-deref",
-        ref,
-        gitObjectIdForSnapshot(desired),
-        before ?? "0".repeat(desired.length),
-    ]);
-    return { kind: "ref", name: ref, action: before === null ? "created" : "updated", before, after: desired };
-}
-async function removeRef(repository, ref) {
-    const before = await readRef(repository, ref);
-    if (before === null)
-        return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
-    await runGit(repository, ["update-ref", "--no-deref", "-d", ref, before]);
-    return { kind: "ref", name: ref, action: "removed", before, after: null };
-}
-async function removeRefWithCustody(repository, ref, custodian, expectedCustodian) {
-    const before = await readRef(repository, ref);
-    if (before === null)
-        return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
-    if ((await readRef(repository, custodian)) !== expectedCustodian) {
-        return { kind: "ref", name: ref, action: "unchanged", before, after: before };
-    }
-    await runGit(repository, ["update-ref", "--stdin", "--no-deref"], [
-        "start",
-        `verify ${custodian} ${gitObjectIdForSnapshot(expectedCustodian)}`,
-        `delete ${ref} ${before}`,
-        "prepare",
-        "commit",
-        "",
-    ].join("\n"));
-    return { kind: "ref", name: ref, action: "removed", before, after: null };
-}
-function retainedRefEffect(ref, snapshot) {
-    return { kind: "ref", name: ref, action: "unchanged", before: snapshot, after: snapshot };
-}
 async function acquireWorktreeTopology(repository) {
     return { paths: new Set(await registeredWorktreePaths(repository)) };
 }
-function fromPrimaryWorktree(repository) {
-    return { ...repository, effectiveCwd: repository.primaryWorktree };
-}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -101,75 +58,13 @@ async function worktree(repository, topology, path, desired) {
     topology.paths.add(path);
     return { kind: "worktree", path, action: "created" };
 }
-async function removeWorktree(repository, topology, path, force = false) {
-    const registered = topology.paths.has(path);
-    if (!registered) {
-        return {
-            effect: { kind: "worktree", path, action: "unchanged" },
-            retained: await pathExists(path),
-        };
-    }
-    if (!(await pathExists(path))) {
-        await runGit(repository, ["worktree", "remove", path]);
-        topology.paths.delete(path);
-        return { effect: { kind: "worktree", path, action: "removed" }, retained: false };
-    }
-    try {
-        await runGit(repository, ["worktree", "remove", ...(force ? ["--force"] : []), path]);
-    }
-    catch {
-        return { effect: { kind: "worktree", path, action: "unchanged" }, retained: true };
-    }
-    topology.paths.delete(path);
-    return { effect: { kind: "worktree", path, action: "removed" }, retained: false };
-}
 async function removeCollectableScratch(repository, topology, effects, lag) {
-    for (const scratch of await collectableScratchWorktrees(topology.paths)) {
-        try {
-            const removal = await removeWorktree(repository, topology, scratch.path, true);
-            effects.push(removal.effect);
-            if (removal.retained)
-                lag.push({ kind: "worktree-retained", path: scratch.path });
-        }
-        finally {
-            scratch.release();
-        }
+    for (const removal of await removeCollectableScratchWorktrees(repository, topology.paths)) {
+        effects.push({ kind: "worktree", path: removal.path, action: removal.action });
+        if (removal.retained)
+            lag.push({ kind: "worktree-retained", path: removal.path });
     }
 }
-async function refRows(repository) {
-    const output = (await runGit(repository, ["for-each-ref", "--format=%(refname)%00%(objectname)"])).toString("utf8");
-    if (output.length === 0)
-        return [];
-    return output
-        .trimEnd()
-        .split("\n")
-        .map((row) => {
-        const [ref, oid, extra] = row.split("\0");
-        if (ref === undefined || oid === undefined || extra !== undefined)
-            throw new Error("Git ref row is malformed");
-        return { ref, oid };
-    });
-}
-async function commitIsAncestor(repository, ancestor, descendant) {
-    try {
-        await runGit(repository, ["merge-base", "--is-ancestor", gitObjectIdForSnapshot(ancestor), descendant]);
-        return true;
-    }
-    catch (error) {
-        if (error instanceof GitPlumbingError && error.status === 1)
-            return false;
-        throw error;
-    }
-}
-async function snapshotCustodian(repository, snapshot) {
-    for (const row of await refRows(repository)) {
-        if (isKeiyakuOwnedRef(row.ref))
-            continue;
-        if (await commitIsAncestor(repository, snapshot, row.oid))
-            return { ref: row.ref, oid: mintSnapshotId(row.oid) };
-    }
-    return null;
-}
 async function reconcileTargetCheckouts(repository, state) {
     if (state.terminal?.kind !== "claimed" || state.coordinates.target === undefined || state.delivery === null) {
         return complete();
@@ -208,190 +103,6 @@ async function reconcileTargetCheckouts(repository, state) {
         result = failed("effect", releaseFailure, result.effects, result.lag);
     return result;
 }
-function retainTerminalWorktree(path, retainedLag, { effects, lag }) {
-    effects.push({ kind: "worktree", path, action: "unchanged" });
-    lag.push(retainedLag);
-    return complete(effects, lag);
-}
-async function terminalSealExpectations(channel, state) {
-    const snapshots = terminalSealSnapshots(state);
-    const objects = await channel.readObjects(snapshots.map(gitObjectIdForSnapshot));
-    return decodeTerminalSealExpectations(state, objects);
-}
-async function removeSealedTerminalWorktree({ repository, topology, path, state, expected, hooks, retryHooks, acc, }) {
-    if (topology.paths.has(path) && (await pathExists(path))) {
-        const terminal = state.terminal;
-        if (terminal === null)
-            throw new Error(`terminal worktree cleanup received active Contract ${state.id}`);
-        const canRecover = terminal.kind === "abandoned";
-        let recovery = null;
-        const recordRecovery = async (workspace) => {
-            const snapshot = mintSnapshotId(await writeCommit({
-                repository,
-                tree: workspace.tree,
-                parent: gitObjectIdForSnapshot(recovery?.snapshot ?? workspace.head),
-                message: `${state.id}: ephemeral abandoned-workspace recovery\n\nKeiyaku-Contract: ${state.id}`,
-                actor: "Keiyaku Recovery",
-                at: terminal.at,
-            }));
-            const effect = {
-                kind: "recovery-snapshot",
-                action: "created",
-                snapshot,
-                retention: "ephemeral",
-            };
-            const existing = acc.effects.findIndex((item) => item.kind === "recovery-snapshot");
-            if (existing < 0)
-                acc.effects.push(effect);
-            else
-                acc.effects[existing] = effect;
-            return { snapshot, workspace };
-        };
-        const before = await observeTerminalWorkspace(repository, path, expected);
-        const beforeWorkspace = before.workspace;
-        const beforeHooks = before.unsealed;
-        if (beforeHooks !== null) {
-            if (!canRecover || beforeWorkspace.submodules.length > 0) {
-                return retainTerminalWorktree(path, beforeHooks, acc);
-            }
-            recovery = await recordRecovery(beforeWorkspace);
-        }
-        const hookLag = await runDestroyHooks(path, await worktreeGitDirectory(repository, path), hooks, retryHooks);
-        if (hookLag !== null)
-            return retainTerminalWorktree(path, hookLag, acc);
-        const after = await observeTerminalWorkspace(repository, path, expected);
-        const afterWorkspace = after.workspace;
-        const afterHooks = after.unsealed;
-        if (afterHooks !== null) {
-            if (!canRecover || afterWorkspace.submodules.length > 0) {
-                return retainTerminalWorktree(path, afterHooks, acc);
-            }
-        }
-        if (canRecover &&
-            (recovery === null ||
-                recovery.workspace.head !== afterWorkspace.head ||
-                recovery.workspace.tree !== afterWorkspace.tree) &&
-            (recovery !== null ||
-                beforeWorkspace.head !== afterWorkspace.head ||
-                beforeWorkspace.tree !== afterWorkspace.tree)) {
-            recovery = await recordRecovery(afterWorkspace);
-        }
-    }
-    const removal = await removeWorktree(repository, topology, path, true);
-    if (removal.retained)
-        return retainTerminalWorktree(path, { kind: "worktree-retained", path }, acc);
-    acc.effects.push(removal.effect);
-    return null;
-}
-async function targetCustodyForClaimedIntegration(repository, state, integration) {
-    if (state.terminal?.kind !== "claimed" || state.coordinates.target === undefined)
-        return null;
-    const target = await readRef(repository, state.coordinates.target);
-    if (target === null)
-        return null;
-    const oid = mintSnapshotId(target);
-    return (await commitIsAncestor(repository, integration, oid)) ? { ref: state.coordinates.target, oid } : null;
-}
-function sealedTree(expected, snapshot) {
-    const tree = expected.treeBySnapshot.get(snapshot);
-    if (tree === undefined)
-        throw new Error(`terminal seal tree was not resolved: ${snapshot}`);
-    return tree;
-}
-async function releaseTerminalCustody({ repository, state, resolveSeal, ref, pin, acc: { effects }, }) {
-    const [deliveryRef, candidatePin] = await Promise.all([readRef(repository, ref), readRef(repository, pin)]);
-    if (deliveryRef === null && candidatePin === null)
-        return;
-    if (state.delivery === null) {
-        const custodian = await snapshotCustodian(repository, state.coordinates.start);
-        if (deliveryRef !== null) {
-            effects.push(custodian === null
-                ? retainedRefEffect(ref, deliveryRef)
-                : await removeRefWithCustody(repository, ref, custodian.ref, custodian.oid));
-        }
-        if (candidatePin !== null)
-            effects.push(await removeRef(repository, pin));
-        return;
-    }
-    const tender = state.delivery.data.tenderSnapshot;
-    const integration = state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot;
-    const target = await targetCustodyForClaimedIntegration(repository, state, integration);
-    if (deliveryRef !== null && target !== null) {
-        if (tender === integration) {
-            effects.push(await removeRefWithCustody(repository, ref, target.ref, target.oid));
-        }
-        else {
-            const expected = await resolveSeal();
-            if (sealedTree(expected, tender) === sealedTree(expected, integration)) {
-                effects.push(await removeRefWithCustody(repository, ref, target.ref, target.oid));
-            }
-            else {
-                effects.push(retainedRefEffect(ref, deliveryRef));
-            }
-        }
-    }
-    else if (deliveryRef !== null) {
-        effects.push(retainedRefEffect(ref, deliveryRef));
-    }
-    if (candidatePin !== null) {
-        if (target !== null) {
-            effects.push(await removeRefWithCustody(repository, pin, target.ref, target.oid));
-        }
-        else if (tender === integration && deliveryRef !== null) {
-            effects.push(await removeRefWithCustody(repository, pin, ref, tender));
-        }
-        else {
-            effects.push(retainedRefEffect(pin, candidatePin));
-        }
-    }
-}
-async function reconcileTerminalManagedWorktree({ repository, channel, hooks, retryHooks, retainTerminalWorktree, place }, state, topology, acc) {
-    const primary = fromPrimaryWorktree(repository);
-    const ref = deliveryRefFor(state.id);
-    const pin = candidatePinRefFor(state.id);
-    const path = place === undefined ? undefined : worktreePath(repository, place);
-    if (path === undefined) {
-        if (retainTerminalWorktree === true)
-            return complete(acc.effects, acc.lag);
-        await releaseTerminalCustody({
-            repository: primary,
-            state,
-            resolveSeal: async () => await terminalSealExpectations(channel, state),
-            ref,
-            pin,
-            acc,
-        });
-        return complete(acc.effects, acc.lag);
-    }
-    const expected = await terminalSealExpectations(channel, state);
-    acc.effects.push(await updateRef(primary, ref, state.delivery?.data.tenderSnapshot ?? state.coordinates.start));
-    if (state.delivery !== null) {
-        acc.effects.push(await updateRef(primary, pin, state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot));
-    }
-    if (retainTerminalWorktree === true)
-        return complete(acc.effects, acc.lag);
-    const retained = await removeSealedTerminalWorktree({
-        repository: primary,
-        topology,
-        path,
-        state,
-        expected,
-        hooks,
-        retryHooks,
-        acc,
-    });
-    if (retained !== null)
-        return retained;
-    await releaseTerminalCustody({
-        repository: primary,
-        state,
-        resolveSeal: async () => expected,
-        ref,
-        pin,
-        acc,
-    });
-    return complete(acc.effects, acc.lag);
-}
 async function reconcileActiveManagedWorktree({ repository, hooks, retryHooks, place }, state, topology, { effects, lag }) {
     if (place === undefined)
         return complete(effects, [...lag, missingPlaceLag(repository)]);
@@ -439,8 +150,9 @@ async function reconcileWithTopology(input, state, topology) {
         const targetCheckouts = await reconcileTargetCheckouts(repository, state);
         effects.push(...targetCheckouts.effects);
         lag.push(...targetCheckouts.lag);
-        if (state.terminal)
-            return await reconcileTerminalManagedWorktree(input, state, topology, { effects, lag });
+        if (state.terminal) {
+            return await reconcileTerminalManagedWorktree(input, state, topology, { effects, lag }, { ref: deliveryRefFor(state.id), pin: candidatePinRefFor(state.id) });
+        }
         return await reconcileActiveManagedWorktree(input, state, topology, { effects, lag });
     }
     catch (error) {

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

@@ -4,14 +4,17 @@ export type MaterializedScratchCandidate = Readonly<{
     cwd: string;
     dispose: () => Promise<WorktreeLeak | null>;
 }>;
-export type CollectableScratchWorktree = Readonly<{
-    path: string;
-    release(): void;
-}>;
 export type WorktreeLeak = Readonly<{
     path: string;
     diagnostic: string;
 }>;
-export declare function collectableScratchWorktrees(paths: Iterable<string>): Promise<readonly CollectableScratchWorktree[]>;
+type CollectableScratchRemoval = Readonly<{
+    path: string;
+    action: "removed" | "unchanged";
+    retained: boolean;
+}>;
+/** Remove only abandoned Verification scratch worktrees whose ownership locks are held. */
+export declare function removeCollectableScratchWorktrees(repository: GitRepository, paths: Set<string>): Promise<readonly CollectableScratchRemoval[]>;
 /** Materialize a disposable candidate worktree and own only its removal. */
 export declare function materializeScratchCandidate(repository: GitRepository, candidate: SnapshotId): Promise<MaterializedScratchCandidate>;
+export {};

package/build/src/git/scratch.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { realpath } from "node:fs/promises";
+import { access, realpath } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { tryAcquireSqliteTransactionLock, } from "../coordination/sqlite-transaction-lock.js";
@@ -17,7 +17,7 @@ function ownershipLockPath(path) {
     const match = SCRATCH_PATTERN.exec(basename(path));
     return match === null ? null : join(SCRATCH_ROOT, `.${SCRATCH_PREFIX}${match[1]}.owner.sqlite`);
 }
-export async function collectableScratchWorktrees(paths) {
+async function collectableScratchWorktrees(paths) {
     const collectable = [];
     for (const path of paths) {
         const lockPath = ownershipLockPath(path);
@@ -29,6 +29,33 @@ export async function collectableScratchWorktrees(paths) {
     }
     return collectable;
 }
+const pathExists = (path) => access(path).then(() => true, () => false);
+/** Remove only abandoned Verification scratch worktrees whose ownership locks are held. */
+export async function removeCollectableScratchWorktrees(repository, paths) {
+    const removals = [];
+    for (const scratch of await collectableScratchWorktrees(paths)) {
+        try {
+            if (!(await pathExists(scratch.path))) {
+                await runGit(repository, ["worktree", "remove", scratch.path]);
+                paths.delete(scratch.path);
+                removals.push({ path: scratch.path, action: "removed", retained: false });
+                continue;
+            }
+            try {
+                await runGit(repository, ["worktree", "remove", "--force", scratch.path]);
+                paths.delete(scratch.path);
+                removals.push({ path: scratch.path, action: "removed", retained: false });
+            }
+            catch {
+                removals.push({ path: scratch.path, action: "unchanged", retained: true });
+            }
+        }
+        finally {
+            scratch.release();
+        }
+    }
+    return removals;
+}
 /** Materialize a disposable candidate worktree and own only its removal. */
 export async function materializeScratchCandidate(repository, candidate) {
     const cwd = scratchPath();

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

@@ -0,0 +1,21 @@
+import type { ContractState, SnapshotId } from "../core/facts/types.js";
+import type { GitDecodeChannel } from "./read-observation.js";
+import { type WorktreeHooks } from "./hooks.js";
+import { type GitRepository } from "./process.js";
+import type { Effect, ReconcileAccumulation, ReconcileResult, WorktreeTopology } from "./reconcile.js";
+type TerminalReconcileInput = Readonly<{
+    repository: GitRepository;
+    channel: GitDecodeChannel;
+    hooks: WorktreeHooks;
+    retryHooks: boolean;
+    retainTerminalWorktree?: boolean;
+    place?: string;
+}>;
+type TerminalCustodyRefs = Readonly<{
+    ref: string;
+    pin: string;
+}>;
+export declare function updateRef(repository: GitRepository, ref: string, desired: SnapshotId): Promise<Effect>;
+export declare function removeRef(repository: GitRepository, ref: string): Promise<Effect>;
+export declare function reconcileTerminalManagedWorktree({ repository, channel, hooks, retryHooks, retainTerminalWorktree, place }: TerminalReconcileInput, state: ContractState, topology: WorktreeTopology, acc: ReconcileAccumulation, { ref, pin }: TerminalCustodyRefs): Promise<ReconcileResult>;
+export {};