@astrosheep/keiyaku 4.0.4 → 4.0.6

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

@@ -1,10 +1,10 @@
-import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertRequestFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, nonterminalRequestFacts, pauseFact, requestFact, sessionFactForCoordinate, stopFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, updateUpstreamRequestServed, } from "./rows.js";
+import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, } from "./rows.js";
 import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingTellFacts, tellFact, tellIdsForFence, } from "./tells.js";
-import { activityFactSlice, pruneActivityFacts, } from "./timeline.js";
+import { activityFactSlice, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
-import { clipAllowedActions } from "../allowed.js";
 export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash } 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;
 export async function readSoul(paths) {
@@ -89,137 +89,6 @@ export async function recordTellReceipt(paths, input) {
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
     }));
 }
-function sameRequestInput(fact, input) {
-    if (fact.id !== input.id || fact.action !== input.action)
-        return false;
-    if (fact.action === "akuma.call" && input.action === "akuma.call") {
-        return fact.archetype === input.archetype
-            && fact.body === input.body
-            && fact.cwd === input.cwd
-            && fact.world === input.world
-            && JSON.stringify(fact.recipe) === JSON.stringify(input.recipe);
-    }
-    if (fact.action === "akuma.wait" && input.action === "akuma.wait") {
-        return fact.completion === input.completion
-            && fact.timeoutMs === input.timeoutMs
-            && JSON.stringify(fact.targets) === JSON.stringify(input.targets);
-    }
-    if (fact.action === "akuma.tell" && input.action === "akuma.tell") {
-        return fact.target === input.target && fact.body === input.body;
-    }
-    return fact.action === "akuma.kill" && input.action === "akuma.kill"
-        && JSON.stringify(fact.targets) === JSON.stringify(input.targets);
-}
-export async function admitRequest(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const soul = soulFact(heart);
-        if (soul === null)
-            throw new Error("Akuma request admission requires a born Soul");
-        const action = input.action;
-        const parentAllowed = soul.allowed;
-        const permitted = action === "akuma.wait" || parentAllowed.includes(action);
-        const normalized = input.action === "akuma.call"
-            ? {
-                ...input,
-                recipe: {
-                    ...input.recipe,
-                    allowed: permitted ? clipAllowedActions(input.recipe.allowed, parentAllowed) : input.recipe.allowed,
-                },
-            }
-            : input;
-        insertRequestFact(heart, {
-            ...normalized,
-            requester: soul.id,
-            admittedAt: input.admittedAt,
-            ...(permitted ? {} : { refusal: `not-allowed: ${action}` }),
-        });
-        const fact = requestFact(heart, input.id);
-        if (fact === null)
-            throw new Error(`Akuma request ${input.id} was not admitted`);
-        if (fact.requester !== soul.id || !sameRequestInput(fact, normalized)) {
-            throw new Error(`Akuma request ${input.id} reused different input`);
-        }
-        return fact;
-    }));
-}
-export async function reserveRequest(paths, id, child) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.action !== "akuma.call")
-            throw new Error(`Akuma request ${id} cannot reserve a child`);
-        if (before.state === "admitted")
-            updateRequestReserved(heart, id, child);
-        else if ((before.state !== "reserved" && before.state !== "served") || before.child !== child) {
-            throw new Error(`Akuma request ${id} cannot reserve ${child}`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function serveRequest(paths, id, child) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.action !== "akuma.call")
-            throw new Error(`Akuma request ${id} cannot serve a child`);
-        if (before.state === "reserved" && before.child === child)
-            updateRequestServed(heart, id, child);
-        else if (before.state !== "served" || before.child !== child) {
-            throw new Error(`Akuma request ${id} cannot serve ${child}`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function serveUpstreamRequest(paths, id, service) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.action === "akuma.call" || service.action !== before.action) {
-            throw new Error(`Akuma request ${id} has a mismatched service reference`);
-        }
-        if (before.state === "admitted")
-            updateUpstreamRequestServed(heart, id, service);
-        else if (before.state !== "served" || JSON.stringify(before.service) !== JSON.stringify(service)) {
-            throw new Error(`Akuma request ${id} cannot be served as ${service.action}`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function refuseRequest(paths, id, diagnostic) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.state === "admitted")
-            updateRequestRefused(heart, id, diagnostic);
-        else if (before.state !== "refused" || before.diagnostic !== diagnostic) {
-            throw new Error(`Akuma request ${id} cannot be refused`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function voidRequest(paths, id, evidence) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
-        const before = requestFact(heart, id);
-        if (before === null)
-            throw new Error(`unknown Akuma request ${id}`);
-        if (before.state === "admitted" || before.state === "reserved")
-            updateRequestVoided(heart, id, evidence);
-        else if (before.state !== "voided" || before.evidence !== evidence) {
-            throw new Error(`Akuma request ${id} cannot be voided`);
-        }
-        return requestFact(heart, id);
-    }));
-}
-export async function readRequest(paths, id) {
-    return await withHeart(paths, (heart) => requestFact(heart, id));
-}
-export async function readNonterminalRequests(paths) {
-    return await withHeart(paths, nonterminalRequestFacts);
-}
 export async function readKill(paths, bodySequence) {
     return await withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
 }
@@ -303,11 +172,21 @@ export async function readHeart(paths) {
             latestKill: latestKillFact(heart),
             stop: stopFact(heart),
             pause: pauseFact(heart),
+            lastActivityAt: readLastActivityAt(heart),
         })));
     }
     catch (error) {
         if (isHeartAbsent(error)) {
-            return { soul: null, latestBody: null, latestSession: null, pending: [], latestKill: null, stop: null, pause: null };
+            return {
+                soul: null,
+                latestBody: null,
+                latestSession: null,
+                pending: [],
+                latestKill: null,
+                stop: null,
+                pause: null,
+                lastActivityAt: null,
+            };
         }
         throw error;
     }

package/build/src/akuma/heart/request-authority.d.ts

@@ -0,0 +1,12 @@
+import type { AkuId, AkumaPaths } from "../identity.js";
+import type { RequestFact, RequestInput, UpstreamRequestService } from "./facts.js";
+export declare function admitRequest(paths: AkumaPaths, input: RequestInput & Readonly<{
+    admittedAt: string;
+}>): Promise<RequestFact>;
+export declare function reserveRequest(paths: AkumaPaths, id: string, child: AkuId): Promise<RequestFact>;
+export declare function serveRequest(paths: AkumaPaths, id: string, child: AkuId): Promise<RequestFact>;
+export declare function serveUpstreamRequest(paths: AkumaPaths, id: string, service: UpstreamRequestService): Promise<RequestFact>;
+export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic: string): Promise<RequestFact>;
+export declare function voidRequest(paths: AkumaPaths, id: string, evidence: string): Promise<RequestFact>;
+export declare function readRequest(paths: AkumaPaths, id: string): Promise<RequestFact | null>;
+export declare function readNonterminalRequests(paths: AkumaPaths): Promise<readonly RequestFact[]>;

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

@@ -0,0 +1,119 @@
+import { insertRequestFact, nonterminalRequestFacts, requestFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, updateUpstreamRequestServed, } from "./request-rows.js";
+import { transaction, withHeart } from "./storage.js";
+import { soulFact } from "./soul.js";
+import { clipAllowedActions } from "../allowed.js";
+import { requestPayloadJson } from "./request-rows.js";
+export async function admitRequest(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const soul = soulFact(heart);
+        if (soul === null)
+            throw new Error("Akuma request admission requires a born Soul");
+        const action = input.action;
+        const parentAllowed = soul.allowed;
+        const permitted = action === "akuma.wait" || parentAllowed.includes(action);
+        const normalized = input.action === "akuma.call"
+            ? {
+                ...input,
+                recipe: {
+                    ...input.recipe,
+                    allowed: permitted ? clipAllowedActions(input.recipe.allowed, parentAllowed) : input.recipe.allowed,
+                },
+            }
+            : input;
+        insertRequestFact(heart, {
+            ...normalized,
+            requester: soul.id,
+            admittedAt: input.admittedAt,
+            ...(permitted ? {} : { refusal: `not-allowed: ${action}` }),
+        });
+        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)) {
+            throw new Error(`Akuma request ${input.id} reused different input`);
+        }
+        return fact;
+    }));
+}
+export async function reserveRequest(paths, id, child) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.action !== "akuma.call")
+            throw new Error(`Akuma request ${id} cannot reserve a child`);
+        if (before.state === "admitted")
+            updateRequestReserved(heart, id, child);
+        else if ((before.state !== "reserved" && before.state !== "served") || before.child !== child) {
+            throw new Error(`Akuma request ${id} cannot reserve ${child}`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export async function serveRequest(paths, id, child) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.action !== "akuma.call")
+            throw new Error(`Akuma request ${id} cannot serve a child`);
+        if (before.state === "reserved" && before.child === child)
+            updateRequestServed(heart, id, child);
+        else if (before.state !== "served" || before.child !== child) {
+            throw new Error(`Akuma request ${id} cannot serve ${child}`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export async function serveUpstreamRequest(paths, id, service) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.action === "akuma.call" || service.action !== before.action) {
+            throw new Error(`Akuma request ${id} has a mismatched service reference`);
+        }
+        if (before.state === "admitted")
+            updateUpstreamRequestServed(heart, id, service);
+        else if (before.state !== "served") {
+            throw new Error(`Akuma request ${id} cannot be served as ${service.action}`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export async function refuseRequest(paths, id, diagnostic) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "admitted")
+            updateRequestRefused(heart, id, diagnostic);
+        else if (before.state !== "refused" || before.diagnostic !== diagnostic) {
+            throw new Error(`Akuma request ${id} cannot be refused`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export async function voidRequest(paths, id, evidence) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "admitted" || before.state === "reserved") {
+            updateRequestVoided(heart, id, evidence);
+        }
+        else if (before.state !== "voided" || before.evidence !== evidence) {
+            throw new Error(`Akuma request ${id} cannot be voided`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export async function readRequest(paths, id) {
+    return await withHeart(paths, (heart) => requestFact(heart, id));
+}
+export async function readNonterminalRequests(paths) {
+    return await withHeart(paths, nonterminalRequestFacts);
+}

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

@@ -0,0 +1,16 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { AkuId } from "../identity.js";
+import type { RequestFact, RequestInput } from "./facts.js";
+export declare function requestPayloadJson(input: RequestInput): string;
+export declare function insertRequestFact(database: DatabaseSync, input: RequestInput & Readonly<{
+    requester: AkuId;
+    admittedAt: string;
+    refusal?: string;
+}>): void;
+export declare function requestFact(database: DatabaseSync, id: string): RequestFact | null;
+export declare function nonterminalRequestFacts(database: DatabaseSync): readonly RequestFact[];
+export declare function updateRequestReserved(database: DatabaseSync, id: string, child: AkuId): void;
+export declare function updateRequestServed(database: DatabaseSync, id: string, child: AkuId): void;
+export declare function updateUpstreamRequestServed(database: DatabaseSync, id: string, service: unknown): void;
+export declare function updateRequestRefused(database: DatabaseSync, id: string, diagnostic: string): void;
+export declare function updateRequestVoided(database: DatabaseSync, id: string, evidence: string): void;

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

@@ -0,0 +1,88 @@
+import { isTaskMutationAction } from "../../task/mutation.js";
+function json(value) {
+    return JSON.stringify(value);
+}
+function parsed(value) {
+    if (typeof value !== "string")
+        throw new Error("Akuma authority contains non-text JSON");
+    return JSON.parse(value);
+}
+export function requestPayloadJson(input) {
+    const { id: _id, action: _action, requester: _requester, admittedAt: _admittedAt, state: _state, child: _child, service: _service, diagnostic: _diagnostic, evidence: _evidence, refusal: _refusal, ...payload } = 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);
+    if (!knownAction)
+        throw new Error(`Akuma authority contains an unknown request action: ${row.action}`);
+    const payload = parsed(row.payload_json);
+    const input = {
+        id: row.id,
+        requester: row.requester,
+        action: row.action,
+        ...payload,
+        admittedAt: row.admitted_at,
+    };
+    if (row.state === "reserved") {
+        if (input.action !== "akuma.call" || row.child === null) {
+            throw new Error("Akuma authority contains an invalid reserved request");
+        }
+        return { ...input, state: row.state, child: row.child };
+    }
+    if (row.state === "served") {
+        if (input.action === "akuma.call") {
+            if (row.child === null)
+                throw new Error("Akuma authority contains a served call without a child");
+            return { ...input, state: row.state, child: row.child };
+        }
+        if (row.service_json === null) {
+            throw new Error("Akuma authority contains a served request without a service reference");
+        }
+        const service = parsed(row.service_json);
+        return { ...input, state: row.state, service };
+    }
+    if (row.state === "refused")
+        return { ...input, state: row.state, diagnostic: row.diagnostic };
+    if (row.state === "voided")
+        return { ...input, state: row.state, evidence: row.evidence };
+    return { ...input, state: "admitted" };
+}
+const REQUEST_COLUMNS = `sequence, id, requester, action, payload_json, admitted_at,
+  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(
+    id, requester, action, payload_json, admitted_at, state, diagnostic
+  ) 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();
+    return rows.map(decodeRequestRow);
+}
+export function updateRequestReserved(database, id, child) {
+    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);
+}
+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);
+}
+export function updateRequestRefused(database, id, diagnostic) {
+    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);
+}

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

@@ -1,6 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
-import type { AkuId } from "../identity.js";
-import type { BodyEnd, BodyFact, CallFact, KillFact, PauseFact, RequestFact, RequestInput, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
+import type { BodyEnd, BodyFact, CallFact, KillFact, PauseFact, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
 export type SealRow = Readonly<{
     evidence: string;
     at: string;
@@ -39,19 +38,6 @@ export type CallRow = Readonly<{
     body: string;
     at: string;
 }>;
-export type RequestRow = Readonly<{
-    sequence: number;
-    id: string;
-    requester: string;
-    action: string;
-    payload_json: string;
-    admitted_at: string;
-    state: RequestFact["state"];
-    child: string | null;
-    service_json: string | null;
-    diagnostic: string | null;
-    evidence: string | null;
-}>;
 export type ActivityRow = Readonly<{
     sequence: number;
     turn_sequence: number;
@@ -77,7 +63,6 @@ export declare function decodeSessionRow(row: SessionRow): SessionFact;
 export declare function decodeBodyRow(row: BodyRow): BodyFact;
 export declare function decodeTurnRow(row: TurnRow): TurnFact;
 export declare function decodeCallRow(row: CallRow): CallFact;
-export declare function decodeRequestRow(row: RequestRow): RequestFact;
 export declare function encodeActivityEvent(event: unknown): string;
 export declare function decodeActivityRow(row: ActivityRow): ActivityFact;
 export declare function sealExists(database: DatabaseSync): boolean;
@@ -100,18 +85,6 @@ export declare function insertActivityFact(database: DatabaseSync, input: Readon
     event: unknown;
     at: string;
 }>): number;
-export declare function insertRequestFact(database: DatabaseSync, input: RequestInput & Readonly<{
-    requester: AkuId;
-    admittedAt: string;
-    refusal?: string;
-}>): void;
-export declare function requestFact(database: DatabaseSync, id: string): RequestFact | null;
-export declare function nonterminalRequestFacts(database: DatabaseSync): readonly RequestFact[];
-export declare function updateRequestReserved(database: DatabaseSync, id: string, child: AkuId): void;
-export declare function updateRequestServed(database: DatabaseSync, id: string, child: AkuId): void;
-export declare function updateUpstreamRequestServed(database: DatabaseSync, id: string, service: unknown): void;
-export declare function updateRequestRefused(database: DatabaseSync, id: string, diagnostic: string): void;
-export declare function updateRequestVoided(database: DatabaseSync, id: string, evidence: string): void;
 export declare function insertStopControl(database: DatabaseSync, bodySequence: number, at: string): void;
 export declare function insertPauseControl(database: DatabaseSync, at: string): void;
 export declare function stopFact(database: DatabaseSync): StopFact | null;

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

@@ -7,66 +7,6 @@ function parsed(value) {
         throw new Error("Akuma authority contains non-text JSON");
     return JSON.parse(value);
 }
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
-function exactKeys(value, expected) {
-    const actual = Object.keys(value).sort();
-    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
-}
-const KILL_EVIDENCE = [
-    "already-killed",
-    "already-stopped",
-    "hung",
-    "killed",
-    "untidy",
-    "unavailable",
-];
-function decodeRequestService(value, input) {
-    const service = object(value);
-    if (service === null || service.action !== input.action) {
-        throw new Error("Akuma authority contains a mismatched request service reference");
-    }
-    if (input.action === "akuma.wait") {
-        if (!exactKeys(service, ["action"])) {
-            throw new Error("Akuma authority contains an invalid wait service reference");
-        }
-        return { action: input.action };
-    }
-    if (input.action === "akuma.tell") {
-        if (!exactKeys(service, ["action", "target", "tellId"])
-            || service.target !== input.target
-            || service.tellId !== input.id) {
-            throw new Error("Akuma authority contains an invalid tell service reference");
-        }
-        return { action: input.action, target: input.target, tellId: input.id };
-    }
-    if (!exactKeys(service, ["action", "results"]) || !Array.isArray(service.results)) {
-        throw new Error("Akuma authority contains an invalid kill service reference");
-    }
-    let targetIndex = -1;
-    const results = service.results.map((value) => {
-        const result = object(value);
-        if (result === null
-            || !exactKeys(result, ["evidence", "id"])
-            || typeof result.id !== "string"
-            || !KILL_EVIDENCE.includes(result.evidence)) {
-            throw new Error("Akuma authority contains an invalid kill service reference");
-        }
-        const index = input.targets.indexOf(result.id);
-        if (index <= targetIndex) {
-            throw new Error("Akuma authority contains an invalid kill service reference");
-        }
-        targetIndex = index;
-        return {
-            id: result.id,
-            evidence: result.evidence,
-        };
-    });
-    return { action: input.action, results };
-}
 function resumeCoordinate(value) {
     const coordinate = decodeResumeCoordinate(value);
     if (coordinate === null)
@@ -126,46 +66,6 @@ export function decodeTurnRow(row) {
 export function decodeCallRow(row) {
     return { kind: "call", sequence: row.sequence, turnSequence: row.turn_sequence, body: row.body, at: row.at };
 }
-export function decodeRequestRow(row) {
-    if (!["akuma.call", "akuma.wait", "akuma.tell", "akuma.kill"].includes(row.action)) {
-        throw new Error(`Akuma authority contains an unknown request action: ${row.action}`);
-    }
-    const payload = parsed(row.payload_json);
-    const input = {
-        id: row.id,
-        requester: row.requester,
-        action: row.action,
-        ...payload,
-        admittedAt: row.admitted_at,
-    };
-    if (row.state === "reserved") {
-        if (input.action !== "akuma.call" || row.child === null) {
-            throw new Error("Akuma authority contains an invalid reserved request");
-        }
-        return { ...input, state: row.state, child: row.child };
-    }
-    if (row.state === "served") {
-        if (input.action === "akuma.call") {
-            if (row.child === null)
-                throw new Error("Akuma authority contains a served call without a child");
-            return { ...input, state: row.state, child: row.child };
-        }
-        if (row.service_json === null) {
-            throw new Error("Akuma authority contains a served request without a service reference");
-        }
-        const service = decodeRequestService(parsed(row.service_json), input);
-        return {
-            ...input,
-            state: row.state,
-            service,
-        };
-    }
-    if (row.state === "refused")
-        return { ...input, state: row.state, diagnostic: row.diagnostic };
-    if (row.state === "voided")
-        return { ...input, state: row.state, evidence: row.evidence };
-    return { ...input, state: "admitted" };
-}
 export function encodeActivityEvent(event) {
     return json(event);
 }
@@ -196,6 +96,9 @@ export function sealFact(database) {
     return row === undefined ? null : { evidence: row.evidence, at: row.at };
 }
 export function insertBodyFact(database, input) {
+    if (latestBodyFact(database)?.hung !== undefined) {
+        throw new Error("Akuma successor is permanently gated by hung custody");
+    }
     const result = database.prepare("INSERT INTO bodies(leash_taken_at) VALUES (?)").run(input.leashTakenAt);
     return Number(result.lastInsertRowid);
 }
@@ -210,43 +113,6 @@ export function insertActivityFact(database, input) {
         .run(sequence, input.turnSequence, encodeActivityEvent(input.event), input.at);
     return sequence;
 }
-const REQUEST_COLUMNS = `sequence, id, requester, action, payload_json, admitted_at,
-  state, child, service_json, diagnostic, evidence`;
-export function insertRequestFact(database, input) {
-    const { id, action, requester, admittedAt, refusal, ...payload } = input;
-    database.prepare(`INSERT OR IGNORE INTO requests(
-    id, requester, action, payload_json, admitted_at, state, diagnostic
-  ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, requester, action, json(payload), 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();
-    return rows.map(decodeRequestRow);
-}
-export function updateRequestReserved(database, id, child) {
-    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);
-}
-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);
-}
-export function updateRequestRefused(database, id, diagnostic) {
-    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);
-}
 export function insertStopControl(database, bodySequence, at) {
     database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('stop', ?, ?)")
         .run(json({ bodySequence }), at);
@@ -288,7 +154,7 @@ export function endBodyFact(database, input) {
 }
 export function markBodyHung(database, input) {
     const result = database.prepare(`UPDATE bodies SET hung_diagnostic = ?, hung_at = ?
-    WHERE sequence = ? AND end IS NULL AND hung_diagnostic IS NULL`)
+    WHERE sequence = ? AND hung_diagnostic IS NULL`)
         .run(input.diagnostic, input.at, input.sequence);
     if (result.changes !== 1)
         throw new Error(`Akuma Body ${input.sequence} cannot record hung custody`);