@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/core/facts/fold.js

@@ -1,4 +1,3 @@
-import { samePrerequisites } from "./eligibility.js";
 import { gatesSatisfied } from "./gate.js";
 import { AuthorityCorruptionError } from "./errors.js";
 function foldError(message) {
@@ -47,12 +46,8 @@ function foldEntry(state, entry, attestations) {
     switch (entry.kind) {
         case "bind":
             foldError("bind may appear only once");
-        case "amend": {
-            if (state.bound !== null && !samePrerequisites(state.terms.after, entry.data.after)) {
-                foldError("cannot change after once prerequisites are consumed");
-            }
+        case "amend":
             return { ...state, terms: cloneTerms(entry.data) };
-        }
         case "bound":
             if (state.bound !== null)
                 foldError("bound may appear only once");

package/build/src/core/facts/gate.d.ts

@@ -3,6 +3,7 @@ export type GateCurrent = Readonly<{
     kind: "attested";
     verdict: "satisfied" | "unsatisfied";
     summary?: string;
+    at: string;
 }> | Readonly<{
     kind: "stale";
     priorVerdict: "satisfied" | "unsatisfied";

package/build/src/core/facts/gate.js

@@ -37,6 +37,7 @@ export function gateReports(state) {
                     kind: "attested",
                     verdict: attestation.data.verdict,
                     ...(attestation.data.summary === undefined ? {} : { summary: attestation.data.summary }),
+                    at: attestation.at,
                 },
             };
         }

package/build/src/core/verbs/amend.d.ts

@@ -8,7 +8,7 @@ export type AmendInput<Failure = never> = Readonly<{
     preparation?: Preparation<AmendData, Failure>;
 }>;
 export type AmendRefusal = Readonly<{
-    kind: "contract-missing" | "terminal" | "terms-moved" | "prerequisites-already-consumed" | "unknown-prerequisite" | "cyclic-prerequisite";
+    kind: "contract-missing" | "terminal" | "terms-moved" | "unknown-prerequisite" | "cyclic-prerequisite";
     contractId: ContractId;
 }>;
 export declare function decideAmend<Failure>({ input, attempt, observation }: DecideInput<AmendInput<Failure>>): OfferDecision<AmendRefusal | Failure>;

package/build/src/core/verbs/amend.js

@@ -1,13 +1,5 @@
 import { prerequisitesReach, samePrerequisites } from "../facts/eligibility.js";
 import { activeContract, prerequisiteStatus } from "../facts/observation.js";
-function prerequisitesConsumed(current, next, observation) {
-    if (samePrerequisites(current.terms.after, next.after))
-        return false;
-    const status = prerequisiteStatus(current.terms.after, observation);
-    if (status === "unknown")
-        throw new Error("current prerequisite is absent from the decision observation");
-    return current.bound !== null || status === "claimed";
-}
 export function decideAmend({ input, attempt, observation }) {
     const id = input.contractId;
     const current = activeContract(observation, id);
@@ -29,9 +21,6 @@ export function decideAmend({ input, attempt, observation }) {
     if (input.preparation.kind === "refused")
         return { kind: "refused", refusal: input.preparation.refusal };
     const { data } = input.preparation;
-    if (prerequisitesConsumed(current, data, observation)) {
-        return { kind: "refused", refusal: { kind: "prerequisites-already-consumed", contractId: id } };
-    }
     const prerequisites = prerequisiteStatus(data.after, observation);
     if (prerequisites === "unknown") {
         return { kind: "refused", refusal: { kind: "unknown-prerequisite", contractId: id } };

package/build/src/core/verbs/deliver.d.ts

@@ -7,7 +7,7 @@ export type DeliverInput<Failure = never> = Readonly<{
     preparation: StampedPreparation<DeliverData, Failure>;
 }>;
 export type DeliverRefusal = Readonly<{
-    kind: "contract-missing" | "not-bound" | "terminal" | "document-moved";
+    kind: "contract-missing" | "terminal" | "document-moved";
     contractId: ContractId;
 }>;
 export declare function decideDeliver<Failure>({ input, attempt, observation, }: DecideInput<DeliverInput<Failure>>): OfferDecision<DeliverRefusal | Failure>;

package/build/src/core/verbs/deliver.js

@@ -1,14 +1,8 @@
-import { activeContract, documentIsCurrent, prerequisiteStatus } from "../facts/observation.js";
+import { activeContract, documentIsCurrent } from "../facts/observation.js";
 export function decideDeliver({ input, attempt, observation, }) {
     const state = activeContract(observation, input.contractId);
     if ("kind" in state)
         return { kind: "refused", refusal: state };
-    const prerequisites = state.bound === null
-        ? prerequisiteStatus(state.terms.after, observation)
-        : "claimed";
-    if (prerequisites !== "claimed") {
-        return { kind: "refused", refusal: { kind: "not-bound", contractId: input.contractId } };
-    }
     if (input.preparation.kind === "unavailable") {
         throw new Error("existing contract requires a stamped delivery preparation");
     }

package/build/src/core/verbs/placement.d.ts

@@ -6,7 +6,7 @@ type PlacementInput = Readonly<{
     at: string;
 }>;
 export type PlacementRefusal = Readonly<{
-    kind: "contract-missing" | "delivery-missing" | "terminal" | "gates-unsatisfied";
+    kind: "contract-missing" | "delivery-missing" | "terminal" | "prerequisites-unsatisfied" | "gates-unsatisfied";
     contractId: ContractId;
 }>;
 export declare function decidePlacement({ input, attempt, observation }: DecideInput<PlacementInput>): OfferDecision<PlacementRefusal>;

package/build/src/core/verbs/placement.js

@@ -1,5 +1,5 @@
 import { gatesSatisfied } from "../facts/gate.js";
-import { activeContract } from "../facts/observation.js";
+import { activeContract, prerequisiteStatus } from "../facts/observation.js";
 export function decidePlacement({ input, attempt, observation }) {
     const id = input.contractId;
     const current = activeContract(observation, id);
@@ -9,6 +9,9 @@ export function decidePlacement({ input, attempt, observation }) {
     if (!delivery) {
         return { kind: "refused", refusal: { kind: "delivery-missing", contractId: id } };
     }
+    if (prerequisiteStatus(current.terms.after, observation) !== "claimed") {
+        return { kind: "refused", refusal: { kind: "prerequisites-unsatisfied", contractId: id } };
+    }
     if (!gatesSatisfied(current)) {
         return { kind: "refused", refusal: { kind: "gates-unsatisfied", contractId: id } };
     }

package/build/src/dispatch/index.d.ts

@@ -23,11 +23,11 @@ export type DispatchPublication = Readonly<{
     kind: "failed";
     failure: DispatchFailure;
 }>;
-export declare function readDispatch(repository: GitRepository, value: AkuId): Dispatch | null;
+export declare function readDispatch(repository: GitRepository, value: AkuId): Promise<Dispatch | null>;
 export declare function readDispatchesAt(observation: GitReadObservation): Promise<readonly Dispatch[]>;
 export declare function readDispatches(repository: GitRepository): Promise<readonly Dispatch[]>;
 export declare function publishDispatch(input: Readonly<{
     repository: GitRepository;
     akuId: AkuId;
     contractId: ContractId;
-}>): DispatchPublication;
+}>): Promise<DispatchPublication>;

package/build/src/dispatch/index.js

@@ -64,19 +64,19 @@ function decode(path, bytes) {
     }
     return dispatch;
 }
-function dispatchFromSnapshot(repository, snapshot, akuId) {
+async function dispatchFromSnapshot(repository, snapshot, akuId) {
     const path = pathFor(akuId);
     const entry = snapshot.paths.get(path);
     if (entry === undefined)
         return null;
     if (entry.type !== "blob")
         corruption(`Dispatch path is not a blob: ${path}`);
-    return decode(path, readBlob(repository, entry.oid));
+    return decode(path, await readBlob(repository, entry.oid));
 }
-export function readDispatch(repository, value) {
+export async function readDispatch(repository, value) {
     const akuId = parseAkuId(value).id;
     const path = pathFor(akuId);
-    return dispatchFromSnapshot(repository, readGitPaths(repository, [path]), akuId);
+    return await dispatchFromSnapshot(repository, await readGitPaths(repository, [path]), akuId);
 }
 export async function readDispatchesAt(observation) {
     const entries = [...observation.snapshot.paths]
@@ -105,10 +105,10 @@ export async function readDispatchesAt(observation) {
     return dispatches.sort((left, right) => Buffer.compare(Buffer.from(left.akuId), Buffer.from(right.akuId)));
 }
 export async function readDispatches(repository) {
-    return withGitDecodeChannel(repository, (channel) => withGitReadObservation(repository, channel, readDispatchesAt));
+    return await withGitDecodeChannel(repository, (channel) => withGitReadObservation(repository, channel, readDispatchesAt));
 }
-function observedPublication(repository, akuId, owner) {
-    const current = readDispatch(repository, akuId);
+async function observedPublication(repository, akuId, owner) {
+    const current = await readDispatch(repository, akuId);
     if (current === null)
         return null;
     return current.contractId === owner
@@ -118,14 +118,14 @@ function observedPublication(repository, akuId, owner) {
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
-export function publishDispatch(input) {
+export async function publishDispatch(input) {
     const akuId = parseAkuId(input.akuId).id;
     const owner = contractId(input.contractId);
     const intended = { akuId, contractId: owner, dispatchedAt: new Date().toISOString() };
     const path = pathFor(akuId);
     for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
-        const snapshot = readGitPaths(input.repository, [path]);
-        const current = dispatchFromSnapshot(input.repository, snapshot, akuId);
+        const snapshot = await readGitPaths(input.repository, [path]);
+        const current = await dispatchFromSnapshot(input.repository, snapshot, akuId);
         if (current !== null) {
             return current.contractId === owner
                 ? { kind: "dispatched", dispatch: current }
@@ -133,29 +133,29 @@ export function publishDispatch(input) {
         }
         const changes = new Map();
         if (snapshot.commit === null) {
-            changes.set(GIT_FORMAT_PATH, { oid: writeBlob(input.repository, GIT_FORMAT_BYTES) });
+            changes.set(GIT_FORMAT_PATH, { oid: await writeBlob(input.repository, GIT_FORMAT_BYTES) });
         }
-        changes.set(path, { oid: writeBlob(input.repository, bytesFor(intended)) });
-        const tree = updateGitTree(input.repository, snapshot.tree, changes);
-        const commit = writeCommit({
+        changes.set(path, { oid: await writeBlob(input.repository, bytesFor(intended)) });
+        const tree = await updateGitTree(input.repository, snapshot.tree, changes);
+        const commit = await writeCommit({
             repository: input.repository,
             tree,
             parent: snapshot.commit,
             message: `dispatch ${akuId}`,
             at: intended.dispatchedAt,
         });
-        const publication = updateRefsAtomically(input.repository, [{
+        const publication = await updateRefsAtomically(input.repository, [{
                 ref: GIT_REF,
                 newOid: commit,
                 expectedOid: snapshot.commit,
             }]);
         if (publication.kind === "published")
             return { kind: "dispatched", dispatch: intended };
-        const observed = observedPublication(input.repository, akuId, owner);
+        const observed = await observedPublication(input.repository, akuId, owner);
         if (observed !== null)
             return observed;
         if (publication.kind === "non-published") {
-            const fresh = readGitPaths(input.repository, [path]);
+            const fresh = await readGitPaths(input.repository, [path]);
             if (fresh.commit === snapshot.commit) {
                 return {
                     kind: "failed",

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

@@ -14,5 +14,5 @@ type Unknown = Readonly<{
     kind: "unknown";
 }>;
 export type Admission = Accepted | PublicationFailed | Unknown;
-export declare function admit(repository: GitRepository, offer: Offer, admission: GitAdmissionSnapshot, assertions?: readonly GitRefAssertion[]): Admission;
+export declare function admit(repository: GitRepository, offer: Offer, admission: GitAdmissionSnapshot, assertions?: readonly GitRefAssertion[]): Promise<Admission>;
 export {};

package/build/src/git/admission.js

@@ -53,16 +53,16 @@ function readCanonicalJournal(admission, id) {
         throw new Error(`missing frozen journal bytes: ${path}`);
     return { bytes: journal, path };
 }
-function buildOffer(repository, admission, appends, companions) {
+async function buildOffer(repository, admission, appends, companions) {
     const snapshot = admission.snapshot;
     const changes = new Map();
     const heads = {};
     if (snapshot.commit === null) {
-        changes.set(GIT_FORMAT_PATH, { oid: writeBlob(repository, GIT_FORMAT_BYTES), mode: "100644", type: "blob" });
+        changes.set(GIT_FORMAT_PATH, { oid: await writeBlob(repository, GIT_FORMAT_BYTES), mode: "100644", type: "blob" });
     }
     for (const companion of companions) {
         changes.set(companion.path, {
-            oid: writeBlob(repository, companion.bytes),
+            oid: await writeBlob(repository, companion.bytes),
             mode: "100644",
             type: "blob",
         });
@@ -72,7 +72,7 @@ function buildOffer(repository, admission, appends, companions) {
         let journal = current.bytes;
         for (const entry of append.entries)
             journal = Buffer.concat([journal, Buffer.from(encodeEntry(entry))]);
-        const blob = writeBlob(repository, journal);
+        const blob = await writeBlob(repository, journal);
         const entries = decodeJournal(journal.toString("utf8"));
         const terminal = entries.some((entry) => entry.kind === "claimed" || entry.kind === "abandoned");
         const destination = contractJournalPath(append.contractId, terminal ? "terminal" : "active");
@@ -83,15 +83,15 @@ function buildOffer(repository, admission, appends, companions) {
     }
     return { changes, heads };
 }
-function publishOffer(repository, admission, target, changes, assertions) {
+async function publishOffer(repository, admission, target, changes, assertions) {
     const { snapshot } = admission;
-    const gitTree = updateGitTreeFromFrozenDirectories(repository, snapshot.tree, admission.treeDirectories, changes);
-    const gitCommit = mintSnapshotId(writeCommit({
+    const gitTree = await updateGitTreeFromFrozenDirectories(repository, snapshot.tree, admission.treeDirectories, changes);
+    const gitCommit = mintSnapshotId(await writeCommit({
         repository,
         tree: gitTree,
         parent: snapshot.commit,
     }));
-    return updateRefsAtomically(repository, [
+    return await updateRefsAtomically(repository, [
         { ref: GIT_REF, newOid: gitObjectIdForSnapshot(gitCommit), expectedOid: snapshot.commit },
         ...(target === null
             ? []
@@ -102,15 +102,15 @@ function publishOffer(repository, admission, target, changes, assertions) {
                 }]),
     ], assertions);
 }
-export function admit(repository, offer, admission, assertions = []) {
+export async function admit(repository, offer, admission, assertions = []) {
     if (!Array.isArray(offer.facts) || offer.facts.length === 0) {
         throw new Error("facts must be a nonempty array");
     }
     const appends = assertAppendStructure(offer.facts);
     const companions = assertCompanionStructure(offer.companions ?? [], appends);
     const target = offer.target ?? null;
-    const attempt = buildOffer(repository, admission, appends, companions);
-    const publication = publishOffer(repository, admission, target, attempt.changes, assertions);
+    const attempt = await buildOffer(repository, admission, appends, companions);
+    const publication = await publishOffer(repository, admission, target, attempt.changes, assertions);
     if (publication.kind === "published") {
         return {
             kind: "accepted",

package/build/src/git/hooks.js

@@ -1,4 +1,4 @@
-import { mkdirSync, readFileSync } from "node:fs";
+import { mkdir, readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { replaceFileDurably } from "../coordination/durable-file.js";
@@ -140,9 +140,9 @@ function decodeMarker(bytes) {
 export function hookMarkerPath(administrationDirectory) {
     return join(administrationDirectory, "keiyaku", "hooks.json");
 }
-function readMarker(administrationDirectory) {
+async function readMarker(administrationDirectory) {
     try {
-        return decodeMarker(readFileSync(hookMarkerPath(administrationDirectory), "utf8"));
+        return decodeMarker(await readFile(hookMarkerPath(administrationDirectory), "utf8"));
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -150,10 +150,10 @@ function readMarker(administrationDirectory) {
         throw error;
     }
 }
-function writeMarker(administrationDirectory, marker) {
+async function writeMarker(administrationDirectory, marker) {
     const path = hookMarkerPath(administrationDirectory);
-    mkdirSync(dirname(path), { recursive: true });
-    replaceFileDurably(path, `${JSON.stringify(marker)}\n`);
+    await mkdir(dirname(path), { recursive: true });
+    await replaceFileDurably(path, `${JSON.stringify(marker)}\n`);
 }
 function freshMarker(commands, createPending) {
     return {
@@ -227,7 +227,7 @@ async function executePendingCommand(input) {
         mode: "immediate",
     });
     try {
-        const marker = readMarker(input.administrationDirectory);
+        const marker = await readMarker(input.administrationDirectory);
         if (marker === null)
             throw new Error("worktree hook marker disappeared before execution");
         const progress = marker[input.phase];
@@ -241,7 +241,7 @@ async function executePendingCommand(input) {
             throw new Error("managed hook runner cancelled without a signal");
         const failure = result.kind === "failed" ? result.failure : null;
         const next = input.command + 1;
-        writeMarker(input.administrationDirectory, withProgress(marker, input.phase, failure === null
+        await writeMarker(input.administrationDirectory, withProgress(marker, input.phase, failure === null
             ? next === marker.commands[input.phase].length ? { status: "ok" } : { status: "pending", next }
             : { status: "failed", command: input.command, failure }));
     }
@@ -268,14 +268,14 @@ async function runPendingCommand(input) {
         throw runnerFailure(outcome);
 }
 async function runPhase(worktree, administrationDirectory, hooks, phase, retryHooks) {
-    let marker = readMarker(administrationDirectory);
+    let marker = await readMarker(administrationDirectory);
     if (marker === null) {
         marker = freshMarker(hooks, phase === "create");
-        writeMarker(administrationDirectory, marker);
+        await writeMarker(administrationDirectory, marker);
     }
     let retryFailure = retryHooks && marker[phase].status === "failed";
     for (;;) {
-        marker = readMarker(administrationDirectory);
+        marker = await readMarker(administrationDirectory);
         if (marker === null)
             throw new Error("worktree hook marker disappeared during execution");
         const progress = marker[phase];
@@ -286,11 +286,11 @@ async function runPhase(worktree, administrationDirectory, hooks, phase, retryHo
                 return { kind: "worktree-hook-failed", phase, path: worktree, command: progress.command, failure: progress.failure };
             }
             retryFailure = false;
-            writeMarker(administrationDirectory, withProgress(marker, phase, { status: "pending", next: progress.command }));
+            await writeMarker(administrationDirectory, withProgress(marker, phase, { status: "pending", next: progress.command }));
             continue;
         }
         if (progress.next === marker.commands[phase].length) {
-            writeMarker(administrationDirectory, withProgress(marker, phase, { status: "ok" }));
+            await writeMarker(administrationDirectory, withProgress(marker, phase, { status: "ok" }));
             continue;
         }
         await runPendingCommand({ administrationDirectory, worktree, phase, command: progress.next });

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

@@ -3,7 +3,6 @@ import type { ChangeId, ContractCoordinates, ContractId, SnapshotId } from "../c
 import { type GitObjectId } from "./identity.js";
 import { type GitRepository } from "./repository.js";
 import type { TenderCapture } from "./tender.js";
-import type { WorkspaceDirtyDelta } from "./tender.js";
 declare const REQUIRED_GIT: "2.38";
 export type IntegrationPreparationRefusal = Readonly<{
     kind: "integration-failed";
@@ -23,27 +22,27 @@ export type IntegrationCoordinates = Readonly<{
 export type IntegrationPlan = Readonly<{
     predecessor: SnapshotId;
     tree: GitObjectId;
-    changeId: ChangeId;
-}>;
-export type ReviewIntegration = Readonly<{
-    changeId: ChangeId;
-    workspace?: WorkspaceDirtyDelta;
 }>;
+/** Mint the one worktree-content identity shared by review and delivery. */
+export declare function worktreeChangeId(repository: GitRepository, input: IntegrationCoordinates, tender: TenderCapture): Promise<ChangeId>;
 /** Materialize the exact integration tree against its observed predecessor. */
 export declare function materializeIntegrationSnapshot(repository: GitRepository, tree: GitObjectId, parent: SnapshotId, input: Readonly<{
     contractId: ContractId;
     title: string;
     message?: string;
-}>): SnapshotId;
-export declare function planIntegration(repository: GitRepository, input: IntegrationCoordinates, tender: TenderCapture, requireBranchesToBeUpToDate: boolean): Preparation<IntegrationPlan, Readonly<{
-    kind: "target-missing";
-    contractId: ContractId;
-}> | IntegrationPreparationRefusal>;
-/** Prepare the integration-derived review subject from one captured tender. */
-export declare function prepareReviewIntegration(repository: GitRepository, input: IntegrationCoordinates, tender: TenderCapture, workspace?: WorkspaceDirtyDelta): Preparation<ReviewIntegration, Readonly<{
+}>): Promise<SnapshotId>;
+export declare function planIntegration(repository: GitRepository, input: IntegrationCoordinates, tender: TenderCapture, requireBranchesToBeUpToDate: boolean): Promise<Preparation<IntegrationPlan, Readonly<{
     kind: "target-missing";
     contractId: ContractId;
-}> | IntegrationPreparationRefusal>;
+}> | IntegrationPreparationRefusal>>;
+export type DeliveryDiffScope = Readonly<{
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+    paths?: readonly string[];
+}>;
+/** Compute predecessor-to-candidate scope from the exact integration trees. */
+export declare function readDeliveryScope(repository: GitRepository, predecessor: SnapshotId, candidate: SnapshotId, includePaths: boolean): Promise<DeliveryDiffScope>;
 /** Read a recorded integration pair's patch, or null when Git no longer has it. */
-export declare function readDeliveryDiff(repository: GitRepository, predecessor: SnapshotId, candidate: SnapshotId): string | null;
+export declare function readDeliveryDiff(repository: GitRepository, predecessor: SnapshotId, candidate: SnapshotId): Promise<string | null>;
 export {};