@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/akuma/body-supervisor.js

@@ -0,0 +1,89 @@
+import { abortableDelay } from "./abort.js";
+import { heartExists, readHeart } from "./heart/index.js";
+const BODY_CONTROL_OBSERVATION_MS = 100;
+export const CONTROL_RESPONSE_MS = 1_000;
+export class BodySupervisor {
+    paths;
+    bodySequence;
+    leash;
+    signal;
+    controller = new AbortController();
+    finished = new AbortController();
+    observer;
+    waiter;
+    observation;
+    stopping;
+    constructor(paths, bodySequence, leash, observation) {
+        this.paths = paths;
+        this.bodySequence = bodySequence;
+        this.leash = leash;
+        this.signal = this.controller.signal;
+        this.observation = observation;
+        this.observer = this.observe();
+    }
+    static async open(paths, bodySequence, leash) {
+        return new BodySupervisor(paths, bodySequence, leash, await readHeart(paths));
+    }
+    get reason() {
+        return this.stopping;
+    }
+    current() {
+        return this.observation;
+    }
+    async recordHung(diagnostic, at) {
+        await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
+    }
+    async refresh() {
+        this.publish(await readHeart(this.paths));
+        return this.observation;
+    }
+    next(after) {
+        if (this.observation !== after)
+            return Promise.resolve(this.observation);
+        return new Promise((resolve) => {
+            this.waiter = resolve;
+        });
+    }
+    cancel(reason) {
+        if (this.stopping !== undefined)
+            return;
+        this.stopping = reason;
+        this.controller.abort(new Error(reason === "control" ? "Akuma Body interrupted by durable control" : "Akuma Heart disappeared"));
+        this.waiter?.(this.observation);
+        this.waiter = undefined;
+    }
+    async close() {
+        this.finished.abort();
+        await this.observer;
+        this.waiter = undefined;
+    }
+    publish(snapshot) {
+        this.observation = snapshot;
+        this.waiter?.(snapshot);
+        this.waiter = undefined;
+    }
+    async observe() {
+        for (;;) {
+            const snapshot = this.observation;
+            if (!(await heartExists(this.paths)))
+                return this.cancel("heart-gone");
+            if (snapshot.stop?.bodySequence === this.bodySequence || snapshot.pause?.bodySequence === this.bodySequence) {
+                return this.cancel("control");
+            }
+            try {
+                await abortableDelay(BODY_CONTROL_OBSERVATION_MS, this.finished.signal);
+            }
+            catch {
+                return;
+            }
+            try {
+                await this.refresh();
+            }
+            catch (error) {
+                if (await heartExists(this.paths))
+                    throw error;
+                return this.cancel("heart-gone");
+            }
+        }
+    }
+}

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

@@ -2,18 +2,59 @@ import { type SessionFact, type Soul } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import type { ProviderAdapter } from "./provider.js";
 import { type UpstreamExecutionPort, type RequestChildLaunch } from "./request-serve.js";
-export { CONTROL_RESPONSE_MS } from "./body-turn.js";
+import { type OwnedProcess, type RunLogReference } from "../runtime/proc/run.js";
+export declare const LEASH_HELD_EXIT = 75;
+export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 export type BodyLaunch = Readonly<{
     paths: AkumaPaths;
     seed?: Omit<Soul, "createdAt">;
     birthSession?: Omit<SessionFact, "sequence">;
     initialBody?: string;
+    refuseIfHeld?: boolean;
+}>;
+export type TellWake = Readonly<{
+    kind: "told";
+}> | Readonly<{
+    kind: "pursuing";
+    bodySequence: number;
+}> | Readonly<{
+    kind: "held";
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+    child?: Readonly<{
+        code: number | null;
+        signal: string | null;
+        log: RunLogReference;
+    }>;
+}>;
+export type TellResult = Readonly<{
+    admission: Readonly<{
+        tellId: string;
+        fact: "recorded";
+    }>;
+    wake: TellWake;
+}>;
+export type TellWakeRuntime = Readonly<{
+    observeHeart(paths: AkumaPaths, signal: AbortSignal): Promise<AsyncGenerator<void>>;
+    spawn(paths: AkumaPaths): Promise<OwnedProcess>;
 }>;
 type BodyRuntime = Readonly<{
     now(): string;
     spawnChild?(launch: RequestChildLaunch): Promise<void>;
+    spawnBody?(launch: BodyLaunch): Promise<OwnedProcess>;
     upstream?: UpstreamExecutionPort;
 }>;
-export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtime?: BodyRuntime): Promise<void>;
-export declare function spawnAkumaBody(launch: BodyLaunch): Promise<void>;
-export declare function runAkumaBody(launch: BodyLaunch, upstream: UpstreamExecutionPort): Promise<void>;
+export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
+    argv: string[];
+    cwd: string;
+    env: {
+        KEIYAKU_ACTOR_ID: import("./identity.js").AkuId;
+    };
+    log: string;
+}>;
+export declare function handoffPendingTells(paths: AkumaPaths, spawn?: (launch: BodyLaunch) => Promise<OwnedProcess>): Promise<void>;
+export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtime?: BodyRuntime): Promise<"held" | void>;
+export declare function spawnAkumaBody(launch: BodyLaunch): Promise<OwnedProcess>;
+export declare function runAkumaBody(launch: BodyLaunch, upstream: UpstreamExecutionPort): Promise<"held" | void>;
+export declare function wakeRecordedTell(paths: AkumaPaths, tellId: string, runtime?: TellWakeRuntime): Promise<TellResult>;

package/build/src/akuma/body.js

@@ -1,30 +1,34 @@
 import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
-import { BodySupervisor, driveTurn, turnRecipe } from "./body-turn.js";
-import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, } from "./heart/index.js";
+import { BodySupervisor } from "./body-supervisor.js";
+import { driveTurn, turnRecipe } from "./turn-drive.js";
+import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, readNonterminalRequests, watchHeart, } from "./heart/index.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
-import { spawnDetachedProcess, } from "../runtime/proc/run.js";
-const LEASH_RETRY_MS = 25;
-export { CONTROL_RESPONSE_MS } from "./body-turn.js";
+import { handoffProcess, spawnDetachedProcess, } from "../runtime/proc/run.js";
+const LEASH_RETRY_MS = 100;
+export const LEASH_HELD_EXIT = 75;
+export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function missing(error) {
     return isHeartAbsent(error) || error.code === "ENOENT";
 }
 async function putDownIfControlled(paths, supervisor, bodySequence, now) {
-    if (supervisor.reason === "control" && await heartExists(paths)) {
+    if (supervisor.reason === "control" && (await heartExists(paths))) {
         await breakBody(paths, { sequence: bodySequence, end: "put-down", at: now() });
     }
 }
-async function takeLeash(paths) {
+async function takeLeash(paths, refuseIfHeld = false) {
     for (;;) {
         try {
             const leash = await HeldAkumaLeash.try(paths);
             if (leash !== null)
                 return leash;
+            if (refuseIfHeld)
+                return "held";
         }
         catch (error) {
             if (missing(error))
-                return null;
+                return "absent";
             throw error;
         }
         await abortableDelay(LEASH_RETRY_MS);
@@ -37,7 +41,7 @@ async function bornSoul(launch, leash, now) {
     if (launch.seed === undefined)
         throw new Error("Akuma wake has no born soul");
     const candidate = { ...launch.seed, createdAt: now };
-    if (await leash.birth(launch.paths, candidate, launch.birthSession) === "sealed")
+    if ((await leash.birth(launch.paths, candidate, launch.birthSession)) === "sealed")
         return null;
     const born = (await readHeart(launch.paths)).soul;
     if (born === null || born.id !== candidate.id) {
@@ -71,11 +75,25 @@ async function persistTurn(paths, turnSequence, result, completedAt) {
     return result.kind === "answered" && result.session === undefined ? "failed" : result.kind;
 }
 function defaultRuntime() {
+    return { now: () => new Date().toISOString(), spawnChild: handoffAkumaBody, spawnBody: spawnAkumaBody };
+}
+export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url) {
+    const encoded = Buffer.from(JSON.stringify(launch), "utf8").toString("base64url");
+    const actorId = launch.seed?.id ?? (await readHeart(launch.paths)).soul?.id;
+    if (actorId === undefined)
+        throw new Error("Akuma wake has no born soul");
+    const source = bodyModuleUrl.endsWith(".ts");
+    const entry = fileURLToPath(new URL(source ? "../akuma-body.ts" : "../akuma-body.js", bodyModuleUrl));
     return {
-        now: () => new Date().toISOString(),
-        spawnChild: spawnAkumaBody,
+        argv: source ? [process.execPath, "--import", "tsx", entry, encoded] : [process.execPath, entry, encoded],
+        cwd: await launchCwd(launch),
+        env: { ...process.env, KEIYAKU_ACTOR_ID: actorId },
+        log: launch.paths.log,
     };
 }
+async function handoffAkumaBody(launch) {
+    await handoffProcess(await bodyProcessInput(launch));
+}
 async function prepareBodyStart(paths, leash) {
     const before = await readHeart(paths);
     if (before.pause !== null)
@@ -132,7 +150,7 @@ async function runBodyTurns(input) {
             adapter,
             bodySequence,
             supervisor,
-            runtimeSpawn: runtime.spawnChild ?? spawnAkumaBody,
+            runtimeSpawn: runtime.spawnChild ?? handoffAkumaBody,
             body: initial ?? "",
             ...(initial === undefined ? {} : { call: initial }),
             launchTells,
@@ -149,8 +167,8 @@ async function runBodyTurns(input) {
             await breakBody(launch.paths, { sequence: bodySequence, end: "put-down", at: runtime.now() });
             return;
         }
-        if (result.kind === "resume-unsupported"
-            || await persistTurn(launch.paths, result.turnSequence, result, runtime.now()) === "failed") {
+        if (result.kind === "resume-unsupported" ||
+            (await persistTurn(launch.paths, result.turnSequence, result, runtime.now())) === "failed") {
             await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
             return;
         }
@@ -158,18 +176,38 @@ async function runBodyTurns(input) {
         initial = undefined;
     }
 }
+export async function handoffPendingTells(paths, spawn = spawnAkumaBody) {
+    try {
+        if ((await readHeart(paths)).pending.length === 0)
+            return;
+        (await spawn({ paths, refuseIfHeld: true })).release();
+    }
+    catch {
+        /* a later Heart interaction retries the unchanged pending Tell */
+    }
+}
 export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()) {
-    const leash = await takeLeash(launch.paths);
-    if (leash === null)
+    const acquired = await takeLeash(launch.paths, launch.refuseIfHeld);
+    if (acquired === "held")
+        return "held";
+    if (acquired === "absent")
         return;
+    const leash = acquired;
+    let bodyStarted = false;
     try {
         const soul = await bornSoul(launch, leash, runtime.now());
         if (soul === null)
             return;
+        if (launch.seed === undefined && launch.initialBody === undefined) {
+            const [heart, requests] = await Promise.all([readHeart(launch.paths), readNonterminalRequests(launch.paths)]);
+            if (heart.pending.length === 0 && requests.length === 0)
+                return;
+        }
         const selected = adapter ?? (await resolveProviderExecution(soul.provider)).adapter;
-        if (!await prepareBodyStart(launch.paths, leash))
+        if (!(await prepareBodyStart(launch.paths, leash)))
             return;
         const body = await leash.recordBody(launch.paths, { leashTakenAt: runtime.now() });
+        bodyStarted = true;
         const supervisor = await BodySupervisor.open(launch.paths, body.sequence, leash);
         const execution = { launch, soul, adapter: selected, bodySequence: body.sequence, supervisor, runtime };
         try {
@@ -181,7 +219,7 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
         }
     }
     catch (error) {
-        if (!await heartExists(launch.paths))
+        if (!(await heartExists(launch.paths)))
             return;
         try {
             await leash.sealIfUnborn(launch.paths, {
@@ -189,30 +227,102 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
                 at: runtime.now(),
             });
         }
-        catch { /* the original Body failure remains authoritative */ }
+        catch {
+            /* the original Body failure remains authoritative */
+        }
         throw error;
     }
     finally {
         leash.release();
+        if (bodyStarted)
+            await handoffPendingTells(launch.paths, runtime.spawnBody ?? spawnAkumaBody);
     }
 }
 export async function spawnAkumaBody(launch) {
-    const encoded = Buffer.from(JSON.stringify(launch), "utf8").toString("base64url");
-    const actorId = launch.seed?.id ?? (await readHeart(launch.paths)).soul?.id;
-    if (actorId === undefined)
-        throw new Error("Akuma wake has no born soul");
-    const owned = await spawnDetachedProcess({
-        argv: [process.execPath, ...process.execArgv, fileURLToPath(new URL("../akuma-body.js", import.meta.url)), encoded],
-        cwd: await launchCwd(launch),
-        env: { ...process.env, KEIYAKU_ACTOR_ID: actorId },
-        log: launch.paths.log,
-    });
-    owned.release();
+    return await spawnDetachedProcess(await bodyProcessInput(launch));
 }
 export async function runAkumaBody(launch, upstream) {
-    await driveAkumaBody(launch, undefined, {
-        now: () => new Date().toISOString(),
-        spawnChild: spawnAkumaBody,
-        upstream,
-    });
+    return await driveAkumaBody(launch, undefined, { ...defaultRuntime(), upstream });
+}
+const DIRECT_TELL_WAKE = {
+    observeHeart: watchHeart,
+    spawn: async (paths) => await spawnAkumaBody({ paths, refuseIfHeld: true }),
+};
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function preAdmissionDiagnostic(exit) {
+    return exit.code === null ? `pre-admission signal ${exit.signal ?? "unknown"}` : `pre-admission exit ${exit.code}`;
+}
+async function settledWake(paths, tellId, after) {
+    const heart = await readHeart(paths);
+    if (tellId !== undefined && !heart.pending.some((tell) => tell.id === tellId))
+        return { kind: "told" };
+    if (heart.latestBody !== null && heart.latestBody.sequence > after) {
+        return { kind: "pursuing", bodySequence: heart.latestBody.sequence };
+    }
+    return null;
+}
+function failedChild(exit) {
+    return {
+        kind: "failed",
+        diagnostic: preAdmissionDiagnostic(exit),
+        child: { code: exit.code, signal: exit.signal, log: exit.log },
+    };
+}
+async function awaitWake(paths, tellId, after, child, changed) {
+    let nextChange = changed.next();
+    for (;;) {
+        const settled = await settledWake(paths, tellId, after);
+        if (settled !== null) {
+            child.release();
+            return settled;
+        }
+        const winner = await Promise.race([
+            nextChange.then(({ done }) => ({ kind: done ? "closed" : "changed" }), (error) => ({ kind: "observer-failed", error })),
+            child.exited.then((exit) => ({ kind: "exited", exit })),
+        ]);
+        if (winner.kind === "changed") {
+            nextChange = changed.next();
+            continue;
+        }
+        const final = await settledWake(paths, tellId, after);
+        if (final !== null) {
+            child.release();
+            return final;
+        }
+        if (winner.kind === "exited") {
+            return winner.exit.code === LEASH_HELD_EXIT ? { kind: "held" } : failedChild(winner.exit);
+        }
+        await child.terminate();
+        await child.exited;
+        return winner.kind === "observer-failed"
+            ? { kind: "failed", diagnostic: diagnostic(winner.error) }
+            : { kind: "failed", diagnostic: "Heart observer closed" };
+    }
+}
+async function wakePendingTells(paths, tellId, runtime) {
+    const watching = new AbortController();
+    let changed;
+    try {
+        const beforeHeart = await readHeart(paths);
+        if (tellId === undefined && beforeHeart.pending.length === 0)
+            return null;
+        const before = beforeHeart.latestBody?.sequence ?? 0;
+        changed = await runtime.observeHeart(paths, watching.signal);
+        return await awaitWake(paths, tellId, before, await runtime.spawn(paths), changed);
+    }
+    catch (error) {
+        return { kind: "failed", diagnostic: diagnostic(error) };
+    }
+    finally {
+        watching.abort();
+        await changed?.return(undefined);
+    }
+}
+export async function wakeRecordedTell(paths, tellId, runtime = DIRECT_TELL_WAKE) {
+    return {
+        admission: { tellId, fact: "recorded" },
+        wake: (await wakePendingTells(paths, tellId, runtime)),
+    };
 }

package/build/src/akuma/coordinate.js

@@ -1,22 +1,32 @@
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value : null;
+        ? value
+        : null;
 }
 export function decodeResumeCoordinate(value) {
     const coordinate = record(value);
     if (coordinate === null)
         return null;
     const keys = Object.keys(coordinate);
-    if (typeof coordinate.sessionFile === "string" && coordinate.sessionFile.trim().length > 0
-        && (coordinate.sessionId === undefined || (typeof coordinate.sessionId === "string" && coordinate.sessionId.trim().length > 0))
-        && keys.every((key) => key === "sessionFile" || key === "sessionId")) {
-        return { sessionFile: coordinate.sessionFile, ...(coordinate.sessionId === undefined ? {} : { sessionId: coordinate.sessionId }) };
+    if (typeof coordinate.sessionFile === "string" &&
+        coordinate.sessionFile.trim().length > 0 &&
+        (coordinate.sessionId === undefined ||
+            (typeof coordinate.sessionId === "string" && coordinate.sessionId.trim().length > 0)) &&
+        keys.every((key) => key === "sessionFile" || key === "sessionId")) {
+        return {
+            sessionFile: coordinate.sessionFile,
+            ...(coordinate.sessionId === undefined ? {} : { sessionId: coordinate.sessionId }),
+        };
     }
     return typeof coordinate.sessionId === "string" && coordinate.sessionId.trim().length > 0 && keys.length === 1
-        ? { sessionId: coordinate.sessionId } : null;
+        ? { sessionId: coordinate.sessionId }
+        : null;
 }
 export function encodeResumeCoordinate(coordinate) {
     return "sessionFile" in coordinate
-        ? { sessionFile: coordinate.sessionFile, ...(coordinate.sessionId === undefined ? {} : { sessionId: coordinate.sessionId }) }
+        ? {
+            sessionFile: coordinate.sessionFile,
+            ...(coordinate.sessionId === undefined ? {} : { sessionId: coordinate.sessionId }),
+        }
         : { sessionId: coordinate.sessionId };
 }

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

@@ -18,5 +18,5 @@ export function lifeAt(current, body, kill, createdAt) {
         return kill?.at ?? null;
     if (current === "asleep")
         return body?.endedAt ?? createdAt;
-    return current === "stranded" ? body?.endedAt ?? null : null;
+    return current === "stranded" ? (body?.endedAt ?? null) : null;
 }

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

@@ -3,7 +3,7 @@ import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, SealFact, S
 export type { CallFact } from "./facts.js";
 import type { ActivityFact } from "./rows.js";
 import { type ActivityFactSlice } from "./timeline.js";
-export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash } from "./storage.js";
+export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash, watchHeart } from "./storage.js";
 export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
 export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, UpstreamRequestService, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";

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

@@ -3,7 +3,7 @@ import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingT
 import { activityFactSlice, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
-export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash } from "./storage.js";
+export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash, watchHeart } from "./storage.js";
 export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
 const ACTIVITY_LIMIT = 5_000;
@@ -80,9 +80,7 @@ export async function recordTellDeliveries(paths, inputs) {
 }
 export async function recordTellReceipt(paths, input) {
     await withHeart(paths, (heart) => transaction(heart, () => {
-        const tellIds = input.evidence === "exact"
-            ? [input.tellId]
-            : tellIdsForFence(heart, input.turnSequence, input.fence);
+        const tellIds = input.evidence === "exact" ? [input.tellId] : tellIdsForFence(heart, input.turnSequence, input.fence);
         if (tellIds.length === 0)
             throw new Error("tell receipt has no delivery mapping");
         insertTellReceiptFact(heart, input);

package/build/src/akuma/heart/request-authority.js

@@ -29,10 +29,10 @@ export async function admitRequest(paths, input) {
         const fact = requestFact(heart, input.id);
         if (fact === null)
             throw new Error(`Akuma request ${input.id} was not admitted`);
-        if (fact.requester !== soul.id
-            || fact.id !== normalized.id
-            || fact.action !== normalized.action
-            || requestPayloadJson(fact) !== requestPayloadJson(normalized)) {
+        if (fact.requester !== soul.id ||
+            fact.id !== normalized.id ||
+            fact.action !== normalized.action ||
+            requestPayloadJson(fact) !== requestPayloadJson(normalized)) {
             throw new Error(`Akuma request ${input.id} reused different input`);
         }
         return fact;

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

@@ -12,9 +12,7 @@ export function requestPayloadJson(input) {
     return json(payload);
 }
 function decodeRequestRow(row) {
-    const knownAction = [
-        "akuma.call", "akuma.wait", "akuma.tell", "akuma.kill", "contract.deliver", "contract.review",
-    ].includes(row.action) || isTaskMutationAction(row.action);
+    const knownAction = ["akuma.call", "akuma.wait", "akuma.tell", "akuma.kill", "contract.deliver", "contract.review"].includes(row.action) || isTaskMutationAction(row.action);
     if (!knownAction)
         throw new Error(`Akuma authority contains an unknown request action: ${row.action}`);
     const payload = parsed(row.payload_json);
@@ -53,36 +51,49 @@ const REQUEST_COLUMNS = `sequence, id, requester, action, payload_json, admitted
   state, child, service_json, diagnostic, evidence`;
 export function insertRequestFact(database, input) {
     const { id, action, requester, admittedAt, refusal } = input;
-    database.prepare(`INSERT OR IGNORE INTO requests(
+    database
+        .prepare(`INSERT OR IGNORE INTO requests(
     id, requester, action, payload_json, admitted_at, state, diagnostic
-  ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, requester, action, requestPayloadJson(input), admittedAt, refusal === undefined ? "admitted" : "refused", refusal ?? null);
+  ) VALUES (?, ?, ?, ?, ?, ?, ?)`)
+        .run(id, requester, action, requestPayloadJson(input), admittedAt, refusal === undefined ? "admitted" : "refused", refusal ?? null);
 }
 export function requestFact(database, id) {
     const row = database.prepare(`SELECT ${REQUEST_COLUMNS} FROM requests WHERE id = ?`).get(id);
     return row === undefined ? null : decodeRequestRow(row);
 }
 export function nonterminalRequestFacts(database) {
-    const rows = database.prepare(`SELECT ${REQUEST_COLUMNS} FROM requests
-    WHERE state IN ('admitted', 'reserved') ORDER BY sequence`).all();
+    const rows = database
+        .prepare(`SELECT ${REQUEST_COLUMNS} FROM requests
+    WHERE state IN ('admitted', 'reserved') ORDER BY sequence`)
+        .all();
     return rows.map(decodeRequestRow);
 }
 export function updateRequestReserved(database, id, child) {
-    database.prepare("UPDATE requests SET state = 'reserved', child = ? WHERE id = ? AND state = 'admitted'")
+    database
+        .prepare("UPDATE requests SET state = 'reserved', child = ? WHERE id = ? AND state = 'admitted'")
         .run(child, id);
 }
 export function updateRequestServed(database, id, child) {
-    database.prepare(`UPDATE requests SET state = 'served', child = ?
-    WHERE id = ? AND state = 'reserved'`).run(child, id);
+    database
+        .prepare(`UPDATE requests SET state = 'served', child = ?
+    WHERE id = ? AND state = 'reserved'`)
+        .run(child, id);
 }
 export function updateUpstreamRequestServed(database, id, service) {
-    database.prepare(`UPDATE requests SET state = 'served', service_json = ?
-    WHERE id = ? AND state = 'admitted' AND action != 'akuma.call'`).run(json(service), id);
+    database
+        .prepare(`UPDATE requests SET state = 'served', service_json = ?
+    WHERE id = ? AND state = 'admitted' AND action != 'akuma.call'`)
+        .run(json(service), id);
 }
 export function updateRequestRefused(database, id, diagnostic) {
-    database.prepare(`UPDATE requests SET state = 'refused', diagnostic = ?
-    WHERE id = ? AND state = 'admitted'`).run(diagnostic, id);
+    database
+        .prepare(`UPDATE requests SET state = 'refused', diagnostic = ?
+    WHERE id = ? AND state = 'admitted'`)
+        .run(diagnostic, id);
 }
 export function updateRequestVoided(database, id, evidence) {
-    database.prepare(`UPDATE requests SET state = 'voided', child = NULL, service_json = NULL, evidence = ?
-    WHERE id = ? AND state IN ('admitted', 'reserved')`).run(evidence, id);
+    database
+        .prepare(`UPDATE requests SET state = 'voided', child = NULL, service_json = NULL, evidence = ?
+    WHERE id = ? AND state IN ('admitted', 'reserved')`)
+        .run(evidence, id);
 }