deepspace 0.5.1 → 0.5.3

package/dist/index.js

@@ -1278,33 +1278,21 @@ var RecordStore = class {
   }
 };
 
-// src/client/storage/ScopeRegistry.tsx
-import { createContext, useContext, useCallback, useRef as useRef3, useMemo } from "react";
-import { jsx as jsx5 } from "react/jsx-runtime";
-var ScopeRegistryContext = createContext(null);
-function useScopeRegistry() {
-  return useContext(ScopeRegistryContext);
+// src/client/storage/record-matching.ts
+function recordMatchesWhere(record, where) {
+  if (!where) return true;
+  const r = record;
+  const data = r.data;
+  if (!data) return false;
+  return Object.entries(where).every(([key, value]) => {
+    if (key in data) return data[key] === value;
+    if (key === "recordId") return r.recordId === value;
+    if (key === "createdBy") return r.createdBy === value;
+    return false;
+  });
 }
-function ScopeRegistryProvider({ children }) {
-  const mapRef = useRef3(/* @__PURE__ */ new Map());
-  const register = useCallback((scopeId, collections, entry) => {
-    for (const name of collections) {
-      mapRef.current.set(name, { scopeId, entry });
-    }
-  }, []);
-  const unregister = useCallback((scopeId, collections) => {
-    for (const name of collections) {
-      const existing = mapRef.current.get(name);
-      if (existing?.scopeId === scopeId) {
-        mapRef.current.delete(name);
-      }
-    }
-  }, []);
-  const resolve = useCallback((collection) => {
-    return mapRef.current.get(collection)?.entry ?? null;
-  }, []);
-  const value = useMemo(() => ({ register, unregister, resolve }), [register, unregister, resolve]);
-  return /* @__PURE__ */ jsx5(ScopeRegistryContext.Provider, { value, children });
+function reconnectDelayMs(attempt) {
+  return Math.min(1e3 * Math.pow(2, attempt), 3e4);
 }
 
 // src/client/storage/serverErrors.ts
@@ -1402,6 +1390,327 @@ function parseServerError(error) {
   };
 }
 
+// src/client/storage/record-socket.ts
+var WS_CONNECTING = 0;
+var WS_OPEN = 1;
+var RecordSocket = class {
+  constructor(config) {
+    this.config = config;
+    this.subscriptions = config.subscriptions ?? /* @__PURE__ */ new Map();
+    this.binaryHandlers = config.binaryHandlers ?? /* @__PURE__ */ new Set();
+    this.yjsJoinHandlers = config.yjsJoinHandlers ?? /* @__PURE__ */ new Map();
+  }
+  ws = null;
+  subscriptions;
+  // subscriptionId → queryKey
+  binaryHandlers;
+  yjsJoinHandlers;
+  pendingRequests = /* @__PURE__ */ new Map();
+  reconnectAttempt = 0;
+  reconnectTimeout = null;
+  // Bumped by connect() (on entry) and disconnect()/destroy(). connect()
+  // captures it before awaiting the auth token and re-checks after; a
+  // mismatch means a teardown (or a newer connect) raced in during the
+  // await, so the resolved connect must bail instead of leaking a socket.
+  connectToken = 0;
+  // Opaque identity the current socket was opened with (e.g. '' for
+  // anonymous, the profile id once signed in). A connect() with a DIFFERENT
+  // tag while OPEN forces a reconnect so the server sees the new identity.
+  identityTag;
+  destroyed = false;
+  // ── lifecycle ─────────────────────────────────────────────────────────────
+  async connect(identityTag) {
+    if (this.destroyed) return;
+    const { config } = this;
+    if (this.ws?.readyState === WS_OPEN) {
+      if (identityTag !== void 0 && identityTag !== this.identityTag) {
+        config.log?.("reconnecting with new identity", config.roomId);
+        this.teardownSocket();
+      } else {
+        return;
+      }
+    }
+    if (this.ws?.readyState === WS_CONNECTING) return;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    const myToken = ++this.connectToken;
+    const params = new URLSearchParams();
+    try {
+      const token = await config.getToken();
+      if (token) params.set("token", token);
+    } catch {
+    }
+    if (this.connectToken !== myToken || this.destroyed) return;
+    for (const [key, value] of Object.entries(config.extraParams ?? {})) {
+      params.set(key, value);
+    }
+    if (identityTag !== void 0) this.identityTag = identityTag;
+    const protocol = typeof window !== "undefined" && window.location.protocol === "https:" ? "wss:" : "ws:";
+    const baseUrl = config.wsUrl?.replace(/^http/, "ws") ?? `${protocol}//${typeof window !== "undefined" ? window.location.host : ""}`;
+    const pathPrefix = config.wsPathPrefix ?? "/ws";
+    const url = `${baseUrl}${pathPrefix}/${config.roomId}?${params.toString()}`;
+    config.log?.("connecting", config.roomId);
+    const WS = config.WebSocketImpl ?? WebSocket;
+    const ws = new WS(url);
+    ws.binaryType = "arraybuffer";
+    this.ws = ws;
+    ws.onopen = () => {
+      config.log?.("connected", config.roomId);
+      config.listeners.onStatus("connected");
+      this.resubscribeAll(ws);
+    };
+    ws.onmessage = (event) => this.handleMessage(event);
+    ws.onclose = () => {
+      config.log?.("disconnected", config.roomId);
+      config.listeners.onStatus("disconnected");
+      config.listeners.onReady(false);
+      this.ws = null;
+      for (const pending of this.pendingRequests.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("WebSocket disconnected"));
+      }
+      this.pendingRequests.clear();
+      for (const queryKey of this.subscriptions.values()) {
+        config.store.resetToLoading(queryKey);
+      }
+      const attempt = this.reconnectAttempt;
+      const delay = reconnectDelayMs(attempt);
+      config.log?.("scheduling reconnect", { roomId: config.roomId, attempt, delayMs: delay });
+      this.reconnectAttempt = attempt + 1;
+      this.reconnectTimeout = setTimeout(() => void this.connect(this.identityTag), delay);
+    };
+    ws.onerror = () => {
+    };
+  }
+  /**
+   * Tear down and reset to a connectable state (auth identity change, scope
+   * unmount-and-remount). Emits status 'connecting' so the UI shows progress
+   * rather than a dead 'disconnected'.
+   */
+  disconnect() {
+    this.connectToken++;
+    this.clearReconnect();
+    this.teardownSocket();
+    this.config.listeners.onStatus("connecting");
+    this.config.listeners.onReady(false);
+    this.reconnectAttempt = 0;
+  }
+  /** Final teardown (unmount): no listener calls — the owner is gone. */
+  destroy() {
+    this.destroyed = true;
+    this.connectToken++;
+    this.clearReconnect();
+    this.teardownSocket();
+  }
+  /** Zero the backoff (tab became visible, user asked to retry). */
+  resetBackoff() {
+    this.reconnectAttempt = 0;
+  }
+  get isOpen() {
+    return this.ws?.readyState === WS_OPEN;
+  }
+  clearReconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+  /** Close without firing onclose — prevents the zombie-reconnect. */
+  teardownSocket() {
+    const ws = this.ws;
+    if (!ws) return;
+    this.config.log?.("closing", this.config.roomId);
+    ws.onclose = null;
+    ws.onmessage = null;
+    ws.onerror = null;
+    ws.onopen = null;
+    ws.close();
+    this.ws = null;
+  }
+  // ── sending ───────────────────────────────────────────────────────────────
+  sendMessage(message) {
+    if (this.ws?.readyState === WS_OPEN) this.ws.send(JSON.stringify(message));
+    else this.config.log?.("send dropped (not connected)", message.type);
+  }
+  sendBinary(data) {
+    if (this.ws?.readyState === WS_OPEN) this.ws.send(data);
+  }
+  sendConfirmed(message, timeoutMs = 1e4) {
+    const ws = this.ws;
+    if (!ws || ws.readyState !== WS_OPEN) {
+      return Promise.reject(new Error("WebSocket not connected"));
+    }
+    const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error("Mutation confirmation timed out"));
+      }, timeoutMs);
+      this.pendingRequests.set(requestId, { resolve, reject, timer });
+      ws.send(JSON.stringify({ ...message, payload: { ...message.payload, requestId } }));
+    });
+  }
+  // ── registrations ─────────────────────────────────────────────────────────
+  registerSubscription(subscriptionId, queryKey) {
+    this.subscriptions.set(subscriptionId, queryKey);
+  }
+  unregisterSubscription(subscriptionId) {
+    this.subscriptions.delete(subscriptionId);
+  }
+  onBinaryMessage(handler) {
+    this.binaryHandlers.add(handler);
+    return () => {
+      this.binaryHandlers.delete(handler);
+    };
+  }
+  registerYjsJoinHandler(docKey, handler) {
+    if (!this.yjsJoinHandlers.has(docKey)) this.yjsJoinHandlers.set(docKey, /* @__PURE__ */ new Set());
+    this.yjsJoinHandlers.get(docKey).add(handler);
+    return () => {
+      const handlers = this.yjsJoinHandlers.get(docKey);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) this.yjsJoinHandlers.delete(docKey);
+      }
+    };
+  }
+  // ── message dispatch ──────────────────────────────────────────────────────
+  resubscribeAll(ws) {
+    for (const [subscriptionId, queryKey] of this.subscriptions) {
+      try {
+        const query = JSON.parse(queryKey);
+        ws.send(JSON.stringify({ type: MSG.SUBSCRIBE, payload: { subscriptionId, query } }));
+      } catch {
+      }
+    }
+  }
+  handleMessage(event) {
+    if (event.data instanceof ArrayBuffer) {
+      this.binaryHandlers.forEach((h) => h(event.data));
+      return;
+    }
+    let msg;
+    try {
+      msg = JSON.parse(event.data);
+    } catch {
+      console.error("[RecordSocket] Failed to parse message");
+      return;
+    }
+    const { type, payload } = msg;
+    const { store, listeners } = this.config;
+    switch (type) {
+      case MSG.USER_INFO: {
+        const { role } = payload;
+        listeners.onRole(role);
+        listeners.onReady(true);
+        this.reconnectAttempt = 0;
+        this.sendMessage({ type: MSG.USER_LIST, payload: {} });
+        break;
+      }
+      case MSG.USER_LIST:
+        listeners.onUsers(payload.users);
+        break;
+      case MSG.QUERY_RESULT: {
+        const { subscriptionId, records } = payload;
+        const queryKey = this.subscriptions.get(subscriptionId);
+        if (queryKey !== void 0) store.setQueryResult(queryKey, records);
+        break;
+      }
+      case MSG.RECORD_CHANGE: {
+        const { collection, record, changeType } = payload;
+        for (const queryKey of this.subscriptions.values()) {
+          try {
+            const query = JSON.parse(queryKey);
+            if (query.collection !== collection) continue;
+            const matches = recordMatchesWhere(record, query.where);
+            const exists = store.hasRecord(queryKey, record.recordId);
+            if (changeType === "delete") {
+              if (exists) store.applyChange(queryKey, record, "delete");
+            } else if (changeType === "create") {
+              if (matches) store.applyChange(queryKey, record, "create");
+            } else {
+              if (matches && exists) store.applyChange(queryKey, record, "update");
+              else if (matches && !exists) store.applyChange(queryKey, record, "create");
+              else if (!matches && exists) store.applyChange(queryKey, record, "delete");
+            }
+          } catch {
+          }
+        }
+        break;
+      }
+      case MSG.ERROR: {
+        const { subscriptionId, error } = payload;
+        if (subscriptionId) {
+          const queryKey = this.subscriptions.get(subscriptionId);
+          if (queryKey !== void 0) store.setError(queryKey, error);
+        } else {
+          const parsed = parseServerError(error);
+          if (parsed.isPermissionError) listeners.onPermissionError?.(parsed.title, parsed.detail);
+          else listeners.onValidationError?.(parsed.title, parsed.detail);
+        }
+        break;
+      }
+      case MSG.YJS_JOIN: {
+        const { collection, recordId, fieldName, canWrite } = payload;
+        const docKey = `${collection}:${recordId}:${fieldName}`;
+        this.yjsJoinHandlers.get(docKey)?.forEach((h) => h(canWrite));
+        break;
+      }
+      case MSG.ACK: {
+        const { requestId, success, error, ...rest } = payload;
+        const pending = this.pendingRequests.get(requestId);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pendingRequests.delete(requestId);
+          if (success) pending.resolve(rest);
+          else pending.reject(new Error(error || "Mutation rejected"));
+        }
+        break;
+      }
+      case MSG.LIST_SCHEMAS: {
+        const { schemas } = payload;
+        listeners.onSchemas?.(schemas ?? []);
+        break;
+      }
+      case MSG.RESUBSCRIBE: {
+        if (this.ws?.readyState === WS_OPEN) this.resubscribeAll(this.ws);
+        break;
+      }
+    }
+  }
+};
+
+// src/client/storage/ScopeRegistry.tsx
+import { createContext, useContext, useCallback, useRef as useRef3, useMemo } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var ScopeRegistryContext = createContext(null);
+function useScopeRegistry() {
+  return useContext(ScopeRegistryContext);
+}
+function ScopeRegistryProvider({ children }) {
+  const mapRef = useRef3(/* @__PURE__ */ new Map());
+  const register = useCallback((scopeId, collections, entry) => {
+    for (const name of collections) {
+      mapRef.current.set(name, { scopeId, entry });
+    }
+  }, []);
+  const unregister = useCallback((scopeId, collections) => {
+    for (const name of collections) {
+      const existing = mapRef.current.get(name);
+      if (existing?.scopeId === scopeId) {
+        mapRef.current.delete(name);
+      }
+    }
+  }, []);
+  const resolve = useCallback((collection) => {
+    return mapRef.current.get(collection)?.entry ?? null;
+  }, []);
+  const value = useMemo(() => ({ register, unregister, resolve }), [register, unregister, resolve]);
+  return /* @__PURE__ */ jsx5(ScopeRegistryContext.Provider, { value, children });
+}
+
 // src/client/storage/context.tsx
 import { Fragment as Fragment5, jsx as jsx6 } from "react/jsx-runtime";
 var RecordContext = createContext2(null);
@@ -1416,18 +1725,6 @@ var RecordAuthContext = createContext2(null);
 function useRecordAuth() {
   return useContext2(RecordAuthContext);
 }
-function recordMatchesWhere(record, where) {
-  if (!where) return true;
-  const r = record;
-  const data = r.data;
-  if (!data) return false;
-  return Object.entries(where).every(([key, value]) => {
-    if (key in data) return data[key] === value;
-    if (key === "recordId") return r.recordId === value;
-    if (key === "createdBy") return r.createdBy === value;
-    return false;
-  });
-}
 function RecordProviderCore({
   roomId,
   wsUrl,
@@ -1450,17 +1747,14 @@ function RecordProviderCore({
     void 0
   );
   const storeRef = useRef4(new RecordStore());
-  const wsRef = useRef4(null);
-  const subscriptionMapRef = useRef4(/* @__PURE__ */ new Map());
+  const socketRef = useRef4(null);
+  const subscriptionsRef = useRef4(/* @__PURE__ */ new Map());
   const binaryHandlersRef = useRef4(/* @__PURE__ */ new Set());
   const yjsJoinHandlersRef = useRef4(/* @__PURE__ */ new Map());
-  const pendingRequestsRef = useRef4(/* @__PURE__ */ new Map());
-  const reconnectAttemptRef = useRef4(0);
-  const reconnectTimeoutRef = useRef4(null);
-  const connectTokenRef = useRef4(0);
-  const connectedWithProfileRef = useRef4(false);
   const userProfileRef = useRef4(null);
   userProfileRef.current = userProfile;
+  const getAuthTokenRef = useRef4(getAuthTokenProp);
+  getAuthTokenRef.current = getAuthTokenProp;
   const refetchUserProfile = useCallback2(async () => {
     try {
       const profile = await fetchUser();
@@ -1481,6 +1775,7 @@ function RecordProviderCore({
       if (mounted)
         fetchUser().then((p) => {
           if (mounted) setUserProfile(p);
+        }).catch(() => {
         });
     }, 3e4);
     return () => {
@@ -1488,228 +1783,54 @@ function RecordProviderCore({
       clearInterval(interval);
     };
   }, [fetchUser]);
-  const handleMessage = useCallback2((event) => {
-    if (event.data instanceof ArrayBuffer) {
-      binaryHandlersRef.current.forEach((handler) => handler(event.data));
-      return;
-    }
-    try {
-      const msg = JSON.parse(event.data);
-      const { type, payload } = msg;
-      switch (type) {
-        case MSG.USER_INFO: {
-          const serverUser = payload;
-          debugLog("[WS] Ready:", { roomId, role: serverUser.role });
-          setRoomRole(serverUser.role);
-          setReady(true);
-          reconnectAttemptRef.current = 0;
-          const ws = wsRef.current;
-          if (ws && ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify({ type: MSG.USER_LIST, payload: {} }));
-          }
-          break;
-        }
-        case MSG.USER_LIST:
-          setAllUsers(payload.users);
+  const userProfileId = userProfile?.id ?? null;
+  useEffect4(() => {
+    if (userProfileLoading) return;
+    const socket = new RecordSocket({
+      roomId,
+      store: storeRef.current,
+      subscriptions: subscriptionsRef.current,
+      binaryHandlers: binaryHandlersRef.current,
+      yjsJoinHandlers: yjsJoinHandlersRef.current,
+      getToken: () => (getAuthTokenRef.current ?? getAuthToken)(),
+      wsUrl,
+      log: (event, detail) => debugLog(`[WS] ${event}`, detail),
+      listeners: {
+        onStatus: setStatus,
+        onReady: setReady,
+        onRole: setRoomRole,
+        onUsers: (users) => {
+          setAllUsers(users);
           setUsersLoaded(true);
-          break;
-        case MSG.QUERY_RESULT: {
-          const { subscriptionId, records } = payload;
-          for (const [subId, queryKey] of subscriptionMapRef.current) {
-            if (subId === subscriptionId) {
-              storeRef.current.setQueryResult(queryKey, records);
-              break;
-            }
-          }
-          break;
-        }
-        case MSG.RECORD_CHANGE: {
-          const { collection, record, changeType } = payload;
-          for (const queryKey of subscriptionMapRef.current.values()) {
-            try {
-              const query = JSON.parse(queryKey);
-              if (query.collection !== collection) continue;
-              const matches = recordMatchesWhere(record, query.where);
-              const exists = storeRef.current.hasRecord(queryKey, record.recordId);
-              if (changeType === "delete") {
-                if (exists) storeRef.current.applyChange(queryKey, record, "delete");
-              } else if (changeType === "create") {
-                if (matches) storeRef.current.applyChange(queryKey, record, "create");
-              } else {
-                if (matches && exists) storeRef.current.applyChange(queryKey, record, "update");
-                else if (matches && !exists)
-                  storeRef.current.applyChange(queryKey, record, "create");
-                else if (!matches && exists)
-                  storeRef.current.applyChange(queryKey, record, "delete");
-              }
-            } catch {
-            }
-          }
-          break;
-        }
-        case MSG.ERROR: {
-          const { subscriptionId, error } = payload;
-          if (subscriptionId) {
-            for (const [subId, queryKey] of subscriptionMapRef.current) {
-              if (subId === subscriptionId) {
-                storeRef.current.setError(queryKey, error);
-                break;
-              }
-            }
-          } else {
-            const parsed = parseServerError(error);
-            console.error("[RecordProvider] Error:", error);
-            if (parsed.isPermissionError) {
-              onPermissionErrorRef.current?.(parsed.title, parsed.detail);
-            } else {
-              onValidationErrorRef.current?.(parsed.title, parsed.detail);
-            }
-          }
-          break;
-        }
-        case MSG.YJS_JOIN: {
-          const { collection, recordId, fieldName, canWrite } = payload;
-          const docKey = `${collection}:${recordId}:${fieldName}`;
-          yjsJoinHandlersRef.current.get(docKey)?.forEach((handler) => handler(canWrite));
-          break;
-        }
-        case MSG.ACK: {
-          const { requestId, success, error, ...rest } = payload;
-          const pending = pendingRequestsRef.current.get(requestId);
-          if (pending) {
-            clearTimeout(pending.timer);
-            pendingRequestsRef.current.delete(requestId);
-            if (success) pending.resolve(rest);
-            else pending.reject(new Error(error || "Mutation rejected"));
-          }
-          break;
-        }
-        case MSG.RESUBSCRIBE: {
-          const ws = wsRef.current;
-          if (ws && ws.readyState === WebSocket.OPEN) {
-            for (const [subscriptionId, queryKey] of subscriptionMapRef.current) {
-              try {
-                const query = JSON.parse(queryKey);
-                ws.send(JSON.stringify({ type: MSG.SUBSCRIBE, payload: { subscriptionId, query } }));
-              } catch {
-              }
-            }
-          }
-          break;
-        }
-      }
-    } catch (e) {
-      console.error("[RecordProvider] Failed to parse message:", e);
-    }
-  }, [roomId]);
-  const connect = useCallback2(async () => {
-    const profile = userProfileRef.current;
-    if (!profile && !allowAnonymous) return;
-    if (wsRef.current?.readyState === WebSocket.OPEN) {
-      if (profile && !connectedWithProfileRef.current) {
-        debugLog(`[WS] Reconnecting with profile data`, { roomId });
-        wsRef.current.onclose = null;
-        wsRef.current.close();
-        wsRef.current = null;
-      } else {
-        return;
+        },
+        onPermissionError: (title, detail) => onPermissionErrorRef.current?.(title, detail),
+        onValidationError: (title, detail) => onValidationErrorRef.current?.(title, detail)
       }
+    });
+    socketRef.current = socket;
+    if (userProfileId || allowAnonymous) {
+      void socket.connect(userProfileId ?? "");
     }
-    if (wsRef.current?.readyState === WebSocket.CONNECTING) return;
-    if (reconnectTimeoutRef.current) {
-      clearTimeout(reconnectTimeoutRef.current);
-      reconnectTimeoutRef.current = null;
-    }
-    const myToken = ++connectTokenRef.current;
-    let baseUrl;
-    if (wsUrl) {
-      baseUrl = wsUrl.replace(/^http/, "ws");
-    } else {
-      const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-      baseUrl = `${protocol}//${window.location.host}`;
-    }
-    const params = new URLSearchParams();
-    try {
-      const tokenFn = getAuthTokenProp ?? getAuthToken;
-      const token = await tokenFn();
-      if (token) params.set("token", token);
-    } catch {
-    }
-    if (connectTokenRef.current !== myToken) return;
-    connectedWithProfileRef.current = !!profile;
-    const wsPath = `/ws/${roomId}`;
-    const url = `${baseUrl}${wsPath}?${params.toString()}`;
-    debugLog("[WS] Connecting:", { roomId, attempt: reconnectAttemptRef.current });
-    const ws = new WebSocket(url);
-    ws.binaryType = "arraybuffer";
-    ws.onopen = () => {
-      debugLog("[WS] Connected:", { roomId });
-      setStatus("connected");
-    };
-    ws.onmessage = handleMessage;
-    ws.onclose = (event) => {
-      debugLog("[WS] Closed:", {
-        roomId,
-        code: event.code,
-        reason: event.reason,
-        wasClean: event.wasClean
-      });
-      setStatus("disconnected");
+    return () => {
+      socketRef.current = null;
+      socket.destroy();
+      setStatus("connecting");
       setReady(false);
-      wsRef.current = null;
-      for (const pending of pendingRequestsRef.current.values()) {
-        clearTimeout(pending.timer);
-        pending.reject(new Error("WebSocket disconnected"));
-      }
-      pendingRequestsRef.current.clear();
-      const attempt = reconnectAttemptRef.current;
-      const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
-      debugLog("[WS] Scheduling reconnect:", { roomId, attempt, delayMs: delay });
-      reconnectAttemptRef.current = attempt + 1;
-      reconnectTimeoutRef.current = setTimeout(connect, delay);
-    };
-    ws.onerror = (e) => {
-      console.error("[WS] Error:", { roomId, error: e });
-    };
-    wsRef.current = ws;
-  }, [roomId, wsUrl, handleMessage, allowAnonymous, getAuthTokenProp]);
-  useEffect4(() => {
-    if (userProfile?.id) connect();
-    else if (allowAnonymous && !userProfileLoading) connect();
-  }, [userProfile?.id, userProfileLoading, allowAnonymous, connect]);
-  useEffect4(() => {
-    const handleVisibilityChange = () => {
-      if (document.visibilityState === "visible") {
-        const ws = wsRef.current;
-        if (ws?.readyState !== WebSocket.OPEN && (userProfileRef.current || allowAnonymous)) {
-          debugLog("[WS] Reconnecting after visibility change");
-          reconnectAttemptRef.current = 0;
-          connect();
-        }
-      }
     };
-    document.addEventListener("visibilitychange", handleVisibilityChange);
-    return () => document.removeEventListener("visibilitychange", handleVisibilityChange);
-  }, [roomId, connect, allowAnonymous]);
+  }, [roomId, wsUrl, userProfileId, userProfileLoading, allowAnonymous]);
   useEffect4(() => {
-    return () => {
-      debugLog("[WS] Unmounting provider:", { roomId });
-      if (reconnectTimeoutRef.current) clearTimeout(reconnectTimeoutRef.current);
-      connectTokenRef.current++;
-      const ws = wsRef.current;
-      if (ws) {
-        ws.onclose = null;
-        ws.onmessage = null;
-        ws.onerror = null;
-        ws.close();
-        wsRef.current = null;
+    const onVisible = () => {
+      if (document.visibilityState === "visible" && !socketRef.current?.isOpen) {
+        debugLog("[WS] Reconnecting after visibility change");
+        socketRef.current?.resetBackoff();
+        void socketRef.current?.connect();
       }
     };
-  }, [roomId]);
+    document.addEventListener("visibilitychange", onVisible);
+    return () => document.removeEventListener("visibilitychange", onVisible);
+  }, []);
   const sendMessage = useCallback2((message) => {
-    const ws = wsRef.current;
-    if (ws && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(message));
-    else console.warn("[RecordProvider] Cannot send message, WebSocket not connected");
+    socketRef.current?.sendMessage(message);
   }, []);
   const setUserRole = useCallback2(
     (userId, role) => {
@@ -1721,14 +1842,13 @@ function RecordProviderCore({
     sendMessage({ type: MSG.USER_LIST, payload: {} });
   }, [sendMessage]);
   const registerSubscription = useCallback2((subscriptionId, queryKey) => {
-    subscriptionMapRef.current.set(subscriptionId, queryKey);
+    subscriptionsRef.current.set(subscriptionId, queryKey);
   }, []);
   const unregisterSubscription = useCallback2((subscriptionId) => {
-    subscriptionMapRef.current.delete(subscriptionId);
+    subscriptionsRef.current.delete(subscriptionId);
   }, []);
   const sendBinary = useCallback2((data) => {
-    const ws = wsRef.current;
-    if (ws && ws.readyState === WebSocket.OPEN) ws.send(data);
+    socketRef.current?.sendBinary(data);
   }, []);
   const onBinaryMessage = useCallback2((handler) => {
     binaryHandlersRef.current.add(handler);
@@ -1738,15 +1858,14 @@ function RecordProviderCore({
   }, []);
   const registerYjsJoinHandler = useCallback2(
     (docKey, handler) => {
-      if (!yjsJoinHandlersRef.current.has(docKey)) {
-        yjsJoinHandlersRef.current.set(docKey, /* @__PURE__ */ new Set());
-      }
-      yjsJoinHandlersRef.current.get(docKey).add(handler);
+      const handlers = yjsJoinHandlersRef.current;
+      if (!handlers.has(docKey)) handlers.set(docKey, /* @__PURE__ */ new Set());
+      handlers.get(docKey).add(handler);
       return () => {
-        const handlers = yjsJoinHandlersRef.current.get(docKey);
-        if (handlers) {
-          handlers.delete(handler);
-          if (handlers.size === 0) yjsJoinHandlersRef.current.delete(docKey);
+        const set = handlers.get(docKey);
+        if (set) {
+          set.delete(handler);
+          if (set.size === 0) handlers.delete(docKey);
         }
       };
     },
@@ -1754,19 +1873,9 @@ function RecordProviderCore({
   );
   const sendConfirmed = useCallback2(
     (message, timeoutMs = 1e4) => {
-      const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-      const ws = wsRef.current;
-      if (!ws || ws.readyState !== WebSocket.OPEN) {
-        return Promise.reject(new Error("WebSocket not connected"));
-      }
-      return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-          pendingRequestsRef.current.delete(requestId);
-          reject(new Error("Mutation confirmation timed out"));
-        }, timeoutMs);
-        pendingRequestsRef.current.set(requestId, { resolve, reject, timer });
-        ws.send(JSON.stringify({ ...message, payload: { ...message.payload, requestId } }));
-      });
+      const socket = socketRef.current;
+      if (!socket) return Promise.reject(new Error("WebSocket not connected"));
+      return socket.sendConfirmed(message, timeoutMs);
     },
     []
   );
@@ -1869,6 +1978,7 @@ function RecordProviderAuthOnly({
       if (mounted) {
         fetchUser().then((p) => {
           if (mounted) setUserProfile(p);
+        }).catch(() => {
         });
       }
     }, 3e4);
@@ -1962,18 +2072,6 @@ function wsLog(event, label) {
 
 // src/client/storage/RecordScope.tsx
 import { Fragment as Fragment6, jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
-function recordMatchesWhere2(record, where) {
-  if (!where) return true;
-  const r = record;
-  const data = r.data;
-  if (!data) return false;
-  return Object.entries(where).every(([key, value]) => {
-    if (key in data) return data[key] === value;
-    if (key === "recordId") return r.recordId === value;
-    if (key === "createdBy") return r.createdBy === value;
-    return false;
-  });
-}
 function HeadlessScope({
   roomId,
   schemas,
@@ -2011,14 +2109,10 @@ function ScopeConnection({
   const [ready, setReady] = useState4(false);
   const [discoveredSchemas, setDiscoveredSchemas] = useState4([]);
   const storeRef = useRef5(new RecordStore());
-  const wsRef = useRef5(null);
-  const subscriptionMapRef = useRef5(/* @__PURE__ */ new Map());
+  const socketRef = useRef5(null);
+  const subscriptionsRef = useRef5(/* @__PURE__ */ new Map());
   const binaryHandlersRef = useRef5(/* @__PURE__ */ new Set());
   const yjsJoinHandlersRef = useRef5(/* @__PURE__ */ new Map());
-  const pendingRequestsRef = useRef5(/* @__PURE__ */ new Map());
-  const reconnectAttemptRef = useRef5(0);
-  const reconnectTimeoutRef = useRef5(null);
-  const connectTokenRef = useRef5(0);
   const userProfileRef = useRef5(auth?.userProfile ?? null);
   userProfileRef.current = auth?.userProfile ?? null;
   const getAuthTokenRef = useRef5(auth?.getAuthToken ?? null);
@@ -2030,239 +2124,60 @@ function ScopeConnection({
   authCallbacksRef.current.onPermissionError = auth?.onPermissionError;
   authCallbacksRef.current.onValidationError = auth?.onValidationError;
   const allowAnonymous = auth?.allowAnonymous ?? false;
-  const handleMessage = useCallback3(
-    (event) => {
-      if (event.data instanceof ArrayBuffer) {
-        binaryHandlersRef.current.forEach((h) => h(event.data));
-        return;
-      }
-      let msg;
-      try {
-        msg = JSON.parse(event.data);
-      } catch {
-        console.error("[RecordScope] Failed to parse message");
-        return;
-      }
-      const { type, payload } = msg;
-      switch (type) {
-        case MSG.USER_INFO: {
-          const { role } = payload;
-          setRoomRole(role);
-          setReady(true);
-          reconnectAttemptRef.current = 0;
-          const ws = wsRef.current;
-          if (ws?.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify({ type: MSG.USER_LIST, payload: {} }));
-          }
-          break;
-        }
-        case MSG.USER_LIST:
-          setAllUsers(payload.users);
-          setUsersLoaded(true);
-          break;
-        case MSG.QUERY_RESULT: {
-          const { subscriptionId, records } = payload;
-          for (const [subId, queryKey] of subscriptionMapRef.current) {
-            if (subId === subscriptionId) {
-              storeRef.current.setQueryResult(queryKey, records);
-              break;
-            }
-          }
-          break;
-        }
-        case MSG.RECORD_CHANGE: {
-          const { collection, record, changeType } = payload;
-          for (const [, queryKey] of subscriptionMapRef.current) {
-            try {
-              const query = JSON.parse(queryKey);
-              if (query.collection !== collection) continue;
-              const matches = recordMatchesWhere2(record, query.where);
-              const exists = storeRef.current.hasRecord(queryKey, record.recordId);
-              if (changeType === "delete") {
-                if (exists) storeRef.current.applyChange(queryKey, record, "delete");
-              } else if (changeType === "create") {
-                if (matches) storeRef.current.applyChange(queryKey, record, "create");
-              } else {
-                if (matches && exists) storeRef.current.applyChange(queryKey, record, "update");
-                else if (matches && !exists)
-                  storeRef.current.applyChange(queryKey, record, "create");
-                else if (!matches && exists)
-                  storeRef.current.applyChange(queryKey, record, "delete");
-              }
-            } catch {
-            }
-          }
-          break;
-        }
-        case MSG.ERROR: {
-          const { subscriptionId, error } = payload;
-          if (subscriptionId) {
-            for (const [subId, queryKey] of subscriptionMapRef.current) {
-              if (subId === subscriptionId) {
-                storeRef.current.setError(queryKey, error);
-                break;
-              }
-            }
-          } else {
-            const parsed = parseServerError(error);
-            if (parsed.isPermissionError) {
-              authCallbacksRef.current.onPermissionError?.(parsed.title, parsed.detail);
-            } else {
-              authCallbacksRef.current.onValidationError?.(parsed.title, parsed.detail);
-            }
-          }
-          break;
-        }
-        case MSG.YJS_JOIN: {
-          const { collection, recordId, fieldName, canWrite } = payload;
-          const docKey = `${collection}:${recordId}:${fieldName}`;
-          yjsJoinHandlersRef.current.get(docKey)?.forEach((h) => h(canWrite));
-          break;
-        }
-        case MSG.ACK: {
-          const { requestId, success, error, ...rest } = payload;
-          const pending = pendingRequestsRef.current.get(requestId);
-          if (pending) {
-            clearTimeout(pending.timer);
-            pendingRequestsRef.current.delete(requestId);
-            if (success) {
-              pending.resolve(rest);
-            } else {
-              pending.reject(new Error(error || "Mutation rejected"));
-            }
-          }
-          break;
-        }
-        case MSG.LIST_SCHEMAS: {
-          const { schemas: list } = payload;
-          setDiscoveredSchemas(list ?? []);
-          break;
-        }
-        case MSG.RESUBSCRIBE: {
-          const ws = wsRef.current;
-          if (ws?.readyState === WebSocket.OPEN) {
-            for (const [subscriptionId, queryKey] of subscriptionMapRef.current) {
-              try {
-                const query = JSON.parse(queryKey);
-                ws.send(JSON.stringify({ type: MSG.SUBSCRIBE, payload: { subscriptionId, query } }));
-              } catch {
-              }
-            }
-          }
-          break;
-        }
-      }
-    },
-    // Body reads only refs/setters, never roomId; keeping deps empty makes the
-    // handler stable and avoids needlessly re-triggering the connect effect
-    // (which lists roomId itself).
-    []
-  );
-  const connect = useCallback3(async () => {
-    const profile = userProfileRef.current;
-    const hasTokenProvider = !!getAuthTokenRef.current;
-    if (!profile && !hasTokenProvider && !allowAnonymous) return;
-    if (wsRef.current?.readyState === WebSocket.OPEN || wsRef.current?.readyState === WebSocket.CONNECTING)
-      return;
-    if (reconnectTimeoutRef.current) {
-      clearTimeout(reconnectTimeoutRef.current);
-      reconnectTimeoutRef.current = null;
-    }
-    const myToken = ++connectTokenRef.current;
-    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-    const baseUrl = wsUrl?.replace(/^http/, "ws") ?? `${protocol}//${window.location.host}`;
-    const params = new URLSearchParams();
-    try {
-      const tokenFn = getAuthTokenRef.current ?? getAuthToken;
-      const token = await tokenFn();
-      if (token) params.set("token", token);
-    } catch {
-    }
-    if (connectTokenRef.current !== myToken) return;
-    params.set("appId", appId);
-    const url = `${baseUrl}${wsPathPrefix}/${roomId}?${params.toString()}`;
-    wsLog("connecting", roomId);
-    const ws = new WebSocket(url);
-    ws.binaryType = "arraybuffer";
-    wsRef.current = ws;
-    ws.onopen = () => {
-      wsLog("connected", roomId);
-      setStatus("connected");
-      for (const [subscriptionId, queryKey] of subscriptionMapRef.current) {
-        try {
-          const query = JSON.parse(queryKey);
-          ws.send(JSON.stringify({ type: MSG.SUBSCRIBE, payload: { subscriptionId, query } }));
-        } catch {
-        }
-      }
-    };
-    ws.onmessage = handleMessage;
-    ws.onclose = () => {
-      wsLog("disconnected", roomId);
-      setStatus("disconnected");
-      setReady(false);
-      wsRef.current = null;
-      for (const [, queryKey] of subscriptionMapRef.current)
-        storeRef.current.resetToLoading(queryKey);
-      for (const [, pending] of pendingRequestsRef.current) {
-        clearTimeout(pending.timer);
-        pending.reject(new Error("WebSocket disconnected"));
-      }
-      pendingRequestsRef.current.clear();
-      const attempt = reconnectAttemptRef.current;
-      const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
-      reconnectAttemptRef.current = attempt + 1;
-      reconnectTimeoutRef.current = setTimeout(connect, delay);
-    };
-    ws.onerror = () => {
-    };
-  }, [roomId, wsUrl, wsPathPrefix, handleMessage, allowAnonymous, appId]);
-  const disconnect = useCallback3(() => {
-    connectTokenRef.current++;
-    if (reconnectTimeoutRef.current) {
-      clearTimeout(reconnectTimeoutRef.current);
-      reconnectTimeoutRef.current = null;
-    }
-    const ws = wsRef.current;
-    if (ws) {
-      wsLog("closing", roomId);
-      ws.onclose = null;
-      ws.onmessage = null;
-      ws.onerror = null;
-      ws.close();
-      wsRef.current = null;
-    }
-    setStatus("connecting");
-    setReady(false);
-    reconnectAttemptRef.current = 0;
-  }, [roomId]);
   const userProfileId = auth?.userProfile?.id ?? null;
   const userProfileLoading = auth?.userProfileLoading ?? false;
   useEffect5(() => {
     if (userProfileLoading) return;
-    disconnect();
+    const socket = new RecordSocket({
+      roomId,
+      store: storeRef.current,
+      subscriptions: subscriptionsRef.current,
+      binaryHandlers: binaryHandlersRef.current,
+      yjsJoinHandlers: yjsJoinHandlersRef.current,
+      getToken: () => (getAuthTokenRef.current ?? getAuthToken)(),
+      wsUrl,
+      wsPathPrefix,
+      extraParams: { appId },
+      log: (event) => wsLog(event, roomId),
+      listeners: {
+        onStatus: setStatus,
+        onReady: setReady,
+        onRole: setRoomRole,
+        onUsers: (users) => {
+          setAllUsers(users);
+          setUsersLoaded(true);
+        },
+        onSchemas: setDiscoveredSchemas,
+        onPermissionError: (title, detail) => authCallbacksRef.current.onPermissionError?.(title, detail),
+        onValidationError: (title, detail) => authCallbacksRef.current.onValidationError?.(title, detail)
+      }
+    });
+    socketRef.current = socket;
     if (userProfileId || allowAnonymous) {
-      connect();
+      void socket.connect(userProfileId ?? "");
     }
-    return disconnect;
-  }, [userProfileId, userProfileLoading, allowAnonymous, connect, disconnect]);
+    return () => {
+      socketRef.current = null;
+      socket.destroy();
+      setStatus("connecting");
+      setReady(false);
+    };
+  }, [roomId, wsUrl, wsPathPrefix, appId, userProfileId, userProfileLoading, allowAnonymous]);
   useEffect5(() => {
     const onVisible = () => {
-      if (document.visibilityState === "visible" && wsRef.current?.readyState !== WebSocket.OPEN) {
-        reconnectAttemptRef.current = 0;
-        connect();
+      if (document.visibilityState === "visible" && !socketRef.current?.isOpen) {
+        socketRef.current?.resetBackoff();
+        void socketRef.current?.connect();
       }
     };
     document.addEventListener("visibilitychange", onVisible);
     return () => document.removeEventListener("visibilitychange", onVisible);
-  }, [connect]);
+  }, []);
   const sendMessage = useCallback3((message) => {
-    const ws = wsRef.current;
-    if (ws?.readyState === WebSocket.OPEN) ws.send(JSON.stringify(message));
+    socketRef.current?.sendMessage(message);
   }, []);
   const sendBinary = useCallback3((data) => {
-    const ws = wsRef.current;
-    if (ws?.readyState === WebSocket.OPEN) ws.send(data);
+    socketRef.current?.sendBinary(data);
   }, []);
   const onBinaryMessage = useCallback3((handler) => {
     binaryHandlersRef.current.add(handler);
@@ -2272,13 +2187,14 @@ function ScopeConnection({
   }, []);
   const registerYjsJoinHandler = useCallback3(
     (docKey, handler) => {
-      if (!yjsJoinHandlersRef.current.has(docKey)) yjsJoinHandlersRef.current.set(docKey, /* @__PURE__ */ new Set());
-      yjsJoinHandlersRef.current.get(docKey).add(handler);
+      const handlers = yjsJoinHandlersRef.current;
+      if (!handlers.has(docKey)) handlers.set(docKey, /* @__PURE__ */ new Set());
+      handlers.get(docKey).add(handler);
       return () => {
-        const handlers = yjsJoinHandlersRef.current.get(docKey);
-        if (handlers) {
-          handlers.delete(handler);
-          if (handlers.size === 0) yjsJoinHandlersRef.current.delete(docKey);
+        const set = handlers.get(docKey);
+        if (set) {
+          set.delete(handler);
+          if (set.size === 0) handlers.delete(docKey);
         }
       };
     },
@@ -2286,18 +2202,9 @@ function ScopeConnection({
   );
   const sendConfirmed = useCallback3(
     (message, timeoutMs = 1e4) => {
-      const ws = wsRef.current;
-      if (!ws || ws.readyState !== WebSocket.OPEN)
-        return Promise.reject(new Error("WebSocket not connected"));
-      const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-      return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-          pendingRequestsRef.current.delete(requestId);
-          reject(new Error("Mutation confirmation timed out"));
-        }, timeoutMs);
-        pendingRequestsRef.current.set(requestId, { resolve, reject, timer });
-        ws.send(JSON.stringify({ ...message, payload: { ...message.payload, requestId } }));
-      });
+      const socket = socketRef.current;
+      if (!socket) return Promise.reject(new Error("WebSocket not connected"));
+      return socket.sendConfirmed(message, timeoutMs);
     },
     []
   );
@@ -2311,10 +2218,10 @@ function ScopeConnection({
     sendMessage({ type: MSG.USER_LIST, payload: {} });
   }, [sendMessage]);
   const registerSubscription = useCallback3((subscriptionId, queryKey) => {
-    subscriptionMapRef.current.set(subscriptionId, queryKey);
+    subscriptionsRef.current.set(subscriptionId, queryKey);
   }, []);
   const unregisterSubscription = useCallback3((subscriptionId) => {
-    subscriptionMapRef.current.delete(subscriptionId);
+    subscriptionsRef.current.delete(subscriptionId);
   }, []);
   useEffect5(() => {
     if (ready) sendMessage({ type: MSG.LIST_SCHEMAS, payload: {} });