@orion-agents/orion-code 0.3.1 → 0.3.4

package/dist/web/session-runtime-registry.js

@@ -0,0 +1,448 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSessionRuntimeRegistryError = exports.WebSessionRuntimeRegistryV1 = void 0;
+const crypto_1 = require("crypto");
+const DEFAULT_MAX_RUNNING_SESSIONS = 3;
+const DEFAULT_MAX_RESIDENT_SESSION_ACTORS = 4;
+/**
+ * Bounded Web-only Session actor pool.
+ *
+ * It owns concurrency admission and actor lifetime, but deliberately knows
+ * nothing about React, HTTP, OrionRuntime, or TUI semantics. Callers provide a
+ * Session-scoped actor and a logical-turn terminal promise. This keeps Web
+ * parallelism out of the single-session CLI/TUI runner.
+ */
+class WebSessionRuntimeRegistryV1 {
+    constructor(options) {
+        this.options = options;
+        this.records = new Map();
+        this.queue = [];
+        this.capacityQueue = Promise.resolve();
+        this.ordinal = 0;
+        this.runningCountValue = 0;
+        this.closed = false;
+        this.maxRunningSessions = boundedInteger(options.maxRunningSessions, DEFAULT_MAX_RUNNING_SESSIONS, 1, 8, 'maxRunningSessions');
+        this.maxResidentSessionActors = boundedInteger(options.maxResidentSessionActors, DEFAULT_MAX_RESIDENT_SESSION_ACTORS, 1, 8, 'maxResidentSessionActors');
+        if (this.maxResidentSessionActors < this.maxRunningSessions) {
+            throw new Error('maxResidentSessionActors must be greater than or equal to maxRunningSessions.');
+        }
+        this.now = options.now ?? Date.now;
+        this.createRevision = options.createRevision ?? crypto_1.randomUUID;
+    }
+    get runningCount() {
+        return this.runningCountValue;
+    }
+    get residentCount() {
+        let count = 0;
+        for (const record of this.records.values())
+            if (record.actor !== undefined)
+                count += 1;
+        return count;
+    }
+    summary(key) {
+        return this.snapshot(this.record(key));
+    }
+    summaries() {
+        return Object.freeze([...this.records.values()]
+            .sort((left, right) => right.lastUsedOrdinal - left.lastUsedOrdinal)
+            .map(record => this.snapshot(record)));
+    }
+    /**
+     * Return the current resident actor without starting a cold Session.
+     *
+     * Snapshot/read paths use this to project live state while preserving the
+     * cold-read invariant: merely selecting or inspecting a Session must not
+     * allocate a Runtime or consume a running slot.
+     */
+    residentActor(key) {
+        this.assertOpen();
+        const record = this.record(key);
+        if (!record.actor || !record.actorReady)
+            return undefined;
+        this.touch(record);
+        return Object.freeze({ actor: record.actor, runtime: this.snapshot(record) });
+    }
+    async ensureResident(key, expectedRuntimeRevision) {
+        return this.withCapacityLock(async () => {
+            this.assertOpen();
+            const record = this.record(key);
+            this.assertRevision(record, expectedRuntimeRevision);
+            const actor = await this.ensureResidentLocked(record);
+            return Object.freeze({ actor, runtime: this.snapshot(record) });
+        });
+    }
+    async withActor(key, expectedRuntimeRevision, action) {
+        return this.withCapacityLock(async () => {
+            this.assertOpen();
+            const record = this.record(key);
+            this.assertRevision(record, expectedRuntimeRevision);
+            const actor = await this.ensureResidentLocked(record);
+            const result = await action(actor);
+            this.touch(record);
+            return Object.freeze({ result, runtime: this.snapshot(record) });
+        });
+    }
+    async admitTurn(input) {
+        return this.withCapacityLock(async () => {
+            this.assertOpen();
+            const record = this.record(input.key);
+            this.assertRevision(record, input.expectedRuntimeRevision);
+            if (record.activeRun || record.queueId) {
+                throw new WebSessionRuntimeRegistryError(409, 'session_turn_already_active', 'The Session already has a running or queued logical turn.');
+            }
+            const actor = await this.ensureResidentLocked(record);
+            if (this.runningCountValue >= this.maxRunningSessions) {
+                const queueId = this.createRevision();
+                record.queueId = queueId;
+                this.queue.push({
+                    queueId,
+                    record,
+                    start: input.start,
+                });
+                record.queuePosition = this.queue.length;
+                this.transition(record, 'queued');
+                this.publishQueuePositions();
+                const runtime = this.snapshot(record);
+                return Object.freeze({
+                    status: 'queued',
+                    queueId,
+                    queuePosition: runtime.queuePosition,
+                    runtime,
+                });
+            }
+            const started = await this.startTurn(record, actor, input.start);
+            return Object.freeze({
+                status: 'started',
+                accepted: started.accepted,
+                runtime: started.runtime,
+            });
+        });
+    }
+    cancelQueued(key, queueId, expectedRuntimeRevision) {
+        this.assertOpen();
+        const record = this.record(key);
+        this.assertRevision(record, expectedRuntimeRevision);
+        if (!record.queueId || record.queueId !== queueId) {
+            throw new WebSessionRuntimeRegistryError(409, 'session_queue_conflict', 'The queued turn no longer matches this Session.');
+        }
+        const index = this.queue.findIndex(item => item.queueId === queueId && item.record === record);
+        if (index < 0) {
+            throw new WebSessionRuntimeRegistryError(409, 'session_queue_conflict', 'The queued turn is no longer pending.');
+        }
+        this.queue.splice(index, 1);
+        record.queueId = undefined;
+        record.queuePosition = undefined;
+        this.transition(record, 'idle');
+        this.publishQueuePositions();
+        return this.snapshot(record);
+    }
+    setPendingApprovalCount(key, count) {
+        this.assertOpen();
+        const record = this.record(key);
+        if (!Number.isSafeInteger(count) || count < 0) {
+            throw new Error('pending approval count must be a non-negative integer.');
+        }
+        const normalized = count;
+        if (record.pendingApprovalCount === normalized)
+            return this.snapshot(record);
+        record.pendingApprovalCount = normalized;
+        if (record.activeRun)
+            this.transition(record, normalized > 0 ? 'waiting_approval' : 'running');
+        else
+            this.bump(record);
+        return this.snapshot(record);
+    }
+    async evict(key, reason = 'session actor evicted') {
+        this.assertOpen();
+        const record = this.record(key);
+        await this.withCapacityLock(async () => {
+            if (!record.actor)
+                return;
+            if (!this.isEvictable(record)) {
+                throw new WebSessionRuntimeRegistryError(409, 'session_actor_busy', 'Running, queued, approval-waiting, or stopping actors cannot be evicted.');
+            }
+            await this.closeResidentLocked(record, reason, 'cold');
+        });
+    }
+    async shutdown(reason = 'Web Session registry shutdown') {
+        this.closed = true;
+        const queued = this.queue.splice(0);
+        for (const item of queued) {
+            item.record.queueId = undefined;
+            item.record.queuePosition = undefined;
+            this.transition(item.record, 'interrupted');
+        }
+        const cleanupErrors = [];
+        await this.withCapacityLock(async () => {
+            const residents = [...this.records.values()].filter(record => record.actor !== undefined);
+            await Promise.all(residents.map(async (record) => {
+                const actor = record.actor;
+                if (!actor)
+                    return;
+                const wasActive = record.activeRun;
+                if (wasActive)
+                    this.runningCountValue = Math.max(0, this.runningCountValue - 1);
+                record.activeRun = false;
+                record.pendingApprovalCount = 0;
+                record.actorReady = false;
+                this.transition(record, 'stopping');
+                try {
+                    await this.options.closeActor(actor, reason);
+                    record.actor = undefined;
+                    record.estimatedBytes = 0;
+                    this.transition(record, wasActive ? 'interrupted' : 'cold');
+                }
+                catch (error) {
+                    record.failure = error;
+                    this.transition(record, 'failed');
+                    cleanupErrors.push(error);
+                }
+            }));
+        });
+        if (cleanupErrors.length > 0) {
+            throw new WebSessionRuntimeRegistryError(503, 'session_actor_cleanup_failed', `${cleanupErrors.length} Session actor(s) could not be closed safely.`);
+        }
+    }
+    record(key) {
+        const normalized = normalizeKey(key);
+        const id = keyId(normalized);
+        let record = this.records.get(id);
+        if (!record) {
+            const now = this.now();
+            record = {
+                key: normalized,
+                phase: 'cold',
+                runtimeRevision: this.createRevision(),
+                pendingApprovalCount: 0,
+                estimatedBytes: 0,
+                updatedAtMs: now,
+                lastUsedOrdinal: ++this.ordinal,
+                activeRun: false,
+                actorReady: false,
+            };
+            this.records.set(id, record);
+            this.publish(record);
+        }
+        return record;
+    }
+    async ensureResidentLocked(record) {
+        if (record.actor && record.actorReady) {
+            this.touch(record);
+            return record.actor;
+        }
+        if (record.actor) {
+            await this.closeResidentLocked(record, 'retry quarantined Session actor cleanup', 'cold');
+        }
+        await this.makeCapacityLocked(record);
+        this.transition(record, 'starting');
+        let actor;
+        try {
+            actor = await this.options.createActor(record.key);
+            await this.options.initializeActor?.(actor, record.key);
+            if (this.closed) {
+                throw new WebSessionRuntimeRegistryError(503, 'session_registry_closed', 'The Web Session registry is closed.');
+            }
+            record.estimatedBytes = normalizeBytes(this.options.estimateActorBytes?.(actor));
+            record.actor = actor;
+            record.actorReady = true;
+            actor = undefined;
+            record.failure = undefined;
+            this.transition(record, 'idle');
+            return record.actor;
+        }
+        catch (error) {
+            if (actor) {
+                try {
+                    await this.options.closeActor(actor, 'Session actor start failed');
+                }
+                catch (cleanupError) {
+                    // Preserve the only handle to the partially initialized actor. It is
+                    // never returned by residentActor/ensureResident and still counts
+                    // against the resident budget until a later eviction or shutdown
+                    // successfully closes it.
+                    record.actor = actor;
+                    record.actorReady = false;
+                    record.estimatedBytes = 0;
+                    record.failure = cleanupError;
+                    this.transition(record, 'failed');
+                    throw new WebSessionRuntimeRegistryError(503, 'session_actor_cleanup_failed', 'A failed Session actor could not be closed safely.');
+                }
+            }
+            record.actor = undefined;
+            record.actorReady = false;
+            record.estimatedBytes = 0;
+            record.failure = error;
+            this.transition(record, 'failed');
+            throw error;
+        }
+    }
+    async makeCapacityLocked(target) {
+        if (this.residentCount < this.maxResidentSessionActors)
+            return;
+        const candidate = [...this.records.values()]
+            .filter(record => record !== target && record.actor && this.isEvictable(record))
+            .sort((left, right) => left.lastUsedOrdinal - right.lastUsedOrdinal)[0];
+        if (!candidate) {
+            throw new WebSessionRuntimeRegistryError(503, 'session_concurrency_limit', 'All resident Session actors are busy; the requested Session remains available read-only.');
+        }
+        await this.closeResidentLocked(candidate, 'idle Session actor evicted by LRU', 'cold');
+    }
+    isEvictable(record) {
+        return (Boolean(record.actor) &&
+            !record.activeRun &&
+            !record.queueId &&
+            record.pendingApprovalCount === 0 &&
+            ['idle', 'failed', 'interrupted'].includes(record.phase));
+    }
+    async closeResidentLocked(record, reason, terminalPhase) {
+        const actor = record.actor;
+        if (!actor)
+            return;
+        record.actorReady = false;
+        this.transition(record, 'stopping');
+        try {
+            await this.options.closeActor(actor, reason);
+            record.actor = undefined;
+            record.estimatedBytes = 0;
+            this.transition(record, terminalPhase);
+        }
+        catch (error) {
+            record.failure = error;
+            this.transition(record, 'failed');
+            throw error;
+        }
+    }
+    async startTurn(record, actor, start) {
+        record.activeRun = true;
+        record.queueId = undefined;
+        record.pendingApprovalCount = 0;
+        this.runningCountValue += 1;
+        this.transition(record, 'running');
+        try {
+            const started = await start(actor);
+            void Promise.resolve(started.settled).then(() => this.finishTurn(record), error => this.finishTurn(record, error));
+            return Object.freeze({ accepted: started.accepted, runtime: this.snapshot(record) });
+        }
+        catch (error) {
+            this.finishTurn(record, error);
+            throw error;
+        }
+    }
+    finishTurn(record, error) {
+        if (!record.activeRun)
+            return;
+        record.activeRun = false;
+        record.pendingApprovalCount = 0;
+        this.runningCountValue = Math.max(0, this.runningCountValue - 1);
+        if (error) {
+            record.failure = error;
+            this.transition(record, 'failed');
+        }
+        else {
+            record.failure = undefined;
+            this.transition(record, 'idle');
+        }
+        this.drainQueue();
+    }
+    drainQueue() {
+        while (!this.closed && this.runningCountValue < this.maxRunningSessions && this.queue.length) {
+            const item = this.queue.shift();
+            item.record.queueId = undefined;
+            item.record.queuePosition = undefined;
+            const actor = item.record.actor;
+            if (!actor) {
+                item.record.failure = new Error('Queued Session actor is no longer resident.');
+                this.transition(item.record, 'failed');
+                continue;
+            }
+            void this.startTurn(item.record, actor, item.start).catch(() => undefined);
+        }
+        this.publishQueuePositions();
+    }
+    publishQueuePositions() {
+        for (const [index, item] of this.queue.entries()) {
+            const queuePosition = index + 1;
+            if (item.record.queuePosition === queuePosition)
+                continue;
+            item.record.queuePosition = queuePosition;
+            this.bump(item.record);
+        }
+    }
+    snapshot(record) {
+        return Object.freeze({
+            ...record.key,
+            runtimeRevision: record.runtimeRevision,
+            phase: record.phase,
+            ...(record.queueId ? { queueId: record.queueId } : {}),
+            ...(record.queueId && record.queuePosition ? { queuePosition: record.queuePosition } : {}),
+            pendingApprovalCount: record.pendingApprovalCount,
+            resident: record.actor !== undefined,
+            estimatedBytes: record.estimatedBytes,
+            updatedAt: new Date(record.updatedAtMs).toISOString(),
+        });
+    }
+    assertRevision(record, expectedRuntimeRevision) {
+        if (expectedRuntimeRevision === undefined)
+            return;
+        if (expectedRuntimeRevision !== record.runtimeRevision) {
+            throw new WebSessionRuntimeRegistryError(409, 'session_runtime_revision_conflict', 'The Session Runtime changed before the operation was admitted.');
+        }
+    }
+    transition(record, phase) {
+        record.phase = phase;
+        this.bump(record);
+    }
+    touch(record) {
+        record.lastUsedOrdinal = ++this.ordinal;
+        record.updatedAtMs = this.now();
+    }
+    bump(record) {
+        record.runtimeRevision = this.createRevision();
+        this.touch(record);
+        this.publish(record);
+    }
+    publish(record) {
+        this.options.onSummaryChanged?.(this.snapshot(record));
+    }
+    withCapacityLock(operation) {
+        const result = this.capacityQueue.then(operation, operation);
+        this.capacityQueue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    assertOpen() {
+        if (this.closed) {
+            throw new WebSessionRuntimeRegistryError(503, 'session_registry_closed', 'The Web Session registry is closed.');
+        }
+    }
+}
+exports.WebSessionRuntimeRegistryV1 = WebSessionRuntimeRegistryV1;
+class WebSessionRuntimeRegistryError extends Error {
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = 'WebSessionRuntimeRegistryError';
+    }
+}
+exports.WebSessionRuntimeRegistryError = WebSessionRuntimeRegistryError;
+function normalizeKey(key) {
+    const workspaceId = key.workspaceId.trim();
+    const sessionId = key.sessionId.trim();
+    if (!workspaceId || !sessionId)
+        throw new Error('Session actor identity must not be empty.');
+    return Object.freeze({ workspaceId, sessionId });
+}
+function keyId(key) {
+    return `${key.workspaceId}\u0000${key.sessionId}`;
+}
+function normalizeBytes(value) {
+    return Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
+function boundedInteger(value, fallback, minimum, maximum, name) {
+    const candidate = value ?? fallback;
+    if (!Number.isSafeInteger(candidate) || candidate < minimum || candidate > maximum) {
+        throw new Error(`${name} must be an integer between ${minimum} and ${maximum}.`);
+    }
+    return candidate;
+}
+//# sourceMappingURL=session-runtime-registry.js.map

package/dist/web/terminal-manager.d.ts

@@ -140,6 +140,7 @@ export declare class TerminalManagerV1 {
     private scheduleReap;
     private setProcessOutputPaused;
     private appendOutput;
+    private flushPendingOutput;
     private handleExit;
     private issueTicket;
     private consumeTicket;

package/dist/web/terminal-manager.js

@@ -11,6 +11,7 @@ const MAX_WORKSPACE_TERMINALS = 2;
 const MAX_SCROLLBACK_BYTES = 2 * 1024 * 1024;
 const MAX_INPUT_BYTES = 64 * 1024;
 const MAX_OUTPUT_FRAME_CHARS = 8000;
+const OUTPUT_COALESCE_MS = 8;
 const DEFAULT_TICKET_TTL_MS = 15000;
 const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 const DEFAULT_FORCE_KILL_DELAY_MS = 1000;
@@ -106,6 +107,7 @@ class TerminalManagerV1 {
             nextSequence: 1,
             frames: [],
             frameBytes: 0,
+            pendingOutput: '',
             dataSubscription: process.onData(data => this.appendOutput(entry, data)),
             exitSubscription: process.onExit(event => this.handleExit(entry, event)),
             removeAfterExit: false,
@@ -144,6 +146,7 @@ class TerminalManagerV1 {
         }
         const entry = this.requireTerminal(input.terminalId);
         this.consumeTicket(entry.id, input.ticket);
+        this.flushPendingOutput(entry, true);
         if (entry.outputPaused)
             this.setProcessOutputPaused(entry, false);
         entry.subscriber?.onReplaced();
@@ -348,16 +351,36 @@ class TerminalManagerV1 {
     appendOutput(entry, data) {
         if (entry.state !== 'running' && entry.state !== 'closing')
             return;
-        for (let offset = 0; offset < data.length;) {
-            let end = Math.min(data.length, offset + MAX_OUTPUT_FRAME_CHARS);
-            if (end < data.length &&
-                end > offset &&
-                isHighSurrogate(data.charCodeAt(end - 1)) &&
-                isLowSurrogate(data.charCodeAt(end))) {
+        entry.pendingOutput += data;
+        this.flushPendingOutput(entry, data.length >= MAX_OUTPUT_FRAME_CHARS);
+        if (entry.pendingOutput && !entry.outputFlushTimer) {
+            entry.outputFlushTimer = setTimeout(() => {
+                entry.outputFlushTimer = undefined;
+                this.flushPendingOutput(entry, true);
+            }, OUTPUT_COALESCE_MS);
+            entry.outputFlushTimer.unref();
+        }
+    }
+    flushPendingOutput(entry, force, final = false) {
+        let emitted = false;
+        while (entry.pendingOutput.length > 0 &&
+            (force || entry.pendingOutput.length >= MAX_OUTPUT_FRAME_CHARS)) {
+            let end = Math.min(entry.pendingOutput.length, MAX_OUTPUT_FRAME_CHARS);
+            if (end < entry.pendingOutput.length &&
+                end > 0 &&
+                isHighSurrogate(entry.pendingOutput.charCodeAt(end - 1)) &&
+                isLowSurrogate(entry.pendingOutput.charCodeAt(end))) {
                 end -= 1;
             }
-            const value = data.slice(offset, end);
-            offset = end;
+            if (!final &&
+                end === entry.pendingOutput.length &&
+                isHighSurrogate(entry.pendingOutput.charCodeAt(end - 1))) {
+                break;
+            }
+            if (end <= 0)
+                break;
+            const value = replaceUnpairedSurrogates(entry.pendingOutput.slice(0, end));
+            entry.pendingOutput = entry.pendingOutput.slice(end);
             const frame = Object.freeze({
                 sequence: entry.nextSequence++,
                 data: value,
@@ -370,12 +393,19 @@ class TerminalManagerV1 {
                 entry.frameBytes -= removed?.bytes ?? 0;
             }
             entry.subscriber?.onFrame(Object.freeze({ type: 'output', sequence: frame.sequence, data: frame.data }));
+            emitted = true;
         }
-        this.touch(entry);
+        if (!entry.pendingOutput && entry.outputFlushTimer) {
+            clearTimeout(entry.outputFlushTimer);
+            entry.outputFlushTimer = undefined;
+        }
+        if (emitted)
+            this.touch(entry);
     }
     handleExit(entry, event) {
         if (this.terminals.get(entry.id) !== entry)
             return;
+        this.flushPendingOutput(entry, true, true);
         entry.state = 'exited';
         entry.exitCode = event.exitCode;
         entry.signal = event.signal;
@@ -486,6 +516,8 @@ class TerminalManagerV1 {
             clearTimeout(entry.forceKillTimer);
         if (entry.reapTimer)
             clearTimeout(entry.reapTimer);
+        if (entry.outputFlushTimer)
+            clearTimeout(entry.outputFlushTimer);
         entry.dataSubscription.dispose();
         entry.exitSubscription.dispose();
         entry.subscriber = undefined;
@@ -578,6 +610,25 @@ function isHighSurrogate(value) {
 function isLowSurrogate(value) {
     return value >= 0xdc00 && value <= 0xdfff;
 }
+function replaceUnpairedSurrogates(value) {
+    let normalized = '';
+    for (let index = 0; index < value.length; index += 1) {
+        const current = value.charCodeAt(index);
+        if (isHighSurrogate(current)) {
+            const next = value.charCodeAt(index + 1);
+            if (isLowSurrogate(next)) {
+                normalized += value[index] + value[index + 1];
+                index += 1;
+            }
+            else {
+                normalized += '\ufffd';
+            }
+            continue;
+        }
+        normalized += isLowSurrogate(current) ? '\ufffd' : value[index];
+    }
+    return normalized;
+}
 function terminateProcessTree(entry) {
     signalProcessTree(entry, 'SIGTERM');
 }

package/dist/web/terminal-server.js

@@ -67,6 +67,8 @@ function ownTerminalSocket(webSocket, terminalId, manager) {
     let connection;
     let backpressurePaused = false;
     let replayPaused = false;
+    const replayTail = [];
+    let replayExit;
     let drainTimer;
     let replayTimer;
     const timer = setTimeout(() => webSocket.close(4401, 'Authentication timeout'), AUTH_TIMEOUT_MS);
@@ -134,12 +136,33 @@ function ownTerminalSocket(webSocket, terminalId, manager) {
         checkBackpressure();
         return true;
     };
+    const sendExit = (event) => {
+        if (!send(event, () => webSocket.close(1000, 'Terminal exited'))) {
+            webSocket.close(1000, 'Terminal exited');
+        }
+    };
+    const drainReplayTail = () => {
+        if (webSocket.readyState !== ws_1.WebSocket.OPEN)
+            return;
+        const next = replayTail.shift();
+        if (next !== undefined) {
+            send(next, drainReplayTail);
+            return;
+        }
+        if (replayExit !== undefined) {
+            const exit = replayExit;
+            replayExit = undefined;
+            sendExit(exit);
+            return;
+        }
+        replayPaused = false;
+        applyFlowControl();
+    };
     const sendReplay = (values, index = 0) => {
         if (webSocket.readyState !== ws_1.WebSocket.OPEN)
             return;
         if (index >= values.length) {
-            replayPaused = false;
-            applyFlowControl();
+            drainReplayTail();
             return;
         }
         if (webSocket.bufferedAmount >= PAUSE_WS_BUFFERED_BYTES) {
@@ -183,11 +206,17 @@ function ownTerminalSocket(webSocket, terminalId, manager) {
                     terminalId,
                     ticket: auth.ticket,
                     afterSequence: auth.afterSequence,
-                    onFrame: frame => send(frame),
+                    onFrame: frame => {
+                        if (replayPaused)
+                            replayTail.push(frame);
+                        else
+                            send(frame);
+                    },
                     onExit: event => {
-                        if (!send(event, () => webSocket.close(1000, 'Terminal exited'))) {
-                            webSocket.close(1000, 'Terminal exited');
-                        }
+                        if (replayPaused)
+                            replayExit = event;
+                        else
+                            sendExit(event);
                     },
                     onReplaced: () => webSocket.close(4409, 'Terminal connection replaced'),
                 });