@astrosheep/keiyaku 2.9.12 → 4.0.0

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

@@ -0,0 +1,319 @@
+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 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, json(session.coordinate), session.cwd, json(session.options), session.admittedAt];
+}
+export function encodeResumeCoordinate(coordinate) {
+    return json(coordinate);
+}
+export function decodeSessionRow(row) {
+    return {
+        sequence: row.sequence,
+        provider: row.provider,
+        coordinate: parsed(row.coordinate_json),
+        cwd: row.cwd,
+        options: parsed(row.options_json),
+        admittedAt: row.admitted_at,
+    };
+}
+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.end === null ? {} : { end: row.end }),
+        ...(row.ended_at === null ? {} : { endedAt: row.ended_at }),
+    };
+}
+export function decodeTurnRow(row) {
+    return {
+        sequence: row.sequence,
+        bodySequence: row.body_sequence,
+        outcome: row.outcome === "answered"
+            ? {
+                kind: "answered",
+                historyId: row.history_id,
+                session: parsed(row.session_json),
+                answer: row.answer,
+            }
+            : { kind: "failed", diagnostic: row.diagnostic },
+        completedAt: row.completed_at,
+    };
+}
+export function decodeTellRow(row) {
+    return { id: row.id, body: row.body, state: row.state, recordedAt: row.recorded_at };
+}
+export function decodeRequestRow(row) {
+    const input = {
+        id: row.id,
+        archetype: row.archetype,
+        body: row.body,
+        ...(row.cwd === null ? {} : { cwd: row.cwd }),
+        world: row.world,
+        recipe: parsed(row.recipe_json),
+        admittedAt: row.admitted_at,
+    };
+    if (row.state === "reserved" || row.state === "served") {
+        return { ...input, state: row.state, child: row.child };
+    }
+    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);
+}
+export function decodeActivityRow(row) {
+    return {
+        sequence: row.sequence,
+        bodySequence: row.body_sequence,
+        event: parsed(row.event_json),
+        at: row.at,
+    };
+}
+export function encodeDeathRow(death) {
+    return json({ evidence: death.evidence });
+}
+export function decodeDeathRow(row) {
+    return { evidence: parsed(row.value_json).evidence, 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);
+}
+export function deletePauseControl(database) {
+    database.prepare("DELETE FROM control WHERE kind = 'pause'").run();
+}
+export function sealFact(database) {
+    const row = database.prepare("SELECT evidence, at FROM seal WHERE singleton = 1").get();
+    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);
+    return Number(result.lastInsertRowid);
+}
+export function insertSessionFact(database, input) {
+    const result = database.prepare(`INSERT INTO sessions(provider, coordinate_json, cwd, options_json, admitted_at)
+    VALUES (?, ?, ?, ?, ?)`).run(...encodeSessionRow(input));
+    return Number(result.lastInsertRowid);
+}
+export function insertActivityFact(database, input) {
+    const result = database.prepare("INSERT INTO activity(body_sequence, event_json, at) VALUES (?, ?, ?)")
+        .run(input.bodySequence, encodeActivityEvent(input.event), input.at);
+    return Number(result.lastInsertRowid);
+}
+export function pruneActivityFacts(database, limit) {
+    database.prepare(`DELETE FROM activity
+    WHERE sequence NOT IN (SELECT sequence FROM activity ORDER BY sequence DESC LIMIT ?)`)
+        .run(limit);
+}
+export function activityFactSlice(database, input) {
+    const bounds = database.prepare("SELECT MIN(sequence) AS lowest, MAX(sequence) AS highest FROM activity")
+        .get();
+    let rows;
+    if (input.before !== undefined) {
+        rows = database.prepare(`SELECT sequence, body_sequence, event_json, at FROM (
+      SELECT sequence, body_sequence, event_json, at FROM activity
+      WHERE sequence < ? ORDER BY sequence DESC LIMIT ?
+    ) ORDER BY sequence`).all(input.before, input.limit);
+    }
+    else if (input.since !== undefined) {
+        rows = database.prepare(`SELECT sequence, body_sequence, event_json, at FROM activity
+      WHERE sequence > ? ORDER BY sequence LIMIT ?`).all(input.since, input.limit);
+    }
+    else {
+        rows = database.prepare(`SELECT sequence, body_sequence, event_json, at FROM (
+      SELECT sequence, body_sequence, event_json, at FROM activity ORDER BY sequence DESC LIMIT ?
+    ) ORDER BY sequence`).all(input.limit);
+    }
+    return {
+        rows: rows.map(decodeActivityRow),
+        lowestRetained: bounds.lowest,
+        highest: bounds.highest,
+    };
+}
+export function deathExists(database) {
+    return database.prepare("SELECT kind FROM control WHERE kind = 'death'").get() !== undefined;
+}
+export function insertTellFact(database, tell) {
+    database.prepare(`INSERT INTO tells(id, body, state, recorded_at)
+    VALUES (?, ?, 'recorded', ?)`).run(tell.id, tell.body, tell.recordedAt);
+}
+export function tellState(database, id) {
+    const row = database.prepare("SELECT state FROM tells WHERE id = ?").get(id);
+    return row?.state ?? null;
+}
+export function updateTellState(database, id, state) {
+    database.prepare("UPDATE tells SET state = ? WHERE id = ?").run(state, id);
+}
+const REQUEST_COLUMNS = `sequence, id, archetype, body, cwd, world, recipe_json, admitted_at,
+  state, child, diagnostic, evidence`;
+export function insertRequestFact(database, input) {
+    database.prepare(`INSERT OR IGNORE INTO requests(id, archetype, body, cwd, world, recipe_json, admitted_at, state)
+    VALUES (?, ?, ?, ?, ?, ?, ?, 'admitted')`).run(input.id, input.archetype, input.body, input.cwd ?? null, input.world, json(input.recipe), input.admittedAt);
+}
+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 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, evidence = ?
+    WHERE id = ? AND state IN ('admitted', 'reserved')`).run(evidence, id);
+}
+export function insertStopControl(database, at) {
+    database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('stop', '{}', ?)").run(at);
+}
+export function insertPauseControl(database, at) {
+    database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('pause', '{}', ?)").run(at);
+}
+export function stopExists(database) {
+    return database.prepare("SELECT kind FROM control WHERE kind = 'stop'").get() !== undefined;
+}
+export function pauseExists(database) {
+    return database.prepare("SELECT kind FROM control WHERE kind = 'pause'").get() !== undefined;
+}
+export function deleteAbandonedControls(database) {
+    database.prepare("DELETE FROM control WHERE kind IN ('stop', 'pause')").run();
+}
+export function insertDeathFact(database, death) {
+    database.prepare("INSERT INTO control(kind, value_json, at) VALUES ('death', ?, ?)")
+        .run(encodeDeathRow(death), death.at);
+}
+export function voidTellsByDeath(database) {
+    database.prepare("UPDATE tells SET state = 'voided-by-death' WHERE state NOT IN ('consumed', 'voided-by-death')").run();
+}
+export function voidRequestsByDeath(database, evidence) {
+    database.prepare(`UPDATE requests SET state = 'voided',
+    evidence = CASE WHEN child IS NULL THEN ? ELSE ? || '; child=' || child END,
+    child = NULL
+    WHERE state IN ('admitted', 'reserved')`).run(evidence, evidence);
+}
+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 insertAnsweredTurnFact(database, input) {
+    const result = database.prepare(`INSERT INTO turns(body_sequence, outcome, history_id, session_json, answer, completed_at)
+    VALUES (?, 'answered', ?, ?, ?, ?)`).run(input.bodySequence, input.outcome.historyId, encodeResumeCoordinate(input.outcome.session), input.outcome.answer, input.completedAt);
+    return Number(result.lastInsertRowid);
+}
+export function insertFailedTurnFact(database, input) {
+    const result = database.prepare(`INSERT INTO turns(body_sequence, outcome, diagnostic, completed_at)
+    VALUES (?, 'failed', ?, ?)`).run(input.bodySequence, input.outcome.diagnostic, input.completedAt);
+    return Number(result.lastInsertRowid);
+}
+export function finishBodyFact(database, input) {
+    database.prepare("UPDATE bodies SET end = 'exited', ended_at = ? WHERE sequence = ? AND end IS NULL")
+        .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
+    FROM bodies ORDER BY sequence DESC LIMIT 1`).get();
+    return row === undefined ? null : decodeBodyRow(row);
+}
+export function latestSessionFact(database) {
+    const row = database.prepare(`SELECT sequence, provider, coordinate_json, cwd, options_json, admitted_at
+    FROM sessions ORDER BY sequence DESC LIMIT 1`).get();
+    return row === undefined ? null : decodeSessionRow(row);
+}
+export function sessionFactForCoordinate(database, coordinate) {
+    const row = database.prepare(`SELECT sequence, provider, coordinate_json, cwd, options_json, admitted_at
+    FROM sessions WHERE coordinate_json = ? ORDER BY sequence DESC LIMIT 1`)
+        .get(encodeResumeCoordinate(coordinate));
+    return row === undefined ? null : decodeSessionRow(row);
+}
+export function pendingTellFacts(database) {
+    const rows = database.prepare(`SELECT id, body, state, recorded_at FROM tells
+    WHERE state NOT IN ('consumed', 'voided-by-death') ORDER BY recorded_at, id`)
+        .all();
+    return rows.map(decodeTellRow);
+}
+export function deathFact(database) {
+    const row = database.prepare("SELECT value_json, at FROM control WHERE kind = 'death'").get();
+    return row === undefined ? null : decodeDeathRow(row);
+}
+export function historyFacts(database) {
+    const rows = database.prepare(`SELECT sequence, body_sequence, outcome, history_id, session_json,
+    answer, diagnostic, completed_at FROM turns ORDER BY sequence`).all();
+    return rows.map(decodeTurnRow);
+}
+export function lastAnsweredTurnFact(database) {
+    const row = database.prepare(`SELECT sequence, body_sequence, outcome, history_id, session_json,
+    answer, diagnostic, completed_at FROM turns WHERE outcome = 'answered' ORDER BY sequence DESC LIMIT 1`)
+        .get();
+    return row === undefined ? null : decodeTurnRow(row);
+}
+export function latestTurnFact(database) {
+    const row = database.prepare(`SELECT sequence, body_sequence, outcome, history_id, session_json,
+    answer, diagnostic, completed_at FROM turns ORDER BY sequence DESC LIMIT 1`).get();
+    return row === undefined ? null : decodeTurnRow(row);
+}
+export function answeredTurnFact(database, historyId) {
+    const row = database.prepare(`SELECT sequence, body_sequence, outcome, history_id, session_json,
+    answer, diagnostic, completed_at FROM turns WHERE outcome = 'answered' AND history_id = ?`).get(historyId);
+    return row === undefined ? null : decodeTurnRow(row);
+}

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

@@ -0,0 +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 = 6)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 6);\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 AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    outcome TEXT NOT NULL 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 NOT NULL,\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    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\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    body TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('recorded', 'delivered', 'seen', 'consumed', 'voided-by-death')),\n    recorded_at TEXT NOT NULL\n  ) STRICT;\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', 'death')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\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

@@ -0,0 +1,113 @@
+const HEART_SCHEMA_VERSION = 6;
+const LEASH_SCHEMA_VERSION = 4;
+function assertSchemaVersion(database, table, expected) {
+    const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
+    if (row?.version !== expected)
+        throw new Error(`Akuma ${table === "akuma_schema" ? "heart" : "leash"} schema version must be ${expected}`);
+}
+export function assertHeartSchemaVersion(database) {
+    assertSchemaVersion(database, "akuma_schema", HEART_SCHEMA_VERSION);
+}
+export function assertLeashSchemaVersion(database) {
+    assertSchemaVersion(database, "leash_schema", LEASH_SCHEMA_VERSION);
+}
+export const HEART_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS akuma_schema (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    version INTEGER NOT NULL CHECK (version = ${HEART_SCHEMA_VERSION})
+  ) STRICT;
+  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
+  ) 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,
+    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),
+    ended_at TEXT
+  ) STRICT;
+  CREATE TABLE IF NOT EXISTS sessions (
+    sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+    provider TEXT NOT NULL,
+    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),
+    cwd TEXT NOT NULL,
+    options_json TEXT NOT NULL CHECK (json_valid(options_json)),
+    admitted_at TEXT NOT NULL
+  ) STRICT;
+  CREATE TABLE IF NOT EXISTS turns (
+    sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),
+    outcome TEXT NOT NULL CHECK (outcome IN ('answered', 'failed')),
+    history_id TEXT UNIQUE,
+    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),
+    answer TEXT,
+    diagnostic TEXT,
+    completed_at TEXT NOT NULL,
+    CHECK (
+      (outcome = 'answered' AND history_id IS NOT NULL 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)
+    )
+  ) STRICT;
+  CREATE TABLE IF NOT EXISTS activity (
+    sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),
+    event_json TEXT NOT NULL CHECK (json_valid(event_json)),
+    at TEXT NOT NULL
+  ) STRICT;
+  CREATE TABLE IF NOT EXISTS tells (
+    id TEXT PRIMARY KEY,
+    body TEXT NOT NULL,
+    state TEXT NOT NULL CHECK (state IN ('recorded', 'delivered', 'seen', 'consumed', 'voided-by-death')),
+    recorded_at TEXT NOT NULL
+  ) STRICT;
+  CREATE TABLE IF NOT EXISTS requests (
+    sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+    id TEXT NOT NULL UNIQUE,
+    archetype TEXT NOT NULL,
+    body TEXT NOT NULL,
+    cwd TEXT,
+    world TEXT NOT NULL,
+    recipe_json TEXT NOT NULL CHECK (json_valid(recipe_json)),
+    admitted_at TEXT NOT NULL,
+    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),
+    child TEXT,
+    diagnostic TEXT,
+    evidence TEXT,
+    CHECK (
+      (state = 'admitted' AND child IS NULL AND diagnostic IS NULL AND evidence IS NULL)
+      OR (state IN ('reserved', 'served') AND child IS NOT NULL AND diagnostic IS NULL AND evidence IS NULL)
+      OR (state = 'refused' AND child IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)
+      OR (state = 'voided' AND child IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)
+    )
+  ) STRICT;
+  CREATE TABLE IF NOT EXISTS control (
+    kind TEXT PRIMARY KEY CHECK (kind IN ('stop', 'pause', 'death')),
+    value_json TEXT NOT NULL CHECK (json_valid(value_json)),
+    at TEXT NOT NULL
+  ) STRICT;
+`;
+export const LEASH_SCHEMA = `
+  PRAGMA journal_mode=DELETE;
+  CREATE TABLE IF NOT EXISTS leash_schema (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    version INTEGER NOT NULL CHECK (version = ${LEASH_SCHEMA_VERSION})
+  ) STRICT;
+  INSERT OR IGNORE INTO leash_schema(singleton, version) VALUES (1, ${LEASH_SCHEMA_VERSION});
+  CREATE TABLE IF NOT EXISTS seal (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    evidence TEXT NOT NULL,
+    at TEXT NOT NULL
+  ) STRICT;
+`;

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

@@ -0,0 +1,46 @@
+declare const AKU_ID: unique symbol;
+export type AkuId = string & {
+    readonly [AKU_ID]: true;
+};
+export type AkumaPaths = Readonly<{
+    directory: string;
+    heart: string;
+    leash: string;
+    log: string;
+}>;
+export type AllocatedAkuma = Readonly<{
+    id: AkuId;
+    archetype: string;
+    suffix: string;
+    paths: AkumaPaths;
+}>;
+export declare function archetypeName(value: string): string;
+export declare function akuId(input: Readonly<{
+    archetype: string;
+    suffix: string;
+}>): AkuId;
+export declare function parseAkuId(value: string): Readonly<{
+    id: AkuId;
+    archetype: string;
+    suffix: string;
+}>;
+export declare function akumaRunRoot(worldRoot: string): string;
+export declare function akumaPaths(input: Readonly<{
+    runRoot: string;
+    archetype: string;
+    suffix: string;
+}>): AkumaPaths;
+export declare function akuIdFromDirectoryName(name: string): Readonly<{
+    id: AkuId;
+    archetype: string;
+    suffix: string;
+}>;
+export declare function ensureAkumaRunRoot(worldRoot: string): string;
+export declare function allocateAkumaDirectory(input: Readonly<{
+    worldRoot: string;
+    archetype: string;
+    draw?: () => string;
+}>): AllocatedAkuma;
+export declare function pathsForAkuId(worldRoot: string, id: AkuId): AkumaPaths;
+export declare function worldRootForAkumaPaths(paths: AkumaPaths): string;
+export {};

package/build/src/akuma/identity.js

@@ -0,0 +1,89 @@
+import { randomBytes } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { identityCoordinate, identitySegments } from "../identity/coordinates.js";
+import { normalizeIdentityStem } from "../identity/normalize.js";
+const HEX8 = /^[0-9a-f]{8}$/u;
+export function archetypeName(value) {
+    if (value.length === 0 || normalizeIdentityStem({ source: value }) !== value) {
+        throw new TypeError("Akuma archetype must be one normalized human identity segment");
+    }
+    return value;
+}
+function suffixSegment(value) {
+    if (!HEX8.test(value))
+        throw new TypeError("Akuma suffix must be lower hex8");
+    return value;
+}
+export function akuId(input) {
+    return identityCoordinate({
+        family: "aku",
+        segments: [archetypeName(input.archetype), suffixSegment(input.suffix)],
+    });
+}
+export function parseAkuId(value) {
+    const segments = identitySegments({ family: "aku", value });
+    if (segments.length !== 2)
+        throw new TypeError("Akuma identity must be aku/<archetype>/<hex8>");
+    const archetype = archetypeName(segments[0]);
+    const suffix = suffixSegment(segments[1]);
+    return { id: akuId({ archetype, suffix }), archetype, suffix };
+}
+export function akumaRunRoot(worldRoot) {
+    return join(worldRoot, ".keiyaku", "akuma", "run");
+}
+export function akumaPaths(input) {
+    const directory = join(input.runRoot, `${archetypeName(input.archetype)}-${suffixSegment(input.suffix)}`);
+    return {
+        directory,
+        heart: join(directory, "heart.db"),
+        leash: join(directory, "leash.db"),
+        log: join(directory, "stdio.log"),
+    };
+}
+export function akuIdFromDirectoryName(name) {
+    if (name.length < 10 || name.at(-9) !== "-")
+        throw new Error(`invalid Akuma run directory ${name}`);
+    const archetype = name.slice(0, -9);
+    const suffix = name.slice(-8);
+    return { id: akuId({ archetype, suffix }), archetype, suffix };
+}
+export function ensureAkumaRunRoot(worldRoot) {
+    const runRoot = akumaRunRoot(worldRoot);
+    mkdirSync(runRoot, { recursive: true });
+    try {
+        writeFileSync(join(runRoot, ".gitignore"), "*\n", { flag: "wx" });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+    return runRoot;
+}
+export function allocateAkumaDirectory(input) {
+    const archetype = archetypeName(input.archetype);
+    const runRoot = ensureAkumaRunRoot(input.worldRoot);
+    for (;;) {
+        const suffix = suffixSegment(input.draw?.() ?? randomBytes(4).toString("hex"));
+        const paths = akumaPaths({ runRoot, archetype, suffix });
+        try {
+            mkdirSync(paths.directory);
+            return { id: akuId({ archetype, suffix }), archetype, suffix, paths };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+}
+export function pathsForAkuId(worldRoot, id) {
+    const parsed = parseAkuId(id);
+    return akumaPaths({ runRoot: akumaRunRoot(worldRoot), archetype: parsed.archetype, suffix: parsed.suffix });
+}
+export function worldRootForAkumaPaths(paths) {
+    const runRoot = dirname(paths.directory);
+    const worldRoot = dirname(dirname(dirname(runRoot)));
+    if (akumaRunRoot(worldRoot) !== runRoot)
+        throw new Error("Akuma paths are outside the run topology");
+    return worldRoot;
+}

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

@@ -0,0 +1,7 @@
+export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
+export { AkumaArchetypeError } from "./archetype.js";
+export { AkumaBodyRequestError } from "./requests.js";
+export type { AkumaList, AkumaListRow, AkumaStatus, ActivityHistory, ActivityRow, ActivitySnapshot, ForkReceipt, InterruptReceipt, TellReceipt, UnbornAkumaListRow, } from "./akuma.js";
+export type { AgentEvent, ToolCall, ToolEvent, ToolResult } from "./provider.js";
+export type { AkuId } from "./identity.js";
+export type { Confinement, KillEvidence, ProviderOptions, ResumeCoordinate, TurnFact, } from "./heart/index.js";

package/build/src/akuma/index.js

@@ -0,0 +1,3 @@
+export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
+export { AkumaArchetypeError } from "./archetype.js";
+export { AkumaBodyRequestError } from "./requests.js";