@astrosheep/keiyaku 2.9.13 → 4.0.0

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

@@ -0,0 +1,78 @@
+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";
+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 declare function readSoul(paths: AkumaPaths): Soul | null;
+export declare function heartExists(paths: AkumaPaths): boolean;
+export declare function readSeal(paths: AkumaPaths): SealFact | null;
+export declare function recordBody(paths: AkumaPaths, input: Readonly<{
+    collar: Collar;
+    leashTakenAt: string;
+}>): BodyFact;
+export declare function recordSession(paths: AkumaPaths, input: Omit<SessionFact, "sequence">): SessionFact;
+export declare function appendActivity(paths: AkumaPaths, input: Readonly<{
+    bodySequence: number;
+    event: unknown;
+    at: string;
+}>): number;
+export type ActivitySliceInput = Readonly<{
+    before?: number;
+    since?: number;
+    limit?: number;
+}>;
+export type ActivitySlice = ActivityFactSlice;
+export type { ActivityFact };
+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 admitRequest(paths: AkumaPaths, input: RequestInput & Readonly<{
+    admittedAt: string;
+}>): RequestFact;
+export declare function reserveRequest(paths: AkumaPaths, id: string, child: AkuId): RequestFact;
+export declare function serveRequest(paths: AkumaPaths, id: string, child: AkuId): RequestFact;
+export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic: string): RequestFact;
+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 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 finishBodyIfIdle(paths: AkumaPaths, input: Readonly<{
+    sequence: number;
+    at: string;
+}>): Readonly<{
+    kind: "finished";
+} | {
+    kind: "pending";
+    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

@@ -0,0 +1,361 @@
+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";
+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;
+    return withHeart(paths, soulFact);
+}
+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();
+    }
+}
+export function recordBody(paths, input) {
+    return withHeart(paths, (heart) => {
+        return { sequence: insertBodyFact(heart, input), collar: input.collar, leashTakenAt: input.leashTakenAt };
+    });
+}
+export function recordSession(paths, input) {
+    return withHeart(paths, (heart) => ({ sequence: insertSessionFact(heart, input), ...input }));
+}
+export function appendActivity(paths, input) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const sequence = insertActivityFact(heart, input);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return sequence;
+    }));
+}
+export function activitySlice(paths, input = {}) {
+    const limit = input.limit ?? ACTIVITY_LIMIT;
+    return withHeart(paths, (heart) => activityFactSlice(heart, { ...input, limit }));
+}
+export function recordTell(paths, tell) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        if (deathExists(heart))
+            return "dead";
+        insertTellFact(heart, tell);
+        return "recorded";
+    }));
+}
+const TELL_ORDER = {
+    recorded: 0,
+    delivered: 1,
+    seen: 2,
+    consumed: 3,
+    "voided-by-death": 3,
+};
+export function advanceTell(paths, id, state) {
+    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);
+    }));
+}
+function sameRequestInput(fact, input) {
+    return fact.id === input.id
+        && fact.archetype === input.archetype
+        && fact.body === input.body
+        && fact.cwd === input.cwd
+        && fact.world === input.world
+        && JSON.stringify(fact.recipe) === JSON.stringify(input.recipe);
+}
+export function admitRequest(paths, input) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        insertRequestFact(heart, input);
+        const fact = requestFact(heart, input.id);
+        if (fact === null)
+            throw new Error(`Akuma request ${input.id} was not admitted`);
+        if (!sameRequestInput(fact, input))
+            throw new Error(`Akuma request ${input.id} reused different input`);
+        return fact;
+    }));
+}
+export function reserveRequest(paths, id, child) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "admitted")
+            updateRequestReserved(heart, id, child);
+        else if ((before.state !== "reserved" && before.state !== "served") || before.child !== child) {
+            throw new Error(`Akuma request ${id} cannot reserve ${child}`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export function serveRequest(paths, id, child) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "reserved" && before.child === child)
+            updateRequestServed(heart, id, child);
+        else if (before.state !== "served" || before.child !== child) {
+            throw new Error(`Akuma request ${id} cannot serve ${child}`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export function refuseRequest(paths, id, diagnostic) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "admitted")
+            updateRequestRefused(heart, id, diagnostic);
+        else if (before.state !== "refused" || before.diagnostic !== diagnostic) {
+            throw new Error(`Akuma request ${id} cannot be refused`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export function voidRequest(paths, id, evidence) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "admitted" || before.state === "reserved")
+            updateRequestVoided(heart, id, evidence);
+        else if (before.state !== "voided" || before.evidence !== evidence) {
+            throw new Error(`Akuma request ${id} cannot be voided`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export function readRequest(paths, id) {
+    return withHeart(paths, (heart) => requestFact(heart, id));
+}
+export function readNonterminalRequests(paths) {
+    return withHeart(paths, nonterminalRequestFacts);
+}
+export function requestStop(paths, at) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        if (deathExists(heart))
+            return "dead";
+        insertStopControl(heart, at);
+        return "requested";
+    }));
+}
+export function requestPause(paths, at) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        if (deathExists(heart))
+            return "dead";
+        insertPauseControl(heart, at);
+        return "requested";
+    }));
+}
+export function stopRequested(paths) { return withHeart(paths, stopExists); }
+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 recordDeath(paths, death) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        if (deathExists(heart))
+            return "already-dead";
+        insertDeathFact(heart, death);
+        voidTellsByDeath(heart);
+        voidRequestsByDeath(heart, `death:${death.evidence}`);
+        return "recorded";
+    }));
+}
+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 finishBodyIfIdle(paths, input) {
+    return withHeart(paths, (heart) => transaction(heart, () => {
+        const pending = pendingTellFacts(heart);
+        if (pending.length > 0)
+            return { kind: "pending", tells: pending.map((tell) => tell.id) };
+        finishBodyFact(heart, input);
+        return { kind: "finished" };
+    }));
+}
+export function readHeart(paths) {
+    if (!existsSync(paths.heart)) {
+        return { soul: null, latestBody: null, latestSession: null, pending: [], death: null };
+    }
+    return withHeart(paths, (heart) => ({
+        soul: soulFact(heart),
+        latestBody: latestBodyFact(heart),
+        latestSession: latestSessionFact(heart),
+        pending: pendingTellFacts(heart),
+        death: deathFact(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")
+            return null;
+        const recipe = sessionFactForCoordinate(heart, turn.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,
+            provider: recipe.provider,
+            cwd: recipe.cwd,
+            options: recipe.options,
+        };
+    });
+}

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

@@ -0,0 +1,189 @@
+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";
+export type SoulRow = Readonly<{
+    id: string;
+    archetype: string;
+    description: string | null;
+    provider_json: string;
+    options_json: string;
+    cwd: string;
+    origin_json: string;
+    confinement_json: string;
+    created_at: string;
+}>;
+export type SealRow = Readonly<{
+    evidence: string;
+    at: string;
+}>;
+export type BodyRow = Readonly<{
+    sequence: number;
+    pid: number;
+    process_group: number;
+    spawned_at: string;
+    leash_taken_at: string;
+    end: BodyEnd | null;
+    ended_at: string | null;
+}>;
+export type SessionRow = Readonly<{
+    sequence: number;
+    provider: string;
+    coordinate_json: string;
+    cwd: string;
+    options_json: string;
+    admitted_at: string;
+}>;
+export type TurnRow = Readonly<{
+    sequence: number;
+    body_sequence: number;
+    outcome: "answered" | "failed";
+    history_id: string | null;
+    session_json: string | null;
+    answer: string | null;
+    diagnostic: string | null;
+    completed_at: string;
+}>;
+export type TellRow = Readonly<{
+    id: string;
+    body: string;
+    state: TellState;
+    recorded_at: string;
+}>;
+export type RequestRow = Readonly<{
+    sequence: number;
+    id: string;
+    archetype: string;
+    body: string;
+    cwd: string | null;
+    world: string;
+    recipe_json: string;
+    admitted_at: string;
+    state: RequestFact["state"];
+    child: string | null;
+    diagnostic: string | null;
+    evidence: string | null;
+}>;
+export type ActivityRow = Readonly<{
+    sequence: number;
+    body_sequence: number;
+    event_json: string;
+    at: string;
+}>;
+export type ActivityFact = Readonly<{
+    sequence: number;
+    bodySequence: 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;
+    at: string;
+}>;
+export declare function encodeSoulRow(soul: Soul): readonly [
+    AkuId,
+    string,
+    string | null,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string
+];
+export declare function decodeSoulRow(row: SoulRow): Soul;
+export declare function encodeSessionRow(session: Omit<SessionFact, "sequence">): readonly [string, string, string, string, string];
+export declare function encodeResumeCoordinate(coordinate: ResumeCoordinate): string;
+export declare function decodeSessionRow(row: SessionRow): SessionFact;
+export declare function decodeBodyRow(row: BodyRow): BodyFact;
+export declare function decodeTurnRow(row: TurnRow): TurnFact;
+export declare function decodeTellRow(row: TellRow): TellFact;
+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;
+export declare function insertSealFact(database: DatabaseSync, input: Readonly<{
+    evidence: string;
+    at: string;
+}>): void;
+export declare function deletePauseControl(database: DatabaseSync): void;
+export declare function sealFact(database: DatabaseSync): Readonly<{
+    evidence: string;
+    at: string;
+}> | null;
+export declare function insertBodyFact(database: DatabaseSync, input: Readonly<{
+    collar: Collar;
+    leashTakenAt: string;
+}>): number;
+export declare function insertSessionFact(database: DatabaseSync, input: Omit<SessionFact, "sequence">): number;
+export declare function insertActivityFact(database: DatabaseSync, input: Readonly<{
+    bodySequence: 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;
+export declare function requestFact(database: DatabaseSync, id: string): RequestFact | null;
+export declare function nonterminalRequestFacts(database: DatabaseSync): readonly RequestFact[];
+export declare function updateRequestReserved(database: DatabaseSync, id: string, child: AkuId): void;
+export declare function updateRequestServed(database: DatabaseSync, id: string, child: AkuId): void;
+export declare function 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 insertPauseControl(database: DatabaseSync, at: string): void;
+export declare function stopExists(database: DatabaseSync): boolean;
+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 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 finishBodyFact(database: DatabaseSync, input: Readonly<{
+    sequence: number;
+    at: string;
+}>): void;
+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 lastAnsweredTurnFact(database: DatabaseSync): TurnFact | null;
+export declare function latestTurnFact(database: DatabaseSync): TurnFact | null;
+export declare function answeredTurnFact(database: DatabaseSync, historyId: string): TurnFact | null;
+export {};