@xnetjs/runtime 0.0.1

package/dist/index.js

@@ -0,0 +1,3061 @@
+// src/client.ts
+import { getSigningPublicKeyFromPrivate, sign, verify } from "@xnetjs/crypto";
+import { MemoryNodeStorageAdapter, NodeStore } from "@xnetjs/data";
+import { createMainThreadBridgeSync } from "@xnetjs/data-bridge";
+import { UndoManager } from "@xnetjs/history";
+import { PluginRegistry } from "@xnetjs/plugins";
+
+// src/sync/sync-manager.ts
+import {
+  createSyncLifecycleState,
+  resolveSyncReplicationPolicy,
+  signYjsUpdate,
+  verifyYjsEnvelopeV1
+} from "@xnetjs/sync";
+import {
+  Awareness,
+  applyAwarenessUpdate,
+  encodeAwarenessUpdate,
+  removeAwarenessStates
+} from "y-protocols/awareness";
+import * as Y2 from "yjs";
+
+// 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 toBase643(data) {
+    let binary = "";
+    for (let i = 0; i < data.length; i++) {
+      binary += String.fromCharCode(data[i]);
+    }
+    return btoa(binary);
+  }
+  function fromBase642(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: toBase643(blobData)
+              });
+            } else {
+              connection.publish(BLOB_SYNC_ROOM, {
+                type: "blob-data",
+                cid,
+                data: toBase643(blobData)
+              });
+            }
+          } else {
+            connection.publish(BLOB_SYNC_ROOM, {
+              type: "blob-not-found",
+              cid
+            });
+          }
+        }
+        break;
+      }
+      case "blob-data": {
+        const blobData = fromBase642(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 connectTimer = null;
+  let destroyed = false;
+  let connectInProgress = false;
+  let policyViolation = false;
+  const reconnectDelay = config.reconnectDelay ?? 2e3;
+  const maxReconnectDelay = config.maxReconnectDelay ?? 3e4;
+  const rateLimitBackoffMs = config.rateLimitBackoffMs ?? 15e3;
+  const maxReconnects = config.maxReconnects ?? Infinity;
+  const connectTimeout = config.connectTimeout ?? 1e4;
+  const initialConnectTimeout = config.initialConnectTimeout ?? (connectTimeout > 0 ? Math.min(connectTimeout, 6e3) : 0);
+  function clearConnectTimer() {
+    if (connectTimer) {
+      clearTimeout(connectTimer);
+      connectTimer = null;
+    }
+  }
+  function abandonSocket(socket) {
+    if (!socket) return;
+    socket.onopen = null;
+    socket.onmessage = null;
+    socket.onclose = null;
+    socket.onerror = null;
+    try {
+      socket.close();
+    } catch {
+    }
+  }
+  function onConnectTimeout() {
+    connectTimer = null;
+    if (status !== "connecting") return;
+    log("WebSocket connect timeout after", connectTimeout, "ms");
+    connectInProgress = false;
+    const stalled = ws;
+    ws = null;
+    abandonSocket(stalled);
+    setStatus("error");
+    scheduleReconnect();
+  }
+  function armConnectTimeout() {
+    const timeout = reconnectAttempts === 0 ? initialConnectTimeout : connectTimeout;
+    if (timeout <= 0 || !Number.isFinite(timeout)) return;
+    connectTimer = setTimeout(onConnectTimeout, timeout);
+  }
+  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;
+  }
+  function hubConfigured() {
+    return Boolean(config.url) && config.url.trim().length > 0;
+  }
+  function shouldSkipConnect() {
+    if (destroyed) {
+      log("doConnect called but manager is destroyed");
+      return true;
+    }
+    if (connectInProgress) {
+      log("doConnect called but connection already in progress");
+      return true;
+    }
+    if (!hubConfigured()) {
+      log("No hub URL configured \u2014 staying offline");
+      return true;
+    }
+    return false;
+  }
+  async function doConnect() {
+    if (shouldSkipConnect()) return;
+    connectInProgress = true;
+    log("Connecting to:", config.url);
+    setStatus("connecting");
+    try {
+      const token = await resolveAuthToken();
+      ws = new WebSocket(config.url, buildProtocols(token));
+      armConnectTimeout();
+      ws.onopen = () => {
+        clearConnectTimer();
+        connectInProgress = false;
+        log("WebSocket connected");
+        setStatus("connected");
+        reconnectAttempts = 0;
+        policyViolation = false;
+        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) => {
+        clearConnectTimer();
+        connectInProgress = false;
+        log("WebSocket closed, code:", event.code, "reason:", event.reason || "(none)");
+        ws = null;
+        policyViolation = event.code === 1008;
+        setStatus("disconnected");
+        scheduleReconnect();
+      };
+      ws.onerror = (event) => {
+        clearConnectTimer();
+        connectInProgress = false;
+        log("WebSocket error:", event);
+        setStatus("error");
+      };
+    } catch (err) {
+      clearConnectTimer();
+      connectInProgress = false;
+      log("Failed to create WebSocket:", err);
+      setStatus("error");
+      scheduleReconnect();
+    }
+  }
+  function scheduleReconnect() {
+    if (destroyed || reconnectAttempts >= maxReconnects) return;
+    if (reconnectTimer) return;
+    reconnectAttempts++;
+    let backoff;
+    if (policyViolation) {
+      policyViolation = false;
+      backoff = rateLimitBackoffMs + Math.floor(Math.random() * rateLimitBackoffMs * 0.5);
+    } else {
+      backoff = Math.min(reconnectDelay * 2 ** (reconnectAttempts - 1), maxReconnectDelay);
+    }
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      void doConnect();
+    }, backoff);
+  }
+  return {
+    get status() {
+      return status;
+    },
+    get roomCount() {
+      return rooms.size;
+    },
+    connect() {
+      destroyed = false;
+      void doConnect();
+    },
+    disconnect() {
+      destroyed = true;
+      clearConnectTimer();
+      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);
+    }
+  };
+}
+function createMultiHubConnectionManager(config) {
+  const managers = dedupeHubConfigs(config.hubs).map((hub) => createConnectionManager(hub));
+  const statusListeners = /* @__PURE__ */ new Set();
+  const messageListeners = /* @__PURE__ */ new Set();
+  const rooms = /* @__PURE__ */ new Map();
+  let status = aggregateConnectionStatus(managers.map((manager) => manager.status));
+  managers.forEach((manager) => {
+    manager.onStatus(() => {
+      emitAggregateStatus();
+    });
+    manager.onMessage((message) => {
+      for (const handler of messageListeners) {
+        try {
+          handler(message);
+        } catch {
+        }
+      }
+    });
+  });
+  function emitAggregateStatus() {
+    const nextStatus = aggregateConnectionStatus(managers.map((manager) => manager.status));
+    if (nextStatus === status) return;
+    status = nextStatus;
+    for (const handler of statusListeners) {
+      try {
+        handler(nextStatus);
+      } catch {
+      }
+    }
+  }
+  function ensureRoom(room) {
+    const existing = rooms.get(room);
+    if (existing) {
+      return {
+        ready: existing.ready,
+        unsubscribe: existing.unsubscribe
+      };
+    }
+    const handlers = /* @__PURE__ */ new Set();
+    const dispatch = (data) => {
+      for (const handler of handlers) {
+        try {
+          handler(data);
+        } catch {
+        }
+      }
+    };
+    const subscriptions = managers.map((manager) => manager.joinRoomAsync(room, dispatch));
+    const ready = Promise.all(subscriptions.map((subscription) => subscription.ready)).then(
+      () => void 0
+    );
+    const unsubscribe = () => {
+      for (const subscription of subscriptions) {
+        subscription.unsubscribe();
+      }
+      rooms.delete(room);
+    };
+    rooms.set(room, {
+      handlers,
+      ready,
+      unsubscribe
+    });
+    return { ready, unsubscribe };
+  }
+  return {
+    get status() {
+      return status;
+    },
+    get roomCount() {
+      return rooms.size;
+    },
+    connect() {
+      for (const manager of managers) {
+        manager.connect();
+      }
+      emitAggregateStatus();
+    },
+    disconnect() {
+      for (const manager of managers) {
+        manager.disconnect();
+      }
+      emitAggregateStatus();
+    },
+    joinRoom(room, handler) {
+      const { unsubscribe } = ensureRoom(room);
+      const current = rooms.get(room);
+      current?.handlers.add(handler);
+      return () => {
+        const latest = rooms.get(room);
+        if (!latest) return;
+        latest.handlers.delete(handler);
+        if (latest.handlers.size === 0) {
+          unsubscribe();
+        }
+      };
+    },
+    joinRoomAsync(room, handler) {
+      const { ready, unsubscribe } = ensureRoom(room);
+      const current = rooms.get(room);
+      current?.handlers.add(handler);
+      return {
+        ready,
+        unsubscribe: () => {
+          const latest = rooms.get(room);
+          if (!latest) return;
+          latest.handlers.delete(handler);
+          if (latest.handlers.size === 0) {
+            unsubscribe();
+          }
+        }
+      };
+    },
+    leaveRoom(room) {
+      const current = rooms.get(room);
+      current?.unsubscribe();
+    },
+    publish(room, data) {
+      for (const manager of managers) {
+        manager.publish(room, data);
+      }
+    },
+    sendRaw(message) {
+      for (const manager of managers) {
+        manager.sendRaw(message);
+      }
+    },
+    onMessage(handler) {
+      messageListeners.add(handler);
+      return () => messageListeners.delete(handler);
+    },
+    onStatus(handler) {
+      statusListeners.add(handler);
+      return () => statusListeners.delete(handler);
+    }
+  };
+}
+function dedupeHubConfigs(configs) {
+  const seen = /* @__PURE__ */ new Set();
+  return configs.filter((config) => {
+    if (!config.url || seen.has(config.url)) return false;
+    seen.add(config.url);
+    return true;
+  });
+}
+function aggregateConnectionStatus(statuses) {
+  if (statuses.includes("connected")) return "connected";
+  if (statuses.includes("connecting")) return "connecting";
+  if (statuses.length > 0 && statuses.every((status) => status === "error")) return "error";
+  if (statuses.includes("error")) return "error";
+  return "disconnected";
+}
+
+// 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 MAX_SENDS_PER_WINDOW = 40;
+var SEND_WINDOW_MS = 1e3;
+var SYNC_RESPONSE_TIMEOUT_MS = 4e3;
+var STRUCTURAL_REJECTION_CODES = /* @__PURE__ */ new Set(["INVALID_HASH", "INVALID_SIGNATURE", "INVALID_CHANGE"]);
+var MAX_STRUCTURAL_REJECTIONS = 5;
+var NodeStoreSyncProvider = class {
+  constructor(store, room) {
+    this.store = store;
+    this.room = room;
+  }
+  /** Confirmed, persisted high-water mark (advanced from the hub's response). */
+  lastSyncedLamport = 0;
+  /** Optimistic in-memory cursor: lamport of the last change actually sent. */
+  pushedThrough = 0;
+  cursorLoaded = false;
+  connection = null;
+  roomCleanup = null;
+  statusCleanup = null;
+  messageCleanup = null;
+  storeCleanup = null;
+  unknownChangeTypeListeners = /* @__PURE__ */ new Set();
+  // Throttled send queue.
+  sendQueue = [];
+  queuedHashes = /* @__PURE__ */ new Set();
+  sendTimer = null;
+  sentInWindow = 0;
+  // Request-sync-first: resolver for the in-flight node-sync-response wait.
+  syncResponseResolver = null;
+  // Protocol-skew circuit breaker state. `structuralRejections` counts
+  // consecutive structural node-errors (reset on forward progress); once it
+  // trips, `outboundHalted` stops all pushes until the next reconnect.
+  structuralRejections = 0;
+  outboundHalted = false;
+  // Resolver for an in-flight node-clear ("reset my data") round-trip.
+  clearResolver = null;
+  // One-shot: emit a performance mark when the first remote change BEGINS
+  // applying to the local store (marked just before the awaited write, so it
+  // captures when the inbound write burst starts contending with reads on the
+  // single SQLite worker). Makes that contention visible on the boot timeline
+  // and in DevTools (exploration 0212).
+  firstRemoteApplyMarked = false;
+  /**
+   * Mark the first remote apply once. Platform-agnostic and defensive: a
+   * missing `performance` global, or a throw, is a no-op — instrumentation
+   * must never break sync.
+   */
+  markFirstRemoteApply() {
+    if (this.firstRemoteApplyMarked) return;
+    this.firstRemoteApplyMarked = true;
+    try {
+      performance?.mark?.("xnet:sync:first-remote-apply");
+    } catch {
+    }
+  }
+  /**
+   * 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.onConnected();
+      } else {
+        this.onDisconnected();
+      }
+    });
+    this.storeCleanup = this.store.subscribe((event) => {
+      if (event.isRemote) return;
+      this.enqueueChange(event.change);
+    });
+    if (connection.status === "connected") {
+      void this.onConnected();
+    }
+  }
+  detach() {
+    this.roomCleanup?.();
+    this.statusCleanup?.();
+    this.messageCleanup?.();
+    this.storeCleanup?.();
+    this.roomCleanup = null;
+    this.statusCleanup = null;
+    this.messageCleanup = null;
+    this.storeCleanup = null;
+    this.connection = null;
+    this.clearSendQueue();
+    this.resolveSyncResponse();
+    this.resolveClear(0);
+  }
+  // ─── Connect lifecycle ──────────────────────────────────────────────────
+  /**
+   * On connect: load the persisted cursor, ask the hub for its high-water mark
+   * FIRST, then push only the changes the hub is actually missing. Combined
+   * with the persisted cursor, a normal reload of an in-sync workspace pushes
+   * nothing (exploration 0206).
+   */
+  async onConnected() {
+    this.outboundHalted = false;
+    this.structuralRejections = 0;
+    await this.ensureCursorLoaded();
+    if (!this.connection || this.connection.status !== "connected") return;
+    this.requestSync();
+    await this.waitForSyncResponse();
+    await this.syncLocalChanges();
+  }
+  onDisconnected() {
+    this.clearSendQueue();
+    this.resolveSyncResponse();
+  }
+  async ensureCursorLoaded() {
+    if (this.cursorLoaded) return;
+    try {
+      const stored = await this.store.getSyncCursor(this.room);
+      this.lastSyncedLamport = Math.max(this.lastSyncedLamport, stored);
+      this.pushedThrough = Math.max(this.pushedThrough, this.lastSyncedLamport);
+    } catch (err) {
+      console.warn("[NodeStoreSync] failed to load sync cursor; replaying from 0:", err);
+    }
+    this.cursorLoaded = true;
+  }
+  waitForSyncResponse() {
+    return new Promise((resolve) => {
+      this.syncResponseResolver = resolve;
+      setTimeout(() => this.resolveSyncResponse(), SYNC_RESPONSE_TIMEOUT_MS);
+    });
+  }
+  resolveSyncResponse() {
+    const resolve = this.syncResponseResolver;
+    this.syncResponseResolver = null;
+    resolve?.();
+  }
+  /**
+   * Ask the hub to wipe every stored change for this room ("reset my data"),
+   * then reset the local sync cursor so a later sync re-pulls from scratch.
+   * Resolves with the number of changes the hub removed (0 on timeout or when
+   * offline). Pairs with a local wipe + reload for a full reset.
+   */
+  async clearRoom() {
+    if (!this.connection || this.connection.status !== "connected") return 0;
+    const cleared = await new Promise((resolve) => {
+      this.clearResolver = resolve;
+      this.connection?.sendRaw({ type: "node-clear", room: this.room });
+      setTimeout(() => this.resolveClear(0), SYNC_RESPONSE_TIMEOUT_MS);
+    });
+    this.lastSyncedLamport = 0;
+    this.pushedThrough = 0;
+    this.cursorLoaded = true;
+    try {
+      await this.store.setSyncCursor(this.room, 0);
+    } catch {
+    }
+    return cleared;
+  }
+  resolveClear(cleared) {
+    const resolve = this.clearResolver;
+    this.clearResolver = null;
+    resolve?.(cleared);
+  }
+  // ─── Inbound ────────────────────────────────────────────────────────────
+  handleRoomMessage(data) {
+    if (data.type === "node-change") {
+      const change = data.change;
+      void this.handleRemoteChange(change);
+    }
+  }
+  handleDirectMessage(message) {
+    if (message.type === "node-cleared") {
+      if (message.room === this.room) {
+        this.resolveClear(typeof message.cleared === "number" ? message.cleared : 0);
+      }
+      return;
+    }
+    if (message.type === "node-error") {
+      const code = typeof message.code === "string" ? message.code : "UNKNOWN";
+      console.warn(
+        "[NodeStoreSync] hub rejected a node change:",
+        code,
+        message.error ?? message.message ?? ""
+      );
+      if (STRUCTURAL_REJECTION_CODES.has(code)) {
+        this.recordStructuralRejection(code, message);
+      }
+      return;
+    }
+    if (message.type !== "node-sync-response") return;
+    const response = message;
+    if (response.room !== this.room) return;
+    void this.handleSyncResponse(response);
+  }
+  /**
+   * Trip the circuit breaker after enough consecutive structural rejections.
+   *
+   * Structural rejections (bad hash/signature/shape) are not transient: the
+   * same change re-sent is rejected again, and — when it's a protocol/build
+   * skew — so is every other local change. Rather than re-flood the hub forever
+   * (the symptom that motivated this), we stop pushing, drop the queue, and log
+   * ONE actionable error. A reconnect clears the breaker (the hub may have been
+   * upgraded) via {@link onConnected}, and any forward progress resets the
+   * counter so sparse one-off rejections never accumulate to a false trip.
+   */
+  recordStructuralRejection(code, message) {
+    this.structuralRejections += 1;
+    if (this.outboundHalted || this.structuralRejections < MAX_STRUCTURAL_REJECTIONS) return;
+    this.outboundHalted = true;
+    this.clearSendQueue();
+    console.error(
+      `[NodeStoreSync] Pausing outbound sync after ${this.structuralRejections} consecutive "${code}" rejections. Local changes are valid but the hub keeps rejecting them \u2014 this usually means the hub is on an incompatible @xnetjs/sync build (protocol/hash skew). Outbound sync resumes on reconnect. Hub said: ${message.error ?? message.message ?? "(no detail)"}`
+    );
+  }
+  requestSync() {
+    if (!this.connection) return;
+    this.connection.sendRaw({
+      type: "node-sync-request",
+      room: this.room,
+      sinceLamport: this.lastSyncedLamport
+    });
+  }
+  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;
+    }
+    try {
+      this.markFirstRemoteApply();
+      await this.store.applyRemoteChange(change);
+    } catch (err) {
+      console.warn(
+        `[NodeStoreSync] skipping un-appliable remote change for node ${change.payload?.nodeId}:`,
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+  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) {
+        this.markFirstRemoteApply();
+        await this.store.applyRemoteChanges(knownChanges);
+      }
+    }
+    if (response.highWaterMark > this.lastSyncedLamport) {
+      this.lastSyncedLamport = response.highWaterMark;
+      this.pushedThrough = Math.max(this.pushedThrough, this.lastSyncedLamport);
+      this.structuralRejections = 0;
+      try {
+        await this.store.setSyncCursor(this.room, this.lastSyncedLamport);
+      } catch (err) {
+        console.warn("[NodeStoreSync] failed to persist sync cursor:", err);
+      }
+    }
+    this.resolveSyncResponse();
+  }
+  // ─── Outbound (throttled) ────────────────────────────────────────────────
+  /** Enqueue every local change since the last confirmed send, then drain. */
+  async syncLocalChanges() {
+    if (this.outboundHalted) return;
+    if (!this.connection || this.connection.status !== "connected") return;
+    const changes = await this.store.getChangesSince(this.pushedThrough);
+    if (changes.length === 0) return;
+    changes.sort((a, b) => a.lamport - b.lamport || a.authorDID.localeCompare(b.authorDID));
+    for (const change of changes) {
+      this.enqueueChange(change);
+    }
+  }
+  /** Queue a change for throttled broadcast (deduped by hash). */
+  enqueueChange(change) {
+    if (this.outboundHalted) return;
+    if (change.lamport <= this.pushedThrough) return;
+    if (this.queuedHashes.has(change.hash)) return;
+    this.queuedHashes.add(change.hash);
+    this.sendQueue.push(change);
+    this.scheduleDrain(0);
+  }
+  scheduleDrain(delayMs) {
+    if (this.sendTimer) return;
+    this.sendTimer = setTimeout(() => {
+      this.sendTimer = null;
+      this.drain();
+    }, delayMs);
+  }
+  drain() {
+    if (this.outboundHalted) return;
+    if (!this.connection || this.connection.status !== "connected") return;
+    this.sentInWindow = 0;
+    while (this.sendQueue.length > 0 && this.sentInWindow < MAX_SENDS_PER_WINDOW) {
+      const change = this.sendQueue.shift();
+      this.queuedHashes.delete(change.hash);
+      this.publishChange(change);
+      this.sentInWindow += 1;
+    }
+    if (this.sendQueue.length > 0) {
+      this.scheduleDrain(SEND_WINDOW_MS);
+    }
+  }
+  publishChange(change) {
+    if (!this.connection) return;
+    this.connection.publish(this.room, {
+      type: "node-change",
+      room: this.room,
+      change: this.serializeChange(change)
+    });
+    this.pushedThrough = Math.max(this.pushedThrough, change.lamport);
+  }
+  clearSendQueue() {
+    if (this.sendTimer) {
+      clearTimeout(this.sendTimer);
+      this.sendTimer = null;
+    }
+    this.sendQueue = [];
+    this.queuedHashes.clear();
+    this.sentInWindow = 0;
+  }
+  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,
+      lamportAuthor: change.authorDID,
+      authorDid: change.authorDID,
+      wallTime: change.wallTime,
+      parentHash: change.parentHash,
+      payload: change.payload,
+      signatureB64: bytesToBase64(change.signature),
+      // protocolVersion is part of the hashed fields — dropping it makes
+      // every relayed change fail verifyChangeHash on the receiving side
+      protocolVersion: change.protocolVersion,
+      batchId: change.batchId,
+      batchIndex: change.batchIndex,
+      batchSize: change.batchSize
+    };
+  }
+  deserializeChange(serialized) {
+    const payload = serialized.payload && !serialized.payload.schemaId && serialized.schemaId ? { ...serialized.payload, schemaId: serialized.schemaId } : serialized.payload;
+    return {
+      id: serialized.id,
+      type: serialized.type,
+      hash: serialized.hash,
+      parentHash: serialized.parentHash,
+      authorDID: serialized.authorDid,
+      signature: base64ToBytes(serialized.signatureB64),
+      wallTime: serialized.wallTime,
+      lamport: serialized.lamportTime,
+      payload,
+      protocolVersion: serialized.protocolVersion,
+      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: 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, clientId) {
+      entries.push({
+        nodeId,
+        update: toBase64(update),
+        clientId,
+        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
+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 serializeEnvelope(envelope) {
+  let update = "";
+  for (let i = 0; i < envelope.update.length; i++) {
+    update += String.fromCharCode(envelope.update[i]);
+  }
+  let signature = "";
+  for (let i = 0; i < envelope.signature.length; i++) {
+    signature += String.fromCharCode(envelope.signature[i]);
+  }
+  return {
+    update: btoa(update),
+    authorDID: envelope.authorDID,
+    signature: btoa(signature),
+    timestamp: envelope.timestamp,
+    clientId: envelope.clientId
+  };
+}
+function deserializeEnvelope(data) {
+  try {
+    const update = data.update;
+    const signature = data.signature;
+    return {
+      update: Uint8Array.from(atob(update), (char) => char.charCodeAt(0)),
+      authorDID: data.authorDID,
+      signature: Uint8Array.from(atob(signature), (char) => char.charCodeAt(0)),
+      timestamp: data.timestamp,
+      clientId: data.clientId
+    };
+  } catch {
+    return null;
+  }
+}
+function hasEnvelope(data) {
+  return typeof data.envelope === "object" && data.envelope !== null && "update" in data.envelope && "authorDID" in data.envelope && "signature" in data.envelope;
+}
+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 resolveSignalingUrls(primaryUrl, additionalUrls) {
+  const seen = /* @__PURE__ */ new Set();
+  return [primaryUrl, ...additionalUrls ?? []].map((url) => url.trim()).filter((url) => {
+    if (!url || seen.has(url)) return false;
+    seen.add(url);
+    return true;
+  });
+}
+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 REGISTRY_SAVE_DEBOUNCE_MS = 2e3;
+  let registrySaveTimer = null;
+  function scheduleRegistrySave() {
+    if (lifecycleInput.stopped) return;
+    if (registrySaveTimer) return;
+    registrySaveTimer = setTimeout(() => {
+      registrySaveTimer = null;
+      void registry.save();
+    }, REGISTRY_SAVE_DEBOUNCE_MS);
+  }
+  function flushRegistrySave() {
+    if (registrySaveTimer) {
+      clearTimeout(registrySaveTimer);
+      registrySaveTimer = null;
+    }
+    if (lifecycleInput.stopped) return;
+    void registry.save();
+  }
+  const handleVisibilityChange = () => {
+    if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+      flushRegistrySave();
+    }
+  };
+  const handlePageHide = () => {
+    flushRegistrySave();
+  };
+  let persistenceListenersAttached = false;
+  function attachPersistenceListeners() {
+    if (persistenceListenersAttached) return;
+    if (typeof document === "undefined" || typeof addEventListener !== "function") return;
+    persistenceListenersAttached = true;
+    addEventListener("visibilitychange", handleVisibilityChange);
+    addEventListener("pagehide", handlePageHide);
+  }
+  function detachPersistenceListeners() {
+    if (!persistenceListenersAttached) return;
+    persistenceListenersAttached = false;
+    try {
+      removeEventListener("visibilitychange", handleVisibilityChange);
+      removeEventListener("pagehide", handlePageHide);
+    } catch {
+    }
+  }
+  const signalingUrls = resolveSignalingUrls(config.signalingUrl, config.signalingUrls);
+  const connection = signalingUrls.length > 1 ? createMultiHubConnectionManager({
+    hubs: signalingUrls.map((url) => ({
+      url,
+      ucanToken: config.ucanToken,
+      getUCANToken: config.getUCANToken
+    }))
+  }) : createConnectionManager({
+    url: signalingUrls[0] ?? config.signalingUrl,
+    ucanToken: config.ucanToken,
+    getUCANToken: config.getUCANToken
+  });
+  const replicationPolicy = resolveSyncReplicationPolicy(config.replication);
+  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);
+  const statusListeners = /* @__PURE__ */ new Set();
+  const lifecycleListeners = /* @__PURE__ */ new Set();
+  const verificationFailureListeners = /* @__PURE__ */ new Set();
+  const reconciliationListeners = /* @__PURE__ */ new Set();
+  let status = connection.status;
+  let lifecycleInput = {
+    started: false,
+    stopped: false,
+    localReady: false,
+    everConnected: false,
+    connectionStatus: status,
+    replaying: false
+  };
+  let lifecycle = createSyncLifecycleState(lifecycleInput);
+  let connectedRecovery = null;
+  let lastVerificationFailure = null;
+  let lastReconciliationReport = null;
+  function toBase643(data) {
+    let binary = "";
+    for (let i = 0; i < data.length; i++) {
+      binary += String.fromCharCode(data[i]);
+    }
+    return btoa(binary);
+  }
+  function fromBase642(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;
+  }
+  function createOutgoingSyncPayload(update, clientId) {
+    if (config.signingKey && config.authorDID) {
+      return {
+        envelope: serializeEnvelope(
+          signYjsUpdate(update, config.authorDID, config.signingKey, clientId)
+        )
+      };
+    }
+    if (replicationPolicy.allowUnsignedReplication) {
+      return { update: toBase643(update) };
+    }
+    console.warn(
+      "[SyncManager] Dropping Yjs replication payload because signed replication is required and no signing identity is configured."
+    );
+    return null;
+  }
+  function verifyIncomingUpdate(nodeId, data) {
+    if (hasEnvelope(data)) {
+      const envelope = deserializeEnvelope(data.envelope);
+      if (!envelope) {
+        lastVerificationFailure = {
+          nodeId,
+          sender: typeof data.from === "string" ? data.from : null,
+          reason: "invalid_envelope",
+          at: Date.now()
+        };
+        emitVerificationFailure(lastVerificationFailure);
+        return null;
+      }
+      const verification = verifyYjsEnvelopeV1(envelope);
+      if (!verification.valid) {
+        lastVerificationFailure = {
+          nodeId,
+          sender: typeof data.from === "string" ? data.from : null,
+          reason: verification.reason ?? "invalid_signature",
+          at: Date.now()
+        };
+        emitVerificationFailure(lastVerificationFailure);
+        return null;
+      }
+      return envelope.update;
+    }
+    if (replicationPolicy.requireSignedReplication) {
+      lastVerificationFailure = {
+        nodeId,
+        sender: typeof data.from === "string" ? data.from : null,
+        reason: "missing_envelope",
+        at: Date.now()
+      };
+      emitVerificationFailure(lastVerificationFailure);
+      return null;
+    }
+    if (typeof data.update !== "string") {
+      return null;
+    }
+    return fromBase642(data.update);
+  }
+  function emitStatus(nextStatus) {
+    for (const handler of statusListeners) {
+      try {
+        handler(nextStatus);
+      } catch {
+      }
+    }
+  }
+  function emitLifecycle(nextLifecycle) {
+    for (const handler of lifecycleListeners) {
+      try {
+        handler(nextLifecycle);
+      } catch {
+      }
+    }
+  }
+  function emitVerificationFailure(failure) {
+    for (const handler of verificationFailureListeners) {
+      try {
+        handler(failure);
+      } catch {
+      }
+    }
+  }
+  function emitReconciliationReport(report) {
+    for (const handler of reconciliationListeners) {
+      try {
+        handler(report);
+      } catch {
+      }
+    }
+  }
+  function updateLifecycle(patch = {}) {
+    lifecycleInput = {
+      ...lifecycleInput,
+      ...patch
+    };
+    const nextLifecycle = createSyncLifecycleState(lifecycleInput, lifecycle);
+    const changed = nextLifecycle.phase !== lifecycle.phase || nextLifecycle.connectionStatus !== lifecycle.connectionStatus || nextLifecycle.replaying !== lifecycle.replaying || nextLifecycle.lastTransitionAt !== lifecycle.lastTransitionAt;
+    lifecycle = nextLifecycle;
+    if (changed) {
+      emitLifecycle(nextLifecycle);
+    }
+  }
+  function clearRemotePresence() {
+    for (const [nodeId, awareness] of awarenessMap) {
+      const remoteClientIds = Array.from(awareness.getStates().keys()).filter(
+        (clientId) => clientId !== awareness.clientID
+      );
+      if (remoteClientIds.length > 0) {
+        removeAwarenessStates(awareness, remoteClientIds, "connection-lost");
+      }
+      if (awarenessSnapshots.has(nodeId)) {
+        emitAwarenessSnapshot(nodeId, []);
+      }
+    }
+  }
+  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: toBase643(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: toBase643(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 = fromBase642(data.sv);
+          const diff = Y2.encodeStateAsUpdate(doc, remoteSV);
+          log2(
+            "Received sync-step1, remote SV size:",
+            remoteSV.length,
+            "sending diff size:",
+            diff.length
+          );
+          const payload = createOutgoingSyncPayload(diff, doc.clientID);
+          if (!payload) {
+            break;
+          }
+          connection.publish(room, {
+            type: "sync-step2",
+            from: peerId,
+            to: data.from,
+            ...payload
+          });
+          break;
+        }
+        case "sync-step2": {
+          if (data.to && data.to !== peerId) {
+            log2("Ignoring sync-step2 addressed to different peer:", data.to);
+            break;
+          }
+          const update = verifyIncomingUpdate(nodeId, data);
+          if (!update) {
+            log2("Rejected sync-step2 for node:", nodeId, "last failure:", lastVerificationFailure);
+            break;
+          }
+          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 = verifyIncomingUpdate(nodeId, data);
+          if (!update) {
+            log2("Rejected sync-update for node:", nodeId, "last failure:", lastVerificationFailure);
+            break;
+          }
+          log2("Received sync-update, size:", update.length);
+          Y2.applyUpdate(doc, update, "remote");
+          break;
+        }
+        case "awareness": {
+          const update = fromBase642(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") {
+        const payload = createOutgoingSyncPayload(update, doc.clientID);
+        if (payload) {
+          connection.publish(room, {
+            type: "sync-update",
+            from: peerId,
+            ...payload
+          });
+        }
+      } else {
+        void offlineQueue.enqueue(nodeId, update, doc.clientID);
+      }
+    });
+  }
+  async function drainOfflineQueue() {
+    if (offlineQueue.size === 0) return 0;
+    updateLifecycle({ replaying: true });
+    try {
+      return await offlineQueue.drain(async (entry) => {
+        const room = `xnet-doc-${entry.nodeId}`;
+        if (replicationPolicy.requireSignedReplication) {
+          const payload = createOutgoingSyncPayload(fromBase642(entry.update), entry.clientId ?? 0);
+          if (!payload) {
+            throw new Error("signed replication required");
+          }
+          connection.publish(room, {
+            type: "sync-update",
+            from: peerId,
+            ...payload
+          });
+          return;
+        }
+        connection.publish(room, {
+          type: "sync-update",
+          from: peerId,
+          update: entry.update
+        });
+      });
+    } finally {
+      updateLifecycle({ replaying: false });
+    }
+  }
+  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: toBase643(sv)
+    });
+  }
+  async function reconcileTrackedRooms(options = {}) {
+    const nodeIds = options.nodeIds ?? Array.from(roomCleanups.keys());
+    const replayedOfflineChanges = await drainOfflineQueue();
+    const repairedNodeIds = [];
+    const skippedNodeIds = [];
+    for (const nodeId of nodeIds) {
+      if (!pool.has(nodeId)) {
+        skippedNodeIds.push(nodeId);
+        continue;
+      }
+      const doc = await pool.acquire(nodeId);
+      try {
+        sendSyncStep1(nodeId, doc);
+        repairedNodeIds.push(nodeId);
+      } finally {
+        pool.release(nodeId);
+      }
+    }
+    lastReconciliationReport = {
+      reason: options.reason ?? "manual",
+      replayedOfflineChanges,
+      repairedNodeIds,
+      skippedNodeIds,
+      at: Date.now()
+    };
+    emitReconciliationReport(lastReconciliationReport);
+    return lastReconciliationReport;
+  }
+  async function handleConnected() {
+    if (connectedRecovery) {
+      await connectedRecovery;
+      return;
+    }
+    connectedRecovery = reconcileTrackedRooms({ reason: "reconnect" }).finally(() => {
+      connectedRecovery = null;
+    });
+    await connectedRecovery;
+  }
+  connection.onStatus((nextStatus) => {
+    if (status !== nextStatus) {
+      status = nextStatus;
+      emitStatus(nextStatus);
+    }
+    const everConnected = lifecycleInput.everConnected || nextStatus === "connected";
+    updateLifecycle({
+      connectionStatus: nextStatus,
+      everConnected
+    });
+    if (lifecycleInput.started && !lifecycleInput.stopped && (nextStatus === "disconnected" || nextStatus === "error")) {
+      clearRemotePresence();
+    }
+    if (nextStatus === "connected") {
+      void handleConnected();
+    }
+  });
+  return {
+    async start() {
+      log2("Starting SyncManager...");
+      updateLifecycle({
+        started: true,
+        stopped: false,
+        localReady: false,
+        everConnected: false,
+        connectionStatus: status,
+        replaying: false
+      });
+      await registry.load();
+      if (lifecycleInput.stopped) return;
+      log2("Registry loaded, tracked nodes:", registry.getTracked().length);
+      attachPersistenceListeners();
+      await offlineQueue.load();
+      log2("Offline queue loaded, size:", offlineQueue.size);
+      updateLifecycle({ localReady: true });
+      log2("Connecting to signaling server...");
+      connection.connect();
+      nodeSyncProvider?.attach(connection);
+      blobSync?.start();
+      const tracked = registry.getTracked();
+      log2("Joining rooms for", tracked.length, "tracked nodes");
+      for (const entry of tracked) {
+        void joinNodeRoom(entry.nodeId).catch((err) => {
+          log2("Background room join failed during start for node:", entry.nodeId, err);
+        });
+      }
+      log2("SyncManager started");
+    },
+    async stop() {
+      updateLifecycle({
+        stopped: true,
+        replaying: false
+      });
+      blobSync?.stop();
+      nodeSyncProvider?.detach();
+      for (const nodeId of Array.from(roomCleanups.keys())) {
+        leaveNodeRoom(nodeId);
+      }
+      detachPersistenceListeners();
+      if (registrySaveTimer) {
+        clearTimeout(registrySaveTimer);
+        registrySaveTimer = null;
+      }
+      connection.disconnect();
+      await pool.flushAll();
+      registry.prune();
+      await registry.save();
+      await offlineQueue.save();
+      await pool.destroy();
+    },
+    track(nodeId, schemaId) {
+      registry.track(nodeId, schemaId);
+      scheduleRegistrySave();
+      joinNodeRoom(nodeId).catch((err) => {
+        log2("Error joining room for track:", err);
+      });
+    },
+    untrack(nodeId) {
+      registry.untrack(nodeId);
+      scheduleRegistrySave();
+      leaveNodeRoom(nodeId);
+    },
+    async acquire(nodeId) {
+      log2("Acquiring doc for node:", nodeId);
+      registry.touch(nodeId);
+      scheduleRegistrySave();
+      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)) {
+        void joinNodeRoom(nodeId).catch((err) => {
+          log2("Background room join failed for node:", nodeId, err);
+        });
+      } else if (connection.status === "connected") {
+        sendSyncStep1(nodeId, doc);
+      }
+      if (blobSync) {
+        const cids = extractBlobCids(doc);
+        if (cids.length > 0) {
+          blobSync.requestBlobs(cids);
+        }
+      }
+      return doc;
+    },
+    release(nodeId) {
+      pool.release(nodeId);
+    },
+    async clearHubData() {
+      if (!nodeSyncProvider) return 0;
+      return nodeSyncProvider.clearRoom();
+    },
+    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);
+      }
+    },
+    reconcile(options) {
+      return reconcileTrackedRooms(options);
+    },
+    get status() {
+      return status;
+    },
+    get lifecycle() {
+      return lifecycle;
+    },
+    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;
+    },
+    get lastVerificationFailure() {
+      return lastVerificationFailure;
+    },
+    get lastReconciliationReport() {
+      return lastReconciliationReport;
+    },
+    on(event, handler) {
+      if (event === "status") {
+        const statusHandler = handler;
+        statusListeners.add(statusHandler);
+        return () => statusListeners.delete(statusHandler);
+      }
+      if (event === "lifecycle") {
+        const lifecycleHandler = handler;
+        lifecycleListeners.add(lifecycleHandler);
+        return () => lifecycleListeners.delete(lifecycleHandler);
+      }
+      if (event === "verification-failure") {
+        const verificationHandler = handler;
+        verificationFailureListeners.add(verificationHandler);
+        return () => verificationFailureListeners.delete(verificationHandler);
+      }
+      if (event === "reconciliation") {
+        const reconciliationHandler = handler;
+        reconciliationListeners.add(reconciliationHandler);
+        return () => reconciliationListeners.delete(reconciliationHandler);
+      }
+      return () => {
+      };
+    }
+  };
+}
+
+// src/client.ts
+function permissiveDecision(input) {
+  return {
+    allowed: true,
+    action: input.action,
+    subject: input.subject,
+    resource: input.nodeId,
+    roles: [],
+    grants: [],
+    reasons: [],
+    cached: false,
+    evaluatedAt: 0,
+    duration: 0
+  };
+}
+function reportCrash(telemetry, err, codeNamespace) {
+  telemetry?.reportCrash(err instanceof Error ? err : new Error(String(err)), { codeNamespace });
+}
+function buildNodeStore(options, storage) {
+  return new NodeStore({
+    storage,
+    authorDID: options.authorDID,
+    signingKey: options.signingKey,
+    changeSigner: options.changeSigner,
+    authEvaluator: options.authEvaluator,
+    nodeContentCipher: options.nodeContentCipher,
+    auth: options.auth,
+    schemaLookup: options.schemaLookup,
+    propertyLookup: options.propertyLookup,
+    lensRegistry: options.lensRegistry,
+    telemetry: options.telemetry
+  });
+}
+function buildSyncManager(store, storage, options) {
+  const sync = options.sync;
+  if (!sync) return null;
+  const signalingUrl = sync.signalingUrl ?? sync.signalingUrls?.[0] ?? "ws://localhost:4444";
+  return createSyncManager({
+    nodeStore: store,
+    storage,
+    signalingUrl,
+    authorDID: options.authorDID,
+    signingKey: options.signingKey,
+    signalingUrls: sync.signalingUrls,
+    replication: sync.replication,
+    blobStore: sync.blobStore,
+    nodeSyncRoom: sync.nodeSyncRoom,
+    ucanToken: sync.ucanToken,
+    getUCANToken: sync.getUCANToken,
+    poolSize: sync.poolSize,
+    trackTTL: sync.trackTTL,
+    onDocUpdate: sync.onDocUpdate,
+    onDocEvict: sync.onDocEvict
+  });
+}
+function startSyncManager(syncManager, bridge, sync, telemetry) {
+  const managed = bridge;
+  managed.setSyncManager?.(syncManager);
+  if (sync.autoStart === false) return;
+  syncManager.start().catch((err) => reportCrash(telemetry, err, "runtime.syncManager.start"));
+}
+function buildPlugins(store, options) {
+  const plugins = options.plugins;
+  if (!plugins) return null;
+  const registry = new PluginRegistry(store, plugins.platform ?? "web");
+  if (plugins.autoLoad !== false) {
+    registry.loadFromStore().catch((err) => reportCrash(options.telemetry, err, "runtime.plugins.loadFromStore"));
+  }
+  return registry;
+}
+function buildUndo(store, options) {
+  const undo = options.undo;
+  if (!undo) return null;
+  const manager = new UndoManager(
+    store,
+    options.authorDID,
+    { localOnly: undo.localOnly ?? true, maxStackSize: undo.maxStackSize ?? 200 },
+    options.telemetry
+  );
+  manager.start();
+  return manager;
+}
+async function deactivateAllPlugins(registry) {
+  for (const plugin of registry.getAll()) {
+    if (plugin.status === "active") {
+      await registry.deactivate(plugin.manifest.id).catch(() => {
+      });
+    }
+  }
+}
+async function createXNetClient(options) {
+  const { authorDID, signingKey, identity, telemetry, dataBridge, bridgeOptions, sync } = options;
+  if (!authorDID || !signingKey) {
+    throw new Error("createXNetClient requires both authorDID and signingKey.");
+  }
+  const storage = options.nodeStorage ?? new MemoryNodeStorageAdapter();
+  if ("open" in storage && typeof storage.open === "function") {
+    await storage.open();
+  }
+  const store = buildNodeStore(options, storage);
+  await store.initialize();
+  const bridgeCreatedInternally = !dataBridge;
+  const bridge = dataBridge ?? createMainThreadBridgeSync(store, bridgeOptions);
+  const syncManager = buildSyncManager(store, storage, options);
+  if (syncManager && sync) startSyncManager(syncManager, bridge, sync, telemetry);
+  const pluginRegistry = buildPlugins(store, options);
+  const undoManager = buildUndo(store, options);
+  const publicKey = getSigningPublicKeyFromPrivate(signingKey);
+  let destroyed = false;
+  const runtimeStatus = {
+    phase: "ready",
+    bridgeMode: bridgeCreatedInternally ? "main-thread" : "custom",
+    syncEnabled: syncManager !== null
+  };
+  const client = {
+    store,
+    bridge,
+    syncManager,
+    plugins: pluginRegistry,
+    undo: undoManager,
+    identity,
+    authorDID,
+    get status() {
+      return bridge.status;
+    },
+    runtimeStatus,
+    query: bridge.query.bind(bridge),
+    async fetch(schema, queryOptions) {
+      const subscription = bridge.query(schema, queryOptions);
+      const immediate = subscription.getSnapshot();
+      if (immediate !== null) return immediate;
+      return new Promise((resolve) => {
+        const unsubscribe = subscription.subscribe(() => {
+          const snapshot = subscription.getSnapshot();
+          if (snapshot !== null) {
+            unsubscribe();
+            resolve(snapshot);
+          }
+        });
+      });
+    },
+    get(nodeId) {
+      return store.get(nodeId);
+    },
+    mutate: {
+      create: bridge.create.bind(bridge),
+      update: bridge.update.bind(bridge),
+      delete: bridge.delete.bind(bridge),
+      restore: bridge.restore.bind(bridge),
+      bulkWrite: bridge.bulkWrite.bind(bridge),
+      transaction(operations) {
+        if (typeof bridge.transaction !== "function") {
+          throw new Error("The active DataBridge does not support transactions.");
+        }
+        return bridge.transaction(operations);
+      }
+    },
+    auth: options.auth ?? null,
+    async can(input) {
+      if (options.authEvaluator) return options.authEvaluator.can(input);
+      return permissiveDecision(input);
+    },
+    node: {
+      async acquire(nodeId) {
+        if (typeof bridge.acquireDoc !== "function") {
+          throw new Error(
+            "node.acquire() requires a doc-capable bridge with a SyncManager. Enable `sync` or supply a bridge that implements acquireDoc()."
+          );
+        }
+        return bridge.acquireDoc(nodeId);
+      },
+      release(nodeId) {
+        bridge.releaseDoc?.(nodeId);
+      }
+    },
+    sign(message) {
+      return sign(message, signingKey);
+    },
+    verify(message, signature, key) {
+      return verify(message, signature, key ?? publicKey);
+    },
+    on(event, handler) {
+      return bridge.on(event, handler);
+    },
+    async destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      runtimeStatus.phase = "destroyed";
+      undoManager?.stop();
+      if (pluginRegistry) {
+        await deactivateAllPlugins(pluginRegistry);
+      }
+      if (syncManager) {
+        await syncManager.stop().catch(() => {
+        });
+      }
+      const managedBridge = bridge;
+      managedBridge.setSyncManager?.(null);
+      if (bridgeCreatedInternally) {
+        bridge.destroy();
+      }
+      if ("close" in storage && typeof storage.close === "function") {
+        await storage.close();
+      }
+    }
+  };
+  return client;
+}
+
+// src/live-query.ts
+function liveQuery(client, schema, options) {
+  const subscription = client.query(schema, options);
+  const runs = /* @__PURE__ */ new Set();
+  let unsubscribeBridge = null;
+  const read = () => subscription.getSnapshot();
+  const ensureBridgeSubscription = () => {
+    if (unsubscribeBridge) return;
+    unsubscribeBridge = subscription.subscribe(() => {
+      const value = read();
+      for (const run of runs) run(value);
+    });
+  };
+  return {
+    subscribe(run) {
+      runs.add(run);
+      ensureBridgeSubscription();
+      run(read());
+      return () => {
+        runs.delete(run);
+        if (runs.size === 0 && unsubscribeBridge) {
+          unsubscribeBridge();
+          unsubscribeBridge = null;
+        }
+      };
+    },
+    get: read,
+    destroy() {
+      if (unsubscribeBridge) {
+        unsubscribeBridge();
+        unsubscribeBridge = null;
+      }
+      runs.clear();
+    }
+  };
+}
+
+// src/sync/WebSocketSyncProvider.ts
+import { resolveSyncReplicationPolicy as resolveSyncReplicationPolicy2, signYjsUpdate as signYjsUpdate2, verifyYjsEnvelopeV1 as verifyYjsEnvelopeV12 } from "@xnetjs/sync";
+import {
+  Awareness as Awareness2,
+  applyAwarenessUpdate as applyAwarenessUpdate2,
+  encodeAwarenessUpdate as encodeAwarenessUpdate2,
+  removeAwarenessStates as removeAwarenessStates2
+} from "y-protocols/awareness";
+import * as Y3 from "yjs";
+function log3(provider, ...args) {
+  if (typeof localStorage !== "undefined" && localStorage.getItem("xnet:sync:debug") === "true") {
+    console.log(`[WSSyncProvider:${provider.room}]`, ...args);
+  }
+}
+function toBase642(data) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(data).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < data.length; i++) {
+    binary += String.fromCharCode(data[i]);
+  }
+  return btoa(binary);
+}
+function fromBase64(str) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(str, "base64"));
+  }
+  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;
+}
+function serializeEnvelope2(envelope) {
+  return {
+    update: toBase642(envelope.update),
+    authorDID: envelope.authorDID,
+    signature: toBase642(envelope.signature),
+    timestamp: envelope.timestamp,
+    clientId: envelope.clientId
+  };
+}
+function deserializeEnvelope2(data) {
+  try {
+    return {
+      update: fromBase64(data.update),
+      authorDID: data.authorDID,
+      signature: fromBase64(data.signature),
+      timestamp: data.timestamp,
+      clientId: data.clientId
+    };
+  } catch {
+    return null;
+  }
+}
+function hasEnvelope2(data) {
+  return typeof data.envelope === "object" && data.envelope !== null && "update" in data.envelope && "authorDID" in data.envelope && "signature" in data.envelope;
+}
+var WebSocketSyncProvider = class {
+  doc;
+  room;
+  url;
+  awareness;
+  ws = null;
+  reconnectDelay;
+  maxReconnectAttempts;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  destroyed = false;
+  connected = false;
+  synced = false;
+  peerId;
+  remotePeerIds = /* @__PURE__ */ new Set();
+  eventHandlers = /* @__PURE__ */ new Map();
+  options;
+  replicationPolicy;
+  constructor(doc, options) {
+    this.doc = doc;
+    this.room = options.room;
+    this.url = options.url;
+    this.options = options;
+    this.reconnectDelay = options.reconnectDelay ?? 2e3;
+    this.maxReconnectAttempts = options.maxReconnectAttempts ?? Infinity;
+    this.replicationPolicy = resolveSyncReplicationPolicy2(options.replication);
+    this.peerId = Math.random().toString(36).slice(2, 10);
+    this.awareness = new Awareness2(doc);
+    this.doc.on("update", this._onDocUpdate);
+    this.awareness.on("update", this._onAwarenessUpdate);
+    this._connect();
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  get isSynced() {
+    return this.synced;
+  }
+  /** Helper to get XML fragment length for debug logging */
+  _getFragmentLength() {
+    try {
+      const fragment = this.doc.getXmlFragment("default");
+      return fragment?.length ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  emit(event, data) {
+    this.eventHandlers.get(event)?.forEach((handler) => handler(data));
+  }
+  destroy() {
+    this.destroyed = true;
+    this.doc.off("update", this._onDocUpdate);
+    this.awareness.off("update", this._onAwarenessUpdate);
+    removeAwarenessStates2(this.awareness, [this.doc.clientID], this);
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this._send({ type: "unsubscribe", topics: [this.room] });
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+    this.emit("status", { connected: false });
+    this.eventHandlers.clear();
+  }
+  _connect() {
+    if (this.destroyed) return;
+    try {
+      this.ws = new WebSocket(this.url);
+      this.ws.onopen = () => {
+        log3(this, "WebSocket connected to", this.url);
+        this.connected = true;
+        this.reconnectAttempts = 0;
+        this.emit("status", { connected: true });
+        log3(this, "Subscribing to room:", this.room);
+        this._send({ type: "subscribe", topics: [this.room] });
+        const sv = Y3.encodeStateVector(this.doc);
+        log3(this, "Sending sync-step1, state vector size:", sv.length);
+        this._publish({
+          type: "sync-step1",
+          from: this.peerId,
+          sv: toBase642(sv)
+        });
+        const awarenessUpdate = encodeAwarenessUpdate2(this.awareness, [this.doc.clientID]);
+        log3(this, "Sending initial awareness update");
+        this._publish({
+          type: "awareness",
+          from: this.peerId,
+          update: toBase642(awarenessUpdate)
+        });
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data);
+          if (msg.type === "publish" && msg.topic === this.room) {
+            this._handleSyncMessage(msg.data);
+          } else if (msg.type === "pong") {
+          }
+        } catch {
+        }
+      };
+      this.ws.onclose = (event) => {
+        log3(this, "WebSocket closed, code:", event.code, "reason:", event.reason || "(none)");
+        this.connected = false;
+        this.synced = false;
+        this.remotePeerIds.clear();
+        this.emit("peers", { count: 0 });
+        this.emit("status", { connected: false });
+        this._scheduleReconnect();
+      };
+      this.ws.onerror = (event) => {
+        log3(this, "WebSocket error:", event);
+      };
+    } catch {
+      this._scheduleReconnect();
+    }
+  }
+  _scheduleReconnect() {
+    if (this.destroyed) return;
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) return;
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => {
+      this._connect();
+    }, this.reconnectDelay);
+  }
+  _send(msg) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+  _publish(data) {
+    this._send({
+      type: "publish",
+      topic: this.room,
+      data
+    });
+  }
+  _createOutgoingPayload(update) {
+    if (this.options.authorDID && this.options.signingKey) {
+      return {
+        envelope: serializeEnvelope2(
+          signYjsUpdate2(update, this.options.authorDID, this.options.signingKey, this.doc.clientID)
+        )
+      };
+    }
+    if (this.replicationPolicy.allowUnsignedReplication) {
+      return { update: toBase642(update) };
+    }
+    console.warn(
+      "[WebSocketSyncProvider] Signed replication is required, but no signing identity was provided."
+    );
+    return null;
+  }
+  _extractIncomingUpdate(data) {
+    if (hasEnvelope2(data)) {
+      const envelope = deserializeEnvelope2(data.envelope);
+      if (!envelope) {
+        return null;
+      }
+      const verification = verifyYjsEnvelopeV12(envelope);
+      if (!verification.valid) {
+        return null;
+      }
+      return envelope.update;
+    }
+    if (this.replicationPolicy.requireSignedReplication) {
+      return null;
+    }
+    if (typeof data.update !== "string") {
+      return null;
+    }
+    return fromBase64(data.update);
+  }
+  /** Handle incoming sync messages from other peers */
+  _handleSyncMessage(data) {
+    if (!data || data.from === this.peerId) return;
+    if (data.from && typeof data.from === "string") {
+      const hadPeer = this.remotePeerIds.has(data.from);
+      this.remotePeerIds.add(data.from);
+      if (!hadPeer) {
+        this.emit("peers", { count: this.remotePeerIds.size });
+      }
+    }
+    log3(this, "Received message type:", data.type, "from:", data.from);
+    switch (data.type) {
+      case "sync-step1": {
+        const remoteSV = fromBase64(data.sv);
+        const diff = Y3.encodeStateAsUpdate(this.doc, remoteSV);
+        log3(
+          this,
+          "Received sync-step1 from peer, their SV size:",
+          remoteSV.length,
+          "our diff size:",
+          diff.length
+        );
+        log3(this, "Sending sync-step2 to peer:", data.from, "update size:", diff.length);
+        const payload = this._createOutgoingPayload(diff);
+        if (payload) {
+          this._publish({
+            type: "sync-step2",
+            from: this.peerId,
+            to: data.from,
+            ...payload
+          });
+        }
+        if (!this.synced) {
+          const sv = Y3.encodeStateVector(this.doc);
+          log3(this, "Sending our sync-step1 in response, SV size:", sv.length);
+          this._publish({
+            type: "sync-step1",
+            from: this.peerId,
+            sv: toBase642(sv)
+          });
+        }
+        const awarenessUpdate = encodeAwarenessUpdate2(this.awareness, [this.doc.clientID]);
+        this._publish({
+          type: "awareness",
+          from: this.peerId,
+          update: toBase642(awarenessUpdate)
+        });
+        break;
+      }
+      case "sync-step2": {
+        if (data.to && data.to !== this.peerId) {
+          log3(this, "Ignoring sync-step2 addressed to different peer:", data.to);
+          return;
+        }
+        const update = this._extractIncomingUpdate(data);
+        if (!update) {
+          return;
+        }
+        log3(
+          this,
+          "Received sync-step2, applying update size:",
+          update.length,
+          "doc content before:",
+          this.doc.getMap("meta").size,
+          "keys"
+        );
+        Y3.applyUpdate(this.doc, update, this);
+        log3(
+          this,
+          "After applying update, doc content:",
+          this.doc.getMap("meta").size,
+          "keys, XML fragment length:",
+          this._getFragmentLength()
+        );
+        if (!this.synced) {
+          this.synced = true;
+          log3(this, "Sync complete! Emitting synced event");
+          this.emit("synced", { synced: true });
+        }
+        break;
+      }
+      case "sync-update": {
+        const update = this._extractIncomingUpdate(data);
+        if (!update) {
+          return;
+        }
+        log3(this, "Received sync-update, size:", update.length);
+        Y3.applyUpdate(this.doc, update, this);
+        break;
+      }
+      case "awareness": {
+        const update = fromBase64(data.update);
+        log3(this, "Received awareness update");
+        applyAwarenessUpdate2(this.awareness, update, this);
+        break;
+      }
+      case "awareness-snapshot": {
+        const users = Array.isArray(data.users) ? data.users : [];
+        this.emit("awareness-snapshot", users);
+        break;
+      }
+    }
+  }
+  /** Broadcast local doc updates to peers */
+  _onDocUpdate = (update, origin) => {
+    if (origin === this) return;
+    if (this.connected) {
+      const payload = this._createOutgoingPayload(update);
+      if (payload) {
+        this._publish({
+          type: "sync-update",
+          from: this.peerId,
+          ...payload
+        });
+      }
+    }
+  };
+  /** Broadcast local awareness changes to peers */
+  _onAwarenessUpdate = ({ added, updated, removed }, origin) => {
+    if (origin === this) return;
+    const changedClients = [...added, ...updated, ...removed];
+    if (changedClients.length === 0) return;
+    if (this.connected) {
+      const update = encodeAwarenessUpdate2(this.awareness, changedClients);
+      this._publish({
+        type: "awareness",
+        from: this.peerId,
+        update: toBase642(update)
+      });
+    }
+  };
+};
+
+// src/sync/InitialSyncManager.ts
+function createInitialSyncManager() {
+  let progress = {
+    phase: "connecting",
+    roomsTotal: 0,
+    roomsSynced: 0,
+    bytesReceived: 0
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  let syncedRoomIds = /* @__PURE__ */ new Set();
+  function notify() {
+    const snapshot = { ...progress };
+    for (const listener of listeners) {
+      listener(snapshot);
+    }
+  }
+  return {
+    onProgress(listener) {
+      listeners.add(listener);
+      listener({ ...progress });
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    handleMessage(msg) {
+      switch (msg.type) {
+        case "initial-sync":
+          progress.phase = "syncing";
+          if (msg.update) {
+            progress.bytesReceived += msg.update.byteLength;
+          }
+          if (msg.room) {
+            syncedRoomIds.add(msg.room);
+            progress.roomsSynced = syncedRoomIds.size;
+          }
+          if (msg.roomCount != null) {
+            progress.roomsTotal = msg.roomCount;
+          }
+          notify();
+          break;
+        case "node-changes":
+          if (msg.changes) {
+            progress.bytesReceived += JSON.stringify(msg.changes).length;
+          }
+          notify();
+          break;
+        case "initial-sync-complete":
+          progress.phase = "complete";
+          progress.roomsTotal = msg.roomCount ?? syncedRoomIds.size;
+          progress.roomsSynced = syncedRoomIds.size;
+          notify();
+          break;
+      }
+    },
+    getProgress() {
+      return { ...progress };
+    },
+    start() {
+      syncedRoomIds = /* @__PURE__ */ new Set();
+      progress = {
+        phase: "connecting",
+        roomsTotal: 0,
+        roomsSynced: 0,
+        bytesReceived: 0
+      };
+      notify();
+    },
+    setError(error) {
+      progress.phase = "error";
+      progress.error = error;
+      notify();
+    },
+    reset() {
+      syncedRoomIds = /* @__PURE__ */ new Set();
+      progress = {
+        phase: "connecting",
+        roomsTotal: 0,
+        roomsSynced: 0,
+        bytesReceived: 0
+      };
+      listeners.clear();
+    }
+  };
+}
+
+// src/protocol.ts
+import { CURRENT_PROTOCOL_VERSION } from "@xnetjs/sync";
+var XNET_SCHEMA_VERSION = "1.0.0";
+var XNET_SYNC_ENVELOPE_VERSION = 2;
+var XNET_AWARENESS_VERSION = 1;
+var XNET_DATA_MODEL_VERSION = 1;
+var XNET_UCAN_PROFILE = "1.0";
+var XNET_PROTOCOL_VERSION = {
+  id: "xnet/1.0",
+  dataModel: XNET_DATA_MODEL_VERSION,
+  change: CURRENT_PROTOCOL_VERSION,
+  syncEnvelope: XNET_SYNC_ENVELOPE_VERSION,
+  awareness: XNET_AWARENESS_VERSION,
+  schema: XNET_SCHEMA_VERSION,
+  cryptoLevel: 0,
+  ucan: XNET_UCAN_PROFILE
+};
+var XNET_SUPPORTED_PROTOCOL_VERSIONS = [XNET_PROTOCOL_VERSION.id];
+function negotiateProtocolVersion(ours, theirs) {
+  const offered = new Set(theirs);
+  for (const version of ours) {
+    if (offered.has(version)) {
+      return version;
+    }
+  }
+  return null;
+}
+function isProtocolCompatible(theirs) {
+  return negotiateProtocolVersion(XNET_SUPPORTED_PROTOCOL_VERSIONS, theirs) !== null;
+}
+export {
+  METABRIDGE_ORIGIN,
+  METABRIDGE_SEED_ORIGIN,
+  NodeStoreSyncProvider,
+  WebSocketSyncProvider,
+  XNET_AWARENESS_VERSION,
+  XNET_DATA_MODEL_VERSION,
+  XNET_PROTOCOL_VERSION,
+  XNET_SCHEMA_VERSION,
+  XNET_SUPPORTED_PROTOCOL_VERSIONS,
+  XNET_SYNC_ENVELOPE_VERSION,
+  XNET_UCAN_PROFILE,
+  createConnectionManager,
+  createInitialSyncManager,
+  createMetaBridge,
+  createMultiHubConnectionManager,
+  createNodePool,
+  createOfflineQueue,
+  createRegistry,
+  createSyncManager,
+  createXNetClient,
+  isProtocolCompatible,
+  liveQuery,
+  negotiateProtocolVersion
+};