@astrosheep/keiyaku 4.0.1 → 4.0.2

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

@@ -1,27 +1,15 @@
 import type { DatabaseSync } from "node:sqlite";
 import type { AkuId } from "../identity.js";
-import type { BodyEnd, BodyFact, CallFact, Collar, KillFact, RequestFact, RequestInput, ResumeCoordinate, SessionFact, Soul, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
-export type SoulRow = Readonly<{
-    id: string;
-    archetype: string;
-    description: string | null;
-    provider_json: string;
-    options_json: string;
-    cwd: string;
-    origin_json: string;
-    confinement_json: string;
-    created_at: string;
-}>;
+import type { BodyEnd, BodyFact, CallFact, KillFact, PauseFact, RequestFact, RequestInput, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
 export type SealRow = Readonly<{
     evidence: string;
     at: string;
 }>;
 export type BodyRow = Readonly<{
     sequence: number;
-    pid: number;
-    process_group: number;
-    spawned_at: string;
     leash_taken_at: string;
+    hung_diagnostic: string | null;
+    hung_at: string | null;
     end: BodyEnd | null;
     ended_at: string | null;
 }>;
@@ -84,18 +72,6 @@ export type KillRow = Readonly<{
     evidence: "killed";
     at: string;
 }>;
-export declare function encodeSoulRow(soul: Soul): readonly [
-    AkuId,
-    string,
-    string | null,
-    string,
-    string,
-    string,
-    string,
-    string,
-    string
-];
-export declare function decodeSoulRow(row: SoulRow): Soul;
 export declare function encodeSessionRow(session: Omit<SessionFact, "sequence">): readonly [string, string, string, string, string];
 export declare function encodeResumeCoordinate(coordinate: ResumeCoordinate): string;
 export declare function decodeSessionRow(row: SessionRow): SessionFact;
@@ -105,9 +81,7 @@ 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 soulFact(database: DatabaseSync): Soul | null;
 export declare function sealExists(database: DatabaseSync): boolean;
-export declare function insertSoulFact(database: DatabaseSync, soul: Soul): void;
 export declare function insertSealFact(database: DatabaseSync, input: Readonly<{
     evidence: string;
     at: string;
@@ -119,7 +93,6 @@ export declare function sealFact(database: DatabaseSync): Readonly<{
     at: string;
 }> | null;
 export declare function insertBodyFact(database: DatabaseSync, input: Readonly<{
-    collar: Collar;
     leashTakenAt: string;
 }>): number;
 export declare function insertSessionFact(database: DatabaseSync, input: Omit<SessionFact, "sequence">): number;
@@ -140,13 +113,18 @@ export declare function updateRequestVoided(database: DatabaseSync, id: string,
 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;
-export declare function pauseExists(database: DatabaseSync): boolean;
+export declare function pauseFact(database: DatabaseSync): PauseFact | null;
 export declare function insertKillFact(database: DatabaseSync, bodySequence: number, at: string): void;
 export declare function endBodyFact(database: DatabaseSync, input: Readonly<{
     sequence: number;
     end: BodyEnd;
     at: string;
 }>): void;
+export declare function markBodyHung(database: DatabaseSync, input: Readonly<{
+    sequence: number;
+    diagnostic: string;
+    at: string;
+}>): void;
 export declare function insertTurnStartFact(database: DatabaseSync, input: Readonly<{
     bodySequence: number;
     startedAt: string;

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

@@ -13,32 +13,6 @@ function resumeCoordinate(value) {
         throw new Error("Akuma authority contains an invalid resume coordinate");
     return coordinate;
 }
-export function encodeSoulRow(soul) {
-    return [
-        soul.id,
-        soul.archetype,
-        soul.description ?? null,
-        json(soul.provider),
-        json(soul.options),
-        soul.cwd,
-        json(soul.origin),
-        json(soul.confinement),
-        soul.createdAt,
-    ];
-}
-export function decodeSoulRow(row) {
-    return {
-        id: row.id,
-        archetype: row.archetype,
-        ...(row.description === null ? {} : { description: row.description }),
-        provider: parsed(row.provider_json),
-        options: parsed(row.options_json),
-        cwd: row.cwd,
-        origin: parsed(row.origin_json),
-        confinement: parsed(row.confinement_json),
-        createdAt: row.created_at,
-    };
-}
 export function encodeSessionRow(session) {
     return [session.provider, encodeResumeCoordinate(session.coordinate), session.cwd, json(session.options), session.admittedAt];
 }
@@ -58,8 +32,8 @@ export function decodeSessionRow(row) {
 export function decodeBodyRow(row) {
     return {
         sequence: row.sequence,
-        collar: { pid: row.pid, processGroup: row.process_group, spawnedAt: row.spawned_at },
         leashTakenAt: row.leash_taken_at,
+        ...(row.hung_diagnostic === null ? {} : { hung: { diagnostic: row.hung_diagnostic, at: row.hung_at } }),
         ...(row.end === null ? {} : { end: row.end }),
         ...(row.ended_at === null ? {} : { endedAt: row.ended_at }),
     };
@@ -80,7 +54,7 @@ export function decodeTurnRow(row) {
         outcome: row.outcome === "answered"
             ? {
                 kind: "answered",
-                historyId: row.history_id,
+                ...(row.history_id === null ? {} : { historyId: row.history_id }),
                 session: resumeCoordinate(parsed(row.session_json)),
                 answer: row.answer,
             }
@@ -123,18 +97,9 @@ export function decodeActivityRow(row) {
         at: row.at,
     };
 }
-export function soulFact(database) {
-    const row = database.prepare(`SELECT id, archetype, description, provider_json, options_json, cwd,
-    origin_json, confinement_json, created_at FROM soul WHERE singleton = 1`).get();
-    return row === undefined ? null : decodeSoulRow(row);
-}
 export function sealExists(database) {
     return database.prepare("SELECT singleton FROM seal WHERE singleton = 1").get() !== undefined;
 }
-export function insertSoulFact(database, soul) {
-    database.prepare(`INSERT INTO soul(singleton, id, archetype, description, provider_json, options_json, cwd, origin_json, confinement_json, created_at)
-    VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(...encodeSoulRow(soul));
-}
 export function insertSealFact(database, input) {
     database.prepare("INSERT OR IGNORE INTO seal(singleton, evidence, at) VALUES (1, ?, ?)")
         .run(input.evidence, input.at);
@@ -150,8 +115,7 @@ export function sealFact(database) {
     return row === undefined ? null : { evidence: row.evidence, at: row.at };
 }
 export function insertBodyFact(database, input) {
-    const result = database.prepare(`INSERT INTO bodies(pid, process_group, spawned_at, leash_taken_at)
-    VALUES (?, ?, ?, ?)`).run(input.collar.pid, input.collar.processGroup, input.collar.spawnedAt, input.leashTakenAt);
+    const result = database.prepare("INSERT INTO bodies(leash_taken_at) VALUES (?)").run(input.leashTakenAt);
     return Number(result.lastInsertRowid);
 }
 export function insertSessionFact(database, input) {
@@ -201,7 +165,11 @@ export function insertStopControl(database, bodySequence, at) {
         .run(json({ bodySequence }), at);
 }
 export function insertPauseControl(database, at) {
-    database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('pause', '{}', ?)").run(at);
+    const body = latestBodyFact(database);
+    if (body === null)
+        throw new Error("Akuma has no Body to interrupt");
+    database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('pause', ?, ?)")
+        .run(json({ bodySequence: body.sequence }), at);
 }
 export function stopFact(database) {
     const row = database.prepare("SELECT value_json, at FROM control WHERE kind = 'stop'").get();
@@ -213,8 +181,15 @@ export function stopFact(database) {
     }
     return { bodySequence: value.bodySequence, requestedAt: row.at };
 }
-export function pauseExists(database) {
-    return database.prepare("SELECT kind FROM control WHERE kind = 'pause'").get() !== undefined;
+export function pauseFact(database) {
+    const row = database.prepare("SELECT value_json, at FROM control WHERE kind = 'pause'").get();
+    if (row === undefined)
+        return null;
+    const value = parsed(row.value_json);
+    if (!Number.isSafeInteger(value.bodySequence) || value.bodySequence <= 0) {
+        throw new Error("Akuma pause control has an invalid Body sequence");
+    }
+    return { bodySequence: value.bodySequence, requestedAt: row.at };
 }
 export function insertKillFact(database, bodySequence, at) {
     database.prepare("INSERT OR IGNORE INTO kills(body_sequence, evidence, at) VALUES (?, 'killed', ?)")
@@ -224,6 +199,13 @@ export function endBodyFact(database, input) {
     database.prepare("UPDATE bodies SET end = ?, ended_at = ? WHERE sequence = ? AND end IS NULL")
         .run(input.end, input.at, input.sequence);
 }
+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`)
+        .run(input.diagnostic, input.at, input.sequence);
+    if (result.changes !== 1)
+        throw new Error(`Akuma Body ${input.sequence} cannot record hung custody`);
+}
 export function insertTurnStartFact(database, input) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('turn-start')").run().lastInsertRowid);
     database.prepare("INSERT INTO turns(sequence, body_sequence, started_at) VALUES (?, ?, ?)")
@@ -239,7 +221,7 @@ export function insertTurnEndFact(database, input) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('turn-end')").run().lastInsertRowid);
     const result = input.outcome.kind === "answered"
         ? database.prepare(`UPDATE turns SET end_sequence = ?, outcome = 'answered', history_id = ?,
-        session_json = ?, answer = ?, completed_at = ? WHERE sequence = ? AND end_sequence IS NULL`).run(sequence, input.outcome.historyId, encodeResumeCoordinate(input.outcome.session), input.outcome.answer, input.completedAt, input.turnSequence)
+        session_json = ?, answer = ?, completed_at = ? WHERE sequence = ? AND end_sequence IS NULL`).run(sequence, input.outcome.historyId ?? null, encodeResumeCoordinate(input.outcome.session), input.outcome.answer, input.completedAt, input.turnSequence)
         : database.prepare(`UPDATE turns SET end_sequence = ?, outcome = 'failed', diagnostic = ?, completed_at = ?
         WHERE sequence = ? AND end_sequence IS NULL`).run(sequence, input.outcome.diagnostic, input.completedAt, input.turnSequence);
     if (result.changes !== 1)
@@ -251,7 +233,7 @@ export function finishBodyFact(database, input) {
         .run(input.at, input.sequence);
 }
 export function latestBodyFact(database) {
-    const row = database.prepare(`SELECT sequence, pid, process_group, spawned_at, leash_taken_at, end, ended_at
+    const row = database.prepare(`SELECT sequence, leash_taken_at, hung_diagnostic, hung_at, end, ended_at
     FROM bodies ORDER BY sequence DESC LIMIT 1`).get();
     return row === undefined ? null : decodeBodyRow(row);
 }

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

@@ -1,5 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
 export declare function assertHeartSchemaVersion(database: DatabaseSync): void;
 export declare function assertLeashSchemaVersion(database: DatabaseSync): void;
-export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 10)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 10);\n  CREATE TABLE IF NOT EXISTS soul (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    id TEXT NOT NULL UNIQUE,\n    archetype TEXT NOT NULL,\n    description TEXT,\n    provider_json TEXT NOT NULL CHECK (json_valid(provider_json)),\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    cwd TEXT NOT NULL,\n    origin_json TEXT NOT NULL CHECK (json_valid(origin_json)),\n    confinement_json TEXT NOT NULL CHECK (json_valid(confinement_json)),\n    created_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS bodies (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    pid INTEGER NOT NULL CHECK (pid > 0),\n    process_group INTEGER NOT NULL CHECK (process_group > 0),\n    spawned_at TEXT NOT NULL,\n    leash_taken_at TEXT NOT NULL,\n    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),\n    ended_at TEXT\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS sessions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    provider TEXT NOT NULL,\n    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),\n    cwd TEXT NOT NULL,\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    admitted_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS turns (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    started_at TEXT NOT NULL,\n    end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,\n    outcome TEXT CHECK (outcome IN ('answered', 'failed')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    diagnostic TEXT,\n    completed_at TEXT,\n    CHECK (\n      (outcome = 'answered' AND history_id IS NOT NULL AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NULL AND completed_at IS NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS timeline (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS calls (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    event_json TEXT NOT NULL CHECK (json_valid(event_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tells (\n    id TEXT PRIMARY KEY,\n    sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_deliveries (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    route TEXT NOT NULL CHECK (route IN ('launch', 'live')),\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT NOT NULL,\n    receipt TEXT CHECK (receipt IN ('unavailable', 'required')),\n    delivered_at TEXT NOT NULL,\n    CHECK ((route = 'launch' AND receipt IS NULL) OR (route = 'live' AND receipt IS NOT NULL)),\n    UNIQUE (tell_id, turn_sequence, fence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_receipts (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    evidence TEXT NOT NULL CHECK (evidence IN ('exact', 'fence')),\n    tell_id TEXT REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT,\n    kind TEXT NOT NULL,\n    received_at TEXT NOT NULL,\n    CHECK (\n      (evidence = 'exact' AND tell_id IS NOT NULL AND turn_sequence IS NULL AND fence IS NULL)\n      OR (evidence = 'fence' AND tell_id IS NULL AND turn_sequence IS NOT NULL AND fence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_exact\n    ON tell_receipts(tell_id, kind) WHERE evidence = 'exact';\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind) WHERE evidence = 'fence';\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    archetype TEXT NOT NULL,\n    body TEXT NOT NULL,\n    cwd TEXT,\n    world TEXT NOT NULL,\n    recipe_json TEXT NOT NULL CHECK (json_valid(recipe_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),\n    child TEXT,\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state IN ('reserved', 'served') AND child IS NOT NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS control (\n    kind TEXT PRIMARY KEY CHECK (kind IN ('stop', 'pause')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS kills (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL UNIQUE REFERENCES bodies(sequence),\n    evidence TEXT NOT NULL CHECK (evidence = 'killed'),\n    at TEXT NOT NULL\n  ) STRICT;\n";
+export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 14)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 14);\n  CREATE TABLE IF NOT EXISTS soul (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS bodies (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    leash_taken_at TEXT NOT NULL,\n    hung_diagnostic TEXT,\n    hung_at TEXT,\n    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),\n    ended_at TEXT,\n    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL) OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL AND end IS NULL))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS sessions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    provider TEXT NOT NULL,\n    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),\n    cwd TEXT NOT NULL,\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    admitted_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS turns (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    started_at TEXT NOT NULL,\n    end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,\n    outcome TEXT CHECK (outcome IN ('answered', 'failed')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    diagnostic TEXT,\n    completed_at TEXT,\n    CHECK (\n      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NULL AND completed_at IS NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS timeline (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS calls (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    event_json TEXT NOT NULL CHECK (json_valid(event_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tells (\n    id TEXT PRIMARY KEY,\n    sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_deliveries (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    route TEXT NOT NULL CHECK (route IN ('launch', 'live')),\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT NOT NULL,\n    receipt TEXT CHECK (receipt IN ('unavailable', 'required')),\n    delivered_at TEXT NOT NULL,\n    CHECK ((route = 'launch' AND receipt IS NULL) OR (route = 'live' AND receipt IS NOT NULL)),\n    UNIQUE (tell_id, turn_sequence, fence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_receipts (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    evidence TEXT NOT NULL CHECK (evidence IN ('exact', 'fence')),\n    tell_id TEXT REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT,\n    kind TEXT NOT NULL,\n    received_at TEXT NOT NULL,\n    CHECK (\n      (evidence = 'exact' AND tell_id IS NOT NULL AND turn_sequence IS NULL AND fence IS NULL)\n      OR (evidence = 'fence' AND tell_id IS NULL AND turn_sequence IS NOT NULL AND fence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_exact\n    ON tell_receipts(tell_id, kind) WHERE evidence = 'exact';\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind) WHERE evidence = 'fence';\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    archetype TEXT NOT NULL,\n    body TEXT NOT NULL,\n    cwd TEXT,\n    world TEXT NOT NULL,\n    recipe_json TEXT NOT NULL CHECK (json_valid(recipe_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),\n    child TEXT,\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state IN ('reserved', 'served') AND child IS NOT NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS control (\n    kind TEXT PRIMARY KEY CHECK (kind IN ('stop', 'pause')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS kills (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL UNIQUE REFERENCES bodies(sequence),\n    evidence TEXT NOT NULL CHECK (evidence = 'killed'),\n    at TEXT NOT NULL\n  ) STRICT;\n";
 export declare const LEASH_SCHEMA = "\n  PRAGMA journal_mode=DELETE;\n  CREATE TABLE IF NOT EXISTS leash_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 4)\n  ) STRICT;\n  INSERT OR IGNORE INTO leash_schema(singleton, version) VALUES (1, 4);\n  CREATE TABLE IF NOT EXISTS seal (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    evidence TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n";

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

@@ -1,4 +1,4 @@
-const HEART_SCHEMA_VERSION = 10;
+const HEART_SCHEMA_VERSION = 14;
 const LEASH_SCHEMA_VERSION = 4;
 function assertSchemaVersion(database, table, expected) {
     const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
@@ -19,24 +19,16 @@ export const HEART_SCHEMA = `
   INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, ${HEART_SCHEMA_VERSION});
   CREATE TABLE IF NOT EXISTS soul (
     singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-    id TEXT NOT NULL UNIQUE,
-    archetype TEXT NOT NULL,
-    description TEXT,
-    provider_json TEXT NOT NULL CHECK (json_valid(provider_json)),
-    options_json TEXT NOT NULL CHECK (json_valid(options_json)),
-    cwd TEXT NOT NULL,
-    origin_json TEXT NOT NULL CHECK (json_valid(origin_json)),
-    confinement_json TEXT NOT NULL CHECK (json_valid(confinement_json)),
-    created_at TEXT NOT NULL
+    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))
   ) STRICT;
   CREATE TABLE IF NOT EXISTS bodies (
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
-    pid INTEGER NOT NULL CHECK (pid > 0),
-    process_group INTEGER NOT NULL CHECK (process_group > 0),
-    spawned_at TEXT NOT NULL,
     leash_taken_at TEXT NOT NULL,
+    hung_diagnostic TEXT,
+    hung_at TEXT,
     end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),
-    ended_at TEXT
+    ended_at TEXT,
+    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL) OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL AND end IS NULL))
   ) STRICT;
   CREATE TABLE IF NOT EXISTS sessions (
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -58,7 +50,7 @@ export const HEART_SCHEMA = `
     diagnostic TEXT,
     completed_at TEXT,
     CHECK (
-      (outcome = 'answered' AND history_id IS NOT NULL AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)
+      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)
       OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NOT NULL)
       OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NULL AND completed_at IS NULL)
     )

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

@@ -0,0 +1,8 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { Soul, SoulRow } from "./facts.js";
+export declare function decodeSoul(value: unknown): Soul;
+export declare function encodeSoul(soul: Soul): string;
+export declare function encodeSoulRow(soul: Soul): readonly [string];
+export declare function decodeSoulRow(row: SoulRow): Soul;
+export declare function soulFact(database: DatabaseSync): Soul | null;
+export declare function insertSoulFact(database: DatabaseSync, soul: Soul): void;

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

@@ -0,0 +1,136 @@
+import { parseAkuId } from "../identity.js";
+import { decodeProviderOptions, decodeProviderRecipe, decodeReadonlyRestraint, } from "../provider-recipe.js";
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function unknownKey(value, allowed) {
+    return Object.keys(value).find((key) => !allowed.includes(key));
+}
+function nonblank(value, what) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Akuma soul ${what} must be a nonblank string`);
+    }
+    return value;
+}
+function soulAkuIdentity(value, what) {
+    try {
+        return parseAkuId(nonblank(value, what));
+    }
+    catch (error) {
+        throw new Error(`Akuma soul ${what} is not an Akuma identity coordinate`, { cause: error });
+    }
+}
+function decodeOrigin(value) {
+    const origin = record(value);
+    if (origin === null)
+        throw new Error("Akuma soul origin must be an object");
+    if (origin.kind === "direct") {
+        if (unknownKey(origin, ["kind"]) !== undefined)
+            throw new Error("Akuma soul direct origin must have only kind");
+        return { kind: "direct" };
+    }
+    if (origin.kind === "request") {
+        if (unknownKey(origin, ["kind", "parent", "requestId"]) !== undefined) {
+            throw new Error("Akuma soul request origin must have only kind, parent, and requestId");
+        }
+        return {
+            kind: "request",
+            parent: soulAkuIdentity(origin.parent, "request parent").id,
+            requestId: nonblank(origin.requestId, "request requestId"),
+        };
+    }
+    if (origin.kind === "fork") {
+        if (unknownKey(origin, ["at", "kind", "parent"]) !== undefined) {
+            throw new Error("Akuma soul fork origin must have only kind, parent, and at");
+        }
+        return {
+            kind: "fork",
+            parent: soulAkuIdentity(origin.parent, "fork parent").id,
+            at: nonblank(origin.at, "fork at"),
+        };
+    }
+    throw new Error("Akuma soul origin must be direct, request, or fork");
+}
+function decodeConfinement(value) {
+    const confinement = record(value);
+    if (confinement === null)
+        throw new Error("Akuma soul confinement must be an object");
+    if (confinement.kind === "unconfined") {
+        if (unknownKey(confinement, ["kind"]) !== undefined)
+            throw new Error("Akuma soul unconfined confinement must have only kind");
+        return { kind: "unconfined" };
+    }
+    if (confinement.kind === "declared") {
+        if (unknownKey(confinement, ["kind", "writableRoots"]) !== undefined) {
+            throw new Error("Akuma soul declared confinement must have only kind and writableRoots");
+        }
+        if (!Array.isArray(confinement.writableRoots)
+            || confinement.writableRoots.some((root) => typeof root !== "string" || root.trim().length === 0)) {
+            throw new Error("Akuma soul declared confinement writableRoots must be nonblank strings");
+        }
+        return { kind: "declared", writableRoots: [...confinement.writableRoots] };
+    }
+    throw new Error("Akuma soul confinement must be unconfined or declared");
+}
+function validateSoul(value) {
+    const soul = record(value);
+    if (soul === null)
+        throw new Error("Akuma soul must be an object");
+    if (unknownKey(soul, ["archetype", "confinement", "createdAt", "cwd", "description", "id", "options", "origin", "provider", "readonly"]) !== undefined) {
+        throw new Error("Akuma soul has an unknown field");
+    }
+    const identity = soulAkuIdentity(soul.id, "id");
+    const id = identity.id;
+    const archetype = nonblank(soul.archetype, "name");
+    if (identity.archetype !== archetype)
+        throw new Error("Akuma soul id and name must agree");
+    const description = soul.description === undefined ? undefined : nonblank(soul.description, "description");
+    const provider = decodeProviderRecipe(soul.provider);
+    const options = decodeProviderOptions(soul.options);
+    const restraint = soul.readonly === undefined ? undefined : decodeReadonlyRestraint(soul.readonly);
+    if ((options.readonly === true) !== (restraint !== undefined)) {
+        throw new Error("Akuma soul readonly option and restraint must agree");
+    }
+    return {
+        id,
+        archetype,
+        ...(description === undefined ? {} : { description }),
+        provider,
+        options,
+        ...(restraint === undefined ? {} : { readonly: restraint }),
+        cwd: nonblank(soul.cwd, "cwd"),
+        origin: decodeOrigin(soul.origin),
+        confinement: decodeConfinement(soul.confinement),
+        createdAt: nonblank(soul.createdAt, "createdAt"),
+    };
+}
+function deepFreeze(value) {
+    if (value !== null && typeof value === "object") {
+        for (const key of Object.keys(value)) {
+            deepFreeze(value[key]);
+        }
+        Object.freeze(value);
+    }
+    return value;
+}
+export function decodeSoul(value) {
+    return deepFreeze(validateSoul(value));
+}
+export function encodeSoul(soul) {
+    return JSON.stringify(validateSoul(soul));
+}
+export function encodeSoulRow(soul) {
+    return [encodeSoul(soul)];
+}
+export function decodeSoulRow(row) {
+    return decodeSoul(JSON.parse(row.soul_json));
+}
+export function soulFact(database) {
+    const row = database.prepare("SELECT soul_json FROM soul WHERE singleton = 1").get();
+    return row === undefined ? null : decodeSoulRow(row);
+}
+export function insertSoulFact(database, soul) {
+    database.prepare("INSERT INTO soul(singleton, soul_json) VALUES (1, ?)").run(...encodeSoulRow(soul));
+}

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

@@ -1,33 +1,47 @@
 import { DatabaseSync } from "node:sqlite";
 import type { AkumaPaths } from "../identity.js";
-import type { LeashProbe, SessionFact, Soul, StopFact, TellFact } from "./facts.js";
+import type { BodyFact, LeashProbe, SessionFact, Soul, StopFact, TellFact } from "./facts.js";
 import { sealFact } from "./rows.js";
-export declare function openHeart(path: string, verify?: boolean): DatabaseSync;
-export declare function withHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T): T;
+export declare class HeartAbsentError extends Error {
+    readonly path: string;
+    constructor(path: string, options?: ErrorOptions);
+}
+export declare function isHeartAbsent(error: unknown): error is HeartAbsentError;
+export declare function withHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T): Promise<T>;
 export declare function transaction<T>(database: DatabaseSync, body: () => T): T;
-export declare function initializeHeart(paths: AkumaPaths): void;
+export declare function initializeHeart(paths: AkumaPaths): Promise<void>;
 export declare class HeldAkumaLeash {
     private readonly database;
     private closed;
+    private bodySequence;
     private constructor();
-    static try(paths: AkumaPaths): HeldAkumaLeash | null;
-    birth(paths: AkumaPaths, soul: Soul, session?: Omit<SessionFact, "sequence">): "born" | "already-born" | "sealed";
+    static try(paths: AkumaPaths): Promise<HeldAkumaLeash | null>;
+    birth(paths: AkumaPaths, soul: Soul, session?: Omit<SessionFact, "sequence">): Promise<"born" | "already-born" | "sealed">;
     sealIfUnborn(paths: AkumaPaths, input: Readonly<{
         evidence: string;
         at: string;
-    }>): "born" | "sealed";
-    clearPause(paths: AkumaPaths): void;
-    settleStop(paths: AkumaPaths, expectedBodySequence?: number): Readonly<{
+    }>): Promise<"born" | "sealed">;
+    clearPause(paths: AkumaPaths): Promise<void>;
+    clearStop(paths: AkumaPaths): Promise<void>;
+    recordBody(paths: AkumaPaths, input: Readonly<{
+        leashTakenAt: string;
+    }>): Promise<BodyFact>;
+    recordBodyHung(paths: AkumaPaths, input: Readonly<{
+        sequence: number;
+        diagnostic: string;
+        at: string;
+    }>): Promise<void>;
+    settleStop(paths: AkumaPaths, expectedBodySequence?: number): Promise<Readonly<{
         target: StopFact;
         result: "recorded" | "already-killed";
-    }> | null;
-    recordInterruptTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Readonly<{
+    }> | null>;
+    recordInterruptTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Promise<Readonly<{
         kind: "not-born";
     } | {
         kind: "recorded";
         tell: TellFact;
-    }>;
+    }>>;
     release(): void;
 }
-export declare function probeLeash(paths: AkumaPaths): LeashProbe;
-export declare function readSealFromLeash(paths: AkumaPaths): ReturnType<typeof sealFact>;
+export declare function probeLeash(paths: AkumaPaths): Promise<LeashProbe>;
+export declare function readSealFromLeash(paths: AkumaPaths): Promise<ReturnType<typeof sealFact>>;