@foretag/tanstack-db-surrealdb 0.3.0 → 0.3.1

package/dist/index.js

@@ -22,106 +22,1831 @@ __export(index_exports, {
   surrealCollectionOptions: () => surrealCollectionOptions
 });
 module.exports = __toCommonJS(index_exports);
+
+// node_modules/@tanstack/query-core/build/modern/subscribable.js
+var Subscribable = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    this.onSubscribe();
+    return () => {
+      this.listeners.delete(listener);
+      this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+};
+
+// node_modules/@tanstack/query-core/build/modern/timeoutManager.js
+var defaultTimeoutProvider = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (callback, delay) => setTimeout(callback, delay),
+  clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+  setInterval: (callback, delay) => setInterval(callback, delay),
+  clearInterval: (intervalId) => clearInterval(intervalId)
+};
+var TimeoutManager = class {
+  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+  // type at app boot; and if we leave that type, then any new timer provider
+  // would need to support ReturnType<typeof setTimeout>, which is infeasible.
+  //
+  // We settle for type safety for the TimeoutProvider type, and accept that
+  // this class is unsafe internally to allow for extension.
+  #provider = defaultTimeoutProvider;
+  #providerCalled = false;
+  setTimeoutProvider(provider) {
+    if (process.env.NODE_ENV !== "production") {
+      if (this.#providerCalled && provider !== this.#provider) {
+        console.error(
+          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
+          { previous: this.#provider, provider }
+        );
+      }
+    }
+    this.#provider = provider;
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = false;
+    }
+  }
+  setTimeout(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = true;
+    }
+    return this.#provider.setTimeout(callback, delay);
+  }
+  clearTimeout(timeoutId) {
+    this.#provider.clearTimeout(timeoutId);
+  }
+  setInterval(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = true;
+    }
+    return this.#provider.setInterval(callback, delay);
+  }
+  clearInterval(intervalId) {
+    this.#provider.clearInterval(intervalId);
+  }
+};
+var timeoutManager = new TimeoutManager();
+function systemSetTimeoutZero(callback) {
+  setTimeout(callback, 0);
+}
+
+// node_modules/@tanstack/query-core/build/modern/utils.js
+var isServer = typeof window === "undefined" || "Deno" in globalThis;
+function noop() {
+}
+function isValidTimeout(value) {
+  return typeof value === "number" && value >= 0 && value !== Infinity;
+}
+function timeUntilStale(updatedAt, staleTime) {
+  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function resolveStaleTime(staleTime, query) {
+  return typeof staleTime === "function" ? staleTime(query) : staleTime;
+}
+function resolveEnabled(enabled, query) {
+  return typeof enabled === "function" ? enabled(query) : enabled;
+}
+function hashKey(queryKey) {
+  return JSON.stringify(
+    queryKey,
+    (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+      result[key] = val[key];
+      return result;
+    }, {}) : val
+  );
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(a, b) {
+  if (a === b) {
+    return a;
+  }
+  const array = isPlainArray(a) && isPlainArray(b);
+  if (!array && !(isPlainObject(a) && isPlainObject(b))) return b;
+  const aItems = array ? a : Object.keys(a);
+  const aSize = aItems.length;
+  const bItems = array ? b : Object.keys(b);
+  const bSize = bItems.length;
+  const copy = array ? new Array(bSize) : {};
+  let equalItems = 0;
+  for (let i = 0; i < bSize; i++) {
+    const key = array ? i : bItems[i];
+    const aItem = a[key];
+    const bItem = b[key];
+    if (aItem === bItem) {
+      copy[key] = aItem;
+      if (array ? i < aSize : hasOwn.call(a, key)) equalItems++;
+      continue;
+    }
+    if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
+      copy[key] = bItem;
+      continue;
+    }
+    const v = replaceEqualDeep(aItem, bItem);
+    copy[key] = v;
+    if (v === aItem) equalItems++;
+  }
+  return aSize === bSize && equalItems === aSize ? a : copy;
+}
+function shallowEqualObjects(a, b) {
+  if (!b || Object.keys(a).length !== Object.keys(b).length) {
+    return false;
+  }
+  for (const key in a) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  }
+  const ctor = o.constructor;
+  if (ctor === void 0) {
+    return true;
+  }
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot)) {
+    return false;
+  }
+  if (!prot.hasOwnProperty("isPrototypeOf")) {
+    return false;
+  }
+  if (Object.getPrototypeOf(o) !== Object.prototype) {
+    return false;
+  }
+  return true;
+}
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function replaceData(prevData, data, options) {
+  if (typeof options.structuralSharing === "function") {
+    return options.structuralSharing(prevData, data);
+  } else if (options.structuralSharing !== false) {
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        return replaceEqualDeep(prevData, data);
+      } catch (error) {
+        console.error(
+          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`
+        );
+        throw error;
+      }
+    }
+    return replaceEqualDeep(prevData, data);
+  }
+  return data;
+}
+var skipToken = Symbol();
+
+// node_modules/@tanstack/query-core/build/modern/focusManager.js
+var FocusManager = class extends Subscribable {
+  #focused;
+  #cleanup;
+  #setup;
+  constructor() {
+    super();
+    this.#setup = (onFocus) => {
+      if (!isServer && window.addEventListener) {
+        const listener = () => onFocus();
+        window.addEventListener("visibilitychange", listener, false);
+        return () => {
+          window.removeEventListener("visibilitychange", listener);
+        };
+      }
+      return;
+    };
+  }
+  onSubscribe() {
+    if (!this.#cleanup) {
+      this.setEventListener(this.#setup);
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.#cleanup?.();
+      this.#cleanup = void 0;
+    }
+  }
+  setEventListener(setup) {
+    this.#setup = setup;
+    this.#cleanup?.();
+    this.#cleanup = setup((focused) => {
+      if (typeof focused === "boolean") {
+        this.setFocused(focused);
+      } else {
+        this.onFocus();
+      }
+    });
+  }
+  setFocused(focused) {
+    const changed = this.#focused !== focused;
+    if (changed) {
+      this.#focused = focused;
+      this.onFocus();
+    }
+  }
+  onFocus() {
+    const isFocused = this.isFocused();
+    this.listeners.forEach((listener) => {
+      listener(isFocused);
+    });
+  }
+  isFocused() {
+    if (typeof this.#focused === "boolean") {
+      return this.#focused;
+    }
+    return globalThis.document?.visibilityState !== "hidden";
+  }
+};
+var focusManager = new FocusManager();
+
+// node_modules/@tanstack/query-core/build/modern/thenable.js
+function pendingThenable() {
+  let resolve;
+  let reject;
+  const thenable = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  thenable.status = "pending";
+  thenable.catch(() => {
+  });
+  function finalize(data) {
+    Object.assign(thenable, data);
+    delete thenable.resolve;
+    delete thenable.reject;
+  }
+  thenable.resolve = (value) => {
+    finalize({
+      status: "fulfilled",
+      value
+    });
+    resolve(value);
+  };
+  thenable.reject = (reason) => {
+    finalize({
+      status: "rejected",
+      reason
+    });
+    reject(reason);
+  };
+  return thenable;
+}
+
+// node_modules/@tanstack/query-core/build/modern/notifyManager.js
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+  let queue = [];
+  let transactions = 0;
+  let notifyFn = (callback) => {
+    callback();
+  };
+  let batchNotifyFn = (callback) => {
+    callback();
+  };
+  let scheduleFn = defaultScheduler;
+  const schedule = (callback) => {
+    if (transactions) {
+      queue.push(callback);
+    } else {
+      scheduleFn(() => {
+        notifyFn(callback);
+      });
+    }
+  };
+  const flush = () => {
+    const originalQueue = queue;
+    queue = [];
+    if (originalQueue.length) {
+      scheduleFn(() => {
+        batchNotifyFn(() => {
+          originalQueue.forEach((callback) => {
+            notifyFn(callback);
+          });
+        });
+      });
+    }
+  };
+  return {
+    batch: (callback) => {
+      let result;
+      transactions++;
+      try {
+        result = callback();
+      } finally {
+        transactions--;
+        if (!transactions) {
+          flush();
+        }
+      }
+      return result;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (callback) => {
+      return (...args) => {
+        schedule(() => {
+          callback(...args);
+        });
+      };
+    },
+    schedule,
+    /**
+     * Use this method to set a custom notify function.
+     * This can be used to for example wrap notifications with `React.act` while running tests.
+     */
+    setNotifyFunction: (fn) => {
+      notifyFn = fn;
+    },
+    /**
+     * Use this method to set a custom function to batch notifications together into a single tick.
+     * By default React Query will use the batch function provided by ReactDOM or React Native.
+     */
+    setBatchNotifyFunction: (fn) => {
+      batchNotifyFn = fn;
+    },
+    setScheduler: (fn) => {
+      scheduleFn = fn;
+    }
+  };
+}
+var notifyManager = createNotifyManager();
+
+// node_modules/@tanstack/query-core/build/modern/onlineManager.js
+var OnlineManager = class extends Subscribable {
+  #online = true;
+  #cleanup;
+  #setup;
+  constructor() {
+    super();
+    this.#setup = (onOnline) => {
+      if (!isServer && window.addEventListener) {
+        const onlineListener = () => onOnline(true);
+        const offlineListener = () => onOnline(false);
+        window.addEventListener("online", onlineListener, false);
+        window.addEventListener("offline", offlineListener, false);
+        return () => {
+          window.removeEventListener("online", onlineListener);
+          window.removeEventListener("offline", offlineListener);
+        };
+      }
+      return;
+    };
+  }
+  onSubscribe() {
+    if (!this.#cleanup) {
+      this.setEventListener(this.#setup);
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.#cleanup?.();
+      this.#cleanup = void 0;
+    }
+  }
+  setEventListener(setup) {
+    this.#setup = setup;
+    this.#cleanup?.();
+    this.#cleanup = setup(this.setOnline.bind(this));
+  }
+  setOnline(online) {
+    const changed = this.#online !== online;
+    if (changed) {
+      this.#online = online;
+      this.listeners.forEach((listener) => {
+        listener(online);
+      });
+    }
+  }
+  isOnline() {
+    return this.#online;
+  }
+};
+var onlineManager = new OnlineManager();
+
+// node_modules/@tanstack/query-core/build/modern/retryer.js
+function canFetch(networkMode) {
+  return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
+}
+
+// node_modules/@tanstack/query-core/build/modern/query.js
+function fetchState(data, options) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
+    ...data === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+
+// node_modules/@tanstack/query-core/build/modern/queryObserver.js
+var QueryObserver = class extends Subscribable {
+  constructor(client, options) {
+    super();
+    this.options = options;
+    this.#client = client;
+    this.#selectError = null;
+    this.#currentThenable = pendingThenable();
+    this.bindMethods();
+    this.setOptions(options);
+  }
+  #client;
+  #currentQuery = void 0;
+  #currentQueryInitialState = void 0;
+  #currentResult = void 0;
+  #currentResultState;
+  #currentResultOptions;
+  #currentThenable;
+  #selectError;
+  #selectFn;
+  #selectResult;
+  // This property keeps track of the last query with defined data.
+  // It will be used to pass the previous data and query to the placeholder function between renders.
+  #lastQueryWithDefinedData;
+  #staleTimeoutId;
+  #refetchIntervalId;
+  #currentRefetchInterval;
+  #trackedProps = /* @__PURE__ */ new Set();
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    if (this.listeners.size === 1) {
+      this.#currentQuery.addObserver(this);
+      if (shouldFetchOnMount(this.#currentQuery, this.options)) {
+        this.#executeFetch();
+      } else {
+        this.updateResult();
+      }
+      this.#updateTimers();
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.destroy();
+    }
+  }
+  shouldFetchOnReconnect() {
+    return shouldFetchOn(
+      this.#currentQuery,
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return shouldFetchOn(
+      this.#currentQuery,
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.#clearStaleTimeout();
+    this.#clearRefetchInterval();
+    this.#currentQuery.removeObserver(this);
+  }
+  setOptions(options) {
+    const prevOptions = this.options;
+    const prevQuery = this.#currentQuery;
+    this.options = this.#client.defaultQueryOptions(options);
+    if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, this.#currentQuery) !== "boolean") {
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    }
+    this.#updateQuery();
+    this.#currentQuery.setOptions(this.options);
+    if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
+      this.#client.getQueryCache().notify({
+        type: "observerOptionsUpdated",
+        query: this.#currentQuery,
+        observer: this
+      });
+    }
+    const mounted = this.hasListeners();
+    if (mounted && shouldFetchOptionally(
+      this.#currentQuery,
+      prevQuery,
+      this.options,
+      prevOptions
+    )) {
+      this.#executeFetch();
+    }
+    this.updateResult();
+    if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || resolveStaleTime(this.options.staleTime, this.#currentQuery) !== resolveStaleTime(prevOptions.staleTime, this.#currentQuery))) {
+      this.#updateStaleTimeout();
+    }
+    const nextRefetchInterval = this.#computeRefetchInterval();
+    if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) {
+      this.#updateRefetchInterval(nextRefetchInterval);
+    }
+  }
+  getOptimisticResult(options) {
+    const query = this.#client.getQueryCache().build(this.#client, options);
+    const result = this.createResult(query, options);
+    if (shouldAssignObserverCurrentProperties(this, result)) {
+      this.#currentResult = result;
+      this.#currentResultOptions = this.options;
+      this.#currentResultState = this.#currentQuery.state;
+    }
+    return result;
+  }
+  getCurrentResult() {
+    return this.#currentResult;
+  }
+  trackResult(result, onPropTracked) {
+    return new Proxy(result, {
+      get: (target, key) => {
+        this.trackProp(key);
+        onPropTracked?.(key);
+        if (key === "promise") {
+          this.trackProp("data");
+          if (!this.options.experimental_prefetchInRender && this.#currentThenable.status === "pending") {
+            this.#currentThenable.reject(
+              new Error(
+                "experimental_prefetchInRender feature flag is not enabled"
+              )
+            );
+          }
+        }
+        return Reflect.get(target, key);
+      }
+    });
+  }
+  trackProp(key) {
+    this.#trackedProps.add(key);
+  }
+  getCurrentQuery() {
+    return this.#currentQuery;
+  }
+  refetch({ ...options } = {}) {
+    return this.fetch({
+      ...options
+    });
+  }
+  fetchOptimistic(options) {
+    const defaultedOptions = this.#client.defaultQueryOptions(options);
+    const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
+    return query.fetch().then(() => this.createResult(query, defaultedOptions));
+  }
+  fetch(fetchOptions) {
+    return this.#executeFetch({
+      ...fetchOptions,
+      cancelRefetch: fetchOptions.cancelRefetch ?? true
+    }).then(() => {
+      this.updateResult();
+      return this.#currentResult;
+    });
+  }
+  #executeFetch(fetchOptions) {
+    this.#updateQuery();
+    let promise = this.#currentQuery.fetch(
+      this.options,
+      fetchOptions
+    );
+    if (!fetchOptions?.throwOnError) {
+      promise = promise.catch(noop);
+    }
+    return promise;
+  }
+  #updateStaleTimeout() {
+    this.#clearStaleTimeout();
+    const staleTime = resolveStaleTime(
+      this.options.staleTime,
+      this.#currentQuery
+    );
+    if (isServer || this.#currentResult.isStale || !isValidTimeout(staleTime)) {
+      return;
+    }
+    const time = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime);
+    const timeout = time + 1;
+    this.#staleTimeoutId = timeoutManager.setTimeout(() => {
+      if (!this.#currentResult.isStale) {
+        this.updateResult();
+      }
+    }, timeout);
+  }
+  #computeRefetchInterval() {
+    return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false;
+  }
+  #updateRefetchInterval(nextInterval) {
+    this.#clearRefetchInterval();
+    this.#currentRefetchInterval = nextInterval;
+    if (isServer || resolveEnabled(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {
+      return;
+    }
+    this.#refetchIntervalId = timeoutManager.setInterval(() => {
+      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
+        this.#executeFetch();
+      }
+    }, this.#currentRefetchInterval);
+  }
+  #updateTimers() {
+    this.#updateStaleTimeout();
+    this.#updateRefetchInterval(this.#computeRefetchInterval());
+  }
+  #clearStaleTimeout() {
+    if (this.#staleTimeoutId) {
+      timeoutManager.clearTimeout(this.#staleTimeoutId);
+      this.#staleTimeoutId = void 0;
+    }
+  }
+  #clearRefetchInterval() {
+    if (this.#refetchIntervalId) {
+      timeoutManager.clearInterval(this.#refetchIntervalId);
+      this.#refetchIntervalId = void 0;
+    }
+  }
+  createResult(query, options) {
+    const prevQuery = this.#currentQuery;
+    const prevOptions = this.options;
+    const prevResult = this.#currentResult;
+    const prevResultState = this.#currentResultState;
+    const prevResultOptions = this.#currentResultOptions;
+    const queryChange = query !== prevQuery;
+    const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
+    const { state } = query;
+    let newState = { ...state };
+    let isPlaceholderData = false;
+    let data;
+    if (options._optimisticResults) {
+      const mounted = this.hasListeners();
+      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
+      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
+      if (fetchOnMount || fetchOptionally) {
+        newState = {
+          ...newState,
+          ...fetchState(state.data, query.options)
+        };
+      }
+      if (options._optimisticResults === "isRestoring") {
+        newState.fetchStatus = "idle";
+      }
+    }
+    let { error, errorUpdatedAt, status } = newState;
+    data = newState.data;
+    let skipSelect = false;
+    if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
+      let placeholderData;
+      if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
+        placeholderData = prevResult.data;
+        skipSelect = true;
+      } else {
+        placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(
+          this.#lastQueryWithDefinedData?.state.data,
+          this.#lastQueryWithDefinedData
+        ) : options.placeholderData;
+      }
+      if (placeholderData !== void 0) {
+        status = "success";
+        data = replaceData(
+          prevResult?.data,
+          placeholderData,
+          options
+        );
+        isPlaceholderData = true;
+      }
+    }
+    if (options.select && data !== void 0 && !skipSelect) {
+      if (prevResult && data === prevResultState?.data && options.select === this.#selectFn) {
+        data = this.#selectResult;
+      } else {
+        try {
+          this.#selectFn = options.select;
+          data = options.select(data);
+          data = replaceData(prevResult?.data, data, options);
+          this.#selectResult = data;
+          this.#selectError = null;
+        } catch (selectError) {
+          this.#selectError = selectError;
+        }
+      }
+    }
+    if (this.#selectError) {
+      error = this.#selectError;
+      data = this.#selectResult;
+      errorUpdatedAt = Date.now();
+      status = "error";
+    }
+    const isFetching = newState.fetchStatus === "fetching";
+    const isPending = status === "pending";
+    const isError = status === "error";
+    const isLoading = isPending && isFetching;
+    const hasData = data !== void 0;
+    const result = {
+      status,
+      fetchStatus: newState.fetchStatus,
+      isPending,
+      isSuccess: status === "success",
+      isError,
+      isInitialLoading: isLoading,
+      isLoading,
+      data,
+      dataUpdatedAt: newState.dataUpdatedAt,
+      error,
+      errorUpdatedAt,
+      failureCount: newState.fetchFailureCount,
+      failureReason: newState.fetchFailureReason,
+      errorUpdateCount: newState.errorUpdateCount,
+      isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,
+      isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
+      isFetching,
+      isRefetching: isFetching && !isPending,
+      isLoadingError: isError && !hasData,
+      isPaused: newState.fetchStatus === "paused",
+      isPlaceholderData,
+      isRefetchError: isError && hasData,
+      isStale: isStale(query, options),
+      refetch: this.refetch,
+      promise: this.#currentThenable,
+      isEnabled: resolveEnabled(options.enabled, query) !== false
+    };
+    const nextResult = result;
+    if (this.options.experimental_prefetchInRender) {
+      const finalizeThenableIfPossible = (thenable) => {
+        if (nextResult.status === "error") {
+          thenable.reject(nextResult.error);
+        } else if (nextResult.data !== void 0) {
+          thenable.resolve(nextResult.data);
+        }
+      };
+      const recreateThenable = () => {
+        const pending = this.#currentThenable = nextResult.promise = pendingThenable();
+        finalizeThenableIfPossible(pending);
+      };
+      const prevThenable = this.#currentThenable;
+      switch (prevThenable.status) {
+        case "pending":
+          if (query.queryHash === prevQuery.queryHash) {
+            finalizeThenableIfPossible(prevThenable);
+          }
+          break;
+        case "fulfilled":
+          if (nextResult.status === "error" || nextResult.data !== prevThenable.value) {
+            recreateThenable();
+          }
+          break;
+        case "rejected":
+          if (nextResult.status !== "error" || nextResult.error !== prevThenable.reason) {
+            recreateThenable();
+          }
+          break;
+      }
+    }
+    return nextResult;
+  }
+  updateResult() {
+    const prevResult = this.#currentResult;
+    const nextResult = this.createResult(this.#currentQuery, this.options);
+    this.#currentResultState = this.#currentQuery.state;
+    this.#currentResultOptions = this.options;
+    if (this.#currentResultState.data !== void 0) {
+      this.#lastQueryWithDefinedData = this.#currentQuery;
+    }
+    if (shallowEqualObjects(nextResult, prevResult)) {
+      return;
+    }
+    this.#currentResult = nextResult;
+    const shouldNotifyListeners = () => {
+      if (!prevResult) {
+        return true;
+      }
+      const { notifyOnChangeProps } = this.options;
+      const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
+      if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !this.#trackedProps.size) {
+        return true;
+      }
+      const includedProps = new Set(
+        notifyOnChangePropsValue ?? this.#trackedProps
+      );
+      if (this.options.throwOnError) {
+        includedProps.add("error");
+      }
+      return Object.keys(this.#currentResult).some((key) => {
+        const typedKey = key;
+        const changed = this.#currentResult[typedKey] !== prevResult[typedKey];
+        return changed && includedProps.has(typedKey);
+      });
+    };
+    this.#notify({ listeners: shouldNotifyListeners() });
+  }
+  #updateQuery() {
+    const query = this.#client.getQueryCache().build(this.#client, this.options);
+    if (query === this.#currentQuery) {
+      return;
+    }
+    const prevQuery = this.#currentQuery;
+    this.#currentQuery = query;
+    this.#currentQueryInitialState = query.state;
+    if (this.hasListeners()) {
+      prevQuery?.removeObserver(this);
+      query.addObserver(this);
+    }
+  }
+  onQueryUpdate() {
+    this.updateResult();
+    if (this.hasListeners()) {
+      this.#updateTimers();
+    }
+  }
+  #notify(notifyOptions) {
+    notifyManager.batch(() => {
+      if (notifyOptions.listeners) {
+        this.listeners.forEach((listener) => {
+          listener(this.#currentResult);
+        });
+      }
+      this.#client.getQueryCache().notify({
+        query: this.#currentQuery,
+        type: "observerResultsUpdated"
+      });
+    });
+  }
+};
+function shouldLoadOnMount(query, options) {
+  return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false);
+}
+function shouldFetchOnMount(query, options) {
+  return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
+}
+function shouldFetchOn(query, options, field) {
+  if (resolveEnabled(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
+    const value = typeof field === "function" ? field(query) : field;
+    return value === "always" || value !== false && isStale(query, options);
+  }
+  return false;
+}
+function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
+  return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+}
+function isStale(query, options) {
+  return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
+}
+function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
+  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+    return true;
+  }
+  return false;
+}
+
+// node_modules/@tanstack/query-db-collection/dist/esm/query.js
+var import_db2 = require("@tanstack/db");
+
+// node_modules/@tanstack/query-db-collection/dist/esm/errors.js
+var import_db = require("@tanstack/db");
+var QueryCollectionError = class extends import_db.TanStackDBError {
+  constructor(message) {
+    super(message);
+    this.name = `QueryCollectionError`;
+  }
+};
+var QueryKeyRequiredError = class extends QueryCollectionError {
+  constructor() {
+    super(`[QueryCollection] queryKey must be provided.`);
+    this.name = `QueryKeyRequiredError`;
+  }
+};
+var QueryFnRequiredError = class extends QueryCollectionError {
+  constructor() {
+    super(`[QueryCollection] queryFn must be provided.`);
+    this.name = `QueryFnRequiredError`;
+  }
+};
+var QueryClientRequiredError = class extends QueryCollectionError {
+  constructor() {
+    super(`[QueryCollection] queryClient must be provided.`);
+    this.name = `QueryClientRequiredError`;
+  }
+};
+var GetKeyRequiredError = class extends QueryCollectionError {
+  constructor() {
+    super(`[QueryCollection] getKey must be provided.`);
+    this.name = `GetKeyRequiredError`;
+  }
+};
+var SyncNotInitializedError = class extends QueryCollectionError {
+  constructor() {
+    super(
+      `Collection must be in 'ready' state for manual sync operations. Sync not initialized yet.`
+    );
+    this.name = `SyncNotInitializedError`;
+  }
+};
+var DuplicateKeyInBatchError = class extends QueryCollectionError {
+  constructor(key) {
+    super(`Duplicate key '${key}' found within batch operations`);
+    this.name = `DuplicateKeyInBatchError`;
+  }
+};
+var UpdateOperationItemNotFoundError = class extends QueryCollectionError {
+  constructor(key) {
+    super(`Update operation: Item with key '${key}' does not exist`);
+    this.name = `UpdateOperationItemNotFoundError`;
+  }
+};
+var DeleteOperationItemNotFoundError = class extends QueryCollectionError {
+  constructor(key) {
+    super(`Delete operation: Item with key '${key}' does not exist`);
+    this.name = `DeleteOperationItemNotFoundError`;
+  }
+};
+
+// node_modules/@tanstack/query-db-collection/dist/esm/manual-sync.js
+var activeBatchContexts = /* @__PURE__ */ new WeakMap();
+function normalizeOperations(ops, ctx) {
+  const operations = Array.isArray(ops) ? ops : [ops];
+  const normalized = [];
+  for (const op of operations) {
+    if (op.type === `delete`) {
+      const keys = Array.isArray(op.key) ? op.key : [op.key];
+      for (const key of keys) {
+        normalized.push({ type: `delete`, key });
+      }
+    } else {
+      const items = Array.isArray(op.data) ? op.data : [op.data];
+      for (const item of items) {
+        let key;
+        if (op.type === `update`) {
+          key = ctx.getKey(item);
+        } else {
+          const resolved = ctx.collection.validateData(
+            item,
+            op.type === `upsert` ? `insert` : op.type
+          );
+          key = ctx.getKey(resolved);
+        }
+        normalized.push({ type: op.type, key, data: item });
+      }
+    }
+  }
+  return normalized;
+}
+function validateOperations(operations, ctx) {
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const op of operations) {
+    if (seenKeys.has(op.key)) {
+      throw new DuplicateKeyInBatchError(op.key);
+    }
+    seenKeys.add(op.key);
+    if (op.type === `update`) {
+      if (!ctx.collection._state.syncedData.has(op.key)) {
+        throw new UpdateOperationItemNotFoundError(op.key);
+      }
+    } else if (op.type === `delete`) {
+      if (!ctx.collection._state.syncedData.has(op.key)) {
+        throw new DeleteOperationItemNotFoundError(op.key);
+      }
+    }
+  }
+}
+function performWriteOperations(operations, ctx) {
+  const normalized = normalizeOperations(operations, ctx);
+  validateOperations(normalized, ctx);
+  ctx.begin();
+  for (const op of normalized) {
+    switch (op.type) {
+      case `insert`: {
+        const resolved = ctx.collection.validateData(op.data, `insert`);
+        ctx.write({
+          type: `insert`,
+          value: resolved
+        });
+        break;
+      }
+      case `update`: {
+        const currentItem = ctx.collection._state.syncedData.get(op.key);
+        const updatedItem = {
+          ...currentItem,
+          ...op.data
+        };
+        const resolved = ctx.collection.validateData(
+          updatedItem,
+          `update`,
+          op.key
+        );
+        ctx.write({
+          type: `update`,
+          value: resolved
+        });
+        break;
+      }
+      case `delete`: {
+        const currentItem = ctx.collection._state.syncedData.get(op.key);
+        ctx.write({
+          type: `delete`,
+          value: currentItem
+        });
+        break;
+      }
+      case `upsert`: {
+        const existsInSyncedStore = ctx.collection._state.syncedData.has(op.key);
+        const resolved = ctx.collection.validateData(
+          op.data,
+          existsInSyncedStore ? `update` : `insert`,
+          op.key
+        );
+        if (existsInSyncedStore) {
+          ctx.write({
+            type: `update`,
+            value: resolved
+          });
+        } else {
+          ctx.write({
+            type: `insert`,
+            value: resolved
+          });
+        }
+        break;
+      }
+    }
+  }
+  ctx.commit();
+  const updatedData = Array.from(ctx.collection._state.syncedData.values());
+  if (ctx.updateCacheData) {
+    ctx.updateCacheData(updatedData);
+  } else {
+    ctx.queryClient.setQueryData(ctx.queryKey, updatedData);
+  }
+}
+function createWriteUtils(getContext) {
+  function ensureContext() {
+    const context = getContext();
+    if (!context) {
+      throw new SyncNotInitializedError();
+    }
+    return context;
+  }
+  return {
+    writeInsert(data) {
+      const operation = {
+        type: `insert`,
+        data
+      };
+      const ctx = ensureContext();
+      const batchContext = activeBatchContexts.get(ctx);
+      if (batchContext?.isActive) {
+        batchContext.operations.push(operation);
+        return;
+      }
+      performWriteOperations(operation, ctx);
+    },
+    writeUpdate(data) {
+      const operation = {
+        type: `update`,
+        data
+      };
+      const ctx = ensureContext();
+      const batchContext = activeBatchContexts.get(ctx);
+      if (batchContext?.isActive) {
+        batchContext.operations.push(operation);
+        return;
+      }
+      performWriteOperations(operation, ctx);
+    },
+    writeDelete(key) {
+      const operation = {
+        type: `delete`,
+        key
+      };
+      const ctx = ensureContext();
+      const batchContext = activeBatchContexts.get(ctx);
+      if (batchContext?.isActive) {
+        batchContext.operations.push(operation);
+        return;
+      }
+      performWriteOperations(operation, ctx);
+    },
+    writeUpsert(data) {
+      const operation = {
+        type: `upsert`,
+        data
+      };
+      const ctx = ensureContext();
+      const batchContext = activeBatchContexts.get(ctx);
+      if (batchContext?.isActive) {
+        batchContext.operations.push(operation);
+        return;
+      }
+      performWriteOperations(operation, ctx);
+    },
+    writeBatch(callback) {
+      const ctx = ensureContext();
+      const existingBatch = activeBatchContexts.get(ctx);
+      if (existingBatch?.isActive) {
+        throw new Error(
+          `Cannot nest writeBatch calls. Complete the current batch before starting a new one.`
+        );
+      }
+      const batchContext = {
+        operations: [],
+        isActive: true
+      };
+      activeBatchContexts.set(ctx, batchContext);
+      try {
+        const result = callback();
+        if (
+          // @ts-expect-error - Runtime check for async callback, callback is typed as () => void but user might pass async
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          result && typeof result === `object` && `then` in result && // @ts-expect-error - Runtime check for async callback, callback is typed as () => void but user might pass async
+          typeof result.then === `function`
+        ) {
+          throw new Error(
+            `writeBatch does not support async callbacks. The callback must be synchronous.`
+          );
+        }
+        if (batchContext.operations.length > 0) {
+          performWriteOperations(batchContext.operations, ctx);
+        }
+      } finally {
+        batchContext.isActive = false;
+        activeBatchContexts.delete(ctx);
+      }
+    }
+  };
+}
+
+// node_modules/@tanstack/query-db-collection/dist/esm/serialization.js
+function serializeLoadSubsetOptions(options) {
+  if (!options) {
+    return void 0;
+  }
+  const result = {};
+  if (options.where) {
+    result.where = serializeExpression(options.where);
+  }
+  if (options.orderBy?.length) {
+    result.orderBy = options.orderBy.map((clause) => {
+      const baseOrderBy = {
+        expression: serializeExpression(clause.expression),
+        direction: clause.compareOptions.direction,
+        nulls: clause.compareOptions.nulls,
+        stringSort: clause.compareOptions.stringSort
+      };
+      if (clause.compareOptions.stringSort === `locale`) {
+        return {
+          ...baseOrderBy,
+          locale: clause.compareOptions.locale,
+          localeOptions: clause.compareOptions.localeOptions
+        };
+      }
+      return baseOrderBy;
+    });
+  }
+  if (options.limit !== void 0) {
+    result.limit = options.limit;
+  }
+  if (options.offset !== void 0) {
+    result.offset = options.offset;
+  }
+  return Object.keys(result).length === 0 ? void 0 : JSON.stringify(result);
+}
+function serializeExpression(expr) {
+  if (!expr) {
+    return null;
+  }
+  switch (expr.type) {
+    case `val`:
+      return {
+        type: `val`,
+        value: serializeValue(expr.value)
+      };
+    case `ref`:
+      return {
+        type: `ref`,
+        path: [...expr.path]
+      };
+    case `func`:
+      return {
+        type: `func`,
+        name: expr.name,
+        args: expr.args.map((arg) => serializeExpression(arg))
+      };
+    default:
+      return null;
+  }
+}
+function serializeValue(value) {
+  if (value === void 0) {
+    return { __type: `undefined` };
+  }
+  if (typeof value === `number`) {
+    if (Number.isNaN(value)) {
+      return { __type: `nan` };
+    }
+    if (value === Number.POSITIVE_INFINITY) {
+      return { __type: `infinity`, sign: 1 };
+    }
+    if (value === Number.NEGATIVE_INFINITY) {
+      return { __type: `infinity`, sign: -1 };
+    }
+  }
+  if (value === null || typeof value === `string` || typeof value === `number` || typeof value === `boolean`) {
+    return value;
+  }
+  if (value instanceof Date) {
+    return { __type: `date`, value: value.toJSON() };
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeValue(item));
+  }
+  if (typeof value === `object`) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [
+        key,
+        serializeValue(val)
+      ])
+    );
+  }
+  return value;
+}
+
+// node_modules/@tanstack/query-db-collection/dist/esm/query.js
+var QueryCollectionUtilsImpl = class {
+  constructor(state, refetch, writeUtils) {
+    this.state = state;
+    this.refetchFn = refetch;
+    this.refetch = refetch;
+    this.writeInsert = writeUtils.writeInsert;
+    this.writeUpdate = writeUtils.writeUpdate;
+    this.writeDelete = writeUtils.writeDelete;
+    this.writeUpsert = writeUtils.writeUpsert;
+    this.writeBatch = writeUtils.writeBatch;
+  }
+  async clearError() {
+    this.state.lastError = void 0;
+    this.state.errorCount = 0;
+    this.state.lastErrorUpdatedAt = 0;
+    await this.refetchFn({ throwOnError: true });
+  }
+  // Getters for error state
+  get lastError() {
+    return this.state.lastError;
+  }
+  get isError() {
+    return !!this.state.lastError;
+  }
+  get errorCount() {
+    return this.state.errorCount;
+  }
+  // Getters for QueryObserver state
+  get isFetching() {
+    return Array.from(this.state.observers.values()).some(
+      (observer) => observer.getCurrentResult().isFetching
+    );
+  }
+  get isRefetching() {
+    return Array.from(this.state.observers.values()).some(
+      (observer) => observer.getCurrentResult().isRefetching
+    );
+  }
+  get isLoading() {
+    return Array.from(this.state.observers.values()).some(
+      (observer) => observer.getCurrentResult().isLoading
+    );
+  }
+  get dataUpdatedAt() {
+    return Math.max(
+      0,
+      ...Array.from(this.state.observers.values()).map(
+        (observer) => observer.getCurrentResult().dataUpdatedAt
+      )
+    );
+  }
+  get fetchStatus() {
+    return Array.from(this.state.observers.values()).map(
+      (observer) => observer.getCurrentResult().fetchStatus
+    );
+  }
+};
+function queryCollectionOptions(config) {
+  const {
+    queryKey,
+    queryFn,
+    select,
+    queryClient,
+    enabled,
+    refetchInterval,
+    retry,
+    retryDelay,
+    staleTime,
+    getKey,
+    onInsert,
+    onUpdate,
+    onDelete,
+    meta,
+    ...baseCollectionConfig
+  } = config;
+  const syncMode = baseCollectionConfig.syncMode ?? `eager`;
+  if (!queryKey) {
+    throw new QueryKeyRequiredError();
+  }
+  if (!queryFn) {
+    throw new QueryFnRequiredError();
+  }
+  if (!queryClient) {
+    throw new QueryClientRequiredError();
+  }
+  if (!getKey) {
+    throw new GetKeyRequiredError();
+  }
+  const state = {
+    lastError: void 0,
+    errorCount: 0,
+    lastErrorUpdatedAt: 0,
+    observers: /* @__PURE__ */ new Map()
+  };
+  const hashToQueryKey = /* @__PURE__ */ new Map();
+  const queryToRows = /* @__PURE__ */ new Map();
+  const rowToQueries = /* @__PURE__ */ new Map();
+  const unsubscribes = /* @__PURE__ */ new Map();
+  const queryRefCounts = /* @__PURE__ */ new Map();
+  const addRow = (rowKey, hashedQueryKey) => {
+    const rowToQueriesSet = rowToQueries.get(rowKey) || /* @__PURE__ */ new Set();
+    rowToQueriesSet.add(hashedQueryKey);
+    rowToQueries.set(rowKey, rowToQueriesSet);
+    const queryToRowsSet = queryToRows.get(hashedQueryKey) || /* @__PURE__ */ new Set();
+    queryToRowsSet.add(rowKey);
+    queryToRows.set(hashedQueryKey, queryToRowsSet);
+  };
+  const removeRow = (rowKey, hashedQuerKey) => {
+    const rowToQueriesSet = rowToQueries.get(rowKey) || /* @__PURE__ */ new Set();
+    rowToQueriesSet.delete(hashedQuerKey);
+    rowToQueries.set(rowKey, rowToQueriesSet);
+    const queryToRowsSet = queryToRows.get(hashedQuerKey) || /* @__PURE__ */ new Set();
+    queryToRowsSet.delete(rowKey);
+    queryToRows.set(hashedQuerKey, queryToRowsSet);
+    return rowToQueriesSet.size === 0;
+  };
+  const internalSync = (params) => {
+    const { begin, write, commit, markReady, collection } = params;
+    let syncStarted = false;
+    const generateQueryKeyFromOptions = (opts) => {
+      if (typeof queryKey === `function`) {
+        return queryKey(opts);
+      } else if (syncMode === `on-demand`) {
+        const serialized = serializeLoadSubsetOptions(opts);
+        return serialized !== void 0 ? [...queryKey, serialized] : queryKey;
+      } else {
+        return queryKey;
+      }
+    };
+    const createQueryFromOpts = (opts = {}, queryFunction = queryFn) => {
+      const key = generateQueryKeyFromOptions(opts);
+      const hashedQueryKey = hashKey(key);
+      const extendedMeta = { ...meta, loadSubsetOptions: opts };
+      if (state.observers.has(hashedQueryKey)) {
+        queryRefCounts.set(
+          hashedQueryKey,
+          (queryRefCounts.get(hashedQueryKey) || 0) + 1
+        );
+        const observer = state.observers.get(hashedQueryKey);
+        const currentResult = observer.getCurrentResult();
+        if (currentResult.isSuccess) {
+          return true;
+        } else if (currentResult.isError) {
+          return Promise.reject(currentResult.error);
+        } else {
+          return new Promise((resolve, reject) => {
+            const unsubscribe = observer.subscribe((result) => {
+              queueMicrotask(() => {
+                if (result.isSuccess) {
+                  unsubscribe();
+                  resolve();
+                } else if (result.isError) {
+                  unsubscribe();
+                  reject(result.error);
+                }
+              });
+            });
+          });
+        }
+      }
+      const observerOptions = {
+        queryKey: key,
+        queryFn: queryFunction,
+        meta: extendedMeta,
+        structuralSharing: true,
+        notifyOnChangeProps: `all`,
+        // Only include options that are explicitly defined to allow QueryClient defaultOptions to be used
+        ...enabled !== void 0 && { enabled },
+        ...refetchInterval !== void 0 && { refetchInterval },
+        ...retry !== void 0 && { retry },
+        ...retryDelay !== void 0 && { retryDelay },
+        ...staleTime !== void 0 && { staleTime }
+      };
+      const localObserver = new QueryObserver(queryClient, observerOptions);
+      hashToQueryKey.set(hashedQueryKey, key);
+      state.observers.set(hashedQueryKey, localObserver);
+      queryRefCounts.set(
+        hashedQueryKey,
+        (queryRefCounts.get(hashedQueryKey) || 0) + 1
+      );
+      const readyPromise = new Promise((resolve, reject) => {
+        const unsubscribe = localObserver.subscribe((result) => {
+          queueMicrotask(() => {
+            if (result.isSuccess) {
+              unsubscribe();
+              resolve();
+            } else if (result.isError) {
+              unsubscribe();
+              reject(result.error);
+            }
+          });
+        });
+      });
+      if (syncStarted || collection.subscriberCount > 0) {
+        subscribeToQuery(localObserver, hashedQueryKey);
+      }
+      return readyPromise;
+    };
+    const makeQueryResultHandler = (queryKey2) => {
+      const hashedQueryKey = hashKey(queryKey2);
+      const handleQueryResult = (result) => {
+        if (result.isSuccess) {
+          state.lastError = void 0;
+          state.errorCount = 0;
+          const rawData = result.data;
+          const newItemsArray = select ? select(rawData) : rawData;
+          if (!Array.isArray(newItemsArray) || newItemsArray.some((item) => typeof item !== `object`)) {
+            const errorMessage = select ? `@tanstack/query-db-collection: select() must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey2)}` : `@tanstack/query-db-collection: queryFn must return an array of objects. Got: ${typeof newItemsArray} for queryKey ${JSON.stringify(queryKey2)}`;
+            console.error(errorMessage);
+            return;
+          }
+          const currentSyncedItems = new Map(
+            collection._state.syncedData.entries()
+          );
+          const newItemsMap = /* @__PURE__ */ new Map();
+          newItemsArray.forEach((item) => {
+            const key = getKey(item);
+            newItemsMap.set(key, item);
+          });
+          begin();
+          currentSyncedItems.forEach((oldItem, key) => {
+            const newItem = newItemsMap.get(key);
+            if (!newItem) {
+              const needToRemove = removeRow(key, hashedQueryKey);
+              if (needToRemove) {
+                write({ type: `delete`, value: oldItem });
+              }
+            } else if (!(0, import_db2.deepEquals)(oldItem, newItem)) {
+              write({ type: `update`, value: newItem });
+            }
+          });
+          newItemsMap.forEach((newItem, key) => {
+            addRow(key, hashedQueryKey);
+            if (!currentSyncedItems.has(key)) {
+              write({ type: `insert`, value: newItem });
+            }
+          });
+          commit();
+          markReady();
+        } else if (result.isError) {
+          if (result.errorUpdatedAt !== state.lastErrorUpdatedAt) {
+            state.lastError = result.error;
+            state.errorCount++;
+            state.lastErrorUpdatedAt = result.errorUpdatedAt;
+          }
+          console.error(
+            `[QueryCollection] Error observing query ${String(queryKey2)}:`,
+            result.error
+          );
+          markReady();
+        }
+      };
+      return handleQueryResult;
+    };
+    const isSubscribed = (hashedQueryKey) => {
+      return unsubscribes.has(hashedQueryKey);
+    };
+    const subscribeToQuery = (observer, hashedQueryKey) => {
+      if (!isSubscribed(hashedQueryKey)) {
+        const cachedQueryKey = hashToQueryKey.get(hashedQueryKey);
+        const handleQueryResult = makeQueryResultHandler(cachedQueryKey);
+        const unsubscribeFn = observer.subscribe(handleQueryResult);
+        unsubscribes.set(hashedQueryKey, unsubscribeFn);
+        const currentResult = observer.getCurrentResult();
+        if (currentResult.isSuccess || currentResult.isError) {
+          handleQueryResult(currentResult);
+        }
+      }
+    };
+    const subscribeToQueries = () => {
+      state.observers.forEach(subscribeToQuery);
+    };
+    const unsubscribeFromQueries = () => {
+      unsubscribes.forEach((unsubscribeFn) => {
+        unsubscribeFn();
+      });
+      unsubscribes.clear();
+    };
+    syncStarted = true;
+    const unsubscribeFromCollectionEvents = collection.on(
+      `subscribers:change`,
+      ({ subscriberCount }) => {
+        if (subscriberCount > 0) {
+          subscribeToQueries();
+        } else if (subscriberCount === 0) {
+          unsubscribeFromQueries();
+        }
+      }
+    );
+    if (syncMode === `eager`) {
+      const initialResult = createQueryFromOpts({});
+      if (initialResult instanceof Promise) {
+        initialResult.catch(() => {
+        });
+      }
+    } else {
+      markReady();
+    }
+    subscribeToQueries();
+    state.observers.forEach((observer, hashedQueryKey) => {
+      const cachedQueryKey = hashToQueryKey.get(hashedQueryKey);
+      const handleQueryResult = makeQueryResultHandler(cachedQueryKey);
+      handleQueryResult(observer.getCurrentResult());
+    });
+    const cleanupQueryInternal = (hashedQueryKey) => {
+      unsubscribes.get(hashedQueryKey)?.();
+      unsubscribes.delete(hashedQueryKey);
+      const rowKeys = queryToRows.get(hashedQueryKey) ?? /* @__PURE__ */ new Set();
+      const rowsToDelete = [];
+      rowKeys.forEach((rowKey) => {
+        const queries = rowToQueries.get(rowKey);
+        if (!queries) {
+          return;
+        }
+        queries.delete(hashedQueryKey);
+        if (queries.size === 0) {
+          rowToQueries.delete(rowKey);
+          if (collection.has(rowKey)) {
+            rowsToDelete.push(collection.get(rowKey));
+          }
+        }
+      });
+      if (rowsToDelete.length > 0) {
+        begin();
+        rowsToDelete.forEach((row) => {
+          write({ type: `delete`, value: row });
+        });
+        commit();
+      }
+      state.observers.delete(hashedQueryKey);
+      queryToRows.delete(hashedQueryKey);
+      hashToQueryKey.delete(hashedQueryKey);
+      queryRefCounts.delete(hashedQueryKey);
+    };
+    const cleanupQueryIfIdle = (hashedQueryKey) => {
+      const refcount = queryRefCounts.get(hashedQueryKey) || 0;
+      const observer = state.observers.get(hashedQueryKey);
+      if (refcount <= 0) {
+        unsubscribes.get(hashedQueryKey)?.();
+        unsubscribes.delete(hashedQueryKey);
+      }
+      const hasListeners = observer?.hasListeners() ?? false;
+      if (hasListeners) {
+        queryRefCounts.set(hashedQueryKey, 0);
+        return;
+      }
+      if (refcount > 0) {
+        console.warn(
+          `[cleanupQueryIfIdle] Invariant violation: refcount=${refcount} but no listeners. Cleaning up to prevent leak.`,
+          { hashedQueryKey }
+        );
+      }
+      cleanupQueryInternal(hashedQueryKey);
+    };
+    const forceCleanupQuery = (hashedQueryKey) => {
+      cleanupQueryInternal(hashedQueryKey);
+    };
+    const unsubscribeQueryCache = queryClient.getQueryCache().subscribe((event) => {
+      const hashedKey = event.query.queryHash;
+      if (event.type === `removed`) {
+        if (hashToQueryKey.has(hashedKey)) {
+          cleanupQueryIfIdle(hashedKey);
+        }
+      }
+    });
+    const cleanup = async () => {
+      unsubscribeFromCollectionEvents();
+      unsubscribeFromQueries();
+      const allQueryKeys = [...hashToQueryKey.values()];
+      const allHashedKeys = [...state.observers.keys()];
+      for (const hashedKey of allHashedKeys) {
+        forceCleanupQuery(hashedKey);
+      }
+      unsubscribeQueryCache();
+      await Promise.all(
+        allQueryKeys.map(async (qKey) => {
+          await queryClient.cancelQueries({ queryKey: qKey, exact: true });
+          queryClient.removeQueries({ queryKey: qKey, exact: true });
+        })
+      );
+    };
+    const unloadSubset = (options) => {
+      const key = generateQueryKeyFromOptions(options);
+      const hashedQueryKey = hashKey(key);
+      const currentCount = queryRefCounts.get(hashedQueryKey) || 0;
+      const newCount = currentCount - 1;
+      if (newCount <= 0) {
+        queryRefCounts.set(hashedQueryKey, 0);
+        cleanupQueryIfIdle(hashedQueryKey);
+      } else {
+        queryRefCounts.set(hashedQueryKey, newCount);
+      }
+    };
+    const loadSubsetDedupe = syncMode === `eager` ? void 0 : createQueryFromOpts;
+    return {
+      loadSubset: loadSubsetDedupe,
+      unloadSubset: syncMode === `eager` ? void 0 : unloadSubset,
+      cleanup
+    };
+  };
+  const refetch = async (opts) => {
+    const allQueryKeys = [...hashToQueryKey.values()];
+    const refetchPromises = allQueryKeys.map((qKey) => {
+      const queryObserver = state.observers.get(hashKey(qKey));
+      return queryObserver.refetch({
+        throwOnError: opts?.throwOnError
+      });
+    });
+    await Promise.all(refetchPromises);
+  };
+  const updateCacheData = (items) => {
+    const key = typeof queryKey === `function` ? queryKey({}) : queryKey;
+    if (select) {
+      queryClient.setQueryData(key, (oldData) => {
+        if (!oldData || typeof oldData !== `object`) {
+          return oldData;
+        }
+        if (Array.isArray(oldData)) {
+          return items;
+        }
+        const selectedArray = select(oldData);
+        if (Array.isArray(selectedArray)) {
+          for (const propKey of Object.keys(oldData)) {
+            if (oldData[propKey] === selectedArray) {
+              return { ...oldData, [propKey]: items };
+            }
+          }
+        }
+        if (Array.isArray(oldData.data)) {
+          return { ...oldData, data: items };
+        }
+        if (Array.isArray(oldData.items)) {
+          return { ...oldData, items };
+        }
+        if (Array.isArray(oldData.results)) {
+          return { ...oldData, results: items };
+        }
+        for (const propKey of Object.keys(oldData)) {
+          if (Array.isArray(oldData[propKey])) {
+            return { ...oldData, [propKey]: items };
+          }
+        }
+        return oldData;
+      });
+    } else {
+      queryClient.setQueryData(key, items);
+    }
+  };
+  let writeContext = null;
+  const enhancedInternalSync = (params) => {
+    const { begin, write, commit, collection } = params;
+    const contextQueryKey = typeof queryKey === `function` ? queryKey({}) : queryKey;
+    writeContext = {
+      collection,
+      queryClient,
+      queryKey: contextQueryKey,
+      getKey,
+      begin,
+      write,
+      commit,
+      updateCacheData
+    };
+    return internalSync(params);
+  };
+  const writeUtils = createWriteUtils(
+    () => writeContext
+  );
+  const wrappedOnInsert = onInsert ? async (params) => {
+    const handlerResult = await onInsert(params) ?? {};
+    const shouldRefetch = handlerResult.refetch !== false;
+    if (shouldRefetch) {
+      await refetch();
+    }
+    return handlerResult;
+  } : void 0;
+  const wrappedOnUpdate = onUpdate ? async (params) => {
+    const handlerResult = await onUpdate(params) ?? {};
+    const shouldRefetch = handlerResult.refetch !== false;
+    if (shouldRefetch) {
+      await refetch();
+    }
+    return handlerResult;
+  } : void 0;
+  const wrappedOnDelete = onDelete ? async (params) => {
+    const handlerResult = await onDelete(params) ?? {};
+    const shouldRefetch = handlerResult.refetch !== false;
+    if (shouldRefetch) {
+      await refetch();
+    }
+    return handlerResult;
+  } : void 0;
+  const utils = new QueryCollectionUtilsImpl(state, refetch, writeUtils);
+  return {
+    ...baseCollectionConfig,
+    getKey,
+    syncMode,
+    sync: { sync: enhancedInternalSync },
+    onInsert: wrappedOnInsert,
+    onUpdate: wrappedOnUpdate,
+    onDelete: wrappedOnDelete,
+    utils
+  };
+}
+
+// node_modules/@tanstack/query-db-collection/dist/esm/index.js
+var import_db3 = require("@tanstack/db");
+
+// src/index.ts
 var import_loro_crdt = require("loro-crdt");
 var import_surrealdb2 = require("surrealdb");
 
 // src/table.ts
 var import_surrealdb = require("surrealdb");
-function manageTable(db, useLoro, { name, ...args }, syncMode = "eager") {
-  const rawFields = args.fields ?? "*";
-  const fields = rawFields === "*" ? ["*"] : [...rawFields];
-  const cache = /* @__PURE__ */ new Map();
-  let fullyLoaded = false;
-  const pageSize = args.pageSize ?? 100;
-  const initialPageSize = args.initialPageSize ?? Math.min(50, pageSize);
-  let cursor = 0;
-  let progressiveTask = null;
-  const idKey = (id) => typeof id === "string" ? id : id.toString();
-  const upsertCache = (rows) => {
-    for (const row of rows) cache.set(idKey(row.id), row);
-  };
-  const removeFromCache = (id) => {
-    cache.delete(idKey(id));
-  };
-  const listCached = () => Array.from(cache.values());
-  const buildWhere = () => {
+var normalizeFields = (raw) => {
+  if (!raw || raw === "*") return ["*"];
+  return raw;
+};
+var joinOrderBy = (o) => {
+  if (!o) return void 0;
+  return typeof o === "string" ? o : o.join(", ");
+};
+function manageTable(db, useLoro, { name, ...args }) {
+  const fields = normalizeFields(args.fields);
+  const baseWhere = () => {
     if (!useLoro) return args.where;
-    return args.where ? (0, import_surrealdb.and)(args.where, (0, import_surrealdb.eq)("sync_deleted", false)) : (0, import_surrealdb.eq)("sync_deleted", false);
-  };
-  const buildQuery = () => {
-    let q = db.select(new import_surrealdb.Table(name));
-    const cond = buildWhere();
-    if (cond) q = q.where(cond);
-    return q;
-  };
-  const applyPaging = (q, start, limit) => {
-    if (typeof start === "number" && q.start) q = q.start(start);
-    if (typeof limit === "number" && q.limit) q = q.limit(limit);
-    return q;
-  };
-  const fetchAll = async () => {
-    const rows = await buildQuery().fields(...fields);
-    upsertCache(rows);
-    fullyLoaded = true;
-    return rows;
-  };
-  const fetchPage = async (opts) => {
-    const q = applyPaging(
-      buildQuery(),
-      opts?.start ?? 0,
-      opts?.limit ?? pageSize
-    );
-    const rows = await q.fields(...fields);
-    upsertCache(rows);
-    if (rows.length < (opts?.limit ?? pageSize)) fullyLoaded = true;
-    return rows;
-  };
-  const fetchById = async (id) => {
-    const key = idKey(id);
-    const cached = cache.get(key);
-    if (cached) return cached;
-    const res = await db.select(id);
-    const row = Array.isArray(res) ? res[0] : res;
-    if (!row) return null;
-    if (useLoro && row.sync_deleted)
-      return null;
-    cache.set(key, row);
-    return row;
-  };
-  const loadMore = async (limit = pageSize) => {
-    if (fullyLoaded) return { rows: [], done: true };
-    const rows = await fetchPage({ start: cursor, limit });
-    cursor += rows.length;
-    const done = fullyLoaded || rows.length < limit;
-    args.onProgress?.({
+    const alive = (0, import_surrealdb.eq)("sync_deleted", false);
+    return args.where ? (0, import_surrealdb.and)(args.where, alive) : alive;
+  };
+  const listAll = async () => {
+    const where = baseWhere();
+    const whereSql = where ? " WHERE $where" : "";
+    const sql = `SELECT ${fields.join(", ")} FROM type::table($table)${whereSql};`;
+    const [res] = await db.query(sql, {
       table: name,
-      loaded: cache.size,
-      lastBatch: rows.length,
-      done
-    });
-    return { rows, done };
-  };
-  const startProgressive = () => {
-    if (progressiveTask || fullyLoaded) return;
-    progressiveTask = (async () => {
-      if (cache.size === 0) await loadMore(initialPageSize);
-      while (!fullyLoaded) {
-        const { done } = await loadMore(pageSize);
-        if (done) break;
-      }
-    })().finally(() => {
-      progressiveTask = null;
+      where
     });
+    return res ?? [];
   };
-  const listAll = () => fetchAll();
-  const listActive = async () => {
-    if (syncMode === "eager") return fetchAll();
-    if (syncMode === "progressive") {
-      if (cache.size === 0) await loadMore(initialPageSize);
-      startProgressive();
-      return listCached();
-    }
-    return listCached();
+  const loadSubset = async (subset) => {
+    const b = baseWhere();
+    const w = subset?.where;
+    const where = b && w ? (0, import_surrealdb.and)(b, w) : b ?? w;
+    const whereSql = where ? " WHERE $where" : "";
+    const order = joinOrderBy(subset?.orderBy);
+    const orderSql = order ? ` ORDER BY ${order}` : "";
+    const limitSql = typeof subset?.limit === "number" ? " LIMIT $limit" : "";
+    const startSql = typeof subset?.offset === "number" ? " START $offset" : "";
+    const sql = `SELECT ${fields.join(", ")} FROM type::table($table)${whereSql}${orderSql}${limitSql}${startSql};`;
+    const [res] = await db.query(sql, {
+      table: name,
+      where,
+      limit: subset?.limit,
+      offset: subset?.offset
+    });
+    return res ?? [];
   };
   const create = async (data) => {
     await db.create(new import_surrealdb.Table(name)).content(data);
@@ -134,24 +1859,21 @@ function manageTable(db, useLoro, { name, ...args }, syncMode = "eager") {
     await db.update(id).merge({
       ...data,
       sync_deleted: false,
-      updated_at: /* @__PURE__ */ new Date()
+      updated_at: Date.now()
     });
   };
   const remove = async (id) => {
     await db.delete(id);
-    removeFromCache(id);
   };
   const softDelete = async (id) => {
     if (!useLoro) {
       await db.delete(id);
-      removeFromCache(id);
       return;
     }
     await db.upsert(id).merge({
       sync_deleted: true,
-      updated_at: /* @__PURE__ */ new Date()
+      updated_at: Date.now()
     });
-    removeFromCache(id);
   };
   const subscribe = (cb) => {
     let killed = false;
@@ -159,25 +1881,10 @@ function manageTable(db, useLoro, { name, ...args }, syncMode = "eager") {
     const on = (msg) => {
       const { action, value } = msg;
       if (action === "KILLED") return;
-      if (action === "CREATE") {
-        upsertCache([value]);
-        cb({ type: "insert", row: value });
-        return;
-      }
-      if (action === "UPDATE") {
-        if (useLoro && value.sync_deleted) {
-          removeFromCache(value.id);
-          cb({ type: "delete", row: { id: value.id } });
-          return;
-        }
-        upsertCache([value]);
-        cb({ type: "update", row: value });
-        return;
-      }
-      if (action === "DELETE") {
-        removeFromCache(value.id);
+      if (action === "CREATE") cb({ type: "insert", row: value });
+      else if (action === "UPDATE") cb({ type: "update", row: value });
+      else if (action === "DELETE")
         cb({ type: "delete", row: { id: value.id } });
-      }
     };
     const start = async () => {
       if (!db.isFeatureSupported(import_surrealdb.Features.LiveQueries)) return;
@@ -193,380 +1900,166 @@ function manageTable(db, useLoro, { name, ...args }, syncMode = "eager") {
   };
   return {
     listAll,
-    listActive,
-    listCached,
-    fetchPage,
-    fetchById,
-    loadMore,
+    loadSubset,
     create,
     update,
     remove,
     softDelete,
-    subscribe,
-    get isFullyLoaded() {
-      return fullyLoaded;
-    },
-    get cachedCount() {
-      return cache.size;
-    }
+    subscribe
   };
 }
 
 // src/index.ts
-var DEFAULT_INITIAL_PAGE_SIZE = 50;
-var LOCAL_ID_VERIFY_CHUNK = 500;
-var stableStringify = (value) => {
-  const toJson = (v) => {
-    if (v === null) return null;
-    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean")
-      return v;
-    if (v instanceof Date) return v.toISOString();
-    if (Array.isArray(v)) return v.map(toJson);
-    if (typeof v === "object") {
-      const o = v;
-      const keys = Object.keys(o).sort();
-      const out = {};
-      for (const k of keys) out[k] = toJson(o[k]);
-      return out;
-    }
-    return String(v);
-  };
-  return JSON.stringify(toJson(value));
-};
-var chunk = (arr, size) => {
-  const out = [];
-  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
-  return out;
-};
+function toCleanup(res) {
+  if (!res) return () => {
+  };
+  if (typeof res === "function") {
+    return res;
+  }
+  if (typeof res === "object" && res !== null) {
+    const r = res;
+    const cleanup = r["cleanup"];
+    if (typeof cleanup === "function") return cleanup;
+    const unsubscribe = r["unsubscribe"];
+    if (typeof unsubscribe === "function") return unsubscribe;
+    const dispose = r["dispose"];
+    if (typeof dispose === "function") return dispose;
+  }
+  return () => {
+  };
+}
 function surrealCollectionOptions({
   id,
   useLoro = false,
   onError,
   db,
-  syncMode,
+  queryClient,
+  queryKey,
+  syncMode = "eager",
   ...config
 }) {
   let loro;
   if (useLoro) loro = { doc: new import_loro_crdt.LoroDoc(), key: id };
+  const table = manageTable(db, useLoro, config.table);
   const keyOf = (rid) => typeof rid === "string" ? rid : rid.toString();
   const getKey = (row) => keyOf(row.id);
   const loroKey = loro?.key ?? id ?? "surreal";
   const loroMap = useLoro ? loro?.doc?.getMap?.(loroKey) ?? null : null;
-  const loroToArray = () => {
-    if (!loroMap) return [];
-    const json = loroMap.toJSON?.() ?? {};
-    return Object.values(json);
-  };
-  const loroPutMany = (rows) => {
-    if (!loroMap || rows.length === 0) return;
-    for (const row of rows) loroMap.set(getKey(row), row);
+  const loroPut = (row) => {
+    if (!loroMap) return;
+    loroMap.set(getKey(row), row);
     loro?.doc?.commit?.();
   };
-  const loroRemoveMany = (ids) => {
-    if (!loroMap || ids.length === 0) return;
-    for (const id2 of ids) loroMap.delete(id2);
+  const loroRemove = (idStr) => {
+    if (!loroMap) return;
+    loroMap.delete(idStr);
     loro?.doc?.commit?.();
   };
-  const loroRemove = (id2) => loroRemoveMany([id2]);
-  const pushQueue = [];
-  const enqueuePush = (op) => {
-    if (!useLoro) return;
-    pushQueue.push(op);
-  };
-  const flushPushQueue = async () => {
-    if (!useLoro) return;
-    const ops = pushQueue.splice(0, pushQueue.length);
-    for (const op of ops) {
-      if (op.kind === "create") {
-        await table.create(op.row);
-      } else if (op.kind === "update") {
-        const rid = new import_surrealdb2.RecordId(
-          config.table.name,
-          op.row.id.toString()
-        );
-        await table.update(rid, op.row);
-      } else {
-        const rid = new import_surrealdb2.RecordId(config.table.name, op.id);
-        await table.softDelete(rid);
-      }
-    }
-  };
-  const newer = (a, b) => (a?.getTime() ?? -1) > (b?.getTime() ?? -1);
-  const fetchServerByLocalIds = async (ids) => {
-    if (ids.length === 0) return [];
-    const tableName = config.table.name;
-    const parts = chunk(ids, LOCAL_ID_VERIFY_CHUNK);
+  const mergeLocalOverServer = (serverRows) => {
+    if (!useLoro || !loroMap) return serverRows;
+    const localJson = loroMap.toJSON?.() ?? {};
+    const localById = new Map(
+      Object.values(localJson).map((r) => [getKey(r), r])
+    );
     const out = [];
-    for (const p of parts) {
-      const [res] = await db.query(
-        "SELECT * FROM type::table($table) WHERE id IN $ids",
-        {
-          table: tableName,
-          ids: p.map((x) => new import_surrealdb2.RecordId(tableName, x))
-        }
-      );
-      if (res) out.push(...res);
-    }
-    return out;
-  };
-  const dedupeById = (rows) => {
-    const m = /* @__PURE__ */ new Map();
-    for (const r of rows) m.set(getKey(r), r);
-    return Array.from(m.values());
-  };
-  let prevById = /* @__PURE__ */ new Map();
-  const buildMap = (rows) => new Map(rows.map((r) => [getKey(r), r]));
-  const same = (a, b) => {
-    if (useLoro) {
-      return (a.sync_deleted ?? false) === (b.sync_deleted ?? false) && (a.updated_at?.getTime() ?? 0) === (b.updated_at?.getTime() ?? 0);
-    }
-    return stableStringify(a) === stableStringify(b);
-  };
-  const diffAndEmit = (currentRows, write) => {
-    const currById = buildMap(currentRows);
-    for (const [id2, row] of currById) {
-      const prev = prevById.get(id2);
-      if (!prev) write({ type: "insert", value: row });
-      else if (!same(prev, row)) write({ type: "update", value: row });
-    }
-    for (const [id2, prev] of prevById) {
-      if (!currById.has(id2)) write({ type: "delete", value: prev });
-    }
-    prevById = currById;
-  };
-  const reconcileBoot = (serverRows, write) => {
-    const localRows = loroToArray();
-    const serverById = new Map(serverRows.map((r) => [getKey(r), r]));
-    const localById = new Map(localRows.map((r) => [getKey(r), r]));
-    const ids = /* @__PURE__ */ new Set([...serverById.keys(), ...localById.keys()]);
-    const current = [];
-    const toRemove = [];
-    const toPut = [];
-    const applyLocal = (row) => {
-      if (!row) return;
-      if (row.sync_deleted) toRemove.push(getKey(row));
-      else toPut.push(row);
-    };
-    for (const id2 of ids) {
-      const s = serverById.get(id2);
-      const l = localById.get(id2);
-      if (s && l) {
-        const sDeleted = s.sync_deleted ?? false;
-        const lDeleted = l.sync_deleted ?? false;
-        const sUpdated = s.updated_at;
-        const lUpdated = l.updated_at;
-        if (sDeleted && lDeleted) {
-          applyLocal(s);
-          current.push(s);
-        } else if (sDeleted && !lDeleted) {
-          applyLocal(s);
-          current.push(s);
-        } else if (!sDeleted && lDeleted) {
-          if (newer(lUpdated, sUpdated)) {
-            enqueuePush({
-              kind: "delete",
-              id: id2,
-              updated_at: lUpdated ?? /* @__PURE__ */ new Date()
-            });
-            applyLocal(l);
-            current.push(l);
-          } else {
-            applyLocal(s);
-            current.push(s);
-          }
-        } else {
-          if (newer(lUpdated, sUpdated)) {
-            enqueuePush({ kind: "update", row: l });
-            applyLocal(l);
-            current.push(l);
-          } else {
-            applyLocal(s);
-            current.push(s);
-          }
-        }
-      } else if (s && !l) {
-        applyLocal(s);
-        current.push(s);
-      } else if (!s && l) {
-        const lDeleted = l.sync_deleted ?? false;
-        const lUpdated = l.updated_at;
-        if (lDeleted) {
-          enqueuePush({
-            kind: "delete",
-            id: id2,
-            updated_at: lUpdated ?? /* @__PURE__ */ new Date()
-          });
-          applyLocal(l);
-          current.push(l);
-        } else {
-          enqueuePush({ kind: "create", row: l });
-          applyLocal(l);
-          current.push(l);
-        }
+    for (const s of serverRows) {
+      const idStr = getKey(s);
+      const l = localById.get(idStr);
+      if (!l) {
+        out.push(s);
+        continue;
       }
+      const lDeleted = (l.sync_deleted ?? false) === true;
+      if (lDeleted) continue;
+      out.push(l);
     }
-    loroRemoveMany(toRemove);
-    loroPutMany(toPut);
-    diffAndEmit(current, write);
+    return out;
   };
-  const table = manageTable(db, useLoro, config.table, syncMode);
-  const now = () => /* @__PURE__ */ new Date();
-  const sync = ({
-    begin,
-    write,
-    commit,
-    markReady
-  }) => {
-    if (!db.isFeatureSupported(import_surrealdb2.Features.LiveQueries)) {
-      markReady();
-      return () => {
-      };
-    }
-    let offLive = null;
-    let work = Promise.resolve();
-    const enqueueWork = (fn) => {
-      work = work.then(fn).catch((e) => onError?.(e));
-      return work;
-    };
-    const makeTombstone = (id2) => ({
-      id: new import_surrealdb2.RecordId(config.table.name, id2).toString(),
-      updated_at: now(),
-      sync_deleted: true
-    });
-    const start = async () => {
+  const base = queryCollectionOptions({
+    getKey: (row) => getKey(row),
+    queryKey,
+    queryClient,
+    syncMode,
+    queryFn: async ({ meta }) => {
       try {
-        let serverRows;
-        if (syncMode === "eager") {
-          serverRows = await table.listAll();
-        } else if (syncMode === "progressive") {
-          const first = await table.loadMore(
-            config.table.initialPageSize ?? DEFAULT_INITIAL_PAGE_SIZE
-          );
-          serverRows = first.rows;
-        } else {
-          serverRows = await table.listActive();
-        }
-        await enqueueWork(async () => {
-          begin();
-          if (useLoro) {
-            const localIds = loroToArray().map(getKey);
-            const verifiedServerRows = syncMode === "eager" ? serverRows : dedupeById([
-              ...serverRows,
-              ...await fetchServerByLocalIds(
-                localIds
-              )
-            ]);
-            reconcileBoot(verifiedServerRows, write);
-          } else {
-            diffAndEmit(serverRows, write);
-          }
-          commit();
-          markReady();
-        });
-        if (syncMode === "progressive") {
-          void (async () => {
-            while (!table.isFullyLoaded) {
-              const { rows } = await table.loadMore();
-              if (rows.length === 0) break;
-              await enqueueWork(async () => {
-                begin();
-                try {
-                  if (useLoro) loroPutMany(rows);
-                  diffAndEmit(rows, write);
-                } finally {
-                  commit();
-                }
-              });
-            }
-          })().catch((e) => onError?.(e));
-        }
-        await flushPushQueue();
-        offLive = table.subscribe((evt) => {
-          void enqueueWork(async () => {
-            begin();
-            try {
-              if (evt.type === "insert" || evt.type === "update") {
-                const row = evt.row;
-                const deleted = useLoro ? row.sync_deleted ?? false : false;
-                if (deleted) {
-                  if (useLoro) loroRemove(getKey(row));
-                  const prev = prevById.get(getKey(row)) ?? makeTombstone(getKey(row));
-                  write({ type: "delete", value: prev });
-                  prevById.delete(getKey(row));
-                } else {
-                  if (useLoro) loroPutMany([row]);
-                  const had = prevById.has(getKey(row));
-                  write({
-                    type: had ? "update" : "insert",
-                    value: row
-                  });
-                  prevById.set(getKey(row), row);
-                }
-              } else {
-                const rid = getKey(evt.row);
-                if (useLoro) loroRemove(rid);
-                const prev = prevById.get(rid) ?? makeTombstone(rid);
-                write({ type: "delete", value: prev });
-                prevById.delete(rid);
-              }
-            } finally {
-              commit();
-            }
-          });
-        });
+        const subset = syncMode === "on-demand" ? meta["surrealSubset"] : void 0;
+        const rows = syncMode === "eager" ? await table.listAll() : await table.loadSubset(subset);
+        return mergeLocalOverServer(rows);
       } catch (e) {
         onError?.(e);
-        markReady();
+        return [];
       }
-    };
-    void start();
-    return () => {
-      if (offLive) offLive();
-    };
-  };
-  const onInsert = async (p) => {
-    const resultRows = [];
-    for (const m of p.transaction.mutations) {
-      if (m.type !== "insert") continue;
-      const base = { ...m.modified };
-      const row = useLoro ? { ...base, updated_at: now(), sync_deleted: false } : base;
-      if (useLoro) loroPutMany([row]);
-      await table.create(row);
-      resultRows.push(row);
-    }
-    return resultRows;
-  };
-  const onUpdate = async (p) => {
-    const resultRows = [];
-    for (const m of p.transaction.mutations) {
-      if (m.type !== "update") continue;
-      const id2 = m.key;
-      const base = { ...m.modified, id: id2 };
-      const merged = useLoro ? { ...base, updated_at: now() } : base;
-      if (useLoro) loroPutMany([merged]);
-      const rid = new import_surrealdb2.RecordId(config.table.name, keyOf(id2));
-      await table.update(rid, merged);
-      resultRows.push(merged);
-    }
-    return resultRows;
-  };
-  const onDelete = async (p) => {
-    const resultRows = [];
-    for (const m of p.transaction.mutations) {
-      if (m.type !== "delete") continue;
-      const id2 = m.key;
-      if (useLoro) loroRemove(keyOf(id2));
-      await table.softDelete(new import_surrealdb2.RecordId(config.table.name, keyOf(id2)));
-    }
-    return resultRows;
-  };
+    },
+    onInsert: (async (p) => {
+      const now = () => /* @__PURE__ */ new Date();
+      const resultRows = [];
+      for (const m of p.transaction.mutations) {
+        if (m.type !== "insert") continue;
+        const baseRow = { ...m.modified };
+        const row = useLoro ? {
+          ...baseRow,
+          updated_at: now(),
+          sync_deleted: false
+        } : baseRow;
+        if (useLoro) loroPut(row);
+        await table.create(row);
+        resultRows.push(row);
+      }
+      return resultRows;
+    }),
+    onUpdate: (async (p) => {
+      const now = () => /* @__PURE__ */ new Date();
+      const resultRows = [];
+      for (const m of p.transaction.mutations) {
+        if (m.type !== "update") continue;
+        const idKey = m.key;
+        const baseRow = { ...m.modified, id: idKey };
+        const row = useLoro ? { ...baseRow, updated_at: now() } : baseRow;
+        if (useLoro) loroPut(row);
+        await table.update(
+          new import_surrealdb2.RecordId(config.table.name, keyOf(idKey)),
+          row
+        );
+        resultRows.push(row);
+      }
+      return resultRows;
+    }),
+    onDelete: (async (p) => {
+      for (const m of p.transaction.mutations) {
+        if (m.type !== "delete") continue;
+        const idKey = m.key;
+        if (useLoro) loroRemove(keyOf(idKey));
+        await table.softDelete(
+          new import_surrealdb2.RecordId(config.table.name, keyOf(idKey))
+        );
+      }
+      return [];
+    })
+  });
+  const baseSync = base.sync?.sync;
+  const sync = baseSync ? {
+    sync: (ctx) => {
+      const offBase = baseSync(ctx);
+      if (!db.isFeatureSupported(import_surrealdb2.Features.LiveQueries))
+        return offBase;
+      const offLive = table.subscribe((evt) => {
+        if (useLoro) {
+          if (evt.type === "delete")
+            loroRemove(getKey(evt.row));
+          else loroPut(evt.row);
+        }
+        void queryClient.invalidateQueries({ queryKey, exact: false }).catch((e) => onError?.(e));
+      });
+      const baseCleanup = toCleanup(baseSync(ctx));
+      return () => {
+        offLive();
+        baseCleanup();
+      };
+    }
+  } : void 0;
   return {
-    id,
-    getKey,
-    sync: { sync },
-    onInsert,
-    onDelete,
-    onUpdate
+    ...base,
+    sync: sync ?? base.sync
   };
 }
 // Annotate the CommonJS export names for ESM import in node: