@ttt-productions/chat-react 0.13.15 → 0.13.16

package/dist/realtime/channel-client.js

@@ -14,11 +14,12 @@
 //   - error codes incl. 4401 AUTH_EXPIRED -> re-mint a grant ONCE via grantProvider
 //
 // Timers are injected (setTimeout/clearTimeout/now) so tests run deterministically.
-import { createReconnectController } from '@ttt-productions/realtime-core';
-import { CLIENT_FRAME, CHAT_CLOSE_CODES, buildFrame, parseFrame, isInboxSnapshot, ChatSendRejectedPayloadSchema, } from './wire.js';
+import { createReconnectController, } from '@ttt-productions/realtime-core';
+import { CLIENT_KINDS, CHAT_CLOSE_CODES, ChatSendRejectedPayloadSchema, HEARTBEAT_MS, TYPING_COALESCE_MS, HISTORY_PAGE_MAX, } from '@ttt-productions/chat-schemas';
+import { buildFrame, parseFrame, isInboxSnapshot, } from './wire.js';
 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 { defaultTimers, isChatAccessDeniedError, isTerminalErrorCode, TERMINAL_ERROR_CODE, 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',
@@ -335,15 +336,15 @@ export class ChannelClient {
         // Resume: ask the DO for the authoritative snapshot, then live deltas flow. The
         // field name MUST be `afterSeq` — the Channel DO reads `payload.afterSeq`; any other
         // name reads as cursorless and forces a full resync every reconnect.
-        this.sendFrame(CLIENT_FRAME.RESUME, { afterSeq: this.resumeSeq });
+        this.sendFrame(CLIENT_KINDS.RESUME, { afterSeq: this.resumeSeq });
         this.diag?.(DIAG.RESUME_REQUEST, { afterSeq: this.resumeSeq, attempt: this.connectAttempt });
         // If the UI had presence open, re-subscribe after a reconnect.
         if (this.presenceSubscribed)
-            this.sendFrame(CLIENT_FRAME.PRESENCE_SUBSCRIBE, {});
+            this.sendFrame(CLIENT_KINDS.PRESENCE_SUBSCRIBE, {});
         // Re-send the last read cursor so a read-ack dropped during the disconnect window
         // (sendFrame returns false on a closed socket) is not lost until the next message.
         if (this.lastReadAck)
-            this.sendFrame(CLIENT_FRAME.READ_ACK, { ...this.lastReadAck });
+            this.sendFrame(CLIENT_KINDS.READ_ACK, { ...this.lastReadAck });
         // Re-send every un-acked pending send with its ORIGINAL clientMessageId so a send
         // that lost its socket before the ack is not silently dropped. The DO dedups
         // (re-acks, no re-broadcast, no flood-token) — this is the client half of the
@@ -390,7 +391,7 @@ export class ChannelClient {
                     continue;
                 }
             }
-            const sent = this.sendFrame(CLIENT_FRAME.SEND, {
+            const sent = this.sendFrame(CLIENT_KINDS.SEND, {
                 clientMessageId: pending.clientMessageId,
                 text: pending.text,
             });
@@ -501,7 +502,10 @@ export class ChannelClient {
             if (typeof rawId === 'string' && rawId.length > 0 && rawId.length <= 200) {
                 const orphaned = this.pendingSends.get(rawId);
                 if (orphaned && !orphaned.failed) {
-                    this.diag?.(DIAG.SEND_REJECTED, { clientMessageId: rawId, outcome: 'unparseable-fail-closed' });
+                    this.diag?.(DIAG.SEND_REJECTED, {
+                        clientMessageId: rawId,
+                        outcome: 'unparseable-fail-closed',
+                    });
                     this.failPendingSend(rawId);
                     return;
                 }
@@ -514,13 +518,23 @@ export class ChannelClient {
         // No matching pending send — already acked/reconciled, or never ours. A late
         // ack/echo (which may have already landed) always wins; nothing to correlate.
         if (!pending || pending.failed) {
-            this.diag?.(DIAG.SEND_REJECTED, { clientMessageId, code, retryable, outcome: 'no-pending-send' });
+            this.diag?.(DIAG.SEND_REJECTED, {
+                clientMessageId,
+                code,
+                retryable,
+                outcome: 'no-pending-send',
+            });
             return;
         }
         if (!retryable) {
             // Terminal: an unchanged resend cannot succeed (blocked-word / archived /
             // deleted). Fail ONLY this bubble, recording the reason + terminal class.
-            this.diag?.(DIAG.SEND_REJECTED, { clientMessageId, code, retryable: false, outcome: 'terminal' });
+            this.diag?.(DIAG.SEND_REJECTED, {
+                clientMessageId,
+                code,
+                retryable: false,
+                outcome: 'terminal',
+            });
             this.failPendingSend(clientMessageId, code, false);
             return;
         }
@@ -532,12 +546,23 @@ export class ChannelClient {
         // If the budget already elapsed (a long stream of retryable rejections), fail
         // now rather than scheduling yet another doomed resend.
         if (this.timers.now() - pending.sentAt >= SERVER_RETRYABLE_MAX_AGE_MS) {
-            this.diag?.(DIAG.SEND_REJECTED, { clientMessageId, code, retryable: true, outcome: 'budget-exhausted' });
+            this.diag?.(DIAG.SEND_REJECTED, {
+                clientMessageId,
+                code,
+                retryable: true,
+                outcome: 'budget-exhausted',
+            });
             this.failPendingSend(clientMessageId, code, true);
             return;
         }
         const delayMs = this.clampRetryDelay(retryAfterMs);
-        this.diag?.(DIAG.SEND_REJECTED, { clientMessageId, code, retryable: true, outcome: 'retry-scheduled', delayMs });
+        this.diag?.(DIAG.SEND_REJECTED, {
+            clientMessageId,
+            code,
+            retryable: true,
+            outcome: 'retry-scheduled',
+            delayMs,
+        });
         this.scheduleSendRetry(clientMessageId, delayMs);
     }
     /**
@@ -564,7 +589,7 @@ export class ChannelClient {
             }
             // A server-retryable resend does NOT count toward the attempt cap (that cap is
             // for blind reconnect resends only) — leave `attempts` untouched.
-            const sent = this.sendFrame(CLIENT_FRAME.SEND, {
+            const sent = this.sendFrame(CLIENT_KINDS.SEND, {
                 clientMessageId: current.clientMessageId,
                 text: current.text,
             });
@@ -581,7 +606,9 @@ export class ChannelClient {
             // contract violation), NOTHING else would ever re-check the budget on a
             // stable socket — so arm a deadline check that fails the send at budget end.
             // This makes SERVER_RETRYABLE_MAX_AGE_MS a hard ceiling, not a best effort.
-            const remainingMs = SERVER_RETRYABLE_MAX_AGE_MS - (this.timers.now() - current.sentAt) + SEND_RETRY_MIN_DELAY_MS;
+            const remainingMs = SERVER_RETRYABLE_MAX_AGE_MS -
+                (this.timers.now() - current.sentAt) +
+                SEND_RETRY_MIN_DELAY_MS;
             current.retryTimer = this.timers.setTimeout(() => {
                 current.retryTimer = null;
                 if (this.closedByUs)
@@ -632,7 +659,7 @@ export class ChannelClient {
         pending.serverRetryable = false;
         pending.lastRejectionCode = undefined;
         pending.sentAt = this.timers.now();
-        const sent = this.sendFrame(CLIENT_FRAME.SEND, {
+        const sent = this.sendFrame(CLIENT_KINDS.SEND, {
             clientMessageId: pending.clientMessageId,
             text: pending.text,
         });
@@ -646,7 +673,9 @@ export class ChannelClient {
             sent,
         });
         const next = this.state.messages.map((m) => {
-            if (!(m.meta?.optimistic && m.meta?.clientMessageId === clientMessageId && m.meta?.sendFailed)) {
+            if (!(m.meta?.optimistic &&
+                m.meta?.clientMessageId === clientMessageId &&
+                m.meta?.sendFailed)) {
                 return m;
             }
             // Back to the normal pending look — drop every failure marker.
@@ -668,7 +697,12 @@ export class ChannelClient {
         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.diag?.(DIAG.SOCKET_CLOSE, {
+                code,
+                closedByUs: true,
+                outcome: 'closed',
+                resumeSeq: this.resumeSeq,
+            });
             this.setState({ status: 'closed' });
             return;
         }
@@ -676,7 +710,12 @@ export class ChannelClient {
         if (code === CHAT_CLOSE_CODES.AUTH_EXPIRED && !this.reauthAttempted) {
             this.reauthAttempted = true;
             this.reconnectCause = 'auth-expired';
-            this.diag?.(DIAG.SOCKET_CLOSE, { code, closedByUs: false, outcome: 're-grant', resumeSeq: this.resumeSeq });
+            this.diag?.(DIAG.SOCKET_CLOSE, {
+                code,
+                closedByUs: false,
+                outcome: 're-grant',
+                resumeSeq: this.resumeSeq,
+            });
             this.setState({ status: 'reconnecting' });
             void this.openSocket();
             return;
@@ -688,7 +727,12 @@ export class ChannelClient {
         if (code === CHAT_CLOSE_CODES.REVOKED) {
             this.closedByUs = true;
             this.controller.close();
-            this.diag?.(DIAG.SOCKET_CLOSE, { code, closedByUs: false, outcome: 'revoked', resumeSeq: this.resumeSeq });
+            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.
@@ -698,7 +742,12 @@ export class ChannelClient {
         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.diag?.(DIAG.SOCKET_CLOSE, {
+            code,
+            closedByUs: false,
+            outcome: 'reconnect',
+            resumeSeq: this.resumeSeq,
+        });
         this.scheduleReconnect();
     }
     scheduleReconnect() {
@@ -815,7 +864,10 @@ export class ChannelClient {
                 return;
             default:
                 // unknown/optional types tolerated (forward compat)
-                this.diag?.(DIAG.FRAME_DROPPED, { kind: safeDiagnosticLabel(frame.type), reason: 'unknown-type' });
+                this.diag?.(DIAG.FRAME_DROPPED, {
+                    kind: safeDiagnosticLabel(frame.type),
+                    reason: 'unknown-type',
+                });
                 return;
         }
     }
@@ -937,7 +989,10 @@ export class ChannelClient {
             // A non-resync snapshot IS the first authoritative data (even an empty delta =
             // 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.
-            this.setState({ ...(this.state.hasLoadedInitialData ? {} : this.initialDataLoaded()), isSynced: true });
+            this.setState({
+                ...(this.state.hasLoadedInitialData ? {} : this.initialDataLoaded()),
+                isSynced: true,
+            });
             return;
         }
         // Resync: drop the local tail and re-page from the top per the pinned contract.
@@ -999,7 +1054,11 @@ export class ChannelClient {
             seq: row.seq,
             hasClientMessageId: Boolean(row.clientMessageId),
             moderationKind: row.moderationKind ?? null,
-            op: prior.reconciledOptimistic ? 'optimistic-reconcile' : prior.hadRow ? 'replace-by-seq' : 'insert',
+            op: prior.reconciledOptimistic
+                ? 'optimistic-reconcile'
+                : prior.hadRow
+                    ? 'replace-by-seq'
+                    : 'insert',
             cursorBefore,
             cursorAfter: this.resumeSeq,
         });
@@ -1062,7 +1121,11 @@ export class ChannelClient {
             // correlated rejection was superseded) means the send actually landed, so the
             // row must render as delivered, not failed.
             const { sendFailed: _sendFailed, sendFailureCode: _sendFailureCode, sendRetryable: _sendRetryable, ...restMeta } = m.meta;
-            return { ...m, messageId: seqToMessageId(seq), meta: { ...restMeta, optimistic: false, seq } };
+            return {
+                ...m,
+                messageId: seqToMessageId(seq),
+                meta: { ...restMeta, optimistic: false, seq },
+            };
         });
         next.sort(sortBySeq);
         if (seq > this.resumeSeq)
@@ -1089,7 +1152,9 @@ export class ChannelClient {
         }
         const bySeq = new Map();
         for (const m of this.state.messages) {
-            if (m.meta?.optimistic && typeof m.meta?.clientMessageId === 'string' && incomingCmids.has(m.meta.clientMessageId)) {
+            if (m.meta?.optimistic &&
+                typeof m.meta?.clientMessageId === 'string' &&
+                incomingCmids.has(m.meta.clientMessageId)) {
                 continue; // reconciled by the incoming server row
             }
             bySeq.set(m.messageId, m);
@@ -1153,7 +1218,7 @@ export class ChannelClient {
         // actually sent over an open socket. A closed socket returns false — no phantom
         // "sent" bubble, and the caller keeps the composer text — so a disconnect between
         // render and click can't silently swallow the message.
-        const sent = this.sendFrame(CLIENT_FRAME.SEND, {
+        const sent = this.sendFrame(CLIENT_KINDS.SEND, {
             clientMessageId: args.clientMessageId,
             text: args.text,
         });
@@ -1203,7 +1268,7 @@ export class ChannelClient {
      */
     readAck(readSeq, focused) {
         this.lastReadAck = { readSeq, focused };
-        return this.sendFrame(CLIENT_FRAME.READ_ACK, { readSeq, focused });
+        return this.sendFrame(CLIENT_KINDS.READ_ACK, { readSeq, focused });
     }
     /** Coalesced typing signal: at most one frame per TYPING_COALESCE_MS. */
     typing() {
@@ -1211,15 +1276,15 @@ export class ChannelClient {
         if (now - this.lastTypingSentAt < TYPING_COALESCE_MS)
             return;
         this.lastTypingSentAt = now;
-        this.sendFrame(CLIENT_FRAME.TYPING, {});
+        this.sendFrame(CLIENT_KINDS.TYPING, {});
     }
     presenceSubscribe() {
         this.presenceSubscribed = true;
-        this.sendFrame(CLIENT_FRAME.PRESENCE_SUBSCRIBE, {});
+        this.sendFrame(CLIENT_KINDS.PRESENCE_SUBSCRIBE, {});
     }
     presenceUnsubscribe() {
         this.presenceSubscribed = false;
-        this.sendFrame(CLIENT_FRAME.PRESENCE_UNSUBSCRIBE, {});
+        this.sendFrame(CLIENT_KINDS.PRESENCE_UNSUBSCRIBE, {});
         this.setState({ presence: [] });
     }
     /** Fetch the page of history older than the oldest loaded message (epoch-aware by seq). */
@@ -1234,7 +1299,7 @@ export class ChannelClient {
             this.setState({ isFetchingOlder: false });
     }
     requestHistory(beforeSeq, kind) {
-        const sent = this.sendFrame(CLIENT_FRAME.HISTORY, { beforeSeq, limit: HISTORY_PAGE_MAX });
+        const sent = this.sendFrame(CLIENT_KINDS.HISTORY, { beforeSeq, limit: HISTORY_PAGE_MAX });
         if (sent)
             this.historyRequests.push(kind);
         this.diag?.(DIAG.HISTORY_REQUEST, { beforeSeq, limit: HISTORY_PAGE_MAX, sent });
@@ -1251,7 +1316,7 @@ export class ChannelClient {
             // stops the heartbeat and owns what happens next.
             if (this.isInboundSilent())
                 return this.closeDeadSocket();
-            this.sendFrame(CLIENT_FRAME.HEARTBEAT, {});
+            this.sendFrame(CLIENT_KINDS.HEARTBEAT, {});
             this.heartbeatTimer = this.timers.setTimeout(tick, HEARTBEAT_MS);
         };
         this.heartbeatTimer = this.timers.setTimeout(tick, HEARTBEAT_MS);