@astrosheep/keiyaku 4.5.7 → 4.5.9

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

@@ -1,124 +1,118 @@
-import { type AkuId } from "./identity.js";
-import { decodeProviderOptions, type ReadonlyRestraint } from "./provider-recipe.js";
-import { decodeProviderExecution } from "./providers/index.js";
-import { type TaskMutationAction, type TaskMutationRequest } from "../task/mutation.js";
-export type RequestRecipe = Readonly<{
-    description?: string;
-    allowed: readonly string[];
-    provider: ReturnType<typeof decodeProviderExecution>;
-    options: ReturnType<typeof decodeProviderOptions>;
-    readonly?: ReadonlyRestraint;
+import { z } from "zod";
+declare const requestEnvelopeSchema: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    payload: z.ZodUnknown;
+}, z.core.$strict>;
+declare const upstreamRequestFailureSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"akuma-not-born">;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"failed">;
+    diagnostic: z.ZodString;
+}, z.core.$strict>]>;
+declare const returnedEnvelopeSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"returned">;
+    result: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"failed">;
+    failure: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"akuma-not-born">;
+        id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+}, z.core.$strict>]>;
+declare const receiptEnvelopeSchema: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    state: z.ZodLiteral<"served">;
+    outcome: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"returned">;
+        result: z.ZodUnknown;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+        failure: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"akuma-not-born">;
+            id: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"failed">;
+            diagnostic: z.ZodString;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>]>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    state: z.ZodLiteral<"served">;
+    reference: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    state: z.ZodLiteral<"refused">;
+    diagnostic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    state: z.ZodLiteral<"voided">;
+    evidence: z.ZodString;
+    failure: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>]>;
+export type RequestEnvelope = z.infer<typeof requestEnvelopeSchema>;
+/**
+ * A Body Request operation is owned by the verb that defines its public
+ * values.  Transport only carries the opaque values produced here.
+ */
+export type RequestCommand<Input, Output, Service, Reference = Service, Context = unknown> = Readonly<{
+    action: string;
+    encodeRequest(input: Input): unknown;
+    decodeRequest(payload: unknown): Input | null;
+    encodeResult(result: Output): unknown;
+    decodeResult(result: unknown): Output;
+    encodeFailure?(error: unknown): unknown | null;
+    decodeFailure?(failure: unknown): Error | null;
+    encodeService(service: Service): unknown;
+    decodeService(service: unknown): Service;
+    projectService(service: Service): Reference;
+    projectChild?(child: string): Reference;
+    decodeReference(reference: unknown): Reference;
+    /** The operation owner proves the Body-owned execution capability before use. */
+    decodeExecutionContext(value: unknown): Context;
+    isPermitted(allowed: readonly string[]): boolean;
+    execute(input: Input, context: Context): Promise<Readonly<{
+        result: Output;
+    }> & (Readonly<{
+        service: Service;
+    }> | Readonly<{
+        child: string;
+    }>)>;
 }>;
-export type CallRequestClaim = Readonly<{
-    id: string;
-    action: "akuma.call";
-    world: string;
-    archetype: string;
-    body: string;
-    cwd?: string;
-    recipe: RequestRecipe;
+export type ErasedRequestCommand = Readonly<{
+    action: string;
+    resolve(payload: unknown): ErasedRequest | null;
 }>;
-export type WaitRequestClaim = Readonly<{
-    id: string;
-    action: "akuma.wait";
-    targets: readonly AkuId[];
-    completion: "any" | "all";
-    timeoutMs?: number;
+export type ErasedRequest = Readonly<{
+    payloadJson: string;
+    isPermitted(allowed: readonly string[]): boolean;
+    execute(context: unknown): Promise<ErasedRequestExecution>;
+    encodeFailure(error: unknown): unknown | null;
+    projectServiceJson(serviceJson: string): unknown;
+    projectChild(child: string): unknown;
 }>;
-export type TellRequestClaim = Readonly<{
-    id: string;
-    action: "akuma.tell";
-    target: AkuId;
-    body: string;
-}>;
-export type KillRequestClaim = Readonly<{
-    id: string;
-    action: "akuma.kill";
-    targets: readonly AkuId[];
-}>;
-export type DeliverRequestClaim = Readonly<{
-    id: string;
-    action: "contract.deliver";
-    repoRoot: string;
-    contractId: string;
-    message?: string;
-    includeDirty: boolean;
-    materializeConflict: boolean;
-}>;
-export type ReviewRequestClaim = Readonly<{
-    id: string;
-    action: "contract.review";
-    repoRoot: string;
-    contractId: string;
-    verdict: "satisfied" | "unsatisfied";
-    summary?: string;
-}>;
-export type TaskRequestClaim = Readonly<{
-    id: string;
-    action: TaskMutationAction;
-    world: string;
-    request: TaskMutationRequest;
-}>;
-export type RequestClaim = CallRequestClaim | WaitRequestClaim | TellRequestClaim | KillRequestClaim | DeliverRequestClaim | ReviewRequestClaim | TaskRequestClaim;
-export type StructuralRequestClaim = (Omit<CallRequestClaim, "recipe"> & Readonly<{
-    recipe: unknown;
-}>) | Exclude<RequestClaim, CallRequestClaim>;
-export type UpstreamRequestFailure = Readonly<{
-    kind: "akuma-not-born";
-    id: AkuId;
-}> | Readonly<{
-    kind: "failed";
-    diagnostic: string;
-}>;
-export type UpstreamRequestOutcome = Readonly<{
-    kind: "returned";
+export type ErasedRequestExecution = Readonly<{
     result: unknown;
+    serviceJson: string;
 }> | Readonly<{
-    kind: "failed";
-    failure: UpstreamRequestFailure;
-}>;
-export type ForwardedDeliveryReference = Readonly<{
-    kind: "accepted-reference";
-    repoRoot: string;
-    contractId: string;
-    deliveryFactId: string;
-}>;
-export type ForwardedReviewReference = Readonly<{
-    kind: "accepted-reference";
-    repoRoot: string;
-    contractId: string;
-    reviewFactId: string;
-}>;
-export type ForwardedTaskReference = Readonly<{
-    kind: "served-reference";
-    action: TaskMutationAction;
-}>;
-type ReceiptBase<A extends RequestClaim["action"], S extends string> = Readonly<{
-    id: string;
-    action: A;
-    state: S;
+    result: unknown;
+    child: string;
 }>;
-export type RequestReceipt = (ReceiptBase<"akuma.call", "served"> & Readonly<{
-    child: AkuId;
-}>) | (ReceiptBase<"contract.deliver", "served"> & Readonly<{
-    reference: ForwardedDeliveryReference;
-}>) | (ReceiptBase<"contract.review", "served"> & Readonly<{
-    reference: ForwardedReviewReference;
-}>) | (ReceiptBase<TaskMutationAction, "served"> & Readonly<{
-    reference: ForwardedTaskReference;
-}>) | (ReceiptBase<Exclude<RequestClaim["action"], "akuma.call">, "served"> & Readonly<{
-    outcome: UpstreamRequestOutcome;
-}>) | (ReceiptBase<RequestClaim["action"], "refused"> & Readonly<{
-    diagnostic: string;
-}>) | (ReceiptBase<RequestClaim["action"], "voided"> & Readonly<{
-    evidence: string;
-}>);
-export declare function absolute(value: unknown): value is string;
-export declare function canonicalAkuId(value: unknown): AkuId | null;
-export declare function decodeRecipe(value: unknown): RequestRecipe | null;
-export declare function decodeClaim(bytes: string, fileId: string): StructuralRequestClaim | null;
-export declare function decodeReceipt(bytes: string, id: string, action: RequestClaim["action"]): RequestReceipt | null;
-export declare function requestPayload(claim: RequestClaim): unknown;
+/** Erases only static TypeScript parameters; each operation codec remains captured by its owner descriptor. */
+export declare function eraseRequestCommand<Input, Output, Service, Reference, Context>(command: RequestCommand<Input, Output, Service, Reference, Context>): ErasedRequestCommand;
+export type UpstreamRequestFailure = z.infer<typeof upstreamRequestFailureSchema>;
+export type ReturnedEnvelope = z.infer<typeof returnedEnvelopeSchema>;
+export type ReceiptEnvelope = z.infer<typeof receiptEnvelopeSchema>;
+export declare function decodeEnvelope(bytes: string, fileId: string): RequestEnvelope | null;
+export declare function decodeReceiptEnvelope(bytes: string, id: string, action: string): ReceiptEnvelope | null;
 export declare function requestPath(directory: string, id: string): string;
 export declare function receiptPath(directory: string, id: string): string;
 export declare function atomicJson(path: string, value: unknown): Promise<void>;

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

@@ -1,205 +1,67 @@
 import { randomUUID } from "node:crypto";
 import { rename, rm, writeFile } from "node:fs/promises";
-import { isAbsolute, join, resolve } from "node:path";
-import { decodeAllowedActions } from "./allowed.js";
-import { archetypeName, parseAkuId } from "./identity.js";
-import { decodeProviderOptions, decodeReadonlyRestraint } from "./provider-recipe.js";
-import { decodeProviderExecution } from "./providers/index.js";
-import { decodeTaskMutationRequest, isTaskMutationAction, } from "../task/mutation.js";
+import { join } from "node:path";
+import { z } from "zod";
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function exactKeys(value, expected) {
-    const actual = Object.keys(value).sort();
-    const sorted = [...expected].sort();
-    return actual.length === sorted.length && actual.every((key, index) => key === sorted[index]);
-}
-export function absolute(value) {
-    return typeof value === "string" && isAbsolute(value) && resolve(value) === value;
-}
-export function canonicalAkuId(value) {
-    if (typeof value !== "string")
-        return null;
-    try {
-        const id = parseAkuId(value).id;
-        return id === value ? id : null;
-    }
-    catch {
-        return null;
-    }
-}
-function canonicalTargets(value) {
-    if (!Array.isArray(value) || value.length === 0)
-        return null;
-    const ids = [];
-    for (const item of value) {
-        const id = canonicalAkuId(item);
-        if (id === null || (ids.length > 0 && Buffer.compare(Buffer.from(ids.at(-1)), Buffer.from(id)) >= 0))
-            return null;
-        ids.push(id);
-    }
-    return ids;
-}
-export function decodeRecipe(value) {
-    const recipe = object(value);
-    if (recipe === null)
-        return null;
-    const expected = [
-        "allowed",
-        "options",
-        "provider",
-        ...(recipe.description === undefined ? [] : ["description"]),
-        ...(recipe.readonly === undefined ? [] : ["readonly"]),
-    ];
-    if (!exactKeys(recipe, expected) ||
-        (recipe.description !== undefined &&
-            (typeof recipe.description !== "string" || recipe.description.trim().length === 0)))
-        return null;
-    try {
-        const options = decodeProviderOptions(recipe.options);
-        const readonly = recipe.readonly === undefined ? undefined : decodeReadonlyRestraint(recipe.readonly);
-        if ((options.readonly === true) !== (readonly !== undefined))
-            return null;
-        return Object.freeze({
-            ...(recipe.description === undefined ? {} : { description: recipe.description }),
-            allowed: decodeAllowedActions(recipe.allowed),
-            provider: decodeProviderExecution(recipe.provider),
-            options,
-            ...(readonly === undefined ? {} : { readonly }),
-        });
-    }
-    catch {
-        return null;
-    }
-}
-function contractId(value) {
-    return typeof value === "string" && /^kei\/[^/\s]+$/u.test(value) ? value : null;
-}
-function decodeCall(id, payload) {
-    const expected = ["archetype", "body", "recipe", "world", ...(payload.cwd === undefined ? [] : ["cwd"])];
-    if (!exactKeys(payload, expected) ||
-        typeof payload.body !== "string" ||
-        !absolute(payload.world) ||
-        (payload.cwd !== undefined && !absolute(payload.cwd)))
-        return null;
-    try {
-        archetypeName(payload.archetype);
-    }
-    catch {
-        return null;
-    }
-    return {
-        id,
-        action: "akuma.call",
-        world: payload.world,
-        archetype: payload.archetype,
-        body: payload.body,
-        recipe: payload.recipe,
-        ...(payload.cwd === undefined ? {} : { cwd: payload.cwd }),
-    };
-}
-function decodeWait(id, payload) {
-    const targets = canonicalTargets(payload.targets);
-    const expected = ["completion", "targets", ...(payload.timeoutMs === undefined ? [] : ["timeoutMs"])];
-    if (!exactKeys(payload, expected) ||
-        targets === null ||
-        (payload.completion !== "any" && payload.completion !== "all") ||
-        (payload.timeoutMs !== undefined && (!Number.isSafeInteger(payload.timeoutMs) || payload.timeoutMs < 0)))
-        return null;
+const requestIdSchema = z.string().regex(UUID);
+const actionSchema = z.string().refine((value) => value.trim() !== "");
+const requestEnvelopeSchema = z.object({ id: requestIdSchema, action: actionSchema, payload: z.unknown() }).strict();
+const upstreamRequestFailureSchema = z.union([
+    z.object({ kind: z.literal("akuma-not-born"), id: z.string() }).strict(),
+    z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
+]);
+const returnedEnvelopeSchema = z.union([
+    z.object({ kind: z.literal("returned"), result: z.unknown() }).strict(),
+    z.object({ kind: z.literal("failed"), failure: upstreamRequestFailureSchema }).strict(),
+]);
+const receiptEnvelopeSchema = z.union([
+    z
+        .object({ id: requestIdSchema, action: actionSchema, state: z.literal("served"), outcome: returnedEnvelopeSchema })
+        .strict(),
+    z.object({ id: requestIdSchema, action: actionSchema, state: z.literal("served"), reference: z.unknown() }).strict(),
+    z.object({ id: requestIdSchema, action: actionSchema, state: z.literal("refused"), diagnostic: z.string() }).strict(),
+    z
+        .object({
+        id: requestIdSchema,
+        action: actionSchema,
+        state: z.literal("voided"),
+        evidence: z.string(),
+        failure: z.unknown().optional(),
+    })
+        .strict(),
+]);
+/** Erases only static TypeScript parameters; each operation codec remains captured by its owner descriptor. */
+export function eraseRequestCommand(command) {
     return {
-        id,
-        action: "akuma.wait",
-        targets,
-        completion: payload.completion,
-        ...(payload.timeoutMs === undefined ? {} : { timeoutMs: payload.timeoutMs }),
+        action: command.action,
+        resolve: (payload) => {
+            const input = command.decodeRequest(payload);
+            if (input === null)
+                return null;
+            return {
+                payloadJson: JSON.stringify(command.encodeRequest(input)),
+                isPermitted: (allowed) => command.isPermitted(allowed),
+                execute: async (context) => {
+                    const served = await command.execute(input, command.decodeExecutionContext(context));
+                    return "child" in served
+                        ? { result: command.encodeResult(served.result), child: served.child }
+                        : {
+                            result: command.encodeResult(served.result),
+                            serviceJson: JSON.stringify(command.encodeService(served.service)),
+                        };
+                },
+                encodeFailure: (error) => command.encodeFailure?.(error) ?? null,
+                projectServiceJson: (serviceJson) => command.projectService(command.decodeService(JSON.parse(serviceJson))),
+                projectChild: (child) => {
+                    if (command.projectChild === undefined)
+                        throw new Error(`request ${command.action} has no child reference codec`);
+                    return command.projectChild(child);
+                },
+            };
+        },
     };
 }
-function decodeTell(id, payload) {
-    const target = canonicalAkuId(payload.target);
-    return exactKeys(payload, ["body", "target"]) && target !== null && typeof payload.body === "string"
-        ? { id, action: "akuma.tell", target, body: payload.body }
-        : null;
-}
-function decodeKill(id, payload) {
-    const targets = canonicalTargets(payload.targets);
-    return exactKeys(payload, ["targets"]) && targets !== null ? { id, action: "akuma.kill", targets } : null;
-}
-function decodeDeliver(id, payload) {
-    const valid = exactKeys(payload, [
-        "contractId",
-        "includeDirty",
-        "materializeConflict",
-        "repoRoot",
-        ...(payload.message === undefined ? [] : ["message"]),
-    ]);
-    const selected = contractId(payload.contractId);
-    return valid &&
-        selected !== null &&
-        absolute(payload.repoRoot) &&
-        typeof payload.includeDirty === "boolean" &&
-        typeof payload.materializeConflict === "boolean" &&
-        (payload.message === undefined || (typeof payload.message === "string" && payload.message.trim().length > 0))
-        ? {
-            id,
-            action: "contract.deliver",
-            repoRoot: payload.repoRoot,
-            contractId: selected,
-            includeDirty: payload.includeDirty,
-            materializeConflict: payload.materializeConflict,
-            ...(payload.message === undefined ? {} : { message: payload.message }),
-        }
-        : null;
-}
-function decodeReview(id, payload) {
-    const valid = exactKeys(payload, [
-        "contractId",
-        "repoRoot",
-        "verdict",
-        ...(payload.summary === undefined ? [] : ["summary"]),
-    ]);
-    const selected = contractId(payload.contractId);
-    return valid &&
-        selected !== null &&
-        absolute(payload.repoRoot) &&
-        (payload.verdict === "satisfied" || payload.verdict === "unsatisfied") &&
-        (payload.summary === undefined || (typeof payload.summary === "string" && payload.summary.trim().length > 0))
-        ? {
-            id,
-            action: "contract.review",
-            repoRoot: payload.repoRoot,
-            contractId: selected,
-            verdict: payload.verdict,
-            ...(payload.summary === undefined ? {} : { summary: payload.summary }),
-        }
-        : null;
-}
-function decodeTask(id, action, payload) {
-    if (!isTaskMutationAction(action) || !exactKeys(payload, ["request", "world"]) || !absolute(payload.world))
-        return null;
-    try {
-        return {
-            id,
-            action,
-            world: payload.world,
-            request: decodeTaskMutationRequest(action, payload.request),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-const CLAIM_DECODERS = {
-    "akuma.call": decodeCall,
-    "akuma.wait": decodeWait,
-    "akuma.tell": decodeTell,
-    "akuma.kill": decodeKill,
-    "contract.deliver": decodeDeliver,
-    "contract.review": decodeReview,
-};
-export function decodeClaim(bytes, fileId) {
+export function decodeEnvelope(bytes, fileId) {
     let decoded;
     try {
         decoded = JSON.parse(bytes);
@@ -207,107 +69,10 @@ export function decodeClaim(bytes, fileId) {
     catch {
         return null;
     }
-    const value = object(decoded);
-    if (value === null ||
-        !exactKeys(value, ["action", "id", "payload"]) ||
-        !UUID.test(fileId) ||
-        typeof value.id !== "string" ||
-        !UUID.test(value.id))
-        return null;
-    const payload = object(value.payload);
-    if (payload === null || typeof value.action !== "string")
-        return null;
-    const decoder = CLAIM_DECODERS[value.action];
-    return decoder === undefined ? decodeTask(value.id, value.action, payload) : decoder(value.id, payload);
-}
-function outcome(value) {
-    const input = object(value);
-    if (input?.kind === "returned" && exactKeys(input, ["kind", "result"])) {
-        return { kind: input.kind, result: input.result };
-    }
-    const failure = object(input?.failure);
-    if (input?.kind !== "failed" || !exactKeys(input, ["failure", "kind"]) || failure === null)
-        return null;
-    if (failure.kind === "akuma-not-born" && exactKeys(failure, ["id", "kind"])) {
-        const id = canonicalAkuId(failure.id);
-        return id === null ? null : { kind: input.kind, failure: { kind: failure.kind, id } };
-    }
-    return failure.kind === "failed" &&
-        exactKeys(failure, ["diagnostic", "kind"]) &&
-        typeof failure.diagnostic === "string"
-        ? { kind: input.kind, failure: { kind: failure.kind, diagnostic: failure.diagnostic } }
-        : null;
+    const parsed = requestEnvelopeSchema.safeParse(decoded);
+    return UUID.test(fileId) && parsed.success ? parsed.data : null;
 }
-function envelope(value, id, action) {
-    if (value.state === "refused" &&
-        exactKeys(value, ["action", "diagnostic", "id", "state"]) &&
-        typeof value.diagnostic === "string") {
-        return { id, action, state: value.state, diagnostic: value.diagnostic };
-    }
-    if (value.state === "voided" &&
-        exactKeys(value, ["action", "evidence", "id", "state"]) &&
-        typeof value.evidence === "string") {
-        return { id, action, state: value.state, evidence: value.evidence };
-    }
-    if (action !== "akuma.call" && value.state === "served" && exactKeys(value, ["action", "id", "outcome", "state"])) {
-        const decoded = outcome(value.outcome);
-        return decoded === null ? null : { id, action, state: value.state, outcome: decoded };
-    }
-    return null;
-}
-function reference(value, action) {
-    const input = object(value);
-    const field = action === "contract.deliver" ? "deliveryFactId" : "reviewFactId";
-    if (input === null ||
-        !exactKeys(input, ["contractId", field, "kind", "repoRoot"]) ||
-        input.kind !== "accepted-reference" ||
-        !absolute(input.repoRoot) ||
-        contractId(input.contractId) === null ||
-        typeof input[field] !== "string" ||
-        input[field].trim().length === 0)
-        return null;
-    return action === "contract.deliver"
-        ? {
-            kind: input.kind,
-            repoRoot: input.repoRoot,
-            contractId: input.contractId,
-            deliveryFactId: input.deliveryFactId,
-        }
-        : {
-            kind: input.kind,
-            repoRoot: input.repoRoot,
-            contractId: input.contractId,
-            reviewFactId: input.reviewFactId,
-        };
-}
-function decodeCallReceipt(value, id) {
-    if (value.state !== "served" || !exactKeys(value, ["action", "child", "id", "state"]))
-        return null;
-    const child = canonicalAkuId(value.child);
-    return child === null ? null : { id, action: "akuma.call", state: value.state, child };
-}
-function decodeContractReceipt(value, id, action) {
-    if (value.state !== "served" || !exactKeys(value, ["action", "id", "reference", "state"]))
-        return null;
-    const selected = reference(value.reference, action);
-    if (selected === null)
-        return null;
-    return action === "contract.deliver"
-        ? { id, action, state: value.state, reference: selected }
-        : { id, action, state: value.state, reference: selected };
-}
-function decodeTaskReceipt(value, id, action) {
-    if (value.state !== "served" || !exactKeys(value, ["action", "id", "reference", "state"]))
-        return null;
-    const selected = object(value.reference);
-    if (selected === null ||
-        !exactKeys(selected, ["action", "kind"]) ||
-        selected.kind !== "served-reference" ||
-        selected.action !== action)
-        return null;
-    return { id, action, state: value.state, reference: { kind: selected.kind, action } };
-}
-export function decodeReceipt(bytes, id, action) {
+export function decodeReceiptEnvelope(bytes, id, action) {
     let decoded;
     try {
         decoded = JSON.parse(bytes);
@@ -315,28 +80,8 @@ export function decodeReceipt(bytes, id, action) {
     catch {
         return null;
     }
-    const value = object(decoded);
-    if (value === null || value.id !== id || value.action !== action)
-        return null;
-    const shared = envelope(value, id, action);
-    if (shared !== null)
-        return shared;
-    if (action === "akuma.call")
-        return decodeCallReceipt(value, id);
-    if (action === "contract.deliver" || action === "contract.review")
-        return decodeContractReceipt(value, id, action);
-    if (isTaskMutationAction(action))
-        return decodeTaskReceipt(value, id, action);
-    return null;
-}
-export function requestPayload(claim) {
-    if (isTaskMutationAction(claim.action)) {
-        const task = claim;
-        const { action: _action, ...request } = task.request;
-        return { world: task.world, request };
-    }
-    const { id: _id, action: _action, ...payload } = claim;
-    return payload;
+    const parsed = receiptEnvelopeSchema.safeParse(decoded);
+    return parsed.success && parsed.data.id === id && parsed.data.action === action ? parsed.data : null;
 }
 export function requestPath(directory, id) {
     return join(directory, `${id}.request.json`);