@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/library/contract-execution.js

@@ -1,159 +1,534 @@
+/** @architectureCompositionRoot */
+import { AkumaBodyRequestError } from "../akuma/request-rendezvous.js";
+import { executionChannel } from "../akuma/requests.js";
+import { prepareAmendDocument } from "../body/amend.js";
+import { decodeArcDocument } from "../body/arc.js";
 import { decodeContractDocument } from "../body/decode.js";
+import { contractId } from "../core/facts/types.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
+import { documentDiff } from "../markdown/diff.js";
+import { abandonOperation } from "../protocol/abandon.js";
+import { amendOperation } from "../protocol/amend.js";
+import { arcOperation } from "../protocol/arc.js";
+import { auditOperation } from "../protocol/audit.js";
+import { completeCandidate } from "../protocol/completion.js";
 import { admitDeliveryOperation } from "../protocol/deliver.js";
-import { withScopeAbortSignal } from "../protocol/operations.js";
+import { withScopeAbortSignal, } from "../protocol/operations.js";
+import { executionStop, isOperationalFailure, isOperationalStop, } from "../protocol/progress.js";
 import { admitReviewOperation } from "../protocol/review.js";
-import { completeCandidate } from "../protocol/completion.js";
-import { ExecutionProgress, contractCheckpoint, executionStop } from "../protocol/progress.js";
+import { releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection } from "../settlement/holder.js";
 import { continueDeliveredDependents } from "./continuation.js";
-import { documentDerivation } from "./input.js";
-import { completeMutation, projectMutationFinality } from "./mutation.js";
-import { requireLeadingAdmission } from "./refusal.js";
-import { receiptFromProgress, withExecutionReceipt } from "./execution-result.js";
-function derivedDocument(state) {
-    return documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id);
-}
-function retainTrailingFailure(context, operation, error) {
-    const receipt = receiptFromProgress(operation, context.contractId, context.progress);
-    if (receipt === undefined)
-        throw error;
-    try {
-        context.progress.recordStop(executionStop(context.contractId, "admission", error, context.signal));
+import { requestForwardedContractLive } from "./contract-operations.js";
+import { acceptedOutcome, admissionOf, conclusions, expected, retainAdmission } from "./contract-outcomes.js";
+import { derivedContractPolicy, derivedGates, derivedHooks, gateNames, } from "./contract-settings.js";
+import { deliveryForContract } from "./delivery.js";
+import { actorOption, contractTerms, documentDerivation, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, requireInput, requireMarkdown, } from "./input.js";
+import { InvocationAccumulator } from "./invocation.js";
+import { KeiyakuError, errorCategory, project, validated, } from "./outcome.js";
+import { completeReconcile } from "./reconcile.js";
+import { observeChangedRegion } from "./region.js";
+export class ContractExecution {
+    seat;
+    constructor(seat) {
+        this.seat = seat;
     }
-    catch (unexpected) {
-        throw withExecutionReceipt(unexpected, receipt);
+    get id() {
+        return this.seat.id;
     }
-}
-/** The channel's own retirement cannot hide an already returned admission. */
-export async function withContractExecution(input, operation, run) {
-    const progress = new ExecutionProgress(input.observe);
-    const scope = withScopeAbortSignal(input.scope, input.signal);
-    let produced;
-    try {
-        return await withGitDecodeChannel(scope, async (channel) => {
-            const context = {
-                ...input,
+    get scope() {
+        return this.seat.scope;
+    }
+    get execution() {
+        return this.seat.execution;
+    }
+    get composition() {
+        return this.seat.composition;
+    }
+    async amend(input) {
+        const { markdown, gates, prerequisites, actor } = validated(() => {
+            const values = requireInput(input, "amend input", ["actor", "markdown", "gates", "after"]);
+            return {
+                markdown: values.markdown === undefined ? undefined : requireMarkdown(values.markdown),
+                gates: values.gates === undefined ? undefined : derivedGates(this.composition, gateNames(values.gates)),
+                prerequisites: values.after === undefined ? undefined : normalizedList(values.after, "after", contractId),
+                actor: actorOption(values.actor).actor,
+            };
+        });
+        const hooks = derivedHooks(this.composition);
+        const amendmentPlan = markdown === undefined ? undefined : validated(() => prepareAmendDocument(markdown));
+        validated(() => {
+            if (markdown === undefined && gates === undefined && prerequisites === undefined)
+                throw new TypeError("amend requires markdown, after, or gates");
+        });
+        let changedSections;
+        return await this.local("amend", async (accumulator, channel, scope) => {
+            const admission = admissionOf(await amendOperation({
+                scope,
+                channel,
+                contractId: this.id,
+                progress: accumulator,
+                ...(actor === undefined ? {} : { actor }),
+                deriveAmendment: (source) => {
+                    const current = persistedDocument(source.document.bytes);
+                    const amendment = amendmentPlan === undefined ? undefined : validated(() => amendmentPlan(current));
+                    changedSections = amendment?.changedSections;
+                    const amended = amendment === undefined ? current : validated(() => decodeContractDocument(amendment.document));
+                    const terms = markdown === undefined
+                        ? {
+                            document: source.document,
+                            segments: source.segments,
+                            gates: gates ?? source.gates,
+                            after: prerequisites ?? source.after,
+                        }
+                        : contractTerms(amended, gates ?? source.gates, prerequisites ?? source.after);
+                    return { terms, verification: documentDerivation(amended, terms.gates, this.id).verification };
+                },
+            }));
+            if (admission.kind !== "accepted")
+                return expected(this.id, admission);
+            const accepted = admission.accepted;
+            const changes = changedAmendTerms(accepted.value.source, accepted.value.terms);
+            const diff = documentDiff("before", "after", accepted.value.source.document.bytes, accepted.value.terms.document.bytes);
+            accumulator.extendConclusions(this.id, { documentDiff: diff, changes });
+            const region = await observeChangedRegion(scope, this.id, changedSections, decodeContractDocument(accepted.value.terms.document.bytes).region);
+            const value = await this.conclude(accumulator, {
+                scope,
+                channel,
+                leading: accepted,
+                hooks,
+                verificationResidueRecorded: false,
+                value: () => ({ documentDiff: diff, changes, ...region }),
+            });
+            return acceptedOutcome("amend", this.id, accumulator, value);
+        });
+    }
+    /** One promise with an optional observation callback; observation never delays custody. */
+    async deliver(input, options) {
+        const values = validated(() => normalizeDeliverInput(input));
+        const observer = validated(() => observationOptions(options));
+        const channel = executionChannel(this.execution);
+        if (channel.kind === "body-request")
+            return await forwardedContractOutcome({
+                revive: (value) => deliveryForContract(this.scope, value),
+                directory: channel.directory,
+                action: "contract.deliver",
+                ...(observer === undefined ? {} : { observe: observer }),
+                ...(values.signal === undefined ? {} : { signal: values.signal }),
+                request: {
+                    action: "contract.deliver",
+                    repoRoot: this.scope.primaryWorktree,
+                    contractId: this.id,
+                    ...(values.message === undefined ? {} : { message: values.message }),
+                    includeDirty: values.includeDirty,
+                    materializeConflict: values.materializeConflict,
+                    overwrite: values.overwrite,
+                },
+            });
+        const { hooks, requireBranchesToBeUpToDate } = derivedContractPolicy(this.composition);
+        return await this.local("deliver", async (accumulator, localChannel, scope) => {
+            let leadingValue;
+            let stage = "admission";
+            try {
+                values.signal?.throwIfAborted();
+                const outcome = await admitDeliveryOperation({
+                    scope,
+                    channel: localChannel,
+                    contractId: this.id,
+                    progress: accumulator,
+                    ...(this.composition.actor === undefined ? {} : { actor: this.composition.actor }),
+                    ...(values.signal === undefined ? {} : { signal: values.signal }),
+                    ...(values.message === undefined ? {} : { message: values.message }),
+                    includeDirty: values.includeDirty,
+                    materializeConflict: values.materializeConflict,
+                    overwrite: values.overwrite,
+                    requireBranchesToBeUpToDate,
+                    deriveDocument: derivedDocument,
+                });
+                if (outcome.kind === "integration-conflict-materialized")
+                    return { kind: "handoff", contract: this.id, value: outcome };
+                if (outcome.kind !== "accepted")
+                    return expected(this.id, outcome);
+                leadingValue = outcome.value;
+                stage = "verification";
+                await advanceAndContinue(accumulator, scope, localChannel, this.id, this.composition, outcome, values.signal, "verification");
+            }
+            catch (error) {
+                retainTrailingFailure(accumulator, this.id, error, values.signal, stage);
+            }
+            const base = admittedDeliveryValue(accumulator, this.id);
+            requireMatchingDeliveryLeading(leadingValue, base);
+            const retained = accumulator.conclusions(this.id) ?? {};
+            const value = { ...base, ...leadingValue, ...retained };
+            accumulator.recordConclusions(this.id, value);
+            await this.reconcileContracts(accumulator, scope, localChannel, hooks);
+            return acceptedOutcome("deliver", this.id, accumulator, deliveryForContract(this.scope, value));
+        }, values.signal, observer);
+    }
+    async review(input, options) {
+        const values = validated(() => requireInput(input, "review input", ["verdict", "summary", "signal"]));
+        const verdict = values.verdict;
+        if (verdict !== "satisfied" && verdict !== "unsatisfied")
+            throw new KeiyakuError("invalid-input", "verdict must be satisfied or unsatisfied", {
+                cause: new TypeError("verdict must be satisfied or unsatisfied"),
+            });
+        const summary = validated(() => optionalNonblank(values.summary, "review summary"));
+        const signal = validated(() => optionalSignal(values.signal));
+        const observer = validated(() => observationOptions(options));
+        const channel = executionChannel(this.execution);
+        if (channel.kind === "body-request")
+            return await forwardedContractOutcome({
+                directory: channel.directory,
+                action: "contract.review",
+                ...(observer === undefined ? {} : { observe: observer }),
+                ...(signal === undefined ? {} : { signal }),
+                request: {
+                    action: "contract.review",
+                    repoRoot: this.scope.primaryWorktree,
+                    contractId: this.id,
+                    verdict,
+                    ...(summary === undefined ? {} : { summary }),
+                },
+            });
+        const hooks = derivedHooks(this.composition);
+        return await this.local("review", async (accumulator, localChannel, scope) => {
+            let value = {};
+            let stage = "admission";
+            try {
+                signal?.throwIfAborted();
+                const outcome = await admitReviewOperation({
+                    scope,
+                    channel: localChannel,
+                    contractId: this.id,
+                    progress: accumulator,
+                    ...(this.composition.actor === undefined ? {} : { actor: this.composition.actor }),
+                    ...(signal === undefined ? {} : { signal }),
+                    verdict,
+                    ...(summary === undefined ? {} : { summary }),
+                });
+                if (outcome.kind !== "accepted")
+                    return expected(this.id, outcome);
+                value = outcome.value;
+                accumulator.extendConclusions(this.id, value);
+                stage = "placement";
+                if (verdict === "satisfied")
+                    value = {
+                        ...value,
+                        ...(await advanceAndContinue(accumulator, scope, localChannel, this.id, this.composition, outcome, signal, "placement")),
+                    };
+            }
+            catch (error) {
+                retainTrailingFailure(accumulator, this.id, error, signal, stage);
+            }
+            const retained = { ...value, ...accumulator.conclusions(this.id) };
+            accumulator.extendConclusions(this.id, retained);
+            await this.reconcileContracts(accumulator, scope, localChannel, hooks);
+            return acceptedOutcome("review", this.id, accumulator, retained);
+        }, signal, observer);
+    }
+    async abandon(input) {
+        const { note, actor } = validated(() => {
+            const values = input === undefined ? undefined : requireInput(input, "abandon input", ["note", "actor"]);
+            return {
+                note: optionalNonblank(values?.note, "abandon note"),
+                actor: actorOption(values?.actor),
+            };
+        });
+        const hooks = derivedHooks(this.composition);
+        return await this.local("abandon", async (accumulator, channel, scope) => {
+            const admission = admissionOf((await releaseTaskHolderWithFence(scope, channel, this.id, () => abandonOperation({
+                scope,
+                channel,
+                contractId: this.id,
+                ...actor,
+                ...(note === undefined ? {} : { note }),
+                observationSelection: taskHolderObservationSelection(),
+                progress: accumulator,
+                decorateOffer: async ({ observation, contractId: owner }) => {
+                    const companion = await releaseTaskHolder(channel, observation, owner);
+                    return companion === null ? [] : [companion];
+                },
+            }))).result);
+            if (admission.kind !== "accepted")
+                return expected(this.id, admission);
+            await this.conclude(accumulator, {
                 scope,
                 channel,
-                progress,
-                ...(scope.signal === undefined ? {} : { signal: scope.signal }),
+                leading: admission.accepted,
+                hooks,
+                verificationResidueRecorded: false,
+                value: () => ({}),
+            });
+            return acceptedOutcome("abandon", this.id, accumulator, undefined);
+        });
+    }
+    async arc(input) {
+        const { chapter, actor } = validated(() => {
+            const values = requireInput(input, "arc input", ["markdown", "actor"]);
+            return {
+                chapter: decodeArcDocument(requireMarkdown(values.markdown)),
+                actor: actorOption(values.actor),
             };
-            produced = await run(context);
-            return produced;
+        });
+        const hooks = derivedHooks(this.composition);
+        return await this.local("arc", async (accumulator, channel, scope) => {
+            const admission = admissionOf(await arcOperation({
+                scope,
+                channel,
+                contractId: this.id,
+                ...actor,
+                chapter,
+                progress: accumulator,
+            }));
+            if (admission.kind !== "accepted")
+                return expected(this.id, admission);
+            await this.conclude(accumulator, {
+                scope,
+                channel,
+                leading: admission.accepted,
+                hooks,
+                verificationResidueRecorded: false,
+                value: () => ({}),
+            });
+            return acceptedOutcome("arc", this.id, accumulator, undefined);
         });
     }
-    catch (error) {
-        const receipt = receiptFromProgress(operation, input.contractId, progress);
-        if (receipt === undefined)
-            throw error;
-        if (produced?.kind === "accepted") {
+    async audit(input, options) {
+        const values = validated(() => input === undefined ? undefined : requireInput(input, "audit input", ["includeDirty", "showDiff", "signal"]));
+        const includeDirty = validated(() => optionalBoolean(values?.includeDirty, "includeDirty") ?? false);
+        const showDiff = validated(() => optionalBoolean(values?.showDiff, "showDiff") ?? false);
+        const signal = validated(() => optionalSignal(values?.signal));
+        const observer = validated(() => observationOptions(options));
+        const channel = executionChannel(this.execution);
+        if (channel.kind === "body-request")
+            return await forwardedContractOutcome({
+                directory: channel.directory,
+                action: "contract.audit",
+                ...(observer === undefined ? {} : { observe: observer }),
+                ...(signal === undefined ? {} : { signal }),
+                request: {
+                    action: "contract.audit",
+                    repoRoot: this.scope.primaryWorktree,
+                    contractId: this.id,
+                    includeDirty,
+                    showDiff,
+                },
+            });
+        const { hooks, requireBranchesToBeUpToDate } = derivedContractPolicy(this.composition);
+        return await this.local("audit", async (accumulator, localChannel, scope) => {
+            const admission = admissionOf(await auditOperation({
+                scope,
+                channel: localChannel,
+                progress: accumulator,
+                contractId: this.id,
+                deriveDocument: derivedDocument,
+                includeDirty,
+                showDiff,
+                requireBranchesToBeUpToDate,
+                ...(signal === undefined ? {} : { signal }),
+                ...(this.composition.actor === undefined ? {} : { actor: this.composition.actor }),
+            }));
+            if (admission.kind !== "accepted")
+                return expected(this.id, admission);
+            const report = await this.conclude(accumulator, {
+                scope,
+                channel: localChannel,
+                leading: admission.accepted,
+                hooks,
+                verificationResidueRecorded: false,
+                value: (value) => value,
+            });
+            return acceptedOutcome("audit", this.id, accumulator, report);
+        }, signal, observer);
+    }
+    /** One accumulator before the first admission-capable await, one projector after teardown. */
+    async local(operation, run, signal, observer) {
+        const accumulator = new InvocationAccumulator(observer);
+        const scope = withScopeAbortSignal(this.scope, signal);
+        let projection;
+        let completed;
+        let retirement;
+        try {
+            projection = await withGitDecodeChannel(scope, async (channel) => {
+                completed = await run(accumulator, channel, scope);
+                return completed;
+            }, (error) => {
+                retirement = error;
+                accumulator.recordChannelRetirement(this.id, error);
+            });
+        }
+        catch (error) {
+            projection =
+                error === retirement && completed?.kind === "accepted" && isOperationalFailure(error)
+                    ? completed
+                    : { kind: "failed", contract: this.id, error: invocationFailure(error, scope.signal) };
+        }
+        const projected = project(operation, accumulator.snapshot(), projection);
+        if (projected.kind === "failed")
+            throw projected.error;
+        return projected.outcome;
+    }
+    async conclude(accumulator, input) {
+        retainAdmission(accumulator, this.id, input.leading, input.verificationResidueRecorded);
+        const value = input.value(input.leading.value);
+        accumulator.extendConclusions(this.id, conclusions(value));
+        await this.reconcileContracts(accumulator, input.scope, input.channel, input.hooks);
+        return value;
+    }
+    async reconcileContracts(accumulator, scope, channel, hooks) {
+        for (const contract of [...new Set([this.id, ...accumulator.snapshot().affected])]) {
             try {
-                progress.recordStop(executionStop(input.contractId, "reconciliation", error, scope.signal));
-                const updated = { ...produced, executionStops: progress.snapshot().stops };
-                const finality = projectMutationFinality(updated);
-                return { ...updated, pending: finality.kind === "accepted-pending" ? finality.pending : [] };
+                scope.signal?.throwIfAborted();
+                accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "started" });
+                const report = await (async () => {
+                    try {
+                        return await completeReconcile({
+                            scope,
+                            channel,
+                            contractId: contract,
+                            hooks,
+                            retryHooks: false,
+                            progress: accumulator,
+                        });
+                    }
+                    finally {
+                        accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "finished" });
+                    }
+                })();
+                void report;
             }
-            catch (unexpected) {
-                throw withExecutionReceipt(unexpected, receipt);
+            catch (error) {
+                if (!isOperationalStop(error, scope.signal))
+                    throw error;
+                accumulator.recordStop(executionStop(contract, "reconciliation", error, scope.signal));
             }
         }
-        throw withExecutionReceipt(error, receipt);
     }
 }
-async function advanceAndContinue(context, checkpoint, start) {
+function changedAmendTerms(before, after) {
+    return {
+        ...(before.gates.length === after.gates.length && before.gates.every((gate, index) => gate === after.gates[index])
+            ? {}
+            : { gates: after.gates }),
+        ...(before.after.length === after.after.length && before.after.every((id, index) => id === after.after[index])
+            ? {}
+            : { after: after.after }),
+    };
+}
+function persistedDocument(bytes) {
+    try {
+        return decodeContractDocument(bytes);
+    }
+    catch (cause) {
+        throw new KeiyakuError("authority-corruption", "undecodable persisted Contract document", { cause });
+    }
+}
+function derivedDocument(state) {
+    return documentDerivation(persistedDocument(state.terms.document.bytes), state.terms.gates, state.id);
+}
+function observationOptions(options) {
+    if (options === undefined)
+        return undefined;
+    const input = requireInput(options, "observation options", ["observe"]);
+    if (input.observe !== undefined && typeof input.observe !== "function")
+        throw new TypeError("observe must be a function");
+    return input.observe;
+}
+function normalizeDeliverInput(input) {
+    const values = input === undefined
+        ? undefined
+        : requireInput(input, "deliver input", ["message", "includeDirty", "materializeConflict", "overwrite", "signal"]);
+    const message = optionalNonblank(values?.message, "deliver message");
+    const signal = optionalSignal(values?.signal);
+    return {
+        ...(message === undefined ? {} : { message }),
+        includeDirty: optionalBoolean(values?.includeDirty, "includeDirty") ?? false,
+        materializeConflict: optionalBoolean(values?.materializeConflict, "materializeConflict") ?? false,
+        overwrite: optionalBoolean(values?.overwrite, "overwrite") ?? false,
+        ...(signal === undefined ? {} : { signal }),
+    };
+}
+/** A trailing operational failure after a confirmed admission is a typed stop, never a lost receipt. */
+function retainTrailingFailure(accumulator, contractId, error, signal, stage) {
+    if (accumulator.head(contractId) === undefined)
+        throw error;
+    if (!isOperationalStop(error, signal))
+        throw error;
+    accumulator.recordStop(executionStop(contractId, stage, error, signal));
+}
+// eslint-disable-next-line max-params -- Keep this local operation's custody, admission, and policy witnesses explicit.
+async function advanceAndContinue(accumulator, scope, channel, contractId, composition, outcome, signal, start) {
+    const checkpoint = { state: outcome.state, journal: outcome.journal };
     const result = await completeCandidate({
-        repository: context.scope,
-        channel: context.channel,
+        repository: scope,
+        channel,
         checkpoint,
-        progress: context.progress,
+        progress: accumulator,
         start,
         deriveDocument: derivedDocument,
-        ...(context.actor === undefined ? {} : { actor: context.actor }),
-        ...(context.signal === undefined ? {} : { signal: context.signal }),
+        ...(composition.actor === undefined ? {} : { actor: composition.actor }),
+        ...(signal === undefined ? {} : { signal }),
     });
-    if (result.kind === "completed")
-        context.progress.observe({
-            kind: "stage",
-            contractId: context.contractId,
-            stage: "continuation",
-            state: "started",
-        });
-    const continuation = result.kind !== "completed"
-        ? undefined
-        : await continueDeliveredDependents({
-            ...context,
-            completed: result,
-            deriveDocument: derivedDocument,
-        });
-    if (result.kind === "completed")
-        context.progress.observe({
-            kind: "stage",
-            contractId: context.contractId,
-            stage: "continuation",
-            state: "finished",
-        });
+    accumulator.recordCandidate(contractId, result.evidence);
+    if (result.kind !== "completed")
+        return { ...result.evidence };
+    accumulator.observe({ kind: "stage", contractId, stage: "continuation", state: "started" });
+    const continuation = await continueDeliveredDependents({
+        scope,
+        channel,
+        progress: accumulator,
+        completed: result,
+        deriveDocument: derivedDocument,
+        ...(composition.actor === undefined ? {} : { actor: composition.actor }),
+        ...(signal === undefined ? {} : { signal }),
+    });
+    accumulator.observe({ kind: "stage", contractId, stage: "continuation", state: "finished" });
     return { ...result.evidence, ...(continuation === undefined ? {} : { continuation }) };
 }
-/** Review records testimony, then the same shared node judges automatic placement. */
-export async function executeLocalReview(input) {
-    return await withContractExecution(input, "review", async (context) => {
-        let value = {};
-        try {
-            context.signal?.throwIfAborted();
-            const leading = requireLeadingAdmission(await admitReviewOperation({
-                ...context,
-                verdict: input.verdict,
-                ...(input.summary === undefined ? {} : { summary: input.summary }),
-            }));
-            value = leading.value;
-            if (input.verdict === "satisfied")
-                value = { ...value, ...(await advanceAndContinue(context, contractCheckpoint(leading), "placement")) };
-        }
-        catch (error) {
-            retainTrailingFailure(context, "review", error);
-        }
-        return await completeMutation({
-            ...context,
-            operation: "review",
-            accepted: context.progress.accepted(context.contractId, value),
-            value: (review) => review,
-        });
-    });
+/** An accepted delivery's leading act must be the fact this invocation admitted. */
+function requireMatchingDeliveryLeading(leading, base) {
+    const mismatched = leading !== undefined && (leading.leading.kind !== base.leading.kind || leading.leading.fact !== base.leading.fact);
+    if (mismatched)
+        throw new Error("accepted delivery leading disagrees with its admitted fact");
 }
-function admittedDeliveryValue(context) {
-    const fact = context.progress
-        .snapshot()
-        .facts.find((entry) => entry.contract === context.contractId && entry.kind === "deliver");
+function admittedDeliveryValue(accumulator, contractId) {
+    const fact = accumulator.snapshot().facts.find((entry) => entry.contract === contractId && entry.kind === "deliver");
     if (fact?.kind === "deliver")
-        return fact.data;
-    const delivery = context.progress.checkpoint(context.contractId)?.state.delivery?.data;
-    if (delivery !== undefined)
-        return delivery;
+        return { ...fact.data, leading: { kind: "admitted-now", fact: fact.entry } };
+    const delivery = accumulator.checkpoint(contractId)?.state.delivery;
+    if (delivery !== undefined && delivery !== null)
+        return { ...delivery.data, leading: { kind: "already-admitted", fact: delivery.entry } };
     throw new Error("confirmed delivery requires its own receipt");
 }
-/** Delivery admits a candidate; completion and dependent continuation remain automatic. */
-export async function executeLocalDelivery(input) {
-    return await withContractExecution(input, "deliver", async (context) => {
-        let trailing = {};
-        let leadingValue;
-        try {
-            context.signal?.throwIfAborted();
-            const outcome = await admitDeliveryOperation({ ...input, ...context, deriveDocument: derivedDocument });
-            if (outcome.kind === "integration-conflict-materialized")
-                return outcome;
-            const leading = requireLeadingAdmission(outcome);
-            leadingValue = leading.value;
-            trailing = await advanceAndContinue(context, contractCheckpoint(leading), "verification");
-        }
-        catch (error) {
-            retainTrailingFailure(context, "deliver", error);
-        }
-        const value = { ...admittedDeliveryValue(context), ...leadingValue, ...trailing };
-        return await completeMutation({
-            ...context,
-            operation: "deliver",
-            accepted: context.progress.accepted(context.contractId, value),
-            value: (delivery) => delivery,
+async function forwardedContractOutcome(input) {
+    try {
+        const result = (await requestForwardedContractLive({
+            directory: input.directory,
+            action: input.action,
+            request: input.request,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            ...(input.observe === undefined ? {} : { observe: input.observe }),
+        }));
+        return result.kind === "accepted" && input.revive !== undefined
+            ? { ...result, value: input.revive(result.value) }
+            : result;
+    }
+    catch (error) {
+        if (error instanceof KeiyakuError)
+            throw error;
+        if (input.signal?.aborted === true && error === input.signal.reason)
+            throw invocationFailure(error, input.signal);
+        throw new KeiyakuError(error instanceof AkumaBodyRequestError && (error.outcome === "unknown" || error.outcome === "unproven")
+            ? "unknown-outcome"
+            : errorCategory(error), errorMessage(error), {
+            cause: error,
         });
-    });
+    }
+}
+function invocationFailure(error, signal) {
+    return signal?.aborted === true && error === signal.reason
+        ? new KeiyakuError("aborted", errorMessage(error), { cause: error })
+        : error;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
 }