@astrosheep/keiyaku 2.9.11 → 2.9.13

package/build/core/renew.js

@@ -6,6 +6,7 @@ import { withContractCarrierSession } from "./contract-carrier.js";
 import { runLifecycle } from "./lifecycle-runner.js";
 import { committedLifecycleFacts, derivedCleanupFacts, isCompleteLifecycleOutcome, } from "./outcome-base.js";
 import { abortDetachedRenewChain, readDetachedRenewScratch, renewScratchName, } from "./renew-rewrite.js";
+import { scopePathEvidence } from "./scope.js";
 import { persistResponseHistory } from "./transcripts.js";
 import { admitRenew, checkCancellation, prepareRenew, sameAdmission, scopeEntry } from "./renew-plan.js";
 async function persistRenewResponse(journal, facts, persist) {
@@ -46,6 +47,7 @@ async function executeRenew(input, continuation) {
         },
         signal: input.signal,
         ...(input.renewDeliveryProjector ? { renewDeliveryProjector: input.renewDeliveryProjector } : {}),
+        ...(input.transactionRunner ? { transactionRunner: input.transactionRunner } : {}),
         admit: (session, replay) => admitRenew(session, input, replay, continuation?.scratch),
         prepare: (admission) => prepareRenew(admission.business, input, continuation),
         revalidate: async ({ session, admission }) => {
@@ -79,7 +81,11 @@ async function executeRenew(input, continuation) {
             if (admission.business.acceptedReplay) {
                 const accepted = admission.business.acceptedReplay;
                 const replayed = await context.replayCommitted({ transactionObjectId: accepted.transactionObjectId });
-                const sealed = { ...accepted.seal.data, scopeViolationEvidence: [], ledgerHead: accepted.sealObjectId };
+                const sealed = {
+                    ...accepted.seal.data,
+                    scopeViolationEvidence: await scopePathEvidence(admission.business.targetRoot, admission.business.model.effectiveScope, accepted.seal.data.scopeAudit.violations),
+                    ledgerHead: accepted.sealObjectId,
+                };
                 const value = {
                     ...committedLifecycleFacts({ head: accepted.transactionObjectId, entryKind: "renew", contractId: input.contractId, carrier: replayed.carrier }),
                     contractId: input.contractId,
@@ -95,13 +101,6 @@ async function executeRenew(input, continuation) {
                     carrier: replayed.carrier,
                     targetRoot: admission.business.targetRoot,
                 };
-                if (continuation) {
-                    await context.journal.run({
-                        effect: "renew-scratch-cleanup",
-                        idempotencyKey: `${input.contractId}:${accepted.transactionObjectId}:renew-scratch-cleanup`,
-                        run: async () => abortDetachedRenewChain({ cwd: input.cwd, scratchName: continuation.scratch.scratchName }),
-                    });
-                }
                 await persistRenewResponse(context.journal, value, input.persistResponse);
                 return { kind: "committed", commit: replayed, entryKind: "renew", value };
             }
@@ -140,7 +139,7 @@ async function executeRenew(input, continuation) {
                 if (!admission.business.amendment) {
                     const transactionObjectId = admission.replay.state === "verb-committed"
                         ? admission.replay.transaction.transactionObjectId
-                        : admission.ledgerHead;
+                        : admission.replay.transactionObjectId;
                     const replayed = await context.replayCommitted({ transactionObjectId });
                     const accepted = replayed.transaction.entries.at(-1);
                     if (!accepted)
@@ -166,7 +165,7 @@ async function executeRenew(input, continuation) {
                 const published = await context.publishAuthoritative({
                     verb: "renew",
                     admittedLedgerHead: admission.ledgerHead,
-                    acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
+                    acceptedLifecycleTail: context.session.lifecycle.contractHead,
                     entries: [admission.business.amendment],
                 });
                 if (published.status === "refused-before-effects")
@@ -203,15 +202,19 @@ async function executeRenew(input, continuation) {
             const published = await context.publishAuthoritative({
                 verb: "renew",
                 admittedLedgerHead: admission.ledgerHead,
-                acceptedLifecycleTail: context.session.lifecycle.history.at(-1).objectId,
+                acceptedLifecycleTail: context.session.lifecycle.contractHead,
                 entries,
+                target: {
+                    ref: admission.business.targetRef,
+                    expectedOid: prepared.entry.data.newBase,
+                },
                 delivery: {
                     ref: admission.business.deliveryRef,
                     expectedOid: prepared.entry.data.oldHead,
                 },
             });
             if (published.status === "refused-before-effects")
-                return { kind: "refused-before-effects", authoritativeHead: admission.ledgerHead, refusal: { code: "CONCURRENT_MODIFICATION", message: "repository ledger or delivery ref changed before renew transaction" } };
+                return { kind: "refused-before-effects", authoritativeHead: admission.ledgerHead, refusal: { code: "CONCURRENT_MODIFICATION", message: "repository target, ledger, or delivery ref changed before renew transaction" } };
             if (published.status === "indeterminate")
                 return { kind: "precommit-effects-only", authoritativeHead: admission.ledgerHead };
             const sealIndex = published.transaction.entries.findIndex((entry) => entry.kind === "seal");
@@ -239,13 +242,6 @@ async function executeRenew(input, continuation) {
                 carrier: published.carrier,
                 targetRoot: admission.business.targetRoot,
             };
-            if (continuation) {
-                await context.journal.run({
-                    effect: "renew-scratch-cleanup",
-                    idempotencyKey: `${input.contractId}:${published.head}:renew-scratch-cleanup`,
-                    run: async () => abortDetachedRenewChain({ cwd: input.cwd, scratchName: continuation.scratch.scratchName }),
-                });
-            }
             await persistRenewResponse(context.journal, value, input.persistResponse);
             return { kind: "committed", commit: published, entryKind: "renew", value };
         },
@@ -261,19 +257,7 @@ export async function renewContract(input) {
 }
 export async function continueRenewContract(input) {
     const scratchName = renewScratchName(input.contractId);
-    let scratch;
-    try {
-        scratch = await readDetachedRenewScratch({ cwd: input.cwd, scratchName });
-    }
-    catch (error) {
-        throw new FlowError("RENEW_SCRATCH_NOT_FOUND", `no renew conflict scratch is open for ${input.contractId}`, { cause: error });
-    }
-    return executeRenew(input, { scratch, resolution: input.resolution ?? { kind: "scratch-files" } });
-}
-export async function abortRenewContract(input) {
-    checkCancellation(input.signal);
-    return withContractCarrierSession({ cwd: input.cwd, contractId: input.contractId, mode: "observe-only", signal: input.signal }, async (session) => {
-        const scratchName = renewScratchName(input.contractId);
+    for (let attempt = 0; attempt < 2; attempt += 1) {
         let scratch;
         try {
             scratch = await readDetachedRenewScratch({ cwd: input.cwd, scratchName });
@@ -281,17 +265,37 @@ export async function abortRenewContract(input) {
         catch (error) {
             throw new FlowError("RENEW_SCRATCH_NOT_FOUND", `no renew conflict scratch is open for ${input.contractId}`, { cause: error });
         }
+        const result = await executeRenew(input, { scratch, resolution: input.resolution ?? { kind: "scratch-files" } });
+        const code = result.family === "refused-before-effects" ? result.failedInvariant.code : null;
+        if (attempt === 0 && (code === "LIFECYCLE_COORDINATES_CHANGED"
+            || code === "LIFECYCLE_REPLAY_COORDINATES_CHANGED"
+            || code === "RENEW_COORDINATES_CHANGED"
+            || code === "CONCURRENT_MODIFICATION"))
+            continue;
+        if (isCompleteLifecycleOutcome(result)) {
+            await abortDetachedRenewChain({ cwd: input.cwd, scratchName: scratch.scratchName });
+        }
+        return result;
+    }
+    throw new FlowError("INTERNAL_STATE", "bounded renew continuation retry exhausted unexpectedly");
+}
+export async function abortRenewContract(input) {
+    checkCancellation(input.signal);
+    return withContractCarrierSession({ cwd: input.cwd, contractId: input.contractId, mode: "observe-only", signal: input.signal }, async (session) => {
+        const scratchName = renewScratchName(input.contractId);
         checkCancellation(input.signal);
         const cleanup = await abortDetachedRenewChain({ cwd: input.cwd, scratchName });
+        if (cleanup.status === "absent") {
+            throw new FlowError("RENEW_SCRATCH_NOT_FOUND", `no renew conflict scratch is open for ${input.contractId}`);
+        }
         return {
             ...derivedCleanupFacts({
                 contractId: input.contractId,
-                authoritativeHead: session.lifecycle.observedLedgerHead,
+                authoritativeHead: session.pins.repositoryLedgerHead,
                 effect: "renew-conflict-scratch-cleanup",
-                receipt: { status: cleanup.status, scratchName, oldHead: scratch.oldHead },
+                receipt: { status: cleanup.status, scratchName },
             }),
             contractId: input.contractId,
-            oldHead: scratch.oldHead,
             scratchName,
             carrier: session.initialCarrier,
         };

package/build/core/repository-ledger/accepted-fold-read.js

@@ -1,15 +1,18 @@
 import { resolveLocalBranchHead } from "../../git/refs.js";
 import { foldRepositoryLedger } from "./fold-repository.js";
 import { REPOSITORY_LEDGER_REF } from "./codec.js";
+import { repositoryLedgerHead } from "./identity.js";
 import { traverseRepositoryLedger } from "./traversal.js";
 export async function observeRepositoryLedgerHead(cwd) {
-    return (await resolveLocalBranchHead(cwd, REPOSITORY_LEDGER_REF))?.head ?? null;
+    const head = (await resolveLocalBranchHead(cwd, REPOSITORY_LEDGER_REF))?.head;
+    return head === undefined ? null : repositoryLedgerHead(head);
 }
 /** The shared current-head typed traversal and fold used by full and targeted reads. */
 export async function readAcceptedRepositoryFold(cwd, options = {}) {
-    const observedLedgerHead = await (options.observeHead ?? observeRepositoryLedgerHead)(cwd);
-    if (observedLedgerHead === null)
+    const observed = await (options.observeHead ?? observeRepositoryLedgerHead)(cwd);
+    if (observed === null)
         return { observedLedgerHead: null, traversed: null, folded: null };
+    const observedLedgerHead = repositoryLedgerHead(observed);
     const traversed = await traverseRepositoryLedger(cwd, observedLedgerHead, options.signal, { historicalSemanticEvidence: false });
     return {
         observedLedgerHead,

package/build/core/repository-ledger/claim-evidence.js

@@ -119,7 +119,7 @@ export async function assertHonestClaimEvidence(cwd, evidence, readContext) {
     let merge;
     try {
         const coordinates = readContext?.coordinates ?? await deriveHostGitCoordinates(cwd);
-        merge = readContext === undefined
+        merge = readContext?.reader === undefined
             ? await readCommitObject(cwd, coordinates, evidence.mergeCommit)
             : await readContext.reader.read(evidence.mergeCommit);
     }

package/build/core/repository-ledger/codec.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { verificationDeclarationSchema } from "../verification-declaration.js";
 export const REPOSITORY_LEDGER_REF = "refs/heads/keiyaku-ledger";
 export const REPOSITORY_DELIVERY_REF_PREFIX = "refs/heads/keiyaku/";
 export function repositoryDeliveryRef(contract) {
@@ -61,7 +62,7 @@ function buildLifecycleEntrySchema(format) {
         design: nonblank,
         scope: z.array(nonblank).min(1),
         criteria: z.array(nonblank),
-        verification: z.array(nonblank),
+        verification: z.array(verificationDeclarationSchema),
         extensions: z.array(extension),
         base: oid,
         target: fullBranchRefSchema,
@@ -103,7 +104,7 @@ function buildLifecycleEntrySchema(format) {
         }
     });
     return z.discriminatedUnion("kind", [
-        lifecycleEnvelope("bind", 2, bindData),
+        lifecycleEnvelope("bind", 3, bindData),
         lifecycleEnvelope("bootstrap", 1, bootstrapData),
         lifecycleEnvelope("arc", 1, z.object({
             arc: safePositiveInteger,
@@ -124,10 +125,15 @@ function buildLifecycleEntrySchema(format) {
             }).strict(),
             scopeAudit: z.object({ violations: z.array(nonblank) }).strict(),
         }).strict()),
-        lifecycleEnvelope("amend", 1, z.object({
-            amendment: nonblank,
+        lifecycleEnvelope("amend", 2, z.object({
+            amendment: z.string(),
             scopeDelta: z.object({ add: z.array(nonblank).min(1) }).strict().optional(),
-        }).strict()),
+            verificationDelta: z.object({ replace: z.array(verificationDeclarationSchema) }).strict().optional(),
+        }).strict().superRefine((value, context) => {
+            if (!value.amendment.trim() && !value.scopeDelta && !value.verificationDelta) {
+                context.addIssue({ code: "custom", message: "amend requires prose, a scope delta, or a verification delta" });
+            }
+        })),
         lifecycleEnvelope("renew", 1, z.object({
             oldBase: oid,
             newBase: oid,