@astrosheep/keiyaku 2.9.6 → 2.9.8

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

@@ -1,5 +1,5 @@
 import { appendRecord, readValidatedHistory, writeTransition, } from "./database.js";
-import { ProjectionGenerationStoreError, VERDICTS, assertExecutionId, assertIsoTimestamp, assertNonNegativeSafeInteger, assertPositiveSafeInteger, cloneFacts, validateAdoptionFacts, validateKillIntentFacts, validateLaunchFacts, validateTellFence, validateVerdictFacts, } from "./model.js";
+import { ProjectionGenerationStoreError, VERDICTS, assertExecutionId, assertIsoTimestamp, cloneFacts, validateAdoptionFacts, validateInterruptIntentFacts, validateKillIntentFacts, validateLaunchFacts, validateTellFence, validateVerdictFacts, } from "./model.js";
 function committed(records) {
     return { status: "committed", records };
 }
@@ -20,6 +20,38 @@ export function launchIfSettled(database, readOnly, input) {
         return committed([appendRecord(database, "launch", executionId, facts, history.records.length + 1)]);
     });
 }
+/** Persist an asynchronous interrupt wake rejection as one closed successor. */
+export function failInterruptWakeIfSettled(database, readOnly, input) {
+    const predecessorExecutionId = assertExecutionId(input.predecessorExecutionId);
+    const successorExecutionId = assertExecutionId(input.successorExecutionId);
+    const successorFacts = validateLaunchFacts(input.successorFacts, "interrupt wake successor launch facts");
+    const terminalAt = assertIsoTimestamp(input.terminalAt, "terminalAt");
+    return writeTransition(database, readOnly, () => {
+        const history = readValidatedHistory(database);
+        const current = history.current;
+        if (!current)
+            return rejected("no-current-launch", null);
+        if (current.launch.executionId !== predecessorExecutionId)
+            return rejected("not-current", current);
+        if (current.verdict?.facts.state !== "interrupted") {
+            return rejected(current.verdict ? "already-terminal" : "current-generation-open", current);
+        }
+        if (history.records.some((record) => record.kind === "launch" && record.executionId === successorExecutionId)) {
+            return rejected("execution-id-already-used", current);
+        }
+        const verdictFacts = validateVerdictFacts({
+            state: "launch-failed",
+            cause: input.cause,
+            tellRetained: true,
+            terminalAt,
+        }, "interrupt wake failure verdict facts");
+        const firstSeq = history.records.length + 1;
+        return committed([
+            appendRecord(database, "launch", successorExecutionId, successorFacts, firstSeq),
+            appendRecord(database, "verdict", successorExecutionId, verdictFacts, firstSeq + 1),
+        ]);
+    });
+}
 export function adoptionIfCurrent(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const facts = validateAdoptionFacts(input.facts, "adoption facts");
@@ -51,10 +83,32 @@ export function requestKillIfOpen(database, readOnly, input) {
             return rejected("already-terminal", current);
         if (current.killIntent)
             return rejected("kill-requested", current);
+        if (current.interruptIntent)
+            return rejected("interrupt-requested", current);
         const facts = validateKillIntentFacts({ operatorAction: "kill", killedAt }, "kill-intent facts");
         return committed([appendRecord(database, "kill-intent", executionId, facts, history.records.length + 1)]);
     });
 }
+export function requestInterruptIfOpen(database, readOnly, input) {
+    const executionId = assertExecutionId(input.executionId);
+    const interruptedAt = assertIsoTimestamp(input.interruptedAt, "interruptedAt");
+    return writeTransition(database, readOnly, () => {
+        const history = readValidatedHistory(database);
+        const current = history.current;
+        if (!current)
+            return rejected("no-current-launch", null);
+        if (current.launch.executionId !== executionId)
+            return rejected("not-current", current);
+        if (current.verdict)
+            return rejected("already-terminal", current);
+        if (current.killIntent)
+            return rejected("kill-requested", current);
+        if (current.interruptIntent)
+            return rejected("interrupt-requested", current);
+        const facts = validateInterruptIntentFacts({ interruptedAt }, "interrupt-intent facts");
+        return committed([appendRecord(database, "interrupt-intent", executionId, facts, history.records.length + 1)]);
+    });
+}
 export function runnerKilledIfRequested(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const callerFacts = cloneFacts(input.facts ?? {}, "killed verdict facts");
@@ -87,6 +141,84 @@ export function runnerKilledIfRequested(database, readOnly, input) {
         return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
     });
 }
+export function runnerInterruptedIfRequested(database, readOnly, input) {
+    const executionId = assertExecutionId(input.executionId);
+    const callerFacts = cloneFacts(input.facts ?? {}, "interrupted verdict facts");
+    for (const reserved of ["state", "interruptIntentSeq", "interruptedAt", "terminalAt"]) {
+        if (reserved in callerFacts) {
+            throw new ProjectionGenerationStoreError(`interrupted verdict facts.${reserved} is reserved`);
+        }
+    }
+    const terminalAt = input.terminalAt === undefined
+        ? undefined
+        : assertIsoTimestamp(input.terminalAt, "terminalAt");
+    return writeTransition(database, readOnly, () => {
+        const history = readValidatedHistory(database);
+        const current = history.current;
+        if (!current)
+            return rejected("no-current-launch", null);
+        if (current.launch.executionId !== executionId)
+            return rejected("not-current", current);
+        if (current.verdict)
+            return rejected("already-terminal", current);
+        if (!current.interruptIntent)
+            return rejected("kill-not-requested", current);
+        const facts = validateVerdictFacts({
+            ...callerFacts,
+            state: "interrupted",
+            interruptIntentSeq: current.interruptIntent.seq,
+            interruptedAt: current.interruptIntent.facts.interruptedAt,
+            ...(terminalAt ? { terminalAt } : {}),
+        }, "interrupted verdict facts");
+        return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
+    });
+}
+/** Publish a stopped provider outcome while atomically honoring any stop intent that won first. */
+export function runnerVerdictIfOpen(database, readOnly, input) {
+    const executionId = assertExecutionId(input.executionId);
+    if (!VERDICTS.has(input.verdict))
+        throw new ProjectionGenerationStoreError(`unknown verdict '${String(input.verdict)}'`);
+    if (input.verdict === "killed" || input.verdict === "interrupted" || input.verdict === "launch-failed" || input.verdict === "lost-runner") {
+        throw new ProjectionGenerationStoreError(`runner outcome verdict '${input.verdict}' is not publishable`);
+    }
+    const callerFacts = cloneFacts(input.facts ?? {}, "runner verdict facts");
+    const terminalAt = assertIsoTimestamp(input.terminalAt, "terminalAt");
+    return writeTransition(database, readOnly, () => {
+        const history = readValidatedHistory(database);
+        const current = history.current;
+        if (!current)
+            return rejected("no-current-launch", null);
+        if (current.launch.executionId !== executionId)
+            return rejected("not-current", current);
+        if (current.verdict)
+            return rejected("already-terminal", current);
+        let facts;
+        if (current.interruptIntent) {
+            const { state: _state, interruptIntentSeq: _seq, interruptedAt: _at, terminalAt: _terminal, ...rest } = callerFacts;
+            facts = validateVerdictFacts({
+                ...rest,
+                state: "interrupted",
+                interruptIntentSeq: current.interruptIntent.seq,
+                interruptedAt: current.interruptIntent.facts.interruptedAt,
+                terminalAt,
+            }, "runner interrupted verdict facts");
+        }
+        else if (current.killIntent && !(input.verdict === "failed" && callerFacts.operatorAction === "kill")) {
+            const { state: _state, killIntentSeq: _seq, killedAt: _at, terminalAt: _terminal, ...rest } = callerFacts;
+            facts = validateVerdictFacts({
+                ...rest,
+                state: "killed",
+                killIntentSeq: current.killIntent.seq,
+                killedAt: current.killIntent.facts.killedAt,
+                terminalAt,
+            }, "runner killed verdict facts");
+        }
+        else {
+            facts = validateVerdictFacts({ ...callerFacts, state: input.verdict, terminalAt }, "runner verdict facts");
+        }
+        return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
+    });
+}
 export function settleKillIfRunnerDead(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const releasedLockEvidence = cloneFacts(input.releasedLockEvidence, "released runner-lock evidence");
@@ -128,8 +260,8 @@ export function verdictIfOpen(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     if (!VERDICTS.has(input.verdict))
         throw new ProjectionGenerationStoreError(`unknown verdict '${String(input.verdict)}'`);
-    if (input.verdict === "killed") {
-        throw new ProjectionGenerationStoreError("verdict 'killed' is reserved to runnerKilledIfRequested and settleKillIfRunnerDead");
+    if (input.verdict === "killed" || input.verdict === "interrupted") {
+        throw new ProjectionGenerationStoreError(`verdict '${input.verdict}' is reserved to its runner-owned transition`);
     }
     return writeTransition(database, readOnly, () => {
         const history = readValidatedHistory(database);
@@ -140,15 +272,15 @@ export function verdictIfOpen(database, readOnly, input) {
             return rejected("not-current", current);
         if (current.verdict)
             return rejected("already-terminal", current);
+        if (input.verdict === "launch-failed" && current.adoption) {
+            return rejected("already-adopted", current);
+        }
         if (current.killIntent) {
             const killEscalationFailed = input.verdict === "failed"
                 && input.facts?.operatorAction === "kill";
             if (!killEscalationFailed)
                 return rejected("kill-requested", current);
         }
-        if (input.verdict === "launch-failed" && current.adoption) {
-            return rejected("already-adopted", current);
-        }
         const facts = validateVerdictFacts({ ...(input.facts ?? {}), state: input.verdict, ...(input.terminalAt ? { terminalAt: assertIsoTimestamp(input.terminalAt, "terminalAt") } : {}) }, "verdict facts");
         return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
     });
@@ -156,8 +288,10 @@ export function verdictIfOpen(database, readOnly, input) {
 export function supersedeStartupTimeout(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const successorExecutionId = assertExecutionId(input.successorExecutionId);
-    const observedAtMs = assertNonNegativeSafeInteger(input.observedAtMs, "observedAtMs");
-    const startupTimeoutMs = assertPositiveSafeInteger(input.startupTimeoutMs, "startupTimeoutMs");
+    const releasedLockEvidence = cloneFacts(input.releasedLockEvidence, "released startup-lock evidence");
+    if (Object.keys(releasedLockEvidence).length === 0) {
+        throw new ProjectionGenerationStoreError("released startup-lock evidence must not be empty");
+    }
     const diagnostic = cloneFacts(input.diagnostic, "startup-timeout diagnostic");
     const successorFacts = validateLaunchFacts(input.successorFacts, "successor launch facts");
     const terminalAt = input.terminalAt === undefined
@@ -172,19 +306,24 @@ export function supersedeStartupTimeout(database, readOnly, input) {
             return rejected("not-current", current);
         if (current.verdict)
             return rejected("already-terminal", current);
-        if (current.killIntent)
-            return rejected("kill-requested", current);
         if (current.adoption)
             return rejected("already-adopted", current);
+        if (current.killIntent) {
+            const verdictFacts = validateVerdictFacts({
+                state: "killed",
+                killIntentSeq: current.killIntent.seq,
+                killedAt: current.killIntent.facts.killedAt,
+                releasedLockEvidence,
+                ...(terminalAt === undefined ? {} : { terminalAt }),
+            }, "startup-timeout killed verdict facts");
+            return committed([appendRecord(database, "verdict", executionId, verdictFacts, history.records.length + 1)]);
+        }
         if (history.records.some((record) => record.kind === "launch" && record.executionId === successorExecutionId)) {
             return rejected("execution-id-already-used", current);
         }
-        const launchedAtMs = Date.parse(current.launch.facts.createdAt);
-        if (observedAtMs - launchedAtMs < startupTimeoutMs) {
-            return rejected("startup-timeout-not-elapsed", current);
-        }
         const verdictFactsBase = {
             ...diagnostic,
+            releasedLockEvidence,
             state: "launch-failed",
             ...(terminalAt === undefined ? {} : { terminalAt }),
         };
@@ -196,6 +335,44 @@ export function supersedeStartupTimeout(database, readOnly, input) {
         ]);
     });
 }
+export function settleStartupFailure(database, readOnly, input) {
+    const executionId = assertExecutionId(input.executionId);
+    const releasedLockEvidence = cloneFacts(input.releasedLockEvidence, "released startup-lock evidence");
+    if (Object.keys(releasedLockEvidence).length === 0) {
+        throw new ProjectionGenerationStoreError("released startup-lock evidence must not be empty");
+    }
+    const diagnostic = cloneFacts(input.diagnostic, "startup failure diagnostic");
+    const terminalAt = input.terminalAt === undefined
+        ? undefined
+        : assertIsoTimestamp(input.terminalAt, "terminalAt");
+    return writeTransition(database, readOnly, () => {
+        const history = readValidatedHistory(database);
+        const current = history.current;
+        if (!current)
+            return rejected("no-current-launch", null);
+        if (current.launch.executionId !== executionId)
+            return rejected("not-current", current);
+        if (current.verdict)
+            return rejected("already-terminal", current);
+        if (current.adoption)
+            return rejected("already-adopted", current);
+        const facts = current.killIntent
+            ? validateVerdictFacts({
+                state: "killed",
+                killIntentSeq: current.killIntent.seq,
+                killedAt: current.killIntent.facts.killedAt,
+                releasedLockEvidence,
+                ...(terminalAt === undefined ? {} : { terminalAt }),
+            }, "startup failure killed verdict facts")
+            : validateVerdictFacts({
+                ...diagnostic,
+                releasedLockEvidence,
+                state: "launch-failed",
+                ...(terminalAt === undefined ? {} : { terminalAt }),
+            }, "startup failure verdict facts");
+        return committed([appendRecord(database, "verdict", executionId, facts, history.records.length + 1)]);
+    });
+}
 export function replaceDeadRunner(database, readOnly, input) {
     const executionId = assertExecutionId(input.executionId);
     const successorExecutionId = assertExecutionId(input.successorExecutionId);
@@ -259,6 +436,8 @@ export function handoff(database, readOnly, input) {
             return rejected("already-terminal", current);
         if (current.killIntent)
             return rejected("kill-requested", current);
+        if (current.interruptIntent)
+            return rejected("interrupt-requested", current);
         if (!current.adoption)
             return rejected("not-adopted", current);
         if (history.records.some((record) => record.kind === "launch" && record.executionId === successorExecutionId)) {

package/build/core/projection/index.js

@@ -9,11 +9,11 @@ export { assertProjectionAlias, isProjectionAlias, moveProjectionAlias, projecti
 export { resolveProjectionCoordinate } from "./projection-coordinate.js";
 export { appendGenerationEvent, executionEventsPath, isProjectionId, isPublishedProjection, isoFromNowMs, projectionDir, projectionRoot, readProjectionEvents, } from "./projection-core.js";
 export { readProjectionIdentity } from "./projection-identity.js";
-export { killProjectionGeneration } from "./projection-kill.js";
+export { interruptProjectionGeneration, killProjectionGeneration } from "./projection-kill.js";
 export { observeProjectionLife, observeProjectionLifeSnapshot, } from "./projection-life-observer.js";
 export { mintProjection, mintRepositoryProjection, ProjectionMintCollisionError, } from "./projection-mint.js";
-export { acquireProjectionRunnerLock, initializeProjectionRunnerLockDatabase, isProjectionRunnerLockPlatformSupported, observeProjectionRunnerLock, projectionRunnerLockPath, } from "./projection-runner-lock.js";
-export { hasStrandableProjectionGeneration, prioritizeProjectionStatusRows, readProjectionStatusBoard, } from "./projection-status.js";
+export { acquireProjectionRunnerLock, acquireProjectionRunnerSettlementLock, acquireProjectionRunnerTransferTarget, initializeProjectionRunnerLockDatabase, isProjectionRunnerLockPlatformSupported, observeProjectionRunnerLock, projectionRunnerLockPath, } from "./projection-runner-lock.js";
+export { hasStrandableProjectionGeneration, prioritizeProjectionStatusRows, readAkumaNonterminalProjectionStatus, readExactProjectionStatus, readOperationalProjectionStatusBoard, } from "./projection-status.js";
 export { projectTerminalFailure, } from "./projection-terminal-failure.js";
 export { snapshotCommissionProjectionIds, waitForProjection, waitForProjectionSet, } from "./projection-wait.js";
 export { assertTellEffortSupported, assertProjectionTellable, tellProjection, } from "./projection-wake.js";
@@ -22,6 +22,6 @@ export { createProjectionExecutionId } from "./generation/projection-generation-
 export { PROJECTION_ADOPTION_TIMEOUT_MS, startProjectionGeneration, } from "./generation/projection-generation-launcher.js";
 export { projectionGenerationRunnerArgv, spawnProjectionGenerationRunner, } from "./generation/projection-generation-process.js";
 export { runProjectionGeneration, } from "./generation/projection-generation-runner.js";
-export { executeProjectionGeneration } from "./generation/projection-generation-execution.js";
+export { executeProjectionGeneration, prepareProjectionGenerationExecution, } from "./generation/projection-generation-execution.js";
 export { runProjectionGenerationRuntime } from "./generation/projection-generation-runtime.js";
-export { claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, listTellIds, markTellConsumed, markTellSubmitted, readProjectionTellCounts, readTellOriginal, readTellSubmitted, writeInboxTell, } from "./tell/store.js";
+export { claimFencedTells, claimTellToInflight, listTellIds, markTellConsumed, markTellSubmitted, readPendingTellWindow, readProjectionTellCounts, readTellOriginal, readTellSubmitted, writeInboxTell, } from "./tell/store.js";

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

@@ -5,7 +5,7 @@ import { projectionCoordinateRoot } from "./projection-coordinate.js";
 import { ProjectionStateError, } from "../atomic-publish.js";
 export { atomicPublishFile, ProjectionStateError, randomHex8 } from "../atomic-publish.js";
 export { isTellCausallyConsumed, } from "./tell/model.js";
-export { claimAllInbox, claimFencedTells, claimTellToInflight, demoteSubmittedTellsForReplay, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./tell/store.js";
+export { claimAllInbox, claimFencedTells, claimTellToInflight, listTellIds, markTellConsumed, markTellSubmitted, readTellOriginal, readTellSubmitted, snapshotPendingTells, writeInboxTell, } from "./tell/store.js";
 /** Relative segments for `.keiyaku/projection`. */
 export const PROJECTION_ROOT_SEGMENTS = [".keiyaku", "projection"];
 export const PROJECTION_ID_PATTERN = /^[a-zA-Z0-9]+(?:[.-][a-zA-Z0-9]+)*\/[0-9a-f]{8}$/;

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

@@ -1,18 +1,61 @@
 import { openProjectionGenerationStore } from "./generation/store.js";
-import { observeProjectionRunnerLock } from "./projection-runner-lock.js";
+import { acquireProjectionRunnerSettlementLock, observeProjectionRunnerLock, ProjectionRunnerLockUnavailableError, } from "./projection-runner-lock.js";
+/** The runner observes this durable intent and owns native termination. */
+export function interruptProjectionGeneration(projectionDirectory, nowMs = Date.now()) {
+    const store = openProjectionGenerationStore(projectionDirectory);
+    try {
+        for (;;) {
+            const current = store.readCurrentGeneration();
+            if (!current)
+                return { status: "already-closed" };
+            if (current.verdict)
+                return { status: "already-closed", executionId: current.launch.executionId };
+            const executionId = current.launch.executionId;
+            if (!current.adoption || observeProjectionRunnerLock(projectionDirectory).state !== "held") {
+                return { status: "already-closed", executionId };
+            }
+            const request = store.requestInterruptIfOpen({
+                executionId,
+                interruptedAt: new Date(nowMs).toISOString(),
+            });
+            if (request.status === "committed")
+                return { status: "accepted", executionId };
+            if (request.reason === "not-current")
+                continue;
+            if (request.reason === "interrupt-requested")
+                return { status: "accepted", executionId };
+            return { status: "already-closed", executionId };
+        }
+    }
+    finally {
+        store.close();
+    }
+}
 function settleReleasedLeash(store, projectionDirectory, executionId) {
-    const observation = observeProjectionRunnerLock(projectionDirectory);
-    if (observation.state === "held" || observation.state === "unknown") {
+    const current = store.readCurrentGeneration();
+    if (current?.launch.executionId !== executionId
+        || current.verdict) {
         return { status: "accepted", executionId };
     }
-    // Positive released-leash evidence only; settlement race still reports accepted.
-    store.settleKillIfRunnerDead({
-        executionId,
-        releasedLockEvidence: {
-            state: "released",
+    let deathEvidence;
+    try {
+        deathEvidence = acquireProjectionRunnerSettlementLock(projectionDirectory);
+    }
+    catch (error) {
+        if (error instanceof ProjectionRunnerLockUnavailableError) {
+            return { status: "accepted", executionId };
+        }
+        return { status: "accepted", executionId };
+    }
+    try {
+        store.settleKillIfRunnerDead({
             executionId,
-        },
-    });
+            releasedLockEvidence: { state: "acquired", executionId },
+        });
+    }
+    finally {
+        deathEvidence.close();
+    }
     return { status: "accepted", executionId };
 }
 /**

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

@@ -4,6 +4,7 @@ export const GENERATION_VERDICT_STATES = [
     "launch-failed",
     "lost-runner",
     "dismissed",
+    "interrupted",
     "killed",
 ];
 function asLaunch(record) {
@@ -21,6 +22,11 @@ function asKillIntent(record) {
         ? record
         : undefined;
 }
+function asInterruptIntent(record) {
+    return record.kind === "interrupt-intent"
+        ? record
+        : undefined;
+}
 function asVerdict(record) {
     return record.kind === "verdict"
         ? record
@@ -41,18 +47,21 @@ export function selectCurrentGeneration(records) {
         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 } : {}),
     };
 }
@@ -67,6 +76,7 @@ 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":