@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -1,473 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { ProjectionStateError } from "../../atomic-publish.js";
-import { configureHeartBusyTimeout } from "../heart.js";
-import { ProjectionGenerationStoreError, parseStoredRow, validateHistory, } from "./model.js";
-import { ProjectionGenerationLedger } from "./ledger.js";
-export const PROJECTION_GENERATION_STORE_FILE = "heart";
-export const PROJECTION_GENERATION_SCHEMA_VERSION = 6;
-const GENERATION_SCHEMA_SQL = `
-  CREATE TABLE generation_schema (
-    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-    version INTEGER NOT NULL CHECK (version = ${PROJECTION_GENERATION_SCHEMA_VERSION})
-  ) STRICT
-`;
-const GENERATION_RECORD_SQL = `
-  CREATE TABLE generation_records (
-    seq INTEGER PRIMARY KEY CHECK (seq > 0),
-    activity_kind TEXT NOT NULL CHECK (activity_kind IN ('launch', 'adoption', 'kill-intent', 'interrupt-intent', 'verdict')),
-    execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
-    facts_json TEXT NOT NULL CHECK (json_valid(facts_json))
-  ) 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 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', 'seen', 'consumed')
-    ),
-    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)
-    )
-  ) STRICT
-`;
-const TELL_RECEIPT_TABLE_SQL = `
-  CREATE TABLE projection_tell_receipts (
-    tell_id TEXT NOT NULL REFERENCES projection_tells(tell_id),
-    execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
-    stage TEXT NOT NULL CHECK (stage IN ('seen', 'consumed')),
-    correlation_kind TEXT NOT NULL CHECK (correlation_kind IN ('exact', 'fence', 'inherited')),
-    fence_json TEXT CHECK (fence_json IS NULL OR json_valid(fence_json)),
-    received_at TEXT NOT NULL CHECK (length(trim(received_at)) > 0),
-    PRIMARY KEY (tell_id, execution_id, stage)
-  ) STRICT
-`;
-const TELL_RECEIPT_CAPABILITY_TABLE_SQL = `
-  CREATE TABLE projection_tell_receipt_capabilities (
-    execution_id TEXT PRIMARY KEY CHECK (length(trim(execution_id)) > 0),
-    seen TEXT NOT NULL CHECK (seen IN ('exact', 'fence', 'unavailable')),
-    consumed TEXT NOT NULL CHECK (consumed IN ('exact', 'fence', 'unavailable'))
-  ) STRICT
-`;
-const TELL_LAUNCH_BATCH_TABLE_SQL = `
-  CREATE TABLE projection_tell_launch_batches (
-    execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
-    tell_id TEXT NOT NULL REFERENCES projection_tells(tell_id),
-    PRIMARY KEY (execution_id, tell_id)
-  ) STRICT
-`;
-/** One row records that an execution's launch-input membership is fixed, even when empty. */
-const TELL_LAUNCH_ADMISSION_TABLE_SQL = `
-  CREATE TABLE projection_tell_launch_admissions (
-    execution_id TEXT PRIMARY KEY CHECK (length(trim(execution_id)) > 0)
-  ) STRICT
-`;
-const TELL_LAUNCH_COORDINATE_TABLE_SQL = `
-  CREATE TABLE projection_tell_launch_coordinates (
-    execution_id TEXT NOT NULL CHECK (length(trim(execution_id)) > 0),
-    fence_json TEXT NOT NULL CHECK (json_valid(fence_json)),
-    PRIMARY KEY (execution_id, fence_json)
-  ) STRICT
-`;
-const closedDatabases = new WeakSet();
-function projectionHeartPath(projectionDirectory) {
-    return path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
-}
-function openHeartConnection(databasePath, readOnly, foreignKeys = false) {
-    const database = new DatabaseSync(databasePath, {
-        readOnly,
-        ...(foreignKeys ? { enableForeignKeyConstraints: true } : {}),
-        enableDoubleQuotedStringLiterals: false,
-        allowExtension: false,
-    });
-    try {
-        configureHeartBusyTimeout(database);
-        if (!readOnly) {
-            database.exec("PRAGMA journal_mode = DELETE");
-            database.exec("PRAGMA synchronous = FULL");
-            database.exec("PRAGMA foreign_keys = ON");
-            database.exec("PRAGMA trusted_schema = OFF");
-        }
-        return database;
-    }
-    catch (error) {
-        try {
-            database.close();
-        }
-        catch { /* preserve configuration failure */ }
-        throw error;
-    }
-}
-/** Classify only proved missing schema evidence as historical incompatibility. */
-export function projectionGenerationStoreInspectionError(databasePath, error) {
-    if (error instanceof ProjectionGenerationStoreError)
-        return error;
-    const code = error && typeof error === "object" && "code" in error
-        ? error.code
-        : undefined;
-    if (code === "ENOENT") {
-        return new ProjectionGenerationStoreError(`projection generation store does not exist at ${databasePath}`, {
-            cause: error,
-            observation: "incompatible",
-        });
-    }
-    return new ProjectionGenerationStoreError(`projection generation store could not be inspected at ${databasePath}`, {
-        cause: error,
-    });
-}
-function projectionGenerationStoreReadError(databasePath, error) {
-    if (error instanceof ProjectionGenerationStoreError)
-        return error;
-    const sqliteCode = error && typeof error === "object" && "errcode" in error
-        ? error.errcode
-        : undefined;
-    const incompatible = sqliteCode === 11 || sqliteCode === 26;
-    return new ProjectionGenerationStoreError(`cannot read projection generation store at ${databasePath}`, {
-        cause: error,
-        ...(incompatible ? { observation: "incompatible" } : {}),
-    });
-}
-function pragmaNumber(database, pragma) {
-    const row = database.prepare(`PRAGMA ${pragma}`).get();
-    const value = row ? Object.values(row)[0] : undefined;
-    if (typeof value !== "number" && typeof value !== "bigint") {
-        throw new ProjectionGenerationStoreError(`PRAGMA ${pragma} returned an invalid value`, { observation: "incompatible" });
-    }
-    return Number(value);
-}
-export function rollbackQuietly(database) {
-    try {
-        database.exec("ROLLBACK");
-    }
-    catch {
-        // Preserve the transition or schema failure that caused the rollback.
-    }
-}
-function validateSchemaShape(database) {
-    const version = pragmaNumber(database, "user_version");
-    if (version !== PROJECTION_GENERATION_SCHEMA_VERSION) {
-        throw new ProjectionGenerationStoreError(`incompatible projection generation schema version ${version}; expected ${PROJECTION_GENERATION_SCHEMA_VERSION}`, { observation: "incompatible" });
-    }
-    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 !== "table:generation_records,table:generation_schema,table:projection_identity,table:projection_tell_launch_admissions,table:projection_tell_launch_batches,table:projection_tell_launch_coordinates,table:projection_tell_receipt_capabilities,table:projection_tell_receipts,table:projection_tells") {
-        throw new ProjectionGenerationStoreError(`projection generation schema contains unexpected objects: ${signature || "none"}`, { observation: "incompatible" });
-    }
-    const metadata = database.prepare("SELECT singleton, version FROM generation_schema").all();
-    if (metadata.length !== 1
-        || Number(metadata[0].singleton) !== 1
-        || Number(metadata[0].version) !== PROJECTION_GENERATION_SCHEMA_VERSION) {
-        throw new ProjectionGenerationStoreError("projection generation schema metadata is malformed", { observation: "incompatible" });
-    }
-    const generationColumns = database.prepare("PRAGMA table_info(generation_records)").all();
-    const generationSignature = generationColumns
-        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-        .join(",");
-    if (generationSignature !== "seq:INTEGER:0:1,activity_kind:TEXT:1:0,execution_id:TEXT:1:0,facts_json:TEXT:1:0") {
-        throw new ProjectionGenerationStoreError("projection generation record schema is malformed", { observation: "incompatible" });
-    }
-    const identityColumns = database.prepare("PRAGMA table_info(projection_identity)").all();
-    const identitySignature = identityColumns
-        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-        .join(",");
-    if (identitySignature !== "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") {
-        throw new ProjectionGenerationStoreError("projection identity schema is malformed", { observation: "incompatible" });
-    }
-    const tellColumns = database.prepare("PRAGMA table_info(projection_tells)").all();
-    const tellSignature = tellColumns
-        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-        .join(",");
-    if (tellSignature !== "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") {
-        throw new ProjectionGenerationStoreError("projection tell schema is malformed", { observation: "incompatible" });
-    }
-    const receiptColumns = database.prepare("PRAGMA table_info(projection_tell_receipts)").all();
-    const receiptSignature = receiptColumns
-        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-        .join(",");
-    if (receiptSignature !== "tell_id:TEXT:1:1,execution_id:TEXT:1:2,stage:TEXT:1:3,correlation_kind:TEXT:1:0,fence_json:TEXT:0:0,received_at:TEXT:1:0") {
-        throw new ProjectionGenerationStoreError("projection tell receipt schema is malformed", { observation: "incompatible" });
-    }
-    const capabilityColumns = database.prepare("PRAGMA table_info(projection_tell_receipt_capabilities)").all();
-    const capabilitySignature = capabilityColumns
-        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-        .join(",");
-    if (capabilitySignature !== "execution_id:TEXT:1:1,seen:TEXT:1:0,consumed:TEXT:1:0") {
-        throw new ProjectionGenerationStoreError("projection tell receipt capability schema is malformed", { observation: "incompatible" });
-    }
-    const launchBatchColumns = database.prepare("PRAGMA table_info(projection_tell_launch_batches)").all();
-    const launchBatchSignature = launchBatchColumns
-        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-        .join(",");
-    if (launchBatchSignature !== "execution_id:TEXT:1:1,tell_id:TEXT:1:2") {
-        throw new ProjectionGenerationStoreError("projection tell launch batch schema is malformed", { observation: "incompatible" });
-    }
-    const launchAdmissionColumns = database.prepare("PRAGMA table_info(projection_tell_launch_admissions)").all();
-    const launchAdmissionSignature = launchAdmissionColumns
-        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-        .join(",");
-    if (launchAdmissionSignature !== "execution_id:TEXT:1:1") {
-        throw new ProjectionGenerationStoreError("projection tell launch admission schema is malformed", { observation: "incompatible" });
-    }
-    const launchCoordinateColumns = database.prepare("PRAGMA table_info(projection_tell_launch_coordinates)").all();
-    const launchCoordinateSignature = launchCoordinateColumns
-        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-        .join(",");
-    if (launchCoordinateSignature !== "execution_id:TEXT:1:1,fence_json:TEXT:1:2") {
-        throw new ProjectionGenerationStoreError("projection tell launch coordinate schema is malformed", { observation: "incompatible" });
-    }
-    const quickCheck = database.prepare("PRAGMA quick_check").get();
-    if (!quickCheck || Object.values(quickCheck)[0] !== "ok") {
-        throw new ProjectionGenerationStoreError("projection generation database failed quick_check", { observation: "incompatible" });
-    }
-}
-function initializeOrValidateSchema(database) {
-    database.exec("BEGIN EXCLUSIVE");
-    try {
-        const version = pragmaNumber(database, "user_version");
-        const objects = database.prepare(`
-      SELECT name, type
-      FROM sqlite_schema
-      WHERE name NOT LIKE 'sqlite_%'
-      ORDER BY name
-    `).all();
-        if (version === 0 && objects.length === 0) {
-            database.exec(GENERATION_SCHEMA_SQL);
-            database.exec(GENERATION_RECORD_SQL);
-            database.prepare("INSERT INTO generation_schema (singleton, version) VALUES (1, ?)")
-                .run(PROJECTION_GENERATION_SCHEMA_VERSION);
-            database.exec(IDENTITY_TABLE_SQL);
-            database.exec(TELL_TABLE_SQL);
-            database.exec(TELL_RECEIPT_TABLE_SQL);
-            database.exec(TELL_RECEIPT_CAPABILITY_TABLE_SQL);
-            database.exec(TELL_LAUNCH_BATCH_TABLE_SQL);
-            database.exec(TELL_LAUNCH_ADMISSION_TABLE_SQL);
-            database.exec(TELL_LAUNCH_COORDINATE_TABLE_SQL);
-            database.exec(`PRAGMA user_version = ${PROJECTION_GENERATION_SCHEMA_VERSION}`);
-        }
-        else if (version !== PROJECTION_GENERATION_SCHEMA_VERSION) {
-            throw new ProjectionGenerationStoreError(`incompatible projection generation schema version ${version}; expected ${PROJECTION_GENERATION_SCHEMA_VERSION}`, { observation: "incompatible" });
-        }
-        validateSchemaShape(database);
-        database.exec("COMMIT");
-    }
-    catch (error) {
-        rollbackQuietly(database);
-        throw error;
-    }
-}
-export function openMutableDatabase(projectionDirectory) {
-    const stat = fs.statSync(projectionDirectory);
-    if (!stat.isDirectory())
-        throw new ProjectionGenerationStoreError("projection generation store parent must be a directory");
-    const databasePath = projectionHeartPath(projectionDirectory);
-    let database;
-    try {
-        database = openHeartConnection(databasePath, false, true);
-    }
-    catch (error) {
-        try {
-            database?.close();
-        }
-        catch { /* preserve the open/configuration failure */ }
-        throw new ProjectionGenerationStoreError(`cannot open projection generation store at ${databasePath}`, { cause: error });
-    }
-    try {
-        initializeOrValidateSchema(database);
-        readValidatedHistory(database, false);
-        return { databasePath, database };
-    }
-    catch (error) {
-        database.close();
-        if (error instanceof ProjectionGenerationStoreError)
-            throw error;
-        throw new ProjectionGenerationStoreError(`invalid projection generation store at ${databasePath}`, { cause: error });
-    }
-}
-export function openReadOnlyDatabase(projectionDirectory) {
-    const stat = fs.statSync(projectionDirectory);
-    if (!stat.isDirectory())
-        throw new ProjectionGenerationStoreError("projection generation store parent must be a directory");
-    const databasePath = projectionHeartPath(projectionDirectory);
-    try {
-        if (!fs.lstatSync(databasePath).isFile()) {
-            throw new ProjectionGenerationStoreError("projection generation store must be a regular file", { observation: "incompatible" });
-        }
-    }
-    catch (error) {
-        throw projectionGenerationStoreInspectionError(databasePath, error);
-    }
-    let database;
-    try {
-        database = openHeartConnection(databasePath, true);
-        validateSchemaShape(database);
-        readValidatedHistory(database, true);
-        return { databasePath, database };
-    }
-    catch (error) {
-        try {
-            database?.close();
-        }
-        catch { /* preserve the read/open failure */ }
-        throw projectionGenerationStoreReadError(databasePath, error);
-    }
-}
-function withProjectionHeartOperation(open, mode, operation) {
-    const database = open();
-    try {
-        if (mode === "read")
-            return operation(database);
-        database.exec(mode === "snapshot" ? "BEGIN" : "BEGIN IMMEDIATE");
-        try {
-            const result = operation(database);
-            database.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            rollbackQuietly(database);
-            throw error;
-        }
-    }
-    finally {
-        closeDatabase(database);
-    }
-}
-/** Read the validated heart through one consistent SQLite snapshot. */
-export function withGenerationReadSnapshot(projectionDirectory, read) {
-    return withProjectionHeartOperation(() => openReadOnlyDatabase(projectionDirectory).database, "snapshot", read);
-}
-function openProjectionHeartDatabase(projectionDirectory, readOnly) {
-    const databasePath = projectionHeartPath(projectionDirectory);
-    if (!fs.lstatSync(databasePath).isFile()) {
-        throw new ProjectionStateError("projection heart must be a regular file");
-    }
-    return openHeartConnection(databasePath, readOnly, true);
-}
-export function withProjectionHeartRead(projectionDirectory, read) {
-    return withProjectionHeartOperation(() => openProjectionHeartDatabase(projectionDirectory, true), "read", read);
-}
-export function withProjectionHeartReadSnapshot(projectionDirectory, read) {
-    return withProjectionHeartOperation(() => openProjectionHeartDatabase(projectionDirectory, true), "snapshot", read);
-}
-export function withProjectionHeartWrite(projectionDirectory, write) {
-    return withProjectionHeartOperation(() => openProjectionHeartDatabase(projectionDirectory, false), "write", write);
-}
-export function openProjectionTellObserver(projectionDirectory) {
-    const database = openProjectionHeartDatabase(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 (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;
-            closeDatabase(database);
-        },
-    };
-}
-export function assertDatabaseOpen(database) {
-    if (closedDatabases.has(database))
-        throw new ProjectionGenerationStoreError("projection generation store is closed");
-}
-export function connectionBoundGenerationStore(database, readOnly) {
-    return new ProjectionGenerationLedger(database, readOnly);
-}
-export function readValidatedHistory(database, readOnly) {
-    const records = connectionBoundGenerationStore(database, readOnly).readRecords().map((record) => parseStoredRow({
-        seq: record.seq,
-        kind: record.kind,
-        execution_id: record.executionId,
-        facts_json: JSON.stringify(record.facts),
-    }));
-    return { records, current: validateHistory(records) };
-}
-export function appendRecord(database, kind, executionId, facts, seq) {
-    const record = connectionBoundGenerationStore(database, false)
-        .appendRecord(kind, executionId, facts, seq);
-    return {
-        seq: record.seq,
-        kind: record.kind,
-        executionId: record.executionId,
-        facts: record.facts,
-    };
-}
-export function writeTransition(database, readOnly, run) {
-    assertDatabaseOpen(database);
-    return connectionBoundGenerationStore(database, readOnly).write(run);
-}
-export function beginGenerationWriteTransaction(database, readOnly) {
-    assertDatabaseOpen(database);
-    connectionBoundGenerationStore(database, readOnly).beginWriteTransaction();
-}
-export function commitGenerationWriteTransaction(database) {
-    assertDatabaseOpen(database);
-    connectionBoundGenerationStore(database, false).commitWriteTransaction();
-}
-export function rollbackGenerationWriteTransaction(database) {
-    assertDatabaseOpen(database);
-    connectionBoundGenerationStore(database, false).rollbackWriteTransaction();
-}
-export function closeDatabase(database) {
-    if (closedDatabases.has(database))
-        return;
-    closedDatabases.add(database);
-    database.close();
-}

package/build/core/projection/generation/identity.js

@@ -1,84 +0,0 @@
-import { parseExecutionPact, } from "../../execution-pact.js";
-import { assertDatabaseOpen, rollbackQuietly, } from "./database.js";
-import { ProjectionGenerationStoreError } from "./model.js";
-export function initializeIdentity(database, databasePath, readOnly, identity) {
-    assertDatabaseOpen(database);
-    if (readOnly) {
-        throw new ProjectionGenerationStoreError("projection identity store is read-only");
-    }
-    const validated = parseExecutionPact(identity, `${databasePath}#projection_identity`);
-    database.exec("BEGIN IMMEDIATE");
-    try {
-        const existing = database.prepare("SELECT COUNT(*) AS count FROM projection_identity").get();
-        if (Number(existing?.count ?? 0) !== 0) {
-            throw new ProjectionGenerationStoreError("projection identity is already initialized");
-        }
-        database.prepare(`
-      INSERT INTO projection_identity (
-        singleton,
-        version,
-        pid,
-        akuma,
-        provider,
-        authority_json,
-        binding_json,
-        minted_at,
-        workspace_root,
-        effective_policy_json
-      ) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(validated.version, validated.pid, validated.akuma, validated.provider, JSON.stringify(validated.authority), JSON.stringify(validated.binding), validated.mintedAt, validated.workspaceRoot, validated.effectivePolicy === undefined
-            ? null
-            : JSON.stringify(validated.effectivePolicy));
-        database.exec("COMMIT");
-    }
-    catch (error) {
-        rollbackQuietly(database);
-        throw error;
-    }
-}
-export function readIdentity(database, databasePath) {
-    assertDatabaseOpen(database);
-    const rows = database.prepare(`
-    SELECT
-      version,
-      pid,
-      akuma,
-      provider,
-      authority_json,
-      binding_json,
-      minted_at,
-      workspace_root,
-      effective_policy_json
-    FROM projection_identity
-  `).all();
-    if (rows.length !== 1) {
-        throw new ProjectionGenerationStoreError(`projection identity row count must be 1, found ${rows.length}`);
-    }
-    const row = rows[0];
-    let authority;
-    let binding;
-    let effectivePolicy;
-    try {
-        authority = JSON.parse(row.authority_json);
-        binding = JSON.parse(row.binding_json);
-        effectivePolicy = row.effective_policy_json === null
-            ? undefined
-            : JSON.parse(row.effective_policy_json);
-    }
-    catch (error) {
-        throw new ProjectionGenerationStoreError("projection identity contains malformed JSON", {
-            cause: error,
-        });
-    }
-    return parseExecutionPact({
-        version: Number(row.version),
-        pid: Number(row.pid),
-        akuma: row.akuma,
-        provider: row.provider,
-        authority,
-        binding,
-        mintedAt: row.minted_at,
-        workspaceRoot: row.workspace_root,
-        ...(effectivePolicy === undefined ? {} : { effectivePolicy }),
-    }, `${databasePath}#projection_identity`);
-}

package/build/core/projection/generation/ledger.js

@@ -1,91 +0,0 @@
-import { assertExecutionId, assertPositiveSafeInteger, cloneFacts, ProjectionGenerationStoreError, } from "./model.js";
-const RECORD_KINDS = new Set([
-    "launch", "adoption", "kill-intent", "interrupt-intent", "verdict",
-]);
-/** The projection-owned persistence adapter for generation facts in heart. */
-export class ProjectionGenerationLedger {
-    #database;
-    #readOnly;
-    constructor(database, readOnly) {
-        this.#database = database;
-        this.#readOnly = readOnly;
-    }
-    readRecords() {
-        const rows = this.#database.prepare(`
-      SELECT seq, activity_kind, execution_id, facts_json
-      FROM generation_records
-      ORDER BY seq
-    `).all();
-        return rows.map((row) => {
-            const seq = assertPositiveSafeInteger(Number(row.seq), "generation row seq");
-            if (typeof row.activity_kind !== "string" || !RECORD_KINDS.has(row.activity_kind)) {
-                throw new ProjectionGenerationStoreError(`generation row ${seq} has unknown kind '${String(row.activity_kind)}'`);
-            }
-            if (typeof row.execution_id !== "string")
-                throw new ProjectionGenerationStoreError(`generation row ${seq} has invalid execution_id`);
-            const executionId = assertExecutionId(row.execution_id);
-            if (typeof row.facts_json !== "string")
-                throw new ProjectionGenerationStoreError(`generation row ${seq} facts_json must be text`);
-            let facts;
-            try {
-                facts = cloneFacts(JSON.parse(row.facts_json), `generation row ${seq} facts`);
-            }
-            catch (cause) {
-                if (cause instanceof Error && cause.message.startsWith(`generation row ${seq}`))
-                    throw cause;
-                throw new ProjectionGenerationStoreError(`generation row ${seq} facts_json is invalid JSON`, { cause });
-            }
-            return { seq, kind: row.activity_kind, executionId, facts };
-        });
-    }
-    appendRecord(kind, executionId, facts, seq) {
-        if (this.#readOnly)
-            throw new ProjectionGenerationStoreError("projection generation store is read-only");
-        const encoded = JSON.stringify(facts);
-        this.#database.prepare(`
-      INSERT INTO generation_records (seq, activity_kind, execution_id, facts_json)
-      VALUES (?, ?, ?, ?)
-    `).run(seq, kind, executionId, encoded);
-        return { seq, kind, executionId, facts: JSON.parse(encoded) };
-    }
-    write(run) {
-        if (this.#readOnly)
-            throw new ProjectionGenerationStoreError("projection generation store is read-only");
-        if (this.#database.isTransaction)
-            return run();
-        this.#database.exec("BEGIN IMMEDIATE");
-        try {
-            const result = run();
-            this.#database.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            this.rollback();
-            throw error;
-        }
-    }
-    beginWriteTransaction() {
-        if (this.#readOnly)
-            throw new ProjectionGenerationStoreError("projection generation store is read-only");
-        if (this.#database.isTransaction)
-            throw new ProjectionGenerationStoreError("projection generation write transaction is already open");
-        this.#database.exec("BEGIN IMMEDIATE");
-    }
-    commitWriteTransaction() {
-        if (!this.#database.isTransaction)
-            throw new ProjectionGenerationStoreError("projection generation write transaction is not open");
-        this.#database.exec("COMMIT");
-    }
-    rollbackWriteTransaction() {
-        if (this.#database.isTransaction)
-            this.rollback();
-    }
-    rollback() {
-        try {
-            this.#database.exec("ROLLBACK");
-        }
-        catch {
-            // Preserve the failure that caused rollback.
-        }
-    }
-}