@xnetjs/data-bridge 0.0.2 → 0.0.3

package/dist/index.js

@@ -1,20 +1,437 @@
 import {
-  QueryCache
-} from "./chunk-X6F5CPJI.js";
+  NativeBridge,
+  QueryCache,
+  createNativeBridge,
+  createQueryErrorMetadata,
+  createQueryMetadata,
+  createQuerySnapshotMetadata,
+  isExpo,
+  isReactNative
+} from "./chunk-25WNZV7W.js";
+import {
+  NodeStateDecoder,
+  NodeStateEncoder,
+  PortSQLiteAdapter,
+  decodeNodeStates,
+  decodeWorkerQuerySnapshot,
+  encodeNodeStates,
+  encodeWorkerQuerySnapshot,
+  groupNodeChangeEventsBySchema,
+  shouldUseBinaryEncoding
+} from "./chunk-EPNW4GGU.js";
+import {
+  BOUNDED_QUERY_OVERFETCH,
+  applyNodeChangeToBoundedQueryResult,
+  applyNodeChangeToQueryResult,
+  applyQueryDescriptor,
+  createBoundedWorkingSet,
+  createBoundedWorkingSetDescriptor,
+  createQueryDescriptor,
+  decodeQueryCursor,
+  encodeQueryCursor,
+  filterQueryNodes,
+  matchesQueryDescriptor,
+  queryDescriptorNeedsBoundedReload,
+  queryDescriptorSupportsBoundedDelta,
+  queryDescriptorToOptions,
+  reuseEquivalentNodeReferences,
+  serializeQueryDescriptor,
+  sortQueryNodes
+} from "./chunk-5GTIP33X.js";
+
+// src/query-stream.ts
+function createQueryStreamState(input) {
+  return {
+    data: input?.data ?? null,
+    metadata: input?.metadata ?? null,
+    progress: input?.progress ?? null,
+    error: input?.error ?? null,
+    status: input?.status ?? "idle"
+  };
+}
+function getNextMetadata(event, currentMetadata) {
+  return "metadata" in event && event.metadata !== void 0 ? event.metadata : currentMetadata;
+}
+function insertNode(nodes, node, index) {
+  const withoutExisting = nodes.filter((item) => item.id !== node.id);
+  if (index === void 0) return [...withoutExisting, node];
+  const boundedIndex = Math.max(0, Math.min(index, withoutExisting.length));
+  return [...withoutExisting.slice(0, boundedIndex), node, ...withoutExisting.slice(boundedIndex)];
+}
+function updateNode(nodes, nodeId, node) {
+  return nodes.map((item) => item.id === nodeId ? node : item);
+}
+function deleteNode(nodes, nodeId) {
+  return nodes.filter((item) => item.id !== nodeId);
+}
+function reduceQueryStreamEvent(state, event) {
+  const metadata = getNextMetadata(event, state.metadata);
+  switch (event.type) {
+    case "snapshot":
+      return {
+        data: event.nodes,
+        metadata,
+        progress: state.progress,
+        error: null,
+        status: "ready"
+      };
+    case "insert":
+      return {
+        data: insertNode(state.data ?? [], event.node, event.index),
+        metadata,
+        progress: state.progress,
+        error: null,
+        status: "ready"
+      };
+    case "update":
+      return {
+        data: updateNode(state.data ?? [], event.nodeId, event.node),
+        metadata,
+        progress: state.progress,
+        error: null,
+        status: "ready"
+      };
+    case "delete":
+      return {
+        data: deleteNode(state.data ?? [], event.nodeId),
+        metadata,
+        progress: state.progress,
+        error: null,
+        status: "ready"
+      };
+    case "reset":
+      return {
+        data: event.nodes ?? null,
+        metadata,
+        progress: state.progress,
+        error: null,
+        status: event.nodes ? "ready" : "loading"
+      };
+    case "progress":
+      return {
+        data: state.data,
+        metadata,
+        progress: event.progress,
+        error: state.error,
+        status: state.data === null ? "loading" : state.status
+      };
+    case "error":
+      return {
+        data: state.data,
+        metadata,
+        progress: state.progress,
+        error: event.error,
+        status: event.recoverable ? state.status : "error"
+      };
+  }
+}
+function reduceQueryStreamEvents(state, events) {
+  return events.reduce(reduceQueryStreamEvent, state);
+}
+
+// src/remote-query-protocol.ts
+var REMOTE_NODE_QUERY_PROTOCOL = "xnet.node-query";
+var REMOTE_NODE_QUERY_PROTOCOL_VERSION = 1;
+function isRemoteNodeQuerySource(source) {
+  return source === "hub" || source === "federated";
+}
+function createRemoteNodeQueryRequest(input) {
+  return {
+    protocol: REMOTE_NODE_QUERY_PROTOCOL,
+    version: REMOTE_NODE_QUERY_PROTOCOL_VERSION,
+    requestId: input.requestId,
+    descriptor: input.descriptor,
+    mode: input.mode ?? "remote",
+    source: input.source,
+    requestedAt: input.requestedAt ?? Date.now(),
+    ...input.auth ? { auth: input.auth } : {},
+    ...input.client ? { client: input.client } : {}
+  };
+}
+function isRemoteNodeQuerySuccess(response) {
+  return response.type === "node-query/result";
+}
+function isRemoteNodeQueryError(response) {
+  return response.type === "node-query/error";
+}
+
+// src/remote-query-execution.ts
+var REMOTE_QUERY_MODES = /* @__PURE__ */ new Set([
+  "local-then-remote",
+  "remote",
+  "live",
+  "stream"
+]);
+var DEFAULT_NODE_QUERY_ROUTER_THRESHOLDS = {
+  localRowThreshold: 1e4,
+  hybridRowThreshold: 1e5,
+  searchToRemote: true,
+  spatialToRemote: true
+};
+function getRemoteQueryMode(descriptor) {
+  return descriptor.mode && REMOTE_QUERY_MODES.has(descriptor.mode) ? descriptor.mode : null;
+}
+function getRemoteQuerySource(descriptor) {
+  return isRemoteNodeQuerySource(descriptor.source) ? descriptor.source : "hub";
+}
+function shouldRunRemoteQuery(descriptor) {
+  return descriptor.source !== "local" && getRemoteQueryMode(descriptor) !== null;
+}
+function shouldUseRemoteOnlyQuery(descriptor) {
+  return getRemoteQueryMode(descriptor) === "remote";
+}
+function normalizeNodeQueryRouterThresholds(thresholds) {
+  return {
+    ...DEFAULT_NODE_QUERY_ROUTER_THRESHOLDS,
+    ...thresholds
+  };
+}
+function routeRemoteNodeQuery(input) {
+  const { descriptor, localRowCount, hasRemoteClient } = input;
+  const thresholds = normalizeNodeQueryRouterThresholds(input.thresholds);
+  const mode = getRemoteQueryMode(descriptor);
+  const remoteSource = getRemoteQuerySource(descriptor);
+  if (descriptor.source === "local" || descriptor.mode === "local") {
+    return {
+      shouldRunRemote: false,
+      source: "local",
+      reason: "local-source",
+      ...localRowCount !== void 0 ? { localRowCount } : {},
+      thresholds
+    };
+  }
+  if (mode === "remote") {
+    return {
+      shouldRunRemote: true,
+      mode,
+      source: remoteSource,
+      reason: "explicit-remote-mode",
+      ...localRowCount !== void 0 ? { localRowCount } : {},
+      thresholds
+    };
+  }
+  if (mode === "live" || mode === "stream") {
+    return {
+      shouldRunRemote: false,
+      source: "local",
+      reason: "stream-lifecycle",
+      ...localRowCount !== void 0 ? { localRowCount } : {},
+      thresholds
+    };
+  }
+  if (descriptor.source !== "auto") {
+    return mode === "local-then-remote" ? {
+      shouldRunRemote: true,
+      mode,
+      source: remoteSource,
+      reason: "explicit-progressive-mode",
+      ...localRowCount !== void 0 ? { localRowCount } : {},
+      thresholds
+    } : {
+      shouldRunRemote: false,
+      source: "local",
+      reason: "local-by-default",
+      ...localRowCount !== void 0 ? { localRowCount } : {},
+      thresholds
+    };
+  }
+  if (!hasRemoteClient) {
+    return {
+      shouldRunRemote: false,
+      source: "local",
+      reason: "auto-no-remote-client",
+      ...localRowCount !== void 0 ? { localRowCount } : {},
+      thresholds
+    };
+  }
+  const progressiveMode = mode ?? "local-then-remote";
+  if (descriptor.search && thresholds.searchToRemote) {
+    return {
+      shouldRunRemote: true,
+      mode: progressiveMode,
+      source: remoteSource,
+      reason: "auto-search",
+      ...localRowCount !== void 0 ? { localRowCount } : {},
+      thresholds
+    };
+  }
+  if (descriptor.spatial && thresholds.spatialToRemote) {
+    return {
+      shouldRunRemote: true,
+      mode: progressiveMode,
+      source: remoteSource,
+      reason: "auto-spatial",
+      ...localRowCount !== void 0 ? { localRowCount } : {},
+      thresholds
+    };
+  }
+  if (localRowCount === void 0) {
+    return {
+      shouldRunRemote: false,
+      source: "local",
+      reason: "auto-unknown-row-count",
+      thresholds
+    };
+  }
+  if (localRowCount >= thresholds.hybridRowThreshold) {
+    return {
+      shouldRunRemote: true,
+      mode: progressiveMode,
+      source: remoteSource,
+      reason: "auto-large-result",
+      localRowCount,
+      thresholds
+    };
+  }
+  if (localRowCount >= thresholds.localRowThreshold) {
+    return {
+      shouldRunRemote: true,
+      mode: progressiveMode,
+      source: remoteSource,
+      reason: "auto-medium-result",
+      localRowCount,
+      thresholds
+    };
+  }
+  return {
+    shouldRunRemote: false,
+    source: "local",
+    reason: "auto-small-result",
+    localRowCount,
+    thresholds
+  };
+}
+function createQueryRoutingMetadata(route) {
+  return {
+    source: route.shouldRunRemote ? route.source : "local",
+    reason: route.reason,
+    ...route.localRowCount !== void 0 ? { localRowCount: route.localRowCount } : {},
+    thresholds: {
+      localRowThreshold: route.thresholds.localRowThreshold,
+      hybridRowThreshold: route.thresholds.hybridRowThreshold
+    }
+  };
+}
+function chooseNewestNode(left, right) {
+  if (right.updatedAt > left.updatedAt) return right;
+  if (right.updatedAt < left.updatedAt) return left;
+  return right;
+}
+function mergeRemoteNodeSnapshots(localNodes, remoteNodes) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const node of remoteNodes) {
+    const existing = merged.get(node.id);
+    merged.set(node.id, existing ? chooseNewestNode(existing, node) : node);
+  }
+  for (const node of localNodes) {
+    const existing = merged.get(node.id);
+    merged.set(node.id, existing ? chooseNewestNode(existing, node) : node);
+  }
+  return [...merged.values()];
+}
+function isRemoteVerificationFailed(verification) {
+  return verification?.status === "failed";
+}
+function filterRemoteNodesByVerification(nodes, verification) {
+  if (!verification || verification.status === "verified" || verification.status === "unverified") {
+    return [...nodes];
+  }
+  if (verification.status === "failed") {
+    return [];
+  }
+  const verifiedNodeIds = verification.verifiedNodeIds ? new Set(verification.verifiedNodeIds) : null;
+  const failedNodeIds = new Set(verification.failedNodeIds ?? []);
+  return nodes.filter((node) => {
+    if (failedNodeIds.has(node.id)) return false;
+    return verifiedNodeIds ? verifiedNodeIds.has(node.id) : true;
+  });
+}
+function createRemoteVerificationError(input) {
+  return {
+    type: "node-query/error",
+    requestId: input.requestId,
+    source: input.source,
+    code: "VERIFICATION_FAILED",
+    message: input.message ?? "Remote query result verification failed"
+  };
+}
+function createRemoteSuccessMetadata(input) {
+  const { response, source, loadedCount } = input;
+  const pageInfo = {
+    ...response.pageInfo,
+    loadedCount
+  };
+  return {
+    ...response.metadata,
+    source,
+    updatedAt: Date.now(),
+    pageInfo,
+    completeness: response.completeness,
+    staleness: response.staleness,
+    verification: response.verification
+  };
+}
+function createRemoteFallbackMetadata(input) {
+  const { localMetadata, error } = input;
+  const message = error instanceof Error ? error.message : error.message;
+  const reason = !(error instanceof Error) && error.code === "TIMEOUT" ? "source-timeout" : !(error instanceof Error) && error.code === "VERIFICATION_FAILED" ? "verification-failed" : "remote-unavailable";
+  const verification = !(error instanceof Error) && error.code === "VERIFICATION_FAILED" ? { status: "failed" } : localMetadata.verification ?? { status: "unverified" };
+  return {
+    ...localMetadata,
+    source: localMetadata.source === "local" ? "hybrid" : localMetadata.source,
+    updatedAt: Date.now(),
+    completeness: {
+      level: "partial",
+      reason
+    },
+    staleness: localMetadata.staleness ?? {
+      level: "stale",
+      asOf: localMetadata.updatedAt
+    },
+    verification,
+    error: message
+  };
+}
+function withRemoteErrorVerificationMetadata(metadata, error) {
+  if (error instanceof Error || error.code !== "VERIFICATION_FAILED") {
+    return metadata;
+  }
+  return {
+    ...metadata,
+    verification: {
+      status: "failed"
+    }
+  };
+}
 
 // src/main-thread-bridge.ts
+var BULK_STORE_CHANGE_RELOAD_THRESHOLD = 250;
 var MainThreadBridge = class {
   store;
   cache;
   statusListeners = /* @__PURE__ */ new Set();
   storeUnsubscribe = null;
+  storeBatchUnsubscribe = null;
   _syncManager = null;
-  constructor(store) {
+  remoteNodeQueryClient;
+  remoteNodeQueryRouting;
+  remoteLoads = /* @__PURE__ */ new Map();
+  remoteStreams = /* @__PURE__ */ new Map();
+  remoteInvalidations = null;
+  pendingStoreChanges = [];
+  storeChangeFlushQueued = false;
+  constructor(store, options) {
     this.store = store;
     this.cache = new QueryCache();
+    this.remoteNodeQueryClient = options?.remoteNodeQueryClient ?? null;
+    this.remoteNodeQueryRouting = options?.remoteNodeQueryRouting;
     this.storeUnsubscribe = this.store.subscribe((event) => {
-      this.handleStoreChange(event);
+      this.enqueueStoreChange(event);
     });
+    this.storeBatchUnsubscribe = this.store.subscribeToBatchChanges((event) => {
+      this.handleStoreBatchChange(event);
+    });
+    this.startRemoteInvalidationSubscription();
   }
   /**
    * Set the SyncManager for Y.Doc acquisition.
@@ -25,53 +442,704 @@ var MainThreadBridge = class {
   }
   // ─── 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);
+    const descriptor = createQueryDescriptor(schema._schemaId, options);
+    const queryId = serializeQueryDescriptor(descriptor);
+    this.cache.initEntry(queryId, descriptor);
+    if (this.cache.get(queryId) === null) {
+      void this.loadInitialQuery(queryId, descriptor);
     }
     return {
       getSnapshot: () => this.cache.get(queryId),
-      subscribe: (callback) => this.cache.subscribe(queryId, callback)
+      getMetadata: () => this.cache.getMetadata(queryId),
+      subscribe: (callback) => this.subscribeToQuery(queryId, descriptor, callback)
     };
   }
+  subscribeToQuery(queryId, descriptor, callback) {
+    const unsubscribe = this.cache.subscribe(queryId, callback);
+    this.startRemoteQueryStream(queryId, descriptor);
+    return () => {
+      unsubscribe();
+      if (this.cache.getSubscriberCount(queryId) === 0) {
+        this.stopRemoteQueryStream(queryId);
+      }
+    };
+  }
+  async reloadQuery(descriptor) {
+    await this.loadInitialQuery(serializeQueryDescriptor(descriptor), descriptor);
+  }
   /**
-   * Load query data from the store and update cache.
+   * Load query data according to the descriptor's local/remote execution mode.
    */
-  async loadQuery(queryId, schemaId, options) {
+  async loadInitialQuery(queryId, descriptor) {
+    if (shouldUseRemoteOnlyQuery(descriptor)) {
+      await this.loadRemoteQuery(queryId, descriptor);
+      return;
+    }
+    const result = await this.loadLocalQuery(queryId, descriptor);
+    const route = routeRemoteNodeQuery({
+      descriptor,
+      hasRemoteClient: this.remoteNodeQueryClient !== null,
+      localRowCount: this.getQueryRouteRowCount(result),
+      thresholds: this.remoteNodeQueryRouting
+    });
+    if (route.shouldRunRemote) {
+      await this.loadRemoteQuery(queryId, descriptor, route);
+    }
+  }
+  getQueryRouteRowCount(result) {
+    return result?.totalCount ?? result?.plan.candidateNodeCount ?? result?.nodes.length;
+  }
+  /**
+   * Load query data from the local store and update cache.
+   */
+  async loadLocalQuery(queryId, descriptor) {
     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
-        });
+      const useBoundedWorkingSet = queryDescriptorSupportsBoundedDelta(descriptor);
+      const result = await this.store.query(
+        useBoundedWorkingSet ? createBoundedWorkingSetDescriptor(descriptor) : descriptor
+      );
+      this.debugQueryPlan(queryId, result.plan);
+      const previousWorkingSet = this.cache.getWorkingSet(queryId);
+      const mergedNodes = reuseEquivalentNodeReferences(result.nodes, [
+        ...previousWorkingSet?.nodes ?? [],
+        ...this.cache.get(queryId) ?? []
+      ]);
+      const visibleNodes = useBoundedWorkingSet ? mergedNodes.slice(0, descriptor.limit) : mergedNodes;
+      const visibleResult = { ...result, nodes: visibleNodes };
+      this.cache.set(
+        queryId,
+        visibleNodes,
+        descriptor,
+        void 0,
+        {
+          ...createQueryMetadata({ descriptor, result: visibleResult, source: "local" }),
+          source: "local"
+        },
+        useBoundedWorkingSet ? createBoundedWorkingSet(descriptor, mergedNodes) : void 0
+      );
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error("[MainThreadBridge] Failed to load query:", error);
+      this.cache.set(
+        queryId,
+        [],
+        descriptor,
+        void 0,
+        createQueryErrorMetadata({ descriptor, source: "local", error })
+      );
+      return null;
+    }
+  }
+  /**
+   * Load query data from the configured remote query client.
+   */
+  async loadRemoteQuery(queryId, descriptor, route) {
+    if (!route?.shouldRunRemote && !shouldRunRemoteQuery(descriptor)) return;
+    if (!this.remoteNodeQueryClient) {
+      this.handleRemoteQueryError(queryId, descriptor, new Error("Remote query client unavailable"));
+      return;
+    }
+    const existingLoad = this.remoteLoads.get(queryId);
+    if (existingLoad) {
+      await existingLoad;
+      return;
+    }
+    const load = this.executeRemoteQuery(queryId, descriptor, route).finally(() => {
+      this.remoteLoads.delete(queryId);
+    });
+    this.remoteLoads.set(queryId, load);
+    await load;
+  }
+  shouldUseRemoteStream(descriptor) {
+    const mode = getRemoteQueryMode(descriptor);
+    return descriptor.source !== "local" && (mode === "live" || mode === "stream");
+  }
+  startRemoteQueryStream(queryId, descriptor) {
+    if (!this.shouldUseRemoteStream(descriptor)) return;
+    if (this.remoteStreams.has(queryId)) return;
+    if (!this.remoteNodeQueryClient) {
+      this.handleRemoteQueryError(queryId, descriptor, new Error("Remote query client unavailable"));
+      return;
+    }
+    if (!this.remoteNodeQueryClient.stream) {
+      void this.loadRemoteQuery(queryId, descriptor);
+      return;
+    }
+    const localSnapshot = this.cache.get(queryId);
+    const runtime = {
+      state: createQueryStreamState({
+        data: localSnapshot,
+        metadata: this.cache.getMetadata(queryId),
+        status: localSnapshot === null ? "loading" : "ready"
+      }),
+      unsubscribe: null,
+      cancelled: false,
+      start: Promise.resolve()
+    };
+    const mode = getRemoteQueryMode(descriptor);
+    if (!mode) return;
+    this.remoteStreams.set(queryId, runtime);
+    const request = createRemoteNodeQueryRequest({
+      requestId: queryId,
+      descriptor,
+      mode,
+      source: getRemoteQuerySource(descriptor),
+      client: {
+        knownNodeIds: localSnapshot?.map((node) => node.id) ?? []
       }
-      nodes = this.cache.filterNodes(nodes, options);
-      nodes = this.cache.sortNodes(nodes, options);
-      this.cache.set(queryId, nodes, schemaId, options ?? {});
+    });
+    runtime.start = Promise.resolve(
+      this.remoteNodeQueryClient.stream(request, {
+        next: (event) => {
+          if (this.remoteStreams.get(queryId) !== runtime || runtime.cancelled) return;
+          this.applyRemoteStreamEvent(queryId, descriptor, event);
+        },
+        error: (error) => {
+          if (this.remoteStreams.get(queryId) !== runtime || runtime.cancelled) return;
+          this.applyRemoteStreamEvent(queryId, descriptor, {
+            type: "error",
+            error: error.message
+          });
+          this.stopRemoteQueryStream(queryId);
+        },
+        complete: () => {
+          if (this.remoteStreams.get(queryId) !== runtime || runtime.cancelled) return;
+          this.applyRemoteStreamEvent(queryId, descriptor, {
+            type: "progress",
+            progress: { phase: "complete" }
+          });
+          this.stopRemoteQueryStream(queryId);
+        }
+      })
+    ).then((subscription) => {
+      const unsubscribe = this.normalizeRemoteStreamSubscription(subscription);
+      if (runtime.cancelled) {
+        unsubscribe?.();
+        return;
+      }
+      runtime.unsubscribe = unsubscribe;
+    }).catch((err) => {
+      if (runtime.cancelled) return;
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.handleRemoteQueryError(queryId, descriptor, error);
+      this.remoteStreams.delete(queryId);
+    });
+  }
+  stopRemoteQueryStream(queryId) {
+    const runtime = this.remoteStreams.get(queryId);
+    if (!runtime) return;
+    runtime.cancelled = true;
+    this.remoteStreams.delete(queryId);
+    runtime.unsubscribe?.();
+  }
+  normalizeRemoteStreamSubscription(subscription) {
+    return this.normalizeRemoteSubscription(subscription);
+  }
+  normalizeRemoteInvalidationSubscription(subscription) {
+    return this.normalizeRemoteSubscription(subscription);
+  }
+  normalizeRemoteSubscription(subscription) {
+    if (!subscription) return null;
+    if (typeof subscription === "function") return subscription;
+    return () => {
+      subscription.unsubscribe();
+    };
+  }
+  startRemoteInvalidationSubscription() {
+    if (this.remoteInvalidations) return;
+    if (!this.remoteNodeQueryClient?.subscribeInvalidations) return;
+    const runtime = {
+      unsubscribe: null,
+      cancelled: false,
+      start: Promise.resolve()
+    };
+    this.remoteInvalidations = runtime;
+    runtime.start = Promise.resolve(
+      this.remoteNodeQueryClient.subscribeInvalidations({
+        next: (event) => {
+          if (this.remoteInvalidations !== runtime || runtime.cancelled) return;
+          this.handleRemoteQueryInvalidation(event);
+        },
+        error: (error) => {
+          if (this.remoteInvalidations !== runtime || runtime.cancelled) return;
+          console.error("[MainThreadBridge] Remote query invalidation subscription failed:", error);
+          this.stopRemoteInvalidationSubscription();
+        },
+        complete: () => {
+          if (this.remoteInvalidations !== runtime || runtime.cancelled) return;
+          this.stopRemoteInvalidationSubscription();
+        }
+      })
+    ).then((subscription) => {
+      const unsubscribe = this.normalizeRemoteInvalidationSubscription(subscription);
+      if (runtime.cancelled) {
+        unsubscribe?.();
+        return;
+      }
+      runtime.unsubscribe = unsubscribe;
+    }).catch((err) => {
+      if (runtime.cancelled) return;
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error("[MainThreadBridge] Failed to subscribe to remote invalidations:", error);
+      this.remoteInvalidations = null;
+    });
+  }
+  stopRemoteInvalidationSubscription() {
+    const runtime = this.remoteInvalidations;
+    if (!runtime) return;
+    runtime.cancelled = true;
+    this.remoteInvalidations = null;
+    runtime.unsubscribe?.();
+  }
+  handleRemoteQueryInvalidation(event) {
+    for (const entry of this.getRemoteInvalidationEntries(event)) {
+      if (this.cache.getSubscriberCount(entry.queryId) === 0) continue;
+      const route = routeRemoteNodeQuery({
+        descriptor: entry.descriptor,
+        hasRemoteClient: this.remoteNodeQueryClient !== null,
+        localRowCount: this.getRemoteInvalidationRouteRowCount(entry.queryId, entry.data),
+        thresholds: this.remoteNodeQueryRouting
+      });
+      if (route.shouldRunRemote) {
+        void this.loadRemoteQuery(entry.queryId, entry.descriptor, route);
+        continue;
+      }
+      if (shouldRunRemoteQuery(entry.descriptor)) {
+        void this.loadRemoteQuery(entry.queryId, entry.descriptor);
+      }
+    }
+  }
+  getRemoteInvalidationRouteRowCount(queryId, data) {
+    const totalCount = this.cache.getMetadata(queryId)?.pageInfo?.totalCount;
+    return typeof totalCount === "number" ? totalCount : data?.length ?? void 0;
+  }
+  getRemoteInvalidationEntries(event) {
+    const matches = /* @__PURE__ */ new Map();
+    const addEntry = (entry) => {
+      matches.set(entry.queryId, entry);
+    };
+    const addQueryId = (queryId) => {
+      if (!queryId || !this.cache.has(queryId)) return;
+      const descriptor = this.cache.getDescriptor(queryId);
+      if (!descriptor) return;
+      addEntry({ queryId, descriptor, data: this.cache.get(queryId) });
+    };
+    addQueryId(event.requestId);
+    if (event.descriptor) {
+      addQueryId(serializeQueryDescriptor(event.descriptor));
+    }
+    const schemaEntries = event.schemaId !== void 0 ? this.cache.getEntriesForSchema(event.schemaId) : event.requestId || event.descriptor || event.nodeIds ? [] : this.cache.getEntries();
+    schemaEntries.forEach(addEntry);
+    if (event.nodeIds && event.nodeIds.length > 0) {
+      const nodeIds = new Set(event.nodeIds);
+      const candidates = event.schemaId !== void 0 ? this.cache.getEntriesForSchema(event.schemaId) : this.cache.getEntries();
+      candidates.filter((entry) => {
+        if (entry.descriptor.nodeId && nodeIds.has(entry.descriptor.nodeId)) return true;
+        return (entry.data ?? []).some((node) => nodeIds.has(node.id));
+      }).forEach(addEntry);
+    }
+    return Array.from(matches.values());
+  }
+  applyRemoteStreamEvent(queryId, descriptor, event) {
+    const runtime = this.remoteStreams.get(queryId);
+    if (!runtime) return;
+    const normalizedEvent = this.normalizeRemoteStreamEvent(descriptor, runtime.state, event);
+    const eventWithMetadata = event.type === "error" && event.metadata === void 0 ? {
+      ...normalizedEvent,
+      metadata: this.createStreamErrorMetadata(
+        descriptor,
+        runtime.state,
+        normalizedEvent
+      )
+    } : normalizedEvent;
+    const nextState = reduceQueryStreamEvent(runtime.state, eventWithMetadata);
+    runtime.state = nextState;
+    this.cache.set(
+      queryId,
+      nextState.data,
+      descriptor,
+      void 0,
+      this.withStreamMetadata(descriptor, nextState, eventWithMetadata)
+    );
+  }
+  normalizeRemoteStreamEvent(descriptor, state, event) {
+    const verification = event.metadata?.verification;
+    if (isRemoteVerificationFailed(verification)) {
+      return {
+        type: "error",
+        code: "VERIFICATION_FAILED",
+        error: "Remote stream event verification failed",
+        metadata: this.createStreamErrorMetadata(descriptor, state, {
+          type: "error",
+          code: "VERIFICATION_FAILED",
+          error: "Remote stream event verification failed"
+        })
+      };
+    }
+    if (!verification || verification.status !== "mixed") {
+      return event;
+    }
+    switch (event.type) {
+      case "snapshot":
+        return {
+          ...event,
+          nodes: filterRemoteNodesByVerification(event.nodes, verification)
+        };
+      case "reset":
+        return event.nodes ? {
+          ...event,
+          nodes: filterRemoteNodesByVerification(event.nodes, verification)
+        } : event;
+      case "insert":
+        return filterRemoteNodesByVerification([event.node], verification).length > 0 ? event : {
+          type: "delete",
+          nodeId: event.node.id,
+          metadata: event.metadata
+        };
+      case "update":
+        return filterRemoteNodesByVerification([event.node], verification).length > 0 ? event : {
+          type: "delete",
+          nodeId: event.nodeId,
+          metadata: event.metadata
+        };
+      default:
+        return event;
+    }
+  }
+  withStreamMetadata(descriptor, state, event) {
+    const base = state.metadata ?? createQuerySnapshotMetadata({
+      descriptor,
+      nodes: state.data ?? [],
+      source: getRemoteQuerySource(descriptor)
+    });
+    const metadata = { ...base };
+    if (!state.error) {
+      delete metadata.error;
+    }
+    return {
+      ...metadata,
+      updatedAt: Date.now(),
+      stream: {
+        status: state.status,
+        lastEvent: event.type,
+        lastEventAt: Date.now(),
+        ...state.progress ? { progress: state.progress } : {},
+        ...state.error ? { error: state.error } : {},
+        ...event.type === "reset" ? { resetReason: event.reason } : {}
+      },
+      ...state.error ? { error: state.error } : {}
+    };
+  }
+  createStreamErrorMetadata(descriptor, state, event) {
+    const currentMetadata = state.metadata ?? this.cache.getMetadata(serializeQueryDescriptor(descriptor));
+    const error = event.code === "VERIFICATION_FAILED" ? createRemoteVerificationError({
+      requestId: serializeQueryDescriptor(descriptor),
+      source: getRemoteQuerySource(descriptor),
+      message: event.error
+    }) : new Error(event.error);
+    if (currentMetadata && state.data !== null) {
+      return createRemoteFallbackMetadata({
+        localMetadata: currentMetadata,
+        error
+      });
+    }
+    return withRemoteErrorVerificationMetadata(
+      createQueryErrorMetadata({
+        descriptor,
+        source: getRemoteQuerySource(descriptor),
+        error: new Error(event.error)
+      }),
+      error
+    );
+  }
+  async executeRemoteQuery(queryId, descriptor, route) {
+    const mode = route?.shouldRunRemote ? route.mode : getRemoteQueryMode(descriptor);
+    if (!mode) return;
+    const source = route?.shouldRunRemote ? route.source : getRemoteQuerySource(descriptor);
+    const localSnapshot = this.cache.get(queryId) ?? [];
+    const requestDescriptor = {
+      ...descriptor,
+      mode,
+      source
+    };
+    try {
+      const response = await this.remoteNodeQueryClient.query(
+        createRemoteNodeQueryRequest({
+          requestId: queryId,
+          descriptor: requestDescriptor,
+          mode,
+          source,
+          client: {
+            knownNodeIds: localSnapshot.map((node) => node.id)
+          }
+        })
+      );
+      if (isRemoteNodeQueryError(response)) {
+        this.handleRemoteQueryError(queryId, descriptor, response);
+        return;
+      }
+      if (!isRemoteNodeQuerySuccess(response)) return;
+      if (isRemoteVerificationFailed(response.verification)) {
+        this.handleRemoteQueryError(
+          queryId,
+          descriptor,
+          createRemoteVerificationError({
+            requestId: response.requestId,
+            source: response.source
+          })
+        );
+        return;
+      }
+      const verifiedRemoteNodes = filterRemoteNodesByVerification(
+        response.nodes,
+        response.verification
+      );
+      const nodes = mode === "local-then-remote" ? mergeRemoteNodeSnapshots(localSnapshot, verifiedRemoteNodes) : verifiedRemoteNodes;
+      const metadata = createRemoteSuccessMetadata({
+        response,
+        source: mode === "local-then-remote" ? "hybrid" : response.source,
+        loadedCount: nodes.length
+      });
+      this.cache.set(queryId, nodes, descriptor, void 0, {
+        ...metadata,
+        ...route ? { routing: createQueryRoutingMetadata(route) } : {}
+      });
     } catch (err) {
-      console.error("[MainThreadBridge] Failed to load query:", err);
-      this.cache.set(queryId, [], schemaId, options ?? {});
+      this.handleRemoteQueryError(
+        queryId,
+        descriptor,
+        err instanceof Error ? err : new Error(String(err))
+      );
+    }
+  }
+  handleRemoteQueryError(queryId, descriptor, error) {
+    const localSnapshot = this.cache.get(queryId);
+    const localMetadata = this.cache.getMetadata(queryId);
+    if ((descriptor.mode === "local-then-remote" || descriptor.mode === "live" || descriptor.mode === "stream") && localSnapshot && localMetadata) {
+      this.cache.set(
+        queryId,
+        localSnapshot,
+        descriptor,
+        void 0,
+        createRemoteFallbackMetadata({ localMetadata, error })
+      );
+      return;
     }
+    const fallbackSource = getRemoteQuerySource(descriptor);
+    const message = error instanceof Error ? error.message : error.message;
+    const metadata = createQueryErrorMetadata({
+      descriptor,
+      source: fallbackSource,
+      error: new Error(message)
+    });
+    this.cache.set(
+      queryId,
+      [],
+      descriptor,
+      void 0,
+      withRemoteErrorVerificationMetadata(metadata, error)
+    );
+  }
+  debugQueryPlan(queryId, plan) {
+    if (typeof localStorage === "undefined") return;
+    if (localStorage.getItem("xnet:sync:debug") !== "true") return;
+    console.debug("[MainThreadBridge] query", {
+      queryId,
+      durationMs: plan.durationMs,
+      hydratedNodeCount: plan.hydratedNodeCount
+    });
   }
   /**
    * Handle store changes and invalidate affected caches.
    */
+  enqueueStoreChange(event) {
+    this.pendingStoreChanges.push(event);
+    if (this.storeChangeFlushQueued) {
+      return;
+    }
+    this.storeChangeFlushQueued = true;
+    queueMicrotask(() => {
+      this.flushStoreChanges();
+    });
+  }
+  flushStoreChanges() {
+    const events = this.pendingStoreChanges;
+    this.pendingStoreChanges = [];
+    this.storeChangeFlushQueued = false;
+    if (events.length === 0) {
+      return;
+    }
+    if (!this.isBulkStoreChangeSet(events) && events.length === 1) {
+      this.handleStoreChange(events[0]);
+      return;
+    }
+    this.handleStoreChangeSet(events);
+  }
+  isBulkStoreChangeSet(events) {
+    return events.length > BULK_STORE_CHANGE_RELOAD_THRESHOLD || events.some((event) => (event.change.batchSize ?? 1) > BULK_STORE_CHANGE_RELOAD_THRESHOLD);
+  }
+  handleStoreChangeSet(events) {
+    const eventsBySchema = groupNodeChangeEventsBySchema(events);
+    for (const [schemaId, schemaEvents] of eventsBySchema) {
+      const shouldReload = this.isBulkStoreChangeSet(schemaEvents);
+      const changes = schemaEvents.map((event) => ({
+        nodeId: event.change.payload.nodeId,
+        nextNode: event.node ?? null
+      }));
+      for (const entry of this.cache.getEntriesForSchema(schemaId)) {
+        if (entry.descriptor.mode === "remote") continue;
+        if (entry.data === null || shouldReload) {
+          void this.loadInitialQuery(entry.queryId, entry.descriptor);
+          continue;
+        }
+        this.applyChangesToEntry(entry, changes);
+      }
+    }
+  }
+  handleStoreBatchChange(event) {
+    if (event.nodeIds.length > BULK_STORE_CHANGE_RELOAD_THRESHOLD) {
+      this.reloadEntriesForSchemas(event.schemaIds);
+      return;
+    }
+    void this.applyStoreBatchChangeDeltas(event).catch((err) => {
+      console.error("[MainThreadBridge] Failed to apply batch change deltas:", err);
+      this.reloadEntriesForSchemas(event.schemaIds);
+    });
+  }
+  reloadEntriesForSchemas(schemaIds) {
+    for (const schemaId of schemaIds) {
+      for (const entry of this.cache.getEntriesForSchema(schemaId)) {
+        if (entry.descriptor.mode === "remote") continue;
+        void this.loadInitialQuery(entry.queryId, entry.descriptor);
+      }
+    }
+  }
+  async applyStoreBatchChangeDeltas(event) {
+    const nodes = await Promise.all(event.nodeIds.map((nodeId) => this.store.get(nodeId)));
+    const changes = event.nodeIds.map((nodeId, index) => ({
+      nodeId,
+      nextNode: nodes[index]
+    }));
+    for (const schemaId of event.schemaIds) {
+      for (const entry of this.cache.getEntriesForSchema(schemaId)) {
+        if (entry.descriptor.mode === "remote") continue;
+        if (entry.data === null) {
+          void this.loadInitialQuery(entry.queryId, entry.descriptor);
+          continue;
+        }
+        this.applyChangesToEntry(entry, changes);
+      }
+    }
+  }
+  /**
+   * Apply a list of node changes to a single cache entry, falling back to a
+   * storage re-query only when a delta is ambiguous. Optimistic
+   * (pre-persistence) applies skip ambiguous entries instead of reloading —
+   * storage still holds the OLD state, and the durable change event that
+   * follows will reconcile them.
+   */
+  applyChangesToEntry(entry, changes, options) {
+    let data = entry.data ?? [];
+    let workingSet = entry.workingSet;
+    let changed = false;
+    for (const change of changes) {
+      const applied = this.applyChangeToEntryState({
+        descriptor: entry.descriptor,
+        data,
+        workingSet,
+        nodeId: change.nodeId,
+        nextNode: change.nextNode
+      });
+      if (applied.kind === "reload") {
+        if (options?.onAmbiguous !== "skip") {
+          void this.loadInitialQuery(entry.queryId, entry.descriptor);
+        }
+        return;
+      }
+      if (applied.changed) {
+        data = applied.data;
+        workingSet = applied.workingSet;
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.cache.set(entry.queryId, data, void 0, void 0, void 0, workingSet);
+    }
+  }
+  /**
+   * Find the freshest cached snapshot of a node across all cache entries.
+   */
+  findCachedNode(nodeId) {
+    for (const entry of this.cache.getEntries()) {
+      const fromWorkingSet = entry.workingSet?.nodes.find((node) => node.id === nodeId);
+      if (fromWorkingSet) return fromWorkingSet;
+      const fromData = entry.data?.find((node) => node.id === nodeId);
+      if (fromData) return fromData;
+    }
+    return null;
+  }
+  /**
+   * Synchronously apply an optimistic node mutation to every affected cache
+   * entry before persistence, so subscribers see the edit immediately.
+   * Returns a revert function that restores authoritative state by
+   * re-querying storage (used when persistence fails).
+   */
+  applyOptimisticNodeChange(nodeId, mutate) {
+    const current = this.findCachedNode(nodeId);
+    if (!current) {
+      return () => {
+      };
+    }
+    const nextNode = mutate(current);
+    const changes = [{ nodeId, nextNode }];
+    for (const entry of this.cache.getEntriesForSchema(current.schemaId)) {
+      if (entry.descriptor.mode === "remote") continue;
+      if (entry.data === null) continue;
+      this.applyChangesToEntry(entry, changes, { onAmbiguous: "skip" });
+    }
+    return () => {
+      this.reloadEntriesForSchemas([current.schemaId]);
+    };
+  }
+  applyChangeToEntryState(input) {
+    if (input.workingSet && queryDescriptorSupportsBoundedDelta(input.descriptor)) {
+      const delta2 = applyNodeChangeToBoundedQueryResult({
+        descriptor: input.descriptor,
+        workingSet: input.workingSet,
+        nodeId: input.nodeId,
+        nextNode: input.nextNode
+      });
+      if (delta2.kind === "reload") return { kind: "reload" };
+      if (delta2.kind === "noop") {
+        return { kind: "ok", data: input.data, workingSet: input.workingSet, changed: false };
+      }
+      return { kind: "ok", data: delta2.data, workingSet: delta2.workingSet, changed: true };
+    }
+    const delta = applyNodeChangeToQueryResult({
+      descriptor: input.descriptor,
+      currentData: input.data,
+      nodeId: input.nodeId,
+      nextNode: input.nextNode
+    });
+    if (delta.kind === "reload") return { kind: "reload" };
+    if (delta.kind === "noop") {
+      return { kind: "ok", data: input.data, workingSet: input.workingSet, changed: false };
+    }
+    return { kind: "ok", data: delta.data, workingSet: null, changed: true };
+  }
   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);
+    const changes = [{ nodeId: change.payload.nodeId, nextNode: node ?? null }];
+    for (const entry of this.cache.getEntriesForSchema(schemaId)) {
+      if (entry.descriptor.mode === "remote") continue;
+      if (entry.data === null) {
+        void this.loadInitialQuery(entry.queryId, entry.descriptor);
+        continue;
+      }
+      this.applyChangesToEntry(entry, changes);
     }
   }
   // ─── Mutations ──────────────────────────────────────────
@@ -83,14 +1151,41 @@ var MainThreadBridge = class {
     });
   }
   async update(nodeId, changes) {
-    return this.store.update(nodeId, { properties: changes });
+    const revert = this.applyOptimisticNodeChange(nodeId, (node) => ({
+      ...node,
+      properties: { ...node.properties, ...changes },
+      updatedAt: Date.now()
+    }));
+    try {
+      return await this.store.update(nodeId, { properties: changes });
+    } catch (err) {
+      revert();
+      throw err;
+    }
   }
   async delete(nodeId) {
-    await this.store.delete(nodeId);
+    const revert = this.applyOptimisticNodeChange(nodeId, (node) => ({
+      ...node,
+      deleted: true,
+      updatedAt: Date.now()
+    }));
+    try {
+      await this.store.delete(nodeId);
+    } catch (err) {
+      revert();
+      throw err;
+    }
   }
   async restore(nodeId) {
     return this.store.restore(nodeId);
   }
+  async bulkWrite(input) {
+    return this.store.batchWrite(input);
+  }
+  async transaction(operations) {
+    const tx = await this.store.transaction(operations);
+    return { batchId: tx.batchId, results: tx.results, tempIds: tx.tempIds };
+  }
   // ─── Documents ─────────────────────────────────────────
   /**
    * Acquire a Y.Doc for editing.
@@ -120,13 +1215,31 @@ var MainThreadBridge = class {
     }
   }
   // ─── Lifecycle ──────────────────────────────────────────
+  async initialize(config) {
+    const nextRemoteNodeQueryClient = config.remoteNodeQueryClient ?? this.remoteNodeQueryClient;
+    if (nextRemoteNodeQueryClient !== this.remoteNodeQueryClient) {
+      this.stopRemoteInvalidationSubscription();
+    }
+    this.remoteNodeQueryClient = nextRemoteNodeQueryClient;
+    this.remoteNodeQueryRouting = config.remoteNodeQueryRouting ?? this.remoteNodeQueryRouting;
+    this.startRemoteInvalidationSubscription();
+  }
   destroy() {
+    this.stopRemoteInvalidationSubscription();
+    for (const queryId of this.remoteStreams.keys()) {
+      this.stopRemoteQueryStream(queryId);
+    }
     if (this.storeUnsubscribe) {
       this.storeUnsubscribe();
       this.storeUnsubscribe = null;
     }
+    if (this.storeBatchUnsubscribe) {
+      this.storeBatchUnsubscribe();
+      this.storeBatchUnsubscribe = null;
+    }
     this.cache.clear();
     this.statusListeners.clear();
+    this.remoteLoads.clear();
   }
   // ─── Status ─────────────────────────────────────────────
   get status() {
@@ -156,12 +1269,12 @@ var MainThreadBridge = class {
     return this.store.list(options);
   }
 };
-function createMainThreadBridge(store) {
-  return new MainThreadBridge(store);
+function createMainThreadBridge(store, options) {
+  return new MainThreadBridge(store, options);
 }
 
 // src/worker-bridge.ts
-import { wrap, proxy } from "comlink";
+import { wrap, proxy, transfer } from "comlink";
 import { Awareness } from "y-protocols/awareness";
 import * as Y from "yjs";
 
@@ -435,8 +1548,10 @@ var WorkerBridge = class {
   remote;
   cache = new QueryCache();
   subscriptions = /* @__PURE__ */ new Map();
-  queryCounter = 0;
+  activeRemoteSubscriptions = /* @__PURE__ */ new Set();
   statusListeners = /* @__PURE__ */ new Set();
+  changeListeners = /* @__PURE__ */ new Set();
+  changeFeedStarted = false;
   _status = "connecting";
   initialized = false;
   // Mirror Y.Docs on the main thread (for TipTap binding)
@@ -447,13 +1562,21 @@ var WorkerBridge = class {
   }
   /**
    * Initialize the bridge and underlying worker.
+   *
+   * When `config.storagePort` is provided (a MessagePort connected to the
+   * SQLite worker), it is transferred to the data worker so storage calls
+   * run worker-to-worker without a main-thread hop.
    */
   async initialize(config) {
-    await this.remote.initialize({
+    const workerConfig = {
       dbName: config.dbName ?? "xnet",
       authorDID: config.authorDID,
-      signingKey: Array.from(config.signingKey)
-    });
+      signingKey: Array.from(config.signingKey),
+      ...config.storagePort ? { storagePort: config.storagePort } : {}
+    };
+    await this.remote.initialize(
+      config.storagePort ? transfer(workerConfig, [config.storagePort]) : workerConfig
+    );
     this.remote.onStatusChange(
       proxy((status) => {
         this._status = status;
@@ -467,15 +1590,16 @@ var WorkerBridge = class {
   }
   // ─── 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);
+    const descriptor = createQueryDescriptor(schema._schemaId, options);
+    const queryId = serializeQueryDescriptor(descriptor);
+    this.cache.initEntry(queryId, descriptor);
+    if (this.initialized && !this.activeRemoteSubscriptions.has(queryId)) {
+      this.activeRemoteSubscriptions.add(queryId);
+      void this.startWorkerSubscription(queryId, descriptor);
     }
     return {
       getSnapshot: () => this.cache.get(queryId),
+      getMetadata: () => this.cache.getMetadata(queryId),
       subscribe: (callback) => {
         const subs = this.subscriptions.get(queryId) ?? /* @__PURE__ */ new Set();
         subs.add(callback);
@@ -486,26 +1610,62 @@ var WorkerBridge = class {
           unsubCache();
           if (subs.size === 0) {
             this.subscriptions.delete(queryId);
-            this.remote.unsubscribe(queryId).catch(console.error);
+            if (this.activeRemoteSubscriptions.delete(queryId)) {
+              this.remote.unsubscribe(queryId).catch(console.error);
+            }
           }
         };
       }
     };
   }
-  async startWorkerSubscription(queryId, schemaId, options) {
+  async reloadQuery(descriptor) {
+    if (!this.initialized) {
+      throw new Error("WorkerBridge not initialized");
+    }
+    const queryId = serializeQueryDescriptor(descriptor);
+    if (!this.activeRemoteSubscriptions.has(queryId)) {
+      this.cache.initEntry(queryId, descriptor);
+      this.activeRemoteSubscriptions.add(queryId);
+      await this.startWorkerSubscription(queryId, descriptor);
+      return;
+    }
+    const data = decodeWorkerQuerySnapshot(await this.remote.reloadQuery(queryId));
+    this.cache.set(
+      queryId,
+      data,
+      descriptor,
+      void 0,
+      createQuerySnapshotMetadata({ descriptor, nodes: data, source: "memory" })
+    );
+  }
+  async startWorkerSubscription(queryId, descriptor) {
     try {
-      const initial = await this.remote.subscribe(
+      const snapshot = await this.remote.subscribe(
         queryId,
-        schemaId,
-        options,
+        descriptor.schemaId,
+        this.serializeOptions(queryDescriptorToOptions(descriptor)),
         proxy((delta) => {
           this.applyDelta(queryId, delta);
         })
       );
-      this.cache.set(queryId, initial, schemaId, options);
+      const initial = decodeWorkerQuerySnapshot(snapshot);
+      this.cache.set(
+        queryId,
+        initial,
+        descriptor,
+        void 0,
+        createQuerySnapshotMetadata({ descriptor, nodes: initial, source: "memory" })
+      );
     } catch (err) {
       console.error("[WorkerBridge] Failed to subscribe:", err);
-      this.cache.set(queryId, [], schemaId, options);
+      this.activeRemoteSubscriptions.delete(queryId);
+      this.cache.set(
+        queryId,
+        [],
+        descriptor,
+        void 0,
+        createQuerySnapshotMetadata({ descriptor, nodes: [], source: "memory" })
+      );
     }
   }
   applyDelta(queryId, delta) {
@@ -521,12 +1681,15 @@ var WorkerBridge = class {
       case "update":
         updated = current.map((n) => n.id === delta.nodeId ? delta.node : n);
         break;
+      case "reload":
+        updated = delta.data;
+        break;
     }
-    const schemaId = this.cache.getSchemaId(queryId);
+    const descriptor = this.cache.getDescriptor(queryId);
     const options = this.cache.getOptions(queryId);
-    if (schemaId && options) {
+    if (descriptor && options) {
       updated = this.cache.sortNodes(updated, options);
-      this.cache.set(queryId, updated, schemaId, options);
+      this.cache.set(queryId, updated, descriptor);
     }
   }
   serializeOptions(options) {
@@ -537,7 +1700,13 @@ var WorkerBridge = class {
       includeDeleted: options.includeDeleted,
       orderBy: options.orderBy,
       limit: options.limit,
-      offset: options.offset
+      offset: options.offset,
+      page: options.page,
+      spatial: options.spatial,
+      search: options.search,
+      materializedView: options.materializedView,
+      mode: options.mode,
+      source: options.source
     };
   }
   // ─── Mutations ───────────────────────────────────────────────────────────────
@@ -565,6 +1734,44 @@ var WorkerBridge = class {
     }
     return this.remote.restore(nodeId);
   }
+  async bulkWrite(input) {
+    if (!this.initialized) {
+      throw new Error("WorkerBridge not initialized");
+    }
+    return this.remote.bulkWrite(input);
+  }
+  async transaction(operations) {
+    if (!this.initialized) {
+      throw new Error("WorkerBridge not initialized");
+    }
+    return this.remote.transaction(operations);
+  }
+  // ─── Change Feed ─────────────────────────────────────────────────────────────
+  /**
+   * Subscribe to the worker's store change feed (devtools and other
+   * instrumentation). A single proxied forwarder is registered with the
+   * worker on first use; events fan out to local listeners from there.
+   */
+  subscribeToChanges(listener) {
+    this.changeListeners.add(listener);
+    if (!this.changeFeedStarted) {
+      this.changeFeedStarted = true;
+      this.remote.subscribeToChanges(
+        proxy((event) => {
+          for (const handler of this.changeListeners) {
+            try {
+              handler(event);
+            } catch (err) {
+              console.error("[WorkerBridge] Change listener error:", err);
+            }
+          }
+        })
+      );
+    }
+    return () => {
+      this.changeListeners.delete(listener);
+    };
+  }
   // ─── Documents ────────────────────────────────────────────────────────────────
   /**
    * Acquire a Y.Doc for editing.
@@ -582,6 +1789,7 @@ var WorkerBridge = class {
     }
     const existing = this.mirrorDocs.get(nodeId);
     if (existing) {
+      existing.refCount += 1;
       return {
         doc: existing.doc,
         awareness: existing.awareness
@@ -621,6 +1829,7 @@ var WorkerBridge = class {
     const entry = {
       doc: mirrorDoc,
       awareness,
+      refCount: 1,
       applyingRemote: false,
       updateBatcher,
       cleanup: () => {
@@ -643,6 +1852,10 @@ var WorkerBridge = class {
   releaseDoc(nodeId) {
     const entry = this.mirrorDocs.get(nodeId);
     if (!entry) return;
+    entry.refCount = Math.max(0, entry.refCount - 1);
+    if (entry.refCount > 0) {
+      return;
+    }
     entry.cleanup();
     entry.doc.destroy();
     this.mirrorDocs.delete(nodeId);
@@ -660,6 +1873,8 @@ var WorkerBridge = class {
     this.cache.clear();
     this.subscriptions.clear();
     this.statusListeners.clear();
+    this.changeListeners.clear();
+    this.changeFeedStarted = false;
     this.initialized = false;
     this._status = "disconnected";
   }
@@ -682,199 +1897,6 @@ 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";
@@ -882,6 +1904,9 @@ function isWorkerSupported() {
 function isNodeEnvironment() {
   return typeof process !== "undefined" && process.versions?.node !== void 0;
 }
+function getDefaultDataWorkerUrl() {
+  return new URL("./worker/data-worker.js", import.meta.url);
+}
 async function createDataBridge(options) {
   const { nodeStore, config, workerUrl, mode = "auto" } = options;
   const useWorker = mode === "worker" || mode === "auto" && workerUrl && isWorkerSupported() && !isNodeEnvironment();
@@ -892,355 +1917,90 @@ async function createDataBridge(options) {
     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);
+    const bridge2 = new WorkerBridge(workerUrl);
+    await bridge2.initialize(config);
+    return bridge2;
+  }
+  const bridge = new MainThreadBridge(nodeStore, {
+    remoteNodeQueryClient: config.remoteNodeQueryClient,
+    remoteNodeQueryRouting: config.remoteNodeQueryRouting
+  });
+  await bridge.initialize(config);
+  return bridge;
 }
-function createMainThreadBridgeSync(nodeStore) {
-  return new MainThreadBridge(nodeStore);
+function createMainThreadBridgeSync(nodeStore, options) {
+  return new MainThreadBridge(nodeStore, options);
 }
 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 {
+  BOUNDED_QUERY_OVERFETCH,
+  DEFAULT_NODE_QUERY_ROUTER_THRESHOLDS,
   MainThreadBridge,
   NativeBridge,
   NodeStateDecoder,
   NodeStateEncoder,
+  PortSQLiteAdapter,
   QueryCache,
+  REMOTE_NODE_QUERY_PROTOCOL,
+  REMOTE_NODE_QUERY_PROTOCOL_VERSION,
   WorkerBridge,
+  applyNodeChangeToBoundedQueryResult,
+  applyNodeChangeToQueryResult,
+  applyQueryDescriptor,
+  createBoundedWorkingSet,
+  createBoundedWorkingSetDescriptor,
   createDataBridge,
   createDeltaBatcher,
   createMainThreadBridge,
   createMainThreadBridgeSync,
   createNativeBridge,
+  createQueryDescriptor,
+  createQueryErrorMetadata,
+  createQueryMetadata,
+  createQueryRoutingMetadata,
+  createQuerySnapshotMetadata,
+  createQueryStreamState,
+  createRemoteFallbackMetadata,
+  createRemoteNodeQueryRequest,
+  createRemoteSuccessMetadata,
   createUpdateBatcher,
   createWorkerBridge,
   createWorkerBridgeSync,
   debounce,
   decodeNodeStates,
+  decodeQueryCursor,
+  decodeWorkerQuerySnapshot,
   encodeNodeStates,
+  encodeQueryCursor,
+  encodeWorkerQuerySnapshot,
+  filterQueryNodes,
+  filterRemoteNodesByVerification,
+  getDefaultDataWorkerUrl,
+  getRemoteQueryMode,
+  getRemoteQuerySource,
   isExpo,
   isNodeEnvironment,
   isReactNative,
+  isRemoteNodeQueryError,
+  isRemoteNodeQuerySource,
+  isRemoteNodeQuerySuccess,
+  isRemoteVerificationFailed,
   isWorkerSupported,
-  shouldUseBinaryEncoding
+  matchesQueryDescriptor,
+  mergeRemoteNodeSnapshots,
+  normalizeNodeQueryRouterThresholds,
+  queryDescriptorNeedsBoundedReload,
+  queryDescriptorSupportsBoundedDelta,
+  queryDescriptorToOptions,
+  reduceQueryStreamEvent,
+  reduceQueryStreamEvents,
+  routeRemoteNodeQuery,
+  serializeQueryDescriptor,
+  shouldRunRemoteQuery,
+  shouldUseBinaryEncoding,
+  shouldUseRemoteOnlyQuery,
+  sortQueryNodes,
+  withRemoteErrorVerificationMetadata
 };