@astrosheep/keiyaku 4.5.8 → 4.5.9

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

@@ -20,7 +20,6 @@ const auditRequestSchema = contractRequestBaseSchema
     .extend({
     includeDirty: z.boolean(),
     showDiff: z.boolean(),
-    requireBranchesToBeUpToDate: z.boolean(),
 })
     .transform((request) => ({ action: "contract.audit", ...request }));
 const deliverRequestSchema = contractRequestBaseSchema
@@ -112,7 +111,7 @@ async function executeContractRequest(request, context) {
                 kind: "audit-report",
                 repoRoot: request.repoRoot,
                 contractId: request.contractId,
-                report: auditReportSchema.parse(served.auditReport),
+                report: served.auditReport,
             },
         };
     }
@@ -170,7 +169,7 @@ export function contractRequestCommand(action) {
         decodeResult: (value) => decodedContractResult(action, value),
         encodeFailure: encodeContractLiveFailure,
         decodeFailure: decodeContractLiveFailure,
-        encodeService: (service) => decodeContractService(action, service),
+        encodeService: (service) => service,
         decodeService: (service) => decodeContractService(action, service),
         projectService: (service) => decodeContractService(action, service),
         decodeReference: (reference) => decodeContractService(action, reference),

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

@@ -59,6 +59,11 @@ type ActorOptions = Readonly<{
     actor?: string;
     hooks?: WorktreeHooks;
 }>;
+export type LocalContractComposition = Readonly<{
+    actor?: string;
+    hooks?: WorktreeHooks;
+    requireBranchesToBeUpToDate?: boolean;
+}>;
 export type AmendInput = ActorOptions & Readonly<{
     markdown?: string;
     after?: readonly ContractId[];
@@ -78,16 +83,15 @@ export type KeiyakuOfInput = Readonly<{
     repo: Repo;
     id: ContractId;
 }>;
-export type ReviewInput = ActorOptions & Readonly<{
+export type ReviewInput = Readonly<{
     verdict: AttestationVerdict;
     summary?: string;
 }>;
 export type AbandonInput = ActorOptions & Readonly<{
     note?: string;
 }>;
-export type DeliverInput = ActorOptions & Readonly<{
+export type DeliverInput = Readonly<{
     message?: string;
-    requireBranchesToBeUpToDate?: boolean;
     includeDirty?: boolean;
     materializeConflict?: boolean;
     signal?: AbortSignal;

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

@@ -1,3 +1,5 @@
+import { actorOption } from "./input.js";
+import { worktreeHooksOption } from "./configuration.js";
 import type { RegionOverlap } from "./region.js";
 import { type ChangeId, type FactKind, type ContractId, type ContractState, type SnapshotId } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
@@ -13,14 +15,14 @@ import { type ContinuationReport } from "./continuation.js";
 import type { MutationResult } from "./mutation.js";
 export { KeiyakuHandle } from "./contract-handle.js";
 import { KeiyakuHandle } from "./contract-handle.js";
-import type { AbandonInput, AmendInput, AmendResult, ArcInput, BindInput, BindResult, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuOfInput, MarkdownBindInput, ReconcileReport, ReviewInput, ContractHistory, ContractHistoryEvent, Fact, Lag, TopologyEffect } from "./contract-types.js";
+import type { AbandonInput, AmendInput, AmendResult, ArcInput, BindInput, BindResult, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuOfInput, LocalContractComposition, MarkdownBindInput, ReconcileReport, ReviewInput, ContractHistory, ContractHistoryEvent, Fact, Lag, TopologyEffect } from "./contract-types.js";
 import type { AttestationVerdict as OperationAttestationVerdict, Review as OperationReview } from "./contract-operations.js";
 import { KeiyakuRetry, type KeiyakuRefusal, type KeiyakuRetryReason } from "./refusal.js";
 export { KeiyakuRefused } from "./refusal.js";
 export { KeiyakuRetry, type KeiyakuRefusal, type KeiyakuRetryReason };
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
-export type { AbandonInput, AmendInput, AmendResult, ArcInput, AuditInput, AuditReport, ChangeId, ContinuationReport, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractAfterEdge, ContractId, ContractHistory, ContractHistoryEvent, ContractDependent, ContractObservation, ContractPhase, ContractRow, ContractState, ContractWorkspaceObservation, BindInput, BindResult, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuOfInput, MarkdownBindInput, ReconcileReport, ReviewInput, DeliveryPreparationRefusal, Fact, FactKind, IntegrationConflictMaterialized, Lag, MutationResult, PlacementStop, RegionOverlap, SnapshotId, TaskId, TopologyEffect, VerificationReuse, VerificationStop, };
+export type { AbandonInput, AmendInput, AmendResult, ArcInput, AuditInput, AuditReport, ChangeId, ContinuationReport, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractAfterEdge, ContractId, ContractHistory, ContractHistoryEvent, ContractDependent, ContractObservation, ContractPhase, ContractRow, ContractState, ContractWorkspaceObservation, BindInput, BindResult, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuOfInput, MarkdownBindInput, ReconcileReport, ReviewInput, DeliveryPreparationRefusal, Fact, FactKind, IntegrationConflictMaterialized, Lag, LocalContractComposition, MutationResult, PlacementStop, RegionOverlap, SnapshotId, TaskId, TopologyEffect, VerificationReuse, VerificationStop, };
 export type { AfterEndpointObservation };
 export type ActorId = string;
 export type AttestationVerdict = OperationAttestationVerdict;
@@ -28,9 +30,15 @@ export type Review = OperationReview;
 export { Delivery };
 export type { SettlementAction, SettlementLag, SettlementReport } from "../settlement/settle.js";
 export type Keiyaku = KeiyakuHandle;
-export declare function keiyakuOf(input: KeiyakuOfInput, execution?: ExecutionContext): Keiyaku;
+export type LocalContractCompositionCapture = Readonly<{
+    actor?: NonNullable<ReturnType<typeof actorOption>["actor"]>;
+    hooks: ReturnType<typeof worktreeHooksOption>;
+    requireBranchesToBeUpToDate: boolean;
+}>;
+export declare function captureLocalContractComposition(input?: LocalContractComposition): LocalContractCompositionCapture;
+export declare function keiyakuOf(input: KeiyakuOfInput, execution?: ExecutionContext, composition?: LocalContractCompositionCapture): Keiyaku;
 export declare function listKeiyaku(input: ContractListInput): Promise<ContractBoard>;
 export declare function observeKeiyaku(input: ContractObservationInput): Promise<ContractObservation>;
-export declare function bindKeiyaku(input: BindInput, execution?: ExecutionContext): Promise<BindResult>;
+export declare function bindKeiyaku(input: BindInput, execution?: ExecutionContext, composition?: LocalContractCompositionCapture): Promise<BindResult>;
 /** Internal CLI composition; not exported from the package root. */
 export declare function bindFromCli(input: BindInput, execution?: ExecutionContext): Promise<BindResult>;

package/build/src/library/contract.js

@@ -1,5 +1,6 @@
 // Contract's static facade deliberately depends only on construction and observation.
-import { requireInput } from "./input.js";
+import { actorOption, optionalBoolean, requireInput } from "./input.js";
+import { worktreeHooksOption } from "./configuration.js";
 import { contractId, } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractObservationOperation, contractsOperation, } from "../protocol/operations.js";
@@ -15,12 +16,25 @@ export { KeiyakuRefused } from "./refusal.js";
 export { KeiyakuRetry };
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
 export { Delivery };
-export function keiyakuOf(input, execution = localExecutionContext()) {
+export function captureLocalContractComposition(input) {
+    const values = requireInput(input ?? {}, "Keiyaku.withLocal input", [
+        "actor",
+        "hooks",
+        "requireBranchesToBeUpToDate",
+    ]);
+    const actor = actorOption(values.actor).actor;
+    return Object.freeze({
+        ...(actor === undefined ? {} : { actor }),
+        hooks: worktreeHooksOption(values.hooks),
+        requireBranchesToBeUpToDate: optionalBoolean(values.requireBranchesToBeUpToDate, "Keiyaku.withLocal requireBranchesToBeUpToDate") ?? false,
+    });
+}
+export function keiyakuOf(input, execution = localExecutionContext(), composition = captureLocalContractComposition()) {
     const values = requireInput(input, "Keiyaku.of input");
     const scope = scopeForRepo(values.repo);
     if (typeof values.id !== "string")
         throw new TypeError("contract ID must be a string");
-    return new KeiyakuHandle(contractId(values.id), scope, execution);
+    return new KeiyakuHandle(contractId(values.id), scope, execution, composition);
 }
 export async function listKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.list input");
@@ -47,10 +61,11 @@ export async function observeKeiyaku(input) {
     }
     return withGitDecodeChannel(scope, (channel) => contractObservationOperation({ scope, channel, contractId: id }));
 }
-export async function bindKeiyaku(input, execution = localExecutionContext()) {
-    return bindKeiyakuImplementation(input, (id, scope) => new KeiyakuHandle(id, scope, execution));
+export async function bindKeiyaku(input, execution = localExecutionContext(), composition = captureLocalContractComposition()) {
+    return bindKeiyakuImplementation(input, (id, scope) => new KeiyakuHandle(id, scope, execution, composition));
 }
 /** Internal CLI composition; not exported from the package root. */
 export async function bindFromCli(input, execution = localExecutionContext()) {
-    return bindFromCliImplementation(input, (id, scope) => new KeiyakuHandle(id, scope, execution));
+    const composition = captureLocalContractComposition();
+    return bindFromCliImplementation(input, (id, scope) => new KeiyakuHandle(id, scope, execution, composition));
 }

package/build/src/library/fleet-result.d.ts

@@ -144,7 +144,7 @@ declare const akumaObservationSchema: z.ZodObject<{
                         pending: "pending";
                         told: "told";
                     }>;
-                    deliveries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
                         deliveredAt: z.ZodString;
                         route: z.ZodEnum<{
                             live: "live";
@@ -155,7 +155,17 @@ declare const akumaObservationSchema: z.ZodObject<{
                             required: "required";
                             unavailable: "unavailable";
                         }>>;
-                    }, z.core.$strict>>>;
+                    }, z.core.$strict>, z.ZodTransform<Readonly<{
+                        turnSequence: number;
+                        route: "launch" | "live";
+                        receipt?: "unavailable" | "required";
+                        deliveredAt: string;
+                    }>, {
+                        deliveredAt: string;
+                        route: "live" | "launch";
+                        turnSequence: number;
+                        receipt?: "required" | "unavailable" | undefined;
+                    }>>>>;
                 }, z.core.$strict>]>, z.ZodObject<{
                     kind: z.ZodLiteral<"tool">;
                     sequence: z.ZodNumber;
@@ -333,7 +343,7 @@ declare const akumaObservationSchema: z.ZodObject<{
                         pending: "pending";
                         told: "told";
                     }>;
-                    deliveries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
                         deliveredAt: z.ZodString;
                         route: z.ZodEnum<{
                             live: "live";
@@ -344,7 +354,17 @@ declare const akumaObservationSchema: z.ZodObject<{
                             required: "required";
                             unavailable: "unavailable";
                         }>>;
-                    }, z.core.$strict>>>;
+                    }, z.core.$strict>, z.ZodTransform<Readonly<{
+                        turnSequence: number;
+                        route: "launch" | "live";
+                        receipt?: "unavailable" | "required";
+                        deliveredAt: string;
+                    }>, {
+                        deliveredAt: string;
+                        route: "live" | "launch";
+                        turnSequence: number;
+                        receipt?: "required" | "unavailable" | undefined;
+                    }>>>>;
                 }, z.core.$strict>]>, z.ZodObject<{
                     kind: z.ZodLiteral<"tool">;
                     sequence: z.ZodNumber;
@@ -560,7 +580,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                             pending: "pending";
                             told: "told";
                         }>;
-                        deliveries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                        deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
                             deliveredAt: z.ZodString;
                             route: z.ZodEnum<{
                                 live: "live";
@@ -571,7 +591,17 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                                 required: "required";
                                 unavailable: "unavailable";
                             }>>;
-                        }, z.core.$strict>>>;
+                        }, z.core.$strict>, z.ZodTransform<Readonly<{
+                            turnSequence: number;
+                            route: "launch" | "live";
+                            receipt?: "unavailable" | "required";
+                            deliveredAt: string;
+                        }>, {
+                            deliveredAt: string;
+                            route: "live" | "launch";
+                            turnSequence: number;
+                            receipt?: "required" | "unavailable" | undefined;
+                        }>>>>;
                     }, z.core.$strict>]>, z.ZodObject<{
                         kind: z.ZodLiteral<"tool">;
                         sequence: z.ZodNumber;
@@ -749,7 +779,7 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                             pending: "pending";
                             told: "told";
                         }>;
-                        deliveries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                        deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
                             deliveredAt: z.ZodString;
                             route: z.ZodEnum<{
                                 live: "live";
@@ -760,7 +790,17 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                                 required: "required";
                                 unavailable: "unavailable";
                             }>>;
-                        }, z.core.$strict>>>;
+                        }, z.core.$strict>, z.ZodTransform<Readonly<{
+                            turnSequence: number;
+                            route: "launch" | "live";
+                            receipt?: "unavailable" | "required";
+                            deliveredAt: string;
+                        }>, {
+                            deliveredAt: string;
+                            route: "live" | "launch";
+                            turnSequence: number;
+                            receipt?: "required" | "unavailable" | undefined;
+                        }>>>>;
                     }, z.core.$strict>]>, z.ZodObject<{
                         kind: z.ZodLiteral<"tool">;
                         sequence: z.ZodNumber;
@@ -888,6 +928,39 @@ declare const akumaTellResultSchema: z.ZodObject<{
             fact: z.ZodLiteral<"recorded">;
             tellId: z.ZodString;
         }, z.core.$strict>;
+        row: z.ZodObject<{
+            kind: z.ZodLiteral<"tell">;
+            sequence: z.ZodNumber;
+            at: z.ZodString;
+            tellId: z.ZodString;
+            text: z.ZodString;
+            state: z.ZodEnum<{
+                pending: "pending";
+                told: "told";
+            }>;
+            deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
+                deliveredAt: z.ZodString;
+                route: z.ZodEnum<{
+                    live: "live";
+                    launch: "launch";
+                }>;
+                turnSequence: z.ZodNumber;
+                receipt: z.ZodOptional<z.ZodEnum<{
+                    required: "required";
+                    unavailable: "unavailable";
+                }>>;
+            }, z.core.$strict>, z.ZodTransform<Readonly<{
+                turnSequence: number;
+                route: "launch" | "live";
+                receipt?: "unavailable" | "required";
+                deliveredAt: string;
+            }>, {
+                deliveredAt: string;
+                route: "live" | "launch";
+                turnSequence: number;
+                receipt?: "required" | "unavailable" | undefined;
+            }>>>>;
+        }, z.core.$strict>;
         wake: z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodLiteral<"told">;
         }, z.core.$strict>, z.ZodObject<{
@@ -1065,7 +1138,7 @@ export declare const fleetResultSchemas: {
                                 pending: "pending";
                                 told: "told";
                             }>;
-                            deliveries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                            deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
                                 deliveredAt: z.ZodString;
                                 route: z.ZodEnum<{
                                     live: "live";
@@ -1076,7 +1149,17 @@ export declare const fleetResultSchemas: {
                                     required: "required";
                                     unavailable: "unavailable";
                                 }>>;
-                            }, z.core.$strict>>>;
+                            }, z.core.$strict>, z.ZodTransform<Readonly<{
+                                turnSequence: number;
+                                route: "launch" | "live";
+                                receipt?: "unavailable" | "required";
+                                deliveredAt: string;
+                            }>, {
+                                deliveredAt: string;
+                                route: "live" | "launch";
+                                turnSequence: number;
+                                receipt?: "required" | "unavailable" | undefined;
+                            }>>>>;
                         }, z.core.$strict>]>, z.ZodObject<{
                             kind: z.ZodLiteral<"tool">;
                             sequence: z.ZodNumber;
@@ -1254,7 +1337,7 @@ export declare const fleetResultSchemas: {
                                 pending: "pending";
                                 told: "told";
                             }>;
-                            deliveries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                            deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
                                 deliveredAt: z.ZodString;
                                 route: z.ZodEnum<{
                                     live: "live";
@@ -1265,7 +1348,17 @@ export declare const fleetResultSchemas: {
                                     required: "required";
                                     unavailable: "unavailable";
                                 }>>;
-                            }, z.core.$strict>>>;
+                            }, z.core.$strict>, z.ZodTransform<Readonly<{
+                                turnSequence: number;
+                                route: "launch" | "live";
+                                receipt?: "unavailable" | "required";
+                                deliveredAt: string;
+                            }>, {
+                                deliveredAt: string;
+                                route: "live" | "launch";
+                                turnSequence: number;
+                                receipt?: "required" | "unavailable" | undefined;
+                            }>>>>;
                         }, z.core.$strict>]>, z.ZodObject<{
                             kind: z.ZodLiteral<"tool">;
                             sequence: z.ZodNumber;
@@ -1380,6 +1473,39 @@ export declare const fleetResultSchemas: {
                 fact: z.ZodLiteral<"recorded">;
                 tellId: z.ZodString;
             }, z.core.$strict>;
+            row: z.ZodObject<{
+                kind: z.ZodLiteral<"tell">;
+                sequence: z.ZodNumber;
+                at: z.ZodString;
+                tellId: z.ZodString;
+                text: z.ZodString;
+                state: z.ZodEnum<{
+                    pending: "pending";
+                    told: "told";
+                }>;
+                deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
+                    deliveredAt: z.ZodString;
+                    route: z.ZodEnum<{
+                        live: "live";
+                        launch: "launch";
+                    }>;
+                    turnSequence: z.ZodNumber;
+                    receipt: z.ZodOptional<z.ZodEnum<{
+                        required: "required";
+                        unavailable: "unavailable";
+                    }>>;
+                }, z.core.$strict>, z.ZodTransform<Readonly<{
+                    turnSequence: number;
+                    route: "launch" | "live";
+                    receipt?: "unavailable" | "required";
+                    deliveredAt: string;
+                }>, {
+                    deliveredAt: string;
+                    route: "live" | "launch";
+                    turnSequence: number;
+                    receipt?: "required" | "unavailable" | undefined;
+                }>>>>;
+            }, z.core.$strict>;
             wake: z.ZodUnion<readonly [z.ZodObject<{
                 kind: z.ZodLiteral<"told">;
             }, z.core.$strict>, z.ZodObject<{

package/build/src/library/fleet-result.js

@@ -1,4 +1,5 @@
 import { akumaIdSchema, akumaStatusSchema } from "../akuma/akuma.js";
+import { tellRowSchema } from "../akuma/projection.js";
 import { contractId } from "../core/facts/types.js";
 import { taskRowsSchema } from "../task/board.js";
 import { z } from "zod";
@@ -59,6 +60,7 @@ const tellWakeSchema = z.union([
 const tellResultSchema = z
     .object({
     admission: z.object({ fact: z.literal("recorded"), tellId: nonblankTextSchema }).strict(),
+    row: tellRowSchema,
     wake: tellWakeSchema,
 })
     .strict();

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

@@ -6,7 +6,7 @@ export declare function actorOption(actor: unknown): Readonly<{
     actor?: ActorId;
 }>;
 export declare function requireMarkdown(value: unknown, label?: string): string;
-export declare function requireInput(value: unknown, label: string): Record<string, unknown>;
+export declare function requireInput(value: unknown, label: string, allowed?: readonly string[]): Record<string, unknown>;
 /** Shared public-input failure path for operation owners. */
 export declare function invalidInput(message: string): never;
 export declare function taskOption(value: unknown): TaskId | undefined;

package/build/src/library/input.js

@@ -18,9 +18,15 @@ export function requireMarkdown(value, label = "markdown") {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-export function requireInput(value, label) {
+export function requireInput(value, label, allowed) {
     if (!isRecord(value))
         throw new TypeError(`${label} must be an object`);
+    if (allowed !== undefined) {
+        for (const key of Object.keys(value)) {
+            if (!allowed.includes(key))
+                throw new TypeError(`${label} has unknown field: ${key}`);
+        }
+    }
     return value;
 }
 /** Shared public-input failure path for operation owners. */

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

@@ -1,4 +1,4 @@
-import type { Keiyaku as KeiyakuType } from "./contract.js";
+import { type Keiyaku as KeiyakuType, type LocalContractComposition } from "./contract.js";
 import { composeLibrary } from "./composition.js";
 import { type LibraryExecution } from "../akuma/requests.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
@@ -8,6 +8,7 @@ export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHook
 export { AkumaWorldScopeError } from "./address.js";
 export { bodyRequestExecution } from "../akuma/requests.js";
 export type { LibraryExecution } from "../akuma/requests.js";
+export type { LocalContractComposition } from "./contract.js";
 export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, AfterEndpointObservation, ContractAfterEdge, ContractBoard, ContractDependent, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, ContractWorkspaceObservation, ContinuationReport, DeliverInput, Fact, IntegrationConflictMaterialized, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
 export type { ContractId, ContractState, ChangeId, SnapshotId } from "../core/facts/types.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
@@ -32,8 +33,10 @@ export type KeiyakuLibrary = ReturnType<typeof composeLibrary>;
 declare function routedLibrary(input: Readonly<{
     execution: LibraryExecution;
 }>): KeiyakuLibrary;
+declare function localLibrary(input?: LocalContractComposition): KeiyakuLibrary;
 export declare const Keiyaku: Readonly<{
     withExecution: typeof routedLibrary;
+    withLocal: typeof localLibrary;
     prototype: import("./contract-handle.js").KeiyakuHandle;
     [Symbol.hasInstance]: (value: unknown) => boolean;
     bind: (input: Parameters<typeof import("./contract.js").bindKeiyaku>[0]) => Promise<import("./contract-types.js").BindResult>;
@@ -71,6 +74,20 @@ export declare const Keiyaku: Readonly<{
                 fact: "recorded";
                 tellId: string;
             };
+            row: {
+                kind: "tell";
+                sequence: number;
+                at: string;
+                tellId: string;
+                text: string;
+                state: "pending" | "told";
+                deliveries: readonly Readonly<{
+                    turnSequence: number;
+                    route: "launch" | "live";
+                    receipt?: "unavailable" | "required";
+                    deliveredAt: string;
+                }>[];
+            };
             wake: {
                 kind: "failed";
                 diagnostic: string;
@@ -143,31 +160,31 @@ export declare const Keiyaku: Readonly<{
                     } | {
                         kind: "row";
                         row: {
-                            kind: "call";
+                            kind: "tell";
                             sequence: number;
-                            turnSequence: number;
                             at: string;
+                            tellId: string;
                             text: string;
+                            state: "pending" | "told";
+                            deliveries: readonly Readonly<{
+                                turnSequence: number;
+                                route: "launch" | "live";
+                                receipt?: "unavailable" | "required";
+                                deliveredAt: string;
+                            }>[];
                         } | {
-                            kind: "note" | "thought" | "said";
+                            kind: "call";
                             sequence: number;
                             turnSequence: number;
                             at: string;
                             text: string;
-                            truncated?: true | undefined;
                         } | {
-                            kind: "tell";
+                            kind: "note" | "thought" | "said";
                             sequence: number;
+                            turnSequence: number;
                             at: string;
-                            tellId: string;
                             text: string;
-                            state: "pending" | "told";
-                            deliveries: readonly {
-                                deliveredAt: string;
-                                route: "live" | "launch";
-                                turnSequence: number;
-                                receipt?: "required" | "unavailable" | undefined;
-                            }[];
+                            truncated?: true | undefined;
                         } | {
                             kind: "tool";
                             sequence: number;
@@ -268,31 +285,31 @@ export declare const Keiyaku: Readonly<{
                     } | {
                         kind: "row";
                         row: {
-                            kind: "call";
+                            kind: "tell";
                             sequence: number;
-                            turnSequence: number;
                             at: string;
+                            tellId: string;
                             text: string;
+                            state: "pending" | "told";
+                            deliveries: readonly Readonly<{
+                                turnSequence: number;
+                                route: "launch" | "live";
+                                receipt?: "unavailable" | "required";
+                                deliveredAt: string;
+                            }>[];
                         } | {
-                            kind: "note" | "thought" | "said";
+                            kind: "call";
                             sequence: number;
                             turnSequence: number;
                             at: string;
                             text: string;
-                            truncated?: true | undefined;
                         } | {
-                            kind: "tell";
+                            kind: "note" | "thought" | "said";
                             sequence: number;
+                            turnSequence: number;
                             at: string;
-                            tellId: string;
                             text: string;
-                            state: "pending" | "told";
-                            deliveries: readonly {
-                                deliveredAt: string;
-                                route: "live" | "launch";
-                                turnSequence: number;
-                                receipt?: "required" | "unavailable" | undefined;
-                            }[];
+                            truncated?: true | undefined;
                         } | {
                             kind: "tool";
                             sequence: number;

package/build/src/library/keiyaku.js

@@ -1,5 +1,6 @@
+import { captureLocalContractComposition, } from "./contract.js";
 import { composeLibrary } from "./composition.js";
-import { libraryExecutionInput } from "../akuma/requests.js";
+import { libraryExecutionInput, localExecutionContext } from "../akuma/requests.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
@@ -9,7 +10,11 @@ export { bodyRequestExecution } from "../akuma/requests.js";
 function routedLibrary(input) {
     return composeLibrary(libraryExecutionInput(input));
 }
+function localLibrary(input) {
+    return composeLibrary(localExecutionContext(), captureLocalContractComposition(input));
+}
 export const Keiyaku = Object.freeze({
     ...composeLibrary(),
     withExecution: routedLibrary,
+    withLocal: localLibrary,
 });

package/build/src/runtime/proc/run.d.ts

@@ -12,6 +12,7 @@ type ProcessLaunch = Readonly<{
 export type CancellableProcess = Readonly<{
     child: ChildProcess;
     cancelled(): boolean;
+    terminationFailure: Promise<never>;
     terminate(force?: boolean): Promise<void>;
     waitTermination(): Promise<void>;
 }>;