@ttt-productions/chat-react 0.13.7 → 0.13.8

package/dist/realtime/channel-client.js

@@ -19,6 +19,7 @@ import { CLIENT_FRAME, CHAT_CLOSE_CODES, buildFrame, parseFrame, isInboxSnapshot
 import { wireRowToMessage, optimisticMessage, seqToMessageId, applyModerationOverlay, overlayFromRow, } from './map.js';
 import { createDiagnosticsEmitter, safeDiagnosticLabel, CHAT_CLIENT_DIAGNOSTIC_EVENTS as DIAG, } from './diagnostics.js';
 import { defaultTimers, isChatAccessDeniedError, isTerminalErrorCode, TERMINAL_ERROR_CODE, HEARTBEAT_MS, TYPING_COALESCE_MS, HISTORY_PAGE_MAX, MAX_PENDING_SEND_ATTEMPTS, PENDING_SEND_MAX_AGE_MS, SERVER_RETRYABLE_MAX_AGE_MS, SEND_RETRY_MIN_DELAY_MS, SEND_RETRY_MAX_DELAY_MS, } from './shared.js';
+import { InitialLoadBudget } from './initial-load-budget.js';
 const INITIAL = {
     status: 'idle',
     messages: [],
@@ -28,6 +29,7 @@ const INITIAL = {
     hasOlder: true,
     lastErrorCode: null,
     hasLoadedInitialData: false,
+    initialLoadFailed: false,
 };
 /**
  * Retryable error-frame code the channel DO sends when a send arrives BEFORE the
@@ -99,6 +101,15 @@ export class ChannelClient {
     /** Single scheduled re-send for the membership-pending window (never stacks). */
     membershipRetryTimer = null;
     closedByUs = false;
+    /**
+     * The current lifecycle's number, advanced by every `connect()` and `close()`. A grant
+     * that resolves, or a timer that fires, for an older lifecycle is dropped — so a
+     * close → connect while an earlier grant is still minting can never open a second
+     * socket or touch the new lifecycle's state (FRONTEND-108).
+     */
+    lifecycle = 0;
+    /** Reports the first open as failed once its attempts have failed for the budget. */
+    initialLoad;
     /**
      * Per-seq moderation overlay (the max-revision wins). A `revision` frame writes
      * here keyed by `messageSeq` so it applies whether it arrives BEFORE its base
@@ -138,6 +149,7 @@ export class ChannelClient {
         this.timers = config.timers ?? defaultTimers;
         this.controller = createReconnectController(config.reconnect ?? {});
         this.diag = createDiagnosticsEmitter(config.diagnostics);
+        this.initialLoad = new InitialLoadBudget(this.timers, () => this.reportInitialLoadFailed());
     }
     // ---- observable store ----
     getState() {
@@ -154,6 +166,37 @@ export class ChannelClient {
     }
     // ---- connection lifecycle ----
     async connect() {
+        return this.startLifecycle(true);
+    }
+    /**
+     * Retry now (the first-open failure's Retry). While a reconnect is waiting out its
+     * backoff, the wait is cancelled and a socket opens at once; a lifecycle that stopped
+     * (reconnect gave up, or the socket was revoked) starts again; an attempt already in
+     * flight is left to finish. Either way the first-open failure clears, so the opening state
+     * shows while the retry runs. The spent budget stays spent: a retry that fails is reported
+     * again at once, and one that hangs a full budget later.
+     */
+    retryNow() {
+        if (!this.state.hasLoadedInitialData)
+            this.initialLoad.manualRetry();
+        if (this.state.status === 'closed') {
+            void this.startLifecycle(false);
+            return;
+        }
+        if (this.reconnectTimer == null) {
+            if (this.state.initialLoadFailed)
+                this.setState({ initialLoadFailed: false });
+            return;
+        }
+        this.timers.clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        this.controller.reset();
+        this.controller.start();
+        this.reconnectCause = 'manual-retry';
+        this.setState({ status: 'reconnecting', initialLoadFailed: false });
+        void this.openSocket();
+    }
+    async startLifecycle(freshBudget) {
         // Idempotency guard (C-B7): connect() only starts a lifecycle from a fresh
         // (idle) or fully torn-down (closed) state. A second connect() while one is
         // already connecting / open / reconnecting is a no-op, so a stray double-owner
@@ -180,12 +223,27 @@ export class ChannelClient {
         if (isTerminalErrorCode(this.state.lastErrorCode))
             this.setState({ lastErrorCode: null });
         this.closedByUs = false;
+        this.lifecycle += 1;
         this.reconnectCause = 'initial';
+        if (!this.state.hasLoadedInitialData)
+            this.initialLoad.begin(freshBudget);
         this.controller.start();
-        this.setState({ status: 'connecting' });
+        this.setState({ status: 'connecting', initialLoadFailed: false });
         await this.openSocket();
     }
+    /** The first open has failed for long enough to say so (see `initialLoadFailed`). */
+    reportInitialLoadFailed() {
+        if (this.state.hasLoadedInitialData || this.state.initialLoadFailed)
+            return;
+        this.setState({ initialLoadFailed: true });
+    }
+    /** The first authoritative data is applied; it ends any first-open failure. */
+    initialDataLoaded() {
+        this.initialLoad.loaded();
+        return { hasLoadedInitialData: true, initialLoadFailed: false };
+    }
     async openSocket() {
+        const lifecycle = this.lifecycle;
         this.connectAttempt += 1;
         this.diag?.(DIAG.CONNECT_ATTEMPT, {
             attempt: this.connectAttempt,
@@ -199,6 +257,9 @@ export class ChannelClient {
             grantToken = await this.config.grantProvider();
         }
         catch (err) {
+            // A grant for a lifecycle that has since been closed or restarted answers nobody.
+            if (lifecycle !== this.lifecycle)
+                return;
             // A TERMINAL access denial (the app's grant provider translated an
             // authoritative policy "no" into the package-owned ChatAccessDeniedError)
             // must NOT reconnect — the next mint would just re-deny, stranding the shell
@@ -210,24 +271,44 @@ export class ChannelClient {
             if (terminal)
                 return this.denyAccessTerminally();
             this.reconnectCause = 'grant-error';
+            if (!this.state.hasLoadedInitialData)
+                this.initialLoad.noteFailedAttempt();
             return this.scheduleReconnect();
         }
-        if (this.closedByUs)
+        // A grant minted for an earlier lifecycle must never open a socket in this one.
+        if (lifecycle !== this.lifecycle || this.closedByUs)
             return;
         // Socket REPLACEMENT: the previous socket's liveness record dies with it, so
         // the watchdog never judges a new socket against an old deadline.
         this.lastInboundAt = null;
         const url = `${this.config.endpoint.replace(/\/$/, '')}/channel`;
-        this.socket = this.config.socketFactory({
+        // Every callback is fenced to THIS socket: once it has been replaced or torn down,
+        // its late open, frames, and close are ignored.
+        let socket = null;
+        const isCurrent = () => socket !== null && this.socket === socket;
+        socket = this.config.socketFactory({
             url,
             grantToken,
             handlers: {
-                onOpen: () => this.onOpen(),
-                onMessage: (data) => this.onMessage(data),
-                onClose: (code, reason) => this.onClose(code, reason),
-                onError: () => this.onError(),
+                onOpen: () => {
+                    if (isCurrent())
+                        this.onOpen();
+                },
+                onMessage: (data) => {
+                    if (isCurrent())
+                        this.onMessage(data);
+                },
+                onClose: (code, reason) => {
+                    if (isCurrent())
+                        this.onClose(code, reason);
+                },
+                onError: () => {
+                    if (isCurrent())
+                        this.onError();
+                },
             },
         });
+        this.socket = socket;
     }
     onOpen() {
         this.controller.onOpen();
@@ -575,6 +656,9 @@ export class ChannelClient {
         this.socket = null;
         this.lastInboundAt = null;
         this.lastCloseCode = code;
+        // An older-history request in flight died with the socket; nothing will answer it.
+        if (this.state.isFetchingOlder)
+            this.setState({ isFetchingOlder: false });
         if (this.closedByUs) {
             this.diag?.(DIAG.SOCKET_CLOSE, { code, closedByUs: true, outcome: 'closed', resumeSeq: this.resumeSeq });
             this.setState({ status: 'closed' });
@@ -599,9 +683,13 @@ export class ChannelClient {
             this.diag?.(DIAG.SOCKET_CLOSE, { code, closedByUs: false, outcome: 'revoked', resumeSeq: this.resumeSeq });
             this.failAllPendingSends();
             this.setState({ status: 'closed', lastErrorCode: TERMINAL_ERROR_CODE.REVOKED });
+            // Revoked before anything loaded: the first open has failed, and nothing retries it.
+            this.reportInitialLoadFailed();
             return;
         }
         this.reconnectCause = 'transient-close';
+        if (!this.state.hasLoadedInitialData)
+            this.initialLoad.noteFailedAttempt();
         this.diag?.(DIAG.SOCKET_CLOSE, { code, closedByUs: false, outcome: 'reconnect', resumeSeq: this.resumeSeq });
         this.scheduleReconnect();
     }
@@ -618,12 +706,15 @@ export class ChannelClient {
             // an eternal "Sending…"; flip them to the visible failed/retry state.
             this.failAllPendingSends();
             this.setState({ status: 'closed' });
+            // Gave up before anything loaded: nothing retries the first open any more.
+            this.reportInitialLoadFailed();
             return;
         }
         this.setState({ status: 'reconnecting' });
+        const lifecycle = this.lifecycle;
         this.reconnectTimer = this.timers.setTimeout(() => {
             this.reconnectTimer = null;
-            if (this.closedByUs)
+            if (this.closedByUs || lifecycle !== this.lifecycle)
                 return;
             void this.openSocket();
         }, delay);
@@ -640,6 +731,7 @@ export class ChannelClient {
     denyAccessTerminally() {
         this.closedByUs = true;
         this.controller.close();
+        this.initialLoad.dispose();
         this.failAllPendingSends();
         this.setState({ status: 'closed', lastErrorCode: TERMINAL_ERROR_CODE.ACCESS_DENIED });
     }
@@ -838,7 +930,7 @@ export class ChannelClient {
             // caught up) — end initial loading. A resync snapshot instead defers to the
             // re-paged first history page below, so it must NOT end it here.
             if (!this.state.hasLoadedInitialData)
-                this.setState({ hasLoadedInitialData: true });
+                this.setState(this.initialDataLoaded());
             return;
         }
         // Resync: drop the local tail and re-page from the top per the pinned contract.
@@ -1003,9 +1095,9 @@ export class ChannelClient {
             isFetchingOlder: false,
             hasOlder: rows.length >= HISTORY_PAGE_MAX,
             // The first history page — INCLUDING an empty one — is a successful authoritative
-            // load, so it ends initial loading. (Older-page fetches redundantly re-set true,
-            // which is a harmless no-op since the flag never flips back to false.)
-            hasLoadedInitialData: true,
+            // load, so it ends initial loading. An older page arrives only after it, so this
+            // never runs a second time.
+            ...(this.state.hasLoadedInitialData ? {} : this.initialDataLoaded()),
         });
         if (!this.diag)
             return;
@@ -1126,11 +1218,14 @@ export class ChannelClient {
         const oldest = this.state.messages.find((m) => typeof m.meta?.seq === 'number');
         const beforeSeq = oldest && typeof oldest.meta?.seq === 'number' ? oldest.meta.seq : null;
         this.setState({ isFetchingOlder: true });
-        this.requestHistory(beforeSeq);
+        // Unsent (the socket is down): nothing will answer, so it is not in flight.
+        if (!this.requestHistory(beforeSeq))
+            this.setState({ isFetchingOlder: false });
     }
     requestHistory(beforeSeq) {
         const sent = this.sendFrame(CLIENT_FRAME.HISTORY, { beforeSeq, limit: HISTORY_PAGE_MAX });
         this.diag?.(DIAG.HISTORY_REQUEST, { beforeSeq, limit: HISTORY_PAGE_MAX, sent });
+        return sent;
     }
     // ---- heartbeat (20s) + dead-socket watchdog ----
     startHeartbeat() {
@@ -1187,7 +1282,9 @@ export class ChannelClient {
     /** Permanently close this client (auth-user switch / unmount). Idempotent. */
     close() {
         this.closedByUs = true;
+        this.lifecycle += 1;
         this.controller.close();
+        this.initialLoad.dispose();
         this.stopHeartbeat();
         // The heartbeat timer IS the watchdog's timer — stopping it above ends both.
         // Clearing the record too means a later connect() starts from a clean deadline.
@@ -1210,10 +1307,12 @@ export class ChannelClient {
             this.membershipRetryTimer = null;
         }
         if (this.socket) {
-            this.socket.close(1000, 'client teardown');
+            // Detach first: the socket's own late close is not this lifecycle's event.
+            const socket = this.socket;
             this.socket = null;
+            socket.close(1000, 'client teardown');
         }
-        this.setState({ status: 'closed', typing: [], presence: [] });
+        this.setState({ status: 'closed', typing: [], presence: [], isFetchingOlder: false });
     }
 }
 function sortBySeq(a, b) {