@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/akuma/call-request.d.ts

@@ -1,55 +1,163 @@
 import { type Soul } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
-import type { CallInitialTell, CallInitialTellAdmission } from "./call-initial-tell.js";
+import { type CallInitialTell, type CallInitialTellAdmission } from "./call-initial-tell.js";
 import { type ChildRequestCommand, type ErasedRequestCommand, type RequestProtocol } from "./request-wire.js";
 import type { OwnedProcess } from "../runtime/proc/run.js";
 import { z } from "zod";
-import { type WorldRoot } from "../world.js";
+import type { WorldRoot } from "../world.js";
 declare const akumaCallRecipeSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
-    allowed: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./allowed.js").AllowedActions, unknown>>;
-    provider: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+    allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+        "task.add": "task.add";
+        "task.addDocument": "task.addDocument";
+        "task.compose": "task.compose";
+        "task.done": "task.done";
+        "task.drop": "task.drop";
+        "task.hold": "task.hold";
+        "task.resume": "task.resume";
+        "task.start": "task.start";
+        "task.stop": "task.stop";
+        "task.update": "task.update";
+        "akuma.call": "akuma.call";
+        "akuma.kill": "akuma.kill";
+        "akuma.tell": "akuma.tell";
+        "contract.audit": "contract.audit";
+        "contract.deliver": "contract.deliver";
+        "contract.review": "contract.review";
+    }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+    provider: z.ZodPipe<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            acp: "acp";
+            "claude-agent-sdk": "claude-agent-sdk";
+            "codex-app-server": "codex-app-server";
+            "grok-build": "grok-build";
+            "opencode-sdk": "opencode-sdk";
+            pi: "pi";
+        }>;
+        executable: z.ZodOptional<z.ZodString>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodTransform<Readonly<{
+        env?: Readonly<Record<string, string>>;
+        config?: Readonly<Record<string, unknown>>;
+        executable?: string;
         name: string;
         kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
-        executable?: string;
-        config?: Readonly<Record<string, unknown>>;
-        env?: Readonly<Record<string, string>>;
-    }>, unknown>>;
-    options: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
-        model?: string;
-        effort?: string;
-        network?: "disabled" | "enabled";
+    }>, {
+        name: string;
+        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+        executable?: string | undefined;
+        config?: Record<string, unknown> | undefined;
+        env?: Record<string, string> | undefined;
+    }>>;
+    options: z.ZodPipe<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodString>;
+        network: z.ZodOptional<z.ZodEnum<{
+            disabled: "disabled";
+            enabled: "enabled";
+        }>>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        systemPromptMode: z.ZodOptional<z.ZodEnum<{
+            append: "append";
+            replace: "replace";
+        }>>;
+    }, z.core.$strip>, z.ZodTransform<Readonly<{
+        systemPromptMode?: "append" | "replace";
         systemPrompt?: string;
-        systemPromptMode?: import("./provider-recipe.js").SystemPromptMode;
-    }>, unknown>>;
+        network?: "disabled" | "enabled";
+        effort?: string;
+        model?: string;
+    }>, {
+        model?: string | undefined;
+        effort?: string | undefined;
+        network?: "disabled" | "enabled" | undefined;
+        systemPrompt?: string | undefined;
+        systemPromptMode?: "append" | "replace" | undefined;
+    }>>;
 }, z.core.$strict>;
 declare const akumaCallPayloadSchema: z.ZodObject<{
     world: z.ZodString;
     archetype: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-    initialTell: z.ZodObject<{
+    initialTell: z.ZodOptional<z.ZodObject<{
         tellId: z.ZodString;
         body: z.ZodString;
         schemaJson: z.ZodOptional<z.ZodString>;
         initiator: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
+    }, z.core.$strict>>;
     cwd: z.ZodOptional<z.ZodString>;
     recipe: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
-        allowed: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./allowed.js").AllowedActions, unknown>>;
-        provider: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+        allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+            "task.add": "task.add";
+            "task.addDocument": "task.addDocument";
+            "task.compose": "task.compose";
+            "task.done": "task.done";
+            "task.drop": "task.drop";
+            "task.hold": "task.hold";
+            "task.resume": "task.resume";
+            "task.start": "task.start";
+            "task.stop": "task.stop";
+            "task.update": "task.update";
+            "akuma.call": "akuma.call";
+            "akuma.kill": "akuma.kill";
+            "akuma.tell": "akuma.tell";
+            "contract.audit": "contract.audit";
+            "contract.deliver": "contract.deliver";
+            "contract.review": "contract.review";
+        }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+        provider: z.ZodPipe<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                acp: "acp";
+                "claude-agent-sdk": "claude-agent-sdk";
+                "codex-app-server": "codex-app-server";
+                "grok-build": "grok-build";
+                "opencode-sdk": "opencode-sdk";
+                pi: "pi";
+            }>;
+            executable: z.ZodOptional<z.ZodString>;
+            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>, z.ZodTransform<Readonly<{
+            env?: Readonly<Record<string, string>>;
+            config?: Readonly<Record<string, unknown>>;
+            executable?: string;
             name: string;
             kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
-            executable?: string;
-            config?: Readonly<Record<string, unknown>>;
-            env?: Readonly<Record<string, string>>;
-        }>, unknown>>;
-        options: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
-            model?: string;
-            effort?: string;
-            network?: "disabled" | "enabled";
+        }>, {
+            name: string;
+            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+            executable?: string | undefined;
+            config?: Record<string, unknown> | undefined;
+            env?: Record<string, string> | undefined;
+        }>>;
+        options: z.ZodPipe<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            effort: z.ZodOptional<z.ZodString>;
+            network: z.ZodOptional<z.ZodEnum<{
+                disabled: "disabled";
+                enabled: "enabled";
+            }>>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            systemPromptMode: z.ZodOptional<z.ZodEnum<{
+                append: "append";
+                replace: "replace";
+            }>>;
+        }, z.core.$strip>, z.ZodTransform<Readonly<{
+            systemPromptMode?: "append" | "replace";
             systemPrompt?: string;
-            systemPromptMode?: import("./provider-recipe.js").SystemPromptMode;
-        }>, unknown>>;
+            network?: "disabled" | "enabled";
+            effort?: string;
+            model?: string;
+        }>, {
+            model?: string | undefined;
+            effort?: string | undefined;
+            network?: "disabled" | "enabled" | undefined;
+            systemPrompt?: string | undefined;
+            systemPromptMode?: "append" | "replace" | undefined;
+        }>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 export type AkumaCallRecipe = z.infer<typeof akumaCallRecipeSchema>;
@@ -72,13 +180,111 @@ type AkumaCallRequestCapabilities = Readonly<{
     spawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
     admitInitialTell(input: InitialTellAdmissionRequest): Promise<CallInitialTellAdmission>;
 }>;
+declare const liveResultSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"live">;
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+    tell: z.ZodOptional<z.ZodObject<{
+        admission: 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<{
+            kind: z.ZodLiteral<"held">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"pursuing">;
+            bodySequence: z.ZodNumber;
+        }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+            kind: z.ZodLiteral<"failed">;
+            diagnostic: z.ZodString;
+            child: z.ZodOptional<z.ZodObject<{
+                code: z.ZodNullable<z.ZodNumber>;
+                signal: z.ZodNullable<z.ZodString>;
+                log: z.ZodObject<{
+                    path: z.ZodString;
+                    from: z.ZodNumber;
+                    to: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodTransform<{
+            kind: "failed";
+            diagnostic: string;
+        } | {
+            child: {
+                code: number | null;
+                signal: string | null;
+                log: {
+                    path: string;
+                    from: number;
+                    to: number;
+                };
+            };
+            kind: "failed";
+            diagnostic: string;
+        }, {
+            kind: "failed";
+            diagnostic: string;
+            child?: {
+                code: number | null;
+                signal: string | null;
+                log: {
+                    path: string;
+                    from: number;
+                    to: number;
+                };
+            } | undefined;
+        }>>]>;
+    }, z.core.$strict>>;
+    tellFailure: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const referenceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"reference">;
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+}, z.core.$strict>;
+type AkumaCallLive = z.infer<typeof liveResultSchema>;
+type AkumaCallReference = z.infer<typeof referenceSchema>;
+type AkumaCallOutput = AkumaCallLive | AkumaCallReference;
 export declare function decodeAkumaCallRequest(value: unknown): AkumaCallRequest | null;
-export declare function akumaCallRequestProtocol(): RequestProtocol<AkumaCallRequest, AkuId, AkuId>;
-export declare function akumaCallRequestCommand(capabilities: AkumaCallRequestCapabilities): ChildRequestCommand<AkumaCallRequest, AkuId, AkuId>;
+export declare function akumaCallRequestProtocol(): RequestProtocol<AkumaCallRequest, AkumaCallLive, AkumaCallReference>;
+export declare function akumaCallRequestCommand(capabilities: AkumaCallRequestCapabilities): ChildRequestCommand<AkumaCallRequest, AkumaCallLive, AkumaCallReference>;
 export declare function akumaCallRequestCommands(capabilities: AkumaCallRequestCapabilities): Readonly<Record<"akuma.call", ErasedRequestCommand>>;
 export declare function requestForwardedAkumaCall(input: Omit<AkumaCallRequest, "action"> & Readonly<{
     directory: string;
     id: string;
     signal?: AbortSignal;
-}>): Promise<AkuId>;
+}>): Promise<AkumaCallOutput>;
 export {};

package/build/src/akuma/call-request.js

@@ -1,40 +1,14 @@
 import { isAbsolute, resolve } from "node:path";
-import { clipAllowedActions, decodeAllowedActions } from "./allowed.js";
+import { allowedActionsSchema } from "./allowed.js";
 import { refuseRequest, reserveRequest } from "./heart/index.js";
-import { archetypeName, parseAkuId } from "./identity.js";
-import { publishAkuma } from "./publication.js";
-import { decodeProviderOptions } from "./provider-recipe.js";
-import { decodeProviderExecution, resolveProviderExecution } from "./providers/index.js";
+import { archetypeName, akumaIdSchema } from "./identity.js";
+import { callDiagnostic, executePreparedCall } from "./publication.js";
+import { tellResultSchema } from "./call-initial-tell.js";
+import { providerOptionsSchema, providerRecipeSchema } from "./provider-recipe.js";
 import { requestBodyCommand } from "./request-rendezvous.js";
 import { eraseRequestCommand, } from "./request-wire.js";
 import { z } from "zod";
-import { World } from "../world.js";
-function schemaDecode(decode, message) {
-    return z.unknown().transform((value, context) => {
-        try {
-            return decode(value);
-        }
-        catch {
-            context.addIssue({ code: "custom", message });
-            return z.NEVER;
-        }
-    });
-}
 const absolutePathSchema = z.string().refine((value) => isAbsolute(value) && resolve(value) === value);
-const akuIdSchema = z.string().transform((value, context) => {
-    try {
-        const id = parseAkuId(value).id;
-        if (id !== value) {
-            context.addIssue({ code: "custom", message: "expected canonical AkuId" });
-            return z.NEVER;
-        }
-        return id;
-    }
-    catch {
-        context.addIssue({ code: "custom", message: "expected canonical AkuId" });
-        return z.NEVER;
-    }
-});
 const archetypeSchema = z.string().transform((value, context) => {
     try {
         return archetypeName(value);
@@ -44,14 +18,11 @@ const archetypeSchema = z.string().transform((value, context) => {
         return z.NEVER;
     }
 });
-const allowedActionsSchema = schemaDecode(decodeAllowedActions, "expected allowed actions");
-const providerExecutionSchema = schemaDecode(decodeProviderExecution, "expected provider execution");
-const providerOptionsSchema = schemaDecode(decodeProviderOptions, "expected provider options");
 const akumaCallRecipeSchema = z
     .object({
     description: z.string().trim().min(1).optional(),
     allowed: allowedActionsSchema,
-    provider: providerExecutionSchema,
+    provider: providerRecipeSchema,
     options: providerOptionsSchema,
 })
     .strict();
@@ -67,11 +38,20 @@ const akumaCallPayloadSchema = z
     .object({
     world: absolutePathSchema,
     archetype: archetypeSchema,
-    initialTell: initialTellSchema,
+    initialTell: initialTellSchema.optional(),
     cwd: absolutePathSchema.optional(),
     recipe: akumaCallRecipeSchema,
 })
     .strict();
+const liveResultSchema = z
+    .object({
+    kind: z.literal("live"),
+    id: akumaIdSchema,
+    tell: tellResultSchema.optional(),
+    tellFailure: z.string().optional(),
+})
+    .strict();
+const referenceSchema = z.object({ kind: z.literal("reference"), id: akumaIdSchema }).strict();
 export function decodeAkumaCallRequest(value) {
     const parsed = akumaCallPayloadSchema.safeParse(value);
     return parsed.success ? { ...parsed.data, action: "akuma.call" } : null;
@@ -81,60 +61,53 @@ function callPayload(request) {
     return payload;
 }
 async function executeAkumaCall(request, facts, capabilities) {
-    const { world, paths, parent, spawn } = capabilities;
-    const requestWorld = await World.prove(request.world);
-    if (requestWorld !== world) {
-        await refuseRequest(paths, facts.id, `request world ${requestWorld} does not match ${world}`);
-        throw new Error(`request world ${requestWorld} does not match ${world}`);
-    }
-    const selected = await resolveProviderExecution(request.recipe.provider);
-    const admission = selected.adapter.admitOptions(request.recipe.options);
-    if (admission.kind === "refused") {
-        await refuseRequest(paths, facts.id, admission.diagnostic);
-        throw new Error(admission.diagnostic);
-    }
-    const recipe = {
-        ...(request.recipe.description === undefined ? {} : { description: request.recipe.description }),
-        allowed: clipAllowedActions(request.recipe.allowed, parent.allowed),
-        provider: selected.execution,
-        options: admission.options,
-    };
-    const published = await publishAkuma({
-        worldPath: world,
+    const { world, paths, parent, spawn, admitInitialTell } = capabilities;
+    const outcome = await executePreparedCall({
         archetype: request.archetype,
-        signal: facts.signal,
-        launch: async (allocated) => {
-            if (!facts.admissionOpen())
-                throw new Error("body closed request admission");
-            await reserveRequest(paths, facts.id, allocated.id);
-            return await spawn({
-                paths: allocated.paths,
-                seed: {
-                    id: allocated.id,
-                    archetype: allocated.archetype,
-                    ...recipe,
-                    cwd: request.cwd ?? parent.cwd,
-                    origin: { kind: "request", parent: parent.id, requestId: facts.id },
+        cwd: request.cwd ?? parent.cwd,
+        ...(request.initialTell === undefined
+            ? {}
+            : {
+                initialTell: {
+                    tellId: request.initialTell.tellId,
+                    body: request.initialTell.body,
+                    ...(request.initialTell.schemaJson === undefined ? {} : { schemaJson: request.initialTell.schemaJson }),
+                    ...(request.initialTell.initiator === undefined ? {} : { initiator: request.initialTell.initiator }),
                 },
-            });
+            }),
+        signal: facts.signal,
+        custody: {
+            kind: "request",
+            world,
+            coordinate: request.world,
+            recipe: {
+                ...(request.recipe.description === undefined ? {} : { description: request.recipe.description }),
+                provider: request.recipe.provider,
+                options: request.recipe.options,
+                allowed: request.recipe.allowed,
+            },
+            parent,
+            requestId: facts.id,
+            admissionOpen: facts.admissionOpen,
+            reserve: async (child) => {
+                await reserveRequest(paths, facts.id, child);
+            },
+            refuse: async (diagnostic) => {
+                await refuseRequest(paths, facts.id, diagnostic);
+            },
+            spawn,
+            admitInitialTell,
         },
     });
-    const admitted = await capabilities.admitInitialTell({
-        id: published.id,
-        initialTell: {
-            tellId: request.initialTell.tellId,
-            body: request.initialTell.body,
-            ...(request.initialTell.schemaJson === undefined ? {} : { schemaJson: request.initialTell.schemaJson }),
-            ...(request.initialTell.initiator === undefined ? {} : { initiator: request.initialTell.initiator }),
+    return {
+        result: {
+            kind: "live",
+            id: outcome.child.id,
+            ...(outcome.tell === undefined ? {} : { tell: outcome.tell }),
+            ...(outcome.failure === undefined ? {} : { tellFailure: callDiagnostic(outcome.failure) }),
         },
-        signal: facts.signal,
-    });
-    if (admitted.kind === "birth-failed")
-        throw new Error(admitted.diagnostic);
-    if (admitted.kind === "not-born")
-        throw new Error(`Akuma ${published.id} was not born for its initial Tell`);
-    await admitted.wake;
-    return { result: published.id, child: published.id };
+        child: outcome.child.id,
+    };
 }
 export function akumaCallRequestProtocol() {
     return {
@@ -144,16 +117,16 @@ export function akumaCallRequestProtocol() {
         decodeRequest: decodeAkumaCallRequest,
         encodeResult: (result) => result,
         decodeResult: (result) => {
-            const child = akuIdSchema.safeParse(result);
-            if (!child.success)
-                throw new Error("Akuma call returned an invalid child");
-            return child.data;
+            const parsed = liveResultSchema.safeParse(result);
+            if (!parsed.success)
+                throw new Error("Akuma call returned an invalid live child result");
+            return parsed.data;
         },
         decodeReference: (reference) => {
-            const child = akuIdSchema.safeParse(reference);
-            if (!child.success)
+            const parsed = referenceSchema.safeParse(reference);
+            if (!parsed.success)
                 throw new Error("Akuma call stored an invalid child reference");
-            return child.data;
+            return parsed.data;
         },
         isPermitted: (allowed) => allowed.includes("akuma.call"),
     };
@@ -163,10 +136,10 @@ export function akumaCallRequestCommand(capabilities) {
         completion: "child",
         protocol: akumaCallRequestProtocol(),
         projectChild: (child) => {
-            const id = akuIdSchema.safeParse(child);
+            const id = akumaIdSchema.safeParse(child);
             if (!id.success)
                 throw new Error("Akuma call stored an invalid child reference");
-            return id.data;
+            return { kind: "reference", id: id.data };
         },
         execute: async (request, facts) => await executeAkumaCall(request, facts, capabilities),
     };

package/build/src/akuma/coordinate.d.ts

@@ -1,9 +1,19 @@
-export type ResumeCoordinate = Readonly<{
+import { z } from "zod";
+export declare const resumeCoordinateSchema: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+    sessionFile: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<{
+    sessionFile: string;
+    sessionId?: never;
+} | {
+    sessionFile: string;
     sessionId: string;
-    sessionFile?: never;
-}> | Readonly<{
+}, {
     sessionFile: string;
-    sessionId?: string;
-}>;
+    sessionId?: string | undefined;
+}>>, z.ZodObject<{
+    sessionId: z.ZodString;
+}, z.core.$strict>]>;
+export type ResumeCoordinate = z.infer<typeof resumeCoordinateSchema>;
 export declare function decodeResumeCoordinate(value: unknown): ResumeCoordinate | null;
 export declare function encodeResumeCoordinate(coordinate: ResumeCoordinate): unknown;

package/build/src/akuma/coordinate.js

@@ -1,26 +1,16 @@
-function record(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
+import { z } from "zod";
+const coordinateText = z.string().refine((value) => value.trim() !== "");
+// File coordinates take precedence, including coordinates that also name a session.
+export const resumeCoordinateSchema = z.union([
+    z
+        .object({ sessionFile: coordinateText, sessionId: coordinateText.optional() })
+        .strict()
+        .transform(({ sessionFile, sessionId }) => sessionId === undefined ? { sessionFile } : { sessionFile, sessionId }),
+    z.object({ sessionId: coordinateText }).strict(),
+]);
 export function decodeResumeCoordinate(value) {
-    const coordinate = record(value);
-    if (coordinate === null)
-        return null;
-    const keys = Object.keys(coordinate);
-    if (typeof coordinate.sessionFile === "string" &&
-        coordinate.sessionFile.trim().length > 0 &&
-        (coordinate.sessionId === undefined ||
-            (typeof coordinate.sessionId === "string" && coordinate.sessionId.trim().length > 0)) &&
-        keys.every((key) => key === "sessionFile" || key === "sessionId")) {
-        return {
-            sessionFile: coordinate.sessionFile,
-            ...(coordinate.sessionId === undefined ? {} : { sessionId: coordinate.sessionId }),
-        };
-    }
-    return typeof coordinate.sessionId === "string" && coordinate.sessionId.trim().length > 0 && keys.length === 1
-        ? { sessionId: coordinate.sessionId }
-        : null;
+    const result = resumeCoordinateSchema.safeParse(value);
+    return result.success ? result.data : null;
 }
 export function encodeResumeCoordinate(coordinate) {
     return "sessionFile" in coordinate

package/build/src/akuma/dispatch-association.d.ts

@@ -3,7 +3,7 @@ export declare const dispatchAssociationSchema: z.ZodUnion<readonly [z.ZodObject
     kind: z.ZodLiteral<"none">;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"associated">;
-    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"failed">;
     diagnostic: z.ZodString;

package/build/src/akuma/dispatch-association.js

@@ -1,14 +1,5 @@
-import { contractId } from "../core/facts/types.js";
+import { contractIdSchema } from "../git/identity.js";
 import { z } from "zod";
-const contractIdSchema = z.string().transform((value, context) => {
-    try {
-        return contractId(value);
-    }
-    catch {
-        context.addIssue({ code: "custom", message: "expected ContractId" });
-        return z.NEVER;
-    }
-});
 export const dispatchAssociationSchema = z.union([
     z.object({ kind: z.literal("none") }).strict(),
     z.object({ kind: z.literal("associated"), contractId: contractIdSchema }).strict(),