@parhelia/core 0.3.12763 → 0.3.12767

package/dist/editor/client/agentTerminalFocus.d.ts

@@ -1,4 +1,4 @@
-export declare const AGENT_TERMINAL_BLUR_GRACE_MS = 350;
+export declare const AGENT_TERMINAL_BLUR_GRACE_MS = 2000;
 /** Whether an event target is (or is inside) the agent terminal. */
 export declare function isAgentTerminalTarget(target: EventTarget | null): boolean;
 /**

package/dist/editor/client/agentTerminalFocus.js

@@ -11,7 +11,7 @@
 // `document.activeElement`: the prompt textarea holds focus for minutes, and a
 // persistent activeElement check would suppress legitimate clears (e.g. a mode
 // change via keyboard shortcut) while the user types.
-export const AGENT_TERMINAL_BLUR_GRACE_MS = 350;
+export const AGENT_TERMINAL_BLUR_GRACE_MS = 2_000;
 const AGENT_TERMINAL_SELECTOR = "[data-agent-terminal-root]";
 /** Whether an event target is (or is inside) the agent terminal. */
 export function isAgentTerminalTarget(target) {

package/dist/editor/client/agentTerminalFocus.js.map

@@ -1 +1 @@
-{"version":3,"file":"agentTerminalFocus.js","sourceRoot":"","sources":["../../../src/editor/client/agentTerminalFocus.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,6EAA6E;AAC7E,+EAA+E;AAC/E,+EAA+E;AAC/E,6EAA6E;AAC7E,eAAe;AAEf,+EAA+E;AAC/E,8EAA8E;AAC9E,uEAAuE;AACvE,uEAAuE;AACvE,+EAA+E;AAC/E,+EAA+E;AAC/E,sDAAsD;AACtD,MAAM,CAAC,MAAM,4BAA4B,GAAG,GAAG,CAAC;AAEhD,MAAM,uBAAuB,GAAG,4BAA4B,CAAC;AAE7D,oEAAoE;AACpE,MAAM,UAAU,qBAAqB,CAAC,MAA0B;IAC9D,MAAM,OAAO,GAAG,MAAM,YAAY,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;IAC1D,OAAO,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,uBAAuB,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,8BAA8B,CAC5C,MAA0B,EAC1B,GAAW;IAEX,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAI5C;IACC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,4BAA4B,CAAC;IAC/D,OAAO,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,8BAA8B,GAAG,OAAO,CAAC;AACtE,CAAC"}
+{"version":3,"file":"agentTerminalFocus.js","sourceRoot":"","sources":["../../../src/editor/client/agentTerminalFocus.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,6EAA6E;AAC7E,+EAA+E;AAC/E,+EAA+E;AAC/E,6EAA6E;AAC7E,eAAe;AAEf,+EAA+E;AAC/E,8EAA8E;AAC9E,uEAAuE;AACvE,uEAAuE;AACvE,+EAA+E;AAC/E,+EAA+E;AAC/E,sDAAsD;AACtD,MAAM,CAAC,MAAM,4BAA4B,GAAG,KAAK,CAAC;AAElD,MAAM,uBAAuB,GAAG,4BAA4B,CAAC;AAE7D,oEAAoE;AACpE,MAAM,UAAU,qBAAqB,CAAC,MAA0B;IAC9D,MAAM,OAAO,GAAG,MAAM,YAAY,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;IAC1D,OAAO,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,uBAAuB,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,8BAA8B,CAC5C,MAA0B,EAC1B,GAAW;IAEX,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,4BAA4B,CAAC,MAI5C;IACC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,4BAA4B,CAAC;IAC/D,OAAO,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,8BAA8B,GAAG,OAAO,CAAC;AACtE,CAAC"}

package/dist/editor/client/editHistoryReconciliation.d.ts

@@ -0,0 +1,10 @@
+import type { EditOperation } from "../../types";
+import type { ExecutionResult } from "../services/editService";
+export declare function isRedoStackEntry(operation: EditOperation): boolean;
+/**
+ * Persisting any new operation removes all undone operations for that session
+ * on the server. Apply the same rule before deciding whether the new operation
+ * belongs in the currently visible history scope.
+ */
+export declare function reconcileNewHistoryOperation(history: EditOperation[], newOperation: EditOperation, includeNewOperation: boolean): EditOperation[];
+export declare function isMissingEditOperationResult(result: ExecutionResult<unknown>): boolean;

package/dist/editor/client/editHistoryReconciliation.js

@@ -0,0 +1,25 @@
+export function isRedoStackEntry(operation) {
+    return operation.undone === true || operation.canRedo === true;
+}
+/**
+ * Persisting any new operation removes all undone operations for that session
+ * on the server. Apply the same rule before deciding whether the new operation
+ * belongs in the currently visible history scope.
+ */
+export function reconcileNewHistoryOperation(history, newOperation, includeNewOperation) {
+    const historyWithValidRedoStack = newOperation.sessionId && !isRedoStackEntry(newOperation)
+        ? history.filter((operation) => operation.sessionId !== newOperation.sessionId ||
+            !isRedoStackEntry(operation))
+        : history;
+    return includeNewOperation
+        ? [newOperation, ...historyWithValidRedoStack]
+        : historyWithValidRedoStack;
+}
+export function isMissingEditOperationResult(result) {
+    if (result.response.status !== 404)
+        return false;
+    return [result.summary, result.details, result.rawDetails]
+        .filter((value) => typeof value === "string")
+        .some((value) => /operation not found\s*:/i.test(value));
+}
+//# sourceMappingURL=editHistoryReconciliation.js.map

package/dist/editor/client/editHistoryReconciliation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editHistoryReconciliation.js","sourceRoot":"","sources":["../../../src/editor/client/editHistoryReconciliation.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,gBAAgB,CAAC,SAAwB;IACvD,OAAO,SAAS,CAAC,MAAM,KAAK,IAAI,IAAI,SAAS,CAAC,OAAO,KAAK,IAAI,CAAC;AACjE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAC1C,OAAwB,EACxB,YAA2B,EAC3B,mBAA4B;IAE5B,MAAM,yBAAyB,GAC7B,YAAY,CAAC,SAAS,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC;QACvD,CAAC,CAAC,OAAO,CAAC,MAAM,CACZ,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,SAAS,KAAK,YAAY,CAAC,SAAS;YAC9C,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAC/B;QACH,CAAC,CAAC,OAAO,CAAC;IAEd,OAAO,mBAAmB;QACxB,CAAC,CAAC,CAAC,YAAY,EAAE,GAAG,yBAAyB,CAAC;QAC9C,CAAC,CAAC,yBAAyB,CAAC;AAChC,CAAC;AAED,MAAM,UAAU,4BAA4B,CAC1C,MAAgC;IAEhC,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,KAAK,GAAG;QAAE,OAAO,KAAK,CAAC;IAEjD,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,UAAU,CAAC;SACvD,MAAM,CAAC,CAAC,KAAK,EAAmB,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC;SAC7D,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,0BAA0B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AAC7D,CAAC"}

package/dist/editor/client/errorToast.js

@@ -56,7 +56,7 @@ function ExpandableErrorDetails({ details, onToggle, }) {
                     event.stopPropagation();
                     setExpanded((current) => !current);
                     onToggle?.();
-                }, children: [_jsx(ChevronDown, { className: cn("h-3 w-3 transition-transform duration-200", expanded && "rotate-180"), strokeWidth: 1.75 }), expanded ? "Hide details" : "Show details"] }), expanded && (_jsx("pre", { id: detailsId, className: "border-border-default bg-neutral-grey-5 text-neutral-grey-100 mt-2 max-h-36 overflow-auto rounded border p-2 font-mono text-[11px] leading-relaxed whitespace-pre-wrap break-words", children: details }))] }));
+                }, children: [_jsx(ChevronDown, { className: cn("h-3 w-3 transition-transform duration-200", expanded && "rotate-180"), strokeWidth: 1 }), expanded ? "Hide details" : "Show details"] }), expanded && (_jsx("pre", { id: detailsId, className: "border-border-default bg-neutral-grey-5 text-neutral-grey-100 mt-2 max-h-36 overflow-auto rounded border p-2 font-mono text-[11px] leading-relaxed break-words whitespace-pre-wrap", children: details }))] }));
 }
 export function showExpandableErrorToast(error) {
     const normalized = normalizeErrorToastPayload(error);

package/dist/editor/client/errorToast.js.map

@@ -1 +1 @@
-{"version":3,"file":"errorToast.js","sourceRoot":"","sources":["../../../src/editor/client/errorToast.tsx"],"names":[],"mappings":"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"}
+{"version":3,"file":"errorToast.js","sourceRoot":"","sources":["../../../src/editor/client/errorToast.tsx"],"names":[],"mappings":"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"}

package/dist/editor/client/hooks/useEditorWebSocket.d.ts

@@ -1,6 +1,7 @@
 import { type Dispatch, type SetStateAction } from "react";
 import { type EditorSocketDiagnostics } from "../socketDiagnostics";
 export type ConcurrentUserLimitError = {
+    backendReachable: boolean;
     currentUsers: number;
     maxUsers: number;
     message: string;
@@ -10,11 +11,11 @@ export type ConcurrentUserLimitError = {
  * up. Used by recovery code that wants the freshly opened socket to re-issue agent
  * subscriptions via the existing onOpen callback chain — not for routine close handling.
  *
- * Returns whether a close was actually issued. The hook's close handler does NOT null
+ * Returns whether a reconnect was actually initiated. The hook's close handler does NOT null
  * `globalThis.editorSocket`; the next `connect()` call detects `readyState === CLOSED`
  * and overwrites the global, so we must not delete it from this helper. When the socket
- * is already CLOSING/CLOSED there is nothing to do — the hook will replace it on its next
- * scheduleReconnect tick.
+ * is missing or already CLOSING/CLOSED there is no close event to drive recovery, so we route
+ * through the hook's reconnect handler, which re-enters the connect path directly.
  */
 export declare function forceEditorSocketReconnect(reason: string): boolean;
 export declare function useEditorWebSocket(params: {

package/dist/editor/client/hooks/useEditorWebSocket.js

@@ -2,16 +2,30 @@ import { useEffect, useRef } from "react";
 import { checkConnectionAvailability, } from "../../services/editService";
 import { createEditorSocketDiagnostics, getEditorSocketReadyStateLabel, } from "../socketDiagnostics";
 import { createSseTransport, createWebSocketAdapter, ensureEditorRealtimeHandle, getEditorRealtime, setActiveTransport, setReconnectHandler, } from "../realtime/realtimeTransport";
+// Availability recheck cadence while the concurrent-user-limit latch is set. Deliberately slow:
+// the ConcurrentUserLimitDialog polls at 7.5s while open, so this timer only has to cover tabs
+// where the dialog was dismissed.
+const CONCURRENT_LIMIT_RECHECK_MS = 60_000;
+// While on the SSE fallback, how often to probe whether a WebSocket can be opened again. At
+// fallback time an app-pool recycle looks identical to a missing IIS WebSocket feature, so SSE
+// mode must not be permanent — but one probe per interval keeps genuinely WS-less environments
+// free of retry storms.
+const WS_REPROBE_INTERVAL_MS = 5 * 60_000;
+// A probe socket that has not reached OPEN within this window counts as failed.
+const WS_PROBE_TIMEOUT_MS = 5_000;
+// Used when the server rejects the connection without complete limit metadata; the dialog must
+// still appear or the tab has no recovery path besides a reload.
+const CONCURRENT_LIMIT_FALLBACK_MESSAGE = "The concurrent user limit for this license has been reached. Editing becomes available again once another user disconnects.";
 /**
  * Closes the active editor websocket so the hook's own reconnect machinery picks it back
  * up. Used by recovery code that wants the freshly opened socket to re-issue agent
  * subscriptions via the existing onOpen callback chain — not for routine close handling.
  *
- * Returns whether a close was actually issued. The hook's close handler does NOT null
+ * Returns whether a reconnect was actually initiated. The hook's close handler does NOT null
  * `globalThis.editorSocket`; the next `connect()` call detects `readyState === CLOSED`
  * and overwrites the global, so we must not delete it from this helper. When the socket
- * is already CLOSING/CLOSED there is nothing to do — the hook will replace it on its next
- * scheduleReconnect tick.
+ * is missing or already CLOSING/CLOSED there is no close event to drive recovery, so we route
+ * through the hook's reconnect handler, which re-enters the connect path directly.
  */
 export function forceEditorSocketReconnect(reason) {
     // In SSE fallback mode there is no globalThis.editorSocket; route through the transport handle,
@@ -22,10 +36,9 @@ export function forceEditorSocketReconnect(reason) {
         return true;
     }
     const socket = globalThis.editorSocket;
-    if (!socket)
-        return false;
-    if (socket.readyState === WebSocket.OPEN ||
-        socket.readyState === WebSocket.CONNECTING) {
+    if (socket &&
+        (socket.readyState === WebSocket.OPEN ||
+            socket.readyState === WebSocket.CONNECTING)) {
         try {
             socket.close(4000, reason);
             return true;
@@ -34,7 +47,8 @@ export function forceEditorSocketReconnect(reason) {
             return false;
         }
     }
-    return false;
+    realtime.reconnect(reason);
+    return true;
 }
 export function useEditorWebSocket(params) {
     const { sessionId, onMessage, onOpen, onError, onConcurrentUserLimit, onSessionRevoked, connectSocket, requestQuota, sendClientInfo, setSocketDiagnostics, enableWebSocketTransport = true, enableSseFallback = true, transportSettingsReady = true, } = params;
@@ -48,6 +62,12 @@ export function useEditorWebSocket(params) {
     const sseTransportRef = useRef(null);
     const hadOpenedRef = useRef(false);
     const fallbackTimerRef = useRef(null);
+    const limitRecheckTimerRef = useRef(null);
+    const sseReconnectTimeoutRef = useRef(null);
+    const sseReconnectAttemptsRef = useRef(0);
+    const wsReprobeTimerRef = useRef(null);
+    // Tears down an in-flight WebSocket probe (its socket and timeout); null when none is running.
+    const wsProbeCleanupRef = useRef(null);
     // Stable refs for callbacks to avoid re-connecting on every render
     const onMessageRef = useRef(onMessage);
     const onOpenRef = useRef(onOpen);
@@ -154,6 +174,178 @@ export function useEditorWebSocket(params) {
                 connect();
             }, delay);
         };
+        const startConnect = () => {
+            connect().catch((error) => {
+                console.error("Error in WebSocket connection:", error);
+                onErrorRef.current?.(new Event("error"));
+            });
+        };
+        const clearLimitRecheckTimer = () => {
+            if (limitRecheckTimerRef.current) {
+                clearTimeout(limitRecheckTimerRef.current);
+                limitRecheckTimerRef.current = null;
+            }
+        };
+        // While the concurrent-user-limit latch is set no close event will ever fire again, so this
+        // chained timeout (at most one check in flight) is the only automatic way back in once a
+        // seat frees up.
+        const scheduleLimitRecheck = () => {
+            if (disposed || limitRecheckTimerRef.current) {
+                return;
+            }
+            limitRecheckTimerRef.current = setTimeout(() => {
+                limitRecheckTimerRef.current = null;
+                if (disposed || !isConcurrentUserLimitRef.current) {
+                    return;
+                }
+                checkConnectionAvailability(sessionId)
+                    .then((availability) => {
+                    if (disposed || !isConcurrentUserLimitRef.current) {
+                        return;
+                    }
+                    if (availability.allowed) {
+                        isConcurrentUserLimitRef.current = false;
+                        reconnectAttemptsRef.current = 0;
+                        if (modeRef.current === "sse") {
+                            connectSse();
+                        }
+                        else {
+                            startConnect();
+                        }
+                        return;
+                    }
+                    scheduleLimitRecheck();
+                })
+                    .catch(() => {
+                    // Availability unknown (server restarting?) — keep polling.
+                    if (!disposed && isConcurrentUserLimitRef.current) {
+                        scheduleLimitRecheck();
+                    }
+                });
+            }, CONCURRENT_LIMIT_RECHECK_MS);
+        };
+        // The dialog (with its Retry button) must appear even when the availability response carries
+        // partial metadata — a latched limit without a visible dialog leaves no recovery path short
+        // of a reload.
+        const notifyConcurrentUserLimit = (availability) => {
+            isConcurrentUserLimitRef.current = true;
+            onConcurrentUserLimitRef.current?.({
+                backendReachable: availability.backendReachable ?? true,
+                currentUsers: availability.currentUsers ?? 0,
+                maxUsers: availability.maxUsers ?? 0,
+                message: availability.message ?? CONCURRENT_LIMIT_FALLBACK_MESSAGE,
+            });
+            scheduleLimitRecheck();
+        };
+        const clearSseReconnectTimer = () => {
+            if (sseReconnectTimeoutRef.current) {
+                clearTimeout(sseReconnectTimeoutRef.current);
+                sseReconnectTimeoutRef.current = null;
+            }
+        };
+        // EventSource retries transient drops on its own, but a hard failure (connection refused,
+        // non-200 while the server restarts) closes it permanently — the stream must be re-created
+        // by us, reusing the WebSocket backoff curve.
+        const scheduleSseReconnect = () => {
+            if (disposed ||
+                sseReconnectTimeoutRef.current ||
+                modeRef.current !== "sse") {
+                return;
+            }
+            const attempts = sseReconnectAttemptsRef.current;
+            const delay = Math.min(1000 * Math.pow(2, Math.min(attempts, 5)), 30000);
+            reconnectCountRef.current += 1;
+            markSocketEvent("reconnect-scheduled", null, {
+                reconnectCount: reconnectCountRef.current,
+            });
+            sseReconnectTimeoutRef.current = setTimeout(() => {
+                sseReconnectTimeoutRef.current = null;
+                sseReconnectAttemptsRef.current = attempts + 1;
+                connectSse();
+            }, delay);
+        };
+        const clearWsReprobeTimer = () => {
+            if (wsReprobeTimerRef.current) {
+                clearTimeout(wsReprobeTimerRef.current);
+                wsReprobeTimerRef.current = null;
+            }
+        };
+        // SSE mode is sticky by design (a missing IIS WebSocket feature never heals), but the same
+        // fallback also triggers on transient failures like an app-pool recycle — probe occasionally
+        // so those tabs find their way back to the preferred transport.
+        const startWsReprobeTimer = () => {
+            if (disposed || wsReprobeTimerRef.current || !wsEnabledRef.current) {
+                return;
+            }
+            wsReprobeTimerRef.current = setTimeout(() => {
+                wsReprobeTimerRef.current = null;
+                if (disposed || modeRef.current !== "sse") {
+                    return;
+                }
+                if (!isConcurrentUserLimitRef.current) {
+                    probeWebSocket();
+                }
+                startWsReprobeTimer();
+            }, WS_REPROBE_INTERVAL_MS);
+        };
+        // Opens a single throwaway WebSocket. Reaching OPEN proves the transport works again, so the
+        // editor switches back; anything else leaves SSE untouched. The probe carries none of the
+        // hook's listeners, so it must never be adopted as the real socket.
+        const probeWebSocket = () => {
+            if (disposed ||
+                modeRef.current !== "sse" ||
+                !wsEnabledRef.current ||
+                wsProbeCleanupRef.current) {
+                return;
+            }
+            let probe;
+            try {
+                probe = connectSocket(sessionId);
+            }
+            catch {
+                return;
+            }
+            let settled = false;
+            const settle = (opened) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                wsProbeCleanupRef.current = null;
+                clearTimeout(probeTimer);
+                try {
+                    probe.close();
+                }
+                catch {
+                    /* ignore */
+                }
+                if (opened && !disposed && modeRef.current === "sse") {
+                    switchBackToWebSocket();
+                }
+            };
+            const probeTimer = setTimeout(() => settle(false), WS_PROBE_TIMEOUT_MS);
+            wsProbeCleanupRef.current = () => settle(false);
+            probe.addEventListener("open", () => settle(true));
+            probe.addEventListener("close", () => settle(false));
+            probe.addEventListener("error", () => settle(false));
+        };
+        const switchBackToWebSocket = () => {
+            if (disposed) {
+                return;
+            }
+            clearWsReprobeTimer();
+            clearSseReconnectTimer();
+            sseTransportRef.current?.close();
+            sseTransportRef.current = null;
+            setActiveTransport(null);
+            modeRef.current = null;
+            // The probe reached OPEN, so this environment provably supports WebSockets; a later
+            // close-before-open must go through the retry path, not straight back to SSE.
+            hadOpenedRef.current = true;
+            reconnectAttemptsRef.current = 0;
+            sseReconnectAttemptsRef.current = 0;
+            startConnect();
+        };
         const attach = (socket, handler, reusedExistingSocket) => {
             if (disposed) {
                 return;
@@ -193,12 +385,13 @@ export function useEditorWebSocket(params) {
                 }
             }, 5000);
         };
-        // Establishes (or re-establishes) the SSE fallback transport for the rest of the page lifetime.
+        // Establishes (or re-establishes) the SSE fallback transport.
         const connectSse = () => {
             if (disposed)
                 return;
             modeRef.current = "sse";
             clearFallbackTimer();
+            clearSseReconnectTimer();
             if (reconnectTimeoutRef.current) {
                 clearTimeout(reconnectTimeoutRef.current);
                 reconnectTimeoutRef.current = null;
@@ -218,6 +411,8 @@ export function useEditorWebSocket(params) {
                     if (disposed)
                         return;
                     isConcurrentUserLimitRef.current = false;
+                    clearLimitRecheckTimer();
+                    sseReconnectAttemptsRef.current = 0;
                     markSocketEvent("open", null, {
                         lastOpenAt: new Date().toISOString(),
                         lastCloseCode: null,
@@ -239,24 +434,31 @@ export function useEditorWebSocket(params) {
                         lastErrorAt: new Date().toISOString(),
                     });
                     onErrorRef.current?.(event);
-                    // EventSource auto-reconnects on transient drops. Disambiguate a concurrent-user-limit
-                    // rejection (surface it) from a transient failure (let EventSource retry).
+                    // EventSource auto-reconnects on transient drops but stays CLOSED after a hard failure
+                    // (connection refused, non-200 while the server restarts). Capture the state before the
+                    // availability round-trip so a late response cannot mask it.
+                    const closedHard = sseTransportRef.current?.eventSource.readyState ===
+                        EventSource.CLOSED;
+                    // Disambiguate a concurrent-user-limit rejection (surface it) from a plain failure
+                    // (let EventSource retry transient drops; re-create the stream on hard closes).
                     checkConnectionAvailability(sessionId)
                         .then((availability) => {
-                        if (disposed || availability.allowed)
+                        if (disposed)
                             return;
-                        isConcurrentUserLimitRef.current = true;
-                        if (availability.currentUsers !== undefined &&
-                            availability.maxUsers !== undefined &&
-                            availability.message) {
-                            onConcurrentUserLimitRef.current?.({
-                                currentUsers: availability.currentUsers,
-                                maxUsers: availability.maxUsers,
-                                message: availability.message,
-                            });
+                        if (!availability.allowed) {
+                            notifyConcurrentUserLimit(availability);
+                            return;
+                        }
+                        if (closedHard) {
+                            scheduleSseReconnect();
                         }
                     })
-                        .catch(() => { });
+                        .catch(() => {
+                        // Availability unknown — a permanently closed stream still must be replaced.
+                        if (!disposed && closedHard) {
+                            scheduleSseReconnect();
+                        }
+                    });
                 },
                 onSessionRevoked: () => {
                     if (disposed)
@@ -269,12 +471,17 @@ export function useEditorWebSocket(params) {
             });
             sseTransportRef.current = sse;
             setActiveTransport(sse);
+            startWsReprobeTimer();
         };
         function fallbackToSse() {
             if (disposed || modeRef.current === "sse")
                 return;
-            if (!sseEnabledRef.current)
-                return; // SSE fallback disabled in settings.
+            if (!sseEnabledRef.current) {
+                // SSE fallback disabled in settings — keep retrying the WebSocket with backoff instead
+                // of leaving the tab without any transport.
+                scheduleReconnect(socketInstanceRef.current);
+                return;
+            }
             connectSse();
         }
         ensureEditorRealtimeHandle();
@@ -282,17 +489,32 @@ export function useEditorWebSocket(params) {
             if (disposed)
                 return;
             if (modeRef.current === "sse") {
+                // Re-establish the stream for recovery callers, and treat the explicit request as an
+                // opportunity to leave SSE mode if WebSockets have come back in the meantime.
                 connectSse();
+                probeWebSocket();
+                return;
             }
-            else {
-                const ws = globalThis.editorSocket;
+            const ws = globalThis.editorSocket;
+            if (ws &&
+                (ws.readyState === WebSocket.OPEN ||
+                    ws.readyState === WebSocket.CONNECTING)) {
                 try {
-                    ws?.close(4000, reason);
+                    ws.close(4000, reason);
                 }
                 catch {
                     /* ignore */
                 }
+                return;
             }
+            // No live socket to close (already CLOSED, or never created because a connect attempt
+            // latched) — no close event can drive recovery, so re-enter the connect path directly.
+            if (reconnectTimeoutRef.current) {
+                clearTimeout(reconnectTimeoutRef.current);
+                reconnectTimeoutRef.current = null;
+            }
+            reconnectAttemptsRef.current = 0;
+            startConnect();
         });
         const connect = async () => {
             if (disposed || modeRef.current === "sse")
@@ -309,18 +531,9 @@ export function useEditorWebSocket(params) {
                 if (disposed)
                     return;
                 if (!availability.allowed) {
-                    // Connection not allowed - likely concurrent user limit
-                    isConcurrentUserLimitRef.current = true;
-                    if (availability.currentUsers !== undefined &&
-                        availability.maxUsers !== undefined &&
-                        availability.message) {
-                        onConcurrentUserLimitRef.current?.({
-                            currentUsers: availability.currentUsers,
-                            maxUsers: availability.maxUsers,
-                            message: availability.message,
-                        });
-                    }
-                    // Don't attempt connection or retry for concurrent user limit
+                    // Concurrent user limit — don't attempt or retry the connection; the limit recheck
+                    // timer (and the dialog's Retry button) drive recovery from here.
+                    notifyConcurrentUserLimit(availability);
                     return;
                 }
                 // Reset the flag if connection is allowed
@@ -355,6 +568,7 @@ export function useEditorWebSocket(params) {
                     }
                     reconnectAttemptsRef.current = 0;
                     isConcurrentUserLimitRef.current = false;
+                    clearLimitRecheckTimer();
                     hadOpenedRef.current = true;
                     modeRef.current = "websocket";
                     clearFallbackTimer();
@@ -403,16 +617,7 @@ export function useEditorWebSocket(params) {
                             if (disposed)
                                 return;
                             if (!availability.allowed) {
-                                isConcurrentUserLimitRef.current = true;
-                                if (availability.currentUsers !== undefined &&
-                                    availability.maxUsers !== undefined &&
-                                    availability.message) {
-                                    onConcurrentUserLimitRef.current?.({
-                                        currentUsers: availability.currentUsers,
-                                        maxUsers: availability.maxUsers,
-                                        message: availability.message,
-                                    });
-                                }
+                                notifyConcurrentUserLimit(availability);
                                 return;
                             }
                             fallbackToSse();
@@ -423,18 +628,12 @@ export function useEditorWebSocket(params) {
                     if (shouldCheckAvailability) {
                         checkConnectionAvailability(sessionId)
                             .then((availability) => {
+                            if (disposed)
+                                return;
                             if (!availability.allowed) {
-                                isConcurrentUserLimitRef.current = true;
-                                if (availability.currentUsers !== undefined &&
-                                    availability.maxUsers !== undefined &&
-                                    availability.message) {
-                                    onConcurrentUserLimitRef.current?.({
-                                        currentUsers: availability.currentUsers,
-                                        maxUsers: availability.maxUsers,
-                                        message: availability.message,
-                                    });
-                                }
-                                return; // Don't retry
+                                // Don't retry — the limit recheck timer takes over.
+                                notifyConcurrentUserLimit(availability);
+                                return;
                             }
                             // Not a concurrent user limit issue, proceed with retry.
                             scheduleReconnect(socket);
@@ -480,10 +679,7 @@ export function useEditorWebSocket(params) {
             }
         };
         // Call async connect function
-        connect().catch((error) => {
-            console.error("Error in WebSocket connection:", error);
-            onErrorRef.current?.(new Event("error"));
-        });
+        startConnect();
         return () => {
             disposed = true;
             if (reconnectTimeoutRef.current) {
@@ -491,6 +687,11 @@ export function useEditorWebSocket(params) {
                 reconnectTimeoutRef.current = null;
             }
             clearFallbackTimer();
+            clearLimitRecheckTimer();
+            clearSseReconnectTimer();
+            clearWsReprobeTimer();
+            // Settles (and closes) any in-flight WebSocket probe together with its timeout.
+            wsProbeCleanupRef.current?.();
             setReconnectHandler(null);
             if (sseTransportRef.current) {
                 sseTransportRef.current.close();