@xnetjs/react 0.0.2 → 0.0.3

package/dist/chunk-QHNYQVUM.js

@@ -0,0 +1,989 @@
+import {
+  flattenNode,
+  useQuery,
+  useSyncManager
+} from "./chunk-6VOICQZ3.js";
+import {
+  useInstrumentation
+} from "./chunk-JCOFKBOB.js";
+import {
+  useDataBridge,
+  useNodeStore,
+  useXNet,
+  useXNetInternal
+} from "./chunk-IHTMVTTE.js";
+
+// src/hooks/useInfiniteQuery.ts
+import { createQueryDescriptor, serializeQueryDescriptor } from "@xnetjs/data-bridge";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+var DEFAULT_PAGE_SIZE = 50;
+function getBaseFilter(filter) {
+  const baseFilter = { ...filter };
+  delete baseFilter.pageSize;
+  delete baseFilter.maxLoaded;
+  delete baseFilter.page;
+  return {
+    ...baseFilter,
+    orderBy: baseFilter.orderBy ?? { updatedAt: "desc" }
+  };
+}
+function chunkIntoPages(data, pageSize, pageInfo) {
+  if (data.length === 0) return [];
+  const pages = [];
+  for (let i = 0; i < data.length; i += pageSize) {
+    pages.push({ cursor: null, data: data.slice(i, i + pageSize), pageInfo });
+  }
+  return pages;
+}
+function useInfiniteQuery(schema, filter = {}) {
+  const pageSize = filter.page?.first ?? filter.pageSize ?? DEFAULT_PAGE_SIZE;
+  const count = filter.page?.count;
+  const maxLoaded = filter.maxLoaded;
+  const baseFilter = useMemo(() => getBaseFilter(filter), [filter]);
+  const baseKey = useMemo(
+    () => serializeQueryDescriptor(createQueryDescriptor(schema._schemaId, baseFilter)),
+    [schema._schemaId, baseFilter]
+  );
+  const [loadedCount, setLoadedCount] = useState(
+    () => maxLoaded === void 0 ? pageSize : Math.min(pageSize, maxLoaded)
+  );
+  useEffect(() => {
+    setLoadedCount(maxLoaded === void 0 ? pageSize : Math.min(pageSize, maxLoaded));
+  }, [baseKey, pageSize, maxLoaded]);
+  const windowFilter = useMemo(
+    () => count ? { ...baseFilter, page: { first: loadedCount, count } } : { ...baseFilter, limit: loadedCount },
+    [baseFilter, loadedCount, count]
+  );
+  const current = useQuery(schema, windowFilter);
+  const lastDataRef = useRef([]);
+  if (!current.loading) {
+    lastDataRef.current = current.data;
+  }
+  const data = current.loading && current.data.length === 0 ? lastDataRef.current : current.data;
+  const atCeiling = maxLoaded !== void 0 && loadedCount >= maxLoaded;
+  const moreAvailable = current.pageInfo.hasMore || !current.loading && current.data.length >= loadedCount;
+  const hasMore = moreAvailable && !atCeiling;
+  const isFetchingNextPage = current.loading && data.length > 0;
+  const fetchNextPage = useCallback(async () => {
+    if (current.loading || !hasMore) return;
+    setLoadedCount((n) => {
+      if (maxLoaded !== void 0 && n >= maxLoaded) return n;
+      const next = n + pageSize;
+      return maxLoaded === void 0 ? next : Math.min(next, maxLoaded);
+    });
+  }, [current.loading, hasMore, maxLoaded, pageSize]);
+  const reset = useCallback(() => {
+    lastDataRef.current = [];
+    setLoadedCount(maxLoaded === void 0 ? pageSize : Math.min(pageSize, maxLoaded));
+  }, [maxLoaded, pageSize]);
+  const reload = useCallback(() => {
+    current.reload();
+  }, [current]);
+  const pages = useMemo(
+    () => chunkIntoPages(data, pageSize, current.pageInfo),
+    [data, pageSize, current.pageInfo]
+  );
+  const pageInfo = useMemo(
+    () => ({ ...current.pageInfo, hasMore, hasNextPage: hasMore, loadedCount: data.length }),
+    [current.pageInfo, hasMore, data.length]
+  );
+  const loading = current.loading && data.length === 0;
+  return {
+    data,
+    pages,
+    status: current.status,
+    loading,
+    isLoading: loading,
+    isFetching: current.isFetching || isFetchingNextPage,
+    isFetchingNextPage,
+    isLive: current.isLive,
+    source: current.source,
+    error: current.error,
+    reload,
+    reset,
+    fetchNextPage,
+    migrationWarnings: current.migrationWarnings,
+    pageInfo,
+    totalCount: pageInfo.totalCount,
+    hasMore,
+    plan: current.plan,
+    materialized: current.materialized,
+    completeness: current.completeness,
+    staleness: current.staleness,
+    verification: current.verification,
+    stream: current.stream
+  };
+}
+
+// src/hooks/useNode.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useRef as useRef2, useMemo as useMemo2 } from "react";
+import * as Y from "yjs";
+import { METABRIDGE_ORIGIN, METABRIDGE_SEED_ORIGIN } from "@xnetjs/runtime";
+import { WebSocketSyncProvider } from "@xnetjs/runtime";
+function log(...args) {
+  if (typeof localStorage !== "undefined" && localStorage.getItem("xnet:sync:debug") === "true") {
+    console.log("[useNode]", ...args);
+  }
+}
+var DEFAULT_SIGNALING_SERVERS = ["ws://localhost:4444"];
+var DEFAULT_PERSIST_DEBOUNCE = 1e3;
+function generateColor(seed) {
+  let hash = 0;
+  for (let i = 0; i < seed.length; i++) {
+    hash = seed.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  const hue = Math.abs(hash % 360);
+  const s = 0.7;
+  const l = 0.5;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(hue / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (hue < 60) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (hue < 120) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (hue < 180) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (hue < 240) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (hue < 300) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  const toHex = (v) => Math.round((v + m) * 255).toString(16).padStart(2, "0");
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function hasSyncManagerSetter(bridge) {
+  if (!bridge || typeof bridge !== "object") {
+    return false;
+  }
+  const candidate = bridge;
+  return typeof candidate.setSyncManager === "function";
+}
+var pendingFlushes = /* @__PURE__ */ new Map();
+function nowMs() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function useNode(schema, id, options = {}) {
+  const {
+    signalingServers = DEFAULT_SIGNALING_SERVERS,
+    disableSync = false,
+    persistDebounce = DEFAULT_PERSIST_DEBOUNCE,
+    createIfMissing,
+    did
+  } = options;
+  const createIfMissingRef = useRef2(createIfMissing);
+  createIfMissingRef.current = createIfMissing;
+  const { store, isReady } = useNodeStore();
+  const syncManager = useSyncManager();
+  const bridge = useDataBridge();
+  const {
+    authorDID: syncAuthorDID,
+    signingKey: syncSigningKey,
+    sync: syncConfig
+  } = useXNetInternal();
+  const instrumentation = useInstrumentation();
+  const schemaId = schema._schemaId;
+  const hasDocument = schema.schema.document === "yjs";
+  const usingBridgeRef = useRef2(false);
+  const [data, setData] = useState2(null);
+  const [doc, setDoc] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const [isDirty, setIsDirty] = useState2(false);
+  const [lastSavedAt, setLastSavedAt] = useState2(null);
+  const [syncStatus, setSyncStatus] = useState2("offline");
+  const [syncError, setSyncError] = useState2(null);
+  const [peerCount, setPeerCount] = useState2(0);
+  const [wasCreated, setWasCreated] = useState2(false);
+  const [livePresence, setLivePresence] = useState2([]);
+  const [snapshotPresence, setSnapshotPresence] = useState2([]);
+  const [awareness, setAwareness] = useState2(null);
+  const presence = useMemo2(() => {
+    if (livePresence.length === 0 && snapshotPresence.length === 0) return [];
+    const liveByDid = new Map(livePresence.map((user) => [user.did, user]));
+    const snapshotByDid = new Map(snapshotPresence.map((user) => [user.did, user]));
+    const mergedLive = livePresence.map((user) => ({
+      ...snapshotByDid.get(user.did),
+      ...user,
+      isStale: false
+    }));
+    const mergedSnapshot = snapshotPresence.filter((user) => !liveByDid.has(user.did));
+    return [...mergedLive, ...mergedSnapshot];
+  }, [livePresence, snapshotPresence]);
+  const providerRef = useRef2(null);
+  const saveTimeoutRef = useRef2(null);
+  const docRef = useRef2(null);
+  const creatingRef = useRef2(false);
+  const storeRef = useRef2(store);
+  storeRef.current = store;
+  const dataRef = useRef2(null);
+  dataRef.current = data;
+  const loadDurationRef = useRef2(0);
+  const queryIdRef = useRef2(
+    `useNode-${schemaId}-${id || "null"}-${Math.random().toString(36).slice(2, 8)}`
+  );
+  useEffect2(() => {
+    if (!instrumentation?.queryTracker || !id) return;
+    instrumentation.queryTracker.register(queryIdRef.current, {
+      type: "useNode",
+      schemaId,
+      mode: "document",
+      descriptorKey: `node:${schemaId}:${id}`,
+      nodeId: id
+    });
+    return () => {
+      instrumentation.queryTracker.unregister(queryIdRef.current);
+    };
+  }, [instrumentation, schemaId, id]);
+  const load = useCallback2(async () => {
+    if (!store || !isReady || !id) {
+      setData(null);
+      setDoc(null);
+      setLoading(false);
+      return;
+    }
+    if (hasDocument && !disableSync && !syncManager) {
+      setLoading(true);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    setWasCreated(false);
+    setSyncError(null);
+    const loadStartedAt = nowMs();
+    try {
+      const pendingFlush = pendingFlushes.get(id);
+      if (pendingFlush) {
+        await pendingFlush;
+      }
+      let node = await store.get(id);
+      let justCreated = false;
+      if (!node && createIfMissingRef.current && !creatingRef.current) {
+        creatingRef.current = true;
+        try {
+          node = await store.create({
+            id,
+            schemaId,
+            properties: createIfMissingRef.current
+          });
+          justCreated = true;
+          setWasCreated(true);
+          log("Node auto-created:", id);
+        } finally {
+          creatingRef.current = false;
+        }
+      }
+      if (node?.deleted && createIfMissingRef.current) {
+        node = await store.restore(id);
+      }
+      if (!node || node.schemaId !== schemaId) {
+        setData(null);
+        setDoc(null);
+        setLoading(false);
+        return;
+      }
+      setData(flattenNode(node));
+      if (hasDocument) {
+        if (docRef.current && docRef.current.guid === id) {
+          setDoc(docRef.current);
+          setLastSavedAt(node.updatedAt);
+        } else {
+          if (docRef.current) {
+            instrumentation?.yDocRegistry.unregister(docRef.current.guid);
+            if (!usingBridgeRef.current) {
+              if (providerRef.current) {
+                providerRef.current.destroy();
+                providerRef.current = null;
+              }
+              docRef.current.destroy();
+            } else if (docRef.current.guid) {
+              syncManager?.release(docRef.current.guid);
+            }
+            docRef.current = null;
+            setDoc(null);
+            usingBridgeRef.current = false;
+          }
+          let ydoc;
+          let acquiredAwareness = null;
+          if (bridge?.acquireDoc && !disableSync) {
+            if (syncManager && hasSyncManagerSetter(bridge)) {
+              bridge.setSyncManager(syncManager);
+            }
+            const acquired = await bridge.acquireDoc(id);
+            ydoc = acquired.doc;
+            acquiredAwareness = acquired.awareness;
+            usingBridgeRef.current = true;
+            const storedContent = await store.getDocumentContent(id);
+            if (storedContent && storedContent.length > 0) {
+              Y.applyUpdate(ydoc, storedContent, "storage");
+            }
+            if (syncManager) {
+              syncManager.track(id, schemaId);
+            }
+          } else if (syncManager && !disableSync) {
+            ydoc = await syncManager.acquire(id);
+            usingBridgeRef.current = true;
+            const storedContent = await store.getDocumentContent(id);
+            if (storedContent && storedContent.length > 0) {
+              Y.applyUpdate(ydoc, storedContent, "storage");
+            }
+            syncManager.track(id, schemaId);
+          } else {
+            log("Using fallback WebSocketSyncProvider path for:", id);
+            ydoc = new Y.Doc({ guid: id, gc: false });
+            usingBridgeRef.current = false;
+            const storedContent = await store.getDocumentContent(id);
+            if (storedContent && storedContent.length > 0) {
+              Y.applyUpdate(ydoc, storedContent);
+            }
+          }
+          if (acquiredAwareness) {
+            setAwareness(acquiredAwareness);
+          }
+          docRef.current = ydoc;
+          const metaMap = ydoc.getMap("meta");
+          if (metaMap.size === 0 && node.properties) {
+            const entries = Object.entries(node.properties);
+            const hasContent = entries.some(([, v]) => v !== "" && v !== null && v !== void 0);
+            if (hasContent || !justCreated) {
+              ydoc.transact(() => {
+                metaMap.set("_schemaId", schemaId);
+                for (const [key, value] of entries) {
+                  if (!justCreated || value !== "" && value !== null && value !== void 0) {
+                    metaMap.set(key, value);
+                  }
+                }
+              }, "local");
+            }
+          }
+          instrumentation?.yDocRegistry.register(id, ydoc);
+          setDoc(ydoc);
+          setLastSavedAt(node.updatedAt);
+        }
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      loadDurationRef.current = Math.max(0, nowMs() - loadStartedAt);
+      setLoading(false);
+    }
+  }, [store, isReady, id, schemaId, hasDocument, syncManager, disableSync]);
+  const save = useCallback2(async () => {
+    if (!store || !id || !docRef.current) return;
+    saveTimeoutRef.current = null;
+    try {
+      const content = Y.encodeStateAsUpdate(docRef.current);
+      await store.setDocumentContent(id, content);
+      setIsDirty(false);
+      setLastSavedAt(Date.now());
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [store, id]);
+  const saveRef = useRef2(save);
+  saveRef.current = save;
+  const scheduleSave = useCallback2(() => {
+    setIsDirty(true);
+    if (saveTimeoutRef.current) {
+      clearTimeout(saveTimeoutRef.current);
+    }
+    saveTimeoutRef.current = setTimeout(() => {
+      saveRef.current();
+    }, persistDebounce);
+  }, [persistDebounce]);
+  const update = useCallback2(
+    async (properties) => {
+      if (!store || !isReady || !id) return;
+      try {
+        const node = await store.update(id, {
+          properties
+        });
+        setData(flattenNode(node));
+        if (docRef.current) {
+          const metaMap = docRef.current.getMap("meta");
+          docRef.current.transact(() => {
+            metaMap.set("_schemaId", schemaId);
+            for (const [key, value] of Object.entries(properties)) {
+              metaMap.set(key, value);
+            }
+          }, "local");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store, isReady, id]
+  );
+  const remove = useCallback2(async () => {
+    if (!store || !isReady || !id) return;
+    try {
+      await store.delete(id);
+      setData(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [store, isReady, id]);
+  useEffect2(() => {
+    load();
+  }, [load]);
+  useEffect2(() => {
+    if (!doc || !id || !hasDocument) return;
+    if (doc.guid !== id) {
+      return;
+    }
+    if (usingBridgeRef.current && syncManager) {
+      let receivedSyncData = false;
+      let syncTimeoutId = null;
+      const updateHandler2 = (_update, origin) => {
+        if (origin === "remote") {
+          receivedSyncData = true;
+          if (syncTimeoutId) {
+            clearTimeout(syncTimeoutId);
+            syncTimeoutId = null;
+          }
+          setSyncError(null);
+        }
+        scheduleSave();
+      };
+      doc.on("update", updateHandler2);
+      const metaMap = doc.getMap("meta");
+      const applyMetaToNodeStore = () => {
+        if (metaMap.size === 0 || !storeRef.current || !id) return;
+        const remoteProps = {};
+        metaMap.forEach((value, key) => {
+          if (key.startsWith("_")) return;
+          remoteProps[key] = value;
+        });
+        if (Object.keys(remoteProps).length === 0) return;
+        const currentData = dataRef.current;
+        if (currentData) {
+          let hasChanges = false;
+          for (const [key, value] of Object.entries(remoteProps)) {
+            if (currentData[key] !== value) {
+              hasChanges = true;
+              break;
+            }
+          }
+          if (!hasChanges) return;
+        }
+        storeRef.current.update(id, { properties: remoteProps }).then((node) => {
+          if (node) setData(flattenNode(node));
+        }).catch((err) => {
+          console.warn("[useNode] Failed to apply remote meta to NodeStore:", err);
+        });
+      };
+      const metaObserver = (event) => {
+        const origin = event.transaction.origin;
+        if (origin === null || origin === "local" || origin === "storage" || origin === METABRIDGE_ORIGIN || origin === METABRIDGE_SEED_ORIGIN) {
+          return;
+        }
+        applyMetaToNodeStore();
+      };
+      metaMap.observe(metaObserver);
+      if (metaMap.size > 0) {
+        applyMetaToNodeStore();
+      }
+      const statusUnsub = syncManager.on("status", (status) => {
+        setSyncStatus(
+          status === "connected" ? "connected" : status === "connecting" ? "connecting" : "offline"
+        );
+      });
+      setSyncStatus(
+        syncManager.status === "connected" ? "connected" : syncManager.status === "connecting" ? "connecting" : "offline"
+      );
+      const awareness2 = syncManager.getAwareness(id);
+      setAwareness(awareness2);
+      if (awareness2 && did) {
+        awareness2.setLocalStateField("user", {
+          did,
+          name: `${did.slice(8, 16)}...`,
+          color: generateColor(did)
+        });
+      }
+      let awarenessCleanup = null;
+      if (awareness2) {
+        const awarenessHandler = () => {
+          const states = awareness2.getStates();
+          const nextPresence = [];
+          states.forEach((state, clientId) => {
+            if (clientId === awareness2.clientID) return;
+            const user = state.user;
+            if (user?.did) {
+              nextPresence.push({
+                did: user.did,
+                name: user.name,
+                color: user.color || generateColor(user.did),
+                isStale: false
+              });
+            }
+          });
+          setLivePresence(nextPresence);
+        };
+        awareness2.on("change", awarenessHandler);
+        awarenessHandler();
+        awarenessCleanup = () => awareness2.off("change", awarenessHandler);
+      }
+      const snapshotUnsub = syncManager.onAwarenessSnapshot(id, (users) => {
+        const mapped = users.map((user) => ({
+          did: user.did,
+          name: user.state.user?.name,
+          color: user.state.user?.color ?? generateColor(user.did),
+          lastSeen: user.lastSeen,
+          isStale: user.isStale
+        }));
+        setSnapshotPresence(mapped);
+      });
+      if (wasCreated) {
+        syncTimeoutId = setTimeout(() => {
+          const fragment = doc.getXmlFragment("default");
+          const metaMap2 = doc.getMap("meta");
+          const hasContent = (fragment?.length ?? 0) > 0 || metaMap2.size > 1;
+          if (!receivedSyncData && !hasContent) {
+            const errorMsg = "Sync timeout: No content received from peers. The shared document may not exist or peers may be offline.";
+            log("Sync timeout - no content received for:", id);
+            setSyncStatus("error");
+            setSyncError(errorMsg);
+          }
+        }, 1e4);
+      }
+      return () => {
+        if (syncTimeoutId) {
+          clearTimeout(syncTimeoutId);
+        }
+        doc.off("update", updateHandler2);
+        metaMap.unobserve(metaObserver);
+        statusUnsub();
+        if (awarenessCleanup) awarenessCleanup();
+        snapshotUnsub();
+        setAwareness(null);
+        setSyncStatus("offline");
+        setSyncError(null);
+        setPeerCount(0);
+        setLivePresence([]);
+        setSnapshotPresence([]);
+      };
+    }
+    const updateHandler = (_update, _origin) => {
+      scheduleSave();
+    };
+    doc.on("update", updateHandler);
+    if (!disableSync && signalingServers.length > 0) {
+      setSyncStatus("connecting");
+      const provider = new WebSocketSyncProvider(doc, {
+        url: signalingServers[0],
+        room: `xnet-doc-${id}`,
+        authorDID: syncAuthorDID ?? did ?? void 0,
+        signingKey: syncSigningKey ?? void 0,
+        replication: syncConfig
+      });
+      providerRef.current = provider;
+      let receivedSyncData = false;
+      let syncTimeoutId = null;
+      const statusHandler = (event) => {
+        const { connected } = event;
+        setSyncStatus(connected ? "connected" : "connecting");
+      };
+      provider.on("status", statusHandler);
+      const metaMap = doc.getMap("meta");
+      const applyMetaToNodeStore = () => {
+        if (metaMap.size === 0) return;
+        const props = {};
+        metaMap.forEach((value, key) => {
+          if (key.startsWith("_")) return;
+          props[key] = value;
+        });
+        if (Object.keys(props).length > 0 && storeRef.current && id) {
+          storeRef.current.update(id, { properties: props }).then((node) => {
+            if (node) setData(flattenNode(node));
+          }).catch((err) => {
+            console.warn("[useDocument] Failed to apply remote meta to NodeStore:", err);
+          });
+        }
+      };
+      const metaObserver = (event) => {
+        const origin = event.transaction.origin;
+        if (origin === null || origin === "local" || origin === "storage" || origin === METABRIDGE_ORIGIN || origin === METABRIDGE_SEED_ORIGIN) {
+          return;
+        }
+        applyMetaToNodeStore();
+      };
+      metaMap.observe(metaObserver);
+      const syncedHandler = (event) => {
+        const { synced } = event;
+        if (synced) {
+          receivedSyncData = true;
+          if (syncTimeoutId) {
+            clearTimeout(syncTimeoutId);
+            syncTimeoutId = null;
+          }
+          setSyncError(null);
+          applyMetaToNodeStore();
+        }
+      };
+      provider.on("synced", syncedHandler);
+      if (wasCreated) {
+        syncTimeoutId = setTimeout(() => {
+          const fragment = doc.getXmlFragment("default");
+          const metaMap2 = doc.getMap("meta");
+          const hasContent = (fragment?.length ?? 0) > 0 || metaMap2.size > 1;
+          if (!receivedSyncData && !hasContent) {
+            const errorMsg = "Sync timeout: No content received from peers. The shared document may not exist or peers may be offline.";
+            log("Sync timeout - no content received for:", id);
+            setSyncStatus("error");
+            setSyncError(errorMsg);
+          }
+        }, 1e4);
+      }
+      const peersHandler = (event) => {
+        const { count } = event;
+        setPeerCount(count);
+      };
+      provider.on("peers", peersHandler);
+      const { awareness: providerAwareness } = provider;
+      setAwareness(providerAwareness);
+      if (did) {
+        providerAwareness.setLocalStateField("user", {
+          did,
+          name: `${did.slice(8, 16)}...`,
+          color: generateColor(did)
+        });
+      }
+      const awarenessHandler = () => {
+        const states = providerAwareness.getStates();
+        const nextPresence = [];
+        states.forEach((state, clientId) => {
+          if (clientId === providerAwareness.clientID) return;
+          const user = state.user;
+          if (user?.did) {
+            nextPresence.push({
+              did: user.did,
+              name: user.name,
+              color: user.color || generateColor(user.did),
+              isStale: false
+            });
+          }
+        });
+        setLivePresence(nextPresence);
+      };
+      providerAwareness.on("change", awarenessHandler);
+      const snapshotHandler = (users) => {
+        if (!Array.isArray(users)) return;
+        const mapped = users.filter(
+          (user) => Boolean(
+            user && typeof user === "object" && typeof user.did === "string"
+          )
+        ).map(
+          (user) => ({
+            did: user.did,
+            name: user.state.user?.name,
+            color: user.state.user?.color ?? generateColor(user.did),
+            lastSeen: user.lastSeen,
+            isStale: user.isStale
+          })
+        );
+        setSnapshotPresence(mapped);
+      };
+      provider.on("awareness-snapshot", snapshotHandler);
+      return () => {
+        if (syncTimeoutId) {
+          clearTimeout(syncTimeoutId);
+        }
+        doc.off("update", updateHandler);
+        metaMap.unobserve(metaObserver);
+        providerAwareness.off("change", awarenessHandler);
+        provider.off("awareness-snapshot", snapshotHandler);
+        provider.off("synced", syncedHandler);
+        provider.off("status", statusHandler);
+        provider.off("peers", peersHandler);
+        provider.destroy();
+        providerRef.current = null;
+        setAwareness(null);
+        setSyncStatus("offline");
+        setSyncError(null);
+        setPeerCount(0);
+        setLivePresence([]);
+        setSnapshotPresence([]);
+      };
+    }
+    return () => {
+      doc.off("update", updateHandler);
+    };
+  }, [
+    doc,
+    id,
+    hasDocument,
+    disableSync,
+    signalingServers,
+    scheduleSave,
+    did,
+    syncManager,
+    wasCreated
+  ]);
+  useEffect2(() => {
+    return () => {
+      if (saveTimeoutRef.current) {
+        clearTimeout(saveTimeoutRef.current);
+        saveTimeoutRef.current = null;
+      }
+      if (docRef.current && store && id) {
+        const content = Y.encodeStateAsUpdate(docRef.current);
+        const flushPromise = store.setDocumentContent(id, content).catch(() => {
+        }).finally(() => {
+          pendingFlushes.delete(id);
+        });
+        pendingFlushes.set(id, flushPromise);
+      }
+      if (usingBridgeRef.current && id) {
+        if (bridge?.releaseDoc) {
+          bridge.releaseDoc(id);
+        } else if (syncManager) {
+          syncManager.release(id);
+        }
+        usingBridgeRef.current = false;
+      }
+    };
+  }, [store, id, syncManager, bridge]);
+  useEffect2(() => {
+    if (!store || !id || !hasDocument) return;
+    const handleBeforeUnload = () => {
+      if (saveTimeoutRef.current) {
+        clearTimeout(saveTimeoutRef.current);
+        saveTimeoutRef.current = null;
+      }
+      if (docRef.current) {
+        try {
+          const content = Y.encodeStateAsUpdate(docRef.current);
+          store.setDocumentContent(id, content).catch(() => {
+          });
+        } catch {
+        }
+      }
+    };
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => {
+      window.removeEventListener("beforeunload", handleBeforeUnload);
+    };
+  }, [store, id, hasDocument]);
+  useEffect2(() => {
+    if (!store || !id) return;
+    const unsubscribe = store.subscribeToNode(id, (event) => {
+      if (event.node && event.node.schemaId === schemaId) {
+        setData(flattenNode(event.node));
+      }
+    });
+    return unsubscribe;
+  }, [store, id, schemaId]);
+  useEffect2(() => {
+    if (!instrumentation?.queryTracker || !id || loading) return;
+    instrumentation.queryTracker.recordUpdate(
+      queryIdRef.current,
+      data ? 1 : 0,
+      loadDurationRef.current,
+      { source: "local" }
+    );
+    loadDurationRef.current = 0;
+  }, [data, instrumentation, id, loading]);
+  return {
+    // Data
+    data,
+    doc,
+    // Mutations
+    update,
+    remove,
+    // State
+    loading,
+    error,
+    isDirty,
+    lastSavedAt,
+    wasCreated,
+    // Sync
+    syncStatus,
+    syncError,
+    peerCount,
+    // Presence
+    presence,
+    awareness,
+    // Actions
+    save,
+    reload: load
+  };
+}
+
+// src/hooks/useIdentity.ts
+function useIdentity() {
+  const { identity, authorDID } = useXNet();
+  return {
+    identity: identity ?? null,
+    isAuthenticated: !!identity || !!authorDID,
+    did: identity?.did ?? authorDID ?? null
+  };
+}
+
+// src/components/ErrorBoundary.tsx
+import { Component } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ErrorBoundary = class extends Component {
+  state = { hasError: false, error: null };
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error("[ErrorBoundary]", error, errorInfo);
+    this.props.onError?.(error, errorInfo);
+  }
+  handleReset = () => {
+    this.setState({ hasError: false, error: null });
+  };
+  componentDidUpdate(prevProps) {
+    if (this.state.hasError && this.props.resetKey !== void 0 && prevProps.resetKey !== this.props.resetKey) {
+      this.handleReset();
+    }
+  }
+  render() {
+    if (!this.state.hasError) {
+      return this.props.children;
+    }
+    if (this.props.fallback) {
+      if (typeof this.props.fallback === "function") {
+        return this.props.fallback({
+          error: this.state.error ?? new Error("Unknown error"),
+          reset: this.handleReset
+        });
+      }
+      return this.props.fallback;
+    }
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        role: "alert",
+        style: {
+          padding: "2rem",
+          textAlign: "center",
+          maxWidth: "480px",
+          margin: "4rem auto"
+        },
+        children: [
+          /* @__PURE__ */ jsx("h2", { style: { fontSize: "1.25rem", fontWeight: 600, marginBottom: "0.5rem" }, children: "Something went wrong" }),
+          /* @__PURE__ */ jsx("p", { style: { color: "#666", marginBottom: "1rem", fontSize: "0.875rem" }, children: this.state.error?.message ?? "An unexpected error occurred." }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: this.handleReset,
+              style: {
+                padding: "0.5rem 1rem",
+                borderRadius: "6px",
+                border: "1px solid #ccc",
+                background: "#fff",
+                cursor: "pointer",
+                fontSize: "0.875rem"
+              },
+              children: "Try again"
+            }
+          )
+        ]
+      }
+    );
+  }
+};
+
+// src/components/OfflineIndicator.tsx
+import { useState as useState3, useEffect as useEffect3 } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function useIsOffline() {
+  const [offline, setOffline] = useState3(
+    typeof navigator !== "undefined" ? !navigator.onLine : false
+  );
+  useEffect3(() => {
+    const goOffline = () => setOffline(true);
+    const goOnline = () => setOffline(false);
+    window.addEventListener("offline", goOffline);
+    window.addEventListener("online", goOnline);
+    return () => {
+      window.removeEventListener("offline", goOffline);
+      window.removeEventListener("online", goOnline);
+    };
+  }, []);
+  return offline;
+}
+function OfflineIndicator({
+  message = "You are offline. Changes will sync when reconnected.",
+  className,
+  position = "bottom"
+}) {
+  const offline = useIsOffline();
+  if (!offline) return null;
+  const positionStyle = position === "top" ? { top: 0 } : { bottom: 0 };
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      role: "status",
+      "aria-live": "polite",
+      className,
+      style: {
+        position: "fixed",
+        left: 0,
+        right: 0,
+        zIndex: 9999,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        gap: "0.5rem",
+        padding: "0.5rem 1rem",
+        background: "#fbbf24",
+        color: "#78350f",
+        fontSize: "0.875rem",
+        fontWeight: 500,
+        ...positionStyle
+      },
+      children: [
+        /* @__PURE__ */ jsxs2(
+          "svg",
+          {
+            width: "16",
+            height: "16",
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            children: [
+              /* @__PURE__ */ jsx2("line", { x1: "1", y1: "1", x2: "23", y2: "23" }),
+              /* @__PURE__ */ jsx2("path", { d: "M16.72 11.06A10.94 10.94 0 0 1 19 12.55" }),
+              /* @__PURE__ */ jsx2("path", { d: "M5 12.55a10.94 10.94 0 0 1 5.17-2.39" }),
+              /* @__PURE__ */ jsx2("path", { d: "M10.71 5.05A16 16 0 0 1 22.56 9" }),
+              /* @__PURE__ */ jsx2("path", { d: "M1.42 9a15.91 15.91 0 0 1 4.7-2.88" }),
+              /* @__PURE__ */ jsx2("path", { d: "M8.53 16.11a6 6 0 0 1 6.95 0" }),
+              /* @__PURE__ */ jsx2("line", { x1: "12", y1: "20", x2: "12.01", y2: "20" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx2("span", { children: message })
+      ]
+    }
+  );
+}
+
+export {
+  useInfiniteQuery,
+  useNode,
+  useIdentity,
+  ErrorBoundary,
+  useIsOffline,
+  OfflineIndicator
+};