@maiaos/protocol 0.1.0-canary.1

package/dist/terminal/live-effect-schema.js

@@ -0,0 +1,985 @@
+import * as Schema from "effect/Schema";
+import { aggregateRevisionEffectSchema, protocolIdentifierEffectSchema, recordedAtEffectSchema, } from "../envelope/effect-schema.js";
+import { LIVE_TERMINAL_CREATE_FAILURE_CLEANUP_POLICY, LIVE_TERMINAL_RESTART_POLICY, LIVE_TERMINAL_STATE_CHANGED_EDGES, MAX_TERMINAL_COLUMNS, MAX_TERMINAL_CONTROLLER_LEASE_MS, MAX_TERMINAL_CONTROLLER_REQUESTS_PER_TERMINAL, MAX_TERMINAL_GENERATION, MAX_TERMINAL_INPUT_CHUNK_BYTES, MAX_TERMINAL_INPUT_SEQUENCE, MAX_TERMINAL_MUTATION_SEQUENCE, MAX_TERMINAL_NATIVE_OPERATION_SEQUENCE, MAX_TERMINAL_OBSERVER_CHECK_EVENTS, MAX_TERMINAL_OBSERVER_CHECK_RESPONSE_BYTES, MAX_TERMINAL_OBSERVER_LEASE_MS, MAX_TERMINAL_OBSERVER_WAIT_MS, MAX_TERMINAL_OUTPUT_CHUNK_BYTES, MAX_TERMINAL_ROWS, MAX_TERMINAL_SCROLLBACK_BYTES, MAX_TERMINAL_SCROLLBACK_LINES, MAX_TERMINAL_SNAPSHOT_CHUNKS, MAX_TERMINAL_SNAPSHOT_RESPONSE_BYTES, MIN_TERMINAL_COLUMNS, MIN_TERMINAL_CONTROLLER_LEASE_MS, MIN_TERMINAL_OBSERVER_LEASE_MS, MIN_TERMINAL_ROWS, TERMINAL_REVOCATION_POLICY_REVISION, } from "./live-policy.js";
+import { LIVE_TERMINAL_EVENT_SCHEMA_VERSION, LIVE_TERMINAL_MUTATION_SCHEMA_VERSION, LIVE_TERMINAL_SCHEMA_VERSION, } from "./live-version.js";
+const boundedInt = (minimum, maximum) => Schema.Int.check(Schema.isGreaterThanOrEqualTo(minimum), Schema.isLessThanOrEqualTo(maximum));
+const viewportFields = {
+    columns: boundedInt(MIN_TERMINAL_COLUMNS, MAX_TERMINAL_COLUMNS),
+    rows: boundedInt(MIN_TERMINAL_ROWS, MAX_TERMINAL_ROWS),
+};
+const nativeSequenceFields = {
+    nativeOperationSequence: boundedInt(1, MAX_TERMINAL_NATIVE_OPERATION_SEQUENCE),
+};
+export const liveTerminalViewportEffectSchema = Schema.Struct(viewportFields);
+export const liveTerminalExecutionCapabilityEffectSchema = Schema.Struct({
+    assumption: Schema.Literal("cooperative_unsandboxed_local_user_code_may_include_automation"),
+    hardContainment: Schema.Literal(false),
+    limits: Schema.Struct({
+        cpuTime: Schema.Literal("unavailable"),
+        memory: Schema.Literal("unavailable"),
+        processCount: Schema.Literal("unavailable"),
+        survivorCleanup: Schema.Literal("unavailable"),
+        wallTime: Schema.Literal("cooperative"),
+    }),
+    measurementSources: Schema.Struct({
+        host: Schema.Literal("process_host"),
+        knownMembers: Schema.Literal("darwin_descendant_snapshot"),
+    }),
+    releaseQualified: Schema.Literal(false),
+    revocationPolicyRevision: Schema.Literal(TERMINAL_REVOCATION_POLICY_REVISION),
+    sourceCandidate: Schema.Literal(true),
+    tier: Schema.Literal("local_user_interactive_terminal"),
+});
+const pendingCleanupEffectSchema = Schema.Struct({
+    semantic: Schema.Literal("known_identity_members"),
+    state: Schema.Literal("pending"),
+});
+const completeCleanupEffectSchema = Schema.Struct({
+    semantic: Schema.Literal("known_identity_members_complete"),
+    state: Schema.Literal("known_identity_members_complete"),
+    unknownSurvivorExclusion: Schema.Literal("unavailable"),
+});
+const unknownCleanupEffectSchema = Schema.Struct({
+    reason: Schema.Literals([
+        "cleanup_deadline",
+        "containment_lost",
+        "host_failed",
+        "identity_observation_lost",
+        "native_acknowledgement_lost",
+        "node_restarted",
+    ]),
+    semantic: Schema.Literal("known_identity_members"),
+    state: Schema.Literal("unknown"),
+});
+export const liveTerminalCleanupEffectSchema = Schema.Union([
+    pendingCleanupEffectSchema,
+    completeCleanupEffectSchema,
+    unknownCleanupEffectSchema,
+]);
+const terminalExitEffectSchema = Schema.Struct({
+    code: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(255))),
+    observedAt: recordedAtEffectSchema,
+    signal: Schema.optional(Schema.Literals(["hangup", "interrupt", "kill", "terminate", "unknown"])),
+});
+const sessionBaseFields = {
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    chunkHead: aggregateRevisionEffectSchema,
+    createdAt: recordedAtEffectSchema,
+    eventHead: aggregateRevisionEffectSchema,
+    generation: boundedInt(1, MAX_TERMINAL_GENERATION),
+    id: protocolIdentifierEffectSchema,
+    mutationHead: aggregateRevisionEffectSchema,
+    projectId: protocolIdentifierEffectSchema,
+    revision: aggregateRevisionEffectSchema,
+    schemaVersion: Schema.Literal(LIVE_TERMINAL_SCHEMA_VERSION),
+    updatedAt: recordedAtEffectSchema,
+    viewport: liveTerminalViewportEffectSchema,
+    workspaceId: protocolIdentifierEffectSchema,
+    workspaceRevision: aggregateRevisionEffectSchema,
+};
+const activeSessionEffectSchema = (state) => Schema.Struct({
+    ...sessionBaseFields,
+    cleanup: pendingCleanupEffectSchema,
+    state: Schema.Literal(state),
+});
+const closingSessionEffectSchema = Schema.Struct({
+    ...sessionBaseFields,
+    cleanup: pendingCleanupEffectSchema,
+    state: Schema.Literal("closing"),
+});
+const restartingSessionEffectSchema = Schema.Struct({
+    ...sessionBaseFields,
+    cleanup: Schema.Union([
+        pendingCleanupEffectSchema,
+        completeCleanupEffectSchema,
+    ]),
+    state: Schema.Literal("restarting"),
+});
+const exitedSessionEffectSchema = Schema.Struct({
+    ...sessionBaseFields,
+    cleanup: liveTerminalCleanupEffectSchema,
+    exit: terminalExitEffectSchema,
+    state: Schema.Literal("exited"),
+});
+const disconnectedSessionEffectSchema = Schema.Struct({
+    ...sessionBaseFields,
+    cleanup: unknownCleanupEffectSchema,
+    exit: Schema.optional(terminalExitEffectSchema),
+    state: Schema.Literal("disconnected"),
+});
+export const liveTerminalSessionEffectSchema = Schema.Union([
+    activeSessionEffectSchema("creating"),
+    activeSessionEffectSchema("running"),
+    closingSessionEffectSchema,
+    restartingSessionEffectSchema,
+    exitedSessionEffectSchema,
+    disconnectedSessionEffectSchema,
+]);
+const decodedBase64Bytes = (value) => {
+    let padding = 0;
+    if (value.endsWith("=="))
+        padding = 2;
+    else if (value.endsWith("="))
+        padding = 1;
+    return (value.length / 4) * 3 - padding;
+};
+const encodedJsonBytes = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+const base64Bytes = (maximumBytes, expected) => Schema.String.check(Schema.makeFilter((value) => {
+    if (value.length === 0 ||
+        !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value)) {
+        return false;
+    }
+    return decodedBase64Bytes(value) <= maximumBytes;
+}, { expected }));
+const outputBytesEffectSchema = base64Bytes(MAX_TERMINAL_OUTPUT_CHUNK_BYTES, "base64 terminal output encoded from at most 32768 bytes");
+const inputBytesEffectSchema = base64Bytes(MAX_TERMINAL_INPUT_CHUNK_BYTES, "base64 terminal input encoded from at most 32768 bytes");
+export const liveTerminalOutputChunkEffectSchema = Schema.Struct({
+    bytesBase64: outputBytesEffectSchema,
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    cursor: aggregateRevisionEffectSchema,
+    generation: boundedInt(1, MAX_TERMINAL_GENERATION),
+    recordedAt: recordedAtEffectSchema,
+    schemaVersion: Schema.Literal(LIVE_TERMINAL_EVENT_SCHEMA_VERSION),
+    terminalId: protocolIdentifierEffectSchema,
+});
+const observerEventFields = {
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    cursor: aggregateRevisionEffectSchema,
+    recordedAt: recordedAtEffectSchema,
+    schemaVersion: Schema.Literal(LIVE_TERMINAL_EVENT_SCHEMA_VERSION),
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminalId: protocolIdentifierEffectSchema,
+};
+const terminalStateChangedEdges = new Set([
+    ...LIVE_TERMINAL_STATE_CHANGED_EDGES.map(([from, to]) => `${from}:${to}`),
+    ...LIVE_TERMINAL_RESTART_POLICY.stateChanged.map(({ from, to }) => `${from}:${to}`),
+]);
+const restartStateChangedIsAdmitted = (value) => LIVE_TERMINAL_RESTART_POLICY.stateChanged.some((policy) => value.previousState === policy.from &&
+    value.terminal.state === policy.to &&
+    value.previousCleanup.state === policy.previousCleanup &&
+    value.terminal.cleanup.state === policy.resultingCleanup);
+const generationTransitionMatches = (value, policy) => value.previousState === policy.from &&
+    value.terminal.state === policy.to &&
+    value.previousCleanup.state === policy.previousCleanup &&
+    value.terminal.cleanup.state === policy.resultingCleanup &&
+    value.previousGeneration < MAX_TERMINAL_GENERATION &&
+    value.terminalGeneration === value.previousGeneration + 1;
+const lifecycleIdentityMatches = (value) => value.terminal.id === value.terminalId &&
+    value.terminal.generation === value.terminalGeneration &&
+    value.terminal.capability.revocationPolicyRevision ===
+        value.capability.revocationPolicyRevision &&
+    value.terminal.eventHead === value.cursor &&
+    BigInt(value.terminal.revision) === BigInt(value.previousRevision) + 1n;
+const createFailureCleanupMatches = (value) => value.transition === "create-failure-cleanup" &&
+    value.previousState === LIVE_TERMINAL_CREATE_FAILURE_CLEANUP_POLICY.from &&
+    value.terminal.state === LIVE_TERMINAL_CREATE_FAILURE_CLEANUP_POLICY.to &&
+    value.terminalGeneration === value.previousGeneration &&
+    value.previousCleanup.state ===
+        LIVE_TERMINAL_CREATE_FAILURE_CLEANUP_POLICY.previousCleanup &&
+    value.terminal.cleanup.state ===
+        LIVE_TERMINAL_CREATE_FAILURE_CLEANUP_POLICY.resultingCleanup;
+const stateChangeMatches = (value) => value.transition === "state-changed" &&
+    value.terminalGeneration === value.previousGeneration &&
+    terminalStateChangedEdges.has(`${value.previousState}:${value.terminal.state}`) &&
+    (value.terminal.state !== "restarting" ||
+        restartStateChangedIsAdmitted(value));
+const lifecycleTransitionIsAdmitted = (value) => {
+    if (!lifecycleIdentityMatches(value))
+        return false;
+    if (value.transition === "generation-started") {
+        return generationTransitionMatches(value, LIVE_TERMINAL_RESTART_POLICY.generationStarted);
+    }
+    if (value.transition === "generation-outcome-unknown") {
+        return (generationTransitionMatches(value, LIVE_TERMINAL_RESTART_POLICY.generationOutcomeUnknown) && value.terminal.cleanup.reason === "native_acknowledgement_lost");
+    }
+    return createFailureCleanupMatches(value) || stateChangeMatches(value);
+};
+const liveTerminalLifecycleTransitionEventEffectSchema = Schema.Struct({
+    ...observerEventFields,
+    previousCleanup: liveTerminalCleanupEffectSchema,
+    previousGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    previousRevision: aggregateRevisionEffectSchema,
+    previousState: Schema.Literals([
+        "closing",
+        "creating",
+        "disconnected",
+        "exited",
+        "restarting",
+        "running",
+    ]),
+    terminal: liveTerminalSessionEffectSchema,
+    transition: Schema.Literals([
+        "create-failure-cleanup",
+        "generation-outcome-unknown",
+        "generation-started",
+        "state-changed",
+    ]),
+    type: Schema.Literal("lifecycle-transition"),
+}).check(Schema.makeFilter(lifecycleTransitionIsAdmitted, {
+    expected: "a lifecycle transition matching its terminal, generation, and prior cleanup",
+}));
+export const liveTerminalObserverEventEffectSchema = Schema.Union([
+    Schema.Struct({
+        ...observerEventFields,
+        bytesBase64: outputBytesEffectSchema,
+        type: Schema.Literal("output"),
+    }),
+    Schema.Struct({
+        ...observerEventFields,
+        exit: terminalExitEffectSchema,
+        type: Schema.Literal("exit"),
+    }),
+    Schema.Struct({
+        ...observerEventFields,
+        cleanup: liveTerminalCleanupEffectSchema,
+        type: Schema.Literal("cleanup"),
+    }),
+    Schema.Struct({
+        ...observerEventFields,
+        leaseId: protocolIdentifierEffectSchema,
+        reason: Schema.Literals(["expired", "policy", "released", "superseded"]),
+        type: Schema.Literal("controller-revoked"),
+    }),
+    Schema.Struct({
+        ...observerEventFields,
+        headCursor: aggregateRevisionEffectSchema,
+        oldestAvailableCursor: aggregateRevisionEffectSchema,
+        reason: Schema.Literals(["backpressure", "cursor_expired"]),
+        recovery: Schema.Literal("resync-required"),
+        requestedAfterCursor: Schema.optional(aggregateRevisionEffectSchema),
+        type: Schema.Literal("gap"),
+    }),
+    liveTerminalLifecycleTransitionEventEffectSchema,
+]);
+export const liveTerminalObserverSnapshotEffectSchema = Schema.Struct({
+    headCursor: aggregateRevisionEffectSchema,
+    oldestAvailableCursor: aggregateRevisionEffectSchema,
+    retainedBytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(MAX_TERMINAL_SCROLLBACK_BYTES)),
+    retainedLines: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(MAX_TERMINAL_SCROLLBACK_LINES)),
+    tail: Schema.Array(liveTerminalOutputChunkEffectSchema).check(Schema.isMaxLength(MAX_TERMINAL_SNAPSHOT_CHUNKS)),
+    terminal: liveTerminalSessionEffectSchema,
+}).check(Schema.makeFilter((value) => value.tail.every((chunk) => chunk.terminalId === value.terminal.id) &&
+    value.tail.reduce((total, chunk) => total + decodedBase64Bytes(chunk.bytesBase64), 0) <= MAX_TERMINAL_SNAPSHOT_RESPONSE_BYTES &&
+    encodedJsonBytes(value) <= MAX_TERMINAL_SNAPSHOT_RESPONSE_BYTES, { expected: "a terminal observer snapshot within its response byte cap" }));
+const controllerRequestFields = {
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    expiresAt: recordedAtEffectSchema,
+    id: protocolIdentifierEffectSchema,
+    requestedAt: recordedAtEffectSchema,
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminalId: protocolIdentifierEffectSchema,
+};
+export const liveTerminalControllerRequestEffectSchema = Schema.Union([
+    Schema.Struct({
+        ...controllerRequestFields,
+        position: boundedInt(1, MAX_TERMINAL_CONTROLLER_REQUESTS_PER_TERMINAL),
+        state: Schema.Literal("pending"),
+    }),
+    Schema.Struct({
+        ...controllerRequestFields,
+        state: Schema.Literal("ready"),
+    }),
+    Schema.Struct({
+        ...controllerRequestFields,
+        reason: Schema.Literals(["expired", "policy", "queue_saturated"]),
+        state: Schema.Literal("denied"),
+    }),
+]);
+const controllerLeaseFields = {
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    epoch: aggregateRevisionEffectSchema,
+    expiresAt: recordedAtEffectSchema,
+    id: protocolIdentifierEffectSchema,
+    revision: aggregateRevisionEffectSchema,
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminalId: protocolIdentifierEffectSchema,
+};
+export const liveTerminalControllerLeaseEffectSchema = Schema.Union([
+    Schema.Struct({
+        ...controllerLeaseFields,
+        state: Schema.Literal("active"),
+    }),
+    Schema.Struct({
+        ...controllerLeaseFields,
+        state: Schema.Literals(["expired", "released", "revoked"]),
+    }),
+]);
+const commandFields = {
+    commandId: protocolIdentifierEffectSchema,
+};
+const terminalFields = {
+    terminalId: protocolIdentifierEffectSchema,
+};
+const expectedRevisionFields = {
+    expectedTerminalRevision: aggregateRevisionEffectSchema,
+};
+const controllerFenceFields = {
+    controller: Schema.Struct({
+        epoch: aggregateRevisionEffectSchema,
+        expiresAt: recordedAtEffectSchema,
+        id: protocolIdentifierEffectSchema,
+        revision: aggregateRevisionEffectSchema,
+        terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+        terminalId: protocolIdentifierEffectSchema,
+    }),
+};
+export const liveTerminalCreateParametersEffectSchema = Schema.Struct({
+    ...commandFields,
+    ...viewportFields,
+    expectedRevision: Schema.Literal("0"),
+    mode: Schema.Literal("interactive"),
+    workspaceId: protocolIdentifierEffectSchema,
+});
+export const liveTerminalObserverAttachParametersEffectSchema = Schema.Struct({
+    afterCursor: Schema.optional(aggregateRevisionEffectSchema),
+    attachId: protocolIdentifierEffectSchema,
+    commandId: protocolIdentifierEffectSchema,
+    requestedLeaseDurationMs: boundedInt(MIN_TERMINAL_OBSERVER_LEASE_MS, MAX_TERMINAL_OBSERVER_LEASE_MS),
+    terminalId: protocolIdentifierEffectSchema,
+});
+export const liveTerminalObserverCheckParametersEffectSchema = Schema.Struct({
+    afterCursor: aggregateRevisionEffectSchema,
+    limit: boundedInt(1, MAX_TERMINAL_OBSERVER_CHECK_EVENTS),
+    observerId: protocolIdentifierEffectSchema,
+    terminalId: protocolIdentifierEffectSchema,
+    waitMilliseconds: boundedInt(0, MAX_TERMINAL_OBSERVER_WAIT_MS),
+});
+export const liveTerminalObserverDetachParametersEffectSchema = Schema.Struct({
+    observerId: protocolIdentifierEffectSchema,
+    terminalId: protocolIdentifierEffectSchema,
+});
+export const liveTerminalObserverResyncParametersEffectSchema = Schema.Struct({
+    terminalId: protocolIdentifierEffectSchema,
+});
+export const liveTerminalControllerRequestShowParametersEffectSchema = Schema.Struct({
+    controllerRequestId: protocolIdentifierEffectSchema,
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminalId: protocolIdentifierEffectSchema,
+});
+export const liveTerminalControllerRequestParametersEffectSchema = Schema.Struct({
+    ...commandFields,
+    ...terminalFields,
+    requestedLeaseDurationMs: boundedInt(MIN_TERMINAL_CONTROLLER_LEASE_MS, MAX_TERMINAL_CONTROLLER_LEASE_MS),
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+});
+export const liveTerminalControllerAcquireParametersEffectSchema = Schema.Struct({
+    ...commandFields,
+    ...expectedRevisionFields,
+    ...terminalFields,
+    controllerRequestId: protocolIdentifierEffectSchema,
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+});
+const fencedMutationFields = {
+    ...commandFields,
+    ...controllerFenceFields,
+    ...expectedRevisionFields,
+    ...terminalFields,
+};
+export const liveTerminalControllerRenewParametersEffectSchema = Schema.Struct({
+    ...fencedMutationFields,
+    requestedLeaseDurationMs: boundedInt(MIN_TERMINAL_CONTROLLER_LEASE_MS, MAX_TERMINAL_CONTROLLER_LEASE_MS),
+});
+export const liveTerminalControllerReleaseParametersEffectSchema = Schema.Struct(fencedMutationFields);
+export const liveTerminalWriteParametersEffectSchema = Schema.Struct({
+    ...fencedMutationFields,
+    bytesBase64: inputBytesEffectSchema,
+    inputId: protocolIdentifierEffectSchema,
+    inputSequence: boundedInt(1, MAX_TERMINAL_INPUT_SEQUENCE),
+});
+export const liveTerminalResizeParametersEffectSchema = Schema.Struct({
+    ...fencedMutationFields,
+    ...viewportFields,
+});
+export const liveTerminalSignalParametersEffectSchema = Schema.Struct({
+    ...fencedMutationFields,
+    signal: Schema.Literals(["hangup", "interrupt", "terminate"]),
+});
+export const liveTerminalCloseParametersEffectSchema = Schema.Struct(fencedMutationFields);
+export const liveTerminalRestartParametersEffectSchema = Schema.Struct(fencedMutationFields);
+export const liveTerminalDeleteParametersEffectSchema = Schema.Struct({
+    ...commandFields,
+    ...expectedRevisionFields,
+    ...terminalFields,
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+});
+export const liveTerminalReconcileParametersEffectSchema = Schema.Union([
+    Schema.Struct({
+        ...commandFields,
+        mutationSequence: boundedInt(1, MAX_TERMINAL_MUTATION_SEQUENCE),
+        operation: Schema.Literals([
+            "close",
+            "controller.acquire",
+            "controller.release",
+            "controller.renew",
+            "controller.request",
+            "create",
+            "delete",
+            "resize",
+            "signal",
+            "write",
+        ]),
+        terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+        ...terminalFields,
+    }),
+    Schema.Struct({
+        ...commandFields,
+        mutationSequence: boundedInt(1, MAX_TERMINAL_MUTATION_SEQUENCE),
+        operation: Schema.Literal("restart"),
+        plannedTargetTerminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+        sourceTerminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+        ...terminalFields,
+    }).check(Schema.makeFilter((value) => value.sourceTerminalGeneration < MAX_TERMINAL_GENERATION &&
+        value.plannedTargetTerminalGeneration ===
+            value.sourceTerminalGeneration + 1, { expected: "a restart reconciliation for the planned next generation" })),
+]);
+const sha256EffectSchema = Schema.String.check(Schema.isBetweenLength(64, 64), Schema.isPattern(/^[a-f0-9]{64}$/u));
+const mutationReceiptFields = {
+    actorId: Schema.Literal("actor_local_user"),
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    commandId: protocolIdentifierEffectSchema,
+    delivery: Schema.Literals(["duplicate", "new"]),
+    mutationSequence: boundedInt(1, MAX_TERMINAL_MUTATION_SEQUENCE),
+    receiptId: protocolIdentifierEffectSchema,
+    recordedAt: recordedAtEffectSchema,
+    schemaVersion: Schema.Literal(LIVE_TERMINAL_MUTATION_SCHEMA_VERSION),
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminalId: protocolIdentifierEffectSchema,
+    terminalRevision: aggregateRevisionEffectSchema,
+};
+const nonNativeReceipt = (method, operation) => Schema.Struct({
+    ...mutationReceiptFields,
+    method: Schema.Literal(method),
+    nativeAcknowledgement: Schema.Struct({
+        fact: Schema.Literal("not_applicable"),
+    }),
+    operation: Schema.Literal(operation),
+});
+const restartMutationReceiptEffectSchema = Schema.Struct({
+    ...mutationReceiptFields,
+    method: Schema.Literal("terminal.session.restart"),
+    nativeAcknowledgement: Schema.Struct({
+        fact: Schema.Literal("generation_started"),
+        previousCleanup: Schema.Literal("known_identity_members_complete"),
+    }),
+    operation: Schema.Literal("restart"),
+    sourceTerminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+}).check(Schema.makeFilter((value) => value.sourceTerminalGeneration < MAX_TERMINAL_GENERATION &&
+    value.terminalGeneration === value.sourceTerminalGeneration + 1, { expected: "a restart receipt for the exact next generation" }));
+export const liveTerminalMutationReceiptEffectSchema = Schema.Union([
+    Schema.Struct({
+        ...mutationReceiptFields,
+        ...nativeSequenceFields,
+        method: Schema.Literal("terminal.create"),
+        nativeAcknowledgement: Schema.Struct({
+            fact: Schema.Literal("generation_started"),
+        }),
+        operation: Schema.Literal("create"),
+    }),
+    nonNativeReceipt("terminal.controller.request", "controller.request"),
+    nonNativeReceipt("terminal.controller.acquire", "controller.acquire"),
+    nonNativeReceipt("terminal.controller.renew", "controller.renew"),
+    nonNativeReceipt("terminal.controller.release", "controller.release"),
+    Schema.Struct({
+        ...mutationReceiptFields,
+        ...nativeSequenceFields,
+        method: Schema.Literal("terminal.input.write"),
+        nativeAcknowledgement: Schema.Struct({
+            acceptedBytes: boundedInt(1, MAX_TERMINAL_INPUT_CHUNK_BYTES),
+            byteLength: boundedInt(1, MAX_TERMINAL_INPUT_CHUNK_BYTES),
+            fact: Schema.Literal("pty_master_all_bytes_accepted"),
+            inputId: protocolIdentifierEffectSchema,
+            inputSequence: boundedInt(1, MAX_TERMINAL_INPUT_SEQUENCE),
+            sha256: sha256EffectSchema,
+        }),
+        operation: Schema.Literal("write"),
+    }),
+    Schema.Struct({
+        ...mutationReceiptFields,
+        ...nativeSequenceFields,
+        method: Schema.Literal("terminal.session.resize"),
+        nativeAcknowledgement: Schema.Struct({
+            ...viewportFields,
+            fact: Schema.Literal("tiocswinsz_succeeded"),
+        }),
+        operation: Schema.Literal("resize"),
+    }),
+    Schema.Struct({
+        ...mutationReceiptFields,
+        ...nativeSequenceFields,
+        method: Schema.Literal("terminal.session.signal"),
+        nativeAcknowledgement: Schema.Struct({
+            fact: Schema.Literal("tiocsig_succeeded"),
+            signal: Schema.Literals(["hangup", "interrupt", "terminate"]),
+        }),
+        operation: Schema.Literal("signal"),
+    }),
+    Schema.Struct({
+        ...mutationReceiptFields,
+        ...nativeSequenceFields,
+        method: Schema.Literal("terminal.session.close"),
+        nativeAcknowledgement: Schema.Struct({
+            fact: Schema.Literal("known_identity_members_complete"),
+            unknownSurvivorExclusion: Schema.Literal("unavailable"),
+        }),
+        operation: Schema.Literal("close"),
+    }),
+    restartMutationReceiptEffectSchema,
+    nonNativeReceipt("terminal.session.delete", "delete"),
+]);
+const outcomeUnknownFields = {
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    commandId: protocolIdentifierEffectSchema,
+    mutationSequence: boundedInt(1, MAX_TERMINAL_MUTATION_SEQUENCE),
+    outcome: Schema.Literal("outcome_unknown"),
+    reconciliation: Schema.Literal("terminal.mutation.reconcile-required"),
+    replay: Schema.Literal("forbidden"),
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminalId: protocolIdentifierEffectSchema,
+};
+const unknownMutation = (method, operation) => Schema.Struct({
+    ...outcomeUnknownFields,
+    method: Schema.Literal(method),
+    operation: Schema.Literal(operation),
+});
+const nativeUnknownMutation = (method, operation) => Schema.Struct({
+    ...outcomeUnknownFields,
+    ...nativeSequenceFields,
+    method: Schema.Literal(method),
+    operation: Schema.Literal(operation),
+});
+const unknownWriteEffectSchema = Schema.Struct({
+    ...outcomeUnknownFields,
+    ...nativeSequenceFields,
+    byteLength: boundedInt(1, MAX_TERMINAL_INPUT_CHUNK_BYTES),
+    inputId: protocolIdentifierEffectSchema,
+    inputSequence: boundedInt(1, MAX_TERMINAL_INPUT_SEQUENCE),
+    method: Schema.Literal("terminal.input.write"),
+    operation: Schema.Literal("write"),
+    sha256: sha256EffectSchema,
+});
+const restartUnknownBaseFields = {
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    commandId: protocolIdentifierEffectSchema,
+    method: Schema.Literal("terminal.session.restart"),
+    mutationSequence: boundedInt(1, MAX_TERMINAL_MUTATION_SEQUENCE),
+    operation: Schema.Literal("restart"),
+    outcome: Schema.Literal("outcome_unknown"),
+    plannedTargetTerminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    reconciliation: Schema.Literal("terminal.mutation.reconcile-required"),
+    replay: Schema.Literal("forbidden"),
+    sourceTerminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminal: liveTerminalSessionEffectSchema,
+    terminalId: protocolIdentifierEffectSchema,
+};
+const liveTerminalRestartOutcomeUnknownEffectSchema = Schema.Union([
+    Schema.Struct({
+        ...restartUnknownBaseFields,
+        effectPhase: Schema.Literal("source-cleanup"),
+        targetAttempt: Schema.Literal("not-attempted"),
+    }),
+    Schema.Struct({
+        ...restartUnknownBaseFields,
+        effectPhase: Schema.Literal("target-start"),
+        targetAttempt: Schema.Literals(["attempted", "may-have-been-attempted"]),
+    }),
+]).check(Schema.makeFilter((value) => value.sourceTerminalGeneration < MAX_TERMINAL_GENERATION &&
+    value.plannedTargetTerminalGeneration ===
+        value.sourceTerminalGeneration + 1 &&
+    value.terminal.id === value.terminalId &&
+    value.terminal.state === "disconnected" &&
+    value.terminal.cleanup.state === "unknown" &&
+    (value.effectPhase === "source-cleanup"
+        ? value.terminal.generation === value.sourceTerminalGeneration
+        : value.terminal.generation === value.plannedTargetTerminalGeneration &&
+            value.terminal.cleanup.reason === "native_acknowledgement_lost"), { expected: "a phase-exact unknown restart generation projection" }));
+export const liveTerminalMutationOutcomeUnknownEffectSchema = Schema.Union([
+    nativeUnknownMutation("terminal.create", "create"),
+    unknownMutation("terminal.controller.request", "controller.request"),
+    unknownMutation("terminal.controller.acquire", "controller.acquire"),
+    unknownMutation("terminal.controller.renew", "controller.renew"),
+    unknownMutation("terminal.controller.release", "controller.release"),
+    unknownWriteEffectSchema,
+    nativeUnknownMutation("terminal.session.resize", "resize"),
+    nativeUnknownMutation("terminal.session.signal", "signal"),
+    nativeUnknownMutation("terminal.session.close", "close"),
+    liveTerminalRestartOutcomeUnknownEffectSchema,
+    unknownMutation("terminal.session.delete", "delete"),
+]);
+const acknowledged = (fields) => Schema.Struct({
+    ...fields,
+    outcome: Schema.Literal("acknowledged"),
+    receipt: liveTerminalMutationReceiptEffectSchema,
+});
+const liveTerminalCreateAcknowledgedResultEffectSchema = acknowledged({
+    accepted: Schema.Literal(true),
+    delivery: Schema.Literals(["duplicate", "new"]),
+    method: Schema.Literal("terminal.create"),
+    terminal: liveTerminalSessionEffectSchema,
+}).check(Schema.makeFilter((value) => value.delivery === value.receipt.delivery &&
+    value.receipt.method === value.method &&
+    value.receipt.operation === "create" &&
+    value.receipt.terminalGeneration === value.terminal.generation &&
+    value.receipt.terminalId === value.terminal.id &&
+    value.receipt.terminalRevision === value.terminal.revision, { expected: "an acknowledged terminal creation matching its receipt" }));
+export const liveTerminalCreateResultEffectSchema = Schema.Union([
+    liveTerminalCreateAcknowledgedResultEffectSchema,
+    nativeUnknownMutation("terminal.create", "create"),
+]);
+const liveTerminalControllerRequestAcknowledgedResultEffectSchema = acknowledged({
+    controllerRequest: liveTerminalControllerRequestEffectSchema,
+    method: Schema.Literal("terminal.controller.request"),
+}).check(Schema.makeFilter((value) => value.receipt.method === value.method &&
+    value.receipt.operation === "controller.request" &&
+    value.receipt.terminalGeneration ===
+        value.controllerRequest.terminalGeneration &&
+    value.receipt.terminalId === value.controllerRequest.terminalId, { expected: "a controller request matching its mutation receipt" }));
+export const liveTerminalControllerRequestResultEffectSchema = Schema.Union([
+    liveTerminalControllerRequestAcknowledgedResultEffectSchema,
+    unknownMutation("terminal.controller.request", "controller.request"),
+]);
+const controllerLeaseResult = (method, operation) => Schema.Union([
+    acknowledged({
+        lease: liveTerminalControllerLeaseEffectSchema,
+        method: Schema.Literal(method),
+    }).check(Schema.makeFilter((value) => value.receipt.method === value.method &&
+        value.receipt.operation === operation &&
+        value.receipt.terminalGeneration === value.lease.terminalGeneration &&
+        value.receipt.terminalId === value.lease.terminalId, { expected: `a ${operation} lease matching its mutation receipt` })),
+    unknownMutation(method, operation),
+]);
+export const liveTerminalControllerAcquireResultEffectSchema = controllerLeaseResult("terminal.controller.acquire", "controller.acquire");
+export const liveTerminalControllerRenewResultEffectSchema = controllerLeaseResult("terminal.controller.renew", "controller.renew");
+export const liveTerminalControllerReleaseResultEffectSchema = controllerLeaseResult("terminal.controller.release", "controller.release");
+const liveTerminalWriteAcknowledgedResultEffectSchema = acknowledged({
+    acceptedBytes: boundedInt(1, MAX_TERMINAL_INPUT_CHUNK_BYTES),
+    inputId: protocolIdentifierEffectSchema,
+    inputSequence: boundedInt(1, MAX_TERMINAL_INPUT_SEQUENCE),
+    method: Schema.Literal("terminal.input.write"),
+    terminal: liveTerminalSessionEffectSchema,
+}).check(Schema.makeFilter((value) => value.receipt.method === value.method &&
+    value.receipt.operation === "write" &&
+    value.receipt.terminalGeneration === value.terminal.generation &&
+    value.receipt.terminalId === value.terminal.id &&
+    value.receipt.terminalRevision === value.terminal.revision &&
+    value.receipt.nativeAcknowledgement.fact ===
+        "pty_master_all_bytes_accepted" &&
+    value.receipt.nativeAcknowledgement.acceptedBytes ===
+        value.acceptedBytes &&
+    value.receipt.nativeAcknowledgement.byteLength === value.acceptedBytes &&
+    value.receipt.nativeAcknowledgement.inputId === value.inputId &&
+    value.receipt.nativeAcknowledgement.inputSequence === value.inputSequence, { expected: "a terminal write matching its native acknowledgement" }));
+export const liveTerminalWriteResultEffectSchema = Schema.Union([
+    liveTerminalWriteAcknowledgedResultEffectSchema,
+    unknownWriteEffectSchema,
+]);
+const sessionMutationResult = (method, operation) => Schema.Union([
+    acknowledged({
+        method: Schema.Literal(method),
+        terminal: liveTerminalSessionEffectSchema,
+    }).check(Schema.makeFilter((value) => value.receipt.method === value.method &&
+        value.receipt.operation === operation &&
+        value.receipt.terminalGeneration === value.terminal.generation &&
+        value.receipt.terminalId === value.terminal.id &&
+        value.receipt.terminalRevision === value.terminal.revision, { expected: `a ${operation} terminal matching its mutation receipt` })),
+    nativeUnknownMutation(method, operation),
+]);
+export const liveTerminalResizeResultEffectSchema = sessionMutationResult("terminal.session.resize", "resize");
+export const liveTerminalSignalResultEffectSchema = sessionMutationResult("terminal.session.signal", "signal");
+export const liveTerminalCloseResultEffectSchema = sessionMutationResult("terminal.session.close", "close");
+const liveTerminalRestartAcknowledgedResultEffectSchema = acknowledged({
+    method: Schema.Literal("terminal.session.restart"),
+    terminal: liveTerminalSessionEffectSchema,
+}).check(Schema.makeFilter((value) => value.receipt.method === value.method &&
+    value.receipt.operation === "restart" &&
+    value.receipt.terminalGeneration === value.terminal.generation &&
+    value.receipt.terminalId === value.terminal.id &&
+    value.receipt.terminalRevision === value.terminal.revision &&
+    value.receipt.sourceTerminalGeneration < MAX_TERMINAL_GENERATION &&
+    value.terminal.generation === value.receipt.sourceTerminalGeneration + 1, { expected: "a restart terminal matching its source and target receipt" }));
+export const liveTerminalRestartResultEffectSchema = Schema.Union([
+    liveTerminalRestartAcknowledgedResultEffectSchema,
+    liveTerminalRestartOutcomeUnknownEffectSchema,
+]);
+export const liveTerminalDeleteResultEffectSchema = Schema.Union([
+    acknowledged({
+        capability: liveTerminalExecutionCapabilityEffectSchema,
+        deletedAt: recordedAtEffectSchema,
+        method: Schema.Literal("terminal.session.delete"),
+        terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+        terminalId: protocolIdentifierEffectSchema,
+    }).check(Schema.makeFilter((value) => value.receipt.method === value.method &&
+        value.receipt.operation === "delete" &&
+        value.receipt.terminalGeneration === value.terminalGeneration &&
+        value.receipt.terminalId === value.terminalId, { expected: "a terminal deletion matching its mutation receipt" })),
+    unknownMutation("terminal.session.delete", "delete"),
+]);
+export const liveTerminalObserverAttachResultEffectSchema = Schema.Struct({
+    attachId: protocolIdentifierEffectSchema,
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    delivery: Schema.Literals(["duplicate", "new"]),
+    expiresAt: recordedAtEffectSchema,
+    method: Schema.Literal("terminal.observer.attach"),
+    observerId: protocolIdentifierEffectSchema,
+    renewal: Schema.Literal("successful-check-renews"),
+    snapshot: liveTerminalObserverSnapshotEffectSchema,
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+}).check(Schema.makeFilter((value) => value.attachId === value.observerId &&
+    value.terminalGeneration === value.snapshot.terminal.generation, {
+    expected: "an idempotent observer attachment matching its terminal generation",
+}));
+export const liveTerminalObserverCheckResultEffectSchema = Schema.Struct({
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    events: Schema.Array(liveTerminalObserverEventEffectSchema).check(Schema.isMaxLength(MAX_TERMINAL_OBSERVER_CHECK_EVENTS)),
+    headCursor: aggregateRevisionEffectSchema,
+    leaseExpiresAt: recordedAtEffectSchema,
+    method: Schema.Literal("terminal.observer.check"),
+    observerId: protocolIdentifierEffectSchema,
+    renewal: Schema.Literal("successful-check-renewed"),
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminalId: protocolIdentifierEffectSchema,
+    timedOut: Schema.Boolean,
+}).check(Schema.makeFilter((value) => value.events.every((event) => event.terminalId === value.terminalId &&
+    event.capability.revocationPolicyRevision ===
+        value.capability.revocationPolicyRevision) &&
+    !(value.timedOut && value.events.length > 0) &&
+    encodedJsonBytes(value) <= MAX_TERMINAL_OBSERVER_CHECK_RESPONSE_BYTES, { expected: "a terminal observer check within its response byte cap" }));
+export const liveTerminalObserverDetachResultEffectSchema = Schema.Struct({
+    capability: liveTerminalExecutionCapabilityEffectSchema,
+    detached: Schema.Literal(true),
+    method: Schema.Literal("terminal.observer.detach"),
+    observerId: protocolIdentifierEffectSchema,
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminalId: protocolIdentifierEffectSchema,
+});
+export const liveTerminalObserverResyncResultEffectSchema = Schema.Struct({
+    method: Schema.Literal("terminal.observer.resync"),
+    snapshot: liveTerminalObserverSnapshotEffectSchema,
+});
+export const liveTerminalControllerRequestShowResultEffectSchema = Schema.Struct({
+    controllerRequest: liveTerminalControllerRequestEffectSchema,
+    method: Schema.Literal("terminal.controller.request.show"),
+});
+const reconciliationIdentityFields = {
+    commandId: protocolIdentifierEffectSchema,
+    mutationSequence: boundedInt(1, MAX_TERMINAL_MUTATION_SEQUENCE),
+    operation: Schema.Literals([
+        "close",
+        "controller.acquire",
+        "controller.release",
+        "controller.renew",
+        "controller.request",
+        "create",
+        "delete",
+        "resize",
+        "signal",
+        "write",
+    ]),
+    originalReplay: Schema.Literal("forbidden"),
+    terminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminalId: protocolIdentifierEffectSchema,
+};
+const liveTerminalOrdinaryReconcileResultEffectSchema = Schema.Union([
+    Schema.Struct({
+        checkedAt: recordedAtEffectSchema,
+        ...reconciliationIdentityFields,
+        method: Schema.Literal("terminal.mutation.reconcile"),
+        next: Schema.Literal("new-mutation-only"),
+        receipt: liveTerminalMutationReceiptEffectSchema,
+        state: Schema.Literal("acknowledged"),
+        terminal: liveTerminalSessionEffectSchema,
+    }),
+    Schema.Struct({
+        checkedAt: recordedAtEffectSchema,
+        ...reconciliationIdentityFields,
+        method: Schema.Literal("terminal.mutation.reconcile"),
+        next: Schema.Literal("new-mutation-only"),
+        receipt: Schema.Literal("not_found"),
+        state: Schema.Literal("not_found"),
+        terminal: liveTerminalSessionEffectSchema,
+    }),
+    Schema.Struct({
+        checkedAt: recordedAtEffectSchema,
+        ...reconciliationIdentityFields,
+        method: Schema.Literal("terminal.mutation.reconcile"),
+        next: Schema.Literal("reconcile-again"),
+        receipt: Schema.Literal("unknown"),
+        state: Schema.Literal("still_unknown"),
+        terminal: liveTerminalSessionEffectSchema,
+    }),
+]).check(Schema.makeFilter((value) => value.terminal.id === value.terminalId &&
+    value.terminal.generation >= value.terminalGeneration &&
+    (value.state !== "acknowledged" ||
+        (value.receipt.commandId === value.commandId &&
+            value.receipt.operation === value.operation &&
+            value.receipt.mutationSequence === value.mutationSequence &&
+            value.receipt.terminalGeneration === value.terminalGeneration &&
+            value.receipt.terminalId === value.terminalId)), { expected: "an exact terminal mutation reconciliation identity" }));
+const restartReconciliationIdentityFields = {
+    checkedAt: recordedAtEffectSchema,
+    commandId: protocolIdentifierEffectSchema,
+    method: Schema.Literal("terminal.mutation.reconcile"),
+    mutationSequence: boundedInt(1, MAX_TERMINAL_MUTATION_SEQUENCE),
+    operation: Schema.Literal("restart"),
+    originalReplay: Schema.Literal("forbidden"),
+    plannedTargetTerminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    sourceTerminalGeneration: boundedInt(1, MAX_TERMINAL_GENERATION),
+    terminal: liveTerminalSessionEffectSchema,
+    terminalId: protocolIdentifierEffectSchema,
+};
+const liveTerminalRestartReconcileResultStructEffectSchema = Schema.Union([
+    Schema.Struct({
+        ...restartReconciliationIdentityFields,
+        effectPhase: Schema.Literal("not-found"),
+        next: Schema.Literal("new-mutation-only"),
+        receipt: Schema.Literal("not_found"),
+        state: Schema.Literal("not_found"),
+        targetAttempt: Schema.Literal("unknown"),
+    }),
+    Schema.Struct({
+        ...restartReconciliationIdentityFields,
+        effectPhase: Schema.Literal("target-start"),
+        next: Schema.Literal("new-mutation-only"),
+        receipt: restartMutationReceiptEffectSchema,
+        state: Schema.Literal("acknowledged"),
+        targetAttempt: Schema.Literal("attempted"),
+    }),
+    Schema.Struct({
+        ...restartReconciliationIdentityFields,
+        effectPhase: Schema.Literal("source-cleanup"),
+        next: Schema.Literal("reconcile-again"),
+        receipt: Schema.Literal("unknown"),
+        state: Schema.Literal("still_unknown"),
+        targetAttempt: Schema.Literal("not-attempted"),
+    }),
+    Schema.Struct({
+        ...restartReconciliationIdentityFields,
+        effectPhase: Schema.Literal("target-start"),
+        next: Schema.Literal("reconcile-again"),
+        receipt: Schema.Literal("unknown"),
+        state: Schema.Literal("still_unknown"),
+        targetAttempt: Schema.Literals(["attempted", "may-have-been-attempted"]),
+    }),
+]);
+const restartAcknowledgementMatches = (value) => value.receipt.commandId === value.commandId &&
+    value.receipt.mutationSequence === value.mutationSequence &&
+    value.receipt.sourceTerminalGeneration === value.sourceTerminalGeneration &&
+    value.receipt.terminalGeneration === value.plannedTargetTerminalGeneration &&
+    value.receipt.terminalId === value.terminalId &&
+    value.terminal.generation >= value.plannedTargetTerminalGeneration;
+const restartUnknownProjectionMatches = (value) => {
+    if (value.terminal.state !== "disconnected")
+        return false;
+    if (value.effectPhase === "source-cleanup") {
+        return value.terminal.generation === value.sourceTerminalGeneration;
+    }
+    return (value.terminal.generation === value.plannedTargetTerminalGeneration &&
+        value.terminal.cleanup.reason === "native_acknowledgement_lost");
+};
+const restartReconciliationIsAdmitted = (value) => {
+    if (value.sourceTerminalGeneration >= MAX_TERMINAL_GENERATION ||
+        value.plannedTargetTerminalGeneration !==
+            value.sourceTerminalGeneration + 1 ||
+        value.terminal.id !== value.terminalId) {
+        return false;
+    }
+    if (value.state === "acknowledged") {
+        return restartAcknowledgementMatches(value);
+    }
+    if (value.state === "not_found") {
+        return value.terminal.generation >= value.sourceTerminalGeneration;
+    }
+    return restartUnknownProjectionMatches(value);
+};
+const liveTerminalRestartReconcileResultEffectSchema = liveTerminalRestartReconcileResultStructEffectSchema.check(Schema.makeFilter(restartReconciliationIsAdmitted, {
+    expected: "a phase-exact restart reconciliation identity",
+}));
+export const liveTerminalReconcileResultEffectSchema = Schema.Union([
+    liveTerminalOrdinaryReconcileResultEffectSchema,
+    liveTerminalRestartReconcileResultEffectSchema,
+]);
+export const liveTerminalRequestPayloadEffectSchema = Schema.Union([
+    Schema.Struct({
+        method: Schema.Literal("terminal.observer.attach"),
+        parameters: liveTerminalObserverAttachParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.observer.check"),
+        parameters: liveTerminalObserverCheckParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.observer.detach"),
+        parameters: liveTerminalObserverDetachParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.observer.resync"),
+        parameters: liveTerminalObserverResyncParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.controller.request"),
+        parameters: liveTerminalControllerRequestParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.controller.request.show"),
+        parameters: liveTerminalControllerRequestShowParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.controller.acquire"),
+        parameters: liveTerminalControllerAcquireParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.controller.renew"),
+        parameters: liveTerminalControllerRenewParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.controller.release"),
+        parameters: liveTerminalControllerReleaseParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.input.write"),
+        parameters: liveTerminalWriteParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.session.resize"),
+        parameters: liveTerminalResizeParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.session.signal"),
+        parameters: liveTerminalSignalParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.session.close"),
+        parameters: liveTerminalCloseParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.session.restart"),
+        parameters: liveTerminalRestartParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.session.delete"),
+        parameters: liveTerminalDeleteParametersEffectSchema,
+    }),
+    Schema.Struct({
+        method: Schema.Literal("terminal.mutation.reconcile"),
+        parameters: liveTerminalReconcileParametersEffectSchema,
+    }),
+]);
+export const liveTerminalSuccessResultEffectSchema = Schema.Union([
+    liveTerminalCreateResultEffectSchema,
+    liveTerminalObserverAttachResultEffectSchema,
+    liveTerminalObserverCheckResultEffectSchema,
+    liveTerminalObserverDetachResultEffectSchema,
+    liveTerminalObserverResyncResultEffectSchema,
+    liveTerminalControllerRequestResultEffectSchema,
+    liveTerminalControllerRequestShowResultEffectSchema,
+    liveTerminalControllerAcquireResultEffectSchema,
+    liveTerminalControllerRenewResultEffectSchema,
+    liveTerminalControllerReleaseResultEffectSchema,
+    liveTerminalWriteResultEffectSchema,
+    liveTerminalResizeResultEffectSchema,
+    liveTerminalSignalResultEffectSchema,
+    liveTerminalCloseResultEffectSchema,
+    liveTerminalRestartResultEffectSchema,
+    liveTerminalDeleteResultEffectSchema,
+    liveTerminalReconcileResultEffectSchema,
+]);
+//# sourceMappingURL=live-effect-schema.js.map