@astrosheep/keiyaku 4.5.8 → 4.5.9

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

@@ -1,19 +1,27 @@
-import type { ContractId } from "../core/facts/types.js";
+import type { ActorId, ContractId } from "../core/facts/types.js";
 import { type AuditReport } from "../protocol/audit.js";
 import { type RepositoryScope } from "../protocol/operations.js";
 import { type WorktreeHooks } from "./configuration.js";
 import { type MutationResult } from "./mutation.js";
 export type AuditInput = Readonly<{
-    actor?: string;
-    hooks?: WorktreeHooks;
     includeDirty?: boolean;
     showDiff?: boolean;
-    requireBranchesToBeUpToDate?: boolean;
     signal?: AbortSignal;
 }>;
+export type AuditOptions = Readonly<{
+    includeDirty: boolean;
+    showDiff: boolean;
+    signal?: AbortSignal;
+}>;
+export type AuditComposition = Readonly<{
+    actor?: ActorId;
+    hooks?: WorktreeHooks;
+    requireBranchesToBeUpToDate?: boolean;
+}>;
 /** Normalize public audit input and project the protocol audit operation. */
 export declare function auditContract(input: Readonly<{
     scope: RepositoryScope;
     contractId: ContractId;
-    input?: AuditInput;
+    input: AuditOptions;
+    composition?: AuditComposition;
 }>): Promise<MutationResult<AuditReport>>;

package/build/src/library/audit.js

@@ -3,36 +3,24 @@ import { withGitDecodeChannel } from "../git/read-observation.js";
 import { auditOperation } from "../protocol/audit.js";
 import { withScopeAbortSignal } from "../protocol/operations.js";
 import { worktreeHooksOption } from "./configuration.js";
-import { actorOption, documentDerivation, optionalBoolean, optionalSignal, requireInput } from "./input.js";
+import { documentDerivation } from "./input.js";
 import { completeMutation } from "./mutation.js";
 import { requireAccepted } from "./refusal.js";
-function normalizeAuditInput(input) {
-    const values = input === undefined ? undefined : requireInput(input, "audit input");
-    const signal = optionalSignal(values?.signal);
-    return {
-        hooks: worktreeHooksOption(values?.hooks),
-        ...actorOption(values?.actor),
-        includeDirty: optionalBoolean(values?.includeDirty, "includeDirty") ?? false,
-        showDiff: optionalBoolean(values?.showDiff, "showDiff") ?? false,
-        requireBranchesToBeUpToDate: optionalBoolean(values?.requireBranchesToBeUpToDate, "requireBranchesToBeUpToDate") ?? false,
-        ...(signal === undefined ? {} : { signal }),
-    };
-}
 /** Normalize public audit input and project the protocol audit operation. */
 export async function auditContract(input) {
-    const normalized = normalizeAuditInput(input.input);
-    const scope = withScopeAbortSignal(input.scope, normalized.signal);
+    const composition = input.composition;
+    const scope = withScopeAbortSignal(input.scope, input.input.signal);
     return withGitDecodeChannel(scope, async (channel) => {
         const accepted = requireAccepted(await auditOperation({
             scope,
             channel,
             contractId: input.contractId,
             deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
-            includeDirty: normalized.includeDirty,
-            showDiff: normalized.showDiff,
-            requireBranchesToBeUpToDate: normalized.requireBranchesToBeUpToDate,
-            ...(normalized.signal === undefined ? {} : { signal: normalized.signal }),
-            ...(normalized.actor === undefined ? {} : { actor: normalized.actor }),
+            includeDirty: input.input.includeDirty,
+            showDiff: input.input.showDiff,
+            requireBranchesToBeUpToDate: composition?.requireBranchesToBeUpToDate ?? false,
+            ...(input.input.signal === undefined ? {} : { signal: input.input.signal }),
+            ...(composition?.actor === undefined ? {} : { actor: composition.actor }),
         }));
         return completeMutation({
             scope,
@@ -40,7 +28,7 @@ export async function auditContract(input) {
             contractId: input.contractId,
             accepted,
             value: (report) => report,
-            hooks: normalized.hooks,
+            hooks: composition?.hooks ?? worktreeHooksOption(undefined),
         });
     });
 }

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

@@ -5,7 +5,7 @@ import { listCatalog } from "./catalog.js";
 import { nukeKeiyaku } from "./nuke.js";
 import { type ExecutionContext } from "../akuma/requests.js";
 /** Internal composition root for one immutable execution channel. */
-export declare function composeLibrary(context?: ExecutionContext): Readonly<{
+export declare function composeLibrary(context?: ExecutionContext, composition?: Parameters<typeof bindKeiyaku>[2]): Readonly<{
     prototype: KeiyakuHandle;
     [Symbol.hasInstance]: (value: unknown) => boolean;
     bind: (input: Parameters<typeof bindKeiyaku>[0]) => Promise<import("./contract-types.js").BindResult>;
@@ -43,6 +43,20 @@ export declare function composeLibrary(context?: ExecutionContext): 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;
@@ -115,31 +129,31 @@ export declare function composeLibrary(context?: ExecutionContext): 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;
@@ -240,31 +254,31 @@ export declare function composeLibrary(context?: ExecutionContext): 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/composition.js

@@ -5,12 +5,12 @@ import { listCatalog } from "./catalog.js";
 import { nukeKeiyaku } from "./nuke.js";
 import { executionChannel, localExecutionContext } from "../akuma/requests.js";
 /** Internal composition root for one immutable execution channel. */
-export function composeLibrary(context = localExecutionContext()) {
+export function composeLibrary(context = localExecutionContext(), composition) {
     const captured = Object.freeze({ channel: executionChannel(context) });
     return Object.freeze({
         prototype: KeiyakuHandle.prototype,
         [Symbol.hasInstance]: (value) => value instanceof KeiyakuHandle,
-        bind: (input) => bindKeiyaku(input, captured),
+        bind: (input) => bindKeiyaku(input, captured, composition),
         call: (input) => callKeiyaku(input, captured),
         fork: forkKeiyaku,
         history: historyAkuma,
@@ -20,7 +20,7 @@ export function composeLibrary(context = localExecutionContext()) {
         nuke: nukeKeiyaku,
         list: listKeiyaku,
         observe: observeKeiyaku,
-        of: (input) => keiyakuOf(input, captured),
+        of: (input) => keiyakuOf(input, captured, composition),
         status: statusAkuma,
         tell: (input) => tellAkuma(input, captured),
         wait: (input) => waitAkuma(input, captured),

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

@@ -5,8 +5,8 @@ export declare const reconciliationLagSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
     kind: z.ZodLiteral<"worktree-follow-retained">;
     path: z.ZodString;
-    tender: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
-    head: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+    tender: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
+    head: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
     reason: z.ZodEnum<{
         "head-moved": "head-moved";
         "head-attached": "head-attached";
@@ -17,34 +17,34 @@ export declare const reconciliationLagSchema: z.ZodUnion<readonly [z.ZodObject<{
 }, z.core.$strict>, z.ZodTransform<{
     kind: "worktree-follow-retained";
     path: string;
-    tender: import("../core/facts/types.js").SnapshotId;
-    head: import("../core/facts/types.js").SnapshotId;
+    tender: import("./contract.js").SnapshotId;
+    head: import("./contract.js").SnapshotId;
     reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
 } | {
     paths: string[];
     kind: "worktree-follow-retained";
     path: string;
-    tender: import("../core/facts/types.js").SnapshotId;
-    head: import("../core/facts/types.js").SnapshotId;
+    tender: import("./contract.js").SnapshotId;
+    head: import("./contract.js").SnapshotId;
     reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
 }, {
     kind: "worktree-follow-retained";
     path: string;
-    tender: import("../core/facts/types.js").SnapshotId;
-    head: import("../core/facts/types.js").SnapshotId;
+    tender: import("./contract.js").SnapshotId;
+    head: import("./contract.js").SnapshotId;
     reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
     paths?: string[] | undefined;
 }>>, z.ZodPipe<z.ZodObject<{
     kind: z.ZodLiteral<"unsealed-bytes">;
     path: z.ZodString;
     paths: z.ZodArray<z.ZodString>;
-    head: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>>;
+    head: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>>;
 }, z.core.$strict>, z.ZodTransform<{
     kind: "unsealed-bytes";
     path: string;
     paths: string[];
 } | {
-    head: import("../core/facts/types.js").SnapshotId;
+    head: import("./contract.js").SnapshotId;
     kind: "unsealed-bytes";
     path: string;
     paths: string[];
@@ -52,7 +52,7 @@ export declare const reconciliationLagSchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: "unsealed-bytes";
     path: string;
     paths: string[];
-    head?: import("../core/facts/types.js").SnapshotId | undefined;
+    head?: import("./contract.js").SnapshotId | undefined;
 }>>, z.ZodObject<{
     kind: z.ZodLiteral<"target-checkout-retained">;
     path: z.ZodString;
@@ -65,6 +65,12 @@ export declare const reconciliationLagSchema: z.ZodUnion<readonly [z.ZodObject<{
         effect: "effect";
     }>;
     diagnostic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"ref-migration-conflict">;
+    legacyRef: z.ZodString;
+    legacyOid: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
+    currentRef: z.ZodString;
+    currentOid: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"worktree-hook-failed">;
     phase: z.ZodEnum<{

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

@@ -1,8 +1,8 @@
-import { snapshotId } from "../core/facts/types.js";
+import { mintSnapshotId } from "../git/identity.js";
 import { z } from "zod";
 function canonicalSnapshot(value, context) {
     try {
-        return snapshotId(value);
+        return mintSnapshotId(value);
     }
     catch {
         context.addIssue({ code: "custom", message: "expected SnapshotId" });
@@ -62,6 +62,15 @@ export const reconciliationLagSchema = z.union([
         diagnostic: nonblankStringSchema,
     })
         .strict(),
+    z
+        .object({
+        kind: z.literal("ref-migration-conflict"),
+        legacyRef: nonblankStringSchema,
+        legacyOid: snapshotIdSchema,
+        currentRef: nonblankStringSchema,
+        currentOid: snapshotIdSchema,
+    })
+        .strict(),
     z
         .object({
         kind: z.literal("worktree-hook-failed"),