@astrosheep/keiyaku 2.9.12 → 4.0.0

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

@@ -1,411 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { configureHeartBusyTimeout } from "../heart.js";
-import { ProjectionGenerationStoreError, parseStoredRow, validateHistory, } from "./model.js";
-export const PROJECTION_GENERATION_STORE_FILE = "heart";
-export const PROJECTION_GENERATION_SCHEMA_VERSION = 4;
-const SCHEMA_TABLE_SQL = `
-  CREATE TABLE generation_schema (
-    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-    version INTEGER NOT NULL CHECK (version = ${PROJECTION_GENERATION_SCHEMA_VERSION})
-  ) 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', '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();
-/** 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 recordColumns = database.prepare("PRAGMA table_info(generation_records)").all();
-    const columnSignature = recordColumns
-        .map((column) => `${column.name}:${column.type}:${Number(column.notnull)}:${Number(column.pk)}`)
-        .join(",");
-    if (columnSignature !== "seq:INTEGER:0:1,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(SCHEMA_TABLE_SQL);
-            database.exec(RECORD_TABLE_SQL);
-            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.prepare("INSERT INTO generation_schema (singleton, version) VALUES (1, ?)")
-                .run(PROJECTION_GENERATION_SCHEMA_VERSION);
-            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 = path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
-    let database;
-    try {
-        database = new DatabaseSync(databasePath, {
-            enableForeignKeyConstraints: true,
-            enableDoubleQuotedStringLiterals: false,
-            allowExtension: false,
-        });
-        configureHeartBusyTimeout(database);
-        // Rollback journal keeps observers genuinely read-only. A read-only WAL
-        // connection creates/updates -wal and -shm coordination files, while
-        // immutable WAL reads can miss concurrently committed facts.
-        database.exec("PRAGMA journal_mode = DELETE");
-        database.exec("PRAGMA synchronous = FULL");
-        database.exec("PRAGMA foreign_keys = ON");
-        database.exec("PRAGMA trusted_schema = OFF");
-    }
-    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);
-        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 = path.join(projectionDirectory, PROJECTION_GENERATION_STORE_FILE);
-    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 = new DatabaseSync(databasePath, {
-            readOnly: true,
-            enableDoubleQuotedStringLiterals: false,
-            allowExtension: false,
-        });
-        configureHeartBusyTimeout(database);
-        validateSchemaShape(database);
-        readValidatedHistory(database);
-        return { databasePath, database };
-    }
-    catch (error) {
-        try {
-            database?.close();
-        }
-        catch { /* preserve the read/open failure */ }
-        throw projectionGenerationStoreReadError(databasePath, error);
-    }
-}
-/** Read the validated heart through one consistent SQLite snapshot. */
-export function withGenerationReadSnapshot(projectionDirectory, read) {
-    const { database } = openReadOnlyDatabase(projectionDirectory);
-    try {
-        database.exec("BEGIN");
-        try {
-            const result = read(database);
-            database.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            rollbackQuietly(database);
-            throw error;
-        }
-    }
-    finally {
-        closeDatabase(database);
-    }
-}
-export function assertDatabaseOpen(database) {
-    if (closedDatabases.has(database))
-        throw new ProjectionGenerationStoreError("projection generation store is closed");
-}
-export function readValidatedHistory(database) {
-    const rows = database.prepare(`
-    SELECT seq, kind, execution_id, facts_json
-    FROM generation_records
-    ORDER BY seq
-  `).all();
-    const records = rows.map(parseStoredRow);
-    return { records, current: validateHistory(records) };
-}
-export function appendRecord(database, kind, executionId, facts, seq) {
-    const encoded = JSON.stringify(facts);
-    database.prepare(`
-    INSERT INTO generation_records (seq, kind, execution_id, facts_json)
-    VALUES (?, ?, ?, ?)
-  `).run(seq, kind, executionId, encoded);
-    return { seq, kind, executionId, facts: JSON.parse(encoded) };
-}
-export function writeTransition(database, readOnly, run) {
-    assertDatabaseOpen(database);
-    if (readOnly) {
-        throw new ProjectionGenerationStoreError("projection generation store is read-only");
-    }
-    if (database.isTransaction)
-        return run();
-    database.exec("BEGIN IMMEDIATE");
-    try {
-        const result = run();
-        database.exec("COMMIT");
-        return result;
-    }
-    catch (error) {
-        rollbackQuietly(database);
-        throw error;
-    }
-}
-export function beginGenerationWriteTransaction(database, readOnly) {
-    assertDatabaseOpen(database);
-    if (readOnly)
-        throw new ProjectionGenerationStoreError("projection generation store is read-only");
-    if (database.isTransaction)
-        throw new ProjectionGenerationStoreError("projection generation write transaction is already open");
-    database.exec("BEGIN IMMEDIATE");
-}
-export function commitGenerationWriteTransaction(database) {
-    assertDatabaseOpen(database);
-    if (!database.isTransaction)
-        throw new ProjectionGenerationStoreError("projection generation write transaction is not open");
-    database.exec("COMMIT");
-}
-export function rollbackGenerationWriteTransaction(database) {
-    assertDatabaseOpen(database);
-    if (!database.isTransaction)
-        return;
-    rollbackQuietly(database);
-}
-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`);
-}