@maiaos/node 0.1.0-canary.44938d4.manual.1

package/dist/session/turn/storage/interrupt.js

@@ -0,0 +1,757 @@
+import { turnSchema } from "@maiaos/protocol";
+import { Effect, Schema } from "effect";
+import { commandReceiptFromPersisted } from "../../../command-receipt/storage/codec.js";
+import { makeNodeRuntimeError, NodeRuntimeError, } from "../../../runtime/errors.js";
+import { appendFollowUpEventWithMutation, commitCommandWithMutation, findPersistedCommand, } from "../../../storage/journal.js";
+import { advanceSignedSqliteInteger } from "../../../storage/sqlite-integer.js";
+import { sessionRuntimePolicy } from "../../runtime/policy.js";
+import { sessionRuntimeProfile } from "../../storage/runtime-profile.js";
+import { readSession, SESSION_AGGREGATE_TYPE, } from "../../storage/session-record.js";
+import { interruptTurn } from "./lifecycle.js";
+import { readTurn, readTurnRow, statementWithBigInts, } from "./record.js";
+export const TURN_INTERRUPT_METHOD = "turn.interrupt";
+export const TURN_INTERRUPT_AGGREGATE_TYPE = "turn-interrupt";
+const strictDecodeOptions = {
+    errors: "all",
+    onExcessProperty: "error",
+    reportInput: false,
+};
+const identifierSchema = Schema.String.check(Schema.isLengthBetween(1, 128), Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u));
+const revisionSchema = Schema.String.check(Schema.isLengthBetween(1, 19), Schema.isPattern(/^(?:0|[1-9]\d*)$/u));
+const turnInterruptParametersSchema = Schema.Struct({
+    commandId: identifierSchema,
+    expectedRevision: revisionSchema,
+    turnId: identifierSchema,
+});
+const decodeTurnInterruptParameters = Schema.decodeUnknownSync(turnInterruptParametersSchema, strictDecodeOptions);
+const persistPhaseSchema = Schema.Literals([
+    "outcome-unknown",
+    "prepared",
+    "settled",
+]);
+const persistResultSchema = Schema.Struct({
+    nativeRequired: Schema.Boolean,
+    persistPhase: persistPhaseSchema,
+    runtimeTurnId: Schema.optional(Schema.String),
+    turn: Schema.Unknown,
+});
+const decodePersistResult = Schema.decodeUnknownSync(persistResultSchema, strictDecodeOptions);
+const eventTypeRowSchema = Schema.Struct({
+    eventType: Schema.String,
+});
+const decodeEventTypeRow = Schema.decodeUnknownSync(eventTypeRowSchema);
+const commandIdRowSchema = Schema.Struct({
+    commandId: Schema.String,
+});
+const decodeCommandIdRow = Schema.decodeUnknownSync(commandIdRowSchema);
+const countRowSchema = Schema.Struct({ value: Schema.Number });
+const decodeCountRow = Schema.decodeUnknownSync(countRowSchema);
+const interruptReceiptRowSchema = Schema.Struct({
+    actorId: Schema.String,
+    aggregateRevision: Schema.BigInt,
+    createdAt: Schema.String,
+    eventCursor: Schema.BigInt,
+    method: Schema.String,
+    receiptId: Schema.String,
+    requestDigest: Schema.String,
+    resultJson: Schema.String,
+    targetId: Schema.String,
+    targetType: Schema.String,
+});
+const decodeInterruptReceiptRow = Schema.decodeUnknownSync(interruptReceiptRowSchema);
+const eventTypeForPhase = (phase) => {
+    switch (phase) {
+        case "acknowledged":
+            return "turn.interrupt.acknowledged";
+        case "dispatching":
+            return "turn.interrupt.dispatching";
+        case "outcome-unknown":
+            return "turn.interrupt.outcome-unknown";
+        case "prepared":
+            return "turn.interrupt.prepared";
+        case "settled":
+            return "turn.interrupt.settled";
+    }
+};
+const phaseForEventType = (eventType) => {
+    switch (eventType) {
+        case "turn.interrupt.acknowledged":
+            return "acknowledged";
+        case "turn.interrupt.dispatching":
+            return "dispatching";
+        case "turn.interrupt.outcome-unknown":
+            return "outcome-unknown";
+        case "turn.interrupt.prepared":
+            return "prepared";
+        case "turn.interrupt.settled":
+            return "settled";
+        default:
+            throw makeNodeRuntimeError("storage_corrupt", "The turn interrupt phase event is invalid.");
+    }
+};
+const IN_FLIGHT_EVENT_TYPES = [
+    "turn.interrupt.acknowledged",
+    "turn.interrupt.dispatching",
+    "turn.interrupt.prepared",
+];
+const MAXIMUM_IN_FLIGHT_INTERRUPTS = sessionRuntimePolicy.maximumActiveSessions *
+    sessionRuntimePolicy.maximumPendingTurnsPerSession;
+const asStorageError = (error, message) => {
+    if (error instanceof NodeRuntimeError)
+        return error;
+    return makeNodeRuntimeError("storage_failed", message);
+};
+const parseParameters = (raw) => {
+    try {
+        return decodeTurnInterruptParameters(raw);
+    }
+    catch (error) {
+        throw asStorageError(error, "The turn interrupt parameters are invalid.");
+    }
+};
+const requireChanged = (changes) => {
+    if (changes !== 1 && changes !== 1n) {
+        throw makeNodeRuntimeError("storage_conflict", "The turn changed before its interrupt lifecycle event was persisted.", true);
+    }
+};
+const optionalRuntimeTurnId = (runtimeTurnId) => runtimeTurnId === undefined ? {} : { runtimeTurnId };
+const parsePersistedTurn = (value) => {
+    try {
+        return turnSchema.parse(value);
+    }
+    catch (error) {
+        throw asStorageError(error, "The persisted turn interrupt result is invalid.");
+    }
+};
+const decodePersistSnapshot = (resultJson) => {
+    try {
+        const decoded = decodePersistResult(JSON.parse(resultJson));
+        return {
+            nativeRequired: decoded.nativeRequired,
+            persistPhase: decoded.persistPhase,
+            runtimeTurnId: decoded.runtimeTurnId,
+            turn: parsePersistedTurn(decoded.turn),
+        };
+    }
+    catch (error) {
+        throw asStorageError(error, "The persisted turn interrupt result is invalid.");
+    }
+};
+const resultFromSnapshot = (commandId, persisted, snapshot) => ({
+    delivery: persisted.duplicate ? "duplicate" : "new",
+    method: TURN_INTERRUPT_METHOD,
+    nativeRequired: snapshot.nativeRequired,
+    phase: snapshot.persistPhase,
+    receipt: commandReceiptFromPersisted(commandId, persisted),
+    turn: snapshot.turn,
+    ...optionalRuntimeTurnId(snapshot.runtimeTurnId),
+});
+export const turnInterruptResultFromCommand = (commandId, result) => resultFromSnapshot(commandId, result, decodePersistSnapshot(result.resultJson));
+const readInterruptPhase = (database, commandId) => {
+    const row = statementWithBigInts(database, `SELECT event_type AS eventType FROM domain_events
+     WHERE aggregate_type = ? AND aggregate_id = ?
+     ORDER BY aggregate_sequence DESC LIMIT 1`).get(TURN_INTERRUPT_AGGREGATE_TYPE, commandId);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("storage_corrupt", "The turn interrupt command is missing its durable phase.");
+    }
+    return phaseForEventType(decodeEventTypeRow(row).eventType);
+};
+const readInterruptAggregateRevision = (database, commandId) => {
+    const row = statementWithBigInts(database, `SELECT revision FROM aggregate_revisions
+     WHERE aggregate_type = ? AND aggregate_id = ?`).get(TURN_INTERRUPT_AGGREGATE_TYPE, commandId);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("storage_corrupt", "The turn interrupt aggregate revision is missing.");
+    }
+    return Schema.decodeUnknownSync(Schema.Struct({ revision: Schema.BigInt }))(row).revision;
+};
+const findExistingTurnInterruptCommandId = (database, turnId) => {
+    const rows = database
+        .prepare(`SELECT command_id AS commandId FROM command_receipts
+       WHERE method = ? AND target_id = ? LIMIT 2`)
+        .all(TURN_INTERRUPT_METHOD, turnId);
+    if (rows.length > 1) {
+        throw makeNodeRuntimeError("storage_corrupt", "The turn has more than one interrupt command.");
+    }
+    const row = rows[0];
+    return row === undefined ? undefined : decodeCommandIdRow(row).commandId;
+};
+const findExistingPrepare = (database, input) => {
+    const result = findPersistedCommand(database, {
+        actorId: input.actorId,
+        commandId: input.parameters.commandId,
+        method: TURN_INTERRUPT_METHOD,
+        requestDigest: input.requestDigest,
+    });
+    return result === undefined
+        ? undefined
+        : turnInterruptResultFromCommand(input.parameters.commandId, result);
+};
+const requireSessionRevision = (database, row, expectedRevision) => {
+    const session = readSession(database, row.sessionId);
+    if (session.revision !== expectedRevision) {
+        throw makeNodeRuntimeError("storage_conflict", "The session revision changed before the turn interrupt was accepted.", true);
+    }
+};
+const requireSessionProjection = (database, row) => {
+    const session = readSession(database, row.sessionId);
+    if (BigInt(session.revision) < row.sessionRevision) {
+        throw makeNodeRuntimeError("storage_corrupt", "The turn revision is ahead of its session.");
+    }
+    return session;
+};
+const insertSessionTurnEvent = (input) => {
+    input.database
+        .prepare(`INSERT INTO domain_events(
+        aggregate_type, aggregate_id, aggregate_sequence, event_type,
+        payload_json, recorded_at, command_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)`)
+        .run(SESSION_AGGREGATE_TYPE, input.sessionId, input.nextSessionRevision, input.eventType, JSON.stringify(input.eventPayload), input.recordedAt, input.commandId);
+    input.database
+        .prepare(`INSERT INTO aggregate_revisions(aggregate_type, aggregate_id, revision)
+       VALUES (?, ?, ?)
+       ON CONFLICT(aggregate_type, aggregate_id)
+       DO UPDATE SET revision = excluded.revision`)
+        .run(SESSION_AGGREGATE_TYPE, input.sessionId, input.nextSessionRevision);
+};
+const updateSessionRevision = (input) => {
+    const result = input.database
+        .prepare(`UPDATE sessions SET revision = ?, updated_at = ?
+       WHERE session_id = ? AND revision = ?`)
+        .run(input.nextRevision, input.recordedAt, input.sessionId, input.expectedRevision);
+    requireChanged(result.changes);
+};
+const applySessionTurnMutation = (input) => {
+    const session = requireSessionProjection(input.database, input.row);
+    const nextRevision = advanceSignedSqliteInteger(input.row.revision);
+    const sessionRevision = BigInt(session.revision);
+    const nextSessionRevision = advanceSignedSqliteInteger(sessionRevision);
+    input.mutateTurn({ nextRevision, nextSessionRevision });
+    updateSessionRevision({
+        database: input.database,
+        expectedRevision: sessionRevision,
+        nextRevision: nextSessionRevision,
+        recordedAt: input.recordedAt,
+        sessionId: input.row.sessionId,
+    });
+    insertSessionTurnEvent({
+        commandId: input.row.commandId,
+        database: input.database,
+        eventPayload: {
+            ...sessionRuntimeProfile(session),
+            ...input.eventPayload,
+        },
+        eventType: input.eventType,
+        nextSessionRevision,
+        recordedAt: input.recordedAt,
+        sessionId: input.row.sessionId,
+    });
+};
+const updateFailedTurnRow = (database, input) => {
+    const result = database
+        .prepare(`UPDATE session_turns SET state = ?, failure_reason = ?, revision = ?,
+       session_revision = ?, updated_at = ? WHERE turn_id = ?
+       AND state IN ('queued', 'dispatching', 'running') AND revision = ?`)
+        .run(input.state, input.reason, input.nextRevision, input.nextSessionRevision, input.recordedAt, input.row.id, input.row.revision);
+    requireChanged(result.changes);
+};
+const failTurnInOpenTransaction = (database, input) => {
+    applySessionTurnMutation({
+        database,
+        eventPayload: {
+            reason: input.reason,
+            state: input.state,
+            turnId: input.row.id,
+        },
+        eventType: "turn.failed",
+        mutateTurn: ({ nextRevision, nextSessionRevision }) => {
+            updateFailedTurnRow(database, {
+                ...input,
+                nextRevision,
+                nextSessionRevision,
+            });
+        },
+        recordedAt: input.recordedAt,
+        row: input.row,
+    });
+};
+const updateInterruptedTurnRow = (database, input) => {
+    const result = database
+        .prepare(`UPDATE session_turns SET state = 'interrupted', revision = ?,
+       session_revision = ?, updated_at = ?
+       WHERE turn_id = ? AND state = 'running' AND revision = ?`)
+        .run(input.nextRevision, input.nextSessionRevision, input.recordedAt, input.row.id, input.row.revision);
+    requireChanged(result.changes);
+};
+const applyInterruptedTurnMutation = (database, row, recordedAt) => {
+    applySessionTurnMutation({
+        database,
+        eventPayload: { turnId: row.id },
+        eventType: "turn.interrupted",
+        mutateTurn: ({ nextRevision, nextSessionRevision }) => {
+            updateInterruptedTurnRow(database, {
+                nextRevision,
+                nextSessionRevision,
+                recordedAt,
+                row,
+            });
+        },
+        recordedAt,
+        row,
+    });
+};
+const interruptRunningTurnInOpenTransaction = (database, row, recordedAt) => {
+    if (row.state !== "running" || row.runtimeTurnId === null)
+        return false;
+    try {
+        applyInterruptedTurnMutation(database, row, recordedAt);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof NodeRuntimeError &&
+            error.code === "storage_conflict") {
+            return false;
+        }
+        throw error;
+    }
+};
+const persistResultJson = (snapshot) => JSON.stringify({
+    nativeRequired: snapshot.nativeRequired,
+    persistPhase: snapshot.persistPhase,
+    turn: snapshot.turn,
+    ...optionalRuntimeTurnId(snapshot.runtimeTurnId),
+});
+const runtimeProfileForTurn = (database, turnId) => {
+    const row = readTurnRow(database, turnId);
+    return sessionRuntimeProfile(readSession(database, row.sessionId));
+};
+const makeInterruptCommand = (input) => ({
+    actorId: input.command.actorId,
+    aggregateId: input.command.parameters.commandId,
+    aggregateType: TURN_INTERRUPT_AGGREGATE_TYPE,
+    commandId: input.command.parameters.commandId,
+    eventPayloadJson: JSON.stringify({
+        nativeRequired: input.snapshot.nativeRequired,
+        phase: input.snapshot.persistPhase,
+        ...runtimeProfileForTurn(input.database, input.command.parameters.turnId),
+        turnId: input.command.parameters.turnId,
+    }),
+    eventType: input.eventType,
+    expectedRevision: 0n,
+    method: TURN_INTERRUPT_METHOD,
+    requestDigest: input.command.requestDigest,
+    resultJson: persistResultJson(input.snapshot),
+    targetId: input.command.parameters.turnId,
+    targetType: "turn",
+});
+const requireNoOtherInterrupt = (database, turnId, commandId) => {
+    const existing = findExistingTurnInterruptCommandId(database, turnId);
+    if (existing !== undefined && existing !== commandId) {
+        throw makeNodeRuntimeError("storage_conflict", "The turn already has an interrupt command.", true);
+    }
+};
+const queuedInterruptDecision = (input) => ({
+    eventType: eventTypeForPhase("settled"),
+    mutate: () => {
+        failTurnInOpenTransaction(input.database, {
+            reason: "turn_rejected",
+            recordedAt: input.recordedAt,
+            row: input.row,
+            state: "failed",
+        });
+    },
+    snapshot: {
+        nativeRequired: false,
+        persistPhase: "settled",
+        turn: input.current,
+    },
+});
+const dispatchingInterruptDecision = (input) => ({
+    eventType: eventTypeForPhase("outcome-unknown"),
+    mutate: () => {
+        failTurnInOpenTransaction(input.database, {
+            reason: "runtime_exited",
+            recordedAt: input.recordedAt,
+            row: input.row,
+            state: "outcome-unknown",
+        });
+    },
+    snapshot: {
+        nativeRequired: false,
+        persistPhase: "outcome-unknown",
+        turn: input.current,
+    },
+});
+const requireStillRunning = (database, turnId) => {
+    const latest = readTurnRow(database, turnId);
+    if (latest.state !== "running" || latest.runtimeTurnId === null) {
+        throw makeNodeRuntimeError("storage_conflict", "The turn is no longer legally interruptible.", true);
+    }
+};
+const runningInterruptDecision = (database, row, current) => ({
+    eventType: eventTypeForPhase("prepared"),
+    mutate: () => {
+        requireStillRunning(database, row.id);
+    },
+    snapshot: {
+        nativeRequired: true,
+        persistPhase: "prepared",
+        runtimeTurnId: row.runtimeTurnId ?? undefined,
+        turn: current,
+    },
+});
+const decisionForTurn = (database, row, recordedAt) => {
+    const current = readTurn(database, row.id);
+    const context = { current, database, recordedAt, row };
+    if (row.state === "queued") {
+        return queuedInterruptDecision(context);
+    }
+    if (row.state === "dispatching") {
+        return dispatchingInterruptDecision(context);
+    }
+    if (row.state === "running" && row.runtimeTurnId !== null) {
+        return runningInterruptDecision(database, row, current);
+    }
+    throw makeNodeRuntimeError("storage_conflict", "The turn is no longer legally interruptible.", true);
+};
+const commitPreparedInterrupt = (context) => commitCommandWithMutation({
+    database: context.database,
+    input: makeInterruptCommand({
+        command: context.input,
+        database: context.database,
+        eventType: context.decision.eventType,
+        snapshot: context.decision.snapshot,
+    }),
+    mutate: () => {
+        requireNoOtherInterrupt(context.database, context.input.parameters.turnId, context.input.parameters.commandId);
+        requireSessionRevision(context.database, readTurnRow(context.database, context.input.parameters.turnId), context.input.parameters.expectedRevision);
+        context.decision.mutate();
+    },
+    recordedAt: context.recordedAt,
+});
+const requireFreshInterrupt = (database, input) => {
+    const row = readTurnRow(database, input.parameters.turnId);
+    requireSessionRevision(database, row, input.parameters.expectedRevision);
+    requireNoOtherInterrupt(database, input.parameters.turnId, input.parameters.commandId);
+    return row;
+};
+export const prepareTurnInterrupt = (database, rawInput, recordedAt) => {
+    const input = {
+        ...rawInput,
+        parameters: parseParameters(rawInput.parameters),
+    };
+    const existing = findExistingPrepare(database, input);
+    if (existing !== undefined)
+        return existing;
+    const decision = decisionForTurn(database, requireFreshInterrupt(database, input), recordedAt);
+    return turnInterruptResultFromCommand(input.parameters.commandId, commitPreparedInterrupt({ database, decision, input, recordedAt }));
+};
+const INTERRUPT_RECEIPT_SELECT = `SELECT receipt_id AS receiptId, method,
+  actor_id AS actorId, request_digest AS requestDigest,
+  result_json AS resultJson, event_cursor AS eventCursor,
+  created_at AS createdAt, target_type AS targetType, target_id AS targetId,
+  (SELECT aggregate_sequence FROM domain_events
+   WHERE global_sequence = command_receipts.event_cursor)
+   AS aggregateRevision
+ FROM command_receipts WHERE command_id = ? AND method = ?`;
+const persistedFromReceiptRow = (row) => ({
+    actorId: row.actorId,
+    aggregateRevision: row.aggregateRevision.toString(),
+    createdAt: row.createdAt,
+    duplicate: false,
+    eventCursor: row.eventCursor.toString(),
+    method: row.method,
+    receiptId: row.receiptId,
+    resultJson: row.resultJson,
+    targetId: row.targetId,
+    targetType: row.targetType,
+});
+const requirePersistedInterrupt = (database, commandId) => {
+    const row = statementWithBigInts(database, INTERRUPT_RECEIPT_SELECT).get(commandId, TURN_INTERRUPT_METHOD);
+    if (row === undefined) {
+        throw makeNodeRuntimeError("resource_not_found", "The turn interrupt command was not found.");
+    }
+    return persistedFromReceiptRow(decodeInterruptReceiptRow(row));
+};
+const commandFromPersisted = (database, commandId) => {
+    const persisted = requirePersistedInterrupt(database, commandId);
+    const snapshot = decodePersistSnapshot(persisted.resultJson);
+    const phase = readInterruptPhase(database, commandId);
+    return {
+        commandId,
+        nativeRequired: snapshot.nativeRequired,
+        phase,
+        receipt: commandReceiptFromPersisted(commandId, persisted),
+        turn: readTurn(database, persisted.targetId),
+        ...optionalRuntimeTurnId(snapshot.runtimeTurnId),
+    };
+};
+export const readTurnInterrupt = (database, commandId) => commandFromPersisted(database, commandId);
+const appendInterruptPhase = (database, input) => {
+    const expectedRevision = readInterruptAggregateRevision(database, input.commandId);
+    appendFollowUpEventWithMutation({
+        database,
+        event: {
+            aggregateId: input.commandId,
+            aggregateType: TURN_INTERRUPT_AGGREGATE_TYPE,
+            commandId: input.commandId,
+            eventPayloadJson: JSON.stringify({
+                phase: input.nextPhase,
+                ...runtimeProfileForTurn(database, input.turnId),
+                turnId: input.turnId,
+            }),
+            eventType: eventTypeForPhase(input.nextPhase),
+            expectedRevision,
+        },
+        mutate: input.mutate,
+        recordedAt: input.recordedAt,
+    });
+};
+const nativeDispatchTarget = (row) => row.state === "running" && row.runtimeTurnId !== null
+    ? { runtimeTurnId: row.runtimeTurnId }
+    : undefined;
+const notDispatchable = (commandId, phase, reason) => ({
+    commandId,
+    kind: "not-dispatchable",
+    phase,
+    reason,
+});
+const claimReason = (current) => {
+    if (current.phase === "settled")
+        return "already-settled";
+    if (current.phase === "outcome-unknown")
+        return "outcome-unknown";
+    if (current.phase !== "prepared" || !current.nativeRequired) {
+        return "not-prepared";
+    }
+    return undefined;
+};
+const requireDispatchTarget = (row) => {
+    const target = nativeDispatchTarget(row);
+    if (target === undefined) {
+        throw makeNodeRuntimeError("storage_conflict", "The turn is no longer legally interruptible.", true);
+    }
+    return target;
+};
+const dispatchPreparedInterrupt = (database, current, recordedAt) => {
+    const row = readTurnRow(database, current.turn.id);
+    const target = nativeDispatchTarget(row);
+    if (target === undefined) {
+        return notDispatchable(current.commandId, current.phase, "not-running");
+    }
+    appendInterruptPhase(database, {
+        commandId: current.commandId,
+        mutate: () => {
+            requireDispatchTarget(readTurnRow(database, current.turn.id));
+        },
+        nextPhase: "dispatching",
+        recordedAt,
+        turnId: current.turn.id,
+    });
+    return {
+        commandId: current.commandId,
+        kind: "claimed",
+        runtimeTurnId: target.runtimeTurnId,
+        sessionId: row.sessionId,
+        turnId: current.turn.id,
+    };
+};
+export const claimPreparedTurnInterrupt = (database, commandId, recordedAt) => {
+    const current = commandFromPersisted(database, commandId);
+    const blocked = claimReason(current);
+    if (blocked !== undefined) {
+        return notDispatchable(commandId, current.phase, blocked);
+    }
+    return dispatchPreparedInterrupt(database, current, recordedAt);
+};
+export const acknowledgeTurnInterrupt = (database, commandId, recordedAt) => {
+    const current = commandFromPersisted(database, commandId);
+    if (current.phase === "acknowledged" || current.phase === "settled") {
+        return current;
+    }
+    if (current.phase !== "dispatching") {
+        throw makeNodeRuntimeError("storage_conflict", "The turn interrupt is not waiting for native acknowledgement.", true);
+    }
+    appendInterruptPhase(database, {
+        commandId,
+        mutate: () => {
+            readTurnRow(database, current.turn.id);
+        },
+        nextPhase: "acknowledged",
+        recordedAt,
+        turnId: current.turn.id,
+    });
+    return commandFromPersisted(database, commandId);
+};
+const settleInFlightInterruptCommand = (database, current, recordedAt) => {
+    appendInterruptPhase(database, {
+        commandId: current.commandId,
+        mutate: () => {
+            const row = readTurnRow(database, current.turn.id);
+            interruptRunningTurnInOpenTransaction(database, row, recordedAt);
+        },
+        nextPhase: "settled",
+        recordedAt,
+        turnId: current.turn.id,
+    });
+    return commandFromPersisted(database, current.commandId);
+};
+const settlePreparedWithoutNative = (database, current, recordedAt) => {
+    const row = readTurnRow(database, current.turn.id);
+    if (nativeDispatchTarget(row) !== undefined) {
+        throw makeNodeRuntimeError("storage_conflict", "A running turn interrupt must be dispatched before it can settle.", true);
+    }
+    appendInterruptPhase(database, {
+        commandId: current.commandId,
+        mutate: () => {
+            readTurnRow(database, current.turn.id);
+        },
+        nextPhase: "settled",
+        recordedAt,
+        turnId: current.turn.id,
+    });
+    return commandFromPersisted(database, current.commandId);
+};
+export const settleTurnInterrupt = (database, commandId, recordedAt) => {
+    const current = commandFromPersisted(database, commandId);
+    if (current.phase === "settled" || current.phase === "outcome-unknown") {
+        return current;
+    }
+    if (current.phase === "dispatching") {
+        throw makeNodeRuntimeError("storage_conflict", "A dispatching turn interrupt cannot settle as interrupted.", true);
+    }
+    if (current.phase === "acknowledged") {
+        return settleInFlightInterruptCommand(database, current, recordedAt);
+    }
+    if (!current.nativeRequired)
+        return current;
+    return settlePreparedWithoutNative(database, current, recordedAt);
+};
+const failClosedRuntimeSettlement = (phase) => makeNodeRuntimeError("storage_conflict", phase === "prepared"
+    ? "A prepared turn interrupt cannot settle from the runtime callback."
+    : "The turn interrupt is not in a runtime-settlable phase.", true);
+export const settleRuntimeTurnInterrupt = (database, turnId, recordedAt) => {
+    const commandId = findExistingTurnInterruptCommandId(database, turnId);
+    if (commandId === undefined) {
+        return {
+            kind: "direct",
+            turn: interruptTurn(database, turnId, recordedAt),
+        };
+    }
+    const current = commandFromPersisted(database, commandId);
+    if (current.phase === "settled" || current.phase === "outcome-unknown") {
+        return { command: current, kind: "command" };
+    }
+    if (current.phase === "dispatching" || current.phase === "acknowledged") {
+        return {
+            command: settleInFlightInterruptCommand(database, current, recordedAt),
+            kind: "command",
+        };
+    }
+    throw failClosedRuntimeSettlement(current.phase);
+};
+const fenceInFlightTurnIfNeeded = (database, turnId, recordedAt) => {
+    const row = readTurnRow(database, turnId);
+    if (row.state !== "dispatching" &&
+        row.state !== "queued" &&
+        row.state !== "running") {
+        return;
+    }
+    failTurnInOpenTransaction(database, {
+        reason: "runtime_exited",
+        recordedAt,
+        row,
+        state: "outcome-unknown",
+    });
+};
+export const fenceTurnInterruptUnknown = (database, commandId, recordedAt) => {
+    const current = commandFromPersisted(database, commandId);
+    if (current.phase === "outcome-unknown")
+        return current;
+    if (current.phase !== "prepared" &&
+        current.phase !== "dispatching" &&
+        current.phase !== "acknowledged") {
+        throw makeNodeRuntimeError("storage_conflict", "The turn interrupt is not in a fenceable phase.", true);
+    }
+    appendInterruptPhase(database, {
+        commandId,
+        mutate: () => {
+            fenceInFlightTurnIfNeeded(database, current.turn.id, recordedAt);
+        },
+        nextPhase: "outcome-unknown",
+        recordedAt,
+        turnId: current.turn.id,
+    });
+    return commandFromPersisted(database, commandId);
+};
+const listInFlightInterruptCommandIds = (database) => {
+    const rows = database
+        .prepare(`SELECT de.aggregate_id AS commandId
+       FROM domain_events de
+       JOIN aggregate_revisions ar
+         ON ar.aggregate_type = de.aggregate_type
+        AND ar.aggregate_id = de.aggregate_id
+        AND ar.revision = de.aggregate_sequence
+       WHERE de.aggregate_type = ?
+         AND de.event_type IN (?, ?, ?)
+       ORDER BY de.aggregate_sequence
+       LIMIT ?`)
+        .all(TURN_INTERRUPT_AGGREGATE_TYPE, ...IN_FLIGHT_EVENT_TYPES, MAXIMUM_IN_FLIGHT_INTERRUPTS + 1)
+        .map((row) => decodeCommandIdRow(row).commandId);
+    if (rows.length > MAXIMUM_IN_FLIGHT_INTERRUPTS) {
+        throw makeNodeRuntimeError("storage_corrupt", "The recoverable in-flight turn interrupt bound is invalid.");
+    }
+    return rows;
+};
+export const reconcileInFlightTurnInterrupts = (database, recordedAt) => {
+    const commandIds = listInFlightInterruptCommandIds(database);
+    commandIds.forEach((commandId) => {
+        fenceTurnInterruptUnknown(database, commandId, recordedAt);
+    });
+    return commandIds.length;
+};
+export const countTurnInterruptCommands = (database) => decodeCountRow(database
+    .prepare("SELECT count(*) AS value FROM command_receipts WHERE method = ?")
+    .get(TURN_INTERRUPT_METHOD)).value;
+export const prepareTurnInterruptEffect = Effect.fn("Turn.interrupt")(function* (database, input, recordedAt) {
+    return yield* Effect.try({
+        catch: (error) => asStorageError(error, "The Maia turn interrupt could not be persisted."),
+        try: () => prepareTurnInterrupt(database, input, recordedAt),
+    });
+});
+export const claimPreparedTurnInterruptEffect = Effect.fn("Turn.interrupt.claim")(function* (database, commandId, recordedAt) {
+    return yield* Effect.try({
+        catch: (error) => asStorageError(error, "The turn interrupt could not be claimed."),
+        try: () => claimPreparedTurnInterrupt(database, commandId, recordedAt),
+    });
+});
+export const acknowledgeTurnInterruptEffect = Effect.fn("Turn.interrupt.acknowledge")(function* (database, commandId, recordedAt) {
+    return yield* Effect.try({
+        catch: (error) => asStorageError(error, "The turn interrupt acknowledgement could not be persisted."),
+        try: () => acknowledgeTurnInterrupt(database, commandId, recordedAt),
+    });
+});
+export const settleTurnInterruptEffect = Effect.fn("Turn.interrupt.settle")(function* (database, commandId, recordedAt) {
+    return yield* Effect.try({
+        catch: (error) => asStorageError(error, "The turn interrupt could not be settled."),
+        try: () => settleTurnInterrupt(database, commandId, recordedAt),
+    });
+});
+export const settleRuntimeTurnInterruptEffect = Effect.fn("Turn.interrupt.settleRuntime")(function* (database, turnId, recordedAt) {
+    return yield* Effect.try({
+        catch: (error) => asStorageError(error, "The runtime turn interrupt could not be settled."),
+        try: () => settleRuntimeTurnInterrupt(database, turnId, recordedAt),
+    });
+});
+export const fenceTurnInterruptUnknownEffect = Effect.fn("Turn.interrupt.fenceUnknown")(function* (database, commandId, recordedAt) {
+    return yield* Effect.try({
+        catch: (error) => asStorageError(error, "The turn interrupt could not be fenced."),
+        try: () => fenceTurnInterruptUnknown(database, commandId, recordedAt),
+    });
+});
+export const readTurnInterruptEffect = Effect.fn("Turn.interrupt.read")(function* (database, commandId) {
+    return yield* Effect.try({
+        catch: (error) => asStorageError(error, "The turn interrupt could not be read."),
+        try: () => readTurnInterrupt(database, commandId),
+    });
+});
+//# sourceMappingURL=interrupt.js.map