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

package/dist/terminal/storage/live-native-commands.js

@@ -0,0 +1,728 @@
+import { liveTerminalCloseResultSchema, liveTerminalMutationOutcomeUnknownSchema, liveTerminalResizeResultSchema, liveTerminalSessionSchema, liveTerminalSignalResultSchema, liveTerminalWriteResultSchema, MAX_TERMINAL_MUTATION_SEQUENCE, MAX_TERMINAL_NATIVE_OPERATION_SEQUENCE, } from "@maiaos/protocol";
+import { Schema } from "effect";
+import { makeNodeRuntimeError } from "../../runtime/errors.js";
+import { commitCommandWithReceiptMutation, findPersistedCommand, } from "../../storage/journal.js";
+import { transitionControllerLease, transitionControllerRequest, transitionLiveTerminalSession, } from "../live-lifecycle.js";
+import { activatedMutationMethodSchema, commandForResult, createFailureCleanupLifecycleEvent, lifecycleEvent, LOCAL_USER_ACTOR_ID, makeReceipt, newId, updateAcknowledgedMutation, withImmediateTransaction, } from "./live-command-shared.js";
+import { assertLiveTerminalControllerLease } from "./live-controller-commands.js";
+import { readLiveTerminalMutation, } from "./live-mutations.js";
+import { insertLiveTerminalObserverEvent, liveTerminalExitProjection, } from "./live-process-settlement.js";
+import { LIVE_TERMINAL_EXECUTION_CAPABILITY, readLiveTerminalSession, } from "./live-record.js";
+import { liveTerminalRetentionInternals } from "./live-retention.js";
+import { advanceLiveTerminalSqliteInteger, nextLiveTerminalBoundedSequence, } from "./sqlite-counter.js";
+const nullValue = JSON.parse("null");
+const requireExistingMutationIdentity = (mutation, input) => {
+    if (mutation.method !== input.method ||
+        mutation.requestDigest !== input.requestDigest ||
+        mutation.terminalId !== input.parameters.terminalId) {
+        throw makeNodeRuntimeError("storage_conflict", "The command identifier belongs to another Terminal mutation.");
+    }
+};
+const readExistingNativePreparation = (database, input) => {
+    const existing = database
+        .prepare(`SELECT 1 FROM terminal_live_mutations WHERE command_id = ?`)
+        .get(input.parameters.commandId);
+    if (existing === undefined)
+        return;
+    const mutation = readLiveTerminalMutation(database, input.parameters.commandId);
+    requireExistingMutationIdentity(mutation, input);
+    return {
+        mutation,
+        session: readLiveTerminalSession(database, mutation.terminalId),
+    };
+};
+const requireCompleteNativeParameters = (input) => {
+    const complete = (input.method === "terminal.input.write") === (input.write !== undefined) &&
+        (input.method === "terminal.session.resize") ===
+            (input.resize !== undefined) &&
+        (input.method === "terminal.session.signal") ===
+            (input.signal !== undefined);
+    if (complete)
+        return;
+    throw makeNodeRuntimeError("storage_corrupt", "The native Terminal mutation parameters are incomplete.");
+};
+const readNativeMutationSession = (database, input) => {
+    const session = readLiveTerminalSession(database, input.parameters.terminalId);
+    if (session.state !== "running" ||
+        session.generation !== input.parameters.controller.terminalGeneration ||
+        session.revision !== input.parameters.expectedTerminalRevision)
+        throw makeNodeRuntimeError("storage_conflict", "The Terminal mutation fence is stale.", true);
+    assertLiveTerminalControllerLease(database, input.parameters.controller, input.recordedAt);
+    return session;
+};
+const readNativeMutationHeads = (database, terminalId) => database
+    .prepare(`SELECT CAST(mutation_head AS TEXT) AS mutationHead,
+        CAST(native_operation_head AS TEXT) AS nativeOperationHead
+       FROM terminal_live_sessions WHERE terminal_id = ?`)
+    .get(terminalId);
+const preparedNativeMutationValues = (context) => {
+    const { input, mutationSequence, nativeOperationSequence, session } = context;
+    return [
+        input.parameters.commandId,
+        session.id,
+        session.generation,
+        mutationSequence,
+        nativeOperationSequence,
+        input.method,
+        input.requestDigest,
+        BigInt(input.parameters.controller.epoch),
+        BigInt(input.parameters.controller.revision),
+        input.write?.inputId ?? nullValue,
+        input.write?.inputSequence ?? nullValue,
+        input.write?.byteLength ?? nullValue,
+        input.write?.inputDigest ?? nullValue,
+        input.resize?.columns ?? nullValue,
+        input.resize?.rows ?? nullValue,
+        input.signal?.signal ?? nullValue,
+        input.recordedAt,
+        input.recordedAt,
+    ];
+};
+const insertPreparedNativeMutation = (database, context) => {
+    database
+        .prepare(`INSERT INTO terminal_live_mutations(
+        command_id, terminal_id, generation, mutation_sequence,
+        native_operation_sequence, method, request_digest,
+        controller_epoch, controller_revision, input_id, input_sequence,
+        input_byte_length, input_digest, resize_columns, resize_rows,
+        signal_name, effect_phase, dispatch_state, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+        'native-effect', 'prepared', ?, ?)`)
+        .run(...preparedNativeMutationValues(context));
+};
+const applyPreparedClose = (database, input, session) => {
+    if (input.method !== "terminal.session.close")
+        return session;
+    const revision = advanceLiveTerminalSqliteInteger(session.revision);
+    database
+        .prepare(`UPDATE terminal_live_sessions
+       SET state = 'closing', revision = ?, updated_at = ?
+       WHERE terminal_id = ?`)
+        .run(revision, input.recordedAt, session.id);
+    return lifecycleEvent(database, session, input.recordedAt);
+};
+const prepareNativeMutationInTransaction = (database, input) => {
+    const existing = readExistingNativePreparation(database, input);
+    if (existing !== undefined)
+        return existing;
+    requireCompleteNativeParameters(input);
+    const session = readNativeMutationSession(database, input);
+    const heads = readNativeMutationHeads(database, session.id);
+    const mutationSequence = nextLiveTerminalBoundedSequence(heads.mutationHead, MAX_TERMINAL_MUTATION_SEQUENCE);
+    const nativeOperationSequence = nextLiveTerminalBoundedSequence(heads.nativeOperationHead, MAX_TERMINAL_NATIVE_OPERATION_SEQUENCE);
+    insertPreparedNativeMutation(database, {
+        input,
+        mutationSequence,
+        nativeOperationSequence,
+        session,
+    });
+    return {
+        mutation: readLiveTerminalMutation(database, input.parameters.commandId),
+        session: applyPreparedClose(database, input, session),
+    };
+};
+export const prepareLiveTerminalNativeMutation = (database, input) => withImmediateTransaction(database, () => prepareNativeMutationInTransaction(database, input));
+const methodAcknowledgementKind = (method) => {
+    switch (method) {
+        case "terminal.input.write":
+            return "pty-write-accepted";
+        case "terminal.session.resize":
+            return "pty-resized";
+        case "terminal.session.signal":
+            return "signal-delivered";
+        case "terminal.session.close":
+            return "cleanup-known";
+    }
+};
+const operationForNativeMethod = (method) => {
+    switch (method) {
+        case "terminal.input.write":
+            return "write";
+        case "terminal.session.close":
+            return "close";
+        case "terminal.session.resize":
+            return "resize";
+        case "terminal.session.signal":
+            return "signal";
+    }
+};
+const requireNativeAcknowledgement = (mutation, acknowledgement) => {
+    const valid = validNativeAcknowledgement(nativeMethod(mutation.method), mutation, acknowledgement);
+    if (!valid) {
+        throw makeNodeRuntimeError("storage_conflict", "The native Terminal acknowledgement does not match its durable intent.");
+    }
+};
+const validWriteAcknowledgement = (mutation, acknowledgement) => acknowledgement.fact === "pty_master_all_bytes_accepted" &&
+    acknowledgement.acceptedBytes === mutation.inputByteLength &&
+    acknowledgement.byteLength === mutation.inputByteLength &&
+    acknowledgement.inputId === mutation.inputId &&
+    acknowledgement.inputSequence === mutation.inputSequence &&
+    acknowledgement.sha256 === mutation.inputDigest;
+const validNativeAcknowledgement = (method, mutation, acknowledgement) => {
+    switch (method) {
+        case "terminal.input.write":
+            return validWriteAcknowledgement(mutation, acknowledgement);
+        case "terminal.session.resize":
+            return (acknowledgement.fact === "tiocswinsz_succeeded" &&
+                acknowledgement.columns === mutation.resizeColumns &&
+                acknowledgement.rows === mutation.resizeRows);
+        case "terminal.session.signal":
+            return (acknowledgement.fact === "tiocsig_succeeded" &&
+                acknowledgement.signal === mutation.signalName);
+        case "terminal.session.close":
+            return (acknowledgement.fact === "known_identity_members_complete" &&
+                acknowledgement.unknownSurvivorExclusion === "unavailable");
+    }
+};
+const insertCleanupEvent = (database, terminal, recordedAt) => {
+    const cursor = advanceLiveTerminalSqliteInteger(terminal.eventHead);
+    database
+        .prepare(`INSERT INTO terminal_live_events(
+        terminal_id, event_cursor, generation, event_type, metadata_json,
+        recorded_at
+      ) VALUES (?, ?, ?, 'cleanup', ?, ?)`)
+        .run(terminal.id, cursor, terminal.generation, JSON.stringify({ cleanup: terminal.cleanup }), recordedAt);
+    return readLiveTerminalSession(database, terminal.id);
+};
+const applyResizeAcknowledgement = (database, input) => {
+    if (input.method !== "terminal.session.resize" ||
+        input.acknowledgement.fact !== "tiocswinsz_succeeded")
+        return false;
+    database
+        .prepare(`UPDATE terminal_live_sessions SET columns = ?, rows = ?,
+        revision = ?, updated_at = ? WHERE terminal_id = ?`)
+        .run(input.acknowledgement.columns, input.acknowledgement.rows, BigInt(input.projected.revision), input.recordedAt, input.session.id);
+    return true;
+};
+const applyCloseAcknowledgement = (database, input) => {
+    transitionLiveTerminalSession(input.session.state, "exited");
+    const exitedRevision = advanceLiveTerminalSqliteInteger(input.session.revision);
+    database
+        .prepare(`UPDATE terminal_live_sessions SET state = 'exited',
+        exit_signal = 'hangup', exit_observed_at = ?,
+        revision = ?, updated_at = ? WHERE terminal_id = ?`)
+        .run(input.recordedAt, exitedRevision, input.recordedAt, input.session.id);
+    lifecycleEvent(database, input.session, input.recordedAt);
+    database
+        .prepare(`UPDATE terminal_live_sessions
+       SET cleanup_state = 'known_identity_members_complete',
+         revision = ?, updated_at = ? WHERE terminal_id = ?`)
+        .run(BigInt(input.projected.revision), input.recordedAt, input.session.id);
+    return insertCleanupEvent(database, readLiveTerminalSession(database, input.session.id), input.recordedAt);
+};
+const applyNativeAcknowledgedPostcondition = (database, input) => {
+    if (input.method === "terminal.session.close")
+        return applyCloseAcknowledgement(database, input);
+    applyResizeAcknowledgement(database, input);
+    return readLiveTerminalSession(database, input.session.id);
+};
+const nativeResultSchema = (method) => {
+    switch (method) {
+        case "terminal.input.write":
+            return liveTerminalWriteResultSchema;
+        case "terminal.session.close":
+            return liveTerminalCloseResultSchema;
+        case "terminal.session.resize":
+            return liveTerminalResizeResultSchema;
+        case "terminal.session.signal":
+            return liveTerminalSignalResultSchema;
+    }
+};
+const nativeMethod = (method) => {
+    const activated = Schema.decodeUnknownSync(activatedMutationMethodSchema)(method);
+    if (activated !== "terminal.input.write" &&
+        activated !== "terminal.session.close" &&
+        activated !== "terminal.session.resize" &&
+        activated !== "terminal.session.signal") {
+        throw makeNodeRuntimeError("storage_conflict", "The native Terminal mutation method is invalid.");
+    }
+    return activated;
+};
+const decodeNativeDuplicate = (method, persisted) => {
+    const schema = nativeResultSchema(method);
+    const decoded = schema.parse(JSON.parse(persisted.resultJson));
+    return decoded.outcome === "acknowledged"
+        ? schema.parse({
+            ...decoded,
+            receipt: { ...decoded.receipt, delivery: "duplicate" },
+        })
+        : decoded;
+};
+const nativeReceiptCommon = (input, nativeOperationSequence) => ({
+    capability: LIVE_TERMINAL_EXECUTION_CAPABILITY,
+    commandId: input.mutation.commandId,
+    mutationSequence: input.mutation.mutationSequence,
+    nativeOperationSequence,
+    terminalGeneration: input.mutation.generation,
+    terminalId: input.mutation.terminalId,
+    terminalRevision: input.terminalRevision,
+});
+const writeReceiptFields = (input, common) => input.acknowledgement.fact === "pty_master_all_bytes_accepted"
+    ? {
+        ...common,
+        method: "terminal.input.write",
+        nativeAcknowledgement: input.acknowledgement,
+        operation: "write",
+    }
+    : undefined;
+const closeReceiptFields = (input, common) => input.acknowledgement.fact === "known_identity_members_complete"
+    ? {
+        ...common,
+        method: "terminal.session.close",
+        nativeAcknowledgement: input.acknowledgement,
+        operation: "close",
+    }
+    : undefined;
+const resizeReceiptFields = (input, common) => input.acknowledgement.fact === "tiocswinsz_succeeded"
+    ? {
+        ...common,
+        method: "terminal.session.resize",
+        nativeAcknowledgement: input.acknowledgement,
+        operation: "resize",
+    }
+    : undefined;
+const signalReceiptFields = (input, common) => input.acknowledgement.fact === "tiocsig_succeeded"
+    ? {
+        ...common,
+        method: "terminal.session.signal",
+        nativeAcknowledgement: input.acknowledgement,
+        operation: "signal",
+    }
+    : undefined;
+const exactNativeReceiptFields = (input, common) => {
+    let fields;
+    switch (input.method) {
+        case "terminal.input.write":
+            fields = writeReceiptFields(input, common);
+            break;
+        case "terminal.session.close":
+            fields = closeReceiptFields(input, common);
+            break;
+        case "terminal.session.resize":
+            fields = resizeReceiptFields(input, common);
+            break;
+        case "terminal.session.signal":
+            fields = signalReceiptFields(input, common);
+    }
+    if (fields !== undefined)
+        return fields;
+    throw makeNodeRuntimeError("storage_corrupt", "The native Terminal receipt acknowledgement is invalid.");
+};
+const makeNativeReceipt = (persisted, input) => {
+    const nativeOperationSequence = input.mutation.nativeOperationSequence;
+    if (nativeOperationSequence === null) {
+        throw makeNodeRuntimeError("storage_corrupt", "The native Terminal receipt sequence is unavailable.");
+    }
+    const common = nativeReceiptCommon(input, nativeOperationSequence);
+    return makeReceipt(persisted, exactNativeReceiptFields(input, common));
+};
+const readAcknowledgableNativeMutation = (database, input) => {
+    const mutation = readLiveTerminalMutation(database, input.commandId);
+    const method = nativeMethod(mutation.method);
+    if (mutation.requestDigest !== input.requestDigest)
+        throw makeNodeRuntimeError("storage_conflict", "The Terminal mutation request digest changed.");
+    if (mutation.dispatchState !== "attempted" ||
+        mutation.nativeOperationSequence === null)
+        throw makeNodeRuntimeError("storage_conflict", "The native Terminal acknowledgement is stale.", true);
+    requireNativeAcknowledgement(mutation, input.acknowledgement);
+    return { method, mutation };
+};
+const projectClosedTerminal = (input, previous) => liveTerminalSessionSchema.parse({
+    ...previous,
+    cleanup: {
+        semantic: "known_identity_members_complete",
+        state: "known_identity_members_complete",
+        unknownSurvivorExclusion: "unavailable",
+    },
+    eventHead: String(advanceLiveTerminalSqliteInteger(previous.eventHead, 2)),
+    exit: { observedAt: input.recordedAt, signal: "hangup" },
+    revision: String(advanceLiveTerminalSqliteInteger(previous.revision, 2)),
+    state: "exited",
+    updatedAt: input.recordedAt,
+});
+const projectNativeAcknowledgement = (input, method, previous) => {
+    if (method === "terminal.session.resize" &&
+        input.acknowledgement.fact === "tiocswinsz_succeeded")
+        return liveTerminalSessionSchema.parse({
+            ...previous,
+            revision: String(advanceLiveTerminalSqliteInteger(previous.revision)),
+            updatedAt: input.recordedAt,
+            viewport: {
+                columns: input.acknowledgement.columns,
+                rows: input.acknowledgement.rows,
+            },
+        });
+    if (method !== "terminal.session.close")
+        return previous;
+    return projectClosedTerminal(input, previous);
+};
+const pseudoNativePersistedResult = (input, context) => ({
+    actorId: LOCAL_USER_ACTOR_ID,
+    aggregateRevision: "0",
+    createdAt: input.recordedAt,
+    duplicate: false,
+    eventCursor: "0",
+    method: context.method,
+    receiptId: context.receiptId,
+    resultJson: "{}",
+    targetId: context.mutation.terminalId,
+    targetType: "terminal",
+});
+const nativeResultPayload = (input, context) => ({
+    ...(context.method === "terminal.input.write" &&
+        input.acknowledgement.fact === "pty_master_all_bytes_accepted"
+        ? {
+            acceptedBytes: input.acknowledgement.acceptedBytes,
+            inputId: input.acknowledgement.inputId,
+            inputSequence: input.acknowledgement.inputSequence,
+        }
+        : {}),
+    method: context.method,
+    outcome: "acknowledged",
+    receipt: context.receipt,
+    terminal: context.projected,
+});
+const makePreparedNativeResult = (input, context) => {
+    const receipt = makeNativeReceipt(pseudoNativePersistedResult(input, {
+        method: context.method,
+        mutation: context.mutation,
+        receiptId: context.receiptId,
+    }), {
+        acknowledgement: input.acknowledgement,
+        method: context.method,
+        mutation: context.mutation,
+        terminalRevision: context.projected.revision,
+    });
+    return nativeResultSchema(context.method).parse(nativeResultPayload(input, {
+        method: context.method,
+        projected: context.projected,
+        receipt,
+    }));
+};
+const prepareNativeAcknowledgement = (database, input) => {
+    const authority = readAcknowledgableNativeMutation(database, input);
+    const previous = readLiveTerminalSession(database, authority.mutation.terminalId);
+    const projected = projectNativeAcknowledgement(input, authority.method, previous);
+    const receiptId = newId("receipt");
+    const context = { ...authority, previous, projected, receiptId };
+    return {
+        ...context,
+        result: makePreparedNativeResult(input, context),
+    };
+};
+const persistNativeAcknowledgement = (database, input, prepared) => {
+    updateAcknowledgedMutation(database, {
+        ...(input.acknowledgement.fact === "pty_master_all_bytes_accepted"
+            ? { acknowledgedByteLength: input.acknowledgement.acceptedBytes }
+            : {}),
+        acknowledgement: input.acknowledgement,
+        acknowledgementKind: methodAcknowledgementKind(prepared.method),
+        commandId: prepared.mutation.commandId,
+        recordedAt: input.recordedAt,
+    });
+    const actual = applyNativeAcknowledgedPostcondition(database, {
+        acknowledgement: input.acknowledgement,
+        method: prepared.method,
+        projected: prepared.projected,
+        recordedAt: input.recordedAt,
+        session: prepared.previous,
+    });
+    if (JSON.stringify(actual) === JSON.stringify(prepared.projected))
+        return;
+    throw makeNodeRuntimeError("storage_corrupt", "The native Terminal postcondition is invalid.");
+};
+const commitNativeAcknowledgement = (database, input, prepared) => commitCommandWithReceiptMutation({
+    database,
+    input: commandForResult({
+        commandId: prepared.mutation.commandId,
+        expectedRevision: BigInt(prepared.mutation.mutationSequence - 1),
+        method: prepared.method,
+        requestDigest: input.requestDigest,
+        result: prepared.result,
+        terminalId: prepared.mutation.terminalId,
+    }),
+    mutateAfterReceipt: () => {
+        persistNativeAcknowledgement(database, input, prepared);
+    },
+    receiptId: prepared.receiptId,
+    recordedAt: input.recordedAt,
+});
+export const acknowledgeLiveTerminalNativeMutation = (database, input) => {
+    const mutation = readLiveTerminalMutation(database, input.commandId);
+    const method = nativeMethod(mutation.method);
+    const existing = findPersistedCommand(database, {
+        actorId: LOCAL_USER_ACTOR_ID,
+        commandId: input.commandId,
+        method,
+        requestDigest: input.requestDigest,
+    });
+    if (existing !== undefined)
+        return decodeNativeDuplicate(method, existing);
+    const prepared = prepareNativeAcknowledgement(database, input);
+    const persisted = commitNativeAcknowledgement(database, input, prepared);
+    return persisted.duplicate
+        ? decodeNativeDuplicate(method, persisted)
+        : prepared.result;
+};
+const writeUnknownFields = (mutation) => {
+    if (mutation.method !== "terminal.input.write" ||
+        mutation.inputByteLength === null ||
+        mutation.inputId === null ||
+        mutation.inputSequence === null ||
+        mutation.inputDigest === null) {
+        return {};
+    }
+    return {
+        byteLength: mutation.inputByteLength,
+        inputId: mutation.inputId,
+        inputSequence: mutation.inputSequence,
+        sha256: mutation.inputDigest,
+    };
+};
+const isNativeUnknownMutation = (mutation, method) => (mutation.dispatchState === "dispatching" ||
+    mutation.dispatchState === "attempted") &&
+    mutation.nativeOperationSequence !== null &&
+    method !== "terminal.controller.request" &&
+    method !== "terminal.controller.acquire" &&
+    method !== "terminal.controller.release";
+const readUnknownMutationAuthority = (database, input) => {
+    const mutation = readLiveTerminalMutation(database, input.commandId);
+    const method = Schema.decodeUnknownSync(activatedMutationMethodSchema)(mutation.method);
+    if (mutation.requestDigest !== input.requestDigest)
+        throw makeNodeRuntimeError("storage_conflict", "The Terminal mutation request digest changed.");
+    if (!isNativeUnknownMutation(mutation, method))
+        throw makeNodeRuntimeError("storage_conflict", "The native Terminal unknown outcome is stale.", true);
+    return {
+        current: readLiveTerminalSession(database, mutation.terminalId),
+        method,
+        mutation,
+    };
+};
+const readUnknownActiveLeases = (database, authority) => database
+    .prepare(`SELECT lease_id AS id, CAST(revision AS TEXT) AS revision
+         FROM terminal_live_controller_leases
+         WHERE terminal_id = ? AND generation = ? AND state = 'active'`)
+    .all(authority.mutation.terminalId, authority.mutation.generation).map((lease) => ({
+    id: lease.id,
+    revision: advanceLiveTerminalSqliteInteger(lease.revision),
+}));
+const readUnknownControllerRequests = (database, authority) => database
+    .prepare(`SELECT controller_request_id AS id, state
+       FROM terminal_live_controller_requests
+       WHERE terminal_id = ? AND generation = ?
+         AND state IN ('pending', 'ready')`)
+    .all(authority.mutation.terminalId, authority.mutation.generation);
+const makeNativeUnknownResult = (authority) => {
+    const { method, mutation } = authority;
+    return liveTerminalMutationOutcomeUnknownSchema.parse({
+        capability: LIVE_TERMINAL_EXECUTION_CAPABILITY,
+        commandId: mutation.commandId,
+        ...writeUnknownFields(mutation),
+        method,
+        mutationSequence: mutation.mutationSequence,
+        nativeOperationSequence: mutation.nativeOperationSequence,
+        operation: method === "terminal.create"
+            ? "create"
+            : operationForNativeMethod(nativeMethod(method)),
+        outcome: "outcome_unknown",
+        reconciliation: "terminal.mutation.reconcile-required",
+        replay: "forbidden",
+        terminalGeneration: mutation.generation,
+        terminalId: mutation.terminalId,
+    });
+};
+const isCleanCreateCompensation = (input, authority) => authority.method === "terminal.create" &&
+    authority.mutation.dispatchState === "attempted" &&
+    input.reason === "native_acknowledgement_lost" &&
+    input.settlement?.cleanup === "known_identity_members_complete" &&
+    !("failed" in input.settlement.exit);
+const updateCleanCreateSession = (database, context) => {
+    const { input, observedExit, sessionRevision, terminalId } = context;
+    database
+        .prepare(`UPDATE terminal_live_sessions SET state = 'exited',
+        cleanup_state = 'known_identity_members_complete',
+        cleanup_reason = NULL, exit_code = ?, exit_signal = ?,
+        exit_observed_at = ?, revision = ?,
+        updated_at = ? WHERE terminal_id = ? AND state = 'creating'`)
+        .run(observedExit.code ?? nullValue, observedExit.signal ?? nullValue, input.recordedAt, sessionRevision, input.recordedAt, terminalId);
+};
+const compensateCleanCreate = (database, context) => {
+    const { authority, input, sessionRevision } = context;
+    const exit = input.settlement?.exit;
+    if (exit === undefined || "failed" in exit)
+        throw makeNodeRuntimeError("storage_corrupt", "The failed Terminal create cleanup lacks an observed exit.");
+    const observedExit = liveTerminalExitProjection(exit, input.recordedAt);
+    updateCleanCreateSession(database, {
+        input,
+        observedExit,
+        sessionRevision,
+        terminalId: authority.mutation.terminalId,
+    });
+    emitCleanCreateCompensation(database, {
+        authority,
+        input,
+        observedExit,
+    });
+};
+const emitCompensatedCleanup = (database, input, authority) => {
+    const compensated = readLiveTerminalSession(database, authority.mutation.terminalId);
+    insertLiveTerminalObserverEvent(database, {
+        generation: authority.mutation.generation,
+        metadata: { cleanup: compensated.cleanup },
+        recordedAt: input.recordedAt,
+        terminalId: authority.mutation.terminalId,
+        type: "cleanup",
+    });
+};
+const emitCleanCreateCompensation = (database, context) => {
+    const { authority, input, observedExit } = context;
+    createFailureCleanupLifecycleEvent(database, authority.current, input.recordedAt);
+    insertLiveTerminalObserverEvent(database, {
+        generation: authority.mutation.generation,
+        metadata: { exit: observedExit },
+        recordedAt: input.recordedAt,
+        terminalId: authority.mutation.terminalId,
+        type: "exit",
+    });
+    emitCompensatedCleanup(database, input, authority);
+};
+const unknownCleanupReason = (reason) => {
+    switch (reason) {
+        case "native_acknowledgement_lost":
+            return "native_acknowledgement_lost";
+        case "deadline_exceeded":
+            return "cleanup_deadline";
+        case "interrupted":
+            return "containment_lost";
+        case "host_failed":
+        case "transport_failed":
+            return "host_failed";
+    }
+};
+const disconnectUnknownTerminal = (database, context) => {
+    const { authority, input, sessionRevision } = context;
+    database
+        .prepare(`UPDATE terminal_live_sessions SET state = 'disconnected',
+        cleanup_state = 'unknown', cleanup_reason = ?, revision = ?,
+        updated_at = ? WHERE terminal_id = ?`)
+        .run(unknownCleanupReason(input.reason), sessionRevision, input.recordedAt, authority.mutation.terminalId);
+    lifecycleEvent(database, authority.current, input.recordedAt);
+};
+const reserveUnknownMutationEvents = (database, context, leaseCount) => {
+    const { authority, input } = context;
+    const requiredSlots = isCleanCreateCompensation(input, authority)
+        ? 3
+        : leaseCount + 1;
+    const gapRequired = liveTerminalRetentionInternals.reserveEventSlots(database, {
+        gapAlreadyRequired: false,
+        maximumEvents: liveTerminalRetentionInternals.productionPolicy.maximumEvents,
+        requiredSlots,
+        terminalId: authority.mutation.terminalId,
+    });
+    if (gapRequired)
+        liveTerminalRetentionInternals.insertGap(database, authority.mutation.terminalId, input.recordedAt);
+};
+const updateUnknownMutationLease = (database, context, lease) => {
+    const { authority, input } = context;
+    const state = transitionControllerLease("active", { type: "revoke" });
+    database
+        .prepare(`UPDATE terminal_live_controller_leases SET state = ?,
+      revision = ?, updated_at = ?
+     WHERE lease_id = ? AND terminal_id = ? AND generation = ?
+       AND state = 'active'`)
+        .run(state, lease.revision, input.recordedAt, lease.id, authority.mutation.terminalId, authority.mutation.generation);
+};
+const emitUnknownMutationLeaseRevoked = (database, context, leaseId) => {
+    const { authority, input } = context;
+    insertLiveTerminalObserverEvent(database, {
+        generation: authority.mutation.generation,
+        metadata: {
+            capability: LIVE_TERMINAL_EXECUTION_CAPABILITY,
+            leaseId,
+            reason: "policy",
+        },
+        recordedAt: input.recordedAt,
+        terminalId: authority.mutation.terminalId,
+        type: "controller-revoked",
+    });
+};
+const denyUnknownControllerRequest = (database, input, request) => {
+    const state = transitionControllerRequest(request.state, { type: "deny" });
+    database
+        .prepare(`UPDATE terminal_live_controller_requests
+       SET state = ?, position = NULL, denial_reason = 'policy', updated_at = ?
+       WHERE controller_request_id = ? AND state = ?`)
+        .run(state, input.recordedAt, request.id, request.state);
+};
+const revokeUnknownControllerAuthority = (database, input, authority) => {
+    const leases = readUnknownActiveLeases(database, authority);
+    const requests = readUnknownControllerRequests(database, authority);
+    const context = { authority, input };
+    reserveUnknownMutationEvents(database, context, leases.length);
+    leases.forEach((lease) => {
+        updateUnknownMutationLease(database, context, lease);
+        emitUnknownMutationLeaseRevoked(database, context, lease.id);
+    });
+    requests.forEach((request) => {
+        denyUnknownControllerRequest(database, input, request);
+    });
+};
+const persistUnknownMutation = (database, input, authority) => {
+    revokeUnknownControllerAuthority(database, input, authority);
+    database
+        .prepare(`UPDATE terminal_live_mutations SET dispatch_state = 'outcome_unknown',
+        unknown_reason = ?, updated_at = ? WHERE command_id = ?`)
+        .run(input.reason, input.recordedAt, authority.mutation.commandId);
+    const sessionRevision = advanceLiveTerminalSqliteInteger(authority.current.revision);
+    if (isCleanCreateCompensation(input, authority))
+        compensateCleanCreate(database, { authority, input, sessionRevision });
+    else
+        disconnectUnknownTerminal(database, { authority, input, sessionRevision });
+};
+const commitNativeUnknown = (database, context) => {
+    const { authority, input, result } = context;
+    return commitCommandWithReceiptMutation({
+        database,
+        input: commandForResult({
+            commandId: authority.mutation.commandId,
+            expectedRevision: BigInt(authority.mutation.mutationSequence - 1),
+            method: authority.method,
+            requestDigest: input.requestDigest,
+            result,
+            terminalId: authority.mutation.terminalId,
+        }),
+        mutateAfterReceipt: () => {
+            persistUnknownMutation(database, input, authority);
+        },
+        receiptId: newId("receipt"),
+        recordedAt: input.recordedAt,
+    });
+};
+const findNativeUnknownDuplicate = (database, input) => {
+    const mutation = readLiveTerminalMutation(database, input.commandId);
+    const method = Schema.decodeUnknownSync(activatedMutationMethodSchema)(mutation.method);
+    if (mutation.requestDigest !== input.requestDigest)
+        throw makeNodeRuntimeError("storage_conflict", "The Terminal mutation request digest changed.");
+    return findPersistedCommand(database, {
+        actorId: LOCAL_USER_ACTOR_ID,
+        commandId: input.commandId,
+        method,
+        requestDigest: input.requestDigest,
+    });
+};
+export const recordLiveTerminalNativeOutcomeUnknown = (database, input) => {
+    const existing = findNativeUnknownDuplicate(database, input);
+    if (existing !== undefined)
+        return liveTerminalMutationOutcomeUnknownSchema.parse(JSON.parse(existing.resultJson));
+    const authority = readUnknownMutationAuthority(database, input);
+    const result = makeNativeUnknownResult(authority);
+    const persisted = commitNativeUnknown(database, {
+        authority,
+        input,
+        result,
+    });
+    return persisted.duplicate
+        ? liveTerminalMutationOutcomeUnknownSchema.parse(JSON.parse(persisted.resultJson))
+        : result;
+};
+//# sourceMappingURL=live-native-commands.js.map