@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/akuma/publication.js

@@ -2,6 +2,7 @@ import { HeldAkumaLeash, initializeHeart, readHeart, readSeal, readSoul } from "
 import { allocateAkumaDirectory } from "./identity.js";
 import { abortableDelay } from "./abort.js";
 const POLL_MS = 100;
+const CUSTODY_HANDOFF_MS = 1_000;
 export const BIRTH_TIMEOUT_MS = 30_000;
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
@@ -43,24 +44,6 @@ async function observedBirthFailure(paths) {
 function preAdmissionDiagnostic(exit) {
     return exit.code === null ? `pre-admission signal ${exit.signal ?? "unknown"}` : `pre-admission exit ${exit.code}`;
 }
-async function sealObservedExit(paths, exit) {
-    const evidence = preAdmissionDiagnostic(exit);
-    try {
-        const leash = await HeldAkumaLeash.try(paths);
-        if (leash !== null) {
-            try {
-                await leash.sealIfUnborn(paths, { evidence, at: new Date().toISOString() });
-            }
-            finally {
-                leash.release();
-            }
-        }
-    }
-    catch {
-        /* Parent evidence remains authoritative when best-effort sealing fails. */
-    }
-    throw new Error(evidence);
-}
 async function observeSettledExit(owned) {
     if (owned === undefined)
         return { kind: "pending" };
@@ -73,6 +56,21 @@ async function observeSettledExit(owned) {
         return { kind: "exit-error", error };
     }
 }
+async function observeExitWithin(owned, milliseconds) {
+    return await Promise.race([
+        owned.exited.then((exit) => ({ kind: "exited", exit }), (error) => ({ kind: "exit-error", error })),
+        abortableDelay(milliseconds).then(() => ({ kind: "timeout" })),
+    ]);
+}
+async function attemptTermination(owned, force = false) {
+    const outcome = await Promise.race([
+        Promise.resolve()
+            .then(() => owned.terminate(force))
+            .then(() => ({ kind: "terminated" }), (error) => ({ kind: "error", error })),
+        abortableDelay(CUSTODY_HANDOFF_MS).then(() => ({ kind: "timeout" })),
+    ]);
+    return outcome.kind === "error" ? outcome.error : undefined;
+}
 async function awaitBirth(paths, owned, signal) {
     const deadline = performance.now() + BIRTH_TIMEOUT_MS;
     for (;;) {
@@ -84,7 +82,7 @@ async function awaitBirth(paths, owned, signal) {
         if (failure !== null) {
             const settled = await observeSettledExit(owned);
             if (settled.kind === "exited")
-                await sealObservedExit(paths, settled.exit);
+                throw new Error(preAdmissionDiagnostic(settled.exit));
             if (settled.kind === "exit-error")
                 throw new Error(diagnostic(settled.error));
             throw new Error(failure);
@@ -94,7 +92,7 @@ async function awaitBirth(paths, owned, signal) {
             if (settled !== null)
                 return settled;
             if (owned !== undefined)
-                await owned.terminate(true);
+                await attemptTermination(owned, true);
             throw new Error("Akuma birth timed out before Soul admission");
         }
         if (owned === undefined) {
@@ -111,8 +109,7 @@ async function awaitBirth(paths, owned, signal) {
             const settledSoul = await readSoul(paths);
             if (settledSoul !== null)
                 return settledSoul;
-            await sealObservedExit(paths, outcome.exit);
-            continue;
+            throw new Error(preAdmissionDiagnostic(outcome.exit));
         }
         throw new Error(diagnostic(outcome.error));
     }
@@ -127,14 +124,6 @@ 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)
@@ -143,30 +132,54 @@ async function allocatedSoul(allocated) {
         throw new Error("Akuma birth returned a different identity");
     return soul;
 }
-async function awaitConfirmation(result) {
-    try {
-        await result;
-    }
-    catch {
-        await new Promise(() => { });
-    }
+function settlementEvidence(primary, terminationError, exitError) {
+    const reason = primary === undefined || primary === null ? "" : diagnostic(primary).trim();
+    if (reason.length > 0)
+        return reason;
+    const details = [terminationError, exitError]
+        .filter((error) => error !== undefined)
+        .map((error) => diagnostic(error).trim())
+        .filter((detail) => detail.length > 0);
+    return details[0] ?? "Akuma publication failed";
 }
-async function settleCancelledLaunch(allocated, owned, cancellation) {
+async function settleLaunch(allocated, owned, failure) {
     if ((await readSoul(allocated.paths)) !== null) {
         await allocatedSoul(allocated);
+        const settled = await observeExitWithin(owned, CUSTODY_HANDOFF_MS);
+        if (settled.kind === "timeout") {
+            const leash = await HeldAkumaLeash.try(allocated.paths);
+            if (leash === null)
+                return "handoff";
+            leash.release();
+        }
+        if (settled.kind === "exit-error")
+            throw failure;
         return "born";
     }
-    await awaitConfirmation(owned.terminate());
-    await awaitConfirmation(owned.exited);
+    let terminationError;
+    let exitError;
+    let outcome;
+    const preAdmissionExit = diagnostic(failure).startsWith("pre-admission ");
+    const settled = preAdmissionExit ? await observeSettledExit(owned) : { kind: "pending" };
+    if (settled.kind !== "exited") {
+        terminationError = await attemptTermination(owned);
+        const exit = await observeSettledExit(owned);
+        if (exit.kind === "exit-error")
+            exitError = exit.error;
+    }
+    else {
+        /* An already-settled pre-admission exit needs no second termination request. */
+    }
     if ((await readSoul(allocated.paths)) !== null) {
         await allocatedSoul(allocated);
         return "born";
     }
-    const leash = await takeLeash(allocated.paths);
-    let outcome;
+    const leash = await HeldAkumaLeash.try(allocated.paths);
+    if (leash === null)
+        return "handoff";
     try {
         outcome = await leash.sealIfUnborn(allocated.paths, {
-            evidence: diagnostic(cancellation),
+            evidence: settlementEvidence(failure, terminationError, exitError),
             at: new Date().toISOString(),
         });
     }
@@ -242,19 +255,22 @@ export async function launchAkuma(input) {
         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 (owned !== undefined) {
+            let outcome;
+            try {
+                outcome = await settleLaunch(allocated, owned, error);
+            }
+            finally {
+                owned.release();
+            }
+            if (outcome === "born" && input.signal?.aborted && error === input.signal.reason) {
                 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,13 +1,11 @@
-import { type Soul } from "./heart/index.js";
+import { type RequestFact, type Soul } from "./heart/index.js";
 import { type AkumaPaths } from "./identity.js";
 import { type RequestEnvelope } from "./request-wire.js";
 export type PumpInput = Readonly<{
     paths: AkumaPaths;
-    parent: Soul;
+    allowed: readonly string[];
     bodySequence: number;
     now(): string;
-    spawn(launch: unknown): Promise<unknown>;
-    upstream?: unknown;
     signal: AbortSignal;
 }>;
 type ServeClaim = (input: PumpInput & Readonly<{
@@ -35,5 +33,8 @@ export declare class BodyRequestPump {
     stopAdmission(): void;
 }
 export declare function clearBodyRequestTransport(paths: AkumaPaths): Promise<void>;
+export declare function settleReserved(paths: AkumaPaths, parent: Soul, request: Extract<RequestFact, {
+    state: "reserved";
+}>, now: () => string, signal?: AbortSignal): Promise<boolean>;
 export declare function settleBodyRequests(paths: AkumaPaths, parent: Soul, now: () => string, signal?: AbortSignal): Promise<"settled" | "pending">;
 export {};

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

@@ -1,7 +1,7 @@
 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 { HeldAkumaLeash, readNonterminalRequests, readSoul, serveRequest, unproveRequest, voidRequest, } from "./heart/index.js";
 import { pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { BIRTH_TIMEOUT_MS } from "./publication.js";
 import { decodeEnvelope } from "./request-wire.js";
@@ -77,6 +77,8 @@ export class BodyRequestPump {
     }
     async close() {
         this.stopAdmission();
+        if (!this.executionSignal.signal.aborted)
+            this.executionSignal.abort(new Error("Body request pump closed"));
         try {
             await this.running;
         }
@@ -112,14 +114,34 @@ async function settleReservedSoul(paths, parent, request, soul) {
         ? serveRequest(paths, request.id, request.child)
         : voidRequest(paths, request.id, "reserved child origin does not match the request"));
 }
-async function settleReserved(paths, parent, request, now, signal) {
+async function settleReservedWithLeash(paths, parent, request, leash, now) {
+    const childPaths = pathsForAkuId(worldRootForAkumaPaths(paths), request.child);
+    try {
+        const settled = await readSoul(childPaths);
+        if (settled !== null) {
+            await settleReservedSoul(paths, parent, request, settled);
+            return;
+        }
+        const outcome = await leash.sealIfUnborn(childPaths, { evidence: "request settlement", at: now() });
+        if (outcome === "sealed") {
+            await voidRequest(paths, request.id, "reserved child was sealed unborn");
+            return;
+        }
+        const born = await readSoul(childPaths);
+        if (born !== null)
+            await settleReservedSoul(paths, parent, request, born);
+    }
+    finally {
+        leash.release();
+    }
+}
+export async function settleReserved(paths, parent, request, now, signal) {
     const childPaths = pathsForAkuId(worldRootForAkumaPaths(paths), request.child);
     const deadline = performance.now() + BIRTH_TIMEOUT_MS;
     for (;;) {
         signal?.throwIfAborted();
         if (!(await access(childPaths.directory).then(() => true, () => false))) {
-            await voidRequest(paths, request.id, "reserved child directory is absent");
-            return true;
+            return false;
         }
         const soul = await readSoul(childPaths);
         if (soul !== null) {
@@ -128,18 +150,7 @@ async function settleReserved(paths, parent, request, now, signal) {
         }
         const leash = await HeldAkumaLeash.try(childPaths);
         if (leash !== null) {
-            try {
-                const settled = await readSoul(childPaths);
-                if (settled !== null)
-                    await settleReservedSoul(paths, parent, request, settled);
-                else {
-                    await leash.sealIfUnborn(childPaths, { evidence: "request settlement", at: now() });
-                    await voidRequest(paths, request.id, "reserved child was sealed unborn");
-                }
-            }
-            finally {
-                leash.release();
-            }
+            await settleReservedWithLeash(paths, parent, request, leash, now);
             return true;
         }
         if (performance.now() >= deadline)
@@ -155,6 +166,8 @@ export async function settleBodyRequests(paths, parent, now, signal) {
             await voidRequest(paths, request.id, "body died before serving the request");
         else if (request.state === "reserved" && !(await settleReserved(paths, parent, request, now, signal)))
             pending = true;
+        else if (request.state === "begun")
+            await unproveRequest(paths, request.id, "body died after service request began");
     }
     return pending ? "pending" : "settled";
 }

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

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

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

@@ -7,20 +7,25 @@ export class AkumaBodyRequestError extends Error {
     action;
     outcome;
     diagnostic;
+    requestId;
     kind = "akuma-body-request";
-    constructor(action, outcome, diagnostic) {
-        super(`${action} ${outcome === "voided" ? "failed" : "refused"}: ${diagnostic}`);
+    constructor(action, outcome, diagnostic, requestId) {
+        super(`${action} ${outcome === "refused" ? "refused" : outcome}: ${diagnostic}`);
         this.action = action;
         this.outcome = outcome;
         this.diagnostic = diagnostic;
+        this.requestId = requestId;
         this.name = "AkumaBodyRequestError";
     }
 }
-function throwVoidedRequestFailure(action, evidence, failure, decodeFailure) {
+function throwVoidedRequestFailure(action, evidence, failure, decodeFailure, requestId) {
     const ownerFailure = decodeVoidedOwnerFailure(failure, decodeFailure);
     if (ownerFailure !== null)
-        throw ownerFailure;
-    throw new AkumaBodyRequestError(action, "voided", evidence);
+        throw withRequestMetadata(ownerFailure, requestId, action);
+    throw new AkumaBodyRequestError(action, "voided", evidence, requestId);
+}
+function throwUnprovenRequestFailure(action, evidence, requestId) {
+    throw new AkumaBodyRequestError(action, "unproven", evidence, requestId);
 }
 function decodeVoidedOwnerFailure(failure, decodeFailure) {
     if (failure === undefined || decodeFailure === undefined)
@@ -39,62 +44,86 @@ function withRequestMetadata(response, id, action) {
     });
     return response;
 }
+async function readRequestReceipt(input, path, id) {
+    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, receipt.id);
+        }
+        if (receipt.state === "voided") {
+            throwVoidedRequestFailure(receipt.action, receipt.evidence, receipt.failure, input.command.decodeFailure, receipt.id);
+        }
+        if (receipt.state === "unproven")
+            throwUnprovenRequestFailure(receipt.action, receipt.evidence, receipt.id);
+        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")
+            return undefined;
+        throw error;
+    }
+}
 /** 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 payload = input.command.encodeRequest(input.value);
+    try {
+        await atomicJson(requestPath(input.directory, transportId), {
+            id,
+            action: input.command.action,
+            payload,
+        }, input.signal);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        if (input.signal?.aborted)
+            input.signal.throwIfAborted();
+        throw new AkumaBodyRequestError(input.command.action, "unknown", "parent request channel closed before request publication", id);
+    }
     const path = receiptPath(input.directory, transportId);
     for (;;) {
+        const response = await readRequestReceipt(input, path, id);
+        if (response !== undefined)
+            return response;
+        if (!(await access(input.directory).then(() => true, () => false))) {
+            throw new AkumaBodyRequestError(input.command.action, "unknown", "parent request channel closed before a receipt", id);
+        }
         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);
+            await abortableDelay(POLL_MS, input.signal);
         }
         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");
+            if (input.signal?.aborted) {
+                throw new AkumaBodyRequestError(input.command.action, "unknown", "request was cancelled after publication and before a receipt", id);
+            }
+            throw error;
         }
-        await abortableDelay(POLL_MS, input.signal);
     }
 }

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

@@ -1,8 +1,7 @@
 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";
-type PumpInput = Omit<LifecyclePumpInput, "upstream"> & Readonly<{
-    upstream?: unknown;
+type PumpInput = LifecyclePumpInput & Readonly<{
     commands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
 export type ServeInput = Omit<PumpInput, "bodySequence"> & Readonly<{