@astrosheep/keiyaku 4.6.4 → 4.6.7

package/build/src/akuma/body.js

@@ -10,7 +10,7 @@ import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTe
 import { akumaPathsSchema, pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { admitCallInitialTell, } from "./call-initial-tell.js";
 import { akumaExecutionEnvironment } from "./providers/execution-environment.js";
-import { pluginRuntime } from "../plugin/runtime.js";
+import { emitPluginSignal } from "../plugin/akuma-signals.js";
 import { World } from "../world.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests } from "./request-serve.js";
@@ -156,7 +156,7 @@ function boundedDiagnostic(error) {
     const text = diagnostic(error);
     return text.length <= 500 ? text : `${text.slice(0, 500)}...`;
 }
-async function recordPluginDiagnostic(paths, occurrence, error) {
+export async function recordPluginDiagnostic(paths, occurrence, error) {
     try {
         await appendFile(paths.log, `plugin ${occurrence} failed: ${boundedDiagnostic(error)}\n`);
     }
@@ -306,8 +306,7 @@ async function recoverBodyRequests(input) {
     }
     return false;
 }
-function turnOutcomeEmitter(launch, soul) {
-    let plugins;
+function turnOutcomeEmitter(launch, soul, world) {
     const reportDiagnostic = (message) => {
         void recordPluginDiagnostic(launch.paths, "turn outcome", message);
     };
@@ -318,11 +317,7 @@ function turnOutcomeEmitter(launch, soul) {
                 if (turn === null)
                     throw new Error(`Committed Turn ${turnSequence} is missing from Heart`);
                 const participants = await readTurnParticipants(launch.paths, turnSequence);
-                plugins ??= pluginRuntime({
-                    world: await World.at(worldRootForAkumaPaths(launch.paths)),
-                    reportDiagnostic,
-                });
-                await (await plugins).emit({
+                await emitPluginSignal({ world, reportDiagnostic }, {
                     kind: "akuma.turn-outcome",
                     akumaId: soul.id,
                     bodySequence: turn.bodySequence,
@@ -333,7 +328,7 @@ function turnOutcomeEmitter(launch, soul) {
                         ? { kind: "answered", text: outcome.answer }
                         : { kind: "failed", reason: outcome.diagnostic },
                     ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
-                }, reportDiagnostic);
+                });
             }
             catch (error) {
                 await recordPluginDiagnostic(launch.paths, "turn outcome", error);
@@ -341,22 +336,16 @@ function turnOutcomeEmitter(launch, soul) {
         },
     };
 }
-function bodyEndEmitter(launch, soul) {
-    let plugins;
+function bodyEndEmitter(launch, soul, world) {
     const reportDiagnostic = (message) => {
         void recordPluginDiagnostic(launch.paths, "body end", message);
     };
-    return (bodySequence, end, diagnostic) => (async () => {
+    return async (bodySequence, end, diagnostic) => {
         try {
             const latestTurn = await readLatestTurnForBody(launch.paths, bodySequence);
             const initiator = latestTurn?.initiator;
             const participants = latestTurn === null ? [] : await readTurnParticipants(launch.paths, latestTurn.sequence);
-            plugins ??= pluginRuntime({
-                world: await World.at(worldRootForAkumaPaths(launch.paths)),
-                reportDiagnostic,
-            });
-            const runtime = await plugins;
-            await runtime.emit({
+            await emitPluginSignal({ world, reportDiagnostic }, {
                 kind: "akuma.body-ended",
                 akumaId: soul.id,
                 bodySequence,
@@ -365,12 +354,12 @@ function bodyEndEmitter(launch, soul) {
                 ...(participants.length === 0 ? {} : { participants }),
                 ...(diagnostic === undefined ? {} : { diagnostic }),
                 ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
-            }, reportDiagnostic);
+            });
         }
         catch (error) {
             await recordPluginDiagnostic(launch.paths, "body end", error);
         }
-    })();
+    };
 }
 async function admitInitialCallTell(runtime, input) {
     const paths = pathsForAkuId(runtime.world, input.id);
@@ -575,8 +564,8 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
         const prepared = await prepareBodyExecution(launch, leash, runtime, adapter);
         if (prepared === null)
             return;
-        emitBodyEnd = bodyEndEmitter(launch, prepared.soul);
-        emitTurnOutcome = turnOutcomeEmitter(launch, prepared.soul);
+        emitBodyEnd = bodyEndEmitter(launch, prepared.soul, world);
+        emitTurnOutcome = turnOutcomeEmitter(launch, prepared.soul, world);
         const body = await leash.recordBody(launch.paths, { leashTakenAt: runtime.now() });
         bodySequence = body.sequence;
         const supervisor = await BodySupervisor.open(launch.paths, body.sequence, leash);

package/build/src/akuma/call-initial-tell.d.ts

@@ -78,8 +78,8 @@ export declare const tellResultSchema: z.ZodObject<{
             }>;
             turnSequence: z.ZodNumber;
             receipt: z.ZodOptional<z.ZodEnum<{
-                required: "required";
                 unavailable: "unavailable";
+                required: "required";
             }>>;
         }, z.core.$strict>, z.ZodTransform<Readonly<{
             turnSequence: number;
@@ -90,7 +90,7 @@ export declare const tellResultSchema: z.ZodObject<{
             deliveredAt: string;
             route: "live" | "launch";
             turnSequence: number;
-            receipt?: "required" | "unavailable" | undefined;
+            receipt?: "unavailable" | "required" | undefined;
         }>>>>;
     }, z.core.$strict>;
     wake: z.ZodUnion<readonly [z.ZodObject<{

package/build/src/akuma/call-initial-tell.js

@@ -37,7 +37,7 @@ export async function admitCallInitialTell(input) {
     const birth = await waitForObservation({
         timeoutMs: BIRTH_TIMEOUT_MS,
         ...(input.signal === undefined ? {} : { signal: input.signal }),
-        probe: async () => await readWaitComplete(input.world, input.id),
+        probe: async () => await readWaitComplete(input.world, [input.id], "all", input.signal),
         observe: async () => (await bornStatus(paths, input.id, { aperture: "receipt" })).status,
         complete: defaultWaitComplete,
     });

package/build/src/akuma/call-request.d.ts

@@ -206,8 +206,8 @@ declare const liveResultSchema: z.ZodObject<{
                 }>;
                 turnSequence: z.ZodNumber;
                 receipt: z.ZodOptional<z.ZodEnum<{
-                    required: "required";
                     unavailable: "unavailable";
+                    required: "required";
                 }>>;
             }, z.core.$strict>, z.ZodTransform<Readonly<{
                 turnSequence: number;
@@ -218,7 +218,7 @@ declare const liveResultSchema: z.ZodObject<{
                 deliveredAt: string;
                 route: "live" | "launch";
                 turnSequence: number;
-                receipt?: "required" | "unavailable" | undefined;
+                receipt?: "unavailable" | "required" | undefined;
             }>>>>;
         }, z.core.$strict>;
         wake: z.ZodUnion<readonly [z.ZodObject<{

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

@@ -23,12 +23,17 @@ export type ActivitySlice = ActivityFactSlice;
 export type { ActivityFact };
 export type { TimelineFact } from "./timeline.js";
 export declare function activitySlice(paths: AkumaPaths): Promise<ActivitySlice>;
-export declare function readStatusFacts(paths: AkumaPaths, input: StatusFactInput): Promise<ActivitySlice["rows"]>;
+export declare function readStatusFacts(paths: AkumaPaths, input: StatusFactInput, signal?: AbortSignal): Promise<ActivitySlice["rows"]>;
+/** One live observation's successful raw input and decoded frontier, never a connection. */
+export declare function createStatusFactReader(paths: AkumaPaths): {
+    clear(): void;
+    read(input: StatusFactInput, signal?: AbortSignal): Promise<ActivitySlice["rows"]>;
+};
 type LifeSnapshot = Pick<HeartSnapshot, "soul" | "latestBody" | "latestSession" | "latestKill"> & Readonly<{
     hasPendingTell: boolean;
 }>;
 /** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
-export declare function readLifeSnapshot(paths: AkumaPaths): Promise<LifeSnapshot>;
+export declare function readLifeSnapshot(paths: AkumaPaths, signal?: AbortSignal): Promise<LifeSnapshot>;
 export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">, options?: Readonly<{
     interrupt?: boolean;
 }>): Promise<Readonly<{

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

@@ -1,7 +1,7 @@
 import { parsePublicHistoryId } from "../identity.js";
 import { answeredTurnFact, endBodyFact, finishBodyFact, deleteStopControl, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertKillFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, latestTurnFactForBody, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, turnFact, } from "./rows.js";
 import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, hasPendingTell, resolveTellDispositionSnapshot, tellDispositionResolved, tellFact, tellIdsForFence, turnParticipants, } from "./tells.js";
-import { activityFactSlice, statusFacts, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
+import { activityFactSlice, statusFacts, readStatusBatch, decodeTimelineBatch, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, withHeartTransaction, withReadOnlyHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
 import { AkumaBusyError, HeartAuthorityCorruptionError } from "./facts.js";
@@ -53,11 +53,56 @@ export async function appendActivity(paths, input) {
 export async function activitySlice(paths) {
     return await withReadOnlyHeart(paths, (heart) => activityFactSlice(heart));
 }
-export async function readStatusFacts(paths, input) {
-    return await withReadOnlyHeart(paths, (heart) => statusFacts(heart, input));
+export async function readStatusFacts(paths, input, signal) {
+    return await withReadOnlyHeart(paths, (heart) => statusFacts(heart, input), signal);
+}
+// Each query returns a fixed set of scalar columns; compare JSON columns as text.
+function sameRawRows(left, right) {
+    if (left.length !== right.length)
+        return false;
+    if (left.length === 0)
+        return true;
+    const columns = Object.keys(left[0]);
+    return left.every((row, index) => columns.every((column) => row[column] === right[index][column]));
+}
+function sameStatusBatch(left, right) {
+    return (left.frontier === right.frontier &&
+        sameRawRows(left.rows, right.rows) &&
+        sameRawRows(left.turns, right.turns) &&
+        sameRawRows(left.calls, right.calls) &&
+        sameRawRows(left.activity, right.activity) &&
+        sameRawRows(left.tells.rows, right.tells.rows) &&
+        sameRawRows(left.tells.deliveries, right.tells.deliveries) &&
+        sameRawRows(left.tells.bindings, right.tells.bindings));
+}
+/** One live observation's successful raw input and decoded frontier, never a connection. */
+export function createStatusFactReader(paths) {
+    let memo;
+    return {
+        clear() {
+            memo = undefined;
+        },
+        async read(input, signal) {
+            try {
+                const next = await withReadOnlyHeart(paths, (heart) => {
+                    const batch = readStatusBatch(heart, input);
+                    if (memo !== undefined && sameStatusBatch(batch, memo.batch))
+                        return memo;
+                    return { batch, facts: decodeTimelineBatch(batch) };
+                }, signal);
+                // Publication follows COMMIT, so failed reads can never supply a fallback.
+                memo = next;
+                return next.facts;
+            }
+            catch (error) {
+                memo = undefined;
+                throw error;
+            }
+        },
+    };
 }
 /** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
-export async function readLifeSnapshot(paths) {
+export async function readLifeSnapshot(paths, signal) {
     try {
         return await withReadOnlyHeart(paths, (heart) => ({
             soul: soulFact(heart),
@@ -65,7 +110,7 @@ export async function readLifeSnapshot(paths) {
             latestSession: latestSessionFact(heart),
             latestKill: latestKillFact(heart),
             hasPendingTell: hasPendingTell(heart),
-        }));
+        }), signal);
     }
     catch (error) {
         if (isHeartAbsent(error))

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

@@ -1,9 +1,39 @@
 import type { DatabaseSync } from "node:sqlite";
-import { type TellDeliveryInput, type TellFact, type TellReceiptInput } from "./facts.js";
+import { type TellDelivery, type TellDeliveryInput, type TellFact, type TellReceiptInput } from "./facts.js";
+type TellRow = Readonly<{
+    sequence: number;
+    id: string;
+    body: string;
+    schema_json: string | null;
+    initiator: string | null;
+    recorded_at: string;
+    state: TellFact["state"];
+}>;
+type TellDeliveryRow = Readonly<{
+    turn_sequence: number;
+    route: TellDelivery["route"];
+    receipt: TellDelivery["receipt"] | null;
+    delivered_at: string;
+}>;
 export declare const tellStateSql = "CASE\n  WHEN EXISTS (\n    SELECT 1 FROM tell_deliveries d\n    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')\n  ) THEN 'told'\n  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'\n  WHEN EXISTS (\n    SELECT 1 FROM tell_receipts r\n    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence\n    WHERE r.evidence = 'fence' AND d.tell_id = tells.id\n  ) THEN 'told'\n  ELSE 'pending'\nEND";
 export declare const pendingTellSequencesSql = "SELECT tells.sequence FROM tells WHERE CASE\n  WHEN EXISTS (\n    SELECT 1 FROM tell_deliveries d\n    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')\n  ) THEN 'told'\n  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'\n  WHEN EXISTS (\n    SELECT 1 FROM tell_receipts r\n    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence\n    WHERE r.evidence = 'fence' AND d.tell_id = tells.id\n  ) THEN 'told'\n  ELSE 'pending'\nEND = 'pending'\n  UNION SELECT tells.sequence FROM tells JOIN tell_disposition_members m ON m.tell_id = tells.id";
 export declare const pendingTellProtectionSql = "SELECT d.turn_sequence FROM tell_deliveries d\n  JOIN tells ON tells.id = d.tell_id WHERE CASE\n  WHEN EXISTS (\n    SELECT 1 FROM tell_deliveries d\n    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')\n  ) THEN 'told'\n  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'\n  WHEN EXISTS (\n    SELECT 1 FROM tell_receipts r\n    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence\n    WHERE r.evidence = 'fence' AND d.tell_id = tells.id\n  ) THEN 'told'\n  ELSE 'pending'\nEND = 'pending'\n  UNION SELECT d.turn_sequence FROM tell_deliveries d JOIN tell_disposition_members m ON m.tell_id = d.tell_id";
-export declare function tellFactsAtSequences(database: DatabaseSync, sequences: readonly number[]): readonly TellFact[];
+type TellBatch = Readonly<{
+    rows: readonly TellRow[];
+    deliveries: readonly (TellDeliveryRow & {
+        sequence: number;
+        tell_id: string;
+        fence: string;
+    })[];
+    bindings: readonly {
+        sequence: number;
+        tell_id: string;
+        turn_sequence: number;
+        bound_at: string;
+    }[];
+}>;
+export declare function decodeTellBatch(batch: TellBatch): readonly TellFact[];
+export declare function tellBatchAtSequences(database: DatabaseSync, sequences: readonly number[]): TellBatch;
 export declare function hasPendingTell(database: DatabaseSync): boolean;
 export declare function insertTellFact(database: DatabaseSync, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): number;
 export declare function tellFact(database: DatabaseSync, id: string): TellFact | null;
@@ -30,3 +60,4 @@ export declare function insertTellBindingFact(database: DatabaseSync, input: Rea
 export declare function turnParticipants(database: DatabaseSync, turnSequence: number): readonly string[];
 export declare function drainPendingTells(pending: readonly TellFact[], activeTurnSequences?: readonly number[]): readonly TellFact[];
 export declare function openBoundTurns(database: DatabaseSync, bodySequence: number): readonly number[];
+export {};

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

@@ -18,16 +18,26 @@ export const pendingTellSequencesSql = `SELECT tells.sequence FROM tells WHERE $
 export const pendingTellProtectionSql = `SELECT d.turn_sequence FROM tell_deliveries d
   JOIN tells ON tells.id = d.tell_id WHERE ${tellStateSql} = 'pending'
   UNION SELECT d.turn_sequence FROM tell_deliveries d JOIN tell_disposition_members m ON m.tell_id = d.tell_id`;
-function decodeTellRows(database, rows) {
+function readTellBatch(database, rows) {
     if (rows.length === 0)
-        return [];
+        return { rows, deliveries: [], bindings: [] };
     const ids = JSON.stringify(rows.map((row) => row.id));
-    const deliveries = new Map();
-    const deliveryRows = database
-        .prepare(`SELECT tell_id, turn_sequence, route, receipt, delivered_at
+    const deliveries = database
+        .prepare(`SELECT sequence, tell_id, turn_sequence, fence, route, receipt, delivered_at
     FROM tell_deliveries WHERE tell_id IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
         .all(ids);
-    for (const row of deliveryRows) {
+    const bindings = database
+        .prepare(`SELECT sequence, tell_id, turn_sequence, bound_at FROM tell_bindings
+    WHERE sequence IN (
+      SELECT MAX(sequence) FROM tell_bindings
+      WHERE tell_id IN (SELECT value FROM json_each(?)) GROUP BY tell_id
+    ) ORDER BY sequence`)
+        .all(ids);
+    return { rows, deliveries, bindings };
+}
+export function decodeTellBatch(batch) {
+    const deliveries = new Map();
+    for (const row of batch.deliveries) {
         const group = deliveries.get(row.tell_id) ?? [];
         group.push({
             turnSequence: row.turn_sequence,
@@ -38,16 +48,9 @@ function decodeTellRows(database, rows) {
         deliveries.set(row.tell_id, group);
     }
     const bindings = new Map();
-    const bindingRows = database
-        .prepare(`SELECT tell_id, turn_sequence, bound_at FROM tell_bindings
-    WHERE sequence IN (
-      SELECT MAX(sequence) FROM tell_bindings
-      WHERE tell_id IN (SELECT value FROM json_each(?)) GROUP BY tell_id
-    )`)
-        .all(ids);
-    for (const row of bindingRows)
+    for (const row of batch.bindings)
         bindings.set(row.tell_id, { turnSequence: row.turn_sequence, boundAt: row.bound_at });
-    return rows.map((row) => ({
+    return batch.rows.map((row) => ({
         kind: "tell",
         sequence: row.sequence,
         id: row.id,
@@ -60,14 +63,17 @@ function decodeTellRows(database, rows) {
         ...(bindings.has(row.id) ? { binding: bindings.get(row.id) } : {}),
     }));
 }
-export function tellFactsAtSequences(database, sequences) {
+function decodeTellRows(database, rows) {
+    return decodeTellBatch(readTellBatch(database, rows));
+}
+export function tellBatchAtSequences(database, sequences) {
     if (sequences.length === 0)
-        return [];
+        return { rows: [], deliveries: [], bindings: [] };
     const rows = database
         .prepare(`SELECT sequence, id, body, initiator, schema_json, recorded_at, ${tellStateSql} AS state
     FROM tells WHERE sequence IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
         .all(JSON.stringify(sequences));
-    return decodeTellRows(database, rows);
+    return readTellBatch(database, rows);
 }
 export function hasPendingTell(database) {
     return database.prepare(`SELECT 1 FROM tells WHERE ${tellStateSql} = 'pending' LIMIT 1`).get() !== undefined;

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

@@ -1,6 +1,7 @@
 import type { DatabaseSync } from "node:sqlite";
 import type { CallFact, TellFact, TurnEndFact, TurnStartFact } from "./facts.js";
-import { type ActivityFact } from "./rows.js";
+import { type ActivityFact, type ActivityRow, type CallRow, type TurnRow } from "./rows.js";
+import { tellBatchAtSequences } from "./tells.js";
 export type TimelineFact = TurnStartFact | CallFact | ActivityFact | TellFact | TurnEndFact;
 export type ActivityFactSlice = Readonly<{
     rows: readonly TimelineFact[];
@@ -9,10 +10,31 @@ export type ActivityFactSlice = Readonly<{
 }>;
 export declare function lastActivityAt(database: DatabaseSync): string | null;
 export declare function pruneActivityFacts(database: DatabaseSync, limit: number, protectionReleased?: boolean): void;
+type TimelineRow = Readonly<{
+    sequence: number;
+    kind: "turn-start" | "call" | "activity" | "tell" | "turn-end";
+}>;
+type TimelineBatch = Readonly<{
+    rows: readonly TimelineRow[];
+    turns: readonly TurnRow[];
+    calls: readonly CallRow[];
+    activity: readonly ActivityRow[];
+    tells: ReturnType<typeof tellBatchAtSequences>;
+}>;
+export declare function decodeTimelineBatch(batch: TimelineBatch): readonly TimelineFact[];
 export type StatusFactInput = Readonly<{
     aperture: "monitoring" | "receipt";
     admittedTellId?: string;
 }>;
 /** Select the frontier and its delivered Tells, plus aperture-required Tell pins. */
+export declare function readStatusBatch(database: DatabaseSync, input: StatusFactInput): {
+    rows: readonly TimelineRow[];
+    turns: readonly TurnRow[];
+    calls: readonly CallRow[];
+    activity: readonly ActivityRow[];
+    tells: ReturnType<typeof tellBatchAtSequences>;
+    frontier: number | null;
+};
 export declare function statusFacts(database: DatabaseSync, input: StatusFactInput): readonly TimelineFact[];
 export declare function activityFactSlice(database: DatabaseSync): ActivityFactSlice;
+export {};

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

@@ -1,5 +1,5 @@
 import { decodeActivityRow, decodeCallRow, decodeTurnRow, } from "./rows.js";
-import { tellFactsAtSequences, tellStateSql, pendingTellProtectionSql, pendingTellSequencesSql } from "./tells.js";
+import { decodeTellBatch, tellBatchAtSequences, tellStateSql, pendingTellProtectionSql, pendingTellSequencesSql, } from "./tells.js";
 export function lastActivityAt(database) {
     const row = database
         .prepare(`SELECT CASE timeline.kind
@@ -52,36 +52,40 @@ export function pruneActivityFacts(database, limit, protectionReleased = false)
     DELETE FROM timeline WHERE sequence < ? AND sequence NOT IN protected`)
         .run(cutoff.sequence, cutoff.sequence, cutoff.sequence, cutoff.sequence);
 }
-function decodeTimelineRows(database, rows) {
+function readTimelineBatch(database, rows) {
     const sequences = (kind) => JSON.stringify(rows.filter((row) => row.kind === kind).map((row) => row.sequence));
-    const facts = new Map();
     const turns = database
         .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome,
     history_id, session_json, answer, answer_json, schema_json, initiator, diagnostic, completed_at FROM turns
-    WHERE sequence IN (SELECT value FROM json_each(?)) OR end_sequence IN (SELECT value FROM json_each(?))`)
+    WHERE sequence IN (SELECT value FROM json_each(?)) OR end_sequence IN (SELECT value FROM json_each(?))
+    ORDER BY sequence`)
         .all(sequences("turn-start"), sequences("turn-end"));
-    for (const row of turns) {
-        const { end, ...start } = decodeTurnRow(row);
-        facts.set(start.sequence, start);
-        if (end !== undefined)
-            facts.set(end.sequence, end);
-    }
     const calls = database
         .prepare(`SELECT sequence, turn_sequence, body, at FROM calls
-    WHERE sequence IN (SELECT value FROM json_each(?))`)
+    WHERE sequence IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
         .all(sequences("call"));
-    for (const row of calls)
-        facts.set(row.sequence, decodeCallRow(row));
     const activity = database
         .prepare(`SELECT sequence, turn_sequence, event_json, at FROM activity
-    WHERE sequence IN (SELECT value FROM json_each(?))`)
+    WHERE sequence IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
         .all(sequences("activity"));
-    for (const row of activity)
+    const tells = tellBatchAtSequences(database, rows.filter((row) => row.kind === "tell").map((row) => row.sequence));
+    return { rows, turns, calls, activity, tells };
+}
+export function decodeTimelineBatch(batch) {
+    const facts = new Map();
+    for (const row of batch.turns) {
+        const { end, ...start } = decodeTurnRow(row);
+        facts.set(start.sequence, start);
+        if (end !== undefined)
+            facts.set(end.sequence, end);
+    }
+    for (const row of batch.calls)
+        facts.set(row.sequence, decodeCallRow(row));
+    for (const row of batch.activity)
         facts.set(row.sequence, decodeActivityRow(row));
-    const tells = tellFactsAtSequences(database, rows.filter((row) => row.kind === "tell").map((row) => row.sequence));
-    for (const fact of tells)
+    for (const fact of decodeTellBatch(batch.tells))
         facts.set(fact.sequence, fact);
-    return rows.map((row) => {
+    return batch.rows.map((row) => {
         const fact = facts.get(row.sequence);
         if (fact === undefined || fact.kind !== row.kind)
             throw new Error(`Akuma timeline references missing ${row.kind} ${row.sequence}`);
@@ -89,7 +93,7 @@ function decodeTimelineRows(database, rows) {
     });
 }
 /** Select the frontier and its delivered Tells, plus aperture-required Tell pins. */
-export function statusFacts(database, input) {
+export function readStatusBatch(database, input) {
     const frontier = database.prepare("SELECT sequence FROM turns ORDER BY sequence DESC LIMIT 1").get();
     const rows = database
         .prepare(`WITH selected(sequence) AS (
@@ -104,7 +108,10 @@ export function statusFacts(database, input) {
       UNION SELECT sequence FROM tells WHERE ? AND ${tellStateSql} = 'pending'
     ) SELECT timeline.sequence, timeline.kind FROM timeline JOIN selected USING(sequence) ORDER BY sequence`)
         .all(frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, input.admittedTellId ?? null, input.aperture === "monitoring" || input.admittedTellId === undefined ? 1 : 0);
-    return decodeTimelineRows(database, rows);
+    return { frontier: frontier?.sequence ?? null, ...readTimelineBatch(database, rows) };
+}
+export function statusFacts(database, input) {
+    return decodeTimelineBatch(readStatusBatch(database, input));
 }
 export function activityFactSlice(database) {
     const bounds = database.prepare("SELECT MIN(sequence) AS lowest, MAX(sequence) AS highest FROM timeline").get();
@@ -112,7 +119,7 @@ export function activityFactSlice(database) {
         .prepare("SELECT sequence, kind FROM timeline ORDER BY sequence")
         .all();
     return {
-        rows: decodeTimelineRows(database, rows),
+        rows: decodeTimelineBatch(readTimelineBatch(database, rows)),
         lowestRetained: bounds.lowest,
         highest: bounds.highest,
     };

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

@@ -41,8 +41,8 @@ export declare const tellRowSchema: z.ZodObject<{
         }>;
         turnSequence: z.ZodNumber;
         receipt: z.ZodOptional<z.ZodEnum<{
-            required: "required";
             unavailable: "unavailable";
+            required: "required";
         }>>;
     }, z.core.$strict>, z.ZodTransform<Readonly<{
         turnSequence: number;
@@ -53,7 +53,7 @@ export declare const tellRowSchema: z.ZodObject<{
         deliveredAt: string;
         route: "live" | "launch";
         turnSequence: number;
-        receipt?: "required" | "unavailable" | undefined;
+        receipt?: "unavailable" | "required" | undefined;
     }>>>>;
 }, z.core.$strict>;
 declare const outcomeSchema: z.ZodUnion<readonly [z.ZodObject<{
@@ -283,8 +283,8 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
         }>;
         turnSequence: z.ZodNumber;
         receipt: z.ZodOptional<z.ZodEnum<{
-            required: "required";
             unavailable: "unavailable";
+            required: "required";
         }>>;
     }, z.core.$strict>, z.ZodTransform<Readonly<{
         turnSequence: number;
@@ -295,7 +295,7 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
         deliveredAt: string;
         route: "live" | "launch";
         turnSequence: number;
-        receipt?: "required" | "unavailable" | undefined;
+        receipt?: "unavailable" | "required" | undefined;
     }>>>>;
 }, z.core.$strict>]>, z.ZodObject<{
     kind: z.ZodLiteral<"tool">;
@@ -449,8 +449,8 @@ declare const idleSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
         }>;
         turnSequence: z.ZodNumber;
         receipt: z.ZodOptional<z.ZodEnum<{
-            required: "required";
             unavailable: "unavailable";
+            required: "required";
         }>>;
     }, z.core.$strict>, z.ZodTransform<Readonly<{
         turnSequence: number;
@@ -461,7 +461,7 @@ declare const idleSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
         deliveredAt: string;
         route: "live" | "launch";
         turnSequence: number;
-        receipt?: "required" | "unavailable" | undefined;
+        receipt?: "unavailable" | "required" | undefined;
     }>>>>;
 }, z.core.$strict>]>, z.ZodObject<{
     kind: z.ZodLiteral<"tool">;
@@ -638,8 +638,8 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                 }>;
                 turnSequence: z.ZodNumber;
                 receipt: z.ZodOptional<z.ZodEnum<{
-                    required: "required";
                     unavailable: "unavailable";
+                    required: "required";
                 }>>;
             }, z.core.$strict>, z.ZodTransform<Readonly<{
                 turnSequence: number;
@@ -650,7 +650,7 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                 deliveredAt: string;
                 route: "live" | "launch";
                 turnSequence: number;
-                receipt?: "required" | "unavailable" | undefined;
+                receipt?: "unavailable" | "required" | undefined;
             }>>>>;
         }, z.core.$strict>]>, z.ZodObject<{
             kind: z.ZodLiteral<"tool">;
@@ -845,8 +845,8 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                 }>;
                 turnSequence: z.ZodNumber;
                 receipt: z.ZodOptional<z.ZodEnum<{
-                    required: "required";
                     unavailable: "unavailable";
+                    required: "required";
                 }>>;
             }, z.core.$strict>, z.ZodTransform<Readonly<{
                 turnSequence: number;
@@ -857,7 +857,7 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
                 deliveredAt: string;
                 route: "live" | "launch";
                 turnSequence: number;
-                receipt?: "required" | "unavailable" | undefined;
+                receipt?: "unavailable" | "required" | undefined;
             }>>>>;
         }, z.core.$strict>]>, z.ZodObject<{
             kind: z.ZodLiteral<"tool">;