@foretag/tanstack-db-surrealdb 0.3.1 → 0.3.3

package/dist/index.mjs

@@ -1,1790 +1,8 @@
-// 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
-import { deepEquals } from "@tanstack/db";
-
-// node_modules/@tanstack/query-db-collection/dist/esm/errors.js
-import { TanStackDBError } from "@tanstack/db";
-var QueryCollectionError = class extends 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 (!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
-import { extractFieldPath, extractSimpleComparisons, extractValue, parseLoadSubsetOptions, parseOrderByExpression, parseWhereExpression, walkExpression } from "@tanstack/db";
+import { queryCollectionOptions } from '@tanstack/query-db-collection';
+import { LoroDoc } from 'loro-crdt';
+import { RecordId, Features, Table, and, eq } from 'surrealdb';
 
 // src/index.ts
-import { LoroDoc } from "loro-crdt";
-import { Features as Features2, RecordId } from "surrealdb";
-
-// src/table.ts
-import {
-  and,
-  eq,
-  Features,
-  Table
-} from "surrealdb";
 var normalizeFields = (raw) => {
   if (!raw || raw === "*") return ["*"];
   return raw;
@@ -1893,21 +111,14 @@ function manageTable(db, useLoro, { name, ...args }) {
 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 () => {
+  if (typeof res === "function") return res;
+  const cleanup = res.cleanup ?? res.unsubscribe ?? res.dispose;
+  return typeof cleanup === "function" ? cleanup : () => {
   };
 }
+function hasLoadSubset(res) {
+  return typeof res === "object" && res !== null && "loadSubset" in res;
+}
 function surrealCollectionOptions({
   id,
   useLoro = false,
@@ -1949,8 +160,7 @@ function surrealCollectionOptions({
         out.push(s);
         continue;
       }
-      const lDeleted = (l.sync_deleted ?? false) === true;
-      if (lDeleted) continue;
+      if ((l.sync_deleted ?? false) === true) continue;
       out.push(l);
     }
     return out;
@@ -2019,22 +229,35 @@ function surrealCollectionOptions({
   const baseSync = base.sync?.sync;
   const sync = baseSync ? {
     sync: (ctx) => {
-      const offBase = baseSync(ctx);
-      if (!db.isFeatureSupported(Features2.LiveQueries))
-        return offBase;
+      const baseRes = baseSync(ctx);
+      const baseCleanup = toCleanup(baseRes);
+      if (!db.isFeatureSupported(Features.LiveQueries)) {
+        return baseRes;
+      }
       const offLive = table.subscribe((evt) => {
         if (useLoro) {
-          if (evt.type === "delete")
+          if (evt.type === "delete") {
             loroRemove(getKey(evt.row));
-          else loroPut(evt.row);
+          } else {
+            loroPut(evt.row);
+          }
         }
         void queryClient.invalidateQueries({ queryKey, exact: false }).catch((e) => onError?.(e));
       });
-      const baseCleanup = toCleanup(baseSync(ctx));
-      return () => {
+      if (hasLoadSubset(baseRes)) {
+        const resObj = baseRes;
+        return {
+          ...resObj,
+          cleanup: () => {
+            offLive();
+            baseCleanup();
+          }
+        };
+      }
+      return (() => {
         offLive();
         baseCleanup();
-      };
+      });
     }
   } : void 0;
   return {
@@ -2042,6 +265,7 @@ function surrealCollectionOptions({
     sync: sync ?? base.sync
   };
 }
-export {
-  surrealCollectionOptions
-};
+
+export { surrealCollectionOptions };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map