@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -1,185 +1,85 @@
-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";
+import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertRequestFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, nonterminalRequestFacts, pauseFact, requestFact, sessionFactForCoordinate, 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 { isHeartAbsent, readSealFromLeash, transaction, withHeart } from "./storage.js";
+import { soulFact } from "./soul.js";
+export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash } from "./storage.js";
+export { life, lifeAt } 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);
+export async function readSoul(paths) {
     try {
-        return body(database);
-    }
-    finally {
-        database.close();
-    }
-}
-function transaction(database, body) {
-    database.exec("BEGIN IMMEDIATE");
-    try {
-        const result = body();
-        database.exec("COMMIT");
-        return result;
+        return await withHeart(paths, soulFact);
     }
     catch (error) {
-        try {
-            database.exec("ROLLBACK");
-        }
-        catch { /* preserve the adjudication failure */ }
+        if (isHeartAbsent(error))
+            return null;
         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);
+export async function heartExists(paths) {
     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;
-        }
+        return await withHeart(paths, () => true);
     }
-    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();
-        }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return false;
+        throw error;
     }
 }
-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);
+export async function readSeal(paths) {
     try {
-        assertLeashSchemaVersion(leash);
-        return sealFact(leash);
+        return await readSealFromLeash(paths);
     }
-    finally {
-        leash.close();
+    catch (error) {
+        if (isHeartAbsent(error))
+            return null;
+        throw error;
     }
 }
-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 async function recordSession(paths, input) {
+    return await withHeart(paths, (heart) => ({ sequence: insertSessionFact(heart, input), ...input }));
 }
-export function appendActivity(paths, input) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function appendActivity(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const sequence = insertActivityFact(heart, input);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return sequence;
     }));
 }
-export function activitySlice(paths, input = {}) {
+export async function activitySlice(paths, input = {}) {
     const limit = input.limit ?? ACTIVITY_LIMIT;
-    return withHeart(paths, (heart) => activityFactSlice(heart, { ...input, limit }));
+    return await 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";
+export async function recordTell(paths, tell) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        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) {
-    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);
+export async function recordTellDeliveries(paths, inputs) {
+    await withHeart(paths, (heart) => transaction(heart, () => {
+        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 async function recordTellReceipt(paths, input) {
+    await 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) {
@@ -190,8 +90,8 @@ function sameRequestInput(fact, input) {
         && fact.world === input.world
         && JSON.stringify(fact.recipe) === JSON.stringify(input.recipe);
 }
-export function admitRequest(paths, input) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function admitRequest(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         insertRequestFact(heart, input);
         const fact = requestFact(heart, input.id);
         if (fact === null)
@@ -201,8 +101,8 @@ export function admitRequest(paths, input) {
         return fact;
     }));
 }
-export function reserveRequest(paths, id, child) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function reserveRequest(paths, id, child) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -214,8 +114,8 @@ export function reserveRequest(paths, id, child) {
         return requestFact(heart, id);
     }));
 }
-export function serveRequest(paths, id, child) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function serveRequest(paths, id, child) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -227,8 +127,8 @@ export function serveRequest(paths, id, child) {
         return requestFact(heart, id);
     }));
 }
-export function refuseRequest(paths, id, diagnostic) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function refuseRequest(paths, id, diagnostic) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -240,8 +140,8 @@ export function refuseRequest(paths, id, diagnostic) {
         return requestFact(heart, id);
     }));
 }
-export function voidRequest(paths, id, evidence) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function voidRequest(paths, id, evidence) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -253,65 +153,78 @@ export function voidRequest(paths, id, evidence) {
         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 async function readRequest(paths, id) {
+    return await withHeart(paths, (heart) => requestFact(heart, id));
+}
+export async function readNonterminalRequests(paths) {
+    return await withHeart(paths, nonterminalRequestFacts);
+}
+export async function readKill(paths, bodySequence) {
+    return await withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
+}
+export async function requestStop(paths, at) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        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 };
+        if (body.end !== undefined)
+            return { kind: "already-stopped", 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";
+export async function requestPause(paths, at) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        if (soulFact(heart) === null)
+            return { kind: "not-born" };
+        const body = latestBodyFact(heart);
+        if (body === null)
+            throw new Error("Akuma has no Body to interrupt");
         insertPauseControl(heart, at);
-        return "requested";
+        return { kind: "requested", body };
     }));
 }
-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 async function stopRequested(paths, bodySequence) {
+    return await withHeart(paths, (heart) => {
+        const target = stopFact(heart);
+        return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
+    });
 }
-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 async function pauseRequested(paths, bodySequence) {
+    return await withHeart(paths, (heart) => {
+        const target = pauseFact(heart);
+        return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
+    });
 }
-export function breakBody(paths, input) {
-    withHeart(paths, (heart) => endBodyFact(heart, input));
+export async function breakBody(paths, input) {
+    await 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 async function beginTurn(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const fact = insertTurnStartFact(heart, input);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return fact;
+    }));
+}
+export async function endTurn(paths, input) {
+    return await 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, () => {
+export async function finishBodyIfIdle(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        if (stopFact(heart)?.bodySequence === input.sequence || pauseFact(heart)?.bodySequence === input.sequence) {
+            endBodyFact(heart, { ...input, end: "put-down" });
+            return { kind: "controlled" };
+        }
         const pending = pendingTellFacts(heart);
         if (pending.length > 0)
             return { kind: "pending", tells: pending.map((tell) => tell.id) };
@@ -319,43 +232,50 @@ export function finishBodyIfIdle(paths, input) {
         return { kind: "finished" };
     }));
 }
-export function readHeart(paths) {
-    if (!existsSync(paths.heart)) {
-        return { soul: null, latestBody: null, latestSession: null, pending: [], death: null };
+export async function readHeart(paths) {
+    try {
+        return await withHeart(paths, (heart) => ({
+            soul: soulFact(heart),
+            latestBody: latestBodyFact(heart),
+            latestSession: latestSessionFact(heart),
+            pending: pendingTellFacts(heart),
+            latestKill: latestKillFact(heart),
+            stop: stopFact(heart),
+            pause: pauseFact(heart),
+        }));
+    }
+    catch (error) {
+        if (isHeartAbsent(error)) {
+            return { soul: null, latestBody: null, latestSession: null, pending: [], latestKill: null, stop: null, pause: null };
+        }
+        throw error;
     }
-    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 async function readLastAnsweredTurn(paths) {
+    return await withHeart(paths, lastAnsweredTurnFact);
 }
-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")
+export async function readForkPoint(paths, historyId) {
+    try {
+        return await withHeart(paths, (heart) => {
+            const turn = answeredTurnFact(heart, historyId);
+            const outcome = turn?.end?.outcome;
+            if (outcome?.kind !== "answered" || outcome.historyId === undefined)
+                return null;
+            const recipe = sessionFactForCoordinate(heart, outcome.session);
+            if (recipe === null)
+                throw new Error(`Akuma fork point ${historyId} has no session recipe`);
+            return {
+                historyId: outcome.historyId,
+                session: outcome.session,
+                provider: recipe.provider,
+                cwd: recipe.cwd,
+                options: recipe.options,
+            };
+        });
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
             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,
-        };
-    });
+        throw error;
+    }
 }