@xnetjs/data-bridge 0.0.2 → 0.0.3

package/dist/chunk-25WNZV7W.js

@@ -0,0 +1,831 @@
+import {
+  applyNodeChangeToQueryResult,
+  createQueryDescriptor,
+  queryDescriptorToOptions,
+  serializeQueryDescriptor
+} from "./chunk-5GTIP33X.js";
+
+// src/query-cache.ts
+var DEFAULT_MAX_SIZE = 100;
+var MIN_AGE_FOR_EVICTION = 3e4;
+var WEAK_REF_CLEANUP_INTERVAL = 6e4;
+function isSameNodeData(previous, next) {
+  if (previous === next) return true;
+  if (!previous || !next) return false;
+  if (previous.length !== next.length) return false;
+  return next.every((node, index) => node === previous[index]);
+}
+var REMOTE_METADATA_SURFACES = [
+  "stream",
+  "completeness",
+  "staleness",
+  "verification",
+  "materialized"
+];
+function hasEquivalentRemoteSurfaces(previous, next) {
+  return REMOTE_METADATA_SURFACES.every((surface) => {
+    if (previous[surface] === next[surface]) return true;
+    return !previous[surface] && !next[surface];
+  });
+}
+var COMPARED_PAGE_INFO_FIELDS = [
+  "totalCount",
+  "countMode",
+  "hasMore",
+  "hasNextPage",
+  "hasPreviousPage",
+  "loadedCount",
+  "startCursor",
+  "endCursor"
+];
+function isSamePageInfo(previous, next) {
+  if (previous === next) return true;
+  if (!previous || !next) return false;
+  return COMPARED_PAGE_INFO_FIELDS.every((field) => previous[field] === next[field]);
+}
+function isQueryMetadataEquivalent(previous, next) {
+  if (previous === next) return true;
+  if (!previous || !next) return false;
+  return previous.source === next.source && previous.error === next.error && hasEquivalentRemoteSurfaces(previous, next) && isSamePageInfo(previous.pageInfo, next.pageInfo);
+}
+var QueryCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  cleanupInterval = null;
+  constructor(options) {
+    this.maxSize = options?.maxSize ?? DEFAULT_MAX_SIZE;
+    const enableCleanup = options?.enableWeakRefCleanup ?? typeof window !== "undefined";
+    if (enableCleanup) {
+      this.startWeakRefCleanup();
+    }
+  }
+  /**
+   * Start the interval that cleans up dead weak references.
+   */
+  startWeakRefCleanup() {
+    if (this.cleanupInterval) return;
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupDeadWeakRefs();
+    }, WEAK_REF_CLEANUP_INTERVAL);
+    if (typeof this.cleanupInterval === "object" && "unref" in this.cleanupInterval) {
+      this.cleanupInterval.unref();
+    }
+  }
+  /**
+   * Stop the weak reference cleanup interval.
+   */
+  stopCleanup() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  /**
+   * Clean up dead weak references from all cache entries.
+   * Returns the number of dead references removed.
+   */
+  cleanupDeadWeakRefs() {
+    let removed = 0;
+    for (const entry of this.cache.values()) {
+      for (const [identity, ref] of entry.weakSubscribers) {
+        if (ref.deref() === void 0) {
+          entry.weakSubscribers.delete(identity);
+          removed++;
+        }
+      }
+    }
+    return removed;
+  }
+  /**
+   * Compute a stable query ID from schema and options.
+   * Same query params should produce the same ID for deduplication.
+   */
+  computeQueryId(schemaId, options) {
+    const descriptor = typeof schemaId === "string" ? createQueryDescriptor(schemaId, options) : schemaId;
+    return serializeQueryDescriptor(descriptor);
+  }
+  /**
+   * Get cached data for a query (synchronous for useSyncExternalStore).
+   * Updates lastAccessed for LRU tracking.
+   */
+  get(queryId) {
+    const entry = this.cache.get(queryId);
+    if (entry) {
+      entry.lastAccessed = Date.now();
+    }
+    return entry?.data ?? null;
+  }
+  /**
+   * Check if a query is in the cache.
+   */
+  has(queryId) {
+    return this.cache.has(queryId);
+  }
+  /**
+   * Set cached data for a query and notify subscribers.
+   * Triggers LRU eviction if cache exceeds maxSize.
+   */
+  set(queryId, data, schemaIdOrDescriptor, options, metadata, workingSet) {
+    const entry = this.cache.get(queryId);
+    const now = Date.now();
+    const descriptor = typeof schemaIdOrDescriptor === "string" ? createQueryDescriptor(schemaIdOrDescriptor, options) : schemaIdOrDescriptor;
+    if (entry) {
+      const dataUnchanged = isSameNodeData(entry.data, data);
+      const metadataUnchanged = metadata === void 0 || isQueryMetadataEquivalent(entry.metadata, metadata);
+      entry.data = dataUnchanged ? entry.data : data;
+      entry.workingSet = workingSet ?? null;
+      if (descriptor) {
+        entry.schemaId = descriptor.schemaId;
+        entry.descriptor = descriptor;
+        entry.options = queryDescriptorToOptions(descriptor);
+      }
+      if (metadata !== void 0) {
+        entry.metadata = metadataUnchanged && entry.metadata ? entry.metadata : metadata;
+      }
+      entry.lastUpdated = now;
+      entry.lastAccessed = now;
+      if (dataUnchanged && metadataUnchanged) {
+        return;
+      }
+      this.notifySubscribers(queryId);
+    } else {
+      if (!descriptor) {
+        throw new Error(`QueryCache.set requires a descriptor when creating "${queryId}"`);
+      }
+      this.evictIfNeeded();
+      this.cache.set(queryId, {
+        data,
+        workingSet: workingSet ?? null,
+        subscribers: /* @__PURE__ */ new Set(),
+        weakSubscribers: /* @__PURE__ */ new Map(),
+        schemaId: descriptor.schemaId,
+        descriptor,
+        options: queryDescriptorToOptions(descriptor),
+        metadata: metadata ?? null,
+        lastUpdated: now,
+        lastAccessed: now
+      });
+    }
+  }
+  /**
+   * Initialize a cache entry (called when starting a subscription).
+   */
+  initEntry(queryId, schemaIdOrDescriptor, options) {
+    if (!this.cache.has(queryId)) {
+      const now = Date.now();
+      const descriptor = typeof schemaIdOrDescriptor === "string" ? createQueryDescriptor(schemaIdOrDescriptor, options) : schemaIdOrDescriptor;
+      this.cache.set(queryId, {
+        data: null,
+        workingSet: null,
+        subscribers: /* @__PURE__ */ new Set(),
+        weakSubscribers: /* @__PURE__ */ new Map(),
+        schemaId: descriptor.schemaId,
+        descriptor,
+        options: queryDescriptorToOptions(descriptor),
+        metadata: null,
+        lastUpdated: 0,
+        lastAccessed: now
+      });
+    }
+  }
+  /**
+   * Subscribe to cache updates for a query.
+   * Uses strong references - callback will not be garbage collected until unsubscribed.
+   */
+  subscribe(queryId, callback) {
+    const entry = this.cache.get(queryId);
+    if (entry) {
+      entry.subscribers.add(callback);
+    }
+    return () => {
+      const e = this.cache.get(queryId);
+      if (e) {
+        e.subscribers.delete(callback);
+      }
+    };
+  }
+  /**
+   * Subscribe with a weak reference.
+   * The callback can be garbage collected if the owning component is unmounted
+   * and no other references to the callback exist.
+   *
+   * This is useful for long-lived subscriptions where you want automatic cleanup
+   * without explicit unsubscribe calls. However, for React components, prefer
+   * the regular subscribe() with proper cleanup in useEffect.
+   *
+   * @param queryId - The query to subscribe to
+   * @param callback - The callback to invoke on updates
+   * @returns Unsubscribe function
+   */
+  subscribeWeak(queryId, callback) {
+    const entry = this.cache.get(queryId);
+    if (entry) {
+      entry.weakSubscribers.set(callback, new WeakRef(callback));
+    }
+    return () => {
+      const e = this.cache.get(queryId);
+      if (e) {
+        e.weakSubscribers.delete(callback);
+      }
+    };
+  }
+  /**
+   * Notify all subscribers of a query that data has changed.
+   * Handles both strong and weak subscribers, cleaning up dead weak refs.
+   */
+  notifySubscribers(queryId) {
+    const entry = this.cache.get(queryId);
+    if (!entry) return;
+    for (const callback of entry.subscribers) {
+      callback();
+    }
+    for (const [identity, ref] of entry.weakSubscribers) {
+      const callback = ref.deref();
+      if (callback) {
+        callback();
+      } else {
+        entry.weakSubscribers.delete(identity);
+      }
+    }
+  }
+  /**
+   * Get the number of active subscribers for a query.
+   * Includes both strong and live weak subscribers.
+   */
+  getSubscriberCount(queryId) {
+    const entry = this.cache.get(queryId);
+    if (!entry) return 0;
+    let count = entry.subscribers.size;
+    for (const ref of entry.weakSubscribers.values()) {
+      if (ref.deref() !== void 0) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Get the number of weak subscribers (including potentially dead ones).
+   * Useful for debugging.
+   */
+  getWeakSubscriberCount(queryId) {
+    return this.cache.get(queryId)?.weakSubscribers.size ?? 0;
+  }
+  /**
+   * Remove a query from the cache.
+   */
+  delete(queryId) {
+    this.cache.delete(queryId);
+  }
+  /**
+   * Get all query IDs that match a schema.
+   */
+  getQueriesForSchema(schemaId) {
+    const matches = [];
+    for (const [queryId, entry] of this.cache) {
+      if (entry.descriptor.schemaId === schemaId) {
+        matches.push(queryId);
+      }
+    }
+    return matches;
+  }
+  /**
+   * Get all cached entries for a schema.
+   */
+  getEntriesForSchema(schemaId) {
+    const matches = [];
+    for (const [queryId, entry] of this.cache) {
+      if (entry.descriptor.schemaId === schemaId) {
+        matches.push({
+          queryId,
+          descriptor: entry.descriptor,
+          data: entry.data,
+          workingSet: entry.workingSet
+        });
+      }
+    }
+    return matches;
+  }
+  /**
+   * Get all cached entries.
+   */
+  getEntries() {
+    return Array.from(this.cache.entries()).map(([queryId, entry]) => ({
+      queryId,
+      descriptor: entry.descriptor,
+      data: entry.data,
+      workingSet: entry.workingSet
+    }));
+  }
+  /**
+   * Get the bounded-query working set for a cached query, if any.
+   */
+  getWorkingSet(queryId) {
+    return this.cache.get(queryId)?.workingSet ?? null;
+  }
+  /**
+   * Get the schema IRI for a cached query.
+   */
+  getSchemaId(queryId) {
+    return this.cache.get(queryId)?.descriptor.schemaId;
+  }
+  /**
+   * Get the descriptor for a cached query.
+   */
+  getDescriptor(queryId) {
+    return this.cache.get(queryId)?.descriptor;
+  }
+  /**
+   * Get the options for a cached query.
+   */
+  getOptions(queryId) {
+    return this.cache.get(queryId)?.options;
+  }
+  /**
+   * Get the latest metadata for a cached query.
+   */
+  getMetadata(queryId) {
+    return this.cache.get(queryId)?.metadata ?? null;
+  }
+  /**
+   * Set metadata without replacing query data.
+   */
+  setMetadata(queryId, metadata) {
+    const entry = this.cache.get(queryId);
+    if (!entry) return;
+    entry.metadata = metadata;
+    entry.lastUpdated = Date.now();
+    this.notifySubscribers(queryId);
+  }
+  /**
+   * Clear the entire cache and stop cleanup interval.
+   */
+  clear() {
+    this.stopCleanup();
+    this.cache.clear();
+  }
+  /**
+   * Destroy the cache, stopping all cleanup intervals.
+   */
+  destroy() {
+    this.stopCleanup();
+    this.cache.clear();
+  }
+  /**
+   * Get the number of cached queries.
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Get the maximum cache size.
+   */
+  get maxCacheSize() {
+    return this.maxSize;
+  }
+  // ─── LRU Eviction ──────────────────────────────────────────────────────────
+  /**
+   * Check if an entry has any active subscribers (strong or live weak).
+   */
+  hasActiveSubscribers(entry) {
+    if (entry.subscribers.size > 0) return true;
+    for (const ref of entry.weakSubscribers.values()) {
+      if (ref.deref() !== void 0) return true;
+    }
+    return false;
+  }
+  /**
+   * Evict least-recently-used entries if cache exceeds maxSize.
+   * Only evicts entries with no active subscribers and older than MIN_AGE_FOR_EVICTION.
+   */
+  evictIfNeeded() {
+    if (this.cache.size < this.maxSize) return;
+    const now = Date.now();
+    const candidates = [];
+    for (const [queryId, entry] of this.cache) {
+      if (!this.hasActiveSubscribers(entry) && now - entry.lastAccessed > MIN_AGE_FOR_EVICTION) {
+        candidates.push({ queryId, lastAccessed: entry.lastAccessed });
+      }
+    }
+    if (candidates.length === 0) return;
+    candidates.sort((a, b) => a.lastAccessed - b.lastAccessed);
+    const targetSize = Math.floor(this.maxSize * 0.8);
+    const toEvict = this.cache.size - targetSize;
+    for (let i = 0; i < Math.min(toEvict, candidates.length); i++) {
+      this.cache.delete(candidates[i].queryId);
+    }
+  }
+  /**
+   * Manually trigger eviction (for testing or explicit cleanup).
+   */
+  evict() {
+    const sizeBefore = this.cache.size;
+    this.evictIfNeeded();
+    return sizeBefore - this.cache.size;
+  }
+  // ─── Helpers for filtering and sorting ─────────────────────────────────────
+  /**
+   * Filter nodes based on query options.
+   */
+  filterNodes(nodes, options) {
+    if (!options) return nodes;
+    let result = nodes;
+    if (options.where) {
+      result = result.filter((node) => {
+        for (const [key, value] of Object.entries(options.where)) {
+          if (node.properties[key] !== value) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+    if (!options.includeDeleted) {
+      result = result.filter((node) => !node.deleted);
+    }
+    return result;
+  }
+  /**
+   * Sort nodes based on query options.
+   */
+  sortNodes(nodes, options) {
+    if (!options?.orderBy) return nodes;
+    const entries = Object.entries(options.orderBy);
+    if (entries.length === 0) return nodes;
+    return [...nodes].sort((a, b) => {
+      for (const [key, direction] of entries) {
+        const keyStr = key;
+        let aVal;
+        let bVal;
+        if (keyStr === "createdAt" || keyStr === "updatedAt") {
+          aVal = a[keyStr];
+          bVal = b[keyStr];
+        } else {
+          aVal = a.properties[keyStr];
+          bVal = b.properties[keyStr];
+        }
+        if (aVal === bVal) continue;
+        if (aVal == null) return direction === "asc" ? 1 : -1;
+        if (bVal == null) return direction === "asc" ? -1 : 1;
+        const comparison = aVal < bVal ? -1 : 1;
+        return direction === "asc" ? comparison : -comparison;
+      }
+      return 0;
+    });
+  }
+  /**
+   * Apply pagination to nodes.
+   */
+  paginateNodes(nodes, options) {
+    if (!options) return nodes;
+    let result = nodes;
+    if (options.offset !== void 0 && options.offset > 0) {
+      result = result.slice(options.offset);
+    }
+    if (options.limit !== void 0 && options.limit > 0) {
+      result = result.slice(0, options.limit);
+    }
+    return result;
+  }
+};
+
+// src/query-metadata.ts
+import {
+  encodeNodeQueryCursor
+} from "@xnetjs/data";
+function getOffset(descriptor) {
+  return descriptor.offset ?? 0;
+}
+function getPageInfo(input) {
+  const { descriptor, nodes, totalCount, countMode } = input;
+  const loadedCount = nodes.length;
+  const offset = getOffset(descriptor);
+  const hasCursor = descriptor.after !== void 0;
+  const startCursor = loadedCount > 0 ? encodeNodeQueryCursor(descriptor, nodes[0]) : void 0;
+  const endCursor = loadedCount > 0 ? encodeNodeQueryCursor(descriptor, nodes[loadedCount - 1]) : void 0;
+  const hasPreviousPage = offset > 0 || hasCursor;
+  const hasMore = descriptor.limit !== void 0 ? totalCount === null || hasCursor ? loadedCount >= descriptor.limit : offset + loadedCount < totalCount : false;
+  return {
+    totalCount,
+    countMode,
+    hasMore,
+    hasNextPage: hasMore,
+    hasPreviousPage,
+    ...startCursor ? { startCursor } : {},
+    ...endCursor ? { endCursor } : {},
+    loadedCount
+  };
+}
+function getCountMetadata(descriptor, nodes, result) {
+  if (descriptor.count === "none") {
+    return { totalCount: null, countMode: "none" };
+  }
+  if (result?.plan.materializedRowCount !== void 0) {
+    return { totalCount: result.plan.materializedRowCount, countMode: "exact" };
+  }
+  if (result?.totalCount !== void 0) {
+    return { totalCount: result.totalCount, countMode: "exact" };
+  }
+  if (descriptor.count === "estimate") {
+    return {
+      totalCount: result?.plan.candidateNodeCount ?? nodes.length,
+      countMode: "estimate"
+    };
+  }
+  const isUnbounded = descriptor.limit === void 0 && getOffset(descriptor) === 0 && descriptor.after === void 0;
+  return isUnbounded ? { totalCount: nodes.length, countMode: "exact" } : { totalCount: null, countMode: "none" };
+}
+function createQueryMetadata(input) {
+  const { descriptor, result, source } = input;
+  const count = getCountMetadata(descriptor, result.nodes, result);
+  const materializedViewId = result.plan.materializedViewId;
+  return {
+    source,
+    updatedAt: Date.now(),
+    pageInfo: getPageInfo({ descriptor, nodes: result.nodes, ...count }),
+    plan: result.plan,
+    ...materializedViewId ? {
+      materialized: {
+        viewId: materializedViewId,
+        cacheHit: result.plan.materializedCacheHit ?? false,
+        generatedAt: result.plan.materializedGeneratedAt ?? Date.now(),
+        ...result.plan.materializedInvalidatedAt !== void 0 ? { invalidatedAt: result.plan.materializedInvalidatedAt } : {},
+        rowCount: result.plan.materializedRowCount ?? result.nodes.length
+      }
+    } : {}
+  };
+}
+function createQueryErrorMetadata(input) {
+  return {
+    source: input.source,
+    updatedAt: Date.now(),
+    pageInfo: getPageInfo({
+      descriptor: input.descriptor,
+      nodes: [],
+      totalCount: 0,
+      countMode: "exact"
+    }),
+    error: input.error.message
+  };
+}
+function createQuerySnapshotMetadata(input) {
+  return {
+    source: input.source,
+    updatedAt: Date.now(),
+    pageInfo: getPageInfo({
+      descriptor: input.descriptor,
+      nodes: input.nodes,
+      ...getCountMetadata(input.descriptor, input.nodes)
+    })
+  };
+}
+
+// src/native-bridge.ts
+var NativeBridge = class {
+  store;
+  cache;
+  statusListeners = /* @__PURE__ */ new Set();
+  storeUnsubscribe = null;
+  storeBatchUnsubscribe = 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.storeBatchUnsubscribe = this.store.subscribeToBatchChanges((event) => {
+      this.handleStoreBatchChange(event);
+    });
+    this._status = "connected";
+  }
+  // ─── Queries ────────────────────────────────────────────
+  query(schema, options) {
+    const descriptor = createQueryDescriptor(schema._schemaId, options);
+    const queryId = serializeQueryDescriptor(descriptor);
+    this.cache.initEntry(queryId, descriptor);
+    if (this.cache.get(queryId) === null) {
+      void this.loadQuery(queryId, descriptor);
+    }
+    return {
+      getSnapshot: () => this.cache.get(queryId),
+      getMetadata: () => this.cache.getMetadata(queryId),
+      subscribe: (callback) => this.cache.subscribe(queryId, callback)
+    };
+  }
+  async reloadQuery(descriptor) {
+    await this.loadQuery(serializeQueryDescriptor(descriptor), descriptor);
+  }
+  /**
+   * Load query data from the store and update cache.
+   */
+  async loadQuery(queryId, descriptor) {
+    if (this.destroyed) return;
+    try {
+      const result = await this.store.query(descriptor);
+      if (!this.destroyed) {
+        this.cache.set(
+          queryId,
+          result.nodes,
+          descriptor,
+          void 0,
+          createQueryMetadata({ descriptor, result, source: "local" })
+        );
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error("[NativeBridge] Failed to load query:", error);
+      if (!this.destroyed) {
+        this.cache.set(
+          queryId,
+          [],
+          descriptor,
+          void 0,
+          createQueryErrorMetadata({ descriptor, source: "local", error })
+        );
+      }
+    }
+  }
+  /**
+   * 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;
+    for (const entry of this.cache.getEntriesForSchema(schemaId)) {
+      if (entry.data === null) {
+        void this.loadQuery(entry.queryId, entry.descriptor);
+        continue;
+      }
+      const delta = applyNodeChangeToQueryResult({
+        descriptor: entry.descriptor,
+        currentData: entry.data,
+        nodeId: change.payload.nodeId,
+        nextNode: node
+      });
+      if (delta.kind === "reload") {
+        void this.loadQuery(entry.queryId, entry.descriptor);
+        continue;
+      }
+      if (delta.kind === "set") {
+        this.cache.set(entry.queryId, delta.data);
+      }
+    }
+  }
+  handleStoreBatchChange(event) {
+    if (this.destroyed) return;
+    for (const schemaId of event.schemaIds) {
+      for (const entry of this.cache.getEntriesForSchema(schemaId)) {
+        void this.loadQuery(entry.queryId, entry.descriptor);
+      }
+    }
+  }
+  // ─── 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);
+  }
+  async bulkWrite(input) {
+    if (this.destroyed) {
+      throw new Error("NativeBridge has been destroyed");
+    }
+    return this.store.batchWrite(input);
+  }
+  async transaction(operations) {
+    if (this.destroyed) {
+      throw new Error("NativeBridge has been destroyed");
+    }
+    const tx = await this.store.transaction(operations);
+    return { batchId: tx.batchId, results: tx.results, tempIds: tx.tempIds };
+  }
+  // ─── 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.storeBatchUnsubscribe) {
+      this.storeBatchUnsubscribe();
+      this.storeBatchUnsubscribe = 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;
+}
+
+export {
+  QueryCache,
+  createQueryMetadata,
+  createQueryErrorMetadata,
+  createQuerySnapshotMetadata,
+  NativeBridge,
+  createNativeBridge,
+  isReactNative,
+  isExpo
+};