@supalive/core 0.1.4 → 0.1.5

package/dist/src/client/ws_client_manager.js

@@ -1,1013 +0,0 @@
-// ─── Client WebSocket Manager ─────────────────────────────────────────────────
-//
-// Manages a WebSocket connection to the server and handles:
-// - Connection lifecycle (connect, auth, reconnect)
-// - Connection ID management with localStorage persistence
-// - Request/response matching via request IDs
-// - Subscription management with callbacks
-// - Message encoding/decoding
-// - Queued calls when not connected (FIFO, flushed on reconnect)
-// - Pending in-flight calls are re-queued (not rejected) on transport drop
-//   so they re-issue on the next successful connect.
-// - Auto re-subscribe of live queries after reconnect
-// - Passive server-inactivity watchdog: the client never sends a ping; the
-//   server emits `{type:"ping"}` while idle and we close+reconnect after
-//   `serverInactivityMs` of total silence.
-//
-// Subscription identity is server-driven: the client sends `subscribe` with
-// (procedure, input) and the server replies with the canonical `subId` on
-// the response.
-import { ServerMessageSchema } from "../db/types_client_rpc";
-import { computeLocalSubKey, prewarmHasher } from "./sub_key";
-import { supaliveStringify } from "../helper";
-// readyState 1 = OPEN in both environments.
-const WS_OPEN = 1;
-export class RPCError extends Error {
-    code;
-    constructor(message, code) {
-        super(message);
-        this.name = "RPCError";
-        this.code = code;
-    }
-}
-export class WsClientManager {
-    ws = null;
-    options;
-    lastSuccessfulConnectionTime = 0;
-    reconnectionTimeout;
-    requestId = 0;
-    pendingRequests = new Map();
-    /**
-     * Single source of truth for live subscriptions.
-     *
-     * Keying:
-     *   - In-flight subscribe (no subId yet): `_pending:<requestId>`.
-     *   - Established: the server-returned canonical `subId`.
-     *
-     * Routing `sub:update` / `sub:gone` is O(1) (`get(subId)`). Subscribe-time
-     * dedup scans `values()` for a matching `localKey` (O(N)), which is cheap
-     * since subscribes happen on component mounts, not in the hot path.
-     */
-    subscriptions = new Map();
-    queuedCalls = [];
-    reconnectAttempts = 0;
-    reconnectTimer = null;
-    connectionState = "disconnected";
-    authState = "pending";
-    /**
-     * Authenticated user id from `auth:success`. Distinct from `queryIdentity`
-     * (server-side cache/sub segmentation key); this is just "who am I logged
-     * in as" for app display purposes. Null while unauthenticated / anonymous.
-     */
-    authUserId = null;
-    explicitlyClosed = false;
-    stateListeners = new Set();
-    lastPublicState = "disconnected";
-    // ─── Inactivity watchdog (passive — server drives pings) ─────────────────
-    serverInactivityMs;
-    lastServerMessageAt = 0;
-    inactivityTimer = null;
-    // ─── Pending connect() promise ──────────────────────────────────────────
-    //
-    // Tracked on `this` so paths outside the `connect()` closure (the watchdog
-    // firing during the connecting window, the OS-level close handler, the
-    // reconnect-exhaustion drain) can settle the caller's awaiting promise
-    // rather than leaving it suspended. Each setter wraps the underlying
-    // resolve/reject with a one-shot guard so we can call freely; subsequent
-    // calls are no-ops.
-    pendingConnectResolve = null;
-    pendingConnectReject = null;
-    // ─── Send throttle ──────────────────────────────────────────────────────
-    //
-    // The first `throttleEveryN` calls in a quiet window dispatch directly.
-    // The N+1th call flips `throttling = true` and any subsequent call is
-    // parked on `queuedCalls`. A single async loop drains the queue in
-    // batches of up to `throttleEveryN`, sleeping `throttleDelayMs` between
-    // batches, and exits as soon as the queue drains in a single batch
-    // (burst over → back to direct-dispatch mode).
-    throttleEveryN;
-    throttleDelayMs;
-    throttleCounter = 0;
-    throttling = false;
-    // ─── Browser env listeners ──────────────────────────────────────────────
-    visibilityListener = null;
-    onlineListener = null;
-    constructor(options) {
-        this.options = {
-            reconnectionTimeout: 180000, // 3 minutes default
-            reconnect: {
-                enabled: true,
-                maxAttempts: 5,
-                delay: 1000,
-                backoff: 1.5,
-                ...options.reconnect,
-            },
-            ...options,
-        };
-        this.reconnectionTimeout = this.options.reconnectionTimeout;
-        this.serverInactivityMs = options.heartbeat?.serverInactivityMs ?? 60_000;
-        this.throttleEveryN = options.throttle?.everyN ?? 100;
-        this.throttleDelayMs = options.throttle?.delayMs ?? 10;
-        this.installEnvironmentListeners();
-        // Fire and forget: warm the wasm hash module so the first subscribe
-        // isn't billed for the ~5–10ms wasm bootstrap. Swallow rejections —
-        // the lazy path inside `computeLocalSubKey` will surface any real
-        // wasm failure on the first actual subscribe.
-        prewarmHasher().catch(() => { });
-    }
-    /**
-     * Subscribe to client state transitions. Returns an unsubscribe fn.
-     * The listener is called immediately with the current state.
-     */
-    onState(listener) {
-        this.stateListeners.add(listener);
-        listener(this.computePublicState());
-        return () => {
-            this.stateListeners.delete(listener);
-        };
-    }
-    /** Current public state. */
-    getPublicState() {
-        return this.computePublicState();
-    }
-    /**
-     * Connect to the WebSocket server.
-     * Returns a promise that resolves when connected and authenticated.
-     */
-    async connect() {
-        this.explicitlyClosed = false;
-        if (this.connectionState == "connected" || this.connectionState == "connecting") {
-            return;
-        }
-        this.connectionState = "connecting";
-        this.emitState();
-        return new Promise(async (resolve, reject) => {
-            // One-shot guards. Whichever side fires first nulls both slots so
-            // later callers (e.g. handleClose after a successful auth) are no-ops.
-            this.pendingConnectResolve = () => {
-                this.pendingConnectResolve = null;
-                this.pendingConnectReject = null;
-                resolve();
-            };
-            this.pendingConnectReject = (err) => {
-                this.pendingConnectResolve = null;
-                this.pendingConnectReject = null;
-                reject(err);
-            };
-            try {
-                const WS = await getWebSocket();
-                const url = new URL(this.options.url);
-                const ws = new WS(url.toString());
-                this.ws = ws;
-                ws.onopen = () => {
-                    // Arm the inactivity watchdog the moment the upgrade completes.
-                    // If the server stalls and never sends `connected`, the watchdog
-                    // fires at `serverInactivityMs` and forces a reconnect instead
-                    // of leaving the client wedged in "connecting" forever.
-                    // `handleMessage` keeps the timestamp fresh on every inbound
-                    // frame, including the `connected` JSON itself.
-                    this.startInactivityWatchdog();
-                };
-                ws.onmessage = (event) => {
-                    const data = typeof event.data === "string" ? event.data : event.data.toString();
-                    this.handleMessage(data);
-                };
-                ws.onclose = () => {
-                    this.handleClose();
-                };
-                ws.onerror = (err) => {
-                    const error = err instanceof Error ? err : new Error(`WebSocket error: `, { cause: err });
-                    this.handleError(error);
-                    this.pendingConnectReject?.(error);
-                };
-            }
-            catch (err) {
-                this.connectionState = "disconnected";
-                this.emitState();
-                this.pendingConnectReject?.(err);
-            }
-        });
-    }
-    /**
-     * Disconnect from the server.
-     */
-    disconnect() {
-        this.explicitlyClosed = true;
-        this.cleanup();
-        const oldWs = this.ws;
-        this.ws = null;
-        if (oldWs) {
-            oldWs.onmessage = null;
-            oldWs.onerror = null;
-            oldWs.onopen = null;
-            oldWs.onclose = null;
-            try {
-                oldWs.close();
-            }
-            catch { /* swallow */ }
-        }
-        this.removeEnvironmentListeners();
-        this.emitState();
-    }
-    /**
-     * Check if connected and authenticated.
-     */
-    isReady() {
-        return this.connectionState == "connected" && this.authState != "pending";
-    }
-    /**
-     * Check if authenticated.
-     */
-    isAuthenticated() {
-        return this.authState == "authenticated";
-    }
-    /**
-     * Check if anonymouse.
-     */
-    isAnonymouse() {
-        return this.authState == "anonymouse";
-    }
-    /**
-     * The authenticated user's id (from `auth:success`), or null when
-     * unauthenticated / anonymous. Useful for "Logged in as …" display.
-     *
-     * Not to be confused with server-side `queryIdentity`, which is the
-     * cache/subscription segmentation key (resolved entirely on the server).
-     */
-    getAuthUserId() {
-        return this.authUserId;
-    }
-    /**
-     * Call a procedure (query, mutation, or action).
-     *
-     * If the client is not ready (disconnected or still authenticating), the
-     * call is FIFO-queued and dispatched on the next ready state. The promise
-     * still resolves with the eventual server response.
-     *
-     * Pass `onSend` to be notified when the call actually leaves the queue
-     * (used by `useMutation` to flip `state` from "queued" → "loading").
-     */
-    async call(procedure, input, options) {
-        // Not ready — park on the disconnect queue. flushQueuedCalls picks
-        // these up when the next session reaches ready.
-        if (!this.isReady()) {
-            return new Promise((resolve, reject) => {
-                this.queuedCalls.push({
-                    procedure,
-                    input,
-                    resolve,
-                    reject,
-                    onSend: options?.onSend,
-                });
-                if (!this.explicitlyClosed &&
-                    this.connectionState === "disconnected") {
-                    this.connect().catch(() => { });
-                }
-            });
-        }
-        // Throttle disabled — straight dispatch.
-        if (this.throttleEveryN <= 0) {
-            options?.onSend?.();
-            return this.dispatchCall(procedure, input);
-        }
-        // Already throttling — park and let the loop flush us in the next batch.
-        if (this.throttling) {
-            return new Promise((resolve, reject) => {
-                this.queuedCalls.push({
-                    procedure,
-                    input,
-                    resolve,
-                    reject,
-                    onSend: options?.onSend,
-                });
-            });
-        }
-        // Direct dispatch, count toward throttle cap. When we hit the cap,
-        // flip into throttling mode and kick off the drain loop.
-        this.throttleCounter++;
-        if (this.throttleCounter >= this.throttleEveryN) {
-            this.throttling = true;
-            await this.runThrottleLoop();
-        }
-        options?.onSend?.();
-        return this.dispatchCall(procedure, input);
-    }
-    /**
-     * Throttle drain loop. Each iteration: sleep `throttleDelayMs`, then
-     * dispatch up to `throttleEveryN` queued items. Exits as soon as the
-     * queue drains inside a single batch (burst over, back to direct
-     * dispatch on the next `call()`) or the connection goes away
-     * (reconnect path will restart us via `flushQueuedCalls`).
-     */
-    async runThrottleLoop() {
-        while (this.throttling) {
-            await new Promise((r) => setTimeout(r, this.throttleDelayMs));
-            if (!this.isReady()) {
-                this.throttling = false;
-                this.throttleCounter = 0;
-                return;
-            }
-            this.throttleCounter = 0;
-            while (this.throttleCounter < this.throttleEveryN &&
-                this.queuedCalls.length > 0) {
-                const item = this.queuedCalls.shift();
-                item.onSend?.();
-                this.dispatchCall(item.procedure, item.input).then(item.resolve, item.reject);
-                this.throttleCounter++;
-            }
-            if (this.queuedCalls.length === 0) {
-                // Drained without hitting the cap — release the brake.
-                this.throttling = false;
-                this.throttleCounter = 0;
-                return;
-            }
-            // Else: hit cap, more pending — loop and wait again.
-        }
-    }
-    /**
-     * Issue the call against an established connection. Caller must ensure
-     * `isReady()` before invoking.
-     */
-    dispatchCall(procedure, input) {
-        const id = this.generateRequestId();
-        return new Promise((resolve, reject) => {
-            this.pendingRequests.set(id, { resolve, reject });
-            this.send({
-                type: "call",
-                id,
-                procedure,
-                input,
-            });
-        });
-    }
-    /**
-     * Flush queued calls in FIFO order. Called once `isReady()` becomes
-     * true. With the throttle enabled, dispatch the first batch
-     * synchronously then hand off to the drain loop so a large
-     * post-reconnect flush respects backpressure instead of dumping 10k
-     * frames in one tick.
-     */
-    flushQueuedCalls() {
-        if (this.queuedCalls.length === 0)
-            return;
-        if (this.throttleEveryN <= 0) {
-            const queue = this.queuedCalls;
-            this.queuedCalls = [];
-            for (const item of queue) {
-                item.onSend?.();
-                this.dispatchCall(item.procedure, item.input).then(item.resolve, item.reject);
-            }
-            return;
-        }
-        this.throttleCounter = 0;
-        while (this.throttleCounter < this.throttleEveryN &&
-            this.queuedCalls.length > 0) {
-            const item = this.queuedCalls.shift();
-            item.onSend?.();
-            this.dispatchCall(item.procedure, item.input).then(item.resolve, item.reject);
-            this.throttleCounter++;
-        }
-        if (this.queuedCalls.length > 0) {
-            this.throttling = true;
-            this.runThrottleLoop();
-        }
-    }
-    /**
-     * Re-send `subscribe` for every existing subscription. The subId for each
-     * may legitimately change (e.g. `queryIdentity` was a function of user
-     * identity and the user changed during the disconnect), so we re-key the
-     * unified `subscriptions` Map: snapshot every record, drop them from the
-     * Map, then reinsert under a fresh `_pending:<reqId>` key. Each pending
-     * request's `resolve` rekeys the parked record under the new server-issued
-     * subId so subsequent `sub:update` frames route to the existing
-     * `onUpdate` callback (which the React handle is still holding).
-     */
-    resubscribeAll() {
-        if (this.subscriptions.size === 0)
-            return;
-        const subs = Array.from(this.subscriptions.values());
-        this.subscriptions.clear();
-        for (const sub of subs) {
-            const id = this.generateRequestId();
-            const pendingKey = `_pending:${id}`;
-            sub.subId = null;
-            this.subscriptions.set(pendingKey, sub);
-            this.pendingRequests.set(id, {
-                subscribeResolve: (subId) => {
-                    const parked = this.subscriptions.get(pendingKey);
-                    if (!subId || !parked) {
-                        // Server didn't echo a subId, or the record was torn down
-                        // mid-replay (e.g. component unmounted). Drop the parked
-                        // entry so it can't leak.
-                        this.subscriptions.delete(pendingKey);
-                        this.rejectJoiners(parked, new RPCError("Subscribe response missing subId after replay", "PROTOCOL_ERROR"));
-                        return;
-                    }
-                    // Mutate the SAME Subscription object — the LiveQueryHandleImpl
-                    // is still holding its `onUpdate` closure indirectly through
-                    // this record. Replacing the object would orphan the handle.
-                    parked.subId = subId;
-                    this.subscriptions.delete(pendingKey);
-                    this.subscriptions.set(subId, parked);
-                    // Drain joiners that joined during the parked phase.
-                    this.resolveJoiners(parked, subId);
-                },
-                reject: (err) => {
-                    // Keep the parked record alive on transport-level drops so the
-                    // next resubscribeAll replays it; purge (and reject joiners)
-                    // only on protocol-level errors where re-issuing would not help.
-                    if (!(err instanceof RPCError) || err.code !== "DISCONNECTED") {
-                        const parked = this.subscriptions.get(pendingKey);
-                        this.subscriptions.delete(pendingKey);
-                        this.rejectJoiners(parked, err);
-                    }
-                    console.error(`[WSClient] Failed to re-subscribe ${sub.procedure}:`, err);
-                },
-            });
-            this.send({
-                type: "subscribe",
-                id,
-                procedure: sub.procedure,
-                input: sub.input,
-            });
-        }
-    }
-    /**
-     * Subscribe to a live query.
-     *
-     * The client does not compute the subId locally — it sends the
-     * (procedure, input) pair and receives the canonical subId on the
-     * subscribe response. This lets the server's per-procedure
-     * `queryIdentity` override be authoritative without forcing the client
-     * to mirror any of the resolution logic.
-     *
-     * Returns the server-assigned subId and an unsubscribe function.
-     */
-    async subscribe(procedure, input, serializedInput, onUpdate, onGone) {
-        await this.ensureConnected();
-        const localKey = await computeLocalSubKey(procedure, serializedInput);
-        // Manager-level dedup: scan values for an existing subscription with
-        // the same logical (procedure, input). Subscribe is a cold path (mounts,
-        // not the per-message hot path), so a linear scan is the right shape
-        // here in exchange for a single unified Map.
-        const existing = this.findSubByLocalKey(localKey);
-        if (existing) {
-            existing.onUpdate = onUpdate;
-            existing.onGone = onGone;
-            if (existing.subId) {
-                return {
-                    subId: existing.subId,
-                    unsubscribe: () => this.unsubscribeByLocalKey(localKey, existing.subId),
-                };
-            }
-            // Subscribe response for the existing record is still in flight.
-            // Park an event-driven joiner on the record — the originating
-            // subscribeResolve (or the replay's, if the socket dropped first)
-            // drains us when the response lands.
-            return new Promise((resolve, reject) => {
-                const joinerTimeout = setTimeout(() => {
-                    existing.pendingJoiners?.delete(joiner);
-                    reject(new RPCError(`Subscribe timeout: ${procedure}`, "TIMEOUT"));
-                }, 30_000);
-                const joiner = {
-                    resolve: (subId) => {
-                        clearTimeout(joinerTimeout);
-                        existing.pendingJoiners?.delete(joiner);
-                        resolve({
-                            subId,
-                            unsubscribe: () => this.unsubscribeByLocalKey(localKey, subId),
-                        });
-                    },
-                    reject: (err) => {
-                        clearTimeout(joinerTimeout);
-                        existing.pendingJoiners?.delete(joiner);
-                        reject(err);
-                    },
-                };
-                (existing.pendingJoiners ??= new Set()).add(joiner);
-            });
-        }
-        const id = this.generateRequestId();
-        const pendingKey = `_pending:${id}`;
-        const record = {
-            subId: null,
-            localKey,
-            procedure,
-            input,
-            onUpdate,
-            onGone,
-        };
-        this.subscriptions.set(pendingKey, record);
-        let timeout = null;
-        return new Promise((resolve, reject) => {
-            this.pendingRequests.set(id, {
-                subscribeResolve: (subId) => {
-                    if (timeout) {
-                        clearTimeout(timeout);
-                        timeout = null;
-                    }
-                    const sub = this.subscriptions.get(pendingKey);
-                    if (!subId || !sub) {
-                        this.subscriptions.delete(pendingKey);
-                        const err = new RPCError("Subscribe response missing subId", "PROTOCOL_ERROR");
-                        this.rejectJoiners(sub, err);
-                        reject(err);
-                        return;
-                    }
-                    // Re-key from pending sentinel to real subId, same object.
-                    sub.subId = subId;
-                    this.subscriptions.delete(pendingKey);
-                    this.subscriptions.set(subId, sub);
-                    resolve({
-                        subId,
-                        unsubscribe: () => this.unsubscribeByLocalKey(localKey, subId),
-                    });
-                    this.resolveJoiners(sub, subId);
-                },
-                reject: (err) => {
-                    if (timeout) {
-                        clearTimeout(timeout);
-                        timeout = null;
-                    }
-                    // Keep the record alive on transport-level drops (DISCONNECTED)
-                    // so `resubscribeAll` replays it after the reconnect handshake.
-                    // Joiners stay attached to the parked record and are drained by
-                    // the replay's subscribeResolve. Purge (and reject joiners) only
-                    // on real protocol-level errors or the 30s timeout.
-                    if (!(err instanceof RPCError) || err.code !== "DISCONNECTED") {
-                        const sub = this.subscriptions.get(pendingKey);
-                        this.subscriptions.delete(pendingKey);
-                        this.rejectJoiners(sub, err);
-                    }
-                    reject(err);
-                },
-            });
-            this.send({
-                type: "subscribe",
-                id,
-                procedure,
-                input,
-            });
-            timeout = setTimeout(() => {
-                if (this.pendingRequests.has(id)) {
-                    this.pendingRequests.delete(id);
-                    const sub = this.subscriptions.get(pendingKey);
-                    this.subscriptions.delete(pendingKey);
-                    const err = new RPCError(`Subscribe timeout: ${procedure}`, "TIMEOUT");
-                    this.rejectJoiners(sub, err);
-                    reject(err);
-                }
-            }, 30_000);
-        });
-    }
-    findSubByLocalKey(localKey) {
-        for (const sub of this.subscriptions.values()) {
-            if (sub.localKey === localKey)
-                return sub;
-        }
-        return undefined;
-    }
-    /** Resolve every joiner waiting on this Subscription with the canonical subId. */
-    resolveJoiners(sub, subId) {
-        if (!sub.pendingJoiners)
-            return;
-        // Snapshot before iterating — each joiner.resolve() mutates the set.
-        const snapshot = Array.from(sub.pendingJoiners);
-        for (const j of snapshot)
-            j.resolve(subId);
-    }
-    /** Reject every joiner waiting on this Subscription with the given error. */
-    rejectJoiners(sub, err) {
-        if (!sub?.pendingJoiners)
-            return;
-        const snapshot = Array.from(sub.pendingJoiners);
-        for (const j of snapshot)
-            j.reject(err);
-    }
-    unsubscribeByLocalKey(localKey, subId) {
-        const sendUnsubscribe = (subId) => {
-            if (this.connectionState === "connected") {
-                this.send({ type: "unsubscribe", subId });
-            }
-        };
-        if (subId) {
-            // If we have the subId, we can skip straight to the unsubscribe message
-            this.subscriptions.delete(subId);
-            sendUnsubscribe(subId);
-            return;
-        }
-        // We don't know whether the entry is parked under a pending sentinel or
-        // a real subId, so iterate. O(N) is fine here: unsubscribe runs at
-        // most once per handle teardown.
-        for (const [key, sub] of this.subscriptions.entries()) {
-            if (sub.localKey !== localKey)
-                continue;
-            this.subscriptions.delete(key);
-            // Cancel any callers still waiting on the in-flight subscribe.
-            this.rejectJoiners(sub, new RPCError("Subscription cancelled before response", "CANCELLED"));
-            sendUnsubscribe(sub.subId);
-            return;
-        }
-    }
-    // ─── Internal Handlers ──────────────────────────────────────────────────────
-    async handleMessage(dataValue) {
-        // ANY inbound frame counts as a liveness signal — the bytes arrived,
-        // therefore the socket is alive. Done before parse/validate so that
-        // even malformed frames still refresh the watchdog (it's the OS
-        // delivery we care about, not the JSON correctness).
-        this.lastServerMessageAt = Date.now();
-        // Validate against the full server-message union rather than trusting a
-        // naked cast. A protocol-version skew (or a man-in-the-middle proxy
-        // that mangles the payload) would otherwise blow up downstream with a
-        // runtime TypeError on a missing field; better to drop the message
-        // with a clear diagnostic.
-        let data = undefined;
-        try {
-            data = JSON.parse(dataValue);
-        }
-        catch {
-            console.error("[WSClient] Failed to parse server message as JSON:", dataValue);
-        }
-        const parsed = ServerMessageSchema.safeParse(data);
-        if (!parsed.success) {
-            console.error("[WSClient] Invalid server message:", parsed.error.issues, data);
-            return;
-        }
-        const message = parsed.data;
-        switch (message.type) {
-            case "connected": {
-                this.connectionState = "connected";
-                this.reconnectAttempts = 0;
-                // Track successful connection time for reconnection logic
-                this.lastSuccessfulConnectionTime = Date.now();
-                // (Inactivity watchdog already started in `ws.onopen`. The top of
-                // handleMessage refreshed `lastServerMessageAt` for this very frame.)
-                // Send auth if token provided
-                const token = await this.options.token?.();
-                if (token) {
-                    this.authState = "pending";
-                    this.emitState();
-                    this.send({ type: "auth", data: { token } });
-                }
-                else {
-                    this.authState = "anonymouse";
-                    this.options.onConnect?.();
-                    this.emitState();
-                    this.afterReady();
-                    this.pendingConnectResolve?.();
-                }
-                break;
-            }
-            case "auth:success":
-                this.authState = "authenticated";
-                this.authUserId = message.userId;
-                this.options.onConnect?.();
-                this.emitState();
-                this.afterReady();
-                this.pendingConnectResolve?.();
-                break;
-            case "auth:failed":
-                // The WebSocket itself is fine — only auth rejected. Resolve the
-                // connect promise so the app can decide what to do via
-                // `isAuthenticated()` / `getPublicState()`. Avoids flooding the
-                // console for anonymous-friendly apps that simply continue without
-                // a token.
-                this.authState = "unauthenticated";
-                this.authUserId = null;
-                this.options.onConnect?.();
-                this.emitState();
-                this.afterReady();
-                this.pendingConnectResolve?.();
-                break;
-            case "response":
-                this.handleResponse(message);
-                break;
-            case "sub:update":
-                this.handleSubscriptionUpdate(message);
-                break;
-            case "sub:gone":
-                this.handleSubscriptionGone(message);
-                break;
-            case "ping":
-                // The `lastServerMessageAt` update at the top of `handleMessage`
-                // is the only thing this signal exists for. No reply.
-                break;
-            default: {
-                // Exhaustive over `ServerMessageSchema`; reaching here means the
-                // schema was extended without updating this switch.
-                const _exhaustive = message;
-                console.warn("[WSClient] Unhandled server message type:", _exhaustive);
-            }
-        }
-    }
-    /**
-     * Called once the client transitions to a "ready" state on a fresh
-     * connection. Replays live-query subscriptions and flushes any queued
-     * calls in FIFO order.
-     */
-    afterReady() {
-        this.resubscribeAll();
-        this.flushQueuedCalls();
-    }
-    handleResponse(message) {
-        const pending = this.pendingRequests.get(message.id);
-        if (!pending)
-            return;
-        this.pendingRequests.delete(message.id);
-        if (message.success) {
-            if (pending.subscribeResolve) {
-                pending.subscribeResolve(message.subId);
-            }
-            else {
-                pending.resolve?.(message.data);
-            }
-        }
-        else {
-            pending.reject(new RPCError(message.error ?? "Unknown error", message.code));
-        }
-    }
-    handleSubscriptionUpdate(message) {
-        const sub = this.subscriptions.get(message.subId);
-        if (sub) {
-            sub.onUpdate(message.data);
-        }
-    }
-    /**
-     * Handles a `sub:gone` message: the server no longer tracks this
-     * subscription (e.g. it was fully unregistered while we were disconnected
-     * from the sub-manager). Notify the handle and drop the local entry so a
-     * re-subscribe is required to receive further updates.
-     */
-    handleSubscriptionGone(message) {
-        const sub = this.subscriptions.get(message.subId);
-        if (!sub)
-            return;
-        this.subscriptions.delete(message.subId);
-        try {
-            sub.onGone?.(message.reason);
-        }
-        catch (e) {
-            console.error("[WSClient] onGone listener threw:", e);
-        }
-    }
-    handleClose() {
-        // Idempotent: `closeAndReconnect()` calls us synchronously to fast-track
-        // the reconnect, and then the OS-level `ws.onclose` fires again on the
-        // discarded socket. Re-entering would double-fire `onDisconnect` and
-        // double-bump `reconnectAttempts`.
-        if (this.connectionState === "disconnected")
-            return;
-        this.connectionState = "disconnected";
-        this.authState = "pending";
-        this.ws = null;
-        this.stopInactivityWatchdog();
-        this.options.onDisconnect?.();
-        // If a `connect()` promise is still in flight (we never reached
-        // auth:success / anonymous-connected before the close), reject it so
-        // any `await client.connect()` doesn't hang. Auto-reconnect will
-        // still take over via scheduleReconnect below — this only settles
-        // the user-facing promise.
-        this.pendingConnectReject?.(new RPCError("Connection closed before ready", "DISCONNECTED"));
-        // Reject every in-flight request. These were already on the wire — the
-        // server may have processed a mutation but the response frame was lost
-        // when the socket dropped. Re-issuing would risk double-execution
-        // (e.g. a transfer applied twice), so we surface DISCONNECTED to the
-        // caller; the side effect, if it committed, is reflected via the live
-        // query subscription cluster on reconnect.
-        //
-        // Queued calls (this.queuedCalls) are intentionally preserved and
-        // flushed on the next ready state — those were never sent, so
-        // re-issuing them is safe and is the user-visible "I clicked
-        // before the socket reconnected" path. Subscribe pendings are
-        // replayed via resubscribeAll in afterReady.
-        for (const pending of this.pendingRequests.values()) {
-            pending.reject(new RPCError("Connection closed", "DISCONNECTED"));
-        }
-        this.pendingRequests.clear();
-        this.emitState();
-        // Attempt reconnection (unless the caller explicitly disconnected)
-        if (!this.explicitlyClosed && this.options.reconnect?.enabled) {
-            this.scheduleReconnect();
-        }
-    }
-    handleError(err) {
-        this.options.onError?.(err);
-    }
-    // ─── Inactivity watchdog ────────────────────────────────────────────────
-    //
-    // The browser API does not surface ws-protocol pings to JS, and even if
-    // it did, asking the JS thread to *send* a periodic ping is fragile
-    // during synchronous bursts (a tight 10k mutation loop starves the
-    // setInterval long enough to trigger spurious reconnects).
-    //
-    // The server is in charge of liveness instead: it emits `{type:"ping"}`
-    // every `HEARTBEAT_INTERVAL_MS` of channel idle (server side). We
-    // just track the wall-clock of the most recent inbound message, and if
-    // it slips past `serverInactivityMs` we treat the socket as dead.
-    startInactivityWatchdog() {
-        this.stopInactivityWatchdog();
-        this.lastServerMessageAt = Date.now();
-        // Poll at ~quarter cadence so a fresh-stale boundary fires within
-        // serverInactivityMs * 1.25 of the actual silence onset. Minimum 1s.
-        const tickMs = Math.max(1_000, Math.floor(this.serverInactivityMs / 4));
-        this.inactivityTimer = setInterval(() => {
-            if (Date.now() - this.lastServerMessageAt > this.serverInactivityMs) {
-                this.closeAndReconnect("InactiveServer");
-            }
-        }, tickMs);
-    }
-    stopInactivityWatchdog() {
-        if (this.inactivityTimer) {
-            clearInterval(this.inactivityTimer);
-            this.inactivityTimer = null;
-        }
-    }
-    /**
-     * Close the current WebSocket and schedule a reconnect via `handleClose`.
-     *
-     * Atomically swaps the old socket's event handlers to no-ops BEFORE
-     * `close()` so a frame in flight at the moment of close cannot fire
-     * `handleMessage` into a half-cleaned state — that was the source of
-     * the "browser says socket is alive but client says disconnected" race.
-     */
-    closeAndReconnect(reason) {
-        if (this.connectionState === "disconnected")
-            return;
-        console.warn(`[WSClient] closeAndReconnect: ${reason}`);
-        const oldWs = this.ws;
-        if (oldWs) {
-            oldWs.onmessage = null;
-            oldWs.onerror = null;
-            oldWs.onopen = null;
-            // Discard the close handler too — we don't want the OS-level close
-            // event to re-enter handleClose; we invoke it synchronously below.
-            oldWs.onclose = null;
-            try {
-                oldWs.close(4000, reason);
-            }
-            catch { /* swallow */ }
-        }
-        // Synchronous state transition + reconnect scheduling. Same effect
-        // as the OS-level onclose path, but doesn't wait on the close
-        // handshake (which can stall when the socket is half-open).
-        this.handleClose();
-    }
-    installEnvironmentListeners() {
-        // visibilitychange → "visible": a backgrounded tab that just became
-        // visible may have been frozen by the browser. Check staleness now
-        // and reconnect immediately if the watchdog is already past due.
-        if (typeof document !== "undefined" &&
-            typeof document.addEventListener === "function" &&
-            !this.visibilityListener) {
-            this.visibilityListener = () => {
-                if (typeof document === "undefined")
-                    return;
-                if (document.visibilityState !== "visible")
-                    return;
-                if (this.connectionState !== "connected")
-                    return;
-                if (Date.now() - this.lastServerMessageAt > this.serverInactivityMs) {
-                    this.closeAndReconnect("WokeUpStale");
-                }
-            };
-            document.addEventListener("visibilitychange", this.visibilityListener);
-        }
-        // online: a flip back to online is a strong signal that any current
-        // disconnected-state backoff should collapse to "try right now."
-        if (typeof window !== "undefined" &&
-            typeof window.addEventListener === "function" &&
-            !this.onlineListener) {
-            this.onlineListener = () => {
-                if (this.connectionState !== "disconnected")
-                    return;
-                if (this.explicitlyClosed)
-                    return;
-                if (this.reconnectTimer) {
-                    clearTimeout(this.reconnectTimer);
-                    this.reconnectTimer = null;
-                }
-                this.connect().catch(() => { });
-            };
-            window.addEventListener("online", this.onlineListener);
-        }
-    }
-    removeEnvironmentListeners() {
-        if (this.visibilityListener && typeof document !== "undefined") {
-            document.removeEventListener("visibilitychange", this.visibilityListener);
-            this.visibilityListener = null;
-        }
-        if (this.onlineListener && typeof window !== "undefined") {
-            window.removeEventListener("online", this.onlineListener);
-            this.onlineListener = null;
-        }
-    }
-    // ─── Reconnection ───────────────────────────────────────────────────────────
-    scheduleReconnect() {
-        if (this.reconnectAttempts >= (this.options.reconnect?.maxAttempts ?? 5)) {
-            console.error("[WSClient] Max reconnection attempts reached");
-            // We're not going to try again — drain any user-facing promises
-            // that would otherwise hang forever waiting for a connection that
-            // never comes.
-            const giveUp = new RPCError("Max reconnection attempts reached", "DISCONNECTED");
-            for (const q of this.queuedCalls)
-                q.reject(giveUp);
-            this.queuedCalls = [];
-            this.pendingConnectReject?.(giveUp);
-            return;
-        }
-        const base = (this.options.reconnect?.delay ?? 1000) *
-            Math.pow(this.options.reconnect?.backoff ?? 1.5, this.reconnectAttempts);
-        // ±50% jitter so two tabs that disconnected at the same instant don't
-        // wake the server in lockstep on reconnect.
-        const delay = base + base * (Math.random() - 0.5);
-        this.reconnectAttempts++;
-        this.reconnectTimer = setTimeout(() => {
-            this.connect().catch((err) => {
-                console.error("[WSClient] Reconnection failed:", err);
-            });
-        }, delay);
-    }
-    // ─── State Events ───────────────────────────────────────────────────────────
-    computePublicState() {
-        if (this.connectionState === "disconnected")
-            return "disconnected";
-        if (this.connectionState === "connecting")
-            return "connecting";
-        // connectionState === "connected"
-        if (this.authState === "pending")
-            return "authenticating";
-        return "ready";
-    }
-    emitState() {
-        const next = this.computePublicState();
-        if (next === this.lastPublicState)
-            return;
-        this.lastPublicState = next;
-        for (const l of this.stateListeners) {
-            try {
-                l(next);
-            }
-            catch (e) {
-                console.error("[WSClient] state listener threw:", e);
-            }
-        }
-    }
-    // ─── Utilities ──────────────────────────────────────────────────────────────
-    async ensureConnected() {
-        if (this.connectionState != "connected") {
-            await this.connect();
-        }
-    }
-    send(message) {
-        if (this.ws && this.ws.readyState === WS_OPEN) {
-            this.ws.send(supaliveStringify(message));
-        }
-    }
-    cleanup() {
-        this.connectionState = "disconnected";
-        this.authState = "pending";
-        this.stopInactivityWatchdog();
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        const teardown = new RPCError("Client disconnected", "DISCONNECTED");
-        for (const pending of this.pendingRequests.values()) {
-            pending.reject(teardown);
-        }
-        this.pendingRequests.clear();
-        // Explicit disconnect drains the queue with an error — the consumer
-        // tore down on purpose, so we shouldn't hold onto their promises.
-        for (const q of this.queuedCalls) {
-            q.reject(teardown);
-        }
-        this.queuedCalls = [];
-        // The throttle loop (if running) wakes from its sleep, sees
-        // !isReady, and exits on its own. Reset its flags so the next
-        // session starts clean.
-        this.throttling = false;
-        this.throttleCounter = 0;
-        // Also settle any in-flight `connect()` promise so a caller that did
-        // `await client.connect()` racing with `client.disconnect()` doesn't
-        // hang. No-op if already settled.
-        this.pendingConnectReject?.(teardown);
-    }
-    generateRequestId() {
-        return `${++this.requestId}`;
-    }
-}
-// ─── Browser/Node WebSocket Handling ──────────────────────────────────────────
-let WebSocketImpl = null;
-// Check if we're in a browser environment
-if (typeof globalThis !== "undefined" && globalThis.WebSocket) {
-    WebSocketImpl = globalThis.WebSocket;
-}
-async function getWebSocket() {
-    if (WebSocketImpl)
-        return WebSocketImpl;
-    // Dynamic import for Node.js
-    const ws = await import("ws");
-    return ws.WebSocket;
-}
-export { getWebSocket };
-//# sourceMappingURL=ws_client_manager.js.map