@astrosheep/keiyaku 4.0.0 → 4.0.1

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

@@ -1,23 +1,12 @@
 import type { AkuId, AkumaPaths } from "../identity.js";
-import type { BodyEnd, BodyFact, Collar, DeathFact, ForkPoint, HeartSnapshot, LeashProbe, RequestFact, RequestInput, SealFact, SessionFact, Soul, TellFact, TellState, TurnFact } from "./facts.js";
-import type { ActivityFact, ActivityFactSlice } from "./rows.js";
+import type { BodyEnd, BodyFact, Collar, ForkPoint, HeartSnapshot, KillFact, RequestFact, RequestInput, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
+export type { CallFact } from "./facts.js";
+import type { ActivityFact } from "./rows.js";
+import { type ActivityFactSlice } from "./timeline.js";
+export { HeldAkumaLeash, initializeHeart, probeLeash } from "./storage.js";
 export { life } from "./facts.js";
-export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, Collar, CollarProbe, Confinement, DeathFact, HeartSnapshot, ForkPoint, KillEvidence, LeashProbe, ProviderOptions, ProviderExecution, RequestFact, RequestInput, RequestRecipe, ResumeCoordinate, SealFact, SessionFact, Soul, TellFact, TellState, TurnFact, TurnOutcome, } from "./facts.js";
-export declare function initializeHeart(paths: AkumaPaths): void;
-export declare class HeldAkumaLeash {
-    private readonly database;
-    private closed;
-    private constructor();
-    static try(paths: AkumaPaths): HeldAkumaLeash | null;
-    birth(paths: AkumaPaths, soul: Soul, session?: Omit<SessionFact, "sequence">): "born" | "already-born" | "sealed";
-    sealIfUnborn(paths: AkumaPaths, input: Readonly<{
-        evidence: string;
-        at: string;
-    }>): "born" | "sealed";
-    clearPause(paths: AkumaPaths): void;
-    release(): void;
-}
-export declare function probeLeash(paths: AkumaPaths): LeashProbe;
+export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, Collar, CollarProbe, Confinement, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, ProviderOptions, ProviderExecution, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
+export type { ResumeCoordinate } from "../coordinate.js";
 export declare function readSoul(paths: AkumaPaths): Soul | null;
 export declare function heartExists(paths: AkumaPaths): boolean;
 export declare function readSeal(paths: AkumaPaths): SealFact | null;
@@ -27,7 +16,7 @@ export declare function recordBody(paths: AkumaPaths, input: Readonly<{
 }>): BodyFact;
 export declare function recordSession(paths: AkumaPaths, input: Omit<SessionFact, "sequence">): SessionFact;
 export declare function appendActivity(paths: AkumaPaths, input: Readonly<{
-    bodySequence: number;
+    turnSequence: number;
     event: unknown;
     at: string;
 }>): number;
@@ -38,9 +27,16 @@ export type ActivitySliceInput = Readonly<{
 }>;
 export type ActivitySlice = ActivityFactSlice;
 export type { ActivityFact };
+export type { TimelineFact } from "./timeline.js";
 export declare function activitySlice(paths: AkumaPaths, input?: ActivitySliceInput): ActivitySlice;
-export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "state">): "recorded" | "dead";
-export declare function advanceTell(paths: AkumaPaths, id: string, state: Exclude<TellState, "recorded" | "voided-by-death">): void;
+export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Readonly<{
+    kind: "not-born";
+} | {
+    kind: "recorded";
+    tell: TellFact;
+}>;
+export declare function recordTellDeliveries(paths: AkumaPaths, inputs: readonly TellDeliveryInput[]): void;
+export declare function recordTellReceipt(paths: AkumaPaths, input: TellReceiptInput): void;
 export declare function admitRequest(paths: AkumaPaths, input: RequestInput & Readonly<{
     admittedAt: string;
 }>): RequestFact;
@@ -50,18 +46,36 @@ export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic:
 export declare function voidRequest(paths: AkumaPaths, id: string, evidence: string): RequestFact;
 export declare function readRequest(paths: AkumaPaths, id: string): RequestFact | null;
 export declare function readNonterminalRequests(paths: AkumaPaths): readonly RequestFact[];
-export declare function requestStop(paths: AkumaPaths, at: string): "requested" | "dead";
-export declare function requestPause(paths: AkumaPaths, at: string): "requested" | "dead";
-export declare function stopRequested(paths: AkumaPaths): boolean;
+export declare function readKill(paths: AkumaPaths, bodySequence: number): KillFact | null;
+export declare function requestStop(paths: AkumaPaths, at: string): Readonly<{
+    kind: "requested";
+    body: BodyFact;
+}> | Readonly<{
+    kind: "already-killed";
+    body: BodyFact;
+}>;
+export declare function requestPause(paths: AkumaPaths, at: string): Readonly<{
+    kind: "not-born";
+} | {
+    kind: "requested";
+}>;
+export declare function stopRequested(paths: AkumaPaths, bodySequence?: number): boolean;
 export declare function pauseRequested(paths: AkumaPaths): boolean;
-export declare function clearAbandonedControl(paths: AkumaPaths): void;
-export declare function recordDeath(paths: AkumaPaths, death: DeathFact): "recorded" | "already-dead";
 export declare function breakBody(paths: AkumaPaths, input: Readonly<{
     sequence: number;
     end: Exclude<BodyEnd, "exited">;
     at: string;
 }>): void;
-export declare function recordTurn(paths: AkumaPaths, input: Omit<TurnFact, "sequence">): TurnFact;
+export declare function beginTurn(paths: AkumaPaths, input: Readonly<{
+    bodySequence: number;
+    startedAt: string;
+    call?: string;
+}>): TurnStartFact;
+export declare function endTurn(paths: AkumaPaths, input: Readonly<{
+    turnSequence: number;
+    outcome: TurnOutcome;
+    completedAt: string;
+}>): TurnEndFact;
 export declare function finishBodyIfIdle(paths: AkumaPaths, input: Readonly<{
     sequence: number;
     at: string;
@@ -72,7 +86,5 @@ export declare function finishBodyIfIdle(paths: AkumaPaths, input: Readonly<{
     tells: readonly string[];
 }>;
 export declare function readHeart(paths: AkumaPaths): HeartSnapshot;
-export declare function readTurns(paths: AkumaPaths): readonly TurnFact[];
 export declare function readLastAnsweredTurn(paths: AkumaPaths): TurnFact | null;
-export declare function readCurrentTurn(paths: AkumaPaths): TurnFact | null;
 export declare function readForkPoint(paths: AkumaPaths, historyId: string): ForkPoint | null;

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

@@ -1,125 +1,11 @@
 import { existsSync } from "node:fs";
-import { DatabaseSync } from "node:sqlite";
-import { HEART_SCHEMA, LEASH_SCHEMA, assertHeartSchemaVersion, assertLeashSchemaVersion, } from "./schema.js";
-import { activityFactSlice, answeredTurnFact, deathExists, deathFact, deleteAbandonedControls, deletePauseControl, endBodyFact, finishBodyFact, historyFacts, insertActivityFact, insertAnsweredTurnFact, insertBodyFact, insertDeathFact, insertFailedTurnFact, insertPauseControl, insertRequestFact, insertSealFact, insertSessionFact, insertSoulFact, insertStopControl, insertTellFact, latestBodyFact, latestSessionFact, latestTurnFact, lastAnsweredTurnFact, nonterminalRequestFacts, pauseExists, pendingTellFacts, pruneActivityFacts, requestFact, sealExists, sealFact, sessionFactForCoordinate, soulFact, stopExists, tellState, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, updateTellState, voidRequestsByDeath, voidTellsByDeath, } from "./rows.js";
+import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertBodyFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertRequestFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, nonterminalRequestFacts, pauseExists, requestFact, sessionFactForCoordinate, soulFact, stopFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, } from "./rows.js";
+import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingTellFacts, tellFact, tellIdsForFence, } from "./tells.js";
+import { activityFactSlice, pruneActivityFacts, } from "./timeline.js";
+import { readSealFromLeash, transaction, withHeart } from "./storage.js";
+export { HeldAkumaLeash, initializeHeart, probeLeash } from "./storage.js";
 export { life } from "./facts.js";
 const ACTIVITY_LIMIT = 5_000;
-function isBusy(error) {
-    const value = error;
-    const message = String(value?.message ?? "").toLowerCase();
-    return value?.code === "ERR_SQLITE_BUSY" || value?.code === "ERR_SQLITE_LOCKED"
-        || value?.errcode === 5 || message.includes("database is locked") || message.includes("database is busy");
-}
-function openHeart(path, verify = true) {
-    const database = new DatabaseSync(path);
-    database.exec("PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000; PRAGMA journal_mode=WAL");
-    if (verify)
-        assertHeartSchemaVersion(database);
-    return database;
-}
-function withHeart(paths, body) {
-    const database = openHeart(paths.heart);
-    try {
-        return body(database);
-    }
-    finally {
-        database.close();
-    }
-}
-function transaction(database, body) {
-    database.exec("BEGIN IMMEDIATE");
-    try {
-        const result = body();
-        database.exec("COMMIT");
-        return result;
-    }
-    catch (error) {
-        try {
-            database.exec("ROLLBACK");
-        }
-        catch { /* preserve the adjudication failure */ }
-        throw error;
-    }
-}
-export function initializeHeart(paths) {
-    const heart = openHeart(paths.heart, false);
-    try {
-        heart.exec(HEART_SCHEMA);
-        assertHeartSchemaVersion(heart);
-    }
-    finally {
-        heart.close();
-    }
-    const leash = new DatabaseSync(paths.leash);
-    try {
-        leash.exec(LEASH_SCHEMA);
-        assertLeashSchemaVersion(leash);
-    }
-    finally {
-        leash.close();
-    }
-}
-export class HeldAkumaLeash {
-    database;
-    closed = false;
-    constructor(database) {
-        this.database = database;
-    }
-    static try(paths) {
-        const database = new DatabaseSync(paths.leash, { timeout: 0 });
-        try {
-            assertLeashSchemaVersion(database);
-            database.exec("PRAGMA busy_timeout=0; BEGIN EXCLUSIVE");
-            return new HeldAkumaLeash(database);
-        }
-        catch (error) {
-            database.close();
-            if (isBusy(error))
-                return null;
-            throw error;
-        }
-    }
-    birth(paths, soul, session) {
-        if (sealExists(this.database))
-            return "sealed";
-        return withHeart(paths, (heart) => transaction(heart, () => {
-            if (soulFact(heart) !== null)
-                return "already-born";
-            insertSoulFact(heart, soul);
-            if (session !== undefined)
-                insertSessionFact(heart, session);
-            return "born";
-        }));
-    }
-    sealIfUnborn(paths, input) {
-        if (withHeart(paths, (heart) => soulFact(heart)) !== null)
-            return "born";
-        insertSealFact(this.database, input);
-        this.database.exec("COMMIT");
-        this.closed = true;
-        this.database.close();
-        return "sealed";
-    }
-    clearPause(paths) { withHeart(paths, deletePauseControl); }
-    release() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        try {
-            this.database.exec("ROLLBACK");
-        }
-        finally {
-            this.database.close();
-        }
-    }
-}
-export function probeLeash(paths) {
-    const claim = HeldAkumaLeash.try(paths);
-    if (claim === null)
-        return "held";
-    claim.release();
-    return "free";
-}
 export function readSoul(paths) {
     if (!existsSync(paths.heart))
         return null;
@@ -129,14 +15,7 @@ export function heartExists(paths) { return existsSync(paths.heart); }
 export function readSeal(paths) {
     if (!existsSync(paths.leash))
         return null;
-    const leash = new DatabaseSync(paths.leash);
-    try {
-        assertLeashSchemaVersion(leash);
-        return sealFact(leash);
-    }
-    finally {
-        leash.close();
-    }
+    return readSealFromLeash(paths);
 }
 export function recordBody(paths, input) {
     return withHeart(paths, (heart) => {
@@ -159,27 +38,34 @@ export function activitySlice(paths, input = {}) {
 }
 export function recordTell(paths, tell) {
     return withHeart(paths, (heart) => transaction(heart, () => {
-        if (deathExists(heart))
-            return "dead";
-        insertTellFact(heart, tell);
-        return "recorded";
+        if (soulFact(heart) === null)
+            return { kind: "not-born" };
+        const sequence = insertTellFact(heart, tell);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
     }));
 }
-const TELL_ORDER = {
-    recorded: 0,
-    delivered: 1,
-    seen: 2,
-    consumed: 3,
-    "voided-by-death": 3,
-};
-export function advanceTell(paths, id, state) {
+export function recordTellDeliveries(paths, inputs) {
     withHeart(paths, (heart) => transaction(heart, () => {
-        const current = tellState(heart, id);
-        if (current === null)
-            throw new Error(`unknown tell ${id}`);
-        if (TELL_ORDER[state] < TELL_ORDER[current] || current === "voided-by-death")
-            return;
-        updateTellState(heart, id, state);
+        for (const input of inputs) {
+            const current = tellFact(heart, input.tellId);
+            if (current === null)
+                throw new Error(`unknown tell ${input.tellId}`);
+        }
+        for (const input of inputs)
+            insertTellDeliveryFact(heart, input);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+    }));
+}
+export function recordTellReceipt(paths, input) {
+    withHeart(paths, (heart) => transaction(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);
     }));
 }
 function sameRequestInput(fact, input) {
@@ -259,56 +145,55 @@ export function readRequest(paths, id) {
 export function readNonterminalRequests(paths) {
     return withHeart(paths, nonterminalRequestFacts);
 }
+export function readKill(paths, bodySequence) {
+    return withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
+}
 export function requestStop(paths, at) {
     return withHeart(paths, (heart) => transaction(heart, () => {
-        if (deathExists(heart))
-            return "dead";
-        insertStopControl(heart, at);
-        return "requested";
+        const body = latestBodyFact(heart);
+        if (body === null)
+            throw new Error("Akuma has no Body to kill");
+        if (latestKillFact(heart)?.bodySequence === body.sequence)
+            return { kind: "already-killed", body };
+        const existing = stopFact(heart);
+        if (existing !== null && existing.bodySequence !== body.sequence) {
+            throw new Error("Akuma stop target is not the latest Body");
+        }
+        insertStopControl(heart, body.sequence, at);
+        return { kind: "requested", body };
     }));
 }
 export function requestPause(paths, at) {
     return withHeart(paths, (heart) => transaction(heart, () => {
-        if (deathExists(heart))
-            return "dead";
+        if (soulFact(heart) === null)
+            return { kind: "not-born" };
         insertPauseControl(heart, at);
-        return "requested";
+        return { kind: "requested" };
     }));
 }
-export function stopRequested(paths) { return withHeart(paths, stopExists); }
+export function stopRequested(paths, bodySequence) {
+    return withHeart(paths, (heart) => {
+        const target = stopFact(heart);
+        return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
+    });
+}
 export function pauseRequested(paths) { return withHeart(paths, pauseExists); }
-export function clearAbandonedControl(paths) {
-    // A control row without settlement belongs to a vanished caller; the next leash holder revokes it.
-    withHeart(paths, deleteAbandonedControls);
+export function breakBody(paths, input) {
+    withHeart(paths, (heart) => endBodyFact(heart, input));
 }
-export function recordDeath(paths, death) {
+export function beginTurn(paths, input) {
     return withHeart(paths, (heart) => transaction(heart, () => {
-        if (deathExists(heart))
-            return "already-dead";
-        insertDeathFact(heart, death);
-        voidTellsByDeath(heart);
-        voidRequestsByDeath(heart, `death:${death.evidence}`);
-        return "recorded";
+        const fact = insertTurnStartFact(heart, input);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return fact;
     }));
 }
-export function breakBody(paths, input) {
-    withHeart(paths, (heart) => endBodyFact(heart, input));
-}
-export function recordTurn(paths, input) {
-    return withHeart(paths, (heart) => {
-        const sequence = input.outcome.kind === "answered"
-            ? insertAnsweredTurnFact(heart, {
-                bodySequence: input.bodySequence,
-                outcome: input.outcome,
-                completedAt: input.completedAt,
-            })
-            : insertFailedTurnFact(heart, {
-                bodySequence: input.bodySequence,
-                outcome: input.outcome,
-                completedAt: input.completedAt,
-            });
-        return { sequence, ...input };
-    });
+export function endTurn(paths, input) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const fact = insertTurnEndFact(heart, { kind: "turn-end", ...input });
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return fact;
+    }));
 }
 export function finishBodyIfIdle(paths, input) {
     return withHeart(paths, (heart) => transaction(heart, () => {
@@ -321,38 +206,32 @@ export function finishBodyIfIdle(paths, input) {
 }
 export function readHeart(paths) {
     if (!existsSync(paths.heart)) {
-        return { soul: null, latestBody: null, latestSession: null, pending: [], death: null };
+        return { soul: null, latestBody: null, latestSession: null, pending: [], latestKill: null };
     }
     return withHeart(paths, (heart) => ({
         soul: soulFact(heart),
         latestBody: latestBodyFact(heart),
         latestSession: latestSessionFact(heart),
         pending: pendingTellFacts(heart),
-        death: deathFact(heart),
+        latestKill: latestKillFact(heart),
     }));
 }
-export function readTurns(paths) {
-    return withHeart(paths, historyFacts);
-}
 export function readLastAnsweredTurn(paths) {
     return withHeart(paths, lastAnsweredTurnFact);
 }
-export function readCurrentTurn(paths) {
-    return withHeart(paths, latestTurnFact);
-}
 export function readForkPoint(paths, historyId) {
     if (!existsSync(paths.heart))
         return null;
     return withHeart(paths, (heart) => {
         const turn = answeredTurnFact(heart, historyId);
-        if (turn?.outcome.kind !== "answered")
+        if (turn?.end?.outcome.kind !== "answered")
             return null;
-        const recipe = sessionFactForCoordinate(heart, turn.outcome.session);
+        const recipe = sessionFactForCoordinate(heart, turn.end.outcome.session);
         if (recipe === null)
             throw new Error(`Akuma fork point ${historyId} has no session recipe`);
         return {
-            historyId: turn.outcome.historyId,
-            session: turn.outcome.session,
+            historyId: turn.end.outcome.historyId,
+            session: turn.end.outcome.session,
             provider: recipe.provider,
             cwd: recipe.cwd,
             options: recipe.options,

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

@@ -1,6 +1,6 @@
 import type { DatabaseSync } from "node:sqlite";
 import type { AkuId } from "../identity.js";
-import type { BodyEnd, BodyFact, Collar, DeathFact, RequestFact, RequestInput, ResumeCoordinate, SessionFact, Soul, TellFact, TellState, TurnFact } from "./facts.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;
@@ -36,18 +36,20 @@ export type SessionRow = Readonly<{
 export type TurnRow = Readonly<{
     sequence: number;
     body_sequence: number;
-    outcome: "answered" | "failed";
+    started_at: string;
+    end_sequence: number | null;
+    outcome: "answered" | "failed" | null;
     history_id: string | null;
     session_json: string | null;
     answer: string | null;
     diagnostic: string | null;
-    completed_at: string;
+    completed_at: string | null;
 }>;
-export type TellRow = Readonly<{
-    id: string;
+export type CallRow = Readonly<{
+    sequence: number;
+    turn_sequence: number;
     body: string;
-    state: TellState;
-    recorded_at: string;
+    at: string;
 }>;
 export type RequestRow = Readonly<{
     sequence: number;
@@ -65,23 +67,21 @@ export type RequestRow = Readonly<{
 }>;
 export type ActivityRow = Readonly<{
     sequence: number;
-    body_sequence: number;
+    turn_sequence: number;
     event_json: string;
     at: string;
 }>;
 export type ActivityFact = Readonly<{
+    kind: "activity";
     sequence: number;
-    bodySequence: number;
+    turnSequence: number;
     event: unknown;
     at: string;
 }>;
-export type ActivityFactSlice = Readonly<{
-    rows: readonly ActivityFact[];
-    lowestRetained: number | null;
-    highest: number | null;
-}>;
-export type DeathRow = Readonly<{
-    value_json: string;
+export type KillRow = Readonly<{
+    sequence: number;
+    body_sequence: number;
+    evidence: "killed";
     at: string;
 }>;
 export declare function encodeSoulRow(soul: Soul): readonly [
@@ -101,12 +101,10 @@ export declare function encodeResumeCoordinate(coordinate: ResumeCoordinate): st
 export declare function decodeSessionRow(row: SessionRow): SessionFact;
 export declare function decodeBodyRow(row: BodyRow): BodyFact;
 export declare function decodeTurnRow(row: TurnRow): TurnFact;
-export declare function decodeTellRow(row: TellRow): TellFact;
+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 encodeDeathRow(death: DeathFact): string;
-export declare function decodeDeathRow(row: DeathRow): DeathFact;
 export declare function soulFact(database: DatabaseSync): Soul | null;
 export declare function sealExists(database: DatabaseSync): boolean;
 export declare function insertSoulFact(database: DatabaseSync, soul: Soul): void;
@@ -115,6 +113,7 @@ export declare function insertSealFact(database: DatabaseSync, input: Readonly<{
     at: string;
 }>): void;
 export declare function deletePauseControl(database: DatabaseSync): void;
+export declare function deleteStopControl(database: DatabaseSync): void;
 export declare function sealFact(database: DatabaseSync): Readonly<{
     evidence: string;
     at: string;
@@ -125,20 +124,10 @@ export declare function insertBodyFact(database: DatabaseSync, input: Readonly<{
 }>): number;
 export declare function insertSessionFact(database: DatabaseSync, input: Omit<SessionFact, "sequence">): number;
 export declare function insertActivityFact(database: DatabaseSync, input: Readonly<{
-    bodySequence: number;
+    turnSequence: number;
     event: unknown;
     at: string;
 }>): number;
-export declare function pruneActivityFacts(database: DatabaseSync, limit: number): void;
-export declare function activityFactSlice(database: DatabaseSync, input: Readonly<{
-    before?: number;
-    since?: number;
-    limit: number;
-}>): ActivityFactSlice;
-export declare function deathExists(database: DatabaseSync): boolean;
-export declare function insertTellFact(database: DatabaseSync, tell: Omit<TellFact, "state">): void;
-export declare function tellState(database: DatabaseSync, id: string): TellState | null;
-export declare function updateTellState(database: DatabaseSync, id: string, state: TellState): void;
 export declare function insertRequestFact(database: DatabaseSync, input: RequestInput & Readonly<{
     admittedAt: string;
 }>): void;
@@ -148,31 +137,22 @@ export declare function updateRequestReserved(database: DatabaseSync, id: string
 export declare function updateRequestServed(database: DatabaseSync, id: string, child: AkuId): void;
 export declare function updateRequestRefused(database: DatabaseSync, id: string, diagnostic: string): void;
 export declare function updateRequestVoided(database: DatabaseSync, id: string, evidence: string): void;
-export declare function insertStopControl(database: DatabaseSync, at: string): void;
+export declare function insertStopControl(database: DatabaseSync, bodySequence: number, at: string): void;
 export declare function insertPauseControl(database: DatabaseSync, at: string): void;
-export declare function stopExists(database: DatabaseSync): boolean;
+export declare function stopFact(database: DatabaseSync): StopFact | null;
 export declare function pauseExists(database: DatabaseSync): boolean;
-export declare function deleteAbandonedControls(database: DatabaseSync): void;
-export declare function insertDeathFact(database: DatabaseSync, death: DeathFact): void;
-export declare function voidTellsByDeath(database: DatabaseSync): void;
-export declare function voidRequestsByDeath(database: DatabaseSync, evidence: string): void;
+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;
-type AnsweredTurn = Omit<TurnFact, "sequence" | "outcome"> & Readonly<{
-    outcome: Extract<TurnFact["outcome"], {
-        kind: "answered";
-    }>;
-}>;
-export declare function insertAnsweredTurnFact(database: DatabaseSync, input: AnsweredTurn): number;
-type FailedTurn = Omit<TurnFact, "sequence" | "outcome"> & Readonly<{
-    outcome: Extract<TurnFact["outcome"], {
-        kind: "failed";
-    }>;
-}>;
-export declare function insertFailedTurnFact(database: DatabaseSync, input: FailedTurn): number;
+export declare function insertTurnStartFact(database: DatabaseSync, input: Readonly<{
+    bodySequence: number;
+    startedAt: string;
+    call?: string;
+}>): TurnStartFact;
+export declare function insertTurnEndFact(database: DatabaseSync, input: Omit<TurnEndFact, "sequence">): TurnEndFact;
 export declare function finishBodyFact(database: DatabaseSync, input: Readonly<{
     sequence: number;
     at: string;
@@ -180,10 +160,7 @@ export declare function finishBodyFact(database: DatabaseSync, input: Readonly<{
 export declare function latestBodyFact(database: DatabaseSync): BodyFact | null;
 export declare function latestSessionFact(database: DatabaseSync): SessionFact | null;
 export declare function sessionFactForCoordinate(database: DatabaseSync, coordinate: ResumeCoordinate): SessionFact | null;
-export declare function pendingTellFacts(database: DatabaseSync): readonly TellFact[];
-export declare function deathFact(database: DatabaseSync): DeathFact | null;
-export declare function historyFacts(database: DatabaseSync): readonly TurnFact[];
+export declare function latestKillFact(database: DatabaseSync): KillFact | null;
+export declare function killFactForBody(database: DatabaseSync, bodySequence: number): KillFact | null;
 export declare function lastAnsweredTurnFact(database: DatabaseSync): TurnFact | null;
-export declare function latestTurnFact(database: DatabaseSync): TurnFact | null;
 export declare function answeredTurnFact(database: DatabaseSync, historyId: string): TurnFact | null;
-export {};