@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/core/projection/projection-wake.js

@@ -1,360 +0,0 @@
-import { FlowError } from "../../flow-error.js";
-import { parseResolvedAkumaLaunchSnapshot } from "../../agents/launch-snapshot/model.js";
-import { isRecoverableSessionEnvelope } from "../../agents/harness/index.js";
-import { ProjectionStateError } from "../atomic-publish.js";
-import { applyContinuationEffort, readProjectionGenerationContinuationSnapshot, } from "./generation/projection-generation-continuation.js";
-import { createProjectionExecutionId } from "./generation/projection-generation-identity.js";
-import { PROJECTION_ADOPTION_POLL_MS, PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration, } from "./generation/projection-generation-launcher.js";
-import { openProjectionGenerationStore, openProjectionGenerationStoreReadOnly, } from "./generation/store.js";
-import { observeProjectionLifeSnapshot } from "./projection-life-observer.js";
-import { acquireProjectionRunnerLock, acquireProjectionRunnerSettlementLock, ProjectionRunnerLockUnavailableError, } from "./projection-runner-lock.js";
-import { setTimeout as delay } from "node:timers/promises";
-function incompatibleProjectionError(projectionId) {
-    const subject = projectionId ? `Projection '${projectionId}'` : "Projection";
-    const statusCoordinate = projectionId ?? "<projection-id>";
-    return new FlowError("PROJECTION_INCOMPATIBLE", `${subject} has incompatible historical storage; inspect it with keiyaku status ${statusCoordinate}, but tell cannot change it.`);
-}
-/**
- * Tell is a current-schema mutation only. This gate runs before the handler
- * writes an inbox row, so historical storage never acquires pending mail.
- */
-export function assertProjectionTellable(projectionDirectory) {
-    const observation = observeProjectionLifeSnapshot(projectionDirectory, {
-        nowMs: Date.now(),
-        startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-    });
-    if (observation.compatibility === "incompatible")
-        throw incompatibleProjectionError();
-}
-function readCurrentGeneration(projectionDirectory) {
-    const store = openProjectionGenerationStoreReadOnly(projectionDirectory);
-    try {
-        return store.readCurrentGeneration();
-    }
-    finally {
-        store.close();
-    }
-}
-function successorFacts(current, snapshot, nowMs, requireContinuation) {
-    const verdictFacts = current.verdict?.facts;
-    const originalInputs = current.launch.facts.inputs;
-    const inputs = originalInputs
-        && typeof originalInputs === "object"
-        && !Array.isArray(originalInputs)
-        ? originalInputs
-        : {};
-    const session = verdictFacts?.session ?? inputs.session;
-    const launchSnapshot = parseResolvedAkumaLaunchSnapshot(inputs.launchSnapshot);
-    const recoverableSession = isRecoverableSessionEnvelope(launchSnapshot.provider.kind, session);
-    if (requireContinuation && !recoverableSession) {
-        throw new FlowError("PROJECTION_WAKE_FAILED", "The tell was saved, but the successor could not be started because its provider session is not recoverable.");
-    }
-    const { sourceArtifactId: _sourceArtifactId, ...inheritedInputs } = inputs;
-    const resumePath = typeof verdictFacts?.responsePath === "string"
-        ? verdictFacts.responsePath
-        : typeof inputs.resumePath === "string"
-            ? inputs.resumePath
-            : undefined;
-    const continuedInputs = {
-        ...inheritedInputs,
-        ...(recoverableSession ? {
-            session,
-            ...(resumePath ? { resumePath } : {}),
-        } : {}),
-    };
-    const { tellFence: _oldFence, ...inherited } = current.launch.facts;
-    return {
-        ...inherited,
-        createdAt: new Date(nowMs).toISOString(),
-        launchedBy: "tell-wake",
-        parentExecutionId: current.launch.executionId,
-        tellFence: snapshot.tellIds,
-        inputs: applyContinuationEffort(continuedInputs, snapshot.effort),
-    };
-}
-export function assertTellEffortSupported(projectionDirectory, effort) {
-    if (!effort)
-        return;
-    const current = readCurrentGeneration(projectionDirectory);
-    if (!current)
-        throw new ProjectionStateError("projection has no immutable generation launch");
-    const inputs = current.launch.facts.inputs;
-    if (!inputs || typeof inputs !== "object" || Array.isArray(inputs)) {
-        throw new ProjectionStateError("generation launch inputs are missing");
-    }
-    let launchSnapshot;
-    try {
-        launchSnapshot = parseResolvedAkumaLaunchSnapshot(inputs.launchSnapshot);
-    }
-    catch (error) {
-        throw new ProjectionStateError("generation launch has an invalid immutable launchSnapshot", { cause: error });
-    }
-    if (launchSnapshot.akuma.model === undefined) {
-        throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' requires an explicit model.`);
-    }
-    const effortOptions = launchSnapshot.akuma.effortOptions;
-    if (effortOptions === undefined)
-        return;
-    if (!effortOptions.includes(effort)) {
-        throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${effort}' is not permitted; legal values: ${effortOptions.join(", ")}.`);
-    }
-}
-async function startCommittedSuccessor(projectionDirectory, projectionId, executionId, startGeneration, dependencies = {}) {
-    let started;
-    try {
-        started = await startGeneration(projectionDirectory, executionId, dependencies);
-    }
-    finally {
-        dependencies.launchOwnership?.close();
-    }
-    if (started.status === "adopted")
-        return "woken";
-    if (started.status === "pending")
-        return "pending";
-    const reconciled = readCurrentGeneration(projectionDirectory);
-    if (reconciled?.launch.executionId === executionId && reconciled.adoption)
-        return "woken";
-    if (reconciled && !reconciled.verdict && reconciled.launch.executionId !== executionId) {
-        return reconciled.adoption ? "active" : "pending";
-    }
-    throw new FlowError("PROJECTION_WAKE_FAILED", `The tell was saved for '${projectionId}', but its successor could not be started (cause: ${started.cause}).`, {
-        facts: {
-            kind: "projection_wake_failure",
-            projectionId,
-            cause: started.cause,
-            tellRetained: true,
-        },
-    });
-}
-function sessionWakeFailure(projectionId, cause) {
-    return new FlowError("PROJECTION_WAKE_FAILED", `The tell was saved for '${projectionId}', but its successor could not be started (cause: session_unrecoverable).`, {
-        cause,
-        facts: {
-            kind: "projection_wake_failure",
-            projectionId,
-            cause: "session_unrecoverable",
-            tellRetained: true,
-        },
-    });
-}
-export function persistInterruptWakeFailure(projectionDirectory, error, nowMs = Date.now()) {
-    if (!(error instanceof FlowError)
-        || error.code !== "PROJECTION_WAKE_FAILED"
-        || error.facts?.kind !== "projection_wake_failure")
-        return;
-    const continuation = readProjectionGenerationContinuationSnapshot(projectionDirectory, 10);
-    const current = continuation.current;
-    if (current?.verdict?.facts.state !== "interrupted" || !continuation.requiresWake)
-        return;
-    const successorExecutionId = createProjectionExecutionId(nowMs);
-    const facts = successorFacts(current, continuation.successor, nowMs, false);
-    const store = openProjectionGenerationStore(projectionDirectory);
-    try {
-        store.failInterruptWakeIfSettled({
-            predecessorExecutionId: current.launch.executionId,
-            successorExecutionId,
-            successorFacts: facts,
-            cause: error.facts.cause,
-            terminalAt: new Date(nowMs).toISOString(),
-        });
-    }
-    finally {
-        store.close();
-    }
-}
-export async function tellProjection(projectionDirectory, projectionId, effort, dependencies = {}) {
-    const startGeneration = dependencies.startGeneration ?? startProjectionGeneration;
-    const sleep = dependencies.sleep ?? ((milliseconds) => delay(milliseconds));
-    const observationStartedAt = Date.now();
-    for (;;) {
-        const nowMs = Date.now();
-        const observation = observeProjectionLifeSnapshot(projectionDirectory, {
-            nowMs,
-            startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
-        });
-        if (observation.compatibility === "incompatible") {
-            throw incompatibleProjectionError(projectionId);
-        }
-        const life = observation.life;
-        if (life.phase === "active")
-            return "active";
-        if (life.phase === "minting" || life.phase === "quiescent") {
-            if (life.phase === "quiescent" && nowMs - observationStartedAt >= PROJECTION_ADOPTION_TIMEOUT_MS) {
-                throw sessionWakeFailure(projectionId, new Error("projection has no generation continuation"));
-            }
-            await sleep(PROJECTION_ADOPTION_POLL_MS);
-            continue;
-        }
-        if (life.phase === "unknown") {
-            return "pending";
-        }
-        const continuation = readProjectionGenerationContinuationSnapshot(projectionDirectory, 10);
-        const current = continuation.current;
-        if (!current)
-            return "pending";
-        if (current.killIntent && !current.verdict)
-            return "pending";
-        if (!continuation.requiresWake)
-            return "pending";
-        const snapshot = continuation.successor;
-        const successorExecutionId = createProjectionExecutionId(nowMs);
-        let facts;
-        try {
-            facts = successorFacts(current, { ...snapshot, ...(effort ? { effort } : {}) }, nowMs, life.phase !== "startup-timeout");
-        }
-        catch (error) {
-            if (error instanceof FlowError && error.code === "PROJECTION_WAKE_FAILED") {
-                throw sessionWakeFailure(projectionId, error);
-            }
-            throw error;
-        }
-        const store = openProjectionGenerationStore(projectionDirectory);
-        try {
-            if (life.phase === "startup-timeout") {
-                const terminalAt = new Date(nowMs).toISOString();
-                let deathEvidence;
-                try {
-                    deathEvidence = acquireProjectionRunnerSettlementLock(projectionDirectory);
-                }
-                catch (error) {
-                    if (error instanceof ProjectionRunnerLockUnavailableError)
-                        return "pending";
-                    return "pending";
-                }
-                try {
-                    store.beginWriteTransaction();
-                    const protectedCurrent = store.readCurrentGeneration();
-                    if (protectedCurrent?.launch.executionId !== current.launch.executionId
-                        || protectedCurrent.adoption
-                        || protectedCurrent.verdict) {
-                        store.rollbackWriteTransaction();
-                        return "pending";
-                    }
-                    if (protectedCurrent.killIntent) {
-                        const settled = store.settleKillIfRunnerDead({
-                            executionId: current.launch.executionId,
-                            releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
-                            terminalAt,
-                        });
-                        if (settled.status === "committed")
-                            store.commitWriteTransaction();
-                        else
-                            store.rollbackWriteTransaction();
-                        return "pending";
-                    }
-                    deathEvidence.close();
-                    let launchOwnership;
-                    try {
-                        launchOwnership = acquireProjectionRunnerLock(projectionDirectory);
-                    }
-                    catch (error) {
-                        store.rollbackWriteTransaction();
-                        if (error instanceof ProjectionRunnerLockUnavailableError)
-                            return "pending";
-                        return "pending";
-                    }
-                    return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration, {
-                        commitLaunch: () => {
-                            const transition = store.supersedeStartupTimeout({
-                                executionId: current.launch.executionId,
-                                releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
-                                diagnostic: { detail: "runner did not adopt before startup timeout" },
-                                successorExecutionId,
-                                successorFacts: facts,
-                                terminalAt,
-                            });
-                            if (transition.status === "committed")
-                                store.commitWriteTransaction();
-                            else
-                                store.rollbackWriteTransaction();
-                            return transition.status === "committed";
-                        },
-                        launchOwnership,
-                    });
-                }
-                finally {
-                    store.rollbackWriteTransaction();
-                    deathEvidence.close();
-                }
-            }
-            if (life.phase === "lost" && !current.verdict) {
-                let deathEvidence;
-                try {
-                    deathEvidence = acquireProjectionRunnerSettlementLock(projectionDirectory);
-                }
-                catch (error) {
-                    if (error instanceof ProjectionRunnerLockUnavailableError)
-                        return "active";
-                    return "pending";
-                }
-                try {
-                    store.beginWriteTransaction();
-                    const protectedCurrent = store.readCurrentGeneration();
-                    if (protectedCurrent?.launch.executionId !== current.launch.executionId
-                        || !protectedCurrent.adoption
-                        || protectedCurrent.verdict) {
-                        store.rollbackWriteTransaction();
-                        return "pending";
-                    }
-                    const terminalAt = new Date(nowMs).toISOString();
-                    if (protectedCurrent.killIntent) {
-                        const settled = store.settleKillIfRunnerDead({
-                            executionId: current.launch.executionId,
-                            releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
-                            terminalAt,
-                        });
-                        if (settled.status === "committed")
-                            store.commitWriteTransaction();
-                        else
-                            store.rollbackWriteTransaction();
-                        return "pending";
-                    }
-                    deathEvidence.close();
-                    let launchOwnership;
-                    try {
-                        launchOwnership = acquireProjectionRunnerLock(projectionDirectory);
-                    }
-                    catch (error) {
-                        store.rollbackWriteTransaction();
-                        if (error instanceof ProjectionRunnerLockUnavailableError)
-                            return "active";
-                        return "pending";
-                    }
-                    return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration, {
-                        commitLaunch: () => {
-                            const transition = store.replaceDeadRunner({
-                                executionId: current.launch.executionId,
-                                releasedLockEvidence: { observedAt: terminalAt, state: "acquired" },
-                                successorExecutionId,
-                                successorFacts: facts,
-                                terminalAt,
-                            });
-                            if (transition.status === "committed")
-                                store.commitWriteTransaction();
-                            else
-                                store.rollbackWriteTransaction();
-                            return transition.status === "committed";
-                        },
-                        launchOwnership,
-                    });
-                }
-                finally {
-                    store.rollbackWriteTransaction();
-                    deathEvidence.close();
-                }
-            }
-            if (!["done", "failed", "lost", "dismissed", "killed"].includes(life.phase)) {
-                return "pending";
-            }
-            return await startCommittedSuccessor(projectionDirectory, projectionId, successorExecutionId, startGeneration, {
-                commitLaunch: () => store.launchIfSettled({
-                    executionId: successorExecutionId,
-                    facts,
-                }).status === "committed",
-            });
-        }
-        finally {
-            store.close();
-        }
-    }
-}

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();
-        },
-    };
-}