@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/core/projection/heart.js

@@ -1,316 +1,9 @@
-import * as fs from "node:fs";
 import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { isErrnoException } from "../../errno.js";
 export const HEART_FILE = "heart";
-const HEART_SCHEMA_VERSION = 1;
 export const HEART_BUSY_TIMEOUT_MS = 5_000;
-export class ProjectionHeartError extends Error {
-    code = "PROJECTION_HEART_ERROR";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ProjectionHeartError";
-    }
-}
-const HEART_SCHEMA_SQL = `
-  CREATE TABLE heart_schema (
-    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-    version INTEGER NOT NULL CHECK (version = ${HEART_SCHEMA_VERSION})
-  ) STRICT
-`;
-const IDENTITY_TABLE_SQL = `
-  CREATE TABLE projection_identity (
-    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-    version INTEGER NOT NULL CHECK (version = 1),
-    pid INTEGER NOT NULL CHECK (pid >= 0),
-    akuma TEXT NOT NULL CHECK (length(trim(akuma)) > 0),
-    provider TEXT NOT NULL CHECK (length(trim(provider)) > 0),
-    authority_json TEXT NOT NULL CHECK (json_valid(authority_json)),
-    binding_json TEXT NOT NULL CHECK (json_valid(binding_json)),
-    minted_at TEXT NOT NULL CHECK (length(trim(minted_at)) > 0),
-    workspace_root TEXT NOT NULL CHECK (length(trim(workspace_root)) > 0),
-    effective_policy_json TEXT CHECK (
-      effective_policy_json IS NULL OR json_valid(effective_policy_json)
-    )
-  ) STRICT
-`;
-const RECORD_TABLE_SQL = `
-  CREATE TABLE generation_records (
-    seq INTEGER PRIMARY KEY CHECK (seq > 0),
-    kind TEXT NOT NULL CHECK (kind IN ('launch', 'adoption', 'verdict')),
-    execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
-    payload_json TEXT NOT NULL CHECK (json_valid(payload_json))
-  ) STRICT
-`;
-const TELL_TABLE_SQL = `
-  CREATE TABLE projection_tells (
-    tell_id TEXT PRIMARY KEY CHECK (length(trim(tell_id)) > 0),
-    text TEXT NOT NULL,
-    created_at TEXT NOT NULL CHECK (length(trim(created_at)) > 0),
-    effort TEXT CHECK (effort IS NULL OR length(trim(effort)) > 0),
-    state TEXT NOT NULL CHECK (
-      state IN ('inbox', 'inflight', 'submitted', 'consumed', 'delivered')
-    ),
-    execution_id TEXT CHECK (
-      execution_id IS NULL OR length(trim(execution_id)) > 0
-    ),
-    fence_json TEXT CHECK (fence_json IS NULL OR json_valid(fence_json)),
-    replayed_from_json TEXT CHECK (
-      replayed_from_json IS NULL OR json_valid(replayed_from_json)
-    ),
-    delivered_at TEXT CHECK (
-      delivered_at IS NULL OR length(trim(delivered_at)) > 0
-    )
-  ) STRICT
-`;
-const EXPECTED_OBJECT_SIGNATURE = "table:generation_records,table:heart_schema,table:projection_identity,table:projection_tells";
-const EXPECTED_RECORD_COLUMNS = "seq:INTEGER:0:1,kind:TEXT:1:0,execution_id:TEXT:1:0,payload_json:TEXT:1:0";
-const EXPECTED_IDENTITY_COLUMNS = "singleton:INTEGER:0:1,version:INTEGER:1:0,pid:INTEGER:1:0,akuma:TEXT:1:0,provider:TEXT:1:0,authority_json:TEXT:1:0,binding_json:TEXT:1:0,minted_at:TEXT:1:0,workspace_root:TEXT:1:0,effective_policy_json:TEXT:0:0";
-const EXPECTED_TELL_COLUMNS = "tell_id:TEXT:1:1,text:TEXT:1:0,created_at:TEXT:1:0,effort:TEXT:0:0,state:TEXT:1:0,execution_id:TEXT:0:0,fence_json:TEXT:0:0,replayed_from_json:TEXT:0:0,delivered_at:TEXT:0:0";
 export function heartPath(projectionDirectory) {
     return path.join(projectionDirectory, HEART_FILE);
 }
-function rollbackQuietly(database) {
-    try {
-        database.exec("ROLLBACK");
-    }
-    catch {
-        // Preserve the write or schema failure that caused the rollback.
-    }
-}
-function assertParentDirectory(projectionDirectory) {
-    let stat;
-    try {
-        stat = fs.statSync(projectionDirectory);
-    }
-    catch (error) {
-        throw new ProjectionHeartError(`projection heart parent directory does not exist at ${projectionDirectory}`, { cause: error });
-    }
-    if (!stat.isDirectory()) {
-        throw new ProjectionHeartError("projection heart parent must be a directory");
-    }
-}
-function assertRegularHeartFile(databasePath) {
-    let stat;
-    try {
-        stat = fs.lstatSync(databasePath);
-    }
-    catch (error) {
-        throw new ProjectionHeartError(`projection heart does not exist at ${databasePath}`, { cause: error });
-    }
-    if (!stat.isFile()) {
-        throw new ProjectionHeartError("projection heart must be a regular file");
-    }
-}
 export function configureHeartBusyTimeout(database) {
     database.exec(`PRAGMA busy_timeout = ${HEART_BUSY_TIMEOUT_MS}`);
 }
-function configureWritable(database) {
-    configureHeartBusyTimeout(database);
-    database.exec("PRAGMA journal_mode = DELETE");
-    database.exec("PRAGMA synchronous = FULL");
-    database.exec("PRAGMA foreign_keys = ON");
-    database.exec("PRAGMA trusted_schema = OFF");
-}
-function columnSignature(database, table) {
-    const columns = database.prepare(`PRAGMA table_info(${table})`).all();
-    return columns
-        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-        .join(",");
-}
-function validateSchemaShape(database) {
-    const objects = database.prepare(`
-    SELECT name, type
-    FROM sqlite_schema
-    WHERE name NOT LIKE 'sqlite_%'
-    ORDER BY name
-  `).all();
-    const signature = objects.map((object) => `${object.type}:${object.name}`).join(",");
-    if (signature !== EXPECTED_OBJECT_SIGNATURE) {
-        throw new ProjectionHeartError(`projection heart schema contains unexpected objects: ${signature || "none"}`);
-    }
-    const metadata = database.prepare("SELECT singleton, version FROM heart_schema").all();
-    if (metadata.length !== 1
-        || Number(metadata[0].singleton) !== 1
-        || Number(metadata[0].version) !== HEART_SCHEMA_VERSION) {
-        throw new ProjectionHeartError("projection heart schema metadata is malformed");
-    }
-    if (columnSignature(database, "generation_records") !== EXPECTED_RECORD_COLUMNS) {
-        throw new ProjectionHeartError("projection heart generation_records schema is malformed");
-    }
-    if (columnSignature(database, "projection_identity") !== EXPECTED_IDENTITY_COLUMNS) {
-        throw new ProjectionHeartError("projection heart projection_identity schema is malformed");
-    }
-    if (columnSignature(database, "projection_tells") !== EXPECTED_TELL_COLUMNS) {
-        throw new ProjectionHeartError("projection heart projection_tells schema is malformed");
-    }
-    const quickCheck = database.prepare("PRAGMA quick_check").get();
-    if (!quickCheck || Object.values(quickCheck)[0] !== "ok") {
-        throw new ProjectionHeartError("projection heart database failed quick_check");
-    }
-}
-function installSchema(database) {
-    database.exec("BEGIN EXCLUSIVE");
-    try {
-        const objects = database.prepare(`
-      SELECT name, type
-      FROM sqlite_schema
-      WHERE name NOT LIKE 'sqlite_%'
-      ORDER BY name
-    `).all();
-        if (objects.length !== 0) {
-            throw new ProjectionHeartError("projection heart already contains schema objects");
-        }
-        database.exec(HEART_SCHEMA_SQL);
-        database.exec(IDENTITY_TABLE_SQL);
-        database.exec(RECORD_TABLE_SQL);
-        database.exec(TELL_TABLE_SQL);
-        database.prepare("INSERT INTO heart_schema (singleton, version) VALUES (1, ?)")
-            .run(HEART_SCHEMA_VERSION);
-        validateSchemaShape(database);
-        database.exec("COMMIT");
-    }
-    catch (error) {
-        rollbackQuietly(database);
-        throw error;
-    }
-}
-export class ProjectionHeart {
-    databasePath;
-    readOnly;
-    #database;
-    #closed = false;
-    constructor(databasePath, database, readOnly) {
-        this.databasePath = databasePath;
-        this.#database = database;
-        this.readOnly = readOnly;
-    }
-    /** Create a brand-new heart database with schema v1. Fails if the file already exists. */
-    static create(projectionDirectory) {
-        assertParentDirectory(projectionDirectory);
-        const databasePath = heartPath(projectionDirectory);
-        let reserved = false;
-        try {
-            const fd = fs.openSync(databasePath, "wx");
-            fs.closeSync(fd);
-            reserved = true;
-        }
-        catch (error) {
-            if (isErrnoException(error) && error.code === "EEXIST") {
-                throw new ProjectionHeartError(`projection heart already exists at ${databasePath}`, { cause: error });
-            }
-            throw new ProjectionHeartError(`cannot create projection heart at ${databasePath}`, { cause: error });
-        }
-        let database;
-        try {
-            database = new DatabaseSync(databasePath, {
-                enableForeignKeyConstraints: true,
-                enableDoubleQuotedStringLiterals: false,
-                allowExtension: false,
-            });
-            configureWritable(database);
-            installSchema(database);
-            return new ProjectionHeart(databasePath, database, false);
-        }
-        catch (error) {
-            try {
-                database?.close();
-            }
-            catch { /* preserve the causal create failure */ }
-            if (reserved) {
-                try {
-                    fs.unlinkSync(databasePath);
-                }
-                catch {
-                    // Leave a partial file only if unlink itself fails.
-                }
-            }
-            if (error instanceof ProjectionHeartError)
-                throw error;
-            throw new ProjectionHeartError(`cannot create projection heart at ${databasePath}`, { cause: error });
-        }
-    }
-    /** Open an existing heart read-only. Never creates, mutates, or migrates. */
-    static openReadOnly(projectionDirectory) {
-        assertParentDirectory(projectionDirectory);
-        const databasePath = heartPath(projectionDirectory);
-        assertRegularHeartFile(databasePath);
-        let database;
-        try {
-            database = new DatabaseSync(databasePath, {
-                readOnly: true,
-                enableDoubleQuotedStringLiterals: false,
-                allowExtension: false,
-            });
-            configureHeartBusyTimeout(database);
-            validateSchemaShape(database);
-            return new ProjectionHeart(databasePath, database, true);
-        }
-        catch (error) {
-            try {
-                database?.close();
-            }
-            catch { /* preserve open failure */ }
-            if (error instanceof ProjectionHeartError)
-                throw error;
-            throw new ProjectionHeartError(`cannot open projection heart at ${databasePath}`, { cause: error });
-        }
-    }
-    /** Open an existing heart for read/write. Never creates or migrates. */
-    static openWritable(projectionDirectory) {
-        assertParentDirectory(projectionDirectory);
-        const databasePath = heartPath(projectionDirectory);
-        assertRegularHeartFile(databasePath);
-        let database;
-        try {
-            database = new DatabaseSync(databasePath, {
-                enableForeignKeyConstraints: true,
-                enableDoubleQuotedStringLiterals: false,
-                allowExtension: false,
-            });
-            configureWritable(database);
-            validateSchemaShape(database);
-            return new ProjectionHeart(databasePath, database, false);
-        }
-        catch (error) {
-            try {
-                database?.close();
-            }
-            catch { /* preserve open failure */ }
-            if (error instanceof ProjectionHeartError)
-                throw error;
-            throw new ProjectionHeartError(`cannot open projection heart at ${databasePath}`, { cause: error });
-        }
-    }
-    read(fn) {
-        this.#assertOpen();
-        return fn(this.#database);
-    }
-    write(fn) {
-        this.#assertOpen();
-        if (this.readOnly) {
-            throw new ProjectionHeartError("projection heart is read-only");
-        }
-        this.#database.exec("BEGIN IMMEDIATE");
-        try {
-            const result = fn(this.#database);
-            this.#database.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            rollbackQuietly(this.#database);
-            throw error;
-        }
-    }
-    close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        this.#database.close();
-    }
-    #assertOpen() {
-        if (this.#closed) {
-            throw new ProjectionHeartError("projection heart is closed");
-        }
-    }
-}

package/build/core/projection/tell/database.js

@@ -0,0 +1,109 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { ProjectionStateError } from "../../atomic-publish.js";
+import { PROJECTION_GENERATION_STORE_FILE, } from "../generation/store.js";
+import { configureHeartBusyTimeout } from "../heart.js";
+function databasePath(projectionDirectory) {
+    return path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
+}
+function openDatabase(projectionDirectory, readOnly) {
+    const target = databasePath(projectionDirectory);
+    if (!fs.lstatSync(target).isFile()) {
+        throw new ProjectionStateError("projection heart must be a regular file");
+    }
+    const database = new DatabaseSync(target, {
+        readOnly,
+        enableForeignKeyConstraints: true,
+        enableDoubleQuotedStringLiterals: false,
+        allowExtension: false,
+    });
+    configureHeartBusyTimeout(database);
+    if (!readOnly) {
+        database.exec("PRAGMA foreign_keys = ON");
+        database.exec("PRAGMA trusted_schema = OFF");
+    }
+    return database;
+}
+function rollbackQuietly(database) {
+    try {
+        database.exec("ROLLBACK");
+    }
+    catch {
+        // Preserve the transition failure.
+    }
+}
+export function withRead(projectionDirectory, read) {
+    const database = openDatabase(projectionDirectory, true);
+    try {
+        return read(database);
+    }
+    finally {
+        database.close();
+    }
+}
+export function withWrite(projectionDirectory, write) {
+    const database = openDatabase(projectionDirectory, false);
+    try {
+        database.exec("BEGIN IMMEDIATE");
+        try {
+            const result = write(database);
+            database.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            rollbackQuietly(database);
+            throw error;
+        }
+    }
+    finally {
+        database.close();
+    }
+}
+export function openProjectionTellObserver(projectionDirectory) {
+    const database = openDatabase(projectionDirectory, true);
+    let closed = false;
+    let observedDataVersion;
+    const assertOpen = () => {
+        if (closed)
+            throw new ProjectionStateError("projection tell observer is closed");
+    };
+    const readDataVersion = () => {
+        assertOpen();
+        const row = database.prepare("PRAGMA data_version").get();
+        const raw = row?.data_version;
+        const value = typeof raw === "bigint" ? Number(raw) : raw;
+        if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+            throw new ProjectionStateError("PRAGMA data_version returned an invalid value");
+        }
+        return value;
+    };
+    return {
+        hasDataVersionChanged() {
+            const current = readDataVersion();
+            if (observedDataVersion === undefined) {
+                observedDataVersion = current;
+                return true;
+            }
+            if (current === observedDataVersion)
+                return false;
+            observedDataVersion = current;
+            return true;
+        },
+        hasInbox() {
+            assertOpen();
+            return database.prepare(`
+        SELECT 1
+        FROM projection_tells
+        WHERE state = 'inbox'
+        LIMIT 1
+      `).get() !== undefined;
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            database.close();
+        },
+    };
+}

package/build/core/projection/tell/model.js

@@ -0,0 +1,97 @@
+import { ProjectionStateError } from "../../atomic-publish.js";
+export const PROJECTION_TELL_STATES = [
+    "inbox",
+    "inflight",
+    "submitted",
+    "consumed",
+    "delivered",
+];
+export function requireExecutionId(value) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new ProjectionStateError("submitted tell executionId must be a non-empty string");
+    }
+    return value;
+}
+export function parseFence(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new ProjectionStateError("tell fence is required");
+    }
+    const record = value;
+    if (record.kind === "turn" && typeof record.turnId === "string" && record.turnId.length > 0) {
+        return { kind: "turn", turnId: record.turnId };
+    }
+    if (record.kind === "ordinal"
+        && typeof record.ordinal === "number"
+        && Number.isSafeInteger(record.ordinal)
+        && record.ordinal >= 0) {
+        return { kind: "ordinal", ordinal: record.ordinal };
+    }
+    throw new ProjectionStateError("tell fence must be turn(string) or ordinal(non-negative integer)");
+}
+function decodeJson(value, location) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        throw new ProjectionStateError(`${location} contains malformed JSON`, { cause: error });
+    }
+}
+function parseReplay(value) {
+    if (value === null)
+        return [];
+    const decoded = decodeJson(value, "tell replay history");
+    if (!Array.isArray(decoded))
+        throw new ProjectionStateError("tell replay history must be an array");
+    return decoded.map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            throw new ProjectionStateError("tell replay history entry must be an object");
+        }
+        const entry = item;
+        return {
+            executionId: requireExecutionId(entry.executionId),
+            fence: parseFence(entry.fence),
+        };
+    });
+}
+export function originalFromRow(row) {
+    return {
+        version: 1,
+        text: row.text,
+        createdAt: row.created_at,
+        ...(row.effort ? { effort: row.effort } : {}),
+    };
+}
+export function submittedFromRow(row) {
+    if (row.state !== "submitted" && row.state !== "consumed" && row.state !== "delivered") {
+        throw new ProjectionStateError(`tell '${row.tell_id}' is not submitted`);
+    }
+    if (row.execution_id === null || row.fence_json === null) {
+        throw new ProjectionStateError(`tell '${row.tell_id}' is missing submission facts`);
+    }
+    const replayedFrom = parseReplay(row.replayed_from_json);
+    return {
+        ...originalFromRow(row),
+        executionId: requireExecutionId(row.execution_id),
+        fence: parseFence(decodeJson(row.fence_json, "tell fence")),
+        ...(replayedFrom.length > 0 ? { replayedFrom } : {}),
+    };
+}
+export function assertTellIdRandomHex(randomHex) {
+    if (!/^[0-9a-f]{8}$/.test(randomHex)) {
+        throw new ProjectionStateError(`tell id random segment must be 8 lowercase hex chars, got ${randomHex}`);
+    }
+    return randomHex;
+}
+/** The only tell-consumption predicate. */
+export function isTellCausallyConsumed(submitted, checkpoint) {
+    if (submitted.kind !== checkpoint.kind) {
+        throw new ProjectionStateError(`tell fence kind mismatch: ${submitted.kind} vs ${checkpoint.kind}`);
+    }
+    if (submitted.kind === "ordinal" && checkpoint.kind === "ordinal") {
+        return checkpoint.ordinal > submitted.ordinal;
+    }
+    if (submitted.kind === "turn" && checkpoint.kind === "turn") {
+        return checkpoint.turnId === submitted.turnId;
+    }
+    throw new ProjectionStateError("unreachable tell fence comparison");
+}

package/build/core/{projection-tells.js → projection/tell/store.js}

@@ -1,143 +1,7 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { ProjectionStateError, randomHex8 } from "./atomic-publish.js";
-import { PROJECTION_GENERATION_STORE_FILE, } from "./projection-generation-store.js";
-import { configureHeartBusyTimeout } from "./projection/heart.js";
-export const PROJECTION_TELL_STATES = [
-    "inbox",
-    "inflight",
-    "submitted",
-    "consumed",
-    "delivered",
-];
+import { ProjectionStateError, randomHex8 } from "../../atomic-publish.js";
+import { withRead, withWrite } from "./database.js";
+import { assertTellIdRandomHex, originalFromRow, parseFence, requireExecutionId, submittedFromRow, } from "./model.js";
 const PENDING_TELL_LIMIT = 10_000;
-function databasePath(projectionDirectory) {
-    return path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
-}
-function openDatabase(projectionDirectory, readOnly) {
-    const target = databasePath(projectionDirectory);
-    if (!fs.lstatSync(target).isFile()) {
-        throw new ProjectionStateError("projection heart must be a regular file");
-    }
-    const database = new DatabaseSync(target, {
-        readOnly,
-        enableForeignKeyConstraints: true,
-        enableDoubleQuotedStringLiterals: false,
-        allowExtension: false,
-    });
-    configureHeartBusyTimeout(database);
-    if (!readOnly) {
-        database.exec("PRAGMA foreign_keys = ON");
-        database.exec("PRAGMA trusted_schema = OFF");
-    }
-    return database;
-}
-function rollbackQuietly(database) {
-    try {
-        database.exec("ROLLBACK");
-    }
-    catch {
-        // Preserve the transition failure.
-    }
-}
-function withRead(projectionDirectory, read) {
-    const database = openDatabase(projectionDirectory, true);
-    try {
-        return read(database);
-    }
-    finally {
-        database.close();
-    }
-}
-function withWrite(projectionDirectory, write) {
-    const database = openDatabase(projectionDirectory, false);
-    try {
-        database.exec("BEGIN IMMEDIATE");
-        try {
-            const result = write(database);
-            database.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            rollbackQuietly(database);
-            throw error;
-        }
-    }
-    finally {
-        database.close();
-    }
-}
-function requireExecutionId(value) {
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new ProjectionStateError("submitted tell executionId must be a non-empty string");
-    }
-    return value;
-}
-function parseFence(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new ProjectionStateError("tell fence is required");
-    }
-    const record = value;
-    if (record.kind === "turn" && typeof record.turnId === "string" && record.turnId.length > 0) {
-        return { kind: "turn", turnId: record.turnId };
-    }
-    if (record.kind === "ordinal"
-        && typeof record.ordinal === "number"
-        && Number.isSafeInteger(record.ordinal)
-        && record.ordinal >= 0) {
-        return { kind: "ordinal", ordinal: record.ordinal };
-    }
-    throw new ProjectionStateError("tell fence must be turn(string) or ordinal(non-negative integer)");
-}
-function decodeJson(value, location) {
-    try {
-        return JSON.parse(value);
-    }
-    catch (error) {
-        throw new ProjectionStateError(`${location} contains malformed JSON`, { cause: error });
-    }
-}
-function parseReplay(value) {
-    if (value === null)
-        return [];
-    const decoded = decodeJson(value, "tell replay history");
-    if (!Array.isArray(decoded))
-        throw new ProjectionStateError("tell replay history must be an array");
-    return decoded.map((item) => {
-        if (!item || typeof item !== "object" || Array.isArray(item)) {
-            throw new ProjectionStateError("tell replay history entry must be an object");
-        }
-        const entry = item;
-        return {
-            executionId: requireExecutionId(entry.executionId),
-            fence: parseFence(entry.fence),
-        };
-    });
-}
-function originalFromRow(row) {
-    return {
-        version: 1,
-        text: row.text,
-        createdAt: row.created_at,
-        ...(row.effort ? { effort: row.effort } : {}),
-    };
-}
-function submittedFromRow(row) {
-    if (row.state !== "submitted" && row.state !== "consumed" && row.state !== "delivered") {
-        throw new ProjectionStateError(`tell '${row.tell_id}' is not submitted`);
-    }
-    if (row.execution_id === null || row.fence_json === null) {
-        throw new ProjectionStateError(`tell '${row.tell_id}' is missing submission facts`);
-    }
-    const replayedFrom = parseReplay(row.replayed_from_json);
-    return {
-        ...originalFromRow(row),
-        executionId: requireExecutionId(row.execution_id),
-        fence: parseFence(decodeJson(row.fence_json, "tell fence")),
-        ...(replayedFrom.length > 0 ? { replayedFrom } : {}),
-    };
-}
 function selectTell(database, tellId) {
     return database.prepare(`
     SELECT
@@ -154,12 +18,6 @@ function selectTell(database, tellId) {
     WHERE tell_id = ?
   `).get(tellId);
 }
-function assertTellIdRandomHex(randomHex) {
-    if (!/^[0-9a-f]{8}$/.test(randomHex)) {
-        throw new ProjectionStateError(`tell id random segment must be 8 lowercase hex chars, got ${randomHex}`);
-    }
-    return randomHex;
-}
 export function listTellIds(projectionDirectory, state) {
     return withRead(projectionDirectory, (database) => database.prepare(`
       SELECT tell_id
@@ -386,16 +244,3 @@ export function demoteSubmittedTellsForReplay(projectionDirectory, executionId)
         return rows.map((row) => row.tell_id);
     });
 }
-/** The only tell-consumption predicate. */
-export function isTellCausallyConsumed(submitted, checkpoint) {
-    if (submitted.kind !== checkpoint.kind) {
-        throw new ProjectionStateError(`tell fence kind mismatch: ${submitted.kind} vs ${checkpoint.kind}`);
-    }
-    if (submitted.kind === "ordinal" && checkpoint.kind === "ordinal") {
-        return checkpoint.ordinal > submitted.ordinal;
-    }
-    if (submitted.kind === "turn" && checkpoint.kind === "turn") {
-        return checkpoint.turnId === submitted.turnId;
-    }
-    throw new ProjectionStateError("unreachable tell fence comparison");
-}