@astrosheep/keiyaku 4.5.7 → 4.5.8

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

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

@@ -1,49 +1,21 @@
-import { type CallRequestClaim, type DeliverRequestClaim, type ForwardedDeliveryReference, type ForwardedReviewReference, type KillRequestClaim, type ReviewRequestClaim, type TellRequestClaim, type UpstreamRequestOutcome, type WaitRequestClaim } from "./request-wire.js";
-import { type TaskMutationRequest } from "../task/mutation.js";
-export type { UpstreamRequestOutcome } from "./request-wire.js";
-export declare class AkumaBodyRequestError extends Error {
-    readonly outcome: "refused" | "voided";
-    readonly diagnostic: string;
-    readonly kind = "akuma-body-request";
-    constructor(outcome: "refused" | "voided", diagnostic: string);
-}
-export declare function injectedBodyRequests(): string | null;
-export declare function requestBodyCall(input: Omit<CallRequestClaim, "action"> & Readonly<{
+export { AkumaBodyRequestError, requestBodyCommand } from "./request-rendezvous.js";
+export type ExecutionChannel = Readonly<{
+    kind: "local";
+}> | Readonly<{
+    kind: "body-request";
     directory: string;
-}>): Promise<import("./identity.js").AkuId>;
-export declare function requestBodyTask(input: Readonly<{
-    directory: string;
-    world: string;
-    request: TaskMutationRequest;
-    id?: string;
-}>): Promise<unknown>;
-export declare function requestBodyWait(input: Omit<WaitRequestClaim, "action" | "id"> & Readonly<{
-    directory: string;
-    id?: string;
-}>): Promise<UpstreamRequestOutcome>;
-export declare function requestBodyTell(input: Omit<TellRequestClaim, "action" | "id"> & Readonly<{
-    directory: string;
-    id?: string;
-}>): Promise<UpstreamRequestOutcome>;
-export declare function requestBodyKill(input: Omit<KillRequestClaim, "action" | "id"> & Readonly<{
-    directory: string;
-    id?: string;
-}>): Promise<UpstreamRequestOutcome>;
-type ContractRequestInput<T extends DeliverRequestClaim | ReviewRequestClaim> = Omit<T, "action" | "id"> & Readonly<{
-    directory: string;
-    signal?: AbortSignal;
 }>;
-type BodyDeliverInput = ContractRequestInput<DeliverRequestClaim>;
-export declare function requestBodyDeliver(input: BodyDeliverInput & Readonly<{
-    id?: never;
-}>): Promise<UpstreamRequestOutcome>;
-export declare function requestBodyDeliver(input: BodyDeliverInput & Readonly<{
-    id: string;
-}>): Promise<UpstreamRequestOutcome | ForwardedDeliveryReference>;
-type BodyReviewInput = ContractRequestInput<ReviewRequestClaim>;
-export declare function requestBodyReview(input: BodyReviewInput & Readonly<{
-    id?: never;
-}>): Promise<UpstreamRequestOutcome>;
-export declare function requestBodyReview(input: BodyReviewInput & Readonly<{
-    id: string;
-}>): Promise<UpstreamRequestOutcome | ForwardedReviewReference>;
+export type ExecutionContext = Readonly<{
+    channel: ExecutionChannel;
+}>;
+export type LibraryExecution = ExecutionContext;
+export declare function localExecutionContext(): ExecutionContext;
+export declare function bodyRequestExecutionContext(directory: unknown): ExecutionContext;
+/** Constructs the one direct-parent route a caller may explicitly compose. */
+export declare function bodyRequestExecution(input: Readonly<{
+    directory: string;
+}>): LibraryExecution;
+/** Normalizes the public carrier before a composition captures its immutable channel. */
+export declare function libraryExecution(value: unknown): LibraryExecution;
+export declare function libraryExecutionInput(input: unknown): LibraryExecution;
+export declare function executionChannel(context?: ExecutionContext): ExecutionChannel;

package/build/src/akuma/requests.js

@@ -1,120 +1,64 @@
-import { randomUUID } from "node:crypto";
-import { access, readFile } from "node:fs/promises";
-import { abortableDelay } from "./abort.js";
-import { AKUMA_REQUESTS_ENV } from "./provider.js";
-import { absolute, atomicJson, decodeReceipt, receiptPath, requestPath, requestPayload, } from "./request-wire.js";
-import { isTaskMutationAction } from "../task/mutation.js";
-const POLL_MS = 100;
-export class AkumaBodyRequestError extends Error {
-    outcome;
-    diagnostic;
-    kind = "akuma-body-request";
-    constructor(outcome, diagnostic) {
-        super(`Akuma body request ${outcome}: ${diagnostic}`);
-        this.outcome = outcome;
-        this.diagnostic = diagnostic;
-        this.name = "AkumaBodyRequestError";
-    }
-}
-export function injectedBodyRequests() {
-    const directory = process.env[AKUMA_REQUESTS_ENV];
-    if (directory === undefined)
-        return null;
-    if (!absolute(directory))
-        throw new Error(`${AKUMA_REQUESTS_ENV} must be an absolute normalized path`);
-    return directory;
+import { isAbsolute, resolve } from "node:path";
+export { AkumaBodyRequestError, requestBodyCommand } from "./request-rendezvous.js";
+const LOCAL_CHANNEL = Object.freeze({ kind: "local" });
+export function localExecutionContext() {
+    return Object.freeze({ channel: LOCAL_CHANNEL });
 }
-async function requestBody(input) {
-    input.signal?.throwIfAborted();
-    const transportId = randomUUID();
-    await atomicJson(requestPath(input.directory, transportId), {
-        id: input.claim.id,
-        action: input.claim.action,
-        payload: requestPayload(input.claim),
-    });
-    const path = receiptPath(input.directory, transportId);
-    for (;;) {
-        try {
-            const receipt = decodeReceipt(await readFile(path, "utf8"), input.claim.id, input.claim.action);
-            if (receipt === null)
-                throw new Error(`Akuma body request ${input.claim.id} has an invalid receipt`);
-            if (receipt.state === "refused")
-                throw new AkumaBodyRequestError("refused", receipt.diagnostic);
-            if (receipt.state === "voided")
-                throw new AkumaBodyRequestError("voided", receipt.evidence);
-            return receipt;
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-        if (!(await access(input.directory).then(() => true, () => false))) {
-            throw new AkumaBodyRequestError("voided", "parent request channel closed before a receipt");
-        }
-        await abortableDelay(POLL_MS, input.signal);
+export function bodyRequestExecutionContext(directory) {
+    if (typeof directory !== "string" || !isAbsolute(directory) || resolve(directory) !== directory) {
+        throw new Error("AKUMA_REQUESTS must be an absolute normalized path");
     }
+    return Object.freeze({ channel: Object.freeze({ kind: "body-request", directory }) });
 }
-export async function requestBodyCall(input) {
-    const { directory, ...claim } = input;
-    const receipt = await requestBody({ directory, claim: { ...claim, action: "akuma.call" } });
-    if (receipt.action !== "akuma.call" || receipt.state !== "served") {
-        throw new Error(`Akuma body request ${input.id} returned the wrong action`);
+function valueRecord(value, label) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError(`${label} must be an object`);
     }
-    return receipt.child;
+    return value;
 }
-async function requestUpstream(directory, claim, signal) {
-    const receipt = await requestBody({ directory, claim, ...(signal === undefined ? {} : { signal }) });
-    if (receipt.action === "akuma.call" || receipt.state !== "served" || !("outcome" in receipt)) {
-        throw new Error(`Akuma body request ${claim.id} returned the wrong action`);
+function closed(value, keys, label) {
+    for (const key of Object.keys(value)) {
+        if (!keys.includes(key))
+            throw new TypeError(`${label} has unknown field: ${key}`);
     }
-    return receipt.outcome;
 }
-export async function requestBodyTask(input) {
-    const id = input.id ?? randomUUID();
-    const receipt = await requestBody({
-        directory: input.directory,
-        claim: { id, action: input.request.action, world: input.world, request: input.request },
-    });
-    if (!isTaskMutationAction(receipt.action) || receipt.action !== input.request.action || receipt.state !== "served") {
-        throw new Error(`Akuma body request ${id} returned the wrong action`);
+/** Constructs the one direct-parent route a caller may explicitly compose. */
+export function bodyRequestExecution(input) {
+    const value = valueRecord(input, "body request execution input");
+    closed(value, ["directory"], "body request execution input");
+    if (typeof value.directory !== "string")
+        throw new TypeError("body request execution directory must be a string");
+    try {
+        return bodyRequestExecutionContext(value.directory);
+    }
+    catch (error) {
+        throw new TypeError(error instanceof Error ? error.message : String(error));
     }
-    if ("reference" in receipt)
-        return receipt.reference;
-    if (receipt.outcome.kind === "returned")
-        return receipt.outcome.result;
-    throw new Error(receipt.outcome.failure.kind === "failed"
-        ? receipt.outcome.failure.diagnostic
-        : "Akuma body request parent is not born");
-}
-export async function requestBodyWait(input) {
-    const { directory, id = randomUUID(), ...claim } = input;
-    return await requestUpstream(directory, { ...claim, id, action: "akuma.wait" });
-}
-export async function requestBodyTell(input) {
-    const { directory, id = randomUUID(), ...claim } = input;
-    return await requestUpstream(directory, { ...claim, id, action: "akuma.tell" });
-}
-export async function requestBodyKill(input) {
-    const { directory, id = randomUUID(), ...claim } = input;
-    return await requestUpstream(directory, { ...claim, id, action: "akuma.kill" });
 }
-async function requestContract(input, action) {
-    const { directory, id = randomUUID(), signal, ...claim } = input;
-    const receipt = await requestBody({
-        directory,
-        claim: { ...claim, id, action },
-        ...(signal === undefined ? {} : { signal }),
-    });
-    if (receipt.action !== action || receipt.state !== "served") {
-        throw new Error(`Akuma body request ${id} returned the wrong action`);
+/** Normalizes the public carrier before a composition captures its immutable channel. */
+export function libraryExecution(value) {
+    const context = valueRecord(value, "execution");
+    closed(context, ["channel"], "execution");
+    const channel = valueRecord(context.channel, "execution channel");
+    if (channel.kind === "local") {
+        closed(channel, ["kind"], "execution channel");
+        return localExecutionContext();
+    }
+    if (channel.kind === "body-request") {
+        closed(channel, ["directory", "kind"], "execution channel");
+        if (typeof channel.directory !== "string")
+            throw new TypeError("execution channel directory must be a string");
+        return bodyRequestExecution({ directory: channel.directory });
     }
-    return "reference" in receipt
-        ? receipt.reference
-        : receipt.outcome;
+    throw new TypeError("execution channel must be local or body-request");
 }
-export async function requestBodyDeliver(input) {
-    return await requestContract(input, "contract.deliver");
+export function libraryExecutionInput(input) {
+    const value = valueRecord(input, "Keiyaku.withExecution input");
+    closed(value, ["execution"], "Keiyaku.withExecution input");
+    if (value.execution === undefined)
+        throw new TypeError("Keiyaku.withExecution input requires execution");
+    return libraryExecution(value.execution);
 }
-export async function requestBodyReview(input) {
-    return await requestContract(input, "contract.review");
+export function executionChannel(context) {
+    return context?.channel ?? LOCAL_CHANNEL;
 }