@xnetjs/react 0.0.2 → 0.0.3

package/dist/chunk-CWHCGYDW.js

@@ -1,2238 +0,0 @@
-// src/context/security-context.tsx
-import { DEFAULT_SECURITY_LEVEL } from "@xnetjs/crypto";
-import { MemoryPQKeyRegistry } from "@xnetjs/identity";
-import { createContext, useContext, useState, useMemo, useEffect } from "react";
-import { jsx } from "react/jsx-runtime";
-var SecurityContext = createContext(null);
-function SecurityProvider({
-  children,
-  level: initialLevel = DEFAULT_SECURITY_LEVEL,
-  minVerificationLevel: initialMinLevel = 0,
-  verificationPolicy: initialPolicy = "strict",
-  registry: providedRegistry,
-  keyBundle: initialBundle
-}) {
-  const [level, setLevel] = useState(initialLevel);
-  const [minVerificationLevel, setMinVerificationLevel] = useState(initialMinLevel);
-  const [verificationPolicy, setVerificationPolicy] = useState(
-    initialPolicy
-  );
-  const [keyBundle, setKeyBundle] = useState(initialBundle);
-  useEffect(() => {
-    setLevel(initialLevel);
-  }, [initialLevel]);
-  useEffect(() => {
-    setMinVerificationLevel(initialMinLevel);
-  }, [initialMinLevel]);
-  useEffect(() => {
-    setVerificationPolicy(initialPolicy);
-  }, [initialPolicy]);
-  useEffect(() => {
-    setKeyBundle(initialBundle);
-  }, [initialBundle]);
-  const registry = useMemo(() => providedRegistry ?? new MemoryPQKeyRegistry(), [providedRegistry]);
-  const value = useMemo(
-    () => ({
-      level,
-      minVerificationLevel,
-      verificationPolicy,
-      registry,
-      keyBundle,
-      setLevel,
-      setMinVerificationLevel,
-      setVerificationPolicy,
-      setKeyBundle
-    }),
-    [level, minVerificationLevel, verificationPolicy, registry, keyBundle]
-  );
-  return /* @__PURE__ */ jsx(SecurityContext.Provider, { value, children });
-}
-function useSecurityContext() {
-  const context = useContext(SecurityContext);
-  if (!context) {
-    throw new Error("useSecurityContext must be used within SecurityProvider");
-  }
-  return context;
-}
-function useSecurityContextOptional() {
-  return useContext(SecurityContext);
-}
-
-// src/context/telemetry-context.ts
-import { createContext as createContext2, useContext as useContext2 } from "react";
-var TelemetryContext = createContext2(null);
-function useTelemetryReporter() {
-  return useContext2(TelemetryContext);
-}
-
-// src/hooks/usePlugins.ts
-import { createContext as createContext3, useContext as useContext3, useState as useState2, useEffect as useEffect2 } from "react";
-var PluginRegistryContext = createContext3(null);
-function usePluginRegistry() {
-  const registry = useContext3(PluginRegistryContext);
-  if (!registry) {
-    throw new Error(
-      "usePluginRegistry must be used within XNetProvider with plugins enabled. Ensure XNetProvider has platform: 'electron' or platform: 'web' in its config."
-    );
-  }
-  return registry;
-}
-function usePluginRegistryOptional() {
-  return useContext3(PluginRegistryContext);
-}
-function usePlugins() {
-  const registry = usePluginRegistry();
-  const [plugins, setPlugins] = useState2(() => registry.getAll());
-  useEffect2(() => {
-    setPlugins(registry.getAll());
-    const disposable = registry.onChange(() => {
-      setPlugins(registry.getAll());
-    });
-    return () => disposable.dispose();
-  }, [registry]);
-  return plugins;
-}
-function getTypedRegistry(contributions, type) {
-  switch (type) {
-    case "views":
-      return contributions.views;
-    case "commands":
-      return contributions.commands;
-    case "slashCommands":
-      return contributions.slashCommands;
-    case "sidebar":
-      return contributions.sidebar;
-    case "editor":
-      return contributions.editor;
-    case "propertyHandlers":
-      return contributions.propertyHandlers;
-    case "blocks":
-      return contributions.blocks;
-    case "settings":
-      return contributions.settings;
-    default:
-      throw new Error(`Unknown contribution type: ${type}`);
-  }
-}
-function useContributions(type) {
-  const registry = usePluginRegistry();
-  const contributions = registry.getContributions();
-  const typedRegistry = getTypedRegistry(contributions, type);
-  const [items, setItems] = useState2(() => typedRegistry.getAll());
-  useEffect2(() => {
-    setItems(typedRegistry.getAll());
-    const unsubscribe = typedRegistry.onChange(() => {
-      setItems(typedRegistry.getAll());
-    });
-    return unsubscribe;
-  }, [typedRegistry]);
-  return items;
-}
-function useViews() {
-  return useContributions("views");
-}
-function useCommands() {
-  return useContributions("commands");
-}
-function useSlashCommands() {
-  return useContributions("slashCommands");
-}
-function useSidebarItems() {
-  return useContributions("sidebar");
-}
-function useEditorExtensions() {
-  return useContributions("editor");
-}
-function useEditorExtensionsSafe() {
-  const registry = usePluginRegistryOptional();
-  const [items, setItems] = useState2([]);
-  useEffect2(() => {
-    if (!registry) {
-      setItems([]);
-      return;
-    }
-    const contributions = registry.getContributions();
-    const typedRegistry = contributions.editor;
-    setItems(typedRegistry.getAll());
-    const unsubscribe = typedRegistry.onChange(() => {
-      setItems(typedRegistry.getAll());
-    });
-    return unsubscribe;
-  }, [registry]);
-  return items;
-}
-function useView(type) {
-  const views = useViews();
-  return views.find((v) => v.type === type);
-}
-function useCommand(id) {
-  const commands = useCommands();
-  return commands.find((c) => c.id === id);
-}
-
-// src/sync/blob-sync.ts
-var BLOB_SYNC_ROOM = "xnet-blob-sync";
-var MAX_INLINE_SIZE = 256 * 1024;
-function createBlobSyncProvider(config) {
-  const { blobStore, connection, onBlobReceived } = config;
-  let cleanup = null;
-  const pendingRequests = /* @__PURE__ */ new Set();
-  function toBase642(data) {
-    let binary = "";
-    for (let i = 0; i < data.length; i++) {
-      binary += String.fromCharCode(data[i]);
-    }
-    return btoa(binary);
-  }
-  function fromBase64(str) {
-    const binary = atob(str);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-  }
-  async function handleMessage(data) {
-    const msg = data;
-    switch (msg.type) {
-      case "blob-want": {
-        for (const cid of msg.cids) {
-          const blobData = await blobStore.get(cid);
-          if (blobData) {
-            if (blobData.byteLength <= MAX_INLINE_SIZE) {
-              connection.publish(BLOB_SYNC_ROOM, {
-                type: "blob-data",
-                cid,
-                data: toBase642(blobData)
-              });
-            } else {
-              connection.publish(BLOB_SYNC_ROOM, {
-                type: "blob-data",
-                cid,
-                data: toBase642(blobData)
-              });
-            }
-          } else {
-            connection.publish(BLOB_SYNC_ROOM, {
-              type: "blob-not-found",
-              cid
-            });
-          }
-        }
-        break;
-      }
-      case "blob-data": {
-        const blobData = fromBase64(msg.data);
-        await blobStore.put(blobData);
-        pendingRequests.delete(msg.cid);
-        onBlobReceived?.(msg.cid);
-        break;
-      }
-      case "blob-not-found": {
-        pendingRequests.delete(msg.cid);
-        break;
-      }
-      case "blob-have": {
-        const needed = [];
-        for (const cid of msg.cids) {
-          if (!await blobStore.has(cid)) {
-            needed.push(cid);
-          }
-        }
-        if (needed.length > 0) {
-          connection.publish(BLOB_SYNC_ROOM, {
-            type: "blob-want",
-            cids: needed
-          });
-          for (const cid of needed) {
-            pendingRequests.add(cid);
-          }
-        }
-        break;
-      }
-    }
-  }
-  return {
-    start() {
-      if (cleanup) return;
-      cleanup = connection.joinRoom(BLOB_SYNC_ROOM, (data) => {
-        handleMessage(data);
-      });
-    },
-    stop() {
-      if (cleanup) {
-        cleanup();
-        cleanup = null;
-      }
-      pendingRequests.clear();
-    },
-    async requestBlobs(cids) {
-      const missing = [];
-      for (const cid of cids) {
-        if (!await blobStore.has(cid)) {
-          missing.push(cid);
-        }
-      }
-      if (missing.length > 0) {
-        connection.publish(BLOB_SYNC_ROOM, {
-          type: "blob-want",
-          cids: missing
-        });
-        for (const cid of missing) {
-          pendingRequests.add(cid);
-        }
-      }
-    },
-    announceHave(cids) {
-      if (cids.length > 0) {
-        connection.publish(BLOB_SYNC_ROOM, {
-          type: "blob-have",
-          cids
-        });
-      }
-    },
-    get pendingCount() {
-      return pendingRequests.size;
-    }
-  };
-}
-
-// src/sync/connection-manager.ts
-function log(...args) {
-  if (typeof localStorage !== "undefined" && localStorage.getItem("xnet:sync:debug") === "true") {
-    console.log("[ConnectionManager]", ...args);
-  }
-}
-function createConnectionManager(config) {
-  let ws = null;
-  let status = "disconnected";
-  let reconnectAttempts = 0;
-  let reconnectTimer = null;
-  let destroyed = false;
-  let connectInProgress = false;
-  const reconnectDelay = config.reconnectDelay ?? 2e3;
-  const maxReconnects = config.maxReconnects ?? Infinity;
-  const rooms = /* @__PURE__ */ new Map();
-  const statusListeners = /* @__PURE__ */ new Set();
-  const messageListeners = /* @__PURE__ */ new Set();
-  const pendingSubscriptions = /* @__PURE__ */ new Map();
-  function setStatus(s) {
-    log("Status changed:", status, "->", s);
-    status = s;
-    for (const handler of statusListeners) {
-      try {
-        handler(s);
-      } catch {
-      }
-    }
-  }
-  function send(msg) {
-    if (ws?.readyState === WebSocket.OPEN) {
-      log("Sending:", msg);
-      ws.send(JSON.stringify(msg));
-    } else {
-      log("Cannot send, WebSocket not open. readyState:", ws?.readyState);
-    }
-  }
-  function handleMessage(event) {
-    try {
-      const msg = JSON.parse(event.data);
-      if (msg.type === "pong") return;
-      log("Received message:", msg.type, msg.topic ? `topic=${msg.topic}` : "");
-      if (msg.type === "subscribed" && Array.isArray(msg.topics)) {
-        for (const topic of msg.topics) {
-          const pending = pendingSubscriptions.get(topic);
-          if (pending) {
-            log("Subscription confirmed for room:", topic);
-            pending.resolve();
-            pendingSubscriptions.delete(topic);
-          }
-        }
-        return;
-      }
-      if (msg.type === "publish" && msg.topic) {
-        const handlers = rooms.get(msg.topic);
-        if (handlers) {
-          log("Dispatching to", handlers.size, "handler(s) for room:", msg.topic);
-          for (const handler of handlers) {
-            try {
-              handler(msg.data);
-            } catch (err) {
-              log("Handler error:", err);
-            }
-          }
-        } else {
-          log("No handlers for room:", msg.topic);
-        }
-        return;
-      }
-      if (msg && typeof msg === "object") {
-        for (const handler of messageListeners) {
-          try {
-            handler(msg);
-          } catch {
-          }
-        }
-      }
-    } catch (err) {
-      log("Failed to parse message:", err);
-    }
-  }
-  async function resolveAuthToken() {
-    let token = config.ucanToken ?? "";
-    if (!token && config.getUCANToken) {
-      try {
-        token = await config.getUCANToken();
-      } catch {
-        token = "";
-      }
-    }
-    return token;
-  }
-  function buildProtocols(token) {
-    const protocols = ["xnet-sync.v1"];
-    if (token && !/[\s,]/.test(token)) {
-      protocols.push(`xnet-auth.${token}`);
-    }
-    return protocols;
-  }
-  async function doConnect() {
-    if (destroyed) {
-      log("doConnect called but manager is destroyed");
-      return;
-    }
-    if (connectInProgress) {
-      log("doConnect called but connection already in progress");
-      return;
-    }
-    connectInProgress = true;
-    log("Connecting to:", config.url);
-    setStatus("connecting");
-    try {
-      const token = await resolveAuthToken();
-      ws = new WebSocket(config.url, buildProtocols(token));
-      ws.onopen = () => {
-        connectInProgress = false;
-        log("WebSocket connected");
-        setStatus("connected");
-        reconnectAttempts = 0;
-        if (rooms.size > 0) {
-          const roomList = Array.from(rooms.keys());
-          log("Re-subscribing to", roomList.length, "room(s):", roomList);
-          send({ type: "subscribe", topics: roomList });
-        }
-      };
-      ws.onmessage = handleMessage;
-      ws.onclose = (event) => {
-        connectInProgress = false;
-        log("WebSocket closed, code:", event.code, "reason:", event.reason || "(none)");
-        ws = null;
-        setStatus("disconnected");
-        scheduleReconnect();
-      };
-      ws.onerror = (event) => {
-        connectInProgress = false;
-        log("WebSocket error:", event);
-        setStatus("error");
-      };
-    } catch (err) {
-      connectInProgress = false;
-      log("Failed to create WebSocket:", err);
-      setStatus("error");
-      scheduleReconnect();
-    }
-  }
-  function scheduleReconnect() {
-    if (destroyed || reconnectAttempts >= maxReconnects) return;
-    if (reconnectTimer) return;
-    reconnectAttempts++;
-    reconnectTimer = setTimeout(() => {
-      reconnectTimer = null;
-      void doConnect();
-    }, reconnectDelay);
-  }
-  return {
-    get status() {
-      return status;
-    },
-    get roomCount() {
-      return rooms.size;
-    },
-    connect() {
-      destroyed = false;
-      void doConnect();
-    },
-    disconnect() {
-      destroyed = true;
-      if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-      }
-      if (ws) {
-        if (rooms.size > 0) {
-          send({ type: "unsubscribe", topics: Array.from(rooms.keys()) });
-        }
-        ws.close(1e3, "Client disconnect");
-        ws = null;
-      }
-      setStatus("disconnected");
-    },
-    joinRoom(room, handler) {
-      log("Joining room:", room);
-      let handlers = rooms.get(room);
-      if (!handlers) {
-        handlers = /* @__PURE__ */ new Set();
-        rooms.set(room, handlers);
-        log("New room subscription, sending subscribe message");
-        send({ type: "subscribe", topics: [room] });
-      }
-      handlers.add(handler);
-      log("Room", room, "now has", handlers.size, "handler(s)");
-      return () => {
-        log("Leaving room:", room);
-        handlers.delete(handler);
-        if (handlers.size === 0) {
-          rooms.delete(room);
-          pendingSubscriptions.delete(room);
-          send({ type: "unsubscribe", topics: [room] });
-        }
-      };
-    },
-    joinRoomAsync(room, handler) {
-      log("Joining room async:", room);
-      let handlers = rooms.get(room);
-      const isNewRoom = !handlers;
-      if (!handlers) {
-        handlers = /* @__PURE__ */ new Set();
-        rooms.set(room, handlers);
-      }
-      handlers.add(handler);
-      log("Room", room, "now has", handlers.size, "handler(s)");
-      let ready;
-      if (isNewRoom && status === "connected") {
-        log("New room subscription (async), sending subscribe message");
-        ready = new Promise((resolve, _reject) => {
-          pendingSubscriptions.set(room, { resolve, reject: () => resolve() });
-          send({ type: "subscribe", topics: [room] });
-          setTimeout(() => {
-            if (pendingSubscriptions.has(room)) {
-              pendingSubscriptions.delete(room);
-              log("Subscription confirmation timeout for room:", room, "- proceeding anyway");
-              resolve();
-            }
-          }, 5e3);
-        });
-      } else {
-        if (isNewRoom) {
-          log("New room added but not connected, will subscribe when connected");
-        }
-        ready = Promise.resolve();
-      }
-      const unsubscribe = () => {
-        log("Leaving room:", room);
-        handlers.delete(handler);
-        if (handlers.size === 0) {
-          rooms.delete(room);
-          pendingSubscriptions.delete(room);
-          send({ type: "unsubscribe", topics: [room] });
-        }
-      };
-      return { unsubscribe, ready };
-    },
-    leaveRoom(room) {
-      rooms.delete(room);
-      send({ type: "unsubscribe", topics: [room] });
-    },
-    publish(room, data) {
-      log("Publishing to room:", room, "type:", data.type);
-      send({ type: "publish", topic: room, data });
-    },
-    sendRaw(message) {
-      send(message);
-    },
-    onMessage(handler) {
-      messageListeners.add(handler);
-      return () => messageListeners.delete(handler);
-    },
-    onStatus(handler) {
-      statusListeners.add(handler);
-      return () => statusListeners.delete(handler);
-    }
-  };
-}
-
-// src/sync/meta-bridge.ts
-var METABRIDGE_ORIGIN = "metabridge";
-var METABRIDGE_SEED_ORIGIN = "metabridge-seed";
-function createMetaBridge(store, options) {
-  const warnOnExternal = options?.warnOnExternalMetaChanges ?? true;
-  function writePropertiesToMeta(doc, properties, origin) {
-    const metaMap = doc.getMap("meta");
-    doc.transact(() => {
-      for (const [key, value] of Object.entries(properties)) {
-        if (key.startsWith("_")) continue;
-        metaMap.set(key, value);
-      }
-    }, origin);
-  }
-  function setupMetaMonitor(doc, nodeId) {
-    if (!warnOnExternal) return () => {
-    };
-    const metaMap = doc.getMap("meta");
-    const observer = (event, transaction) => {
-      const origin = transaction.origin;
-      if (origin === METABRIDGE_ORIGIN || origin === METABRIDGE_SEED_ORIGIN) {
-        return;
-      }
-      if (origin === null || origin === "local") {
-        return;
-      }
-      const changedKeys = Array.from(event.changes.keys.keys());
-      console.warn(
-        `[MetaBridge] Meta map change from non-MetaBridge source (BLOCKED from NodeStore):`,
-        {
-          nodeId,
-          keys: changedKeys,
-          origin,
-          hint: "Property changes should go through mutate(), not Y.Doc meta map"
-        }
-      );
-    };
-    metaMap.observe(observer);
-    return () => metaMap.unobserve(observer);
-  }
-  return {
-    observe(nodeId, doc) {
-      const unsubscribeStore = store.subscribe((event) => {
-        if (event.change.payload.nodeId !== nodeId) return;
-        const properties = event.change.payload.properties;
-        if (!properties || Object.keys(properties).length === 0) return;
-        writePropertiesToMeta(doc, properties, METABRIDGE_ORIGIN);
-      });
-      const unsubscribeMonitor = setupMetaMonitor(doc, nodeId);
-      return () => {
-        unsubscribeStore();
-        unsubscribeMonitor();
-      };
-    },
-    async seed(nodeId, doc) {
-      const node = await store.get(nodeId);
-      if (!node) return;
-      const properties = node.properties;
-      if (!properties || Object.keys(properties).length === 0) return;
-      writePropertiesToMeta(doc, properties, METABRIDGE_SEED_ORIGIN);
-    },
-    // Backward compatibility alias
-    async applyNow(nodeId, doc) {
-      return this.seed(nodeId, doc);
-    }
-  };
-}
-
-// src/sync/node-pool.ts
-import * as Y from "yjs";
-function createNodePool(config) {
-  const entries = /* @__PURE__ */ new Map();
-  const persistTimers = /* @__PURE__ */ new Map();
-  const maxWarm = config.maxWarm ?? 50;
-  const persistDelay = config.persistDelay ?? 2e3;
-  async function loadDoc(nodeId) {
-    const doc = new Y.Doc({ guid: nodeId, gc: false });
-    const content = await config.storage.getDocumentContent(nodeId);
-    if (content && content.length > 0) {
-      Y.applyUpdate(doc, content);
-    }
-    return doc;
-  }
-  function schedulePersist(nodeId) {
-    const existing = persistTimers.get(nodeId);
-    if (existing) clearTimeout(existing);
-    persistTimers.set(
-      nodeId,
-      setTimeout(async () => {
-        persistTimers.delete(nodeId);
-        const entry = entries.get(nodeId);
-        if (entry && entry.dirty) {
-          const content = Y.encodeStateAsUpdate(entry.doc);
-          await config.storage.setDocumentContent(nodeId, content);
-          entry.dirty = false;
-        }
-      }, persistDelay)
-    );
-  }
-  async function evictIfNeeded() {
-    let warmCount = 0;
-    const warmEntries = [];
-    for (const [id, entry] of entries) {
-      if (entry.state === "warm") {
-        warmCount++;
-        warmEntries.push([id, entry]);
-      }
-    }
-    if (warmCount <= maxWarm) return;
-    warmEntries.sort((a, b) => a[1].lastAccess - b[1].lastAccess);
-    const toEvict = warmEntries.slice(0, warmCount - maxWarm);
-    await Promise.all(
-      toEvict.map(async ([id, entry]) => {
-        try {
-          const content = Y.encodeStateAsUpdate(entry.doc);
-          await config.storage.setDocumentContent(id, content);
-        } catch (err) {
-          console.error(`[NodePool] Failed to persist document ${id} during eviction:`, err);
-        }
-        if (entry.unobserveMeta) {
-          entry.unobserveMeta();
-        }
-        config.onDocEvict?.(id, entry.doc);
-        entry.doc.destroy();
-        entries.delete(id);
-      })
-    );
-  }
-  return {
-    async acquire(nodeId) {
-      let entry = entries.get(nodeId);
-      if (entry) {
-        entry.refCount++;
-        entry.state = "active";
-        entry.lastAccess = Date.now();
-        return entry.doc;
-      }
-      const doc = await loadDoc(nodeId);
-      doc.on("update", () => {
-        const e = entries.get(nodeId);
-        if (e) {
-          e.dirty = true;
-          schedulePersist(nodeId);
-          config.onDocUpdate?.(nodeId, doc);
-        }
-      });
-      const unobserveMeta = config.metaBridge.observe(nodeId, doc);
-      entry = {
-        doc,
-        state: "active",
-        refCount: 1,
-        lastAccess: Date.now(),
-        dirty: false,
-        unobserveMeta
-      };
-      entries.set(nodeId, entry);
-      return doc;
-    },
-    release(nodeId) {
-      const entry = entries.get(nodeId);
-      if (!entry) return;
-      entry.refCount = Math.max(0, entry.refCount - 1);
-      if (entry.refCount === 0) {
-        entry.state = "warm";
-        entry.lastAccess = Date.now();
-        void evictIfNeeded();
-      }
-    },
-    has(nodeId) {
-      return entries.has(nodeId);
-    },
-    getState(nodeId) {
-      return entries.get(nodeId)?.state ?? null;
-    },
-    get size() {
-      return entries.size;
-    },
-    async flushAll() {
-      for (const timer of persistTimers.values()) {
-        clearTimeout(timer);
-      }
-      persistTimers.clear();
-      const promises = [];
-      for (const [id, entry] of entries) {
-        if (entry.dirty) {
-          const content = Y.encodeStateAsUpdate(entry.doc);
-          promises.push(
-            config.storage.setDocumentContent(id, content).then(() => {
-              entry.dirty = false;
-            })
-          );
-        }
-      }
-      await Promise.all(promises);
-    },
-    async destroy() {
-      await this.flushAll();
-      for (const [, entry] of entries) {
-        if (entry.unobserveMeta) entry.unobserveMeta();
-        entry.doc.destroy();
-      }
-      entries.clear();
-    }
-  };
-}
-
-// src/sync/node-store-sync-provider.ts
-import { base64ToBytes, bytesToBase64 } from "@xnetjs/crypto";
-var KNOWN_CHANGE_TYPES = /* @__PURE__ */ new Set(["node-change"]);
-var NodeStoreSyncProvider = class {
-  constructor(store, room) {
-    this.store = store;
-    this.room = room;
-  }
-  lastSyncedLamport = 0;
-  connection = null;
-  roomCleanup = null;
-  statusCleanup = null;
-  messageCleanup = null;
-  storeCleanup = null;
-  unknownChangeTypeListeners = /* @__PURE__ */ new Set();
-  /**
-   * Subscribe to unknown change type events.
-   * These are changes received from peers with types this version doesn't know how to process.
-   * The changes are still stored in the change log for forward compatibility.
-   *
-   * @param listener - Callback invoked when an unknown change type is received
-   * @returns Unsubscribe function
-   */
-  onUnknownChangeType(listener) {
-    this.unknownChangeTypeListeners.add(listener);
-    return () => {
-      this.unknownChangeTypeListeners.delete(listener);
-    };
-  }
-  emitUnknownChangeType(change, peerId) {
-    for (const listener of this.unknownChangeTypeListeners) {
-      try {
-        listener(change, peerId);
-      } catch (err) {
-        console.error("Error in unknown change type listener:", err);
-      }
-    }
-  }
-  attach(connection) {
-    this.connection = connection;
-    this.roomCleanup = connection.joinRoom(this.room, (data) => {
-      this.handleRoomMessage(data);
-    });
-    this.messageCleanup = connection.onMessage((message) => {
-      this.handleDirectMessage(message);
-    });
-    this.statusCleanup = connection.onStatus((status) => {
-      if (status === "connected") {
-        void this.syncLocalChanges();
-        this.requestSync();
-      }
-    });
-    this.storeCleanup = this.store.subscribe((event) => {
-      if (event.isRemote) return;
-      this.broadcastChange(event.change);
-    });
-    if (connection.status === "connected") {
-      void this.syncLocalChanges();
-      this.requestSync();
-    }
-  }
-  detach() {
-    this.roomCleanup?.();
-    this.statusCleanup?.();
-    this.messageCleanup?.();
-    this.storeCleanup?.();
-    this.roomCleanup = null;
-    this.statusCleanup = null;
-    this.messageCleanup = null;
-    this.storeCleanup = null;
-    this.connection = null;
-  }
-  handleRoomMessage(data) {
-    if (data.type === "node-change") {
-      const change = data.change;
-      void this.handleRemoteChange(change);
-    }
-  }
-  handleDirectMessage(message) {
-    if (message.type !== "node-sync-response") return;
-    const response = message;
-    if (response.room !== this.room) return;
-    void this.handleSyncResponse(response);
-  }
-  requestSync() {
-    if (!this.connection) return;
-    this.connection.sendRaw({
-      type: "node-sync-request",
-      room: this.room,
-      sinceLamport: this.lastSyncedLamport
-    });
-  }
-  async syncLocalChanges() {
-    if (!this.connection || this.connection.status !== "connected") return;
-    const changes = await this.store.getChangesSince(this.lastSyncedLamport);
-    if (changes.length === 0) return;
-    changes.sort((a, b) => a.lamport.time - b.lamport.time);
-    for (const change of changes) {
-      this.broadcastChange(change);
-      this.lastSyncedLamport = Math.max(this.lastSyncedLamport, change.lamport.time);
-    }
-  }
-  broadcastChange(change) {
-    if (!this.connection || this.connection.status !== "connected") return;
-    const serialized = this.serializeChange(change);
-    this.connection.publish(this.room, {
-      type: "node-change",
-      room: this.room,
-      change: serialized
-    });
-    this.lastSyncedLamport = Math.max(this.lastSyncedLamport, change.lamport.time);
-  }
-  async handleRemoteChange(serialized, peerId = "unknown") {
-    const change = this.deserializeChange(serialized);
-    if (serialized.lamportTime > this.lastSyncedLamport) {
-      this.lastSyncedLamport = serialized.lamportTime;
-    }
-    if (!KNOWN_CHANGE_TYPES.has(change.type)) {
-      console.warn(
-        `Received unknown change type "${change.type}" from peer ${peerId}. Change stored but not processed (forward compatibility).`
-      );
-      this.emitUnknownChangeType(change, peerId);
-      return;
-    }
-    await this.store.applyRemoteChange(change);
-  }
-  async handleSyncResponse(response, peerId = "hub") {
-    if (response.changes.length > 0) {
-      const allChanges = response.changes.map((s) => this.deserializeChange(s));
-      const knownChanges = [];
-      for (const change of allChanges) {
-        if (KNOWN_CHANGE_TYPES.has(change.type)) {
-          knownChanges.push(change);
-        } else {
-          console.warn(
-            `Received unknown change type "${change.type}" from ${peerId}. Change stored but not processed (forward compatibility).`
-          );
-          this.emitUnknownChangeType(change, peerId);
-        }
-      }
-      if (knownChanges.length > 0) {
-        await this.store.applyRemoteChanges(knownChanges);
-      }
-    }
-    this.lastSyncedLamport = Math.max(this.lastSyncedLamport, response.highWaterMark);
-  }
-  serializeChange(change) {
-    return {
-      id: change.id,
-      type: change.type,
-      hash: change.hash,
-      room: this.room,
-      nodeId: change.payload.nodeId,
-      schemaId: change.payload.schemaId,
-      lamportTime: change.lamport.time,
-      lamportAuthor: change.lamport.author,
-      authorDid: change.authorDID,
-      wallTime: change.wallTime,
-      parentHash: change.parentHash,
-      payload: change.payload,
-      signatureB64: bytesToBase64(change.signature),
-      batchId: change.batchId,
-      batchIndex: change.batchIndex,
-      batchSize: change.batchSize
-    };
-  }
-  deserializeChange(serialized) {
-    return {
-      id: serialized.id,
-      type: serialized.type,
-      hash: serialized.hash,
-      parentHash: serialized.parentHash,
-      authorDID: serialized.authorDid,
-      signature: base64ToBytes(serialized.signatureB64),
-      wallTime: serialized.wallTime,
-      lamport: { time: serialized.lamportTime, author: serialized.lamportAuthor },
-      payload: serialized.payload,
-      batchId: serialized.batchId,
-      batchIndex: serialized.batchIndex,
-      batchSize: serialized.batchSize
-    };
-  }
-};
-
-// src/sync/offline-queue.ts
-function toBase64(data) {
-  let binary = "";
-  for (let i = 0; i < data.length; i++) {
-    binary += String.fromCharCode(data[i]);
-  }
-  return btoa(binary);
-}
-var SAVE_DEBOUNCE_MS = 100;
-function createOfflineQueue(config) {
-  const storageKey = config.storageKey ?? "_xnet_offline_queue";
-  const maxSize = config.maxSize ?? 1e3;
-  let entries = [];
-  let storageNodeReady = false;
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  let saveTimer = null;
-  let saveResolvers = [];
-  const ensureStorageNode = async () => {
-    if (storageNodeReady) {
-      return;
-    }
-    const existing = await config.storage.getNode(storageKey);
-    if (existing) {
-      storageNodeReady = true;
-      return;
-    }
-    const now = Date.now();
-    const systemDid = "did:key:offline-queue";
-    const node = {
-      id: storageKey,
-      schemaId: "xnet://xnet.system/OfflineQueueState",
-      properties: {},
-      timestamps: {},
-      deleted: true,
-      deletedAt: {
-        lamport: { time: 0, author: systemDid },
-        wallTime: now
-      },
-      createdAt: now,
-      createdBy: systemDid,
-      updatedAt: now,
-      updatedBy: systemDid
-    };
-    await config.storage.setNode(node);
-    storageNodeReady = true;
-  };
-  const debouncedSave = () => {
-    return new Promise((resolve) => {
-      saveResolvers.push(resolve);
-      if (saveTimer) {
-        clearTimeout(saveTimer);
-      }
-      saveTimer = setTimeout(async () => {
-        saveTimer = null;
-        const resolvers = saveResolvers;
-        saveResolvers = [];
-        try {
-          await ensureStorageNode();
-          const json = JSON.stringify(entries);
-          const bytes = encoder.encode(json);
-          await config.storage.setDocumentContent(storageKey, bytes);
-        } catch (err) {
-          console.warn("[OfflineQueue] Failed to persist:", err);
-        }
-        resolvers.forEach((r) => r());
-      }, SAVE_DEBOUNCE_MS);
-    });
-  };
-  return {
-    async enqueue(nodeId, update) {
-      entries.push({
-        nodeId,
-        update: toBase64(update),
-        queuedAt: Date.now()
-      });
-      if (entries.length > maxSize) {
-        entries = entries.slice(entries.length - maxSize);
-      }
-      await debouncedSave();
-    },
-    async drain(handler) {
-      let drained = 0;
-      while (entries.length > 0) {
-        const entry = entries[0];
-        try {
-          await handler(entry);
-          entries.shift();
-          drained++;
-        } catch {
-          break;
-        }
-      }
-      if (drained > 0) {
-        await this.save();
-      }
-      return drained;
-    },
-    get size() {
-      return entries.length;
-    },
-    async load() {
-      try {
-        const content = await config.storage.getDocumentContent(storageKey);
-        if (content && content.length > 0) {
-          const json = decoder.decode(content);
-          const parsed = JSON.parse(json);
-          if (Array.isArray(parsed)) {
-            entries = parsed;
-          }
-        }
-      } catch {
-        entries = [];
-      }
-    },
-    async save() {
-      if (saveTimer) {
-        clearTimeout(saveTimer);
-        saveTimer = null;
-        const resolvers = saveResolvers;
-        saveResolvers = [];
-        resolvers.forEach((r) => r());
-      }
-      try {
-        await ensureStorageNode();
-        const json = JSON.stringify(entries);
-        const bytes = encoder.encode(json);
-        await config.storage.setDocumentContent(storageKey, bytes);
-      } catch (err) {
-        console.warn("[OfflineQueue] Failed to persist:", err);
-      }
-    },
-    async clear() {
-      entries = [];
-      await this.save();
-    }
-  };
-}
-
-// src/sync/registry.ts
-function createRegistry(config) {
-  const trackTTL = config.trackTTL ?? 7 * 24 * 60 * 60 * 1e3;
-  const storageKey = config.storageKey ?? "_xnet_tracked_nodes";
-  const tracked = /* @__PURE__ */ new Map();
-  return {
-    track(nodeId, schemaId) {
-      const existing = tracked.get(nodeId);
-      if (existing) {
-        existing.lastOpened = Date.now();
-        return;
-      }
-      tracked.set(nodeId, {
-        nodeId,
-        schemaId,
-        lastOpened: Date.now(),
-        lastSynced: 0,
-        pinned: false
-      });
-    },
-    untrack(nodeId) {
-      tracked.delete(nodeId);
-    },
-    pin(nodeId) {
-      const entry = tracked.get(nodeId);
-      if (entry) entry.pinned = true;
-    },
-    unpin(nodeId) {
-      const entry = tracked.get(nodeId);
-      if (entry) entry.pinned = false;
-    },
-    touch(nodeId) {
-      const entry = tracked.get(nodeId);
-      if (entry) entry.lastOpened = Date.now();
-    },
-    markSynced(nodeId) {
-      const entry = tracked.get(nodeId);
-      if (entry) entry.lastSynced = Date.now();
-    },
-    getTracked() {
-      const now = Date.now();
-      const result = [];
-      for (const entry of tracked.values()) {
-        if (entry.pinned || now - entry.lastOpened < trackTTL) {
-          result.push(entry);
-        }
-      }
-      return result;
-    },
-    isTracked(nodeId) {
-      const entry = tracked.get(nodeId);
-      if (!entry) return false;
-      return entry.pinned || Date.now() - entry.lastOpened < trackTTL;
-    },
-    async load() {
-      try {
-        const entries = await config.storage.get(storageKey);
-        if (entries) {
-          for (const entry of entries) {
-            tracked.set(entry.nodeId, entry);
-          }
-        }
-      } catch {
-      }
-    },
-    async save() {
-      const entries = Array.from(tracked.values());
-      try {
-        await config.storage.set(storageKey, entries);
-      } catch (err) {
-        console.warn("[Registry] Failed to persist:", err);
-      }
-    },
-    prune() {
-      const now = Date.now();
-      let pruned = 0;
-      for (const [id, entry] of tracked) {
-        if (!entry.pinned && now - entry.lastOpened >= trackTTL) {
-          tracked.delete(id);
-          pruned++;
-        }
-      }
-      return pruned;
-    }
-  };
-}
-
-// src/sync/sync-manager.ts
-import {
-  Awareness,
-  applyAwarenessUpdate,
-  encodeAwarenessUpdate,
-  removeAwarenessStates
-} from "y-protocols/awareness";
-import * as Y2 from "yjs";
-if (typeof localStorage !== "undefined" && localStorage.getItem("xnet:sync:debug") === "true") {
-  console.log("[SyncManager] Module loaded from source!");
-}
-function log2(...args) {
-  if (typeof localStorage !== "undefined" && localStorage.getItem("xnet:sync:debug") === "true") {
-    console.log("[SyncManager]", ...args);
-  }
-}
-function createRegistryStorageAdapter(storage) {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  return {
-    async get(key) {
-      try {
-        const content = await storage.getDocumentContent(key);
-        if (!content || content.length === 0) return null;
-        const json = decoder.decode(content);
-        return JSON.parse(json);
-      } catch {
-        return null;
-      }
-    },
-    async set(key, entries) {
-      const json = JSON.stringify(entries);
-      const bytes = encoder.encode(json);
-      await storage.setDocumentContent(key, bytes);
-    }
-  };
-}
-function extractBlobCids(doc) {
-  const cids = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const name of ["default", "prosemirror", ""]) {
-    let fragment;
-    try {
-      fragment = doc.getXmlFragment(name);
-    } catch {
-      continue;
-    }
-    if (!fragment || fragment.length === 0) continue;
-    walkXmlFragment(fragment, (node) => {
-      if (node instanceof Y2.XmlElement) {
-        const cid = node.getAttribute("cid");
-        if (typeof cid === "string" && cid.length > 0 && !seen.has(cid)) {
-          seen.add(cid);
-          cids.push(cid);
-        }
-      }
-    });
-  }
-  const meta = doc.getMap("meta");
-  if (meta) {
-    walkYMap(meta, (value) => {
-      if (typeof value === "object" && value !== null && "cid" in value) {
-        const cid = value.cid;
-        if (typeof cid === "string" && cid.length > 0 && !seen.has(cid)) {
-          seen.add(cid);
-          cids.push(cid);
-        }
-      }
-    });
-  }
-  return cids;
-}
-function walkXmlFragment(node, visitor) {
-  for (let i = 0; i < node.length; i++) {
-    const child = node.get(i);
-    if (child instanceof Y2.XmlElement) {
-      visitor(child);
-      walkXmlFragment(child, visitor);
-    } else if (child instanceof Y2.XmlText) {
-      visitor(child);
-    }
-  }
-}
-function walkYMap(map, visitor) {
-  map.forEach((value) => {
-    if (value instanceof Y2.Map) {
-      walkYMap(value, visitor);
-    } else if (Array.isArray(value)) {
-      for (const item of value) {
-        visitor(item);
-      }
-    } else {
-      visitor(value);
-    }
-  });
-}
-function createSyncManager(config) {
-  const metaBridge = createMetaBridge(config.nodeStore);
-  const pool = createNodePool({
-    storage: config.storage,
-    metaBridge,
-    maxWarm: config.poolSize ?? 50,
-    onDocUpdate: config.onDocUpdate,
-    onDocEvict: (nodeId, doc) => {
-      broadcastDocs.delete(nodeId);
-      config.onDocEvict?.(nodeId, doc);
-    }
-  });
-  const registry = createRegistry({
-    storage: createRegistryStorageAdapter(config.storage),
-    trackTTL: config.trackTTL
-  });
-  const connection = createConnectionManager({
-    url: config.signalingUrl,
-    ucanToken: config.ucanToken,
-    getUCANToken: config.getUCANToken
-  });
-  const offlineQueue = createOfflineQueue({
-    storage: config.storage
-  });
-  const nodeSyncProvider = config.nodeSyncRoom ? new NodeStoreSyncProvider(config.nodeStore, config.nodeSyncRoom) : null;
-  let blobSync = null;
-  if (config.blobStore) {
-    const underlyingStore = config.blobStore;
-    const announcingStore = {
-      get: (cid) => underlyingStore.get(cid),
-      has: (cid) => underlyingStore.has(cid),
-      async put(data) {
-        const cid = await underlyingStore.put(data);
-        if (blobSync) {
-          blobSync.announceHave([cid]);
-        }
-        return cid;
-      }
-    };
-    blobSync = createBlobSyncProvider({
-      blobStore: announcingStore,
-      connection
-    });
-  }
-  const roomCleanups = /* @__PURE__ */ new Map();
-  const awarenessMap = /* @__PURE__ */ new Map();
-  const awarenessSnapshots = /* @__PURE__ */ new Map();
-  const awarenessSnapshotListeners = /* @__PURE__ */ new Map();
-  const broadcastDocs = /* @__PURE__ */ new Set();
-  const peerId = Math.random().toString(36).slice(2, 10);
-  let statusHandlerCleanup = null;
-  function toBase642(data) {
-    let binary = "";
-    for (let i = 0; i < data.length; i++) {
-      binary += String.fromCharCode(data[i]);
-    }
-    return btoa(binary);
-  }
-  function fromBase64(str) {
-    const binary = atob(str);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-      bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-  }
-  async function joinNodeRoom(nodeId) {
-    if (roomCleanups.has(nodeId)) {
-      log2("Already joined room for node:", nodeId);
-      return;
-    }
-    const room = `xnet-doc-${nodeId}`;
-    log2("Joining room:", room);
-    const { unsubscribe, ready } = connection.joinRoomAsync(room, (data) => {
-      handleSyncMessage(nodeId, data);
-    });
-    roomCleanups.set(nodeId, unsubscribe);
-    await ready;
-    if (pool.has(nodeId)) {
-      log2("Doc already in pool, sending initial sync-step1");
-      const doc = await pool.acquire(nodeId);
-      getOrCreateAwareness(nodeId, doc);
-      const sv = Y2.encodeStateVector(doc);
-      log2("Sending sync-step1 for node:", nodeId, "SV size:", sv.length);
-      connection.publish(room, {
-        type: "sync-step1",
-        from: peerId,
-        sv: toBase642(sv)
-      });
-      pool.release(nodeId);
-    } else {
-      log2("Doc not in pool yet for node:", nodeId);
-    }
-  }
-  function leaveNodeRoom(nodeId) {
-    const cleanup = roomCleanups.get(nodeId);
-    if (cleanup) {
-      cleanup();
-      roomCleanups.delete(nodeId);
-    }
-    const awareness = awarenessMap.get(nodeId);
-    if (awareness) {
-      removeAwarenessStates(awareness, [awareness.clientID], "local");
-    }
-    awarenessMap.delete(nodeId);
-    awarenessSnapshots.delete(nodeId);
-    awarenessSnapshotListeners.delete(nodeId);
-    broadcastDocs.delete(nodeId);
-  }
-  function getOrCreateAwareness(nodeId, doc) {
-    const existing = awarenessMap.get(nodeId);
-    if (existing) return existing;
-    const awareness = new Awareness(doc);
-    awarenessMap.set(nodeId, awareness);
-    awareness.on(
-      "update",
-      ({ added, updated, removed }, origin) => {
-        if (origin === "remote") return;
-        const changed = [...added, ...updated, ...removed];
-        if (changed.length === 0) return;
-        if (connection.status !== "connected") return;
-        const room = `xnet-doc-${nodeId}`;
-        const update = encodeAwarenessUpdate(awareness, changed);
-        connection.publish(room, {
-          type: "awareness",
-          from: peerId,
-          update: toBase642(update)
-        });
-      }
-    );
-    return awareness;
-  }
-  function emitAwarenessSnapshot(nodeId, users) {
-    awarenessSnapshots.set(nodeId, users);
-    const listeners = awarenessSnapshotListeners.get(nodeId);
-    if (!listeners) return;
-    for (const handler of listeners) {
-      try {
-        handler(users);
-      } catch {
-      }
-    }
-  }
-  async function handleSyncMessage(nodeId, data) {
-    if (data.from === peerId) {
-      log2("Ignoring own message");
-      return;
-    }
-    log2("Received message for node:", nodeId, "type:", data.type, "from:", data.from);
-    const doc = await pool.acquire(nodeId);
-    const room = `xnet-doc-${nodeId}`;
-    try {
-      switch (data.type) {
-        case "sync-step1": {
-          const remoteSV = fromBase64(data.sv);
-          const diff = Y2.encodeStateAsUpdate(doc, remoteSV);
-          log2(
-            "Received sync-step1, remote SV size:",
-            remoteSV.length,
-            "sending diff size:",
-            diff.length
-          );
-          connection.publish(room, {
-            type: "sync-step2",
-            from: peerId,
-            to: data.from,
-            update: toBase642(diff)
-          });
-          break;
-        }
-        case "sync-step2": {
-          if (data.to && data.to !== peerId) {
-            log2("Ignoring sync-step2 addressed to different peer:", data.to);
-            break;
-          }
-          const update = fromBase64(data.update);
-          log2("Received sync-step2, applying update size:", update.length);
-          log2("Doc state before update - meta keys:", doc.getMap("meta").size);
-          Y2.applyUpdate(doc, update, "remote");
-          log2("Doc state after update - meta keys:", doc.getMap("meta").size);
-          registry.markSynced(nodeId);
-          log2("Marked node as synced:", nodeId);
-          break;
-        }
-        case "sync-update": {
-          const update = fromBase64(data.update);
-          log2("Received sync-update, size:", update.length);
-          Y2.applyUpdate(doc, update, "remote");
-          break;
-        }
-        case "awareness": {
-          const update = fromBase64(data.update);
-          const awareness = getOrCreateAwareness(nodeId, doc);
-          applyAwarenessUpdate(awareness, update, "remote");
-          break;
-        }
-        case "awareness-snapshot": {
-          const users = Array.isArray(data.users) ? data.users : [];
-          emitAwarenessSnapshot(nodeId, users);
-          break;
-        }
-      }
-    } finally {
-      pool.release(nodeId);
-    }
-  }
-  function setupDocBroadcast(nodeId, doc) {
-    if (broadcastDocs.has(nodeId)) return;
-    broadcastDocs.add(nodeId);
-    const room = `xnet-doc-${nodeId}`;
-    doc.on("update", (update, origin) => {
-      if (origin === "remote") return;
-      if (connection.status === "connected") {
-        connection.publish(room, {
-          type: "sync-update",
-          from: peerId,
-          update: toBase642(update)
-        });
-      } else {
-        offlineQueue.enqueue(nodeId, update);
-      }
-    });
-  }
-  async function drainOfflineQueue() {
-    if (offlineQueue.size === 0) return;
-    await offlineQueue.drain(async (entry) => {
-      const room = `xnet-doc-${entry.nodeId}`;
-      connection.publish(room, {
-        type: "sync-update",
-        from: peerId,
-        update: entry.update
-        // Already base64 encoded
-      });
-    });
-  }
-  function sendSyncStep1(nodeId, doc) {
-    const room = `xnet-doc-${nodeId}`;
-    const sv = Y2.encodeStateVector(doc);
-    log2(
-      "sendSyncStep1 for node:",
-      nodeId,
-      "SV size:",
-      sv.length,
-      "connection status:",
-      connection.status
-    );
-    connection.publish(room, {
-      type: "sync-step1",
-      from: peerId,
-      sv: toBase642(sv)
-    });
-  }
-  return {
-    async start() {
-      log2("Starting SyncManager...");
-      await registry.load();
-      log2("Registry loaded, tracked nodes:", registry.getTracked().length);
-      await offlineQueue.load();
-      log2("Offline queue loaded, size:", offlineQueue.size);
-      log2("Connecting to signaling server...");
-      connection.connect();
-      nodeSyncProvider?.attach(connection);
-      blobSync?.start();
-      statusHandlerCleanup = connection.onStatus((s) => {
-        log2("Connection status changed in start():", s);
-        if (s === "connected") {
-          drainOfflineQueue();
-          for (const nodeId of roomCleanups.keys()) {
-            if (pool.has(nodeId)) {
-              pool.acquire(nodeId).then((doc) => {
-                sendSyncStep1(nodeId, doc);
-                pool.release(nodeId);
-              });
-            }
-          }
-        }
-      });
-      const tracked = registry.getTracked();
-      log2("Joining rooms for", tracked.length, "tracked nodes");
-      await Promise.all(tracked.map((entry) => joinNodeRoom(entry.nodeId)));
-      log2("SyncManager started");
-    },
-    async stop() {
-      blobSync?.stop();
-      nodeSyncProvider?.detach();
-      if (statusHandlerCleanup) {
-        statusHandlerCleanup();
-        statusHandlerCleanup = null;
-      }
-      for (const nodeId of Array.from(roomCleanups.keys())) {
-        leaveNodeRoom(nodeId);
-      }
-      connection.disconnect();
-      await pool.flushAll();
-      registry.prune();
-      await registry.save();
-      await offlineQueue.save();
-      await pool.destroy();
-    },
-    track(nodeId, schemaId) {
-      registry.track(nodeId, schemaId);
-      joinNodeRoom(nodeId).catch((err) => {
-        log2("Error joining room for track:", err);
-      });
-    },
-    untrack(nodeId) {
-      registry.untrack(nodeId);
-      leaveNodeRoom(nodeId);
-    },
-    async acquire(nodeId) {
-      console.log("[SyncManager] acquire() called for:", nodeId);
-      log2("Acquiring doc for node:", nodeId);
-      registry.touch(nodeId);
-      const doc = await pool.acquire(nodeId);
-      log2("Doc acquired from pool, guid:", doc.guid, "meta keys:", doc.getMap("meta").size);
-      setupDocBroadcast(nodeId, doc);
-      getOrCreateAwareness(nodeId, doc);
-      if (!roomCleanups.has(nodeId)) {
-        await joinNodeRoom(nodeId);
-      }
-      if (connection.status === "connected") {
-        log2("Connection is connected, sending sync-step1");
-        sendSyncStep1(nodeId, doc);
-      } else {
-        log2("Connection not connected, status:", connection.status);
-      }
-      if (blobSync) {
-        const cids = extractBlobCids(doc);
-        if (cids.length > 0) {
-          blobSync.requestBlobs(cids);
-        }
-      }
-      return doc;
-    },
-    release(nodeId) {
-      pool.release(nodeId);
-    },
-    getAwareness(nodeId) {
-      return awarenessMap.get(nodeId) ?? null;
-    },
-    onAwarenessSnapshot(nodeId, handler) {
-      const listeners = awarenessSnapshotListeners.get(nodeId) ?? /* @__PURE__ */ new Set();
-      listeners.add(handler);
-      awarenessSnapshotListeners.set(nodeId, listeners);
-      const existing = awarenessSnapshots.get(nodeId);
-      if (existing) {
-        handler(existing);
-      }
-      return () => {
-        const current = awarenessSnapshotListeners.get(nodeId);
-        if (!current) return;
-        current.delete(handler);
-        if (current.size === 0) {
-          awarenessSnapshotListeners.delete(nodeId);
-        }
-      };
-    },
-    async requestBlobs(cids) {
-      if (blobSync) {
-        await blobSync.requestBlobs(cids);
-      }
-    },
-    announceBlobs(cids) {
-      if (blobSync) {
-        blobSync.announceHave(cids);
-      }
-    },
-    get status() {
-      return connection.status;
-    },
-    get connection() {
-      return connection;
-    },
-    get poolSize() {
-      return pool.size;
-    },
-    get trackedCount() {
-      return registry.getTracked().length;
-    },
-    get queueSize() {
-      return offlineQueue.size;
-    },
-    get pendingBlobCount() {
-      return blobSync?.pendingCount ?? 0;
-    },
-    on(event, handler) {
-      if (event === "status") {
-        return connection.onStatus(handler);
-      }
-      return () => {
-      };
-    }
-  };
-}
-
-// src/context.ts
-import { MemoryNodeStorageAdapter, NodeStore } from "@xnetjs/data";
-import { createMainThreadBridge, MainThreadBridge } from "@xnetjs/data-bridge";
-import { createUCAN } from "@xnetjs/identity";
-import { PluginRegistry } from "@xnetjs/plugins";
-import React, {
-  createContext as createContext4,
-  useCallback,
-  useContext as useContext4,
-  useEffect as useEffect3,
-  useMemo as useMemo2,
-  useRef,
-  useState as useState3
-} from "react";
-
-// src/hub/auto-backup.ts
-import * as Y3 from "yjs";
-var AutoBackup = class {
-  constructor(upload, options) {
-    this.upload = upload;
-    this.debounceMs = options?.debounceMs ?? 5e3;
-    this.isEnabled = options?.isEnabled ?? (() => true);
-  }
-  timers = /* @__PURE__ */ new Map();
-  debounceMs;
-  isEnabled;
-  handleDocUpdate(docId, doc) {
-    this.scheduleBackup(docId, doc, this.debounceMs);
-  }
-  handleDocEvict(docId, doc) {
-    this.scheduleBackup(docId, doc, 0);
-  }
-  scheduleBackup(docId, doc, delay) {
-    const existing = this.timers.get(docId);
-    if (existing) {
-      clearTimeout(existing);
-    }
-    const run = async () => {
-      this.timers.delete(docId);
-      if (!this.isEnabled()) return;
-      try {
-        const state = Y3.encodeStateAsUpdate(doc);
-        await this.upload(docId, state);
-      } catch (err) {
-        console.warn(`[auto-backup] Failed for ${docId}:`, err);
-      }
-    };
-    if (delay <= 0) {
-      void run();
-      return;
-    }
-    this.timers.set(
-      docId,
-      setTimeout(() => void run(), delay)
-    );
-  }
-  async flush() {
-    for (const timer of this.timers.values()) {
-      clearTimeout(timer);
-    }
-    this.timers.clear();
-  }
-  destroy() {
-    void this.flush();
-  }
-};
-
-// src/hub/backup.ts
-import { concatBytes, decrypt, encrypt, NONCE_SIZE } from "@xnetjs/crypto";
-var toHttpUrl = (hubUrl) => {
-  try {
-    const url = new URL(hubUrl);
-    if (url.protocol === "ws:") url.protocol = "http:";
-    if (url.protocol === "wss:") url.protocol = "https:";
-    return url.toString().replace(/\/$/, "");
-  } catch {
-    return hubUrl;
-  }
-};
-var encodeEncrypted = (encrypted) => concatBytes(encrypted.nonce, encrypted.ciphertext);
-var decodeEncrypted = (payload) => {
-  const nonce = payload.slice(0, NONCE_SIZE);
-  const ciphertext = payload.slice(NONCE_SIZE);
-  return { nonce, ciphertext };
-};
-var resolveFetch = (fetchFn) => {
-  if (fetchFn) return fetchFn;
-  if (typeof fetch === "undefined") {
-    throw new Error("fetch is not available in this environment");
-  }
-  return fetch;
-};
-var buildAuthHeader = async (getAuthToken) => {
-  if (!getAuthToken) return null;
-  const token = await getAuthToken();
-  if (!token) return null;
-  return `Bearer ${token}`;
-};
-async function uploadBackup(config, docId, plaintext) {
-  const encrypted = encrypt(plaintext, config.encryptionKey);
-  const payload = encodeEncrypted(encrypted);
-  return uploadEncryptedBackup(config, docId, payload);
-}
-async function uploadEncryptedBackup(config, docId, payload) {
-  const httpUrl = toHttpUrl(config.hubUrl);
-  const fetcher = resolveFetch(config.fetchFn);
-  const authHeader = await buildAuthHeader(config.getAuthToken);
-  const res = await fetcher(`${httpUrl}/backup/${encodeURIComponent(docId)}`, {
-    method: "PUT",
-    headers: {
-      ...authHeader ? { Authorization: authHeader } : {},
-      "Content-Type": "application/octet-stream"
-    },
-    body: payload
-  });
-  if (!res.ok) {
-    throw new Error(`Backup upload failed: ${res.status} ${res.statusText}`);
-  }
-  return res.json();
-}
-async function downloadBackup(config, docId) {
-  const payload = await downloadEncryptedBackup(config, docId);
-  if (!payload) return null;
-  const encrypted = decodeEncrypted(payload);
-  return decrypt(encrypted, config.encryptionKey);
-}
-async function downloadEncryptedBackup(config, docId) {
-  const httpUrl = toHttpUrl(config.hubUrl);
-  const fetcher = resolveFetch(config.fetchFn);
-  const authHeader = await buildAuthHeader(config.getAuthToken);
-  const res = await fetcher(`${httpUrl}/backup/${encodeURIComponent(docId)}`, {
-    headers: authHeader ? { Authorization: authHeader } : void 0
-  });
-  if (res.status === 404) return null;
-  if (!res.ok) {
-    throw new Error(`Backup download failed: ${res.status} ${res.statusText}`);
-  }
-  return new Uint8Array(await res.arrayBuffer());
-}
-
-// src/context.ts
-function log3(...args) {
-  if (typeof localStorage !== "undefined" && localStorage.getItem("xnet:sync:debug") === "true") {
-    console.log("[XNetProvider]", ...args);
-  }
-}
-var HUB_CAPABILITIES = [
-  { with: "*", can: "hub/*" },
-  { with: "*", can: "backup/*" },
-  { with: "*", can: "files/*" },
-  { with: "*", can: "query/*" },
-  { with: "*", can: "index/*" }
-];
-var HUB_TOKEN_TTL_SECONDS = 60 * 60 * 24;
-var HUB_INDEX_DEBOUNCE_MS = 2e3;
-var XNetContext = createContext4(null);
-var DataBridgeContext = createContext4(null);
-function useDataBridge() {
-  return useContext4(DataBridgeContext);
-}
-function XNetProvider({ config, children }) {
-  const [nodeStore, setNodeStore] = useState3(null);
-  const [nodeStoreReady, setNodeStoreReady] = useState3(false);
-  const [dataBridge, setDataBridge] = useState3(null);
-  const [syncManager, setSyncManager] = useState3(null);
-  const [hubStatus, setHubStatus] = useState3("disconnected");
-  const [pluginRegistry, setPluginRegistry] = useState3(null);
-  const nodeStorageRef = useRef(null);
-  const authorDID = config.authorDID ?? config.identity?.did;
-  const hubUrl = config.hubUrl ?? null;
-  const hubOptions = config.hubOptions;
-  const autoAuth = hubOptions?.autoAuth ?? true;
-  const staticHubAuthToken = hubOptions?.authToken?.trim() ?? "";
-  const autoBackup = hubOptions?.autoBackup ?? false;
-  const backupDebounceMs = hubOptions?.backupDebounceMs ?? 5e3;
-  const enableSearchIndex = hubOptions?.enableSearchIndex ?? false;
-  const nodeSyncRoom = hubOptions?.nodeSyncRoom ?? authorDID ?? "default";
-  const encryptionKey = config.encryptionKey ?? null;
-  const getHubAuthToken = useCallback(async () => {
-    if (staticHubAuthToken) return staticHubAuthToken;
-    if (!hubUrl || !autoAuth) return "";
-    if (!authorDID || !config.signingKey) {
-      throw new Error("Missing authorDID/signingKey for hub auth");
-    }
-    return createUCAN({
-      issuer: authorDID,
-      issuerKey: config.signingKey,
-      audience: hubUrl,
-      capabilities: HUB_CAPABILITIES,
-      expiration: Math.floor(Date.now() / 1e3) + HUB_TOKEN_TTL_SECONDS
-    });
-  }, [authorDID, autoAuth, config.signingKey, hubUrl, staticHubAuthToken]);
-  useEffect3(() => {
-    const nodeStorageAdapter = config.nodeStorage ?? new MemoryNodeStorageAdapter();
-    nodeStorageRef.current = nodeStorageAdapter;
-    const signingKey = config.signingKey;
-    if (!authorDID || !signingKey) {
-      console.warn(
-        "XNetProvider: authorDID and signingKey not provided. NodeStore will not be initialized. Provide these via config.authorDID/config.signingKey or config.identity."
-      );
-      return;
-    }
-    let cancelled = false;
-    const initializeNodeStore = async () => {
-      if ("open" in nodeStorageAdapter && typeof nodeStorageAdapter.open === "function") {
-        await nodeStorageAdapter.open();
-      }
-      if (cancelled) return;
-      const ns = new NodeStore({
-        storage: nodeStorageAdapter,
-        authorDID,
-        signingKey
-      });
-      await ns.initialize();
-      if (cancelled) return;
-      const bridge = config.dataBridge ?? createMainThreadBridge(ns);
-      setNodeStore(ns);
-      setNodeStoreReady(true);
-      setDataBridge(bridge);
-      bridgeRef = config.dataBridge ? null : bridge;
-      if (typeof window !== "undefined") {
-        const win = window;
-        win.__xnetNodeStore = ns;
-      }
-    };
-    let bridgeRef = null;
-    initializeNodeStore();
-    return () => {
-      cancelled = true;
-      if (bridgeRef) {
-        bridgeRef.destroy();
-      }
-      setDataBridge(null);
-      setNodeStore(null);
-      setNodeStoreReady(false);
-      if (typeof window !== "undefined") {
-        delete window.__xnetNodeStore;
-      }
-      if ("close" in nodeStorageAdapter && typeof nodeStorageAdapter.close === "function") {
-        nodeStorageAdapter.close();
-      }
-    };
-  }, [authorDID, config.nodeStorage, config.signingKey, config.dataBridge]);
-  useEffect3(() => {
-    if (config.syncManager) {
-      setSyncManager(config.syncManager);
-      const sm2 = config.syncManager;
-      if (sm2.setIdentity && authorDID && config.signingKey) {
-        sm2.setIdentity(authorDID, config.signingKey);
-      }
-      config.syncManager.start().catch((err) => {
-        console.warn("[XNetProvider] External SyncManager failed to start:", err);
-      });
-      return () => {
-        config.syncManager.stop().catch((err) => {
-          console.warn("[XNetProvider] External SyncManager failed to stop:", err);
-        });
-        setSyncManager(null);
-      };
-    }
-    if (!nodeStore || !nodeStoreReady || config.disableSyncManager) {
-      log3("SyncManager disabled or NodeStore not ready", {
-        nodeStore: !!nodeStore,
-        nodeStoreReady,
-        disableSyncManager: config.disableSyncManager
-      });
-      setSyncManager(null);
-      return;
-    }
-    const storage = nodeStorageRef.current;
-    if (!storage) {
-      log3("No storage adapter available");
-      return;
-    }
-    const signalingUrl = hubUrl ?? config.signalingServers?.[0] ?? "ws://localhost:4444";
-    if (autoAuth && hubUrl && (!authorDID || !config.signingKey)) {
-      console.warn("[XNetProvider] Hub auth enabled but authorDID/signingKey missing");
-    }
-    if (autoBackup && (!hubUrl || !encryptionKey)) {
-      console.warn("[XNetProvider] Auto-backup requires hubUrl and encryptionKey");
-    }
-    console.log("[XNetProvider] Creating SyncManager with signalingUrl:", signalingUrl);
-    log3("Creating SyncManager with signalingUrl:", signalingUrl);
-    let autoBackupManager = null;
-    const enableAutoBackup = Boolean(autoBackup && hubUrl && encryptionKey);
-    const sm = createSyncManager({
-      nodeStore,
-      storage,
-      signalingUrl,
-      authorDID,
-      blobStore: config.blobStore,
-      nodeSyncRoom: hubUrl ? nodeSyncRoom : void 0,
-      getUCANToken: hubUrl ? getHubAuthToken : void 0,
-      onDocUpdate: enableAutoBackup ? (nodeId, doc) => {
-        autoBackupManager?.handleDocUpdate(nodeId, doc);
-      } : void 0,
-      onDocEvict: enableAutoBackup ? (nodeId, doc) => {
-        autoBackupManager?.handleDocEvict(nodeId, doc);
-      } : void 0
-    });
-    if (enableAutoBackup && hubUrl && encryptionKey) {
-      autoBackupManager = new AutoBackup(
-        async (docId, plaintext) => {
-          await uploadBackup(
-            {
-              hubUrl,
-              encryptionKey,
-              getAuthToken: autoAuth ? getHubAuthToken : void 0
-            },
-            docId,
-            plaintext
-          );
-        },
-        {
-          debounceMs: backupDebounceMs,
-          isEnabled: () => sm.connection?.status === "connected"
-        }
-      );
-    }
-    setSyncManager(sm);
-    console.log("[XNetProvider] SyncManager created and set in context");
-    log3("SyncManager created, starting...");
-    sm.start().then(() => {
-      log3("SyncManager started successfully");
-    }).catch((err) => {
-      console.warn("[XNetProvider] SyncManager failed to start:", err);
-      log3("SyncManager start failed:", err);
-    });
-    return () => {
-      sm.stop().catch((err) => {
-        console.warn("[XNetProvider] SyncManager failed to stop:", err);
-      });
-      autoBackupManager?.destroy();
-      setSyncManager(null);
-    };
-  }, [
-    nodeStore,
-    nodeStoreReady,
-    config.disableSyncManager,
-    config.syncManager,
-    config.signalingServers,
-    config.blobStore,
-    authorDID,
-    autoAuth,
-    autoBackup,
-    backupDebounceMs,
-    encryptionKey,
-    getHubAuthToken,
-    hubUrl,
-    nodeSyncRoom
-  ]);
-  useEffect3(() => {
-    if (!dataBridge || !syncManager) return;
-    if (dataBridge instanceof MainThreadBridge) {
-      dataBridge.setSyncManager(syncManager);
-      log3("Connected SyncManager to DataBridge");
-    }
-    return () => {
-      if (dataBridge instanceof MainThreadBridge) {
-        dataBridge.setSyncManager(null);
-      }
-    };
-  }, [dataBridge, syncManager]);
-  useEffect3(() => {
-    if (!syncManager) {
-      setHubStatus("disconnected");
-      return;
-    }
-    setHubStatus(syncManager.status);
-    return syncManager.on("status", (status) => {
-      setHubStatus(status);
-    });
-  }, [syncManager]);
-  useEffect3(() => {
-    if (!nodeStore || !syncManager || !hubUrl || !enableSearchIndex) return;
-    const connection = syncManager.connection;
-    if (!connection) return;
-    const timers = /* @__PURE__ */ new Map();
-    const pending = /* @__PURE__ */ new Map();
-    const schedule = (docId, payload) => {
-      pending.set(docId, payload);
-      const existing = timers.get(docId);
-      if (existing) clearTimeout(existing);
-      timers.set(
-        docId,
-        setTimeout(() => {
-          timers.delete(docId);
-          const next = pending.get(docId);
-          pending.delete(docId);
-          if (!next) return;
-          if (connection.status !== "connected") return;
-          if (next.type === "remove") {
-            connection.sendRaw({ type: "index-remove", docId });
-            return;
-          }
-          connection.sendRaw({
-            type: "index-update",
-            docId,
-            meta: next.meta
-          });
-        }, HUB_INDEX_DEBOUNCE_MS)
-      );
-    };
-    const handleChange = (event) => {
-      const node = event.node;
-      if (!node || node.deleted) {
-        schedule(event.change.payload.nodeId, { type: "remove" });
-        return;
-      }
-      if (!node.schemaId) return;
-      const title = typeof node.properties.title === "string" ? node.properties.title : "";
-      schedule(node.id, {
-        type: "update",
-        meta: {
-          schemaIri: node.schemaId,
-          title,
-          properties: node.properties
-        }
-      });
-    };
-    const unsubscribe = nodeStore.subscribe(handleChange);
-    return () => {
-      unsubscribe();
-      for (const timer of timers.values()) {
-        clearTimeout(timer);
-      }
-      timers.clear();
-      pending.clear();
-    };
-  }, [enableSearchIndex, hubUrl, nodeStore, syncManager]);
-  useEffect3(() => {
-    if (!nodeStore || !nodeStoreReady || config.disablePlugins) {
-      log3("PluginRegistry disabled or NodeStore not ready");
-      setPluginRegistry(null);
-      return;
-    }
-    const platform = config.platform ?? "web";
-    log3("Creating PluginRegistry with platform:", platform);
-    const registry = new PluginRegistry(nodeStore, platform);
-    setPluginRegistry(registry);
-    registry.loadFromStore().catch((err) => {
-      console.warn("[XNetProvider] Failed to load plugins from store:", err);
-    });
-    return () => {
-      const plugins = registry.getAll();
-      for (const plugin of plugins) {
-        if (plugin.status === "active") {
-          registry.deactivate(plugin.manifest.id).catch((err) => {
-            console.warn(`[XNetProvider] Failed to deactivate plugin ${plugin.manifest.id}:`, err);
-          });
-        }
-      }
-      setPluginRegistry(null);
-    };
-  }, [nodeStore, nodeStoreReady, config.disablePlugins, config.platform]);
-  const value = useMemo2(
-    () => ({
-      nodeStore,
-      nodeStoreReady,
-      identity: config.identity,
-      authorDID: authorDID ?? null,
-      syncManager,
-      hubUrl,
-      hubStatus,
-      hubConnection: syncManager?.connection ?? null,
-      getHubAuthToken: hubUrl ? getHubAuthToken : void 0,
-      encryptionKey,
-      blobStore: config.blobStore ?? null,
-      pluginRegistry
-    }),
-    [
-      nodeStore,
-      nodeStoreReady,
-      config.identity,
-      authorDID,
-      syncManager,
-      hubUrl,
-      hubStatus,
-      getHubAuthToken,
-      encryptionKey,
-      config.blobStore,
-      pluginRegistry
-    ]
-  );
-  let content = pluginRegistry ? React.createElement(PluginRegistryContext.Provider, { value: pluginRegistry }, children) : children;
-  if (dataBridge) {
-    content = React.createElement(DataBridgeContext.Provider, { value: dataBridge }, content);
-  }
-  if (config.telemetry) {
-    content = React.createElement(TelemetryContext.Provider, { value: config.telemetry }, content);
-  }
-  content = React.createElement(SecurityProvider, {
-    level: config.security?.level,
-    minVerificationLevel: config.security?.minVerificationLevel,
-    verificationPolicy: config.security?.verificationPolicy,
-    registry: config.security?.registry,
-    keyBundle: config.keyBundle,
-    children: content
-  });
-  return React.createElement(XNetContext.Provider, { value }, content);
-}
-function useXNet() {
-  const context = useContext4(XNetContext);
-  if (!context) {
-    throw new Error("useXNet must be used within an XNetProvider");
-  }
-  return context;
-}
-
-// src/instrumentation.ts
-import { createContext as createContext5, useContext as useContext5 } from "react";
-var InstrumentationContext = createContext5(null);
-function useInstrumentation() {
-  return useContext5(InstrumentationContext);
-}
-
-// src/hooks/useNodeStore.ts
-import { useContext as useContext6 } from "react";
-function useNodeStore() {
-  const context = useContext6(XNetContext);
-  if (context) {
-    return {
-      store: context.nodeStore,
-      isReady: context.nodeStoreReady,
-      error: null
-    };
-  }
-  throw new Error("useNodeStore must be used within an XNetProvider");
-}
-
-export {
-  SecurityProvider,
-  useSecurityContext,
-  useSecurityContextOptional,
-  TelemetryContext,
-  useTelemetryReporter,
-  PluginRegistryContext,
-  usePluginRegistry,
-  usePluginRegistryOptional,
-  usePlugins,
-  useContributions,
-  useViews,
-  useCommands,
-  useSlashCommands,
-  useSidebarItems,
-  useEditorExtensions,
-  useEditorExtensionsSafe,
-  useView,
-  useCommand,
-  uploadBackup,
-  downloadBackup,
-  createConnectionManager,
-  METABRIDGE_ORIGIN,
-  METABRIDGE_SEED_ORIGIN,
-  createMetaBridge,
-  createNodePool,
-  NodeStoreSyncProvider,
-  createOfflineQueue,
-  createRegistry,
-  createSyncManager,
-  XNetContext,
-  useDataBridge,
-  XNetProvider,
-  useXNet,
-  InstrumentationContext,
-  useInstrumentation,
-  useNodeStore
-};