@astrosheep/keiyaku 4.5.6 → 4.5.8

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

@@ -1,76 +1,16 @@
-import { type KillEvidence, type RequestFact } from "./heart/index.js";
-import { type AkuId } from "./identity.js";
-import { type StructuralRequestClaim } from "./request-wire.js";
-import { type TaskMutationRequest } from "../task/mutation.js";
-import { BodyRequestPump as LifecycleBodyRequestPump, type RequestChildLaunch as LifecycleRequestChildLaunch, type PumpInput as LifecyclePumpInput } from "./request-lifecycle.js";
+import { type ErasedRequestCommand, type RequestEnvelope } from "./request-wire.js";
+import { BodyRequestPump as LifecycleBodyRequestPump, type PumpInput as LifecyclePumpInput } from "./request-lifecycle.js";
 export { clearBodyRequestTransport, settleBodyRequests } from "./request-lifecycle.js";
-export type RequestChildLaunch = LifecycleRequestChildLaunch;
-type UpstreamCall = Readonly<{
-    signal: AbortSignal;
-}>;
-type RequesterCall = UpstreamCall & Readonly<{
-    requester: AkuId;
-}>;
-type ContractCall = RequesterCall & Readonly<{
-    repoRoot: string;
-    contractId: string;
-}>;
-export type UpstreamExecutionPort = Readonly<{
-    wait(input: UpstreamCall & Readonly<{
-        targets: readonly AkuId[];
-        completion: "any" | "all";
-        timeoutMs?: number;
-    }>): Promise<unknown>;
-    tell(input: UpstreamCall & Readonly<{
-        target: AkuId;
-        body: string;
-        tellId: string;
-        recordedAt: string;
-    }>): Promise<unknown>;
-    kill(input: Readonly<{
-        targets: readonly AkuId[];
-        signal: AbortSignal;
-    }>): Promise<Readonly<{
-        result: unknown;
-        service: readonly Readonly<{
-            id: AkuId;
-            evidence: KillEvidence;
-        }>[];
-    }>>;
-    deliver(input: ContractCall & Readonly<{
-        message?: string;
-        includeDirty: boolean;
-        materializeConflict: boolean;
-    }>): Promise<Readonly<{
-        result: unknown;
-        deliveryFactId?: string;
-    }>>;
-    review(input: ContractCall & Readonly<{
-        verdict: "satisfied" | "unsatisfied";
-        summary?: string;
-    }>): Promise<Readonly<{
-        result: unknown;
-        reviewFactId?: string;
-    }>>;
-    task(input: RequesterCall & Readonly<{
-        world: string;
-        request: TaskMutationRequest;
-    }>): Promise<unknown>;
-}>;
 type PumpInput = Omit<LifecyclePumpInput, "upstream"> & Readonly<{
-    upstream?: UpstreamExecutionPort;
+    upstream?: unknown;
+    commands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
 export type ServeInput = Omit<PumpInput, "bodySequence"> & Readonly<{
     directory: string;
     transportId: string;
-    claim: StructuralRequestClaim;
+    claim: RequestEnvelope;
     admissionOpen(): boolean;
 }>;
-export type UpstreamFact = Exclude<Extract<RequestFact, {
-    state: "admitted";
-}>, Extract<RequestFact, {
-    action: "akuma.call";
-}>>;
 export declare function serveRequest(input: ServeInput): Promise<void>;
 export declare class BodyRequestPump extends LifecycleBodyRequestPump {
     static open(input: PumpInput): Promise<BodyRequestPump>;

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

@@ -1,251 +1,139 @@
-import { admitRequest, readRequest, refuseRequest, reserveRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
-import { worldRootForAkumaPaths } from "./identity.js";
-import { publishAkuma } from "./publication.js";
-import { atomicJson, canonicalAkuId, decodeRecipe, receiptPath, } from "./request-wire.js";
-import { isTaskMutationAction } from "../task/mutation.js";
-import { executeRequest } from "./request-execution.js";
+import { admitRequest, isRequestInputConflict, readRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
+import { atomicJson, receiptPath, } from "./request-wire.js";
 import { BodyRequestPump as LifecycleBodyRequestPump, } from "./request-lifecycle.js";
 export { clearBodyRequestTransport, settleBodyRequests } from "./request-lifecycle.js";
-function diagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function isTask(value) {
-    return isTaskMutationAction(value.action);
-}
-function refusalRecipe(value) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-        const recipe = value;
-        if (Array.isArray(recipe.allowed))
-            return recipe;
-        return { ...recipe, allowed: [] };
-    }
-    return { allowed: [] };
-}
-function acceptedReceipt(fact, service) {
-    return {
-        id: fact.id,
-        action: fact.action,
-        state: fact.state,
-        reference: service.action === "contract.deliver"
+async function projectCommandReceipt(input, fact, command, outcome, failure) {
+    const receipt = fact.state === "refused"
+        ? { id: fact.id, action: fact.action, state: "refused", diagnostic: fact.diagnostic }
+        : fact.state === "voided"
             ? {
-                kind: "accepted-reference",
-                repoRoot: service.repoRoot,
-                contractId: service.contractId,
-                deliveryFactId: service.deliveryFactId,
+                id: fact.id,
+                action: fact.action,
+                state: "voided",
+                evidence: fact.evidence,
+                ...(failure === undefined ? {} : { failure }),
             }
-            : {
-                kind: "accepted-reference",
-                repoRoot: service.repoRoot,
-                contractId: service.contractId,
-                reviewFactId: service.reviewFactId,
-            },
-    };
-}
-function receiptFor(fact) {
-    if (fact.state === "refused") {
-        return { id: fact.id, action: fact.action, state: fact.state, diagnostic: fact.diagnostic };
-    }
-    if (fact.state === "voided") {
-        return { id: fact.id, action: fact.action, state: fact.state, evidence: fact.evidence };
-    }
-    if (fact.action === "akuma.call" && fact.state === "served") {
-        return { id: fact.id, action: fact.action, state: fact.state, child: fact.child };
-    }
-    if (fact.state !== "served")
-        return null;
-    if (fact.action === "contract.deliver") {
-        return acceptedReceipt(fact, fact.service);
-    }
-    if (fact.action === "contract.review") {
-        return acceptedReceipt(fact, fact.service);
-    }
-    if (isTask(fact)) {
-        return {
-            id: fact.id,
-            action: fact.action,
-            state: fact.state,
-            reference: { kind: "served-reference", action: fact.action },
-        };
-    }
-    return null;
-}
-async function projectReceipt(directory, transportId, fact, outcome) {
-    const receipt = outcome === undefined
-        ? receiptFor(fact)
-        : fact.action === "akuma.call"
-            ? null
-            : { id: fact.id, action: fact.action, state: "served", outcome };
+            : outcome === undefined
+                ? "serviceJson" in fact
+                    ? {
+                        id: fact.id,
+                        action: fact.action,
+                        state: "served",
+                        reference: command.projectServiceJson(fact.serviceJson),
+                    }
+                    : "child" in fact
+                        ? {
+                            id: fact.id,
+                            action: fact.action,
+                            state: "served",
+                            reference: command.projectChild(fact.child),
+                        }
+                        : null
+                : { id: fact.id, action: fact.action, state: "served", outcome };
     if (receipt === null)
         return;
     try {
-        await atomicJson(receiptPath(directory, transportId), receipt);
+        await atomicJson(receiptPath(input.directory, input.transportId), receipt);
     }
     catch (error) {
         if (error.code !== "ENOENT")
             throw error;
     }
 }
-async function refuseInvalidCall(input) {
+async function serveCommand(input, command) {
+    const request = command.resolve(input.claim.payload);
+    if (request === null)
+        return false;
     let fact = await admitRequest(input.paths, {
-        ...input.claim,
-        recipe: refusalRecipe(input.claim.recipe),
+        id: input.claim.id,
+        action: input.claim.action,
+        payloadJson: request.payloadJson,
         admittedAt: input.now(),
+        permitted: request.isPermitted(input.parent.allowed),
     });
-    const existing = receiptFor(fact);
-    if (existing !== null) {
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
-    }
-    fact = await refuseRequest(input.paths, input.claim.id, "invalid akuma.call recipe");
-    await projectReceipt(input.directory, input.transportId, fact);
-}
-async function serveCall(input) {
-    input.signal.throwIfAborted();
-    if (!input.admissionOpen())
-        return;
-    const recipe = decodeRecipe(input.claim.recipe);
-    if (recipe === null) {
-        await refuseInvalidCall(input);
-        return;
-    }
-    let fact = await admitRequest(input.paths, { ...input.claim, recipe, admittedAt: input.now() });
-    const existing = receiptFor(fact);
-    if (existing !== null) {
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
+    if (fact.state !== "admitted") {
+        await projectCommandReceipt(input, fact, request);
+        return true;
     }
     if (!input.admissionOpen()) {
-        fact = await voidRequest(input.paths, input.claim.id, "body closed request admission");
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
-    }
-    if (fact.action !== "akuma.call" || fact.state !== "admitted") {
-        throw new Error(`Akuma request ${fact.id} cannot be replayed from ${fact.state}`);
-    }
-    const request = fact;
-    const world = worldRootForAkumaPaths(input.paths);
-    if (request.world !== world) {
-        fact = await refuseRequest(input.paths, request.id, `request world ${request.world} does not match ${world}`);
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
+        fact = await voidRequest(input.paths, fact.id, "body closed request admission");
+        await projectCommandReceipt(input, fact, request);
+        return true;
     }
     try {
-        const published = await publishAkuma({
-            worldPath: world,
-            archetype: request.archetype,
+        const served = await request.execute({
+            id: fact.id,
+            admittedAt: fact.admittedAt,
+            requester: fact.requester,
             signal: input.signal,
-            launch: async (allocated) => {
-                if (!input.admissionOpen())
-                    throw new Error("body closed request admission");
-                fact = await reserveRequest(input.paths, request.id, allocated.id);
-                return await input.spawn({
-                    paths: allocated.paths,
-                    seed: {
-                        id: allocated.id,
-                        archetype: allocated.archetype,
-                        ...(request.recipe.description === undefined ? {} : { description: request.recipe.description }),
-                        provider: request.recipe.provider,
-                        options: request.recipe.options,
-                        ...(request.recipe.readonly === undefined ? {} : { readonly: request.recipe.readonly }),
-                        allowed: request.recipe.allowed,
-                        cwd: request.cwd ?? input.parent.cwd,
-                        origin: {
-                            kind: "request",
-                            parent: input.parent.id,
-                            requestId: request.id,
-                        },
-                    },
-                    initialBody: request.body,
-                });
-            },
+            upstream: input.upstream,
+            paths: input.paths,
+            parent: input.parent,
+            spawn: input.spawn,
+            admissionOpen: input.admissionOpen,
         });
-        fact = await serveChildRequest(input.paths, request.id, published.id);
+        fact =
+            "child" in served
+                ? await serveChildRequest(input.paths, fact.id, served.child)
+                : await serveUpstreamRequest(input.paths, fact.id, served.serviceJson);
+        await projectCommandReceipt(input, fact, request, { kind: "returned", result: served.result });
     }
     catch (error) {
-        const current = await readRequest(input.paths, request.id);
+        const failure = encodedFailure(request, error);
+        const current = await readRequest(input.paths, fact.id);
         if (current === null)
             throw error;
         fact =
             current.state === "admitted" || current.state === "reserved"
-                ? await voidRequest(input.paths, request.id, diagnostic(error))
+                ? await voidRequest(input.paths, fact.id, diagnostic(error))
                 : current;
+        await projectCommandReceipt(input, fact, request, undefined, failure);
     }
-    await projectReceipt(input.directory, input.transportId, fact);
+    return true;
 }
-function failure(error) {
-    const value = error !== null && typeof error === "object" ? error : null;
-    if (value?.kind === "akuma-not-born") {
-        const id = canonicalAkuId(value.id);
-        if (id !== null)
-            return { kind: "akuma-not-born", id };
-    }
-    return { kind: "failed", diagnostic: diagnostic(error) };
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
 }
-function pendingService(request) {
-    if (request.action === "akuma.wait")
-        return { action: request.action };
-    if (request.action === "akuma.tell") {
-        return { action: request.action, target: request.target, tellId: request.id };
+function encodedFailure(request, error) {
+    try {
+        const failure = request.encodeFailure(error);
+        return failure === null ? undefined : failure;
     }
-    return request.action === "akuma.kill" ? { action: request.action, results: [] } : undefined;
-}
-async function serveUpstream(input) {
-    input.signal.throwIfAborted();
-    let fact = await admitRequest(input.paths, {
-        ...input.claim,
-        admittedAt: input.now(),
-    });
-    const existing = receiptFor(fact);
-    if (existing !== null) {
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
+    catch {
+        return undefined;
     }
-    if (fact.state === "served") {
-        await projectReceipt(input.directory, input.transportId, fact, {
-            kind: "failed",
-            failure: {
-                kind: "failed",
-                diagnostic: "served request receipt is no longer available",
-            },
+}
+export async function serveRequest(input) {
+    const command = input.commands[input.claim.action];
+    if (command === undefined) {
+        await atomicJson(receiptPath(input.directory, input.transportId), {
+            id: input.claim.id,
+            action: input.claim.action,
+            state: "refused",
+            diagnostic: `request action ${input.claim.action} is not registered`,
         });
         return;
     }
-    if (!input.admissionOpen()) {
-        fact = await voidRequest(input.paths, input.claim.id, "body closed request admission");
-        await projectReceipt(input.directory, input.transportId, fact);
+    if (await serveCommand(input, command))
         return;
-    }
-    if (fact.state !== "admitted" || fact.action === "akuma.call") {
-        throw new Error(`Akuma request ${fact.id} cannot be served from ${fact.state}`);
-    }
-    const request = fact;
-    let outcome;
-    let service = pendingService(request);
+}
+async function serveTransportClaim(input) {
     try {
-        const served = await executeRequest(input, request);
-        outcome = { kind: "returned", result: served.result };
-        if (served.service !== undefined)
-            service = served.service;
+        await serveRequest(input);
     }
     catch (error) {
-        outcome = { kind: "failed", failure: failure(error) };
-        fact = await voidRequest(input.paths, request.id, "body failed before serving the request");
-        await projectReceipt(input.directory, input.transportId, fact);
-        return;
+        if (!isRequestInputConflict(error))
+            throw error;
+        await atomicJson(receiptPath(input.directory, input.transportId), {
+            id: input.claim.id,
+            action: input.claim.action,
+            state: "refused",
+            diagnostic: error.message,
+        });
     }
-    fact =
-        service === undefined
-            ? await voidRequest(input.paths, request.id, "body completed without a durable Contract fact reference")
-            : await serveUpstreamRequest(input.paths, request.id, service);
-    await projectReceipt(input.directory, input.transportId, fact, outcome);
-}
-export async function serveRequest(input) {
-    return input.claim.action === "akuma.call"
-        ? await serveCall({ ...input, claim: input.claim })
-        : await serveUpstream({ ...input, claim: input.claim });
 }
 export class BodyRequestPump extends LifecycleBodyRequestPump {
     static async open(input) {
-        return (await LifecycleBodyRequestPump.openWithService(input, async (claim) => await serveRequest(claim)));
+        return (await LifecycleBodyRequestPump.openWithService(input, async (claim) => await serveTransportClaim({ ...claim, commands: input.commands })));
     }
 }

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>;