@astrosheep/keiyaku 2.9.11 → 2.9.13

package/build/core/projection/projection-life-protocol.js

@@ -1,115 +0,0 @@
-export const GENERATION_VERDICT_STATES = [
-    "completed",
-    "failed",
-    "launch-failed",
-    "lost-runner",
-    "dismissed",
-    "interrupted",
-    "killed",
-];
-function asLaunch(record) {
-    return record.kind === "launch"
-        ? record
-        : undefined;
-}
-function asAdoption(record) {
-    return record.kind === "adoption"
-        ? record
-        : undefined;
-}
-function asKillIntent(record) {
-    return record.kind === "kill-intent"
-        ? record
-        : undefined;
-}
-function asInterruptIntent(record) {
-    return record.kind === "interrupt-intent"
-        ? record
-        : undefined;
-}
-function asVerdict(record) {
-    return record.kind === "verdict"
-        ? record
-        : undefined;
-}
-/**
- * Select the current generation using ledger sequence only. The store validates
- * dense sequence and transition legality before records reach this fold.
- */
-export function selectCurrentGeneration(records) {
-    let launch;
-    for (const record of records) {
-        const candidate = asLaunch(record);
-        if (candidate)
-            launch = candidate;
-    }
-    if (!launch)
-        return null;
-    let adoption;
-    let killIntent;
-    let interruptIntent;
-    let verdict;
-    for (const record of records) {
-        if (record.seq <= launch.seq || record.executionId !== launch.executionId)
-            continue;
-        adoption ??= asAdoption(record);
-        killIntent ??= asKillIntent(record);
-        interruptIntent ??= asInterruptIntent(record);
-        verdict ??= asVerdict(record);
-    }
-    return {
-        launch,
-        ...(adoption ? { adoption } : {}),
-        ...(killIntent ? { killIntent } : {}),
-        ...(interruptIntent ? { interruptIntent } : {}),
-        ...(verdict ? { verdict } : {}),
-    };
-}
-function verdictState(record) {
-    const state = record?.facts.state;
-    return typeof state === "string"
-        && GENERATION_VERDICT_STATES.includes(state)
-        ? state
-        : undefined;
-}
-function phaseForVerdict(state) {
-    switch (state) {
-        case "completed": return "done";
-        case "dismissed": return "dismissed";
-        case "interrupted": return "done";
-        case "killed": return "killed";
-        case "lost-runner": return "lost";
-        case "failed":
-        case "launch-failed":
-            return "failed";
-    }
-}
-export function deriveProjectionLife(input) {
-    const chain = selectCurrentGeneration(input.records);
-    if (!chain)
-        return { phase: "quiescent" };
-    const executionId = chain.launch.executionId;
-    if (chain.verdict) {
-        const state = verdictState(chain.verdict);
-        return state
-            ? { phase: phaseForVerdict(state), executionId, verdict: state }
-            : { phase: "unknown", executionId, diagnostic: "current generation has an invalid verdict" };
-    }
-    if (!chain.adoption) {
-        const createdAt = chain.launch.facts.createdAt;
-        const launchedAtMs = typeof createdAt === "string" ? Date.parse(createdAt) : Number.NaN;
-        if (!Number.isFinite(launchedAtMs)) {
-            return { phase: "unknown", executionId, diagnostic: "current launch has an invalid createdAt fact" };
-        }
-        return input.nowMs - launchedAtMs >= input.startupTimeoutMs
-            ? { phase: "startup-timeout", executionId }
-            : { phase: "minting", executionId };
-    }
-    switch (input.runnerLock) {
-        case "held": return { phase: "active", executionId };
-        case "released": return { phase: "lost", executionId };
-        case "unknown":
-        case undefined:
-            return { phase: "unknown", executionId, diagnostic: "runner lock could not be determined" };
-    }
-}

package/build/core/projection/projection-runner-lock.js

@@ -1,382 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DatabaseSync } from "node:sqlite";
-export const PROJECTION_RUNNER_LOCK_DATABASE = "leash";
-const SQLITE_BUSY = 5;
-const SUPPORTED_PLATFORMS = new Set(["darwin", "linux", "win32"]);
-export class ProjectionRunnerLockUnavailableError extends Error {
-    code = "PROJECTION_RUNNER_LOCK_UNAVAILABLE";
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ProjectionRunnerLockUnavailableError";
-    }
-}
-export class ProjectionRunnerLockUnsupportedError extends Error {
-    code = "PROJECTION_RUNNER_LOCK_UNSUPPORTED";
-    constructor(platform) {
-        super(`projection runner locks are unsupported on platform '${platform}'`);
-        this.name = "ProjectionRunnerLockUnsupportedError";
-    }
-}
-export function projectionRunnerLockPath(projectionDirectory) {
-    return path.join(projectionDirectory, PROJECTION_RUNNER_LOCK_DATABASE);
-}
-export function isProjectionRunnerLockPlatformSupported(platform = process.platform) {
-    return SUPPORTED_PLATFORMS.has(platform);
-}
-function errorDetail(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function isSqliteBusy(error) {
-    return typeof error === "object"
-        && error !== null
-        && "errcode" in error
-        && error.errcode === SQLITE_BUSY;
-}
-function readJournalMode(database) {
-    const row = database.prepare("PRAGMA journal_mode").get();
-    return typeof row?.journal_mode === "string" ? row.journal_mode.toLowerCase() : undefined;
-}
-function assertCurrentLockSchema(database) {
-    database.prepare("SELECT id FROM lock_anchor LIMIT 1").get();
-}
-function assertBusyTimeout(busyTimeoutMs) {
-    if (!Number.isSafeInteger(busyTimeoutMs) || busyTimeoutMs < 0) {
-        throw new ProjectionRunnerLockUnavailableError("projection runner lock busy timeout must be a non-negative safe integer");
-    }
-}
-function openGuard(lockPath, busyTimeoutMs) {
-    const database = new DatabaseSync(lockPath);
-    try {
-        database.exec(`PRAGMA busy_timeout=${busyTimeoutMs}`);
-        database.exec("BEGIN DEFERRED");
-        assertCurrentLockSchema(database);
-        if (readJournalMode(database) !== "delete") {
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock database does not use rollback-journal mode");
-        }
-        return database;
-    }
-    catch (error) {
-        closeTransaction(database);
-        throw error;
-    }
-}
-function openReservation(lockPath, busyTimeoutMs) {
-    const database = new DatabaseSync(lockPath);
-    try {
-        database.exec(`PRAGMA busy_timeout=${busyTimeoutMs}`);
-        database.exec("BEGIN IMMEDIATE");
-        return database;
-    }
-    catch (error) {
-        closeTransaction(database);
-        throw error;
-    }
-}
-function closeTransaction(database) {
-    let failure;
-    try {
-        database.exec("ROLLBACK");
-    }
-    catch (error) {
-        failure = error;
-    }
-    try {
-        database.close();
-    }
-    catch (error) {
-        failure ??= error;
-    }
-    return failure;
-}
-function createHeldLock(lockPath, busyTimeoutMs, guard, initialReservation) {
-    let closed = false;
-    let reservation = initialReservation;
-    return {
-        path: lockPath,
-        releaseReservationForTransfer() {
-            if (closed || reservation === undefined)
-                return;
-            const released = reservation;
-            reservation = undefined;
-            const failure = closeTransaction(released);
-            if (failure !== undefined) {
-                throw new ProjectionRunnerLockUnavailableError(`projection runner reservation release failed: ${errorDetail(failure)}`, { cause: failure });
-            }
-        },
-        reclaimReservation() {
-            if (closed || reservation !== undefined)
-                return;
-            try {
-                reservation = openReservation(lockPath, busyTimeoutMs);
-            }
-            catch (error) {
-                throw new ProjectionRunnerLockUnavailableError(`projection runner reservation reclaim failed: ${errorDetail(error)}`, { cause: error });
-            }
-        },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            let failure;
-            if (reservation !== undefined)
-                failure = closeTransaction(reservation);
-            const guardFailure = closeTransaction(guard);
-            failure ??= guardFailure;
-            if (failure !== undefined) {
-                throw new ProjectionRunnerLockUnavailableError(`projection runner lock release failed: ${errorDetail(failure)}`, { cause: failure });
-            }
-        },
-    };
-}
-function closeAfterFailedAcquire(database, error) {
-    try {
-        database.close();
-    }
-    catch {
-        // The acquisition error remains the causal failure. Closing a connection
-        // that never became authoritative cannot turn it into a held lock.
-    }
-    if (isSqliteBusy(error)) {
-        throw new ProjectionRunnerLockUnavailableError("projection runner lock is already held", { cause: error });
-    }
-    throw new ProjectionRunnerLockUnavailableError(`projection runner lock acquisition failed: ${errorDetail(error)}`, { cause: error });
-}
-/**
- * Mint-time initialization for the fixed lock database. This creates storage,
- * forces rollback-journal mode, verifies the anchor schema, and closes without
- * retaining any process-life authority.
- */
-export function initializeProjectionRunnerLockDatabase(projectionDirectory, platform = process.platform) {
-    if (!isProjectionRunnerLockPlatformSupported(platform)) {
-        throw new ProjectionRunnerLockUnsupportedError(platform);
-    }
-    const lockPath = projectionRunnerLockPath(projectionDirectory);
-    let database;
-    try {
-        database = new DatabaseSync(lockPath);
-    }
-    catch (error) {
-        throw new ProjectionRunnerLockUnavailableError(`projection runner lock database could not be initialized: ${errorDetail(error)}`, { cause: error });
-    }
-    let initializationError;
-    try {
-        database.exec("PRAGMA busy_timeout=0");
-        database.exec("PRAGMA journal_mode=DELETE");
-        database.exec("CREATE TABLE IF NOT EXISTS lock_anchor (id INTEGER PRIMARY KEY CHECK (id = 1))");
-        if (readJournalMode(database) !== "delete") {
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock database does not use rollback-journal mode");
-        }
-        assertCurrentLockSchema(database);
-    }
-    catch (error) {
-        initializationError = error;
-    }
-    try {
-        database.close();
-    }
-    catch (error) {
-        initializationError ??= error;
-    }
-    if (initializationError !== undefined) {
-        throw new ProjectionRunnerLockUnavailableError(`projection runner lock database initialization failed: ${errorDetail(initializationError)}`, { cause: initializationError });
-    }
-    return lockPath;
-}
-/**
- * Hold one rollback-mode SHARED guard plus the sole RESERVED claim until
- * close() or process death. An EXCLUSIVE probe cannot pass either component.
- * During handoff the child overlaps the guard before the RESERVED claim moves,
- * so kernel exclusion remains continuous without transferring a connection.
- */
-export function acquireProjectionRunnerLock(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
-    if (!isProjectionRunnerLockPlatformSupported(platform)) {
-        throw new ProjectionRunnerLockUnsupportedError(platform);
-    }
-    const lockPath = projectionRunnerLockPath(projectionDirectory);
-    try {
-        if (!fs.lstatSync(lockPath).isFile()) {
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock database is not a regular file");
-        }
-    }
-    catch (error) {
-        if (error instanceof ProjectionRunnerLockUnavailableError)
-            throw error;
-        throw new ProjectionRunnerLockUnavailableError(`projection runner lock database is not initialized: ${errorDetail(error)}`, { cause: error });
-    }
-    assertBusyTimeout(busyTimeoutMs);
-    let guard;
-    try {
-        guard = openGuard(lockPath, busyTimeoutMs);
-    }
-    catch (error) {
-        throw new ProjectionRunnerLockUnavailableError(`projection runner lock database could not be opened: ${errorDetail(error)}`, { cause: error });
-    }
-    let reservation;
-    try {
-        reservation = openReservation(lockPath, busyTimeoutMs);
-    }
-    catch (error) {
-        if (reservation)
-            closeTransaction(reservation);
-        closeTransaction(guard);
-        return closeAfterFailedAcquire(guard, error);
-    }
-    return createHeldLock(lockPath, busyTimeoutMs, guard, reservation);
-}
-export function acquireProjectionRunnerTransferTarget(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
-    if (!isProjectionRunnerLockPlatformSupported(platform)) {
-        throw new ProjectionRunnerLockUnsupportedError(platform);
-    }
-    assertBusyTimeout(busyTimeoutMs);
-    const lockPath = projectionRunnerLockPath(projectionDirectory);
-    let guard;
-    try {
-        guard = openGuard(lockPath, busyTimeoutMs);
-    }
-    catch (error) {
-        if (guard)
-            closeTransaction(guard);
-        throw new ProjectionRunnerLockUnavailableError(`projection runner transfer acquisition failed: ${errorDetail(error)}`, { cause: error });
-    }
-    let closed = false;
-    return {
-        path: lockPath,
-        promote() {
-            if (closed)
-                throw new ProjectionRunnerLockUnavailableError("projection runner transfer target is closed");
-            let reservation;
-            try {
-                reservation = openReservation(lockPath, busyTimeoutMs);
-            }
-            catch (error) {
-                if (reservation)
-                    closeTransaction(reservation);
-                throw new ProjectionRunnerLockUnavailableError(`projection runner transfer promotion failed: ${errorDetail(error)}`, { cause: error });
-            }
-            closed = true;
-            return createHeldLock(lockPath, busyTimeoutMs, guard, reservation);
-        },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            const failure = closeTransaction(guard);
-            if (failure !== undefined) {
-                throw new ProjectionRunnerLockUnavailableError(`projection runner transfer release failed: ${errorDetail(failure)}`, { cause: failure });
-            }
-        },
-    };
-}
-/** Acquire positive death evidence. Any active guard or transfer blocks this. */
-export function acquireProjectionRunnerSettlementLock(projectionDirectory, platform = process.platform, busyTimeoutMs = 0) {
-    if (!isProjectionRunnerLockPlatformSupported(platform)) {
-        throw new ProjectionRunnerLockUnsupportedError(platform);
-    }
-    assertBusyTimeout(busyTimeoutMs);
-    const lockPath = projectionRunnerLockPath(projectionDirectory);
-    let database;
-    try {
-        database = new DatabaseSync(lockPath);
-        database.exec(`PRAGMA busy_timeout=${busyTimeoutMs}`);
-        database.exec("BEGIN EXCLUSIVE");
-        assertCurrentLockSchema(database);
-        if (readJournalMode(database) !== "delete") {
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock database does not use rollback-journal mode");
-        }
-    }
-    catch (error) {
-        try {
-            database.close();
-        }
-        catch { }
-        if (isSqliteBusy(error)) {
-            throw new ProjectionRunnerLockUnavailableError("projection runner lock is already held", { cause: error });
-        }
-        throw new ProjectionRunnerLockUnavailableError(`projection runner settlement lock acquisition failed: ${errorDetail(error)}`, { cause: error });
-    }
-    let closed = false;
-    return {
-        path: lockPath,
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            const failure = closeTransaction(database);
-            if (failure !== undefined) {
-                throw new ProjectionRunnerLockUnavailableError(`projection runner settlement lock release failed: ${errorDetail(failure)}`, { cause: failure });
-            }
-        },
-    };
-}
-/**
- * Probe without creating the lock database. BEGIN EXCLUSIVE is the positive
- * death test: SQLITE_BUSY proves a SHARED guard or RESERVED owner remains;
- * success proves both are gone. Every other failure remains unknown.
- */
-export function observeProjectionRunnerLock(projectionDirectory, platform = process.platform) {
-    if (!isProjectionRunnerLockPlatformSupported(platform)) {
-        return {
-            state: "unknown",
-            reason: "unsupported-platform",
-            detail: `projection runner locks are unsupported on platform '${platform}'`,
-        };
-    }
-    const lockPath = projectionRunnerLockPath(projectionDirectory);
-    try {
-        if (!fs.lstatSync(lockPath).isFile()) {
-            return {
-                state: "unknown",
-                reason: "open-failed",
-                detail: "projection runner lock database is not a regular file",
-            };
-        }
-    }
-    catch (error) {
-        return { state: "unknown", reason: "open-failed", detail: errorDetail(error) };
-    }
-    let database;
-    try {
-        database = new DatabaseSync(lockPath);
-    }
-    catch (error) {
-        return { state: "unknown", reason: "open-failed", detail: errorDetail(error) };
-    }
-    let transactionOpen = false;
-    try {
-        database.exec("PRAGMA busy_timeout=0");
-        database.exec("BEGIN EXCLUSIVE");
-        transactionOpen = true;
-        assertCurrentLockSchema(database);
-        const journalMode = readJournalMode(database);
-        if (journalMode !== "delete") {
-            return {
-                state: "unknown",
-                reason: "unsupported-journal-mode",
-                detail: `projection runner lock database uses journal mode '${journalMode ?? "unknown"}'`,
-            };
-        }
-        return { state: "released" };
-    }
-    catch (error) {
-        if (isSqliteBusy(error))
-            return { state: "held" };
-        return { state: "unknown", reason: "probe-failed", detail: errorDetail(error) };
-    }
-    finally {
-        if (transactionOpen) {
-            try {
-                database.exec("ROLLBACK");
-            }
-            catch {
-                // Closing below still drops this observer's own ephemeral SHARED lock.
-            }
-        }
-        try {
-            database.close();
-        }
-        catch {
-            // Observer cleanup failures cannot be converted into death evidence.
-        }
-    }
-}

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

@@ -1,127 +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 { 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 withReadSnapshot(projectionDirectory, read) {
-    const database = openDatabase(projectionDirectory, true);
-    try {
-        database.exec("BEGIN");
-        try {
-            const result = read(database);
-            database.exec("COMMIT");
-            return result;
-        }
-        catch (error) {
-            rollbackQuietly(database);
-            throw error;
-        }
-    }
-    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();
-        },
-    };
-}