@xnetjs/data-bridge 0.0.2

package/dist/index.js

@@ -0,0 +1,1246 @@
+import {
+  QueryCache
+} from "./chunk-X6F5CPJI.js";
+
+// src/main-thread-bridge.ts
+var MainThreadBridge = class {
+  store;
+  cache;
+  statusListeners = /* @__PURE__ */ new Set();
+  storeUnsubscribe = null;
+  _syncManager = null;
+  constructor(store) {
+    this.store = store;
+    this.cache = new QueryCache();
+    this.storeUnsubscribe = this.store.subscribe((event) => {
+      this.handleStoreChange(event);
+    });
+  }
+  /**
+   * Set the SyncManager for Y.Doc acquisition.
+   * This is called by XNetProvider after the SyncManager is created.
+   */
+  setSyncManager(syncManager) {
+    this._syncManager = syncManager;
+  }
+  // ─── Queries ────────────────────────────────────────────
+  query(schema, options) {
+    const schemaId = schema._schemaId;
+    const queryId = this.cache.computeQueryId(schemaId, options);
+    this.cache.initEntry(queryId, schemaId, options ?? {});
+    if (!this.cache.has(queryId) || this.cache.get(queryId) === null) {
+      this.loadQuery(queryId, schemaId, options);
+    }
+    return {
+      getSnapshot: () => this.cache.get(queryId),
+      subscribe: (callback) => this.cache.subscribe(queryId, callback)
+    };
+  }
+  /**
+   * Load query data from the store and update cache.
+   */
+  async loadQuery(queryId, schemaId, options) {
+    try {
+      let nodes;
+      if (options?.nodeId) {
+        const node = await this.store.get(options.nodeId);
+        nodes = node && node.schemaId === schemaId && !node.deleted ? [node] : [];
+      } else {
+        nodes = await this.store.list({
+          schemaId,
+          includeDeleted: options?.includeDeleted,
+          limit: options?.limit,
+          offset: options?.offset
+        });
+      }
+      nodes = this.cache.filterNodes(nodes, options);
+      nodes = this.cache.sortNodes(nodes, options);
+      this.cache.set(queryId, nodes, schemaId, options ?? {});
+    } catch (err) {
+      console.error("[MainThreadBridge] Failed to load query:", err);
+      this.cache.set(queryId, [], schemaId, options ?? {});
+    }
+  }
+  /**
+   * Handle store changes and invalidate affected caches.
+   */
+  handleStoreChange(event) {
+    const { node, change } = event;
+    const schemaId = node?.schemaId ?? change.payload.schemaId;
+    if (!schemaId) return;
+    const affectedQueries = this.cache.getQueriesForSchema(schemaId);
+    for (const queryId of affectedQueries) {
+      const options = this.cache.getOptions(queryId);
+      this.loadQuery(queryId, schemaId, options);
+    }
+  }
+  // ─── Mutations ──────────────────────────────────────────
+  async create(schema, data, id) {
+    return this.store.create({
+      id,
+      schemaId: schema._schemaId,
+      properties: data
+    });
+  }
+  async update(nodeId, changes) {
+    return this.store.update(nodeId, { properties: changes });
+  }
+  async delete(nodeId) {
+    await this.store.delete(nodeId);
+  }
+  async restore(nodeId) {
+    return this.store.restore(nodeId);
+  }
+  // ─── Documents ─────────────────────────────────────────
+  /**
+   * Acquire a Y.Doc for editing.
+   * Delegates to SyncManager if available, otherwise throws.
+   *
+   * @throws Error if SyncManager is not set
+   */
+  async acquireDoc(nodeId) {
+    if (!this._syncManager) {
+      throw new Error(
+        "MainThreadBridge.acquireDoc requires SyncManager. Call setSyncManager() first or use useNode with SyncManager context."
+      );
+    }
+    const doc = await this._syncManager.acquire(nodeId);
+    const awareness = this._syncManager.getAwareness(nodeId);
+    if (!awareness) {
+      throw new Error(`Failed to get awareness for node ${nodeId}`);
+    }
+    return { doc, awareness };
+  }
+  /**
+   * Release a Y.Doc when no longer editing.
+   */
+  releaseDoc(nodeId) {
+    if (this._syncManager) {
+      this._syncManager.release(nodeId);
+    }
+  }
+  // ─── Lifecycle ──────────────────────────────────────────
+  destroy() {
+    if (this.storeUnsubscribe) {
+      this.storeUnsubscribe();
+      this.storeUnsubscribe = null;
+    }
+    this.cache.clear();
+    this.statusListeners.clear();
+  }
+  // ─── Status ─────────────────────────────────────────────
+  get status() {
+    return "connected";
+  }
+  on(event, handler) {
+    if (event === "status") {
+      this.statusListeners.add(handler);
+      return () => {
+        this.statusListeners.delete(handler);
+      };
+    }
+    return () => {
+    };
+  }
+  // ─── Direct Store Access (Phase 0 compatibility) ────────
+  get nodeStore() {
+    return this.store;
+  }
+  subscribeToChanges(listener) {
+    return this.store.subscribe(listener);
+  }
+  async get(nodeId) {
+    return this.store.get(nodeId);
+  }
+  async list(options) {
+    return this.store.list(options);
+  }
+};
+function createMainThreadBridge(store) {
+  return new MainThreadBridge(store);
+}
+
+// src/worker-bridge.ts
+import { wrap, proxy } from "comlink";
+import { Awareness } from "y-protocols/awareness";
+import * as Y from "yjs";
+
+// src/utils/debounce.ts
+function debounce(func, options) {
+  const { wait, maxWait, leading = false } = options;
+  let timeoutId = null;
+  let maxTimeoutId = null;
+  let lastArgs = null;
+  function invokeFunc() {
+    if (lastArgs === null) return;
+    const args = lastArgs;
+    lastArgs = null;
+    func(...args);
+  }
+  function cancelTimers() {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    if (maxTimeoutId !== null) {
+      clearTimeout(maxTimeoutId);
+      maxTimeoutId = null;
+    }
+  }
+  function startTimer() {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      cancelTimers();
+      invokeFunc();
+    }, wait);
+  }
+  function startMaxTimer() {
+    if (maxWait === void 0 || maxTimeoutId !== null) return;
+    maxTimeoutId = setTimeout(() => {
+      cancelTimers();
+      invokeFunc();
+    }, maxWait);
+  }
+  function debounced(...args) {
+    const isFirstCall = timeoutId === null;
+    if (leading) {
+      if (isFirstCall) {
+        func(...args);
+        timeoutId = setTimeout(() => {
+          timeoutId = null;
+        }, wait);
+        return;
+      } else {
+        if (timeoutId !== null) {
+          clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+          timeoutId = null;
+        }, wait);
+        return;
+      }
+    }
+    lastArgs = args;
+    startTimer();
+    if (isFirstCall && maxWait !== void 0) {
+      startMaxTimer();
+    }
+  }
+  debounced.cancel = function() {
+    cancelTimers();
+    lastArgs = null;
+  };
+  debounced.flush = function() {
+    cancelTimers();
+    invokeFunc();
+  };
+  debounced.pending = function() {
+    return timeoutId !== null;
+  };
+  return debounced;
+}
+function createUpdateBatcher(options) {
+  const { wait, maxWait, onFlush } = options;
+  let pendingUpdates = [];
+  let timeoutId = null;
+  let maxTimeoutId = null;
+  let yjsModule = null;
+  let yjsLoadPromise = null;
+  function loadYjs() {
+    if (yjsModule) return Promise.resolve(yjsModule);
+    if (yjsLoadPromise) return yjsLoadPromise;
+    yjsLoadPromise = import("yjs").then((Y2) => {
+      yjsModule = Y2;
+      return Y2;
+    }).catch((err) => {
+      yjsLoadPromise = null;
+      throw err;
+    });
+    return yjsLoadPromise;
+  }
+  function flush() {
+    if (pendingUpdates.length === 0) return;
+    const updates = pendingUpdates;
+    pendingUpdates = [];
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    if (maxTimeoutId !== null) {
+      clearTimeout(maxTimeoutId);
+      maxTimeoutId = null;
+    }
+    if (updates.length === 1) {
+      onFlush(updates[0]);
+    } else if (yjsModule) {
+      const merged = yjsModule.mergeUpdates(updates);
+      onFlush(merged);
+    } else {
+      loadYjs().then((Y2) => {
+        const merged = Y2.mergeUpdates(updates);
+        onFlush(merged);
+      }).catch((err) => {
+        console.warn(
+          "[UpdateBatcher] Failed to load Yjs for merging, flushing updates individually:",
+          err
+        );
+        for (const update of updates) {
+          onFlush(update);
+        }
+      });
+    }
+  }
+  function startTimer() {
+    if (timeoutId !== null) return;
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      flush();
+    }, wait);
+  }
+  function startMaxTimer() {
+    if (maxTimeoutId !== null) return;
+    maxTimeoutId = setTimeout(() => {
+      maxTimeoutId = null;
+      flush();
+    }, maxWait);
+  }
+  return {
+    add(update) {
+      pendingUpdates.push(update);
+      if (pendingUpdates.length === 2) {
+        loadYjs().catch(() => {
+        });
+      }
+      startTimer();
+      startMaxTimer();
+    },
+    cancel() {
+      pendingUpdates = [];
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (maxTimeoutId !== null) {
+        clearTimeout(maxTimeoutId);
+        maxTimeoutId = null;
+      }
+    },
+    flush,
+    pending() {
+      return pendingUpdates.length > 0;
+    }
+  };
+}
+function createDeltaBatcher(options) {
+  const { wait, maxWait, onFlush } = options;
+  const pendingDeltas = /* @__PURE__ */ new Map();
+  let timeoutId = null;
+  let maxTimeoutId = null;
+  function flush() {
+    if (pendingDeltas.size === 0) return;
+    const deltas = [];
+    for (const delta of pendingDeltas.values()) {
+      if (delta !== null) {
+        deltas.push(delta);
+      }
+    }
+    pendingDeltas.clear();
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    if (maxTimeoutId !== null) {
+      clearTimeout(maxTimeoutId);
+      maxTimeoutId = null;
+    }
+    if (deltas.length > 0) {
+      onFlush(deltas);
+    }
+  }
+  function startTimer() {
+    if (timeoutId !== null) return;
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      flush();
+    }, wait);
+  }
+  function startMaxTimer() {
+    if (maxTimeoutId !== null) return;
+    maxTimeoutId = setTimeout(() => {
+      maxTimeoutId = null;
+      flush();
+    }, maxWait);
+  }
+  function getNodeId(delta) {
+    return delta.type === "add" ? delta.node.id : delta.nodeId;
+  }
+  return {
+    add(delta) {
+      const nodeId = getNodeId(delta);
+      const existing = pendingDeltas.get(nodeId);
+      if (existing === void 0) {
+        pendingDeltas.set(nodeId, delta);
+      } else if (existing === null) {
+        pendingDeltas.set(nodeId, delta);
+      } else {
+        const coalesced = coalesceDeltas(existing, delta);
+        pendingDeltas.set(nodeId, coalesced);
+      }
+      startTimer();
+      startMaxTimer();
+    },
+    cancel() {
+      pendingDeltas.clear();
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (maxTimeoutId !== null) {
+        clearTimeout(maxTimeoutId);
+        maxTimeoutId = null;
+      }
+    },
+    flush,
+    pending() {
+      return pendingDeltas.size > 0;
+    }
+  };
+}
+function coalesceDeltas(existing, incoming) {
+  if (existing.type === "add" && incoming.type === "remove") {
+    return null;
+  }
+  if (existing.type === "add" && incoming.type === "update") {
+    return { type: "add", node: incoming.node, index: existing.index };
+  }
+  if (existing.type === "remove" && incoming.type === "add") {
+    return { type: "update", nodeId: existing.nodeId, node: incoming.node };
+  }
+  if (existing.type === "update" && incoming.type === "update") {
+    return incoming;
+  }
+  if (existing.type === "update" && incoming.type === "remove") {
+    return incoming;
+  }
+  return incoming;
+}
+
+// src/worker-bridge.ts
+var UPDATE_BATCH_WAIT = 16;
+var UPDATE_BATCH_MAX_WAIT = 100;
+var WorkerBridge = class {
+  worker;
+  remote;
+  cache = new QueryCache();
+  subscriptions = /* @__PURE__ */ new Map();
+  queryCounter = 0;
+  statusListeners = /* @__PURE__ */ new Set();
+  _status = "connecting";
+  initialized = false;
+  // Mirror Y.Docs on the main thread (for TipTap binding)
+  mirrorDocs = /* @__PURE__ */ new Map();
+  constructor(workerUrl) {
+    this.worker = new Worker(workerUrl, { type: "module" });
+    this.remote = wrap(this.worker);
+  }
+  /**
+   * Initialize the bridge and underlying worker.
+   */
+  async initialize(config) {
+    await this.remote.initialize({
+      dbName: config.dbName ?? "xnet",
+      authorDID: config.authorDID,
+      signingKey: Array.from(config.signingKey)
+    });
+    this.remote.onStatusChange(
+      proxy((status) => {
+        this._status = status;
+        for (const handler of this.statusListeners) {
+          handler(status);
+        }
+      })
+    );
+    this.initialized = true;
+    this._status = "connected";
+  }
+  // ─── Queries ─────────────────────────────────────────────────────────────────
+  query(schema, options) {
+    const schemaId = schema._schemaId;
+    const queryId = `q${this.queryCounter++}`;
+    const serializedOptions = this.serializeOptions(options);
+    this.cache.initEntry(queryId, schemaId, serializedOptions);
+    if (this.initialized) {
+      this.startWorkerSubscription(queryId, schemaId, serializedOptions);
+    }
+    return {
+      getSnapshot: () => this.cache.get(queryId),
+      subscribe: (callback) => {
+        const subs = this.subscriptions.get(queryId) ?? /* @__PURE__ */ new Set();
+        subs.add(callback);
+        this.subscriptions.set(queryId, subs);
+        const unsubCache = this.cache.subscribe(queryId, callback);
+        return () => {
+          subs.delete(callback);
+          unsubCache();
+          if (subs.size === 0) {
+            this.subscriptions.delete(queryId);
+            this.remote.unsubscribe(queryId).catch(console.error);
+          }
+        };
+      }
+    };
+  }
+  async startWorkerSubscription(queryId, schemaId, options) {
+    try {
+      const initial = await this.remote.subscribe(
+        queryId,
+        schemaId,
+        options,
+        proxy((delta) => {
+          this.applyDelta(queryId, delta);
+        })
+      );
+      this.cache.set(queryId, initial, schemaId, options);
+    } catch (err) {
+      console.error("[WorkerBridge] Failed to subscribe:", err);
+      this.cache.set(queryId, [], schemaId, options);
+    }
+  }
+  applyDelta(queryId, delta) {
+    const current = this.cache.get(queryId) ?? [];
+    let updated;
+    switch (delta.type) {
+      case "add":
+        updated = [...current, delta.node];
+        break;
+      case "remove":
+        updated = current.filter((n) => n.id !== delta.nodeId);
+        break;
+      case "update":
+        updated = current.map((n) => n.id === delta.nodeId ? delta.node : n);
+        break;
+    }
+    const schemaId = this.cache.getSchemaId(queryId);
+    const options = this.cache.getOptions(queryId);
+    if (schemaId && options) {
+      updated = this.cache.sortNodes(updated, options);
+      this.cache.set(queryId, updated, schemaId, options);
+    }
+  }
+  serializeOptions(options) {
+    if (!options) return {};
+    return {
+      nodeId: options.nodeId,
+      where: options.where,
+      includeDeleted: options.includeDeleted,
+      orderBy: options.orderBy,
+      limit: options.limit,
+      offset: options.offset
+    };
+  }
+  // ─── Mutations ───────────────────────────────────────────────────────────────
+  async create(schema, data, id) {
+    if (!this.initialized) {
+      throw new Error("WorkerBridge not initialized");
+    }
+    return this.remote.create(schema._schemaId, data, id);
+  }
+  async update(nodeId, changes) {
+    if (!this.initialized) {
+      throw new Error("WorkerBridge not initialized");
+    }
+    return this.remote.update(nodeId, changes);
+  }
+  async delete(nodeId) {
+    if (!this.initialized) {
+      throw new Error("WorkerBridge not initialized");
+    }
+    await this.remote.delete(nodeId);
+  }
+  async restore(nodeId) {
+    if (!this.initialized) {
+      throw new Error("WorkerBridge not initialized");
+    }
+    return this.remote.restore(nodeId);
+  }
+  // ─── Documents ────────────────────────────────────────────────────────────────
+  /**
+   * Acquire a Y.Doc for editing.
+   *
+   * Implements the split Y.Doc pattern:
+   * 1. Worker maintains "source of truth" Y.Doc (handles persistence & network sync)
+   * 2. Main thread gets a mirror Y.Doc for TipTap binding
+   * 3. Updates flow bidirectionally:
+   *    - Local edits → worker (for persistence & broadcast)
+   *    - Remote edits → main thread (for rendering)
+   */
+  async acquireDoc(nodeId) {
+    if (!this.initialized) {
+      throw new Error("WorkerBridge not initialized");
+    }
+    const existing = this.mirrorDocs.get(nodeId);
+    if (existing) {
+      return {
+        doc: existing.doc,
+        awareness: existing.awareness
+      };
+    }
+    const mirrorDoc = new Y.Doc({ guid: nodeId, gc: false });
+    const awareness = new Awareness(mirrorDoc);
+    let applyingRemote = false;
+    const acquired = await this.remote.acquireDoc(
+      nodeId,
+      proxy((update, _origin) => {
+        applyingRemote = true;
+        try {
+          Y.applyUpdate(mirrorDoc, update, "remote");
+        } finally {
+          applyingRemote = false;
+        }
+      })
+    );
+    if (acquired.state.length > 0) {
+      Y.applyUpdate(mirrorDoc, acquired.state, "initial");
+    }
+    const updateBatcher = createUpdateBatcher({
+      wait: UPDATE_BATCH_WAIT,
+      maxWait: UPDATE_BATCH_MAX_WAIT,
+      onFlush: (mergedUpdate) => {
+        this.remote.applyLocalUpdate(nodeId, mergedUpdate);
+      }
+    });
+    const updateHandler = (update, origin) => {
+      if (applyingRemote || origin === "remote" || origin === "initial") {
+        return;
+      }
+      updateBatcher.add(update);
+    };
+    mirrorDoc.on("update", updateHandler);
+    const entry = {
+      doc: mirrorDoc,
+      awareness,
+      applyingRemote: false,
+      updateBatcher,
+      cleanup: () => {
+        updateBatcher.flush();
+        updateBatcher.cancel();
+        mirrorDoc.off("update", updateHandler);
+        awareness.destroy();
+      }
+    };
+    this.mirrorDocs.set(nodeId, entry);
+    return {
+      doc: mirrorDoc,
+      awareness
+    };
+  }
+  /**
+   * Release a Y.Doc when no longer editing.
+   * The worker continues syncing in the background.
+   */
+  releaseDoc(nodeId) {
+    const entry = this.mirrorDocs.get(nodeId);
+    if (!entry) return;
+    entry.cleanup();
+    entry.doc.destroy();
+    this.mirrorDocs.delete(nodeId);
+    this.remote.releaseDoc(nodeId);
+  }
+  // ─── Lifecycle ───────────────────────────────────────────────────────────────
+  destroy() {
+    for (const entry of this.mirrorDocs.values()) {
+      entry.cleanup();
+      entry.doc.destroy();
+    }
+    this.mirrorDocs.clear();
+    this.remote.destroy().catch(console.error);
+    this.worker.terminate();
+    this.cache.clear();
+    this.subscriptions.clear();
+    this.statusListeners.clear();
+    this.initialized = false;
+    this._status = "disconnected";
+  }
+  // ─── Status ──────────────────────────────────────────────────────────────────
+  get status() {
+    return this._status;
+  }
+  on(event, handler) {
+    if (event === "status") {
+      this.statusListeners.add(handler);
+      return () => {
+        this.statusListeners.delete(handler);
+      };
+    }
+    return () => {
+    };
+  }
+};
+function createWorkerBridge(workerUrl) {
+  return new WorkerBridge(workerUrl);
+}
+
+// src/native-bridge.ts
+var NativeBridge = class {
+  store;
+  cache;
+  statusListeners = /* @__PURE__ */ new Set();
+  storeUnsubscribe = null;
+  storageAdapter;
+  _status = "disconnected";
+  destroyed = false;
+  constructor(config) {
+    this.store = config.store;
+    this.storageAdapter = config.storageAdapter;
+    this.cache = new QueryCache();
+    this.storeUnsubscribe = this.store.subscribe((event) => {
+      this.handleStoreChange(event);
+    });
+    this._status = "connected";
+  }
+  // ─── Queries ────────────────────────────────────────────
+  query(schema, options) {
+    const schemaId = schema._schemaId;
+    const queryId = this.cache.computeQueryId(schemaId, options);
+    this.cache.initEntry(queryId, schemaId, options ?? {});
+    if (!this.cache.has(queryId) || this.cache.get(queryId) === null) {
+      this.loadQuery(queryId, schemaId, options);
+    }
+    return {
+      getSnapshot: () => this.cache.get(queryId),
+      subscribe: (callback) => this.cache.subscribe(queryId, callback)
+    };
+  }
+  /**
+   * Load query data from the store and update cache.
+   */
+  async loadQuery(queryId, schemaId, options) {
+    if (this.destroyed) return;
+    try {
+      let nodes;
+      if (options?.nodeId) {
+        const node = await this.store.get(options.nodeId);
+        nodes = node && node.schemaId === schemaId && !node.deleted ? [node] : [];
+      } else {
+        nodes = await this.store.list({
+          schemaId,
+          includeDeleted: options?.includeDeleted,
+          limit: options?.limit,
+          offset: options?.offset
+        });
+      }
+      nodes = this.cache.filterNodes(nodes, options);
+      nodes = this.cache.sortNodes(nodes, options);
+      if (!this.destroyed) {
+        this.cache.set(queryId, nodes, schemaId, options ?? {});
+      }
+    } catch (err) {
+      console.error("[NativeBridge] Failed to load query:", err);
+      if (!this.destroyed) {
+        this.cache.set(queryId, [], schemaId, options ?? {});
+      }
+    }
+  }
+  /**
+   * Handle store changes and invalidate affected caches.
+   */
+  handleStoreChange(event) {
+    if (this.destroyed) return;
+    const { node, change } = event;
+    const schemaId = node?.schemaId ?? change.payload.schemaId;
+    if (!schemaId) return;
+    const affectedQueries = this.cache.getQueriesForSchema(schemaId);
+    for (const queryId of affectedQueries) {
+      const options = this.cache.getOptions(queryId);
+      this.loadQuery(queryId, schemaId, options);
+    }
+  }
+  // ─── Mutations ──────────────────────────────────────────
+  async create(schema, data, id) {
+    if (this.destroyed) {
+      throw new Error("NativeBridge has been destroyed");
+    }
+    return this.store.create({
+      id,
+      schemaId: schema._schemaId,
+      properties: data
+    });
+  }
+  async update(nodeId, changes) {
+    if (this.destroyed) {
+      throw new Error("NativeBridge has been destroyed");
+    }
+    return this.store.update(nodeId, { properties: changes });
+  }
+  async delete(nodeId) {
+    if (this.destroyed) {
+      throw new Error("NativeBridge has been destroyed");
+    }
+    await this.store.delete(nodeId);
+  }
+  async restore(nodeId) {
+    if (this.destroyed) {
+      throw new Error("NativeBridge has been destroyed");
+    }
+    return this.store.restore(nodeId);
+  }
+  // ─── Documents ─────────────────────────────────────────
+  /**
+   * Acquire a Y.Doc for editing.
+   *
+   * Note: Y.Doc management in React Native is limited compared to web.
+   * For now, this throws an error. Future versions will support Y.Doc
+   * via native WebSocket sync or JSI bindings.
+   */
+  async acquireDoc(_nodeId) {
+    throw new Error(
+      "Y.Doc editing is not yet supported in NativeBridge. Use a WebView-based editor or wait for Turbo Module support."
+    );
+  }
+  /**
+   * Release a Y.Doc when no longer editing.
+   */
+  releaseDoc(_nodeId) {
+  }
+  // ─── Lifecycle ──────────────────────────────────────────
+  /**
+   * Initialize the bridge.
+   * Opens storage adapter if provided.
+   */
+  async initialize(_config) {
+    if (this.storageAdapter) {
+      await this.storageAdapter.open();
+    }
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.storeUnsubscribe) {
+      this.storeUnsubscribe();
+      this.storeUnsubscribe = null;
+    }
+    if (this.storageAdapter) {
+      this.storageAdapter.close().catch((err) => {
+        console.error("[NativeBridge] Failed to close storage:", err);
+      });
+    }
+    this.cache.clear();
+    this.statusListeners.clear();
+    this._status = "disconnected";
+  }
+  // ─── Status ─────────────────────────────────────────────
+  get status() {
+    return this._status;
+  }
+  on(event, handler) {
+    if (event === "status") {
+      this.statusListeners.add(handler);
+      return () => {
+        this.statusListeners.delete(handler);
+      };
+    }
+    return () => {
+    };
+  }
+  setStatus(status) {
+    if (this._status !== status) {
+      this._status = status;
+      for (const listener of this.statusListeners) {
+        listener(status);
+      }
+    }
+  }
+  // ─── Direct Store Access (compatibility) ────────────────
+  get nodeStore() {
+    return this.store;
+  }
+  subscribeToChanges(listener) {
+    return this.store.subscribe(listener);
+  }
+  async get(nodeId) {
+    return this.store.get(nodeId);
+  }
+  async list(options) {
+    return this.store.list(options);
+  }
+};
+function createNativeBridge(config) {
+  return new NativeBridge(config);
+}
+function isReactNative() {
+  return typeof navigator !== "undefined" && navigator.product === "ReactNative";
+}
+function isExpo() {
+  return typeof global !== "undefined" && global.expo !== void 0;
+}
+
+// src/create-bridge.ts
+function isWorkerSupported() {
+  return typeof Worker !== "undefined";
+}
+function isNodeEnvironment() {
+  return typeof process !== "undefined" && process.versions?.node !== void 0;
+}
+async function createDataBridge(options) {
+  const { nodeStore, config, workerUrl, mode = "auto" } = options;
+  const useWorker = mode === "worker" || mode === "auto" && workerUrl && isWorkerSupported() && !isNodeEnvironment();
+  if (useWorker) {
+    if (!workerUrl) {
+      throw new Error('workerUrl is required when mode is "worker"');
+    }
+    if (!isWorkerSupported()) {
+      throw new Error("Web Workers are not supported in this environment");
+    }
+    const bridge = new WorkerBridge(workerUrl);
+    await bridge.initialize(config);
+    return bridge;
+  }
+  return new MainThreadBridge(nodeStore);
+}
+function createMainThreadBridgeSync(nodeStore) {
+  return new MainThreadBridge(nodeStore);
+}
+function createWorkerBridgeSync(workerUrl) {
+  return new WorkerBridge(workerUrl);
+}
+
+// src/utils/binary-state.ts
+var TAG_NULL = 0;
+var TAG_UNDEFINED = 1;
+var TAG_BOOLEAN_FALSE = 2;
+var TAG_BOOLEAN_TRUE = 3;
+var TAG_NUMBER = 4;
+var TAG_STRING = 5;
+var TAG_UINT8ARRAY = 6;
+var TAG_ARRAY = 7;
+var TAG_OBJECT = 8;
+var TAG_BIGINT = 9;
+var NodeStateEncoder = class {
+  chunks = [];
+  textEncoder = new TextEncoder();
+  /**
+   * Encode an array of NodeState objects.
+   */
+  encode(states) {
+    this.chunks = [];
+    this.writeUint32(states.length);
+    for (const state of states) {
+      this.writeNodeState(state);
+    }
+    return this.finish();
+  }
+  writeNodeState(state) {
+    this.writeString(state.id);
+    this.writeString(state.schemaId);
+    this.writeProperties(state.properties);
+    this.writeTimestamps(state.timestamps);
+    this.writeByte(state.deleted ? 1 : 0);
+    if (state.deletedAt) {
+      this.writeByte(1);
+      this.writeTimestamp(state.deletedAt);
+    } else {
+      this.writeByte(0);
+    }
+    this.writeFloat64(state.createdAt);
+    this.writeString(state.createdBy);
+    this.writeFloat64(state.updatedAt);
+    this.writeString(state.updatedBy);
+    if (state.documentContent) {
+      this.writeByte(1);
+      this.writeUint8Array(state.documentContent);
+    } else {
+      this.writeByte(0);
+    }
+    if (state._unknown && Object.keys(state._unknown).length > 0) {
+      this.writeByte(1);
+      this.writeProperties(state._unknown);
+    } else {
+      this.writeByte(0);
+    }
+    if (state._schemaVersion) {
+      this.writeByte(1);
+      this.writeString(state._schemaVersion);
+    } else {
+      this.writeByte(0);
+    }
+  }
+  writeProperties(props) {
+    const keys = Object.keys(props);
+    this.writeUint32(keys.length);
+    for (const key of keys) {
+      this.writeString(key);
+      this.writeValue(props[key]);
+    }
+  }
+  writeTimestamps(timestamps) {
+    const keys = Object.keys(timestamps);
+    this.writeUint32(keys.length);
+    for (const key of keys) {
+      this.writeString(key);
+      this.writeTimestamp(timestamps[key]);
+    }
+  }
+  writeTimestamp(ts) {
+    this.writeUint32(ts.lamport.time);
+    this.writeString(ts.lamport.author);
+    this.writeFloat64(ts.wallTime);
+  }
+  writeValue(value) {
+    if (value === null) {
+      this.writeByte(TAG_NULL);
+    } else if (value === void 0) {
+      this.writeByte(TAG_UNDEFINED);
+    } else if (typeof value === "boolean") {
+      this.writeByte(value ? TAG_BOOLEAN_TRUE : TAG_BOOLEAN_FALSE);
+    } else if (typeof value === "number") {
+      this.writeByte(TAG_NUMBER);
+      this.writeFloat64(value);
+    } else if (typeof value === "string") {
+      this.writeByte(TAG_STRING);
+      this.writeString(value);
+    } else if (value instanceof Uint8Array) {
+      this.writeByte(TAG_UINT8ARRAY);
+      this.writeUint8Array(value);
+    } else if (Array.isArray(value)) {
+      this.writeByte(TAG_ARRAY);
+      this.writeUint32(value.length);
+      for (const item of value) {
+        this.writeValue(item);
+      }
+    } else if (typeof value === "bigint") {
+      this.writeByte(TAG_BIGINT);
+      this.writeString(value.toString());
+    } else if (typeof value === "object") {
+      this.writeByte(TAG_OBJECT);
+      const obj = value;
+      const keys = Object.keys(obj);
+      this.writeUint32(keys.length);
+      for (const key of keys) {
+        this.writeString(key);
+        this.writeValue(obj[key]);
+      }
+    } else {
+      this.writeByte(TAG_STRING);
+      this.writeString(JSON.stringify(value));
+    }
+  }
+  writeByte(value) {
+    this.chunks.push(new Uint8Array([value]));
+  }
+  writeUint32(value) {
+    const buf = new ArrayBuffer(4);
+    new DataView(buf).setUint32(0, value, true);
+    this.chunks.push(new Uint8Array(buf));
+  }
+  writeFloat64(value) {
+    const buf = new ArrayBuffer(8);
+    new DataView(buf).setFloat64(0, value, true);
+    this.chunks.push(new Uint8Array(buf));
+  }
+  writeString(value) {
+    const bytes = this.textEncoder.encode(value);
+    this.writeUint32(bytes.length);
+    this.chunks.push(bytes);
+  }
+  writeUint8Array(value) {
+    this.writeUint32(value.length);
+    this.chunks.push(value);
+  }
+  finish() {
+    let totalSize = 0;
+    for (const chunk of this.chunks) {
+      totalSize += chunk.length;
+    }
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const chunk of this.chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+};
+var NodeStateDecoder = class {
+  data;
+  view;
+  offset = 0;
+  textDecoder = new TextDecoder();
+  constructor(data) {
+    this.data = data;
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  /**
+   * Decode a Uint8Array back to an array of NodeState objects.
+   */
+  decode() {
+    const count = this.readUint32();
+    const states = [];
+    for (let i = 0; i < count; i++) {
+      states.push(this.readNodeState());
+    }
+    return states;
+  }
+  readNodeState() {
+    const id = this.readString();
+    const schemaId = this.readString();
+    const properties = this.readProperties();
+    const timestamps = this.readTimestamps();
+    const deleted = this.readByte() === 1;
+    const hasDeletedAt = this.readByte() === 1;
+    const deletedAt = hasDeletedAt ? this.readTimestamp() : void 0;
+    const createdAt = this.readFloat64();
+    const createdBy = this.readString();
+    const updatedAt = this.readFloat64();
+    const updatedBy = this.readString();
+    const hasDocumentContent = this.readByte() === 1;
+    const documentContent = hasDocumentContent ? this.readUint8Array() : void 0;
+    const hasUnknown = this.readByte() === 1;
+    const _unknown = hasUnknown ? this.readProperties() : void 0;
+    const hasSchemaVersion = this.readByte() === 1;
+    const _schemaVersion = hasSchemaVersion ? this.readString() : void 0;
+    const state = {
+      id,
+      schemaId,
+      properties,
+      timestamps,
+      deleted,
+      createdAt,
+      createdBy,
+      updatedAt,
+      updatedBy
+    };
+    if (deletedAt) state.deletedAt = deletedAt;
+    if (documentContent) state.documentContent = documentContent;
+    if (_unknown) state._unknown = _unknown;
+    if (_schemaVersion) state._schemaVersion = _schemaVersion;
+    return state;
+  }
+  readProperties() {
+    const count = this.readUint32();
+    const props = {};
+    for (let i = 0; i < count; i++) {
+      const key = this.readString();
+      const value = this.readValue();
+      props[key] = value;
+    }
+    return props;
+  }
+  readTimestamps() {
+    const count = this.readUint32();
+    const timestamps = {};
+    for (let i = 0; i < count; i++) {
+      const key = this.readString();
+      timestamps[key] = this.readTimestamp();
+    }
+    return timestamps;
+  }
+  readTimestamp() {
+    const time = this.readUint32();
+    const author = this.readString();
+    const wallTime = this.readFloat64();
+    return {
+      lamport: { time, author },
+      wallTime
+    };
+  }
+  readValue() {
+    const tag = this.readByte();
+    switch (tag) {
+      case TAG_NULL:
+        return null;
+      case TAG_UNDEFINED:
+        return void 0;
+      case TAG_BOOLEAN_FALSE:
+        return false;
+      case TAG_BOOLEAN_TRUE:
+        return true;
+      case TAG_NUMBER:
+        return this.readFloat64();
+      case TAG_STRING:
+        return this.readString();
+      case TAG_UINT8ARRAY:
+        return this.readUint8Array();
+      case TAG_ARRAY: {
+        const length = this.readUint32();
+        const arr = [];
+        for (let i = 0; i < length; i++) {
+          arr.push(this.readValue());
+        }
+        return arr;
+      }
+      case TAG_BIGINT:
+        return BigInt(this.readString());
+      case TAG_OBJECT: {
+        const length = this.readUint32();
+        const obj = {};
+        for (let i = 0; i < length; i++) {
+          const key = this.readString();
+          obj[key] = this.readValue();
+        }
+        return obj;
+      }
+      default:
+        throw new Error(`Unknown tag: ${tag}`);
+    }
+  }
+  readByte() {
+    return this.data[this.offset++];
+  }
+  readUint32() {
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  readFloat64() {
+    const value = this.view.getFloat64(this.offset, true);
+    this.offset += 8;
+    return value;
+  }
+  readString() {
+    const length = this.readUint32();
+    const bytes = this.data.subarray(this.offset, this.offset + length);
+    this.offset += length;
+    return this.textDecoder.decode(bytes);
+  }
+  readUint8Array() {
+    const length = this.readUint32();
+    const bytes = this.data.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return bytes;
+  }
+};
+function encodeNodeStates(states) {
+  return new NodeStateEncoder().encode(states);
+}
+function decodeNodeStates(data) {
+  return new NodeStateDecoder(data).decode();
+}
+function shouldUseBinaryEncoding(states) {
+  if (states.length > 100) return true;
+  return states.some((s) => s.documentContent && s.documentContent.length > 1e3);
+}
+export {
+  MainThreadBridge,
+  NativeBridge,
+  NodeStateDecoder,
+  NodeStateEncoder,
+  QueryCache,
+  WorkerBridge,
+  createDataBridge,
+  createDeltaBatcher,
+  createMainThreadBridge,
+  createMainThreadBridgeSync,
+  createNativeBridge,
+  createUpdateBatcher,
+  createWorkerBridge,
+  createWorkerBridgeSync,
+  debounce,
+  decodeNodeStates,
+  encodeNodeStates,
+  isExpo,
+  isNodeEnvironment,
+  isReactNative,
+  isWorkerSupported,
+  shouldUseBinaryEncoding
+};