@astrosheep/keiyaku 4.4.0 → 4.5.1

package/build/src/akuma/heart/rows.d.ts

@@ -116,4 +116,4 @@ export declare function sessionFactForCoordinate(database: DatabaseSync, coordin
 export declare function latestKillFact(database: DatabaseSync): KillFact | null;
 export declare function killFactForBody(database: DatabaseSync, bodySequence: number): KillFact | null;
 export declare function lastAnsweredTurnFact(database: DatabaseSync): TurnFact | null;
-export declare function answeredTurnFact(database: DatabaseSync, historyId: string): TurnFact | null;
+export declare function answeredTurnFact(database: DatabaseSync, turnSequence: number): TurnFact | null;

package/build/src/akuma/heart/rows.js

@@ -263,10 +263,10 @@ export function lastAnsweredTurnFact(database) {
         .get();
     return row === undefined ? null : decodeTurnRow(row);
 }
-export function answeredTurnFact(database, historyId) {
+export function answeredTurnFact(database, turnSequence) {
     const row = database
         .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,
-    session_json, answer, diagnostic, completed_at FROM turns WHERE outcome = 'answered' AND history_id = ?`)
-        .get(historyId);
+    session_json, answer, diagnostic, completed_at FROM turns WHERE outcome = 'answered' AND sequence = ?`)
+        .get(turnSequence);
     return row === undefined ? null : decodeTurnRow(row);
 }

package/build/src/akuma/heart/storage.d.ts

@@ -10,6 +10,7 @@ export declare class HeartAbsentError extends Error {
 export declare function isHeartAbsent(error: unknown): error is HeartAbsentError;
 export declare function classifyHeartSchema(paths: AkumaPaths): Promise<"current" | "unsupported">;
 export declare function withHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T): Promise<T>;
+export declare function withReadOnlyHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T): Promise<T>;
 export declare function transaction<T>(database: DatabaseSync, body: () => T): T;
 export declare function readTransaction<T>(database: DatabaseSync, body: () => T): T;
 export declare function initializeHeart(paths: AkumaPaths): Promise<void>;

package/build/src/akuma/heart/storage.js

@@ -12,7 +12,7 @@ const ACTIVITY_LIMIT = 5_000;
 const SQLITE_CANTOPEN = 14;
 export async function watchHeart(paths, signal) {
     const heart = basename(paths.heart);
-    const changes = [];
+    let changed = false;
     let failure;
     let wake;
     // fs.watch opens the directory synchronously. Its throw is therefore the
@@ -20,7 +20,7 @@ export async function watchHeart(paths, signal) {
     const watcher = watchDirectory(dirname(paths.heart), { signal }, (_event, filename) => {
         const name = filename?.toString();
         if (name === undefined || name === heart || name === `${heart}-wal`) {
-            changes.push(undefined);
+            changed = true;
             wake?.();
         }
     });
@@ -36,8 +36,8 @@ export async function watchHeart(paths, signal) {
     return (async function* () {
         try {
             for (;;) {
-                if (changes.length > 0) {
-                    changes.shift();
+                if (changed) {
+                    changed = false;
                     yield;
                     continue;
                 }
@@ -82,9 +82,9 @@ function isBusy(error) {
         message.includes("database is locked") ||
         message.includes("database is busy"));
 }
-async function openExistingDatabase(path, timeout) {
+async function openExistingDatabase(path, timeout, mode = "rw") {
     const uri = pathToFileURL(path);
-    uri.searchParams.set("mode", "rw");
+    uri.searchParams.set("mode", mode);
     try {
         return timeout === undefined ? new DatabaseSync(uri.href) : new DatabaseSync(uri.href, { timeout });
     }
@@ -115,6 +115,19 @@ async function openHeart(path, verify = true) {
         throw error;
     }
 }
+async function openHeartReadOnly(path, verify = true) {
+    const database = await openExistingDatabase(path, undefined, "ro");
+    try {
+        database.exec("PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000");
+        if (verify)
+            assertHeartSchemaVersion(database);
+        return database;
+    }
+    catch (error) {
+        database.close();
+        throw error;
+    }
+}
 export async function classifyHeartSchema(paths) {
     let database;
     try {
@@ -141,6 +154,15 @@ export async function withHeart(paths, body) {
         database.close();
     }
 }
+export async function withReadOnlyHeart(paths, body) {
+    const database = await openHeartReadOnly(paths.heart);
+    try {
+        return body(database);
+    }
+    finally {
+        database.close();
+    }
+}
 export function transaction(database, body) {
     database.exec("BEGIN IMMEDIATE");
     try {

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

@@ -2,6 +2,7 @@ declare const AKU_ID: unique symbol;
 export type AkuId = string & {
     readonly [AKU_ID]: true;
 };
+export declare function parsePublicHistoryId(value: string): number | null;
 export type AkumaPaths = Readonly<{
     directory: string;
     heart: string;

package/build/src/akuma/identity.js

@@ -4,6 +4,13 @@ import { dirname, join } from "node:path";
 import { identityCoordinate, identitySegments } from "../identity/coordinates.js";
 import { normalizeIdentityStem } from "../identity/normalize.js";
 const HEX8 = /^[0-9a-f]{8}$/u;
+export function parsePublicHistoryId(value) {
+    const match = /^turn\/([1-9][0-9]*)$/u.exec(value);
+    if (match === null)
+        return null;
+    const sequence = Number(match[1]);
+    return Number.isSafeInteger(sequence) ? sequence : null;
+}
 export function archetypeName(value) {
     if (value.length === 0 || normalizeIdentityStem({ source: value }) !== value) {
         throw new TypeError("Akuma name must be one normalized human identity segment");

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

@@ -2,7 +2,6 @@ import { type AkuId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
 export { Akuma, AkumaHandle, AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
 export type { AkumaCallInput } from "./akuma.js";
-export type { ResultRoute } from "./result-route.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";
 export type { AllowedAction, AllowedActions } from "./allowed.js";
 export type { WorldRoot } from "../world.js";
@@ -10,7 +9,7 @@ export declare function probeBornAkuma(worldPath: WorldRoot, id: AkuId): Promise
 export { AkumaArchetypeError, listArchetypeDefinitions, listArchetypes } from "./archetype.js";
 export type { ArchetypeCatalogRow } from "./archetype.js";
 export { AkumaBodyRequestError } from "./requests.js";
-export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry, ForkReceipt, InterruptReceipt, TellResult, TellWake, UnbornAkumaListRow, } from "./akuma.js";
+export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHistory, ExactHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry, ForkReceipt, InterruptReceipt, TellResult, TellWake, UnbornAkumaListRow, } from "./akuma.js";
 export type { ActiveToolRow, ClosedTurn, ClosedTurnRow, CompletedToolRow, HistoryCursor, HistoryPage, IdleSnapshotRow, OpenSnapshotRow, OpenTurn, OpenTurnRow, OutcomeRow, ReportedFileChange, RetainedWindow, Snapshot, SnapshotRow, TellRow, TurnLedger, TurnOutcome, TurnStartRow, UnsettledToolRow, } from "./akuma.js";
 export type { AgentEvent, ToolCall, ToolEvent, ToolResult } from "./provider.js";
 export type { AkuId } from "./identity.js";

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

@@ -1,6 +1,14 @@
 import { type ToolCall, type ToolResult } from "./provider.js";
-import type { TellDelivery, TellFact, TimelineFact, TurnEndFact } from "./heart/index.js";
-export type TurnOutcome = TurnEndFact["outcome"];
+import type { TellDelivery, TellFact, TimelineFact } from "./heart/index.js";
+export type TurnOutcome = Readonly<{
+    kind: "answered";
+    historyId: string;
+    answer: string;
+}> | Readonly<{
+    kind: "failed";
+    historyId: string;
+    diagnostic: string;
+}>;
 export type TurnStartRow = Readonly<{
     kind: "turn";
     sequence: number;
@@ -153,7 +161,15 @@ export type ActivityHistory = Readonly<{
     lowestRetained: number | null;
     highest: number | null;
 }>;
+export type ExactHistory = Readonly<{
+    kind: "exact";
+    outcome: OutcomeRow;
+}> | Readonly<{
+    kind: "unknown-history";
+    id: string;
+}>;
 export type HistoryPage = ActivityHistory;
+export declare function selectExactHistory(rows: readonly ActivityRow[], id: string): ExactHistory;
 export type HistoryCursor = Readonly<{
     before?: number;
     since?: number;

package/build/src/akuma/projection.js

@@ -1,4 +1,14 @@
 import { decodeAgentEvent } from "./provider.js";
+function publicOutcome(turnSequence, outcome) {
+    const historyId = `turn/${turnSequence}`;
+    return outcome.kind === "answered"
+        ? { kind: "answered", historyId, answer: outcome.answer }
+        : { kind: "failed", historyId, diagnostic: outcome.diagnostic };
+}
+export function selectExactHistory(rows, id) {
+    const outcome = rows.find((row) => row.kind === "outcome" && row.outcome.historyId === id);
+    return outcome === undefined ? { kind: "unknown-history", id } : { kind: "exact", outcome };
+}
 function duration(startedAt, completedAt) {
     const start = Date.parse(startedAt);
     const end = Date.parse(completedAt);
@@ -171,7 +181,7 @@ export function projectTurns(facts, retained = {
                 sequence: fact.sequence,
                 turnSequence: fact.turnSequence,
                 at: fact.completedAt,
-                outcome: fact.outcome,
+                outcome: publicOutcome(fact.turnSequence, fact.outcome),
             };
             const turn = state.turnsBySequence.get(fact.turnSequence);
             if (turn === undefined)

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

@@ -118,53 +118,64 @@ function finishClaudeInput(input, terminal) {
     else
         input.close();
 }
+function consumeClaudeMessage(context, state, message) {
+    const { input, events, observation, progress, admit, rejectAdmission, settle, controls } = context;
+    if (state.terminal !== null)
+        return;
+    if (!state.admitted && "session_id" in message && typeof message.session_id === "string" && admit()) {
+        state.admitted = true;
+        events.emit({ type: "session", coordinate: { sessionId: message.session_id } });
+    }
+    emitClaudeMessage(message, events, observation);
+    if (message.type === "assistant" &&
+        message.parent_tool_use_id === null &&
+        typeof message.uuid === "string" &&
+        message.uuid.length > 0)
+        state.historyId = message.uuid;
+    if (message.type !== "result")
+        return;
+    if (message.subtype === "success") {
+        state.terminal = successfulResult(message, state.historyId);
+        progress.checkpoint += 1;
+        controls.flushReceipts();
+        queueMicrotask(controls.closeWhenIdle);
+    }
+    else {
+        state.terminal = { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
+        input.close();
+    }
+    progress.ended = true;
+    if (!state.admitted)
+        rejectAdmission(new Error(state.terminal.kind === "failed" ? state.terminal.diagnostic : "Claude query ended before session admission"));
+    finishClaudeInput(input, state.terminal);
+    events.end();
+    settle(state.terminal);
+    controls.settleReceipts();
+}
 async function consumeClaudeQuery(context) {
-    const { query, input, events, observation, progress, admit, rejectAdmission, settle, controls } = context;
-    let admitted = false;
-    let terminal = null;
-    let historyId;
+    const { query, input, events, progress, rejectAdmission, settle, controls } = context;
+    const state = { admitted: false, terminal: null };
     try {
-        for await (const message of query) {
-            if (!admitted && "session_id" in message && typeof message.session_id === "string") {
-                admitted = true;
-                events.emit({ type: "session", coordinate: { sessionId: message.session_id } });
-                admit();
-            }
-            emitClaudeMessage(message, events, observation);
-            if (message.type === "assistant" &&
-                message.parent_tool_use_id === null &&
-                typeof message.uuid === "string" &&
-                message.uuid.length > 0)
-                historyId = message.uuid;
-            if (message.type !== "result")
-                continue;
-            if (message.subtype === "success") {
-                terminal = successfulResult(message, historyId);
-                progress.checkpoint += 1;
-                controls.flushReceipts();
-                queueMicrotask(controls.closeWhenIdle);
-            }
-            else {
-                terminal = { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
-                input.close();
-            }
-        }
+        for await (const message of query)
+            consumeClaudeMessage(context, state, message);
         progress.ended = true;
-        const result = terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" };
-        if (!admitted)
+        const result = state.terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" };
+        if (!state.admitted)
             rejectAdmission(new Error(result.kind === "failed" ? result.diagnostic : "Claude query ended before session admission"));
         settle(result);
     }
     catch (error) {
         progress.ended = true;
+        if (state.terminal !== null)
+            return;
         input.fail(error);
         const failure = error instanceof Error ? error : new Error(String(error));
-        if (!admitted)
+        if (!state.admitted)
             rejectAdmission(failure);
         settle({ kind: "failed", diagnostic: failure.message });
     }
     finally {
-        finishClaudeInput(input, terminal);
+        finishClaudeInput(input, state.terminal);
         events.end();
         controls.settleReceipts();
     }
@@ -206,9 +217,21 @@ function observeClaudeQuery(context) {
     const observation = { tools: new Map() };
     let admit;
     let rejectAdmission;
+    let admissionOpen = true;
     const admission = new Promise((resolve, reject) => {
-        admit = resolve;
-        rejectAdmission = reject;
+        admit = () => {
+            if (!admissionOpen)
+                return false;
+            admissionOpen = false;
+            resolve();
+            return true;
+        };
+        rejectAdmission = (error) => {
+            if (!admissionOpen)
+                return;
+            admissionOpen = false;
+            reject(error);
+        };
     });
     let settle;
     const completion = new Promise((resolve) => {
@@ -247,6 +270,7 @@ function observeClaudeQuery(context) {
     });
     return {
         admission,
+        rejectAdmission,
         completion,
         get ended() {
             return progress.ended;
@@ -282,9 +306,13 @@ async function driveClaude(load, execution, drive) {
         input.fail(error);
         query.close();
     };
-    const abortSetup = () => shutDown(signal.reason);
+    let observed;
+    const abortSetup = () => {
+        shutDown(signal.reason);
+        observed?.rejectAdmission(signal.reason);
+    };
     signal.addEventListener("abort", abortSetup, { once: true });
-    const observed = observeClaudeQuery({
+    observed = observeClaudeQuery({
         query,
         input,
         events,
@@ -296,8 +324,11 @@ async function driveClaude(load, execution, drive) {
             },
         },
     });
+    if (signal.aborted)
+        abortSetup();
     try {
         await Promise.all([launchAcknowledged, observed.admission]);
+        signal.throwIfAborted();
     }
     finally {
         signal.removeEventListener("abort", abortSetup);

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

@@ -1,11 +1,17 @@
 import { type AllocatedAkuma } from "./identity.js";
 import type { OwnedProcess } from "../runtime/proc/run.js";
 export declare const BIRTH_TIMEOUT_MS = 30000;
-export declare function publishAkuma(input: Readonly<{
+export type BirthInput = Readonly<{
     worldPath: string;
     archetype: string;
+    signal?: AbortSignal;
+}>;
+export type LaunchInput = Readonly<{
+    allocated: AllocatedAkuma;
     awaitAsleep?: boolean;
-    reserve?(allocated: AllocatedAkuma): Promise<void>;
     launch(allocated: AllocatedAkuma): Promise<OwnedProcess | void>;
     signal?: AbortSignal;
-}>): Promise<AllocatedAkuma>;
+}>;
+export declare function birthAkuma(input: BirthInput): Promise<AllocatedAkuma>;
+export declare function launchAkuma(input: LaunchInput): Promise<AllocatedAkuma>;
+export declare function publishAkuma(input: BirthInput & Omit<LaunchInput, "allocated">): Promise<AllocatedAkuma>;

package/build/src/akuma/publication.js

@@ -93,6 +93,9 @@ async function awaitBirth(paths, owned, signal) {
             const settled = await settleTimedOutBirth(paths);
             if (settled !== null)
                 return settled;
+            if (owned !== undefined)
+                await owned.terminate(true);
+            throw new Error("Akuma birth timed out before Soul admission");
         }
         if (owned === undefined) {
             await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);
@@ -156,15 +159,25 @@ async function sealLocalFailure(allocated, error) {
         /* the original local publication failure remains authoritative */
     }
 }
-export async function publishAkuma(input) {
+export async function birthAkuma(input) {
     input.signal?.throwIfAborted();
     const allocated = await allocateAkumaDirectory({ worldRoot: input.worldPath, archetype: input.archetype });
     try {
         await initializeHeart(allocated.paths);
         input.signal?.throwIfAborted();
-        await input.reserve?.(allocated);
+        return allocated;
+    }
+    catch (error) {
+        await sealLocalFailure(allocated, error);
+        throw error;
+    }
+}
+export async function launchAkuma(input) {
+    const { allocated } = input;
+    let owned;
+    try {
         input.signal?.throwIfAborted();
-        const owned = await input.launch(allocated);
+        owned = await input.launch(allocated);
         try {
             input.signal?.throwIfAborted();
             const soul = await awaitBirth(allocated.paths, owned ?? undefined, input.signal);
@@ -183,3 +196,7 @@ export async function publishAkuma(input) {
         throw error;
     }
 }
+export async function publishAkuma(input) {
+    const allocated = await birthAkuma(input);
+    return await launchAkuma({ ...input, allocated });
+}

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

@@ -0,0 +1,45 @@
+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;
+}>;
+export type PumpInput = Readonly<{
+    paths: AkumaPaths;
+    parent: Soul;
+    bodySequence: number;
+    now(): string;
+    spawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
+    upstream?: unknown;
+    signal: AbortSignal;
+}>;
+type ServeClaim = (input: PumpInput & Readonly<{
+    directory: string;
+    transportId: string;
+    claim: StructuralRequestClaim;
+    signal: AbortSignal;
+    admissionOpen(): boolean;
+}>) => Promise<void>;
+export declare class BodyRequestPump {
+    private readonly input;
+    private readonly serveClaim;
+    readonly directory: string;
+    readonly failure: Promise<never>;
+    private readonly closeSignal;
+    private readonly executionSignal;
+    private readonly handled;
+    private readonly running;
+    private readonly cancelBody;
+    private admissionClosed;
+    protected constructor(input: PumpInput, serveClaim: ServeClaim);
+    static openWithService(input: PumpInput, serveClaim: ServeClaim): Promise<BodyRequestPump>;
+    private run;
+    close(): Promise<void>;
+    stopAdmission(): void;
+}
+export declare function clearBodyRequestTransport(paths: AkumaPaths): Promise<void>;
+export declare function settleBodyRequests(paths: AkumaPaths, parent: Soul, now: () => string, signal?: AbortSignal): Promise<"settled" | "pending">;
+export {};

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

@@ -0,0 +1,171 @@
+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 { BIRTH_TIMEOUT_MS } from "./publication.js";
+import { atomicJson, decodeClaim, receiptPath } from "./request-wire.js";
+const POLL_MS = 100;
+export class BodyRequestPump {
+    input;
+    serveClaim;
+    directory;
+    failure;
+    closeSignal = new AbortController();
+    executionSignal = new AbortController();
+    handled = new Set();
+    running;
+    cancelBody;
+    admissionClosed = false;
+    constructor(input, serveClaim) {
+        this.input = input;
+        this.serveClaim = serveClaim;
+        this.directory = join(input.paths.directory, "requests", String(input.bodySequence));
+        this.cancelBody = () => {
+            this.stopAdmission();
+            if (!this.executionSignal.signal.aborted)
+                this.executionSignal.abort(input.signal.reason);
+        };
+        input.signal.addEventListener("abort", this.cancelBody, { once: true });
+        if (input.signal.aborted)
+            this.cancelBody();
+        this.running = this.run();
+        this.failure = this.running.then(() => new Promise(() => { }), (error) => Promise.reject(error));
+    }
+    static async openWithService(input, serveClaim) {
+        await mkdir(join(input.paths.directory, "requests", String(input.bodySequence)), { recursive: true });
+        return new BodyRequestPump(input, serveClaim);
+    }
+    async run() {
+        while (!this.closeSignal.signal.aborted) {
+            for (const name of await requestFiles(this.directory)) {
+                if (this.closeSignal.signal.aborted)
+                    return;
+                const transportId = name.slice(0, -".request.json".length);
+                if (this.handled.has(transportId))
+                    continue;
+                const path = join(this.directory, name);
+                const claim = decodeClaim(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);
+                    }
+                }
+                this.handled.add(transportId);
+            }
+            try {
+                await abortableDelay(POLL_MS, this.closeSignal.signal);
+            }
+            catch (error) {
+                if (this.closeSignal.signal.aborted)
+                    return;
+                throw error;
+            }
+        }
+    }
+    async close() {
+        this.stopAdmission();
+        try {
+            await this.running;
+        }
+        finally {
+            this.input.signal.removeEventListener("abort", this.cancelBody);
+            await rm(this.directory, { recursive: true, force: true });
+        }
+    }
+    stopAdmission() {
+        this.admissionClosed = true;
+        if (!this.closeSignal.signal.aborted)
+            this.closeSignal.abort(new Error("Body request pump closed"));
+    }
+}
+export async function clearBodyRequestTransport(paths) {
+    await rm(join(paths.directory, "requests"), { recursive: true, force: true });
+}
+async function requestFiles(directory) {
+    try {
+        return (await readdir(directory)).filter((name) => name.endsWith(".request.json")).sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        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;
+}
+async function settleReservedSoul(paths, parent, request, soul) {
+    await (matchingRequestOrigin(soul, parent.id, request.id)
+        ? 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) {
+    const childPaths = pathsForAkuId(request.world, 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;
+        }
+        const soul = await readSoul(childPaths);
+        if (soul !== null) {
+            await settleReservedSoul(paths, parent, request, soul);
+            return true;
+        }
+        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();
+            }
+            return true;
+        }
+        if (performance.now() >= deadline)
+            return false;
+        await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);
+    }
+}
+export async function settleBodyRequests(paths, parent, now, signal) {
+    let pending = false;
+    for (const request of await readNonterminalRequests(paths)) {
+        signal?.throwIfAborted();
+        if (request.state === "admitted")
+            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;
+    }
+    return pending ? "pending" : "settled";
+}