@astrosheep/keiyaku 4.5.6 → 4.5.8

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -1,6 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { abortable } from "../../abort.js";
-import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, createProviderAttempt, } from "../../provider.js";
 import { createEventState, mapEvent } from "./events.js";
 import { coordinate, loadOpencode, OPENCODE_SDK_PROVIDER, parseModel } from "./session.js";
 function object(value) {
@@ -201,27 +200,51 @@ async function forceDisposeOpencode(abortController, close, finish) {
     await close();
     await finish({ kind: "failed", diagnostic: "OpenCode session force-disposed" });
 }
-async function loadDriveRuntime(execution, input, signal, loader) {
-    return await abortable(loadOpencode({
+async function loadDriveRuntime(execution, input, signal, loader, onRuntime) {
+    const runtime = await loadOpencode({
         ...execution,
         env: {
             ...execution.env,
             ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
         },
-    }, input.cwd, signal, loader), signal, async (late) => await late.close());
+    }, input.cwd, signal, loader, onRuntime);
+    if (signal.aborted) {
+        await runtime.close();
+        signal.throwIfAborted();
+    }
+    return runtime;
+}
+function ownRuntime(custody, runtime) {
+    let closing;
+    let settleRuntimeClosed;
+    let rejectRuntimeClosed;
+    const runtimeClosed = new Promise((resolve, reject) => {
+        settleRuntimeClosed = resolve;
+        rejectRuntimeClosed = reject;
+    });
+    const close = () => {
+        if (closing === undefined) {
+            closing = runtime.close();
+            void closing.then(settleRuntimeClosed, rejectRuntimeClosed);
+        }
+        return closing;
+    };
+    custody?.own({ closed: runtimeClosed, abort: close, forceDispose: close });
+    return close;
 }
 async function openDriveSession(runtime, input, resumeSessionId, signal) {
     const session = runtime.client.session;
-    const response = await abortable(input.session.kind === "fresh"
+    const response = await (input.session.kind === "fresh"
         ? session.create({ query: { directory: input.cwd }, throwOnError: true })
-        : session.get({ path: { id: resumeSessionId }, query: { directory: input.cwd }, throwOnError: true }), signal);
+        : session.get({ path: { id: resumeSessionId }, query: { directory: input.cwd }, throwOnError: true }));
+    signal.throwIfAborted();
     const info = object(object(response)?.data) ?? object(response);
     const sessionId = text(info?.id) ?? resumeSessionId;
     if (sessionId === undefined)
         throw new Error("OpenCode did not return a session id");
     return { session, sessionId };
 }
-async function drive(execution, input, loader) {
+async function drive(execution, input, loader, custody) {
     admit(input.options);
     const signal = input.signal ?? new AbortController().signal;
     const resumeSessionId = input.session.kind === "resume" ? opencodeSessionId(input.session.coordinate) : undefined;
@@ -229,13 +252,11 @@ async function drive(execution, input, loader) {
     const abortSetup = () => abortController.abort(signal.reason);
     signal.addEventListener("abort", abortSetup, { once: true });
     signal.throwIfAborted();
-    const runtime = await loadDriveRuntime(execution, input, abortController.signal, loader);
-    let closing;
+    let closeOnce;
+    const runtime = await loadDriveRuntime(execution, input, abortController.signal, loader, (ready) => {
+        closeOnce = ownRuntime(custody, ready);
+    });
     let iterator;
-    const closeOnce = () => {
-        closing ??= runtime.close();
-        return closing;
-    };
     try {
         const { session, sessionId } = await openDriveSession(runtime, input, resumeSessionId, abortController.signal);
         const events = new AgentEventChannel();
@@ -243,9 +264,11 @@ async function drive(execution, input, loader) {
         const messageID = `msg_${randomUUID().replaceAll("-", "")}`;
         const submissionState = { started: false };
         events.emit({ type: "session", coordinate: coordinate(sessionId) });
-        const streamResult = await abortable(runtime.client.event.subscribe({ query: { directory: input.cwd } }), abortController.signal, async (late) => {
-            await late.stream[Symbol.asyncIterator]().return?.(undefined);
-        });
+        const streamResult = await runtime.client.event.subscribe({ query: { directory: input.cwd } });
+        if (abortController.signal.aborted) {
+            await streamResult.stream[Symbol.asyncIterator]().return?.(undefined);
+            abortController.signal.throwIfAborted();
+        }
         iterator = streamResult.stream[Symbol.asyncIterator]();
         const { completion, finish } = terminalSettlement(events, closeOnce);
         const observation = observeTurn({
@@ -259,12 +282,13 @@ async function drive(execution, input, loader) {
             submissionState,
         });
         submissionState.started = true;
-        await abortable(session.promptAsync({
+        await session.promptAsync({
             path: { id: sessionId },
             query: { directory: input.cwd },
             body: promptBody(input, messageID),
             throwOnError: true,
-        }), abortController.signal);
+        });
+        abortController.signal.throwIfAborted();
         void observation.then(finish);
         signal.removeEventListener("abort", abortSetup);
         return {
@@ -312,11 +336,28 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
                     }),
             };
         },
-        start: (input) => drive(execution, input, loader),
-        resume: (input) => drive(execution, input, loader),
-        fork: async (input) => {
+        start: (input) => createProviderAttempt(input.signal, async (custody) => await drive(execution, { ...input, signal: custody.signal }, loader, custody)),
+        resume: (input) => createProviderAttempt(input.signal, async (custody) => await drive(execution, { ...input, signal: custody.signal }, loader, custody)),
+        fork: (input) => createProviderAttempt(new AbortController().signal, async (custody) => {
             const sessionId = opencodeSessionId(input.session);
-            const runtime = await loadOpencode(execution, input.cwd, new AbortController().signal, loader);
+            let close;
+            const runtime = await loadOpencode(execution, input.cwd, custody.signal, loader, (ready) => {
+                let closing;
+                let settleRuntimeClosed;
+                let rejectRuntimeClosed;
+                const runtimeClosed = new Promise((resolve, reject) => {
+                    settleRuntimeClosed = resolve;
+                    rejectRuntimeClosed = reject;
+                });
+                close = () => {
+                    if (closing === undefined) {
+                        closing = ready.close();
+                        void closing.then(settleRuntimeClosed, rejectRuntimeClosed);
+                    }
+                    return closing;
+                };
+                custody.own({ closed: runtimeClosed, abort: close, forceDispose: close });
+            });
             try {
                 const result = await runtime.client.session.fork({
                     path: { id: sessionId },
@@ -330,8 +371,8 @@ export function createOpencodeProvider(input = { name: OPENCODE_SDK_PROVIDER, ki
                 return { session: coordinate(id) };
             }
             finally {
-                await runtime.close();
+                await close();
             }
-        },
+        }),
     };
 }

package/build/src/akuma/providers/opencode-sdk/session.d.ts

@@ -3,12 +3,13 @@ import type { ResumeCoordinate } from "../../heart/index.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
 export type OpencodeSdkSession = Pick<OpencodeClient["session"], "create" | "get" | "fork" | "abort" | "promptAsync" | "messages">;
 export type OpencodeSdkEvent = Pick<OpencodeClient["event"], "subscribe">;
-export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution) => Promise<Readonly<{
+export type OpencodeSdkLoader = (cwd: string, execution: ProviderExecution, signal: AbortSignal) => Promise<Readonly<{
     client: {
         session: OpencodeSdkSession;
         event: OpencodeSdkEvent;
     };
     close?: () => Promise<void> | void;
+    ready?: Promise<void>;
 }>>;
 export declare const OPENCODE_SDK_PROVIDER: "opencode-sdk";
 export declare function parseModel(model: string): Readonly<{
@@ -22,5 +23,5 @@ export type OpencodeRuntime = Readonly<{
     };
     close: () => Promise<void>;
 }>;
-export declare function loadOpencode(execution: ProviderExecution, cwd: string, signal: AbortSignal, loader?: OpencodeSdkLoader): Promise<OpencodeRuntime>;
+export declare function loadOpencode(execution: ProviderExecution, cwd: string, signal: AbortSignal, loader?: OpencodeSdkLoader, onRuntime?: (runtime: OpencodeRuntime) => void): Promise<OpencodeRuntime>;
 export declare function coordinate(sessionId: string): ResumeCoordinate;

package/build/src/akuma/providers/opencode-sdk/session.js

@@ -37,15 +37,28 @@ async function availablePort() {
         });
     });
 }
-export async function loadOpencode(execution, cwd, signal, loader) {
+export async function loadOpencode(execution, cwd, signal, loader, onRuntime) {
     if (loader) {
-        const loaded = await loader(cwd, execution);
-        return {
+        const loaded = await abortable(loader(cwd, execution, signal), signal);
+        let closing;
+        const runtime = {
             client: loaded.client,
             close: async () => {
-                await loaded.close?.();
+                closing ??= Promise.resolve(loaded.close?.()).then(() => undefined);
+                await closing;
             },
         };
+        onRuntime?.(runtime);
+        try {
+            if (loaded.ready !== undefined)
+                await abortable(loaded.ready, signal);
+            signal.throwIfAborted();
+            return runtime;
+        }
+        catch (error) {
+            await runtime.close();
+            throw error;
+        }
     }
     const port = await availablePort();
     const owned = await spawnDetachedProcess({
@@ -60,19 +73,23 @@ export async function loadOpencode(execution, cwd, signal, loader) {
     });
     const { createOpencodeClient } = await import("@opencode-ai/sdk");
     const client = createOpencodeClient({ baseUrl: `http://127.0.0.1:${port}`, directory: cwd });
+    let closing;
+    const runtime = {
+        client,
+        close: async () => {
+            closing ??= owned.terminate();
+            await closing;
+        },
+    };
+    onRuntime?.(runtime);
     try {
         await waitReady(client, cwd, signal);
     }
     catch (error) {
-        await owned.terminate();
+        await runtime.close();
         throw error;
     }
-    return {
-        client,
-        close: async () => {
-            await owned.terminate();
-        },
-    };
+    return runtime;
 }
 export function coordinate(sessionId) {
     return { sessionId };

package/build/src/akuma/providers/pi/index.js

@@ -1,5 +1,5 @@
 import { abortable } from "../../abort.js";
-import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, createProviderAttempt, } from "../../provider.js";
 import { piTerminalFailure, translatePiEvent } from "./events.js";
 const PI_THINKING_LEVELS = new Set(["minimal", "low", "medium", "high", "xhigh", "max"]);
 const MODEL_PATTERN = /^[^/\s]+\/[^\s]+$/u;
@@ -75,7 +75,12 @@ async function createPiSession(sdk, execution, input, signal) {
         }
         return await sdk.createAgentSession(options);
     });
-    return await abortable(setup, signal, (created) => created.session.dispose());
+    const created = await setup;
+    if (signal.aborted) {
+        await created.session.dispose();
+        signal.throwIfAborted();
+    }
+    return created;
 }
 function forceDisposePi(dispose, settle, setAborting) {
     setAborting();
@@ -109,9 +114,27 @@ async function runPiPrompt(native, input, events, state, settle) {
             : { kind: "failed", diagnostic: diagnostic(error) });
     }
 }
-async function drivePi(sdk, execution, input, signal) {
+async function drivePi(sdk, execution, input, signal, custody) {
     const created = await createPiSession(sdk, execution, input, signal);
     const native = created.session;
+    let retired = false;
+    let settleRetired;
+    const closed = new Promise((resolve) => {
+        settleRetired = resolve;
+    });
+    custody?.own({
+        closed,
+        abort: async () => {
+            native.dispose();
+            retired = true;
+            settleRetired();
+        },
+        forceDispose: async () => {
+            native.dispose();
+            retired = true;
+            settleRetired();
+        },
+    });
     if (signal.aborted) {
         native.dispose();
         signal.throwIfAborted();
@@ -138,6 +161,10 @@ async function drivePi(sdk, execution, input, signal) {
         finally {
             try {
                 native.dispose();
+                if (!retired) {
+                    retired = true;
+                    settleRetired();
+                }
             }
             finally {
                 events.end();
@@ -216,21 +243,22 @@ export function createPiProvider(execution = { name: "pi", kind: "pi" }, load =
     if (execution.env !== undefined && Object.keys(execution.env).length > 0) {
         throw new TypeError("env injection not supported for provider pi");
     }
-    const drive = async (input) => {
-        const signal = input.signal ?? new AbortController().signal;
-        signal.throwIfAborted();
-        return drivePi(await abortable(load(), signal), execution, input, signal);
+    const drive = async (input, custody) => {
+        custody.signal.throwIfAborted();
+        const sdk = await abortable(load(), custody.signal);
+        custody.signal.throwIfAborted();
+        return await drivePi(sdk, execution, { ...input, signal: custody.signal }, custody.signal, custody);
     };
     return {
         admitOptions: admitPiOptions,
-        start: drive,
-        resume: async (input) => {
+        start: (input) => createProviderAttempt(input.signal, async (custody) => await drive(input, custody)),
+        resume: (input) => createProviderAttempt(input.signal, async (custody) => {
             piSessionFile(input.session.coordinate);
-            return drive(input);
-        },
-        fork: async (input) => {
+            return await drive(input, custody);
+        }),
+        fork: (input) => createProviderAttempt(new AbortController().signal, async () => {
             piSessionFile(input.session);
-            return forkPi(await load(), input);
-        },
+            return await forkPi(await load(), input);
+        }),
     };
 }

package/build/src/akuma/publication.js

@@ -127,6 +127,60 @@ async function takeLeashUntil(paths, deadline) {
         await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
     }
 }
+async function takeLeash(paths) {
+    for (;;) {
+        const leash = await HeldAkumaLeash.try(paths);
+        if (leash !== null)
+            return leash;
+        await abortableDelay(POLL_MS);
+    }
+}
+async function allocatedSoul(allocated) {
+    const soul = await readSoul(allocated.paths);
+    if (soul === null)
+        throw new Error("Akuma birth settled without a soul");
+    if (soul.id !== allocated.id)
+        throw new Error("Akuma birth returned a different identity");
+    return soul;
+}
+async function awaitConfirmation(result) {
+    try {
+        await result;
+    }
+    catch {
+        await new Promise(() => { });
+    }
+}
+async function settleCancelledLaunch(allocated, owned, cancellation) {
+    if ((await readSoul(allocated.paths)) !== null) {
+        await allocatedSoul(allocated);
+        return "born";
+    }
+    await awaitConfirmation(owned.terminate());
+    await awaitConfirmation(owned.exited);
+    if ((await readSoul(allocated.paths)) !== null) {
+        await allocatedSoul(allocated);
+        return "born";
+    }
+    const leash = await takeLeash(allocated.paths);
+    let outcome;
+    try {
+        outcome = await leash.sealIfUnborn(allocated.paths, {
+            evidence: diagnostic(cancellation),
+            at: new Date().toISOString(),
+        });
+    }
+    finally {
+        leash.release();
+    }
+    if (outcome === "born") {
+        await allocatedSoul(allocated);
+        return "born";
+    }
+    if ((await readSeal(allocated.paths)) === null)
+        throw new Error("Akuma birth settled without a seal");
+    return "sealed";
+}
 async function awaitAsleepBirth(paths) {
     const leash = await takeLeashUntil(paths, performance.now() + BIRTH_TIMEOUT_MS);
     if (leash === null)
@@ -174,25 +228,33 @@ export async function birthAkuma(input) {
 }
 export async function launchAkuma(input) {
     const { allocated } = input;
-    let owned;
+    let owned = undefined;
     try {
         input.signal?.throwIfAborted();
         owned = await input.launch(allocated);
-        try {
-            input.signal?.throwIfAborted();
-            const soul = await awaitBirth(allocated.paths, owned ?? undefined, input.signal);
-            if (soul.id !== allocated.id)
-                throw new Error("Akuma birth returned a different identity");
-            if (input.awaitAsleep === true)
-                await awaitAsleepBirth(allocated.paths);
-            return allocated;
-        }
-        finally {
-            owned?.release();
-        }
+        input.signal?.throwIfAborted();
+        const soul = await awaitBirth(allocated.paths, owned ?? undefined, input.signal);
+        if (soul.id !== allocated.id)
+            throw new Error("Akuma birth returned a different identity");
+        if (input.awaitAsleep === true)
+            await awaitAsleepBirth(allocated.paths);
+        owned?.release();
+        return allocated;
     }
     catch (error) {
+        if (owned !== undefined && input.signal?.aborted && error === input.signal.reason) {
+            const outcome = await settleCancelledLaunch(allocated, owned, error);
+            if (outcome === "born") {
+                if (input.awaitAsleep === true)
+                    await awaitAsleepBirth(allocated.paths);
+                owned.release();
+                return allocated;
+            }
+            owned.release();
+            throw error;
+        }
         await sealLocalFailure(allocated, error);
+        owned?.release();
         throw error;
     }
 }

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

@@ -1,25 +1,19 @@
 import { type Soul } from "./heart/index.js";
 import { type AkumaPaths } from "./identity.js";
-import { type StructuralRequestClaim } from "./request-wire.js";
-import type { OwnedProcess } from "../runtime/proc/run.js";
-export type RequestChildLaunch = Readonly<{
-    paths: AkumaPaths;
-    seed: Omit<Soul, "createdAt">;
-    initialBody: string;
-}>;
+import { type RequestEnvelope } from "./request-wire.js";
 export type PumpInput = Readonly<{
     paths: AkumaPaths;
     parent: Soul;
     bodySequence: number;
     now(): string;
-    spawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
+    spawn(launch: unknown): Promise<unknown>;
     upstream?: unknown;
     signal: AbortSignal;
 }>;
 type ServeClaim = (input: PumpInput & Readonly<{
     directory: string;
     transportId: string;
-    claim: StructuralRequestClaim;
+    claim: RequestEnvelope;
     signal: AbortSignal;
     admissionOpen(): boolean;
 }>) => Promise<void>;

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

@@ -2,9 +2,9 @@ import { access, mkdir, readFile, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { abortableDelay } from "./abort.js";
 import { HeldAkumaLeash, readNonterminalRequests, readSoul, serveRequest, voidRequest, } from "./heart/index.js";
-import { pathsForAkuId } from "./identity.js";
+import { pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { BIRTH_TIMEOUT_MS } from "./publication.js";
-import { atomicJson, decodeClaim, receiptPath } from "./request-wire.js";
+import { decodeEnvelope } from "./request-wire.js";
 const POLL_MS = 100;
 export class BodyRequestPump {
     input;
@@ -45,26 +45,21 @@ export class BodyRequestPump {
                 if (this.handled.has(transportId))
                     continue;
                 const path = join(this.directory, name);
-                const claim = decodeClaim(await readFile(path, "utf8"), transportId);
+                const claim = decodeEnvelope(await readFile(path, "utf8"), transportId);
                 if (claim === null) {
                     await rm(path, { force: true });
                     this.handled.add(transportId);
                     continue;
                 }
                 if (!this.admissionClosed) {
-                    try {
-                        await this.serveClaim({
-                            directory: this.directory,
-                            transportId,
-                            claim,
-                            ...this.input,
-                            signal: this.executionSignal.signal,
-                            admissionOpen: () => !this.admissionClosed,
-                        });
-                    }
-                    catch (error) {
-                        await projectTransportFailure(this.directory, transportId, claim, error);
-                    }
+                    await this.serveClaim({
+                        directory: this.directory,
+                        transportId,
+                        claim,
+                        ...this.input,
+                        signal: this.executionSignal.signal,
+                        admissionOpen: () => !this.admissionClosed,
+                    });
                 }
                 this.handled.add(transportId);
             }
@@ -107,14 +102,6 @@ async function requestFiles(directory) {
         throw error;
     }
 }
-async function projectTransportFailure(directory, transportId, claim, error) {
-    await atomicJson(receiptPath(directory, transportId), {
-        id: claim.id,
-        action: claim.action,
-        state: "refused",
-        diagnostic: error instanceof Error ? error.message : String(error),
-    });
-}
 function matchingRequestOrigin(soul, parent, id) {
     return soul.origin.kind === "request" && soul.origin.parent === parent && soul.origin.requestId === id;
 }
@@ -124,7 +111,7 @@ async function settleReservedSoul(paths, parent, request, soul) {
         : voidRequest(paths, request.id, "reserved child origin does not match the request"));
 }
 async function settleReserved(paths, parent, request, now, signal) {
-    const childPaths = pathsForAkuId(request.world, request.child);
+    const childPaths = pathsForAkuId(worldRootForAkumaPaths(paths), request.child);
     const deadline = performance.now() + BIRTH_TIMEOUT_MS;
     for (;;) {
         signal?.throwIfAborted();

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

@@ -0,0 +1,26 @@
+import { type RequestCommand } from "./request-wire.js";
+export declare class AkumaBodyRequestError extends Error {
+    readonly action: string;
+    readonly outcome: "refused" | "voided";
+    readonly diagnostic: string;
+    readonly kind = "akuma-body-request";
+    constructor(action: string, outcome: "refused" | "voided", diagnostic: string);
+}
+/** Generic rendezvous only: operation owners supply their own request and result codecs. */
+export declare function requestBodyCommand<Input, Output, Service, Reference = Service>(input: Readonly<{
+    directory: string;
+    id?: string;
+    command: RequestCommand<Input, Output, Service, Reference>;
+    value: Input;
+    signal?: AbortSignal;
+}>): Promise<Readonly<{
+    kind: "returned";
+    result: Output;
+    requestId: string;
+    action: string;
+}> | Readonly<{
+    kind: "reference";
+    reference: Reference;
+    requestId: string;
+    action: string;
+}>>;

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

@@ -0,0 +1,100 @@
+import { randomUUID } from "node:crypto";
+import { access, readFile } from "node:fs/promises";
+import { abortableDelay } from "./abort.js";
+import { atomicJson, decodeReceiptEnvelope, receiptPath, requestPath } from "./request-wire.js";
+const POLL_MS = 100;
+export class AkumaBodyRequestError extends Error {
+    action;
+    outcome;
+    diagnostic;
+    kind = "akuma-body-request";
+    constructor(action, outcome, diagnostic) {
+        super(`${action} ${outcome === "voided" ? "failed" : "refused"}: ${diagnostic}`);
+        this.action = action;
+        this.outcome = outcome;
+        this.diagnostic = diagnostic;
+        this.name = "AkumaBodyRequestError";
+    }
+}
+function throwVoidedRequestFailure(action, evidence, failure, decodeFailure) {
+    const ownerFailure = decodeVoidedOwnerFailure(failure, decodeFailure);
+    if (ownerFailure !== null)
+        throw ownerFailure;
+    throw new AkumaBodyRequestError(action, "voided", evidence);
+}
+function decodeVoidedOwnerFailure(failure, decodeFailure) {
+    if (failure === undefined || decodeFailure === undefined)
+        return null;
+    try {
+        return decodeFailure(failure);
+    }
+    catch {
+        return null;
+    }
+}
+function withRequestMetadata(response, id, action) {
+    Object.defineProperties(response, {
+        requestId: { value: id, enumerable: false },
+        action: { value: action, enumerable: false },
+    });
+    return response;
+}
+/** Generic rendezvous only: operation owners supply their own request and result codecs. */
+export async function requestBodyCommand(input) {
+    const id = input.id ?? randomUUID();
+    input.signal?.throwIfAborted();
+    const transportId = randomUUID();
+    await atomicJson(requestPath(input.directory, transportId), {
+        id,
+        action: input.command.action,
+        payload: input.command.encodeRequest(input.value),
+    });
+    const path = receiptPath(input.directory, transportId);
+    for (;;) {
+        try {
+            const receipt = decodeReceiptEnvelope(await readFile(path, "utf8"), id, input.command.action);
+            if (receipt === null)
+                throw new Error(`Akuma body request ${id} has an invalid receipt`);
+            if (receipt.state === "refused")
+                throw new AkumaBodyRequestError(receipt.action, "refused", receipt.diagnostic);
+            if (receipt.state === "voided") {
+                throwVoidedRequestFailure(receipt.action, receipt.evidence, receipt.failure, input.command.decodeFailure);
+            }
+            if ("reference" in receipt) {
+                let reference;
+                try {
+                    reference = input.command.decodeReference(receipt.reference);
+                }
+                catch (error) {
+                    const diagnostic = error instanceof Error ? error.message : String(error);
+                    throw new Error(`transport integrity: request ${id} action ${input.command.action} returned an invalid durable reference: ${diagnostic}`);
+                }
+                return withRequestMetadata({
+                    kind: "reference",
+                    reference,
+                }, id, input.command.action);
+            }
+            if (receipt.outcome.kind === "failed") {
+                const failure = receipt.outcome.failure;
+                throw new Error(failure.kind === "failed" ? failure.diagnostic : `Akuma ${failure.id} was not born`);
+            }
+            let result;
+            try {
+                result = input.command.decodeResult(receipt.outcome.result);
+            }
+            catch (error) {
+                const diagnostic = error instanceof Error ? error.message : String(error);
+                throw new Error(`transport integrity: request ${id} action ${input.command.action} returned an invalid live result: ${diagnostic}`);
+            }
+            return withRequestMetadata({ kind: "returned", result }, id, input.command.action);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (!(await access(input.directory).then(() => true, () => false))) {
+            throw new AkumaBodyRequestError(input.command.action, "voided", "parent request channel closed before a receipt");
+        }
+        await abortableDelay(POLL_MS, input.signal);
+    }
+}