@astrosheep/keiyaku 4.5.18 → 4.5.19

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

@@ -1,10 +1,10 @@
 import { parsePublicHistoryId } from "../identity.js";
 import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, turnFact, } from "./rows.js";
-import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, resolveTellDispositionSnapshot, successorBodyHoldingDisposition, tellFact, tellIdsForFence, } from "./tells.js";
-import { activityFactSlice, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
-import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHeart, withReadOnlyHeart, } from "./storage.js";
+import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, hasPendingTell, resolveTellDispositionSnapshot, tellDispositionResolved, tellFact, tellIdsForFence, } from "./tells.js";
+import { activityFactSlice, statusFacts, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
+import { isHeartAbsent, readSealFromLeash, withHeartTransaction, withReadOnlyHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
-import { AkumaBusyError } from "./facts.js";
+import { AkumaBusyError, HeartAuthorityCorruptionError } from "./facts.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.js";
 export { AkumaBusyError, life, lifeAt, projectTell } from "./facts.js";
@@ -12,7 +12,7 @@ export { drainPendingTells } from "./tells.js";
 const ACTIVITY_LIMIT = 5_000;
 export async function readSoul(paths) {
     try {
-        return await withHeart(paths, soulFact);
+        return await withReadOnlyHeart(paths, soulFact);
     }
     catch (error) {
         if (isHeartAbsent(error))
@@ -22,7 +22,7 @@ export async function readSoul(paths) {
 }
 export async function heartExists(paths) {
     try {
-        return await withHeart(paths, () => true);
+        return await withReadOnlyHeart(paths, () => true);
     }
     catch (error) {
         if (isHeartAbsent(error))
@@ -41,23 +41,43 @@ export async function readSeal(paths) {
     }
 }
 export async function recordSession(paths, input) {
-    return await withHeart(paths, (heart) => ({ sequence: insertSessionFact(heart, input), ...input }));
+    return await withHeartTransaction(paths, (heart) => ({ sequence: insertSessionFact(heart, input), ...input }));
 }
 export async function appendActivity(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const sequence = insertActivityFact(heart, input);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return sequence;
-    }));
+    });
 }
 export async function activitySlice(paths) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => activityFactSlice(heart)));
+    return await withReadOnlyHeart(paths, (heart) => activityFactSlice(heart));
+}
+export async function readStatusFacts(paths, input) {
+    return await withReadOnlyHeart(paths, (heart) => statusFacts(heart, input));
+}
+/** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
+export async function readLifeSnapshot(paths) {
+    try {
+        return await withReadOnlyHeart(paths, (heart) => ({
+            soul: soulFact(heart),
+            latestBody: latestBodyFact(heart),
+            latestSession: latestSessionFact(heart),
+            latestKill: latestKillFact(heart),
+            hasPendingTell: hasPendingTell(heart),
+        }));
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return { soul: null, latestBody: null, latestSession: null, latestKill: null, hasPendingTell: false };
+        throw error;
+    }
 }
 function sameTellInput(existing, tell) {
     return (existing.body === tell.body && existing.recordedAt === tell.recordedAt && existing.schemaJson === tell.schemaJson);
 }
 export async function recordTell(paths, tell, options = {}) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         if (soulFact(heart) === null)
             return { kind: "not-born" };
         const existing = tellFact(heart, tell.id);
@@ -73,37 +93,40 @@ export async function recordTell(paths, tell, options = {}) {
         const sequence = insertTellFact(heart, tell);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
-    }));
+    });
 }
 export async function readTell(paths, id) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => tellFact(heart, id)));
+    return await withReadOnlyHeart(paths, (heart) => tellFact(heart, id));
 }
 export async function recordTellDeliveries(paths, inputs) {
-    await withHeart(paths, (heart) => transaction(heart, () => {
+    await withHeartTransaction(paths, (heart) => {
         for (const input of inputs) {
             const current = tellFact(heart, input.tellId);
             if (current === null)
                 throw new Error(`unknown tell ${input.tellId}`);
         }
+        let changed = false;
         for (const input of inputs)
-            insertTellDeliveryFact(heart, input);
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
-    }));
+            changed = insertTellDeliveryFact(heart, input) || changed;
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, changed);
+    });
 }
 export async function recordTellReceipt(paths, input) {
-    await withHeart(paths, (heart) => transaction(heart, () => {
+    await withHeartTransaction(paths, (heart) => {
         const tellIds = input.evidence === "exact" ? [input.tellId] : tellIdsForFence(heart, input.turnSequence, input.fence);
         if (tellIds.length === 0)
             throw new Error("tell receipt has no delivery mapping");
-        insertTellReceiptFact(heart, input);
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
-    }));
+        const changed = insertTellReceiptFact(heart, input);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, changed);
+    });
 }
 export async function decidePendingTellDisposition(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const body = latestBodyFact(heart);
         if (body === null || body.sequence !== input.bodySequence)
             return null;
+        if (tellDispositionResolved(heart, input.bodySequence) === true)
+            return null;
         const existing = openTellDispositionIds(heart, input.bodySequence);
         if (existing !== null)
             return { bodySequence: input.bodySequence, tellIds: existing };
@@ -122,46 +145,33 @@ export async function decidePendingTellDisposition(paths, input) {
         insertTellDispositionSnapshot(heart, input.bodySequence, tellIds, input.at);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return { bodySequence: input.bodySequence, tellIds };
-    }));
+    });
 }
 export async function readOpenPendingTellDisposition(paths) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => latestOpenTellDisposition(heart)));
-}
-export async function resolvePendingTellDisposition(paths, bodySequence, at) {
-    await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withReadOnlyHeart(paths, (heart) => latestOpenTellDisposition(heart));
+}
+/** Prove and consume the persisted decision in one transaction, never a caller's stale member list. */
+export async function resolvePendingTellDisposition(paths, bodySequence, at, outcome = "custody") {
+    return await withHeartTransaction(paths, (heart) => {
+        if (tellDispositionResolved(heart, bodySequence) === true)
+            return true;
+        const tellIds = openTellDispositionIds(heart, bodySequence);
+        if (tellIds === null)
+            throw new HeartAuthorityCorruptionError(`Akuma disposition ${bodySequence} is missing`);
+        if (outcome === "undelivered")
+            insertUndeliveredTellReceipts(heart, tellIds, at);
+        if (!dispositionSnapshotProven(heart, tellIds))
+            return false;
         resolveTellDispositionSnapshot(heart, bodySequence, at);
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
-    }));
-}
-/**
- * Heart-owned disposition custody proof. Sequence growth, spawn resolution, and
- * an unqualified held leash are never proof. Returns the successor Body sequence
- * when that exact Body took the frozen Tell-id snapshot by delivery, or true when
- * the snapshot is already fully settled (no longer pending).
- */
-export async function provePendingTellDispositionCustody(paths, disposition) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => {
-        if (!dispositionSnapshotProven(heart, disposition))
-            return { kind: "unproven" };
-        const successorBodySequence = successorBodyHoldingDisposition(heart, disposition);
-        return successorBodySequence === null
-            ? { kind: "proven" }
-            : { kind: "proven", successorBodySequence };
-    }));
-}
-export async function recordUndeliveredPendingTells(paths, at, tellIds) {
-    if (tellIds.length === 0)
-        return;
-    await withHeart(paths, (heart) => transaction(heart, () => {
-        insertUndeliveredTellReceipts(heart, tellIds, at);
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
-    }));
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, true);
+        return true;
+    });
 }
 export async function readKill(paths, bodySequence) {
-    return await withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
+    return await withReadOnlyHeart(paths, (heart) => killFactForBody(heart, bodySequence));
 }
-export async function requestStop(paths, at) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+export async function requestStop(paths, at, signal) {
+    return await withHeartTransaction(paths, (heart) => {
         const body = latestBodyFact(heart);
         if (body === null)
             throw new Error("Akuma has no Body to kill");
@@ -175,10 +185,10 @@ export async function requestStop(paths, at) {
         }
         insertStopControl(heart, body.sequence, at);
         return { kind: "requested", body };
-    }));
+    }, signal);
 }
-export async function requestPause(paths, at) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+export async function requestPause(paths, at, signal) {
+    return await withHeartTransaction(paths, (heart) => {
         if (soulFact(heart) === null)
             return { kind: "not-born" };
         const body = latestBodyFact(heart);
@@ -186,45 +196,45 @@ export async function requestPause(paths, at) {
             throw new Error("Akuma has no Body to interrupt");
         insertPauseControl(heart, at);
         return { kind: "requested", body };
-    }));
+    }, signal);
 }
 export async function stopRequested(paths, bodySequence) {
-    return await withHeart(paths, (heart) => {
+    return await withReadOnlyHeart(paths, (heart) => {
         const target = stopFact(heart);
         return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
     });
 }
 export async function pauseRequested(paths, bodySequence) {
-    return await withHeart(paths, (heart) => {
+    return await withReadOnlyHeart(paths, (heart) => {
         const target = pauseFact(heart);
         return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
     });
 }
 export async function breakBody(paths, input) {
-    await withHeart(paths, (heart) => endBodyFact(heart, input));
+    await withHeartTransaction(paths, (heart) => endBodyFact(heart, input));
 }
 export async function beginTurn(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const fact = insertTurnStartFact(heart, input);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return fact;
-    }));
+    });
 }
 export async function bindTellsToTurn(paths, input) {
-    await withHeart(paths, (heart) => transaction(heart, () => {
+    await withHeartTransaction(paths, (heart) => {
         for (const tellId of input.tellIds) {
             if (tellFact(heart, tellId) === null)
                 throw new Error(`unknown tell ${tellId}`);
             insertTellBindingFact(heart, { tellId, turnSequence: input.turnSequence, boundAt: input.boundAt });
         }
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
-    }));
+    });
 }
 export async function readOpenBoundTurns(paths, bodySequence) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => openBoundTurns(heart, bodySequence)));
+    return await withReadOnlyHeart(paths, (heart) => openBoundTurns(heart, bodySequence));
 }
 export async function failOpenBoundTurns(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const sequences = openBoundTurns(heart, input.bodySequence);
         for (const turnSequence of sequences) {
             insertTurnEndFact(heart, {
@@ -234,22 +244,22 @@ export async function failOpenBoundTurns(paths, input) {
                 completedAt: input.completedAt,
             });
         }
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, sequences.length > 0);
         return sequences;
-    }));
+    });
 }
 export async function readTurn(paths, sequence) {
-    return await withHeart(paths, (heart) => readTransaction(heart, () => turnFact(heart, sequence)));
+    return await withReadOnlyHeart(paths, (heart) => turnFact(heart, sequence));
 }
 export async function endTurn(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const fact = insertTurnEndFact(heart, { kind: "turn-end", ...input });
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, true);
         return fact;
-    }));
+    });
 }
 export async function finishBodyIfIdle(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         if (stopFact(heart)?.bodySequence === input.sequence || pauseFact(heart)?.bodySequence === input.sequence) {
             endBodyFact(heart, { ...input, end: "put-down" });
             return { kind: "controlled" };
@@ -259,11 +269,11 @@ export async function finishBodyIfIdle(paths, input) {
             return { kind: "pending", tells: pending.map((tell) => tell.id) };
         finishBodyFact(heart, input);
         return { kind: "finished" };
-    }));
+    });
 }
 export async function readHeart(paths) {
     try {
-        return await withReadOnlyHeart(paths, (heart) => readTransaction(heart, () => ({
+        return await withReadOnlyHeart(paths, (heart) => ({
             soul: soulFact(heart),
             latestBody: latestBodyFact(heart),
             latestSession: latestSessionFact(heart),
@@ -272,7 +282,7 @@ export async function readHeart(paths) {
             stop: stopFact(heart),
             pause: pauseFact(heart),
             lastActivityAt: readLastActivityAt(heart),
-        })));
+        }));
     }
     catch (error) {
         if (isHeartAbsent(error)) {
@@ -291,14 +301,14 @@ export async function readHeart(paths) {
     }
 }
 export async function readLastAnsweredTurn(paths) {
-    return await withHeart(paths, lastAnsweredTurnFact);
+    return await withReadOnlyHeart(paths, lastAnsweredTurnFact);
 }
 export async function readForkPoint(paths, historyId) {
     const turnSequence = parsePublicHistoryId(historyId);
     if (turnSequence === null)
         return null;
     try {
-        return await withHeart(paths, (heart) => {
+        return await withReadOnlyHeart(paths, (heart) => {
             const turn = answeredTurnFact(heart, turnSequence);
             const outcome = turn?.end?.outcome;
             if (outcome?.kind !== "answered" || outcome.historyId === undefined)

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

@@ -1,6 +1,6 @@
 import { parseAkuId } from "../identity.js";
 import { insertRequestFact, nonterminalRequestFacts, requestFact, updateRequestRefused, updateRequestBegun, updateRequestReserved, updateRequestServed, updateRequestUnproven, updateRequestVoided, updateUpstreamRequestServed, } from "./request-rows.js";
-import { transaction, withHeart } from "./storage.js";
+import { withHeartTransaction, withReadOnlyHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
 import { requestPayloadJson } from "./request-rows.js";
 // This stays out of the public Heart index: only transport service projects it as a refusal.
@@ -14,7 +14,7 @@ export function isRequestInputConflict(error) {
     return error instanceof RequestInputConflictError;
 }
 export async function admitRequest(paths, input) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const soul = soulFact(heart);
         if (soul === null)
             throw new Error("Akuma request admission requires a born Soul");
@@ -34,10 +34,10 @@ export async function admitRequest(paths, input) {
             throw new RequestInputConflictError(input.id);
         }
         return fact;
-    }));
+    });
 }
 export async function reserveRequest(paths, id, child) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -49,13 +49,13 @@ export async function reserveRequest(paths, id, child) {
             throw new Error(`Akuma request ${id} cannot reserve ${child}`);
         }
         return requestFact(heart, id);
-    }));
+    });
 }
 export async function serveRequest(paths, id, child) {
     const parsed = parseAkuId(child);
     if (parsed.id !== child)
         throw new Error(`Akuma request ${id} has a noncanonical child`);
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -65,10 +65,10 @@ export async function serveRequest(paths, id, child) {
             throw new Error(`Akuma request ${id} cannot serve ${child}`);
         }
         return requestFact(heart, id);
-    }));
+    });
 }
 export async function serveUpstreamRequest(paths, id, serviceJson) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -78,10 +78,10 @@ export async function serveUpstreamRequest(paths, id, serviceJson) {
             throw new Error(`Akuma request ${id} cannot be served with this service reference`);
         }
         return requestFact(heart, id);
-    }));
+    });
 }
 export async function refuseRequest(paths, id, diagnostic) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -91,10 +91,10 @@ export async function refuseRequest(paths, id, 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, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -105,10 +105,10 @@ export async function voidRequest(paths, id, evidence) {
             throw new Error(`Akuma request ${id} cannot be voided`);
         }
         return requestFact(heart, id);
-    }));
+    });
 }
 export async function beginRequest(paths, id) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -117,10 +117,10 @@ export async function beginRequest(paths, id) {
         else if (before.state !== "begun")
             throw new Error(`Akuma request ${id} cannot begin`);
         return requestFact(heart, id);
-    }));
+    });
 }
 export async function unproveRequest(paths, id, evidence) {
-    return await withHeart(paths, (heart) => transaction(heart, () => {
+    return await withHeartTransaction(paths, (heart) => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -130,11 +130,11 @@ export async function unproveRequest(paths, id, evidence) {
             throw new Error(`Akuma request ${id} cannot be marked unproven`);
         }
         return requestFact(heart, id);
-    }));
+    });
 }
 export async function readRequest(paths, id) {
-    return await withHeart(paths, (heart) => requestFact(heart, id));
+    return await withReadOnlyHeart(paths, (heart) => requestFact(heart, id));
 }
 export async function readNonterminalRequests(paths) {
-    return await withHeart(paths, nonterminalRequestFacts);
+    return await withReadOnlyHeart(paths, nonterminalRequestFacts);
 }

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

@@ -2,5 +2,5 @@ import type { DatabaseSync } from "node:sqlite";
 export declare function assertHeartSchemaVersion(database: DatabaseSync): void;
 export declare function assertLeashSchemaVersion(database: DatabaseSync): void;
 export declare function heartSchemaIsCurrent(database: DatabaseSync): boolean;
-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 = 25)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 25);\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)\n      OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT 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', 'invalid-output')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    answer_json TEXT CHECK (answer_json IS NULL OR json_valid(answer_json)),\n    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),\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        AND ((schema_json IS NULL AND answer_json IS NULL) OR (schema_json IS NOT NULL AND answer_json IS NOT NULL)))\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL\n        AND answer_json IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome = 'invalid-output' AND answer IS NOT NULL AND answer_json IS NULL\n        AND diagnostic IS NOT NULL AND schema_json IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL\n        AND answer IS NULL AND answer_json 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    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_bindings (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    bound_at TEXT NOT NULL,\n    UNIQUE (tell_id, turn_sequence)\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 tell_dispositions (\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    tell_id TEXT NOT NULL REFERENCES tells(id),\n    decided_at TEXT NOT NULL,\n    resolved_at TEXT,\n    PRIMARY KEY (body_sequence, tell_id)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    requester TEXT NOT NULL,\n    action TEXT NOT NULL,\n    payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'begun', 'served', 'refused', 'voided', 'unproven')),\n    child TEXT,\n    service_json TEXT CHECK (service_json IS NULL OR json_valid(service_json)),\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'reserved' AND child IS NOT NULL AND service_json IS NULL\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'begun' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'served'\n        AND ((child IS NOT NULL AND service_json IS NULL)\n          OR (child IS NULL AND service_json IS NOT NULL))\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND service_json IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n      OR (state = 'unproven' AND child IS NULL AND service_json 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 = 28)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 28);\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)\n      OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT 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', 'invalid-output')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    answer_json TEXT CHECK (answer_json IS NULL OR json_valid(answer_json)),\n    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),\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        AND ((schema_json IS NULL AND answer_json IS NULL) OR (schema_json IS NOT NULL AND answer_json IS NOT NULL)))\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL\n        AND answer_json IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome = 'invalid-output' AND answer IS NOT NULL AND answer_json IS NULL\n        AND diagnostic IS NOT NULL AND schema_json IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL\n        AND answer IS NULL AND answer_json 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 activity_retention (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    checked_sequence INTEGER NOT NULL\n  ) STRICT;\n  INSERT OR IGNORE INTO activity_retention(singleton, checked_sequence) VALUES (1, 0);\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    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_bindings (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    bound_at TEXT NOT NULL,\n    UNIQUE (tell_id, turn_sequence)\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);\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind);\n  CREATE TABLE IF NOT EXISTS tell_dispositions (\n    body_sequence INTEGER PRIMARY KEY REFERENCES bodies(sequence),\n    decided_at TEXT NOT NULL,\n    resolved_at TEXT\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_disposition_members (\n    body_sequence INTEGER NOT NULL REFERENCES tell_dispositions(body_sequence) ON DELETE CASCADE,\n    tell_id TEXT NOT NULL REFERENCES tells(id),\n    PRIMARY KEY (body_sequence, tell_id)\n  ) STRICT;\n  CREATE INDEX IF NOT EXISTS calls_by_turn ON calls(turn_sequence);\n  CREATE INDEX IF NOT EXISTS activity_by_turn ON activity(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_bindings_by_turn ON tell_bindings(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_deliveries_by_turn ON tell_deliveries(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_disposition_members_by_tell ON tell_disposition_members(tell_id);\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    requester TEXT NOT NULL,\n    action TEXT NOT NULL,\n    payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'begun', 'served', 'refused', 'voided', 'unproven')),\n    child TEXT,\n    service_json TEXT CHECK (service_json IS NULL OR json_valid(service_json)),\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'reserved' AND child IS NOT NULL AND service_json IS NULL\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'begun' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'served'\n        AND ((child IS NOT NULL AND service_json IS NULL)\n          OR (child IS NULL AND service_json IS NOT NULL))\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND service_json IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n      OR (state = 'unproven' AND child IS NULL AND service_json 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 = 25;
+const HEART_SCHEMA_VERSION = 28;
 const LEASH_SCHEMA_VERSION = 4;
 function assertSchemaVersion(database, table, expected) {
     const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
@@ -76,6 +76,11 @@ export const HEART_SCHEMA = `
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
     kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))
   ) STRICT;
+  CREATE TABLE IF NOT EXISTS activity_retention (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    checked_sequence INTEGER NOT NULL
+  ) STRICT;
+  INSERT OR IGNORE INTO activity_retention(singleton, checked_sequence) VALUES (1, 0);
   CREATE TABLE IF NOT EXISTS calls (
     sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,
     turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,
@@ -127,16 +132,24 @@ export const HEART_SCHEMA = `
     )
   ) STRICT;
   CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_exact
-    ON tell_receipts(tell_id, kind) WHERE evidence = 'exact';
+    ON tell_receipts(tell_id, kind);
   CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence
-    ON tell_receipts(turn_sequence, fence, kind) WHERE evidence = 'fence';
+    ON tell_receipts(turn_sequence, fence, kind);
   CREATE TABLE IF NOT EXISTS tell_dispositions (
-    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),
-    tell_id TEXT NOT NULL REFERENCES tells(id),
+    body_sequence INTEGER PRIMARY KEY REFERENCES bodies(sequence),
     decided_at TEXT NOT NULL,
-    resolved_at TEXT,
+    resolved_at TEXT
+  ) STRICT;
+  CREATE TABLE IF NOT EXISTS tell_disposition_members (
+    body_sequence INTEGER NOT NULL REFERENCES tell_dispositions(body_sequence) ON DELETE CASCADE,
+    tell_id TEXT NOT NULL REFERENCES tells(id),
     PRIMARY KEY (body_sequence, tell_id)
   ) STRICT;
+  CREATE INDEX IF NOT EXISTS calls_by_turn ON calls(turn_sequence);
+  CREATE INDEX IF NOT EXISTS activity_by_turn ON activity(turn_sequence);
+  CREATE INDEX IF NOT EXISTS tell_bindings_by_turn ON tell_bindings(turn_sequence);
+  CREATE INDEX IF NOT EXISTS tell_deliveries_by_turn ON tell_deliveries(turn_sequence);
+  CREATE INDEX IF NOT EXISTS tell_disposition_members_by_tell ON tell_disposition_members(tell_id);
   CREATE TABLE IF NOT EXISTS requests (
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
     id TEXT NOT NULL UNIQUE,

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

@@ -8,10 +8,8 @@ export declare class HeartAbsentError extends Error {
 }
 export declare function isHeartAbsent(error: unknown): error is HeartAbsentError;
 export declare function classifyHeartSchema(paths: AkumaPaths): Promise<"current" | "unsupported">;
-export declare function withHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T): Promise<T>;
-export declare function withReadOnlyHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T): Promise<T>;
-export declare function transaction<T>(database: DatabaseSync, body: () => T): T;
-export declare function readTransaction<T>(database: DatabaseSync, body: () => T): T;
+export declare function withReadOnlyHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T, signal?: AbortSignal): Promise<T>;
+export declare function withHeartTransaction<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T, signal?: AbortSignal): Promise<T>;
 export declare function initializeHeart(paths: AkumaPaths): Promise<void>;
 export declare class HeldAkumaLeash {
     private readonly database;