@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/library/catalog.js

@@ -1,7 +1,8 @@
+/** @architectureCompositionRoot */
 import { Akuma } from "../akuma/akuma.js";
 import { listArchetypeDefinitions } from "../akuma/archetype.js";
-import { observeTaskCatalogRows } from "../task/catalog.js";
-import { listKeiyaku } from "./contract.js";
+import { observeTaskCatalog } from "../task/catalog.js";
+import { listContractCatalogue } from "./contract.js";
 import { requireInput } from "./input.js";
 import { Repo } from "./repo.js";
 import { World } from "../world.js";
@@ -21,34 +22,62 @@ async function worldRoot(value) {
 function taskQueryValue(query) {
     if (query.namespace !== undefined && !Array.isArray(query.namespace))
         throw new TypeError("Keiyaku.ls Task namespace must be an array");
+    if (query.limit !== undefined && typeof query.limit !== "number")
+        throw new TypeError("Keiyaku.ls Task limit must be a number");
     return {
         kind: "tasks",
         ...(query.namespace === undefined ? {} : { namespace: query.namespace }),
+        ...(query.limit === undefined ? {} : { limit: query.limit }),
     };
 }
-function queryValue(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new TypeError("Keiyaku.ls query must be an object");
-    }
-    const query = value;
-    if (query.kind !== "tasks" && query.kind !== "contracts" && query.kind !== "archetypes" && query.kind !== "akuma") {
-        throw new TypeError("Keiyaku.ls query kind is invalid");
-    }
+const catalogQueryKeys = {
+    tasks: ["kind", "namespace", "limit"],
+    contracts: ["kind", "limit"],
+    archetypes: ["kind"],
+    akuma: ["kind", "archetype", "limit"],
+};
+function catalogQueryKind(value) {
+    if (value === "tasks" || value === "contracts" || value === "archetypes" || value === "akuma")
+        return value;
+    throw new TypeError("Keiyaku.ls query kind is invalid");
+}
+function assertCatalogQueryKeys(query, kind) {
     for (const key of Object.keys(query)) {
-        if (key !== "kind" &&
-            !(query.kind === "akuma" && key === "archetype") &&
-            !(query.kind === "tasks" && key === "namespace")) {
+        if (!catalogQueryKeys[kind].includes(key))
             throw new TypeError(`Keiyaku.ls query has unknown field: ${key}`);
-        }
     }
-    if (query.kind === "tasks")
-        return taskQueryValue(query);
-    if (query.kind !== "akuma")
-        return { kind: query.kind };
+}
+function akumaQueryValue(query) {
     if (query.archetype !== undefined && typeof query.archetype !== "string") {
         throw new TypeError("Keiyaku.ls Akuma name must be a string");
     }
-    return { kind: "akuma", ...(query.archetype === undefined ? {} : { archetype: query.archetype }) };
+    if (query.limit !== undefined && typeof query.limit !== "number")
+        throw new TypeError("Keiyaku.ls Akuma limit must be a number");
+    return {
+        kind: "akuma",
+        ...(query.archetype === undefined ? {} : { archetype: query.archetype }),
+        ...(query.limit === undefined ? {} : { limit: query.limit }),
+    };
+}
+function contractQueryValue(query) {
+    if (query.limit !== undefined && typeof query.limit !== "number")
+        throw new TypeError("Keiyaku.ls Contract limit must be a number");
+    return { kind: "contracts", ...(query.limit === undefined ? {} : { limit: query.limit }) };
+}
+function queryValue(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new TypeError("Keiyaku.ls query must be an object");
+    }
+    const query = value;
+    const kind = catalogQueryKind(query.kind);
+    assertCatalogQueryKeys(query, kind);
+    if (kind === "tasks")
+        return taskQueryValue(query);
+    if (kind === "contracts")
+        return contractQueryValue(query);
+    if (kind === "archetypes")
+        return { kind };
+    return akumaQueryValue(query);
 }
 export async function listCatalog(input) {
     const values = requireInput(input, "Keiyaku.ls input");
@@ -56,7 +85,7 @@ export async function listCatalog(input) {
     const allowed = query.kind === "contracts"
         ? ["query", "repo"]
         : query.kind === "archetypes"
-            ? ["query", "home"]
+            ? ["query", "path", "home"]
             : ["query", "path"];
     for (const key of Object.keys(values)) {
         if (!allowed.includes(key))
@@ -65,21 +94,31 @@ export async function listCatalog(input) {
     if (query.kind === "contracts") {
         if (!(values.repo instanceof Repo))
             throw new TypeError("repo must be a Repo");
-        const board = await listKeiyaku({ repo: values.repo });
-        return { kind: "contracts", root: board.root, state: board.state, observedAt: board.observedAt, rows: board.rows };
+        const catalogue = await listContractCatalogue({
+            repo: values.repo,
+            ...(query.limit === undefined ? {} : { limit: query.limit }),
+        });
+        return { kind: "contracts", ...catalogue };
     }
     if (query.kind === "archetypes") {
+        const path = values.path === undefined ? undefined : await worldRoot(values.path);
         const home = optionalHome(values.home);
         return {
             kind: "archetypes",
-            rows: await listArchetypeDefinitions(home === undefined ? {} : { home }),
+            rows: await listArchetypeDefinitions({
+                ...(path === undefined ? {} : { project: path }),
+                ...(home === undefined ? {} : { home }),
+            }),
         };
     }
     const path = await worldRoot(values.path);
     if (query.kind === "tasks") {
-        return { kind: "tasks", root: path, rows: await observeTaskCatalogRows(path, query.namespace) };
+        return { kind: "tasks", root: path, ...(await observeTaskCatalog(path, query)) };
     }
-    const listed = await Akuma.of(path).list(query.archetype === undefined ? undefined : { archetype: query.archetype });
+    const listed = await Akuma.of(path).list({
+        ...(query.archetype === undefined ? {} : { archetype: query.archetype }),
+        ...(query.limit === undefined ? {} : { limit: query.limit }),
+    });
     return {
         kind: "akuma",
         root: path,
@@ -87,5 +126,6 @@ export async function listCatalog(input) {
         observedAt: listed.observedAt,
         rows: listed.rows,
         searched: listed.searched,
+        hasMore: listed.hasMore,
     };
 }

package/build/src/library/composition.d.ts

@@ -1,3 +1,4 @@
+/** @architectureCompositionRoot */
 import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku } from "./contract.js";
 import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
 import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";

package/build/src/library/composition.js

@@ -1,3 +1,4 @@
+/** @architectureCompositionRoot */
 import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku } from "./contract.js";
 import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
 import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";

package/build/src/library/configuration.d.ts

@@ -1,21 +1,4 @@
-import { SettingsError, type Settings } from "../settings.js";
-import type { WorktreeHooks } from "../git/hooks.js";
-export type { HookCommand, WorktreeHooks } from "../git/hooks.js";
-export type Gate = string;
-export type GatesFromInput = Readonly<{
-    settings: Settings;
-    names?: readonly string[];
-}>;
-export type RequireBranchesToBeUpToDateFromInput = Readonly<{
-    settings: Settings;
-}>;
-export type WorktreeHooksFromInput = Readonly<{
-    settings: Settings;
-}>;
-export { SettingsError };
-export declare function gatesFrom(input: GatesFromInput): readonly Gate[];
-export declare function requireBranchesToBeUpToDateFrom(input: RequireBranchesToBeUpToDateFromInput): boolean;
-export declare function worktreeHooksFrom(input: WorktreeHooksFromInput): WorktreeHooks;
-export declare function normalizedWorktreeHooks(value: unknown): WorktreeHooks;
-export declare const EMPTY_WORKTREE_HOOKS: WorktreeHooks;
-export declare function worktreeHooksOption(value: unknown): WorktreeHooks;
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "../settings.js";
+export type { Gate, GatesFromInput, RequireBranchesToBeUpToDateFromInput } from "../settings.js";
+export { EMPTY_WORKTREE_HOOKS, normalizedWorktreeHooks, worktreeHooksFrom, worktreeHooksOption } from "../git/hooks.js";
+export type { HookCommand, WorktreeHooks, WorktreeHooksFromInput } from "../git/hooks.js";

package/build/src/library/configuration.js

@@ -1,158 +1,2 @@
-import { gateWord } from "../core/facts/types.js";
-import { SettingsError } from "../settings.js";
-export { SettingsError };
-function record(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function namespaceFailure(view) {
-    if (view.kind !== "failed")
-        throw new Error("settings namespace failure expected");
-    throw new SettingsError(view.failures.map((failure) => `${failure.scope}: ${failure.diagnostic}`).join("; "));
-}
-function bundleGates(name, value) {
-    if (!record(value))
-        throw new SettingsError(`gate bundle '${name}' must be an object`);
-    if (value.kind !== "bundle") {
-        throw new SettingsError(`gate bundle '${name}' has unsupported kind: ${String(value.kind)}`);
-    }
-    for (const field of Object.keys(value)) {
-        if (field !== "kind" && field !== "gates") {
-            throw new SettingsError(`gate bundle '${name}' has unknown field: ${field}`);
-        }
-    }
-    if (!Array.isArray(value.gates)) {
-        throw new SettingsError(`gate bundle '${name}'.gates must be an array`);
-    }
-    return value.gates.map((gate) => {
-        if (!gateWord(gate)) {
-            throw new SettingsError(`gate bundle '${name}' contains an invalid gate word`);
-        }
-        if (gate !== "reviewed" && gate !== "verified") {
-            throw new SettingsError(`gate bundle '${name}' contains a gate without a producer: ${gate}`);
-        }
-        return gate;
-    });
-}
-export function gatesFrom(input) {
-    if (!record(input))
-        throw new TypeError("gatesFrom input must be an object");
-    if (input.names !== undefined && !Array.isArray(input.names)) {
-        throw new TypeError("gatesFrom names must be an array");
-    }
-    const names = input.names ?? ["default"];
-    for (const name of names) {
-        if (!gateWord(name))
-            throw new SettingsError("gate bundle name must match ^[a-z][a-z0-9-]{0,63}$");
-    }
-    const view = input.settings.namespace("gates");
-    if (view.kind === "failed")
-        namespaceFailure(view);
-    const expanded = [];
-    const seen = new Set();
-    for (const name of names) {
-        const selected = view.entries.find((entry) => entry.name === name);
-        if (selected === undefined) {
-            if (input.names === undefined) {
-                if (!seen.has("reviewed"))
-                    expanded.push("reviewed");
-                seen.add("reviewed");
-                continue;
-            }
-            throw new SettingsError(`unknown gate bundle: ${name}`);
-        }
-        for (const gate of bundleGates(name, selected.value)) {
-            if (seen.has(gate))
-                continue;
-            seen.add(gate);
-            expanded.push(gate);
-        }
-    }
-    return Object.freeze(expanded);
-}
-function command(value, coordinate, ErrorType) {
-    if (!record(value))
-        throw new ErrorType(`${coordinate} must be an object`);
-    for (const key of Object.keys(value)) {
-        if (key !== "name" && key !== "argv" && key !== "timeoutMs")
-            throw new ErrorType(`${coordinate} has unknown field: ${key}`);
-    }
-    if (typeof value.name !== "string" || value.name.trim().length === 0)
-        throw new ErrorType(`${coordinate}.name must be nonblank`);
-    if (!Array.isArray(value.argv) || value.argv.length === 0 || !value.argv.every((item) => typeof item === "string")) {
-        throw new ErrorType(`${coordinate}.argv must be a nonempty string array`);
-    }
-    if (value.argv[0].trim().length === 0)
-        throw new ErrorType(`${coordinate}.argv[0] must be nonblank`);
-    if (!Number.isSafeInteger(value.timeoutMs) ||
-        value.timeoutMs < 1 ||
-        value.timeoutMs > 2_147_483_647) {
-        throw new ErrorType(`${coordinate}.timeoutMs must be an integer from 1 through 2147483647`);
-    }
-    return Object.freeze({
-        name: value.name.trim(),
-        argv: Object.freeze([...value.argv]),
-        timeoutMs: value.timeoutMs,
-    });
-}
-function commands(value, coordinate, ErrorType) {
-    if (!Array.isArray(value))
-        throw new ErrorType(`${coordinate} must be an array`);
-    return Object.freeze(value.map((item, index) => command(item, `${coordinate}[${index}]`, ErrorType)));
-}
-export function requireBranchesToBeUpToDateFrom(input) {
-    if (!record(input))
-        throw new TypeError("requireBranchesToBeUpToDateFrom input must be an object");
-    const view = input.settings.namespace("git");
-    if (view.kind === "failed")
-        namespaceFailure(view);
-    for (const entry of view.entries) {
-        if (entry.name !== "requireBranchesToBeUpToDate") {
-            throw new SettingsError(`git has unknown entry: ${entry.name}`);
-        }
-    }
-    const selected = view.entries.find((entry) => entry.name === "requireBranchesToBeUpToDate");
-    if (selected === undefined)
-        return false;
-    if (typeof selected.value !== "boolean") {
-        throw new SettingsError("git.requireBranchesToBeUpToDate must be a boolean");
-    }
-    return selected.value;
-}
-export function worktreeHooksFrom(input) {
-    if (!record(input))
-        throw new TypeError("worktreeHooksFrom input must be an object");
-    const view = input.settings.namespace("worktree");
-    if (view.kind === "failed")
-        namespaceFailure(view);
-    for (const entry of view.entries) {
-        if (entry.name !== "create" && entry.name !== "destroy") {
-            throw new SettingsError(`worktree has unknown entry: ${entry.name}`);
-        }
-    }
-    const selected = (phase) => {
-        const entry = view.entries.find((item) => item.name === phase);
-        if (entry === undefined)
-            return Object.freeze([]);
-        return commands(entry.value, `worktree.${phase}`, SettingsError);
-    };
-    return Object.freeze({ create: selected("create"), destroy: selected("destroy") });
-}
-export function normalizedWorktreeHooks(value) {
-    if (!record(value))
-        throw new TypeError("hooks must be an object");
-    for (const key of Object.keys(value)) {
-        if (key !== "create" && key !== "destroy")
-            throw new TypeError(`hooks has unknown field: ${key}`);
-    }
-    return Object.freeze({
-        create: commands(value.create, "hooks.create", TypeError),
-        destroy: commands(value.destroy, "hooks.destroy", TypeError),
-    });
-}
-export const EMPTY_WORKTREE_HOOKS = Object.freeze({
-    create: Object.freeze([]),
-    destroy: Object.freeze([]),
-});
-export function worktreeHooksOption(value) {
-    return value === undefined ? EMPTY_WORKTREE_HOOKS : normalizedWorktreeHooks(value);
-}
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "../settings.js";
+export { EMPTY_WORKTREE_HOOKS, normalizedWorktreeHooks, worktreeHooksFrom, worktreeHooksOption } from "../git/hooks.js";

package/build/src/library/continuation.d.ts

@@ -1,7 +1,8 @@
-import type { ContractId, ContractState } from "../core/facts/types.js";
+import { type ContractId, type ContractState } from "../core/facts/types.js";
 import { type GitDecodeChannel } from "../git/read-observation.js";
 import type { DocumentDerivation, PlacementStop, RepositoryScope } from "../protocol/operations.js";
 import type { AcceptedIntent } from "./mutation.js";
+import { z } from "zod";
 export type ContinuationReport = Readonly<{
     claimed: readonly ContractId[];
     stopped: readonly Readonly<{
@@ -11,6 +12,24 @@ export type ContinuationReport = Readonly<{
         }>;
     }>[];
 }>;
+export declare function decodeContinuationReport(value: unknown): ContinuationReport;
+export declare const continuationReportSchema: z.ZodType<Readonly<{
+    claimed: readonly ContractId[];
+    stopped: readonly Readonly<{
+        contractId: ContractId;
+        stop: PlacementStop | Readonly<{
+            kind: "already-terminal";
+        }>;
+    }>[];
+}>, unknown, z.core.$ZodTypeInternals<Readonly<{
+    claimed: readonly ContractId[];
+    stopped: readonly Readonly<{
+        contractId: ContractId;
+        stop: PlacementStop | Readonly<{
+            kind: "already-terminal";
+        }>;
+    }>[];
+}>, unknown>>;
 export declare function continueDeliveredDependents<Value extends object>(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;

package/build/src/library/continuation.js

@@ -1,9 +1,43 @@
+import { contractId } from "../core/facts/types.js";
 import { observeActiveContractWorld } from "../git/observe.js";
 import { withGitReadObservation } from "../git/read-observation.js";
 import { reconcileDependentWorktree } from "../git/reconcile.js";
 import { worktreePath } from "../git/workspace.js";
 import { continueDeliveryOperation } from "../protocol/deliver.js";
+import { decodePlacementStop } from "../protocol/result-codec.js";
+import { concatenatePrivateStateSeatClose } from "../git/private-state-seat.js";
+import { ownerSchema } from "./result-codec.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
+export function decodeContinuationReport(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("malformed continuation report");
+    const object = value;
+    if (!Array.isArray(object.claimed) || !Array.isArray(object.stopped))
+        throw new Error("malformed continuation report");
+    if (Object.keys(object).some((key) => key !== "claimed" && key !== "stopped"))
+        throw new Error("malformed continuation report");
+    return {
+        claimed: object.claimed.map((id) => contractId(String(id))),
+        stopped: object.stopped.map((item) => {
+            if (item === null || typeof item !== "object" || Array.isArray(item))
+                throw new Error("malformed continuation report");
+            const stopped = item;
+            if (Object.keys(stopped).some((key) => key !== "contractId" && key !== "stop"))
+                throw new Error("malformed continuation report");
+            const stopValue = stopped.stop;
+            const alreadyTerminal = stopValue !== null &&
+                typeof stopValue === "object" &&
+                !Array.isArray(stopValue) &&
+                stopValue.kind === "already-terminal" &&
+                Object.keys(stopValue).length === 1;
+            return {
+                contractId: contractId(String(stopped.contractId)),
+                stop: alreadyTerminal ? { kind: "already-terminal" } : decodePlacementStop(stopValue),
+            };
+        }),
+    };
+}
+export const continuationReportSchema = ownerSchema(decodeContinuationReport, "expected continuation report");
 function reverseDependents(world) {
     const index = new Map();
     for (const record of world.contracts.values()) {
@@ -24,10 +58,12 @@ function reverseDependents(world) {
 function appendAccepted(primary, child) {
     const effects = [...(primary.physical?.effects ?? []), ...(child.physical?.effects ?? [])];
     const lag = [...(primary.physical?.lag ?? []), ...(child.physical?.lag ?? [])];
+    const seatClose = concatenatePrivateStateSeatClose(primary.seatClose, child.seatClose);
     return {
         ...primary,
         facts: [...primary.facts, ...child.facts],
         ...(effects.length === 0 && lag.length === 0 ? {} : { physical: { effects, lag } }),
+        ...(seatClose === undefined ? {} : { seatClose }),
     };
 }
 function appendPhysical(primary, physical) {

package/build/src/library/contract-bind.d.ts

@@ -21,6 +21,7 @@ type BindResult<Handle> = Readonly<Omit<MutationResult<Handle>, "value"> & {
 } & RegionObservation>;
 type HandleFactory<Handle> = (contractId: ContractId, scope: RepositoryScope) => Handle;
 export declare function bindKeiyaku<Handle>(input: BindInput, createHandle: HandleFactory<Handle>): Promise<BindResult<Handle>>;
+export declare function parseMarkdownBindDocument(markdown: string): import("../body/types.js").DecodedContractDocument;
 /** Internal CLI composition; not exported from the package root. */
 export declare function bindFromCli<Handle>(input: BindInput, createHandle: HandleFactory<Handle>): Promise<BindResult<Handle>>;
 export {};

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

@@ -9,14 +9,19 @@ import { observeRegion } from "./region.js";
 import { scopeForRepo } from "./repo.js";
 import { worktreeHooksOption } from "./configuration.js";
 function acceptedBindResult(result, region) {
-    const { facts, head, lags, settlementLags, recoverySnapshot } = result;
+    const { facts, head, lags, settlementLags, recoverySnapshot, pending, cleanup, leak, seatClose } = result;
     return {
+        kind: "accepted",
         facts,
         head,
         keiyaku: result.value,
         lags,
         settlementLags,
+        pending,
         ...(recoverySnapshot === undefined ? {} : { recoverySnapshot }),
+        ...(cleanup === undefined ? {} : { cleanup }),
+        ...(leak === undefined ? {} : { leak }),
+        ...(seatClose === undefined || seatClose.length === 0 ? {} : { seatClose }),
         ...region,
     };
 }
@@ -58,7 +63,7 @@ export async function bindKeiyaku(input, createHandle) {
             const id = admission.value.contractId;
             const toHandle = ({ contractId: contract }) => createHandle(contract, sourceScope);
             const result = await completeMutation({
-                ...completionInput(sourceScope, channel, id, toHandle, hooks),
+                ...completionInput({ scope: sourceScope, channel, contractId: id, value: toHandle, hooks }),
                 accepted: admission,
             });
             return acceptedBindResult(result, await observeRegion(sourceScope, channel, id, fork.document.region));
@@ -66,6 +71,9 @@ export async function bindKeiyaku(input, createHandle) {
     }
     return bindMarkdownFromValues(values, "targetless", createHandle);
 }
+export function parseMarkdownBindDocument(markdown) {
+    return decodeContractDocument(requireMarkdown(markdown));
+}
 /** Internal CLI composition; not exported from the package root. */
 export async function bindFromCli(input, createHandle) {
     const values = requireInput(input, "Keiyaku.bind input");
@@ -77,7 +85,7 @@ async function bindMarkdownFromValues(values, omittedTarget, createHandle) {
     const hooks = worktreeHooksOption(values.hooks);
     const scope = scopeForRepo(values.repo);
     const task = taskOption(values.task);
-    const document = decodeContractDocument(requireMarkdown(values.markdown));
+    const document = parseMarkdownBindDocument(requireMarkdown(values.markdown));
     if ((values.workspace ?? "worktree") !== "worktree")
         throw new TypeError("workspace must be worktree");
     const target = values.target;
@@ -103,9 +111,12 @@ async function bindMarkdownFromValues(values, omittedTarget, createHandle) {
         const id = accepted.value.contractId;
         const toHandle = ({ contractId: contract }) => createHandle(contract, scope);
         const result = admission.admission === null
-            ? await completeMutation({ ...completionInput(scope, channel, id, toHandle, hooks), accepted })
+            ? await completeMutation({
+                ...completionInput({ scope, channel, contractId: id, value: toHandle, hooks }),
+                accepted,
+            })
             : await completeHolderMutation({
-                completion: completionInput(scope, channel, id, toHandle, hooks),
+                completion: completionInput({ scope, channel, contractId: id, value: toHandle, hooks }),
                 admission: admission.admission,
                 requireAccepted,
             });

package/build/src/library/contract-forwarding.d.ts

@@ -6,8 +6,8 @@ import type { AuditReport } from "../protocol/audit.js";
 import type { WorktreeHooks } from "./configuration.js";
 import type { DeliveryValue } from "./delivery.js";
 import { type MutationResult } from "./mutation.js";
-import type { Review } from "./contract-forwarding-result.js";
-export type { Review } from "./contract-forwarding-result.js";
+import type { Review } from "./mutation.js";
+export type { Review } from "./mutation.js";
 import { Repo } from "./repo.js";
 export type DeliveryExecutionInput = Readonly<{
     scope: RepositoryScope;

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

@@ -5,7 +5,7 @@ import { reviewOperation } from "../protocol/review.js";
 import { auditContract } from "./audit.js";
 import { continueAcceptedCompletion } from "./continuation.js";
 import { documentDerivation } from "./input.js";
-import { completionInput, completeMutation } from "./mutation.js";
+import { completionInput, completeMutation, completionPending } from "./mutation.js";
 import { requireAccepted } from "./refusal.js";
 import { scopeForRepo } from "./repo.js";
 function derivedDocument(state) {
@@ -37,7 +37,14 @@ export async function executeLocalDelivery(input) {
             ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
         return completeMutation({
-            ...completionInput(scope, channel, input.contractId, (delivery) => delivery, input.hooks),
+            ...completionInput({
+                scope,
+                channel,
+                contractId: input.contractId,
+                value: (delivery) => delivery,
+                hooks: input.hooks,
+                valuePending: completionPending,
+            }),
             accepted: continued,
         });
     });
@@ -57,7 +64,14 @@ export async function executeLocalReview(input) {
             ...(input.actor === undefined ? {} : { actor: input.actor }),
         });
         return completeMutation({
-            ...completionInput(input.scope, channel, input.contractId, (review) => review, input.hooks),
+            ...completionInput({
+                scope: input.scope,
+                channel,
+                contractId: input.contractId,
+                value: (review) => review,
+                hooks: input.hooks,
+                valuePending: completionPending,
+            }),
             accepted: continued,
         });
     });
@@ -74,7 +88,7 @@ export async function executeForwardedDeliver(input) {
         ...(input.signal === undefined ? {} : { signal: input.signal }),
         hooks: input.hooks,
     });
-    if (!("facts" in result))
+    if (result.kind !== "accepted")
         return { result };
     const delivery = result.facts.find((fact) => fact.kind === "deliver");
     if (delivery === undefined)

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

@@ -1,3 +1,4 @@
+/** @architectureCompositionRoot */
 import { documentDiff } from "../markdown/diff.js";
 import { applyAmendDocument } from "../body/amend.js";
 import { decodeArcDocument } from "../body/arc.js";
@@ -131,7 +132,7 @@ export class KeiyakuHandle {
                 },
             }));
             const completed = await completeMutation({
-                ...completionInput(this.scope, channel, this.id, () => undefined, hooks),
+                ...completionInput({ scope: this.scope, channel, contractId: this.id, value: () => undefined, hooks }),
                 accepted,
             });
             return {
@@ -232,7 +233,7 @@ export class KeiyakuHandle {
                 },
             }));
             return completeHolderMutation({
-                completion: completionInput(this.scope, channel, this.id, () => undefined, hooks),
+                completion: completionInput({ scope: this.scope, channel, contractId: this.id, value: () => undefined, hooks }),
                 admission,
                 requireAccepted,
             });
@@ -251,7 +252,7 @@ export class KeiyakuHandle {
                 chapter,
             }));
             return completeMutation({
-                ...completionInput(this.scope, channel, this.id, () => undefined, hooks),
+                ...completionInput({ scope: this.scope, channel, contractId: this.id, value: () => undefined, hooks }),
                 accepted,
             });
         });

package/build/src/library/contract-operations.d.ts

@@ -1,8 +1,8 @@
-import { type ErasedRequestCommand, type RequestCommand } from "../akuma/request-wire.js";
+import { type ErasedRequestCommand, type RequestProtocol, type ServiceRequestCommand } from "../akuma/request-wire.js";
 import type { AuditReport } from "../protocol/audit.js";
 import type { IntegrationConflictMaterialized } from "../protocol/deliver.js";
 import type { DeliveryValue } from "./delivery.js";
-import type { MutationResult } from "./mutation.js";
+import { type MutationResult } from "./mutation.js";
 import type { DeliveryExecutionInput, Review } from "./contract-forwarding.js";
 import { z } from "zod";
 type DeliveryResult = MutationResult<DeliveryValue> | IntegrationConflictMaterialized;
@@ -225,13 +225,9 @@ export type ContractRequestPort = Readonly<{
         reviewFactId?: string;
     }>>;
 }>;
-type ContractExecutionContext = Readonly<{
-    requester: ContractRequester;
-    signal: AbortSignal;
-    upstream: ContractRequestPort;
-}>;
-export declare function contractRequestCommand(action: ContractRequest["action"]): RequestCommand<ContractRequest, ContractResult, ContractService, ContractReference, ContractExecutionContext>;
-export declare function contractRequestCommands(): Readonly<Record<"contract.audit" | "contract.deliver" | "contract.review", ErasedRequestCommand>>;
+export declare function contractRequestProtocol(action: ContractRequest["action"]): RequestProtocol<ContractRequest, ContractResult, ContractReference>;
+export declare function contractRequestCommand(action: ContractRequest["action"], port: ContractRequestPort): ServiceRequestCommand<ContractRequest, ContractResult, ContractService, ContractReference>;
+export declare function contractRequestCommands(port: ContractRequestPort): Readonly<Record<"contract.audit" | "contract.deliver" | "contract.review", ErasedRequestCommand>>;
 export declare function requestForwardedContractLive<Action extends ContractRequest["action"]>(input: Readonly<{
     directory: string;
     action: Action;