@scrippsproduct/networks-ui-library 2.0.8 → 2.0.9

package/dist/components/ScheduleLayout/ScheduleContext.js

@@ -1,9 +1,9 @@
-var ve = (e) => {
+var le = (e) => {
   throw TypeError(e);
 };
-var Jt = (e, t, s) => t.has(e) || ve("Cannot " + s);
-var i = (e, t, s) => (Jt(e, t, "read from private field"), s ? s.call(e) : t.get(e)), c = (e, t, s) => t.has(e) ? ve("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, s), o = (e, t, s, r) => (Jt(e, t, "write to private field"), r ? r.call(e, s) : t.set(e, s), s), p = (e, t, s) => (Jt(e, t, "access private method"), s);
-var Gt = (e, t, s, r) => ({
+var Bt = (e, t, s) => t.has(e) || le("Cannot " + s);
+var i = (e, t, s) => (Bt(e, t, "read from private field"), s ? s.call(e) : t.get(e)), c = (e, t, s) => t.has(e) ? le("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, s), o = (e, t, s, r) => (Bt(e, t, "write to private field"), r ? r.call(e, s) : t.set(e, s), s), m = (e, t, s) => (Bt(e, t, "access private method"), s);
+var jt = (e, t, s, r) => ({
   set _(n) {
     o(e, t, n, s);
   },
@@ -11,321 +11,406 @@ var Gt = (e, t, s, r) => ({
     return i(e, t, r);
   }
 });
-import { jsx as zt } from "react/jsx-runtime";
-import * as K from "react";
-import { createContext as Ye, useRef as Le, useState as ge, useCallback as ts, useEffect as be, useMemo as es } from "react";
-import { f as Zt } from "../../format-YhWt2D8M.mjs";
-import { l as Bt } from "../../logger-C0N7U0YY.mjs";
-var kt = class {
-  constructor() {
-    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
-  }
-  subscribe(e) {
-    return this.listeners.add(e), this.onSubscribe(), () => {
-      this.listeners.delete(e), this.onUnsubscribe();
-    };
-  }
-  hasListeners() {
-    return this.listeners.size > 0;
-  }
-  onSubscribe() {
-  }
-  onUnsubscribe() {
-  }
-}, ht, tt, bt, Te, ss = (Te = class extends kt {
-  constructor() {
-    super();
-    c(this, ht);
-    c(this, tt);
-    c(this, bt);
-    o(this, bt, (t) => {
-      if (typeof window < "u" && window.addEventListener) {
-        const s = () => t();
-        return window.addEventListener("visibilitychange", s, !1), () => {
-          window.removeEventListener("visibilitychange", s);
-        };
-      }
-    });
-  }
-  onSubscribe() {
-    i(this, tt) || this.setEventListener(i(this, bt));
-  }
-  onUnsubscribe() {
-    var t;
-    this.hasListeners() || ((t = i(this, tt)) == null || t.call(this), o(this, tt, void 0));
-  }
-  setEventListener(t) {
-    var s;
-    o(this, bt, t), (s = i(this, tt)) == null || s.call(this), o(this, tt, t((r) => {
-      typeof r == "boolean" ? this.setFocused(r) : this.onFocus();
-    }));
-  }
-  setFocused(t) {
-    i(this, ht) !== t && (o(this, ht, t), this.onFocus());
-  }
-  onFocus() {
-    const t = this.isFocused();
-    this.listeners.forEach((s) => {
-      s(t);
-    });
-  }
-  isFocused() {
-    var t;
-    return typeof i(this, ht) == "boolean" ? i(this, ht) : ((t = globalThis.document) == null ? void 0 : t.visibilityState) !== "hidden";
-  }
-}, ht = new WeakMap(), tt = new WeakMap(), bt = new WeakMap(), Te), fe = new ss(), rs = {
-  // 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.
+import { jsx as Lt } from "react/jsx-runtime";
+import * as L from "react";
+import { createContext as Be, useRef as Ae, useState as de, useCallback as Ge, useEffect as fe, useMemo as Ve } from "react";
+import { f as Gt } from "../../format-YhWt2D8M.mjs";
+import { l as kt } from "../../logger-C0N7U0YY.mjs";
+const Ie = L.createContext(void 0), $e = (e) => {
+  const t = L.useContext(Ie);
+  if (!t) throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return t;
+}, ze = ({ client: e, children: t }) => (L.useEffect(() => (e.mount(), () => {
+  e.unmount();
+}), [e]), /* @__PURE__ */ Lt(Ie.Provider, {
+  value: e,
+  children: t
+})), We = {
   setTimeout: (e, t) => setTimeout(e, t),
   clearTimeout: (e) => clearTimeout(e),
   setInterval: (e, t) => setInterval(e, t),
   clearInterval: (e) => clearInterval(e)
-}, G, ct, Ie, is = (Ie = class {
+};
+var G, at, Oe, Je = (Oe = class {
   constructor() {
-    // 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 the default provider's concrete timer ID, which is
-    // infeasible across environments.
-    //
-    // We settle for type safety for the TimeoutProvider type, and accept that
-    // this class is unsafe internally to allow for extension.
-    c(this, G, rs);
-    c(this, ct, !1);
+    c(this, G, We);
+    c(this, at, !1);
   }
+  /**
+  * `setTimeoutProvider` can be used to set a custom implementation of the
+  * `setTimeout`, `clearTimeout`, `setInterval`, `clearInterval` functions,
+  * called a `TimeoutProvider`.
+  *
+  * This may be useful if you notice event loop performance issues with
+  * thousands of queries. A custom TimeoutProvider could also support timer
+  * delays longer than the global `setTimeout` maximum delay value of about
+  * 24 days.
+  *
+  * It is important to call `setTimeoutProvider` before creating a
+  * QueryClient or queries, so that the same provider is used consistently
+  * for all timers in the application, since different TimeoutProviders
+  * cannot cancel each others' timers.
+  *
+  * @example
+  * ```ts
+  * import { timeoutManager, QueryClient } from '@tanstack/query-core'
+  * import { CustomTimeoutProvider } from './CustomTimeoutProvider'
+  *
+  * timeoutManager.setTimeoutProvider(new CustomTimeoutProvider())
+  *
+  * export const queryClient = new QueryClient()
+  * ```
+  */
   setTimeoutProvider(e) {
-    process.env.NODE_ENV !== "production" && i(this, ct) && e !== i(this, G) && console.error(
-      "[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.",
-      { previous: i(this, G), provider: e }
-    ), o(this, G, e), process.env.NODE_ENV !== "production" && o(this, ct, !1);
+    process.env.NODE_ENV !== "production" && i(this, at) && e !== i(this, G) && console.error("[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.", {
+      previous: i(this, G),
+      provider: e
+    }), o(this, G, e), process.env.NODE_ENV !== "production" && o(this, at, !1);
   }
+  /**
+  * `setTimeout` schedules a callback to run after approximately `delay`
+  * milliseconds, like the global `setTimeout` function. The callback can be
+  * canceled with `clearTimeout`.
+  *
+  * It returns a timer ID, which may be a number or an object that can be
+  * coerced to a number via `Symbol.toPrimitive`.
+  *
+  * @example
+  * ```ts
+  * import { timeoutManager } from '@tanstack/query-core'
+  *
+  * const timeoutId = timeoutManager.setTimeout(
+  *   () => console.log('ran at:', new Date()),
+  *   1000,
+  * )
+  *
+  * const timeoutIdNumber: number = Number(timeoutId)
+  * ```
+  */
   setTimeout(e, t) {
-    return process.env.NODE_ENV !== "production" && o(this, ct, !0), i(this, G).setTimeout(e, t);
+    return process.env.NODE_ENV !== "production" && o(this, at, !0), i(this, G).setTimeout(e, t);
   }
+  /**
+  * `clearTimeout` cancels a timeout callback scheduled with `setTimeout`,
+  * like the global `clearTimeout` function. It should be called with a
+  * timer ID returned by `setTimeout`.
+  *
+  * @example
+  * ```ts
+  * import { timeoutManager } from '@tanstack/query-core'
+  *
+  * const timeoutId = timeoutManager.setTimeout(
+  *   () => console.log('ran at:', new Date()),
+  *   1000,
+  * )
+  *
+  * timeoutManager.clearTimeout(timeoutId)
+  * ```
+  */
   clearTimeout(e) {
     i(this, G).clearTimeout(e);
   }
+  /**
+  * `setInterval` schedules a callback to be called approximately every
+  * `delay` milliseconds, like the global `setInterval` function.
+  *
+  * Like `setTimeout`, it returns a timer ID, which may be a number or an
+  * object that can be coerced to a number via `Symbol.toPrimitive`.
+  *
+  * @example
+  * ```ts
+  * import { timeoutManager } from '@tanstack/query-core'
+  *
+  * const intervalId = timeoutManager.setInterval(
+  *   () => console.log('ran at:', new Date()),
+  *   1000,
+  * )
+  * ```
+  */
   setInterval(e, t) {
-    return process.env.NODE_ENV !== "production" && o(this, ct, !0), i(this, G).setInterval(e, t);
+    return process.env.NODE_ENV !== "production" && o(this, at, !0), i(this, G).setInterval(e, t);
   }
+  /**
+  * `clearInterval` can be used to cancel an interval, like the global
+  * `clearInterval` function. It should be called with an interval ID
+  * returned by `setInterval`.
+  *
+  * @example
+  * ```ts
+  * import { timeoutManager } from '@tanstack/query-core'
+  *
+  * const intervalId = timeoutManager.setInterval(
+  *   () => console.log('ran at:', new Date()),
+  *   1000,
+  * )
+  *
+  * timeoutManager.clearInterval(intervalId)
+  * ```
+  */
   clearInterval(e) {
     i(this, G).clearInterval(e);
   }
-}, G = new WeakMap(), ct = new WeakMap(), Ie), ut = new is();
-function ns(e) {
+}, G = new WeakMap(), at = new WeakMap(), Oe);
+const nt = new Je();
+function Ze(e) {
   setTimeout(e, 0);
 }
-var as = typeof window > "u" || "Deno" in globalThis;
-function N() {
+const Xe = typeof window > "u" || "Deno" in globalThis;
+function k() {
 }
-function os(e, t) {
+function Ye(e, t) {
   return typeof e == "function" ? e(t) : e;
 }
-function Xt(e) {
+function xe(e) {
   return typeof e == "number" && e >= 0 && e !== 1 / 0;
 }
-function Ke(e, t) {
+function Ue(e, t) {
   return Math.max(e + (t || 0) - Date.now(), 0);
 }
-function ot(e, t) {
-  return typeof e == "function" ? e(t) : e;
-}
-function L(e, t) {
+function P(e, t) {
   return typeof e == "function" ? e(t) : e;
 }
-function we(e, t) {
-  const {
-    type: s = "all",
-    exact: r,
-    fetchStatus: n,
-    predicate: a,
-    queryKey: h,
-    stale: u
-  } = e;
+function ye(e, t) {
+  const { type: s = "all", exact: r, fetchStatus: n, predicate: a, queryKey: h, stale: u } = e;
   if (h) {
     if (r) {
-      if (t.queryHash !== ye(h, t.options))
-        return !1;
-    } else if (!At(t.queryKey, h))
-      return !1;
+      if (t.queryHash !== ae(h, t.options)) return !1;
+    } else if (!Qt(t.queryKey, h)) return !1;
   }
   if (s !== "all") {
-    const f = t.isActive();
-    if (s === "active" && !f || s === "inactive" && f)
-      return !1;
+    const d = t.isActive();
+    if (s === "active" && !d || s === "inactive" && d) return !1;
   }
   return !(typeof u == "boolean" && t.isStale() !== u || n && n !== t.state.fetchStatus || a && !a(t));
 }
-function Se(e, t) {
+function pe(e, t) {
   const { exact: s, status: r, predicate: n, mutationKey: a } = e;
   if (a) {
-    if (!t.options.mutationKey)
-      return !1;
+    if (!t.options.mutationKey) return !1;
     if (s) {
-      if (It(t.options.mutationKey) !== It(a))
-        return !1;
-    } else if (!At(t.options.mutationKey, a))
-      return !1;
+      if (Dt(t.options.mutationKey) !== Dt(a)) return !1;
+    } else if (!Qt(t.options.mutationKey, a)) return !1;
   }
   return !(r && t.state.status !== r || n && !n(t));
 }
-function ye(e, t) {
-  return ((t == null ? void 0 : t.queryKeyHashFn) || It)(e);
+function ae(e, t) {
+  return ((t == null ? void 0 : t.queryKeyHashFn) || Dt)(e);
 }
-function It(e) {
-  return JSON.stringify(
-    e,
-    (t, s) => ee(s) ? Object.keys(s).sort().reduce((r, n) => (r[n] = s[n], r), {}) : s
-  );
+function Dt(e) {
+  return JSON.stringify(e, (t, s) => zt(s) ? Object.keys(s).sort().reduce((r, n) => (r[n] = s[n], r), {}) : s);
 }
-function At(e, t) {
-  return e === t ? !0 : typeof e != typeof t ? !1 : e && t && typeof e == "object" && typeof t == "object" ? Object.keys(t).every((s) => At(e[s], t[s])) : !1;
+function Qt(e, t) {
+  if (e === t) return !0;
+  if (typeof e != typeof t) return !1;
+  if (e && t && typeof e == "object" && typeof t == "object") {
+    if (Array.isArray(e) && Array.isArray(t)) {
+      if (t.length > e.length) return !1;
+      for (let r = 0; r < t.length; r++) if (!Qt(e[r], t[r])) return !1;
+      return !0;
+    }
+    const s = Object.keys(t);
+    for (const r of s) if (!Qt(e[r], t[r])) return !1;
+    return !0;
+  }
+  return !1;
 }
-var us = Object.prototype.hasOwnProperty;
-function Yt(e, t, s = 0) {
-  if (e === t)
-    return e;
+const ts = Object.prototype.hasOwnProperty;
+function $t(e, t, s = 0) {
+  if (e === t) return e;
   if (s > 500) return t;
-  const r = Ce(e) && Ce(t);
-  if (!r && !(ee(e) && ee(t))) return t;
-  const a = (r ? e : Object.keys(e)).length, h = r ? t : Object.keys(t), u = h.length, f = r ? new Array(u) : {};
-  let m = 0;
-  for (let w = 0; w < u; w++) {
-    const d = r ? w : h[w], C = e[d], y = t[d];
+  const r = me(e) && me(t);
+  if (!r && !(zt(e) && zt(t))) return t;
+  const n = (r ? e : Object.keys(e)).length, a = r ? t : Object.keys(t), h = a.length, u = r ? new Array(h) : {};
+  let d = 0;
+  for (let p = 0; p < h; p++) {
+    const f = r ? p : a[p], C = e[f], y = t[f];
     if (C === y) {
-      f[d] = C, (r ? w < a : us.call(e, d)) && m++;
+      u[f] = C, (r ? p < n : ts.call(e, f)) && d++;
       continue;
     }
     if (C === null || y === null || typeof C != "object" || typeof y != "object") {
-      f[d] = y;
+      u[f] = y;
       continue;
     }
-    const P = Yt(C, y, s + 1);
-    f[d] = P, P === C && m++;
+    const R = $t(C, y, s + 1);
+    u[f] = R, R === C && d++;
   }
-  return a === u && m === a ? e : f;
+  return n === h && d === n ? e : u;
 }
-function te(e, t) {
-  if (!t || Object.keys(e).length !== Object.keys(t).length)
-    return !1;
-  for (const s in e)
-    if (e[s] !== t[s])
-      return !1;
+function Vt(e, t) {
+  if (!t || Object.keys(e).length !== Object.keys(t).length) return !1;
+  for (const s in e) if (e[s] !== t[s]) return !1;
   return !0;
 }
-function Ce(e) {
+function me(e) {
   return Array.isArray(e) && e.length === Object.keys(e).length;
 }
-function ee(e) {
-  if (!Oe(e))
-    return !1;
-  const t = e.constructor;
-  if (t === void 0)
-    return !0;
-  const s = t.prototype;
-  return !(!Oe(s) || !s.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(e) !== Object.prototype);
+function zt(e) {
+  if (!ve(e)) return !1;
+  const t = Object.getPrototypeOf(e), s = t == null ? void 0 : t.constructor;
+  if (s === void 0) return !0;
+  if (typeof s != "function") return !1;
+  const r = s.prototype;
+  return !(!ve(r) || !r.hasOwnProperty("isPrototypeOf") || t !== Object.prototype);
 }
-function Oe(e) {
+function ve(e) {
   return Object.prototype.toString.call(e) === "[object Object]";
 }
-function hs(e) {
+function es(e) {
   return new Promise((t) => {
-    ut.setTimeout(t, e);
+    nt.setTimeout(t, e);
   });
 }
-function se(e, t, s) {
-  if (typeof s.structuralSharing == "function")
-    return s.structuralSharing(e, t);
+function Wt(e, t, s) {
+  if (typeof s.structuralSharing == "function") return s.structuralSharing(e, t);
   if (s.structuralSharing !== !1) {
-    if (process.env.NODE_ENV !== "production")
-      try {
-        return Yt(e, t);
-      } catch (r) {
-        throw console.error(
-          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${s.queryHash}]: ${r}`
-        ), r;
-      }
-    return Yt(e, t);
+    if (process.env.NODE_ENV !== "production") try {
+      return $t(e, t);
+    } catch (r) {
+      throw console.error(`Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${s.queryHash}]: ${r}`), r;
+    }
+    return $t(e, t);
   }
   return t;
 }
-function cs(e, t, s = 0) {
+function ss(e, t, s = 0) {
   const r = [...e, t];
   return s && r.length > s ? r.slice(1) : r;
 }
-function ls(e, t, s = 0) {
+function rs(e, t, s = 0) {
   const r = [t, ...e];
   return s && r.length > s ? r.slice(0, -1) : r;
 }
-var $t = /* @__PURE__ */ Symbol();
-function He(e, t) {
-  return process.env.NODE_ENV !== "production" && e.queryFn === $t && console.error(
-    `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${e.queryHash}'`
-  ), !e.queryFn && (t != null && t.initialPromise) ? () => t.initialPromise : !e.queryFn || e.queryFn === $t ? () => Promise.reject(new Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn;
+const Kt = Symbol();
+function Ne(e, t) {
+  return process.env.NODE_ENV !== "production" && e.queryFn === Kt && console.error(`Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${e.queryHash}'`), !e.queryFn && (t != null && t.initialPromise) ? () => t.initialPromise : !e.queryFn || e.queryFn === Kt ? () => Promise.reject(/* @__PURE__ */ new Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn;
 }
-function Ge(e, t) {
+function je(e, t) {
   return typeof e == "function" ? e(...t) : !!e;
 }
-function ds(e, t, s) {
+function is(e, t, s) {
   let r = !1, n;
   return Object.defineProperty(e, "signal", {
     enumerable: !0,
     get: () => (n ?? (n = t()), r || (r = !0, n.aborted ? s() : n.addEventListener("abort", s, { once: !0 })), n)
   }), e;
 }
-var xt = /* @__PURE__ */ (() => {
-  let e = () => as;
-  return {
-    /**
-     * Returns whether the current runtime should be treated as a server environment.
-     */
-    isServer() {
-      return e();
-    },
-    /**
-     * Overrides the server check globally.
-     */
-    setIsServer(t) {
-      e = t;
-    }
-  };
-})();
-function re() {
-  let e, t;
-  const s = new Promise((n, a) => {
-    e = n, t = a;
-  });
-  s.status = "pending", s.catch(() => {
-  });
-  function r(n) {
-    Object.assign(s, n), delete s.resolve, delete s.reject;
-  }
-  return s.resolve = (n) => {
-    r({
-      status: "fulfilled",
-      value: n
-    }), e(n);
-  }, s.reject = (n) => {
-    r({
-      status: "rejected",
-      reason: n
-    }), t(n);
-  }, s;
-}
-var fs = ns;
-function ys() {
+let ns = () => Xe;
+const oe = () => ns();
+var Nt = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(e) {
+    return this.listeners.add(e), this.onSubscribe(), () => {
+      this.listeners.delete(e), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+}, ot, Y, mt, Pe, as = (Pe = class extends Nt {
+  constructor() {
+    super();
+    c(this, ot);
+    c(this, Y);
+    c(this, mt);
+    o(this, mt, (t) => {
+      if (typeof window < "u" && window.addEventListener) {
+        const s = () => t();
+        return window.addEventListener("visibilitychange", s, !1), () => {
+          window.removeEventListener("visibilitychange", s);
+        };
+      }
+    });
+  }
+  onSubscribe() {
+    i(this, Y) || this.setEventListener(i(this, mt));
+  }
+  onUnsubscribe() {
+    var t;
+    this.hasListeners() || ((t = i(this, Y)) == null || t.call(this), o(this, Y, void 0));
+  }
+  /**
+  * `setEventListener` can be used to set a custom event listener that will
+  * be used to determine the focus state. The provided `setup` function
+  * receives a `setFocused` callback: call it with a `boolean` to manually
+  * set the focus state, or with no arguments to re-evaluate the current
+  * focus state and notify subscribers.
+  *
+  * @example
+  * ```ts
+  * import { focusManager } from '@tanstack/query-core'
+  *
+  * focusManager.setEventListener((handleFocus) => {
+  *   const listener = () => handleFocus()
+  *   // Listen to visibilitychange
+  *   if (typeof window !== 'undefined' && window.addEventListener) {
+  *     window.addEventListener('visibilitychange', listener, false)
+  *   }
+  *
+  *   return () => {
+  *     // Be sure to unsubscribe if a new handler is set
+  *     window.removeEventListener('visibilitychange', listener)
+  *   }
+  * })
+  * ```
+  */
+  setEventListener(t) {
+    var s;
+    o(this, mt, t), (s = i(this, Y)) == null || s.call(this), o(this, Y, t((r) => {
+      typeof r == "boolean" ? this.setFocused(r) : this.onFocus();
+    }));
+  }
+  /**
+  * `setFocused` can be used to manually set the focus state. Set `undefined`
+  * to fall back to the default focus check.
+  *
+  * @example
+  * ```ts
+  * import { focusManager } from '@tanstack/query-core'
+  *
+  * // Set focused
+  * focusManager.setFocused(true)
+  *
+  * // Set unfocused
+  * focusManager.setFocused(false)
+  *
+  * // Fallback to the default focus check
+  * focusManager.setFocused(undefined)
+  * ```
+  */
+  setFocused(t) {
+    i(this, ot) !== t && (o(this, ot, t), this.onFocus());
+  }
+  /**
+  * `onFocus` notifies all subscribed listeners with the current focus state.
+  */
+  onFocus() {
+    const t = this.isFocused();
+    this.listeners.forEach((s) => {
+      s(t);
+    });
+  }
+  /**
+  * `isFocused` can be used to get the current focus state.
+  */
+  isFocused() {
+    var t;
+    return typeof i(this, ot) == "boolean" ? i(this, ot) : ((t = globalThis.document) == null ? void 0 : t.visibilityState) !== "hidden";
+  }
+}, ot = new WeakMap(), Y = new WeakMap(), mt = new WeakMap(), Pe);
+const ue = new as(), os = Ze;
+function us() {
   let e = [], t = 0, s = (u) => {
     u();
   }, r = (u) => {
     u();
-  }, n = fs;
+  }, n = os;
   const a = (u) => {
     t ? e.push(u) : n(() => {
       s(u);
@@ -334,58 +419,96 @@ function ys() {
     const u = e;
     e = [], u.length && n(() => {
       r(() => {
-        u.forEach((f) => {
-          s(f);
+        u.forEach((d) => {
+          s(d);
         });
       });
     });
   };
   return {
+    /**
+    * Batches all updates scheduled inside the passed callback.
+    * This is mainly used internally to optimize query client updating.
+    * Batches can be nested; the queue is only flushed once the outermost `batch` call finishes.
+    * The return value of `callback` is passed through.
+    */
     batch: (u) => {
-      let f;
+      let d;
       t++;
       try {
-        f = u();
+        d = u();
       } finally {
         t--, t || h();
       }
-      return f;
+      return d;
     },
     /**
-     * All calls to the wrapped function will be batched.
-     */
-    batchCalls: (u) => (...f) => {
+    * All calls to the wrapped function will be batched.
+    */
+    batchCalls: (u) => (...d) => {
       a(() => {
-        u(...f);
+        u(...d);
       });
     },
+    /**
+    * Schedules a function to be run on the next batch.
+    * By default, the batch is run with a `setTimeout`, but this can be configured via `setScheduler`.
+    */
     schedule: a,
     /**
-     * Use this method to set a custom notify function.
-     * This can be used to for example wrap notifications with `React.act` while running tests.
-     */
+    * 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: (u) => {
       s = u;
     },
     /**
-     * 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.
-     */
+    * Use this method to set a custom function to batch notifications together into a single tick.
+    * Framework adapters use this to plug in their own batching primitive, so that a single query
+    * update only triggers one re-render instead of one per subscriber.
+    *
+    * @example
+    * ```ts
+    * import { notifyManager } from '@tanstack/query-core'
+    * import { batch } from 'solid-js'
+    *
+    * notifyManager.setBatchNotifyFunction(batch)
+    * ```
+    */
     setBatchNotifyFunction: (u) => {
       r = u;
     },
+    /**
+    * Configures a custom callback that schedules when the next batch runs.
+    * The default behavior is `setTimeout(callback, 0)`.
+    *
+    * @example
+    * ```ts
+    * import { notifyManager } from '@tanstack/query-core'
+    *
+    * // Schedule batches in the next microtask
+    * notifyManager.setScheduler(queueMicrotask)
+    *
+    * // Schedule batches before the next frame is rendered
+    * notifyManager.setScheduler(requestAnimationFrame)
+    *
+    * // Schedule batches some time in the future
+    * notifyManager.setScheduler((cb) => setTimeout(cb, 10))
+    * ```
+    */
     setScheduler: (u) => {
       n = u;
     }
   };
 }
-var I = ys(), wt, et, St, Ae, ps = (Ae = class extends kt {
+const A = us();
+var vt, tt, gt, Ee, hs = (Ee = class extends Nt {
   constructor() {
     super();
-    c(this, wt, !0);
-    c(this, et);
-    c(this, St);
-    o(this, St, (t) => {
+    c(this, vt, !0);
+    c(this, tt);
+    c(this, gt);
+    o(this, gt, (t) => {
       if (typeof window < "u" && window.addEventListener) {
         const s = () => t(!0), r = () => t(!1);
         return window.addEventListener("online", s, !1), window.addEventListener("offline", r, !1), () => {
@@ -395,284 +518,514 @@ var I = ys(), wt, et, St, Ae, ps = (Ae = class extends kt {
     });
   }
   onSubscribe() {
-    i(this, et) || this.setEventListener(i(this, St));
+    i(this, tt) || this.setEventListener(i(this, gt));
   }
   onUnsubscribe() {
     var t;
-    this.hasListeners() || ((t = i(this, et)) == null || t.call(this), o(this, et, void 0));
+    this.hasListeners() || ((t = i(this, tt)) == null || t.call(this), o(this, tt, void 0));
   }
+  /**
+  * `setEventListener` can be used to set a custom event listener that will
+  * be used to determine the online state. The provided `setup` function
+  * receives a `setOnline` callback that should be called with a `boolean`
+  * whenever the online state changes.
+  *
+  * @example
+  * ```ts
+  * import NetInfo from '@react-native-community/netinfo'
+  * import { onlineManager } from '@tanstack/query-core'
+  *
+  * onlineManager.setEventListener((setOnline) => {
+  *   return NetInfo.addEventListener((state) => {
+  *     setOnline(!!state.isConnected)
+  *   })
+  * })
+  * ```
+  */
   setEventListener(t) {
     var s;
-    o(this, St, t), (s = i(this, et)) == null || s.call(this), o(this, et, t(this.setOnline.bind(this)));
+    o(this, gt, t), (s = i(this, tt)) == null || s.call(this), o(this, tt, t(this.setOnline.bind(this)));
   }
+  /**
+  * `setOnline` can be used to manually set the online state.
+  *
+  * @example
+  * ```ts
+  * import { onlineManager } from '@tanstack/query-core'
+  *
+  * // Set to online
+  * onlineManager.setOnline(true)
+  *
+  * // Set to offline
+  * onlineManager.setOnline(false)
+  * ```
+  */
   setOnline(t) {
-    i(this, wt) !== t && (o(this, wt, t), this.listeners.forEach((r) => {
-      r(t);
+    i(this, vt) !== t && (o(this, vt, t), this.listeners.forEach((s) => {
+      s(t);
     }));
   }
+  /**
+  * `isOnline` can be used to get the current online state.
+  */
   isOnline() {
-    return i(this, wt);
+    return i(this, vt);
   }
-}, wt = new WeakMap(), et = new WeakMap(), St = new WeakMap(), Ae), Wt = new ps();
-function ms(e) {
+}, vt = new WeakMap(), tt = new WeakMap(), gt = new WeakMap(), Ee);
+const Ht = new hs();
+function cs(e) {
   return Math.min(1e3 * 2 ** e, 3e4);
 }
-function Be(e) {
-  return (e ?? "online") === "online" ? Wt.isOnline() : !0;
+function ke(e) {
+  return (e ?? "online") === "online" ? Ht.isOnline() : !0;
 }
-var ie = class extends Error {
+var Jt = class extends Error {
   constructor(e) {
     super("CancelledError"), this.revert = e == null ? void 0 : e.revert, this.silent = e == null ? void 0 : e.silent;
   }
 };
-function Ve(e) {
-  let t = !1, s = 0, r;
-  const n = re(), a = () => n.status !== "pending", h = (v) => {
+function _e(e) {
+  let t = !1, s = 0, r, n = "pending", a, h;
+  const u = new Promise((g, b) => {
+    a = g, h = b;
+  });
+  u.catch(k);
+  const d = () => n !== "pending", p = (g) => {
     var b;
-    if (!a()) {
-      const S = new ie(v);
-      C(S), (b = e.onCancel) == null || b.call(e, S);
+    if (!d()) {
+      const S = new Jt(g);
+      O(S), (b = e.onCancel) == null || b.call(e, S);
     }
-  }, u = () => {
-    t = !0;
   }, f = () => {
+    t = !0;
+  }, C = () => {
     t = !1;
-  }, m = () => fe.isFocused() && (e.networkMode === "always" || Wt.isOnline()) && e.canRun(), w = () => Be(e.networkMode) && e.canRun(), d = (v) => {
-    a() || (r == null || r(), n.resolve(v));
-  }, C = (v) => {
-    a() || (r == null || r(), n.reject(v));
-  }, y = () => new Promise((v) => {
+  }, y = () => ue.isFocused() && (e.networkMode === "always" || Ht.isOnline()) && e.canRun(), R = () => ke(e.networkMode) && e.canRun(), D = (g) => {
+    d() || (r == null || r(), n = "resolved", a(g));
+  }, O = (g) => {
+    d() || (r == null || r(), n = "rejected", h(g));
+  }, q = () => new Promise((g) => {
     var b;
     r = (S) => {
-      (a() || m()) && v(S);
+      (d() || y()) && g(S);
     }, (b = e.onPause) == null || b.call(e);
   }).then(() => {
-    var v;
-    r = void 0, a() || (v = e.onContinue) == null || v.call(e);
-  }), P = () => {
-    if (a())
-      return;
-    let v;
+    var g;
+    r = void 0, d() || (g = e.onContinue) == null || g.call(e);
+  }), M = () => {
+    if (d()) return;
+    let g;
     const b = s === 0 ? e.initialPromise : void 0;
     try {
-      v = b ?? e.fn();
+      g = b ?? e.fn();
     } catch (S) {
-      v = Promise.reject(S);
+      g = Promise.reject(S);
     }
-    Promise.resolve(v).then(d).catch((S) => {
-      var j;
-      if (a())
-        return;
-      const R = e.retry ?? (xt.isServer() ? 0 : 3), F = e.retryDelay ?? ms, l = typeof F == "function" ? F(s, S) : F, D = R === !0 || typeof R == "number" && s < R || typeof R == "function" && R(s, S);
-      if (t || !D) {
-        C(S);
+    Promise.resolve(g).then(D).catch((S) => {
+      var E;
+      if (d()) return;
+      const l = e.retry ?? (oe() ? 0 : 3), x = e.retryDelay ?? cs, Q = typeof x == "function" ? x(s, S) : x, K = l === !0 || typeof l == "number" && s < l || typeof l == "function" && l(s, S);
+      if (t || !K) {
+        O(S);
         return;
       }
-      s++, (j = e.onFail) == null || j.call(e, s, S), hs(l).then(() => m() ? void 0 : y()).then(() => {
-        t ? C(S) : P();
+      s++, (E = e.onFail) == null || E.call(e, s, S), es(Q).then(() => y() ? void 0 : q()).then(() => {
+        t ? O(S) : M();
       });
     });
   };
   return {
-    promise: n,
-    status: () => n.status,
-    cancel: h,
-    continue: () => (r == null || r(), n),
-    cancelRetry: u,
-    continueRetry: f,
-    canStart: w,
-    start: () => (w() ? P() : y().then(P), n)
+    promise: u,
+    status: () => n,
+    cancel: p,
+    continue: () => (r == null || r(), u),
+    cancelRetry: f,
+    continueRetry: C,
+    canStart: R,
+    start: () => (R() ? M() : q().then(M), u)
   };
 }
-var lt, xe, ze = (xe = class {
+var ut, Fe, Le = (Fe = class {
   constructor() {
-    c(this, lt);
+    c(this, ut);
   }
   destroy() {
     this.clearGcTimeout();
   }
   scheduleGc() {
-    this.clearGcTimeout(), Xt(this.gcTime) && o(this, lt, ut.setTimeout(() => {
+    this.clearGcTimeout(), xe(this.gcTime) && o(this, ut, nt.setTimeout(() => {
       this.optionalRemove();
     }, this.gcTime));
   }
   updateGcTime(e) {
-    this.gcTime = Math.max(
-      this.gcTime || 0,
-      e ?? (xt.isServer() ? 1 / 0 : 300 * 1e3)
-    );
+    this.gcTime = Math.max(this.gcTime || 0, e ?? (oe() ? 1 / 0 : 3e5));
   }
   clearGcTimeout() {
-    i(this, lt) && (ut.clearTimeout(i(this, lt)), o(this, lt, void 0));
-  }
-}, lt = new WeakMap(), xe), dt, Ct, k, ft, T, qt, yt, _, $e, $, qe, vs = (qe = class extends ze {
+    i(this, ut) !== void 0 && (nt.clearTimeout(i(this, ut)), o(this, ut, void 0));
+  }
+}, ut = new WeakMap(), Fe);
+function ls(e) {
+  return { onFetch: (t, s) => {
+    var f, C, y, R, D;
+    const r = t.options, n = (y = (C = (f = t.fetchOptions) == null ? void 0 : f.meta) == null ? void 0 : C.fetchMore) == null ? void 0 : y.direction, a = ((R = t.state.data) == null ? void 0 : R.pages) || [], h = ((D = t.state.data) == null ? void 0 : D.pageParams) || [];
+    let u = {
+      pages: [],
+      pageParams: []
+    }, d = 0;
+    const p = async () => {
+      let O = !1;
+      const q = (b) => {
+        is(b, () => t.signal, () => O = !0);
+      }, M = Ne(t.options, t.fetchOptions), g = async (b, S, l) => {
+        if (O) return Promise.reject(t.signal.reason);
+        if (S == null && b.pages.length) return Promise.resolve(b);
+        const Q = (() => {
+          const ce = {
+            client: t.client,
+            queryKey: t.queryKey,
+            pageParam: S,
+            direction: l ? "backward" : "forward",
+            meta: t.options.meta
+          };
+          return q(ce), ce;
+        })(), K = await M(Q), { maxPages: E } = t.options, U = l ? rs : ss;
+        return {
+          pages: U(b.pages, K, E),
+          pageParams: U(b.pageParams, S, E)
+        };
+      };
+      if (n && a.length) {
+        const b = n === "backward", S = b ? ds : ge, l = {
+          pages: a,
+          pageParams: h
+        };
+        u = await g(l, S(r, l), b);
+      } else {
+        const b = e ?? a.length;
+        do {
+          const S = d === 0 ? h[0] ?? r.initialPageParam : ge(r, u);
+          if (d > 0 && S == null) break;
+          u = await g(u, S), d++;
+        } while (d < b);
+      }
+      return u;
+    };
+    t.options.persister ? t.fetchFn = () => {
+      var O, q;
+      return (q = (O = t.options).persister) == null ? void 0 : q.call(O, p, {
+        client: t.client,
+        queryKey: t.queryKey,
+        meta: t.options.meta,
+        signal: t.signal
+      }, s);
+    } : t.fetchFn = p;
+  } };
+}
+function ge(e, { pages: t, pageParams: s }) {
+  const r = t.length - 1;
+  return t.length > 0 ? e.getNextPageParam(t[r], t, s[r], s) : void 0;
+}
+function ds(e, { pages: t, pageParams: s }) {
+  var r;
+  return t.length > 0 ? (r = e.getPreviousPageParam) == null ? void 0 : r.call(e, t[0], t, s[0], s) : void 0;
+}
+var bt, ht, wt, _, ct, T, qt, lt, H, W, Re, fs = (Re = class extends Le {
   constructor(t) {
     super();
+    c(this, H);
+    c(this, bt);
+    c(this, ht);
+    c(this, wt);
     c(this, _);
-    c(this, dt);
-    c(this, Ct);
-    c(this, k);
-    c(this, ft);
+    c(this, ct);
     c(this, T);
     c(this, qt);
-    c(this, yt);
-    o(this, yt, !1), o(this, qt, t.defaultOptions), this.setOptions(t.options), this.observers = [], o(this, ft, t.client), o(this, k, i(this, ft).getQueryCache()), this.queryKey = t.queryKey, this.queryHash = t.queryHash, o(this, dt, Ee(this.options)), this.state = t.state ?? i(this, dt), this.scheduleGc();
+    c(this, lt);
+    o(this, lt, !1), o(this, qt, t.defaultOptions), this.setOptions(t.options), this.observers = [], o(this, ct, t.client), o(this, _, i(this, ct).getQueryCache()), this.queryKey = t.queryKey, this.queryHash = t.queryHash, o(this, ht, we(this.options)), this.state = t.state ?? i(this, ht), this.scheduleGc();
   }
+  /**
+  * The `meta` object passed in the query's options, if any.
+  */
   get meta() {
     return this.options.meta;
   }
+  /** @internal */
+  get queryType() {
+    return i(this, bt);
+  }
+  /**
+  * The promise for the currently in-flight fetch, if the query is fetching.
+  * `undefined` when the query is not fetching.
+  */
   get promise() {
     var t;
     return (t = i(this, T)) == null ? void 0 : t.promise;
   }
+  /** @internal */
   setOptions(t) {
-    if (this.options = { ...i(this, qt), ...t }, this.updateGcTime(this.options.gcTime), this.state && this.state.data === void 0) {
-      const s = Ee(this.options);
-      s.data !== void 0 && (this.setState(
-        Pe(s.data, s.dataUpdatedAt)
-      ), o(this, dt, s));
+    if (this.options = {
+      ...i(this, qt),
+      ...t
+    }, t != null && t._type && o(this, bt, t._type), this.updateGcTime(this.options.gcTime), this.state && this.state.data === void 0) {
+      const s = we(this.options);
+      s.data !== void 0 && (this.setState(be(s.data, s.dataUpdatedAt)), o(this, ht, s));
     }
   }
   optionalRemove() {
-    !this.observers.length && this.state.fetchStatus === "idle" && i(this, k).remove(this);
+    !this.observers.length && this.state.fetchStatus === "idle" && i(this, _).remove(this);
   }
+  /** @internal */
   setData(t, s) {
-    const r = se(this.state.data, t, this.options);
-    return p(this, _, $).call(this, {
+    const r = Wt(this.state.data, t, this.options);
+    return m(this, H, W).call(this, {
       data: r,
       type: "success",
       dataUpdatedAt: s == null ? void 0 : s.updatedAt,
       manual: s == null ? void 0 : s.manual
     }), r;
   }
-  setState(t, s) {
-    p(this, _, $).call(this, { type: "setState", state: t, setStateOptions: s });
+  /**
+  * Merges the given partial state directly into this query's state, notifying observers. Used
+  * by persistence and broadcast plugins to restore a state snapshot, and by devtools to let a
+  * user manually trigger a loading/error state or edit the cached data.
+  */
+  setState(t) {
+    m(this, H, W).call(this, {
+      type: "setState",
+      state: t
+    });
   }
+  /**
+  * Cancels the query's currently in-flight fetch, if any.
+  * - Returns a promise that resolves once the cancellation has settled.
+  * - If no fetch is in progress, resolves immediately.
+  *
+  * @example
+  * ```ts
+  * await query.cancel()
+  * ```
+  */
   cancel(t) {
     var r, n;
     const s = (r = i(this, T)) == null ? void 0 : r.promise;
-    return (n = i(this, T)) == null || n.cancel(t), s ? s.then(N).catch(N) : Promise.resolve();
+    return (n = i(this, T)) == null || n.cancel(t), s ? s.then(k).catch(k) : Promise.resolve();
   }
+  /**
+  * Clears the query's garbage collection timeout and silently cancels any
+  * in-flight fetch. Called by `QueryCache` when the query is removed from
+  * the cache.
+  *
+  * @see {@link Query#cancel}
+  */
   destroy() {
     super.destroy(), this.cancel({ silent: !0 });
   }
+  /** @internal */
   get resetState() {
-    return i(this, dt);
+    return i(this, ht);
   }
+  /**
+  * Resets the query back to its initial state (the state it had when it was
+  * first created, e.g. any `initialData`), destroying it first to cancel any
+  * in-flight fetch.
+  */
   reset() {
     this.destroy(), this.setState(this.resetState);
   }
+  /**
+  * Returns `true` if the query has at least one observer for which `enabled`
+  * does not resolve to `false`.
+  */
   isActive() {
-    return this.observers.some(
-      (t) => L(t.options.enabled, this) !== !1
-    );
+    return this.observers.some((t) => P(t.options.enabled, this) !== !1);
   }
+  /**
+  * Returns `true` if the query is disabled, meaning it will not fetch
+  * automatically.
+  * - If the query has observers, it is disabled when none of them are active
+  *   (see `isActive`).
+  * - If the query has no observers, it is disabled when its `queryFn` is
+  *   `skipToken` or it has never been fetched.
+  */
   isDisabled() {
-    return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === $t || !this.isFetched();
+    return this.getObserversCount() > 0 ? !this.isActive() : this.options.queryFn === Kt || !this.isFetched();
   }
+  /**
+  * Returns `true` if the query has been fetched, i.e. it has resolved with
+  * either data or an error at least once.
+  */
   isFetched() {
     return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
   }
+  /**
+  * Returns `true` if the query has at least one observer configured with
+  * `staleTime: 'static'`, meaning it is treated as never stale.
+  */
   isStatic() {
-    return this.getObserversCount() > 0 ? this.observers.some(
-      (t) => ot(t.options.staleTime, this) === "static"
-    ) : !1;
+    return this.getObserversCount() > 0 ? this.observers.some((t) => P(t.options.staleTime, this) === "static") : !1;
   }
+  /**
+  * Returns `true` if the query is stale.
+  * - If the query has observers, defers to whether any observer's current
+  *   result reports `isStale` (which accounts for each observer's own
+  *   `staleTime` and `enabled` state).
+  * - If the query has no observers, it is considered stale when it has no
+  *   data or has been invalidated.
+  *
+  * @see {@link Query#isStaleByTime}
+  * @example
+  * ```ts
+  * if (query.isStale()) {
+  *   // refetch or otherwise treat the cached data as outdated
+  * }
+  * ```
+  */
   isStale() {
-    return this.getObserversCount() > 0 ? this.observers.some(
-      (t) => t.getCurrentResult().isStale
-    ) : this.state.data === void 0 || this.state.isInvalidated;
+    return this.getObserversCount() > 0 ? this.observers.some((t) => t.getCurrentResult().isStale) : this.state.data === void 0 || this.state.isInvalidated;
   }
+  /**
+  * Returns `true` if the query's data is stale relative to the given
+  * `staleTime` (defaults to `0`).
+  * - A query with no data is always stale.
+  * - `staleTime: 'static'` is never stale.
+  * - An invalidated query is always stale.
+  * - Otherwise, staleness is based on elapsed time since `dataUpdatedAt`.
+  *
+  * @see {@link Query#isStale}
+  * @example
+  * ```ts
+  * const isStale = query.isStaleByTime(1000 * 60)
+  * ```
+  */
   isStaleByTime(t = 0) {
-    return this.state.data === void 0 ? !0 : t === "static" ? !1 : this.state.isInvalidated ? !0 : !Ke(this.state.dataUpdatedAt, t);
+    return this.state.data === void 0 ? !0 : t === "static" ? !1 : this.state.isInvalidated ? !0 : !Ue(this.state.dataUpdatedAt, t);
   }
+  /** @internal */
   onFocus() {
-    var s;
-    const t = this.observers.find((r) => r.shouldFetchOnWindowFocus());
-    t == null || t.refetch({ cancelRefetch: !1 }), (s = i(this, T)) == null || s.continue();
+    var t, s;
+    (t = this.observers.find((r) => r.shouldFetchOnWindowFocus())) == null || t.refetch({ cancelRefetch: !1 }), (s = i(this, T)) == null || s.continue();
   }
+  /** @internal */
   onOnline() {
-    var s;
-    const t = this.observers.find((r) => r.shouldFetchOnReconnect());
-    t == null || t.refetch({ cancelRefetch: !1 }), (s = i(this, T)) == null || s.continue();
+    var t, s;
+    (t = this.observers.find((r) => r.shouldFetchOnReconnect())) == null || t.refetch({ cancelRefetch: !1 }), (s = i(this, T)) == null || s.continue();
   }
+  /** @internal */
   addObserver(t) {
-    this.observers.includes(t) || (this.observers.push(t), this.clearGcTimeout(), i(this, k).notify({ type: "observerAdded", query: this, observer: t }));
+    this.observers.includes(t) || (this.observers.push(t), this.clearGcTimeout(), i(this, _).notify({
+      type: "observerAdded",
+      query: this,
+      observer: t
+    }));
   }
+  /** @internal */
   removeObserver(t) {
-    this.observers.includes(t) && (this.observers = this.observers.filter((s) => s !== t), this.observers.length || (i(this, T) && (i(this, yt) || p(this, _, $e).call(this) ? i(this, T).cancel({ revert: !0 }) : i(this, T).cancelRetry()), this.scheduleGc()), i(this, k).notify({ type: "observerRemoved", query: this, observer: t }));
+    const s = this.observers.indexOf(t);
+    s !== -1 && (this.observers.splice(s, 1), this.observers.length || (i(this, T) && (i(this, lt) || this.state.fetchStatus === "paused" && this.state.status === "pending" ? i(this, T).cancel({ revert: !0 }) : i(this, T).cancelRetry()), this.scheduleGc()), i(this, _).notify({
+      type: "observerRemoved",
+      query: this,
+      observer: t
+    }));
   }
+  /**
+  * Returns the number of observers currently subscribed to this query.
+  *
+  * @example
+  * ```ts
+  * if (query.getObserversCount() === 0) {
+  *   // no component is currently watching this query
+  * }
+  * ```
+  */
   getObserversCount() {
     return this.observers.length;
   }
+  /**
+  * Marks the query as invalidated, unless it is already invalidated. This
+  * updates `state.isInvalidated` and notifies observers, but does not by
+  * itself trigger a refetch.
+  *
+  * @example
+  * ```ts
+  * query.invalidate()
+  * ```
+  */
   invalidate() {
-    this.state.isInvalidated || p(this, _, $).call(this, { type: "invalidate" });
+    this.state.isInvalidated || m(this, H, W).call(this, { type: "invalidate" });
   }
+  /**
+  * Fetches the query, i.e. runs its `queryFn` (through any configured
+  * retryer/behavior) and updates the query's state with the result.
+  * - If a fetch is already in flight, returns its promise instead of
+  *   starting a new one, unless `fetchOptions.cancelRefetch` is set and the
+  *   query already has data, in which case the current fetch is silently
+  *   cancelled first.
+  * - If `options` is passed, it replaces the query's current options
+  *   before fetching.
+  */
   async fetch(t, s) {
-    var f, m, w, d, C, y, P, v, b, S, R, F;
-    if (this.state.fetchStatus !== "idle" && // If the promise in the retryer is already rejected, we have to definitely
-    // re-start the fetch; there is a chance that the query is still in a
-    // pending state when that happens
-    ((f = i(this, T)) == null ? void 0 : f.status()) !== "rejected") {
-      if (this.state.data !== void 0 && (s != null && s.cancelRefetch))
-        this.cancel({ silent: !0 });
+    var p, f, C, y, R, D, O, q, M, g, b, S;
+    if (this.state.fetchStatus !== "idle" && ((p = i(this, T)) == null ? void 0 : p.status()) !== "rejected") {
+      if (this.state.data !== void 0 && (s != null && s.cancelRefetch)) this.cancel({ silent: !0 });
       else if (i(this, T))
         return i(this, T).continueRetry(), i(this, T).promise;
     }
     if (t && this.setOptions(t), !this.options.queryFn) {
-      const l = this.observers.find((D) => D.options.queryFn);
+      const l = this.observers.find((x) => x.options.queryFn);
       l && this.setOptions(l.options);
     }
-    process.env.NODE_ENV !== "production" && (Array.isArray(this.options.queryKey) || console.error(
-      "As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']"
-    ));
+    process.env.NODE_ENV !== "production" && (Array.isArray(this.options.queryKey) || console.error("As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']"));
     const r = new AbortController(), n = (l) => {
       Object.defineProperty(l, "signal", {
         enumerable: !0,
-        get: () => (o(this, yt, !0), r.signal)
+        get: () => (o(this, lt, !0), r.signal)
       });
     }, a = () => {
-      const l = He(this.options, s), j = (() => {
-        const Z = {
-          client: i(this, ft),
+      const l = Ne(this.options, s), Q = (() => {
+        const K = {
+          client: i(this, ct),
           queryKey: this.queryKey,
           meta: this.meta
         };
-        return n(Z), Z;
+        return n(K), K;
       })();
-      return o(this, yt, !1), this.options.persister ? this.options.persister(
-        l,
-        j,
-        this
-      ) : l(j);
+      return o(this, lt, !1), this.options.persister ? this.options.persister(l, Q, this) : l(Q);
     }, u = (() => {
       const l = {
         fetchOptions: s,
         options: this.options,
         queryKey: this.queryKey,
-        client: i(this, ft),
+        client: i(this, ct),
         state: this.state,
         fetchFn: a
       };
       return n(l), l;
     })();
-    (m = this.options.behavior) == null || m.onFetch(u, this), o(this, Ct, this.state), (this.state.fetchStatus === "idle" || this.state.fetchMeta !== ((w = u.fetchOptions) == null ? void 0 : w.meta)) && p(this, _, $).call(this, { type: "fetch", meta: (d = u.fetchOptions) == null ? void 0 : d.meta }), o(this, T, Ve({
+    (f = i(this, bt) === "infinite" ? ls(this.options.pages) : this.options.behavior) == null || f.onFetch(u, this), o(this, wt, this.state), (this.state.fetchStatus === "idle" || this.state.fetchMeta !== ((C = u.fetchOptions) == null ? void 0 : C.meta)) && m(this, H, W).call(this, {
+      type: "fetch",
+      meta: (y = u.fetchOptions) == null ? void 0 : y.meta
+    });
+    const d = o(this, T, _e({
       initialPromise: s == null ? void 0 : s.initialPromise,
       fn: u.fetchFn,
       onCancel: (l) => {
-        l instanceof ie && l.revert && this.setState({
-          ...i(this, Ct),
+        l instanceof Jt && l.revert && this.setState({
+          ...i(this, wt),
           fetchStatus: "idle"
         }), r.abort();
       },
-      onFail: (l, D) => {
-        p(this, _, $).call(this, { type: "failed", failureCount: l, error: D });
+      onFail: (l, x) => {
+        m(this, H, W).call(this, {
+          type: "failed",
+          failureCount: l,
+          error: x
+        });
       },
       onPause: () => {
-        p(this, _, $).call(this, { type: "pause" });
+        m(this, H, W).call(this, { type: "pause" });
       },
       onContinue: () => {
-        p(this, _, $).call(this, { type: "continue" });
+        m(this, H, W).call(this, { type: "continue" });
       },
       retry: u.options.retry,
       retryDelay: u.options.retryDelay,
@@ -680,47 +1033,27 @@ var lt, xe, ze = (xe = class {
       canRun: () => !0
     }));
     try {
-      const l = await i(this, T).start();
+      const l = await d.start();
       if (l === void 0)
-        throw process.env.NODE_ENV !== "production" && console.error(
-          `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`
-        ), new Error(`${this.queryHash} data is undefined`);
-      return this.setData(l), (y = (C = i(this, k).config).onSuccess) == null || y.call(C, l, this), (v = (P = i(this, k).config).onSettled) == null || v.call(
-        P,
-        l,
-        this.state.error,
-        this
-      ), l;
+        throw process.env.NODE_ENV !== "production" && console.error(`Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`), new Error(`${this.queryHash} data is undefined`);
+      return this.setData(l), (D = (R = i(this, _).config).onSuccess) == null || D.call(R, l, this), (q = (O = i(this, _).config).onSettled) == null || q.call(O, l, this.state.error, this), l;
     } catch (l) {
-      if (l instanceof ie) {
-        if (l.silent)
-          return i(this, T).promise;
+      if (l instanceof Jt) {
+        if (l.silent) return i(this, T).promise;
         if (l.revert) {
-          if (this.state.data === void 0)
-            throw l;
+          if (this.state.data === void 0) throw l;
           return this.state.data;
         }
       }
-      throw p(this, _, $).call(this, {
+      throw m(this, H, W).call(this, {
         type: "error",
         error: l
-      }), (S = (b = i(this, k).config).onError) == null || S.call(
-        b,
-        l,
-        this
-      ), (F = (R = i(this, k).config).onSettled) == null || F.call(
-        R,
-        this.state.data,
-        l,
-        this
-      ), l;
+      }), (g = (M = i(this, _).config).onError) == null || g.call(M, l, this), (S = (b = i(this, _).config).onSettled) == null || S.call(b, this.state.data, l, this), l;
     } finally {
-      this.scheduleGc();
+      i(this, T) === d && o(this, T, void 0), this.scheduleGc();
     }
   }
-}, dt = new WeakMap(), Ct = new WeakMap(), k = new WeakMap(), ft = new WeakMap(), T = new WeakMap(), qt = new WeakMap(), yt = new WeakMap(), _ = new WeakSet(), $e = function() {
-  return this.state.fetchStatus === "paused" && this.state.status === "pending";
-}, $ = function(t) {
+}, bt = new WeakMap(), ht = new WeakMap(), wt = new WeakMap(), _ = new WeakMap(), ct = new WeakMap(), T = new WeakMap(), qt = new WeakMap(), lt = new WeakMap(), H = new WeakSet(), W = function(t) {
   const s = (r) => {
     switch (t.type) {
       case "failed":
@@ -742,13 +1075,13 @@ var lt, xe, ze = (xe = class {
       case "fetch":
         return {
           ...r,
-          ...We(r.data, this.options),
+          ...Ke(r.data, this.options),
           fetchMeta: t.meta ?? null
         };
       case "success":
         const n = {
           ...r,
-          ...Pe(t.data, t.dataUpdatedAt),
+          ...be(t.data, t.dataUpdatedAt),
           dataUpdateCount: r.dataUpdateCount + 1,
           ...!t.manual && {
             fetchStatus: "idle",
@@ -756,7 +1089,7 @@ var lt, xe, ze = (xe = class {
             fetchFailureReason: null
           }
         };
-        return o(this, Ct, t.manual ? n : void 0), n;
+        return o(this, wt, t.manual ? n : void 0), n;
       case "error":
         const a = t.error;
         return {
@@ -768,8 +1101,6 @@ var lt, xe, ze = (xe = class {
           fetchFailureReason: a,
           fetchStatus: "idle",
           status: "error",
-          // flag existing data as invalidated if we get a background error
-          // note that "no data" always means stale so we can set unconditionally here
           isInvalidated: !0
         };
       case "invalidate":
@@ -784,24 +1115,28 @@ var lt, xe, ze = (xe = class {
         };
     }
   };
-  this.state = s(this.state), I.batch(() => {
-    this.observers.forEach((r) => {
+  this.state = s(this.state), A.batch(() => {
+    this.observers.slice().forEach((r) => {
       r.onQueryUpdate();
-    }), i(this, k).notify({ query: this, type: "updated", action: t });
+    }), i(this, _).notify({
+      query: this,
+      type: "updated",
+      action: t
+    });
   });
-}, qe);
-function We(e, t) {
+}, Re);
+function Ke(e, t) {
   return {
     fetchFailureCount: 0,
     fetchFailureReason: null,
-    fetchStatus: Be(t.networkMode) ? "fetching" : "paused",
+    fetchStatus: ke(t.networkMode) ? "fetching" : "paused",
     ...e === void 0 && {
       error: null,
       status: "pending"
     }
   };
 }
-function Pe(e, t) {
+function be(e, t) {
   return {
     data: e,
     dataUpdatedAt: t ?? Date.now(),
@@ -810,7 +1145,7 @@ function Pe(e, t) {
     status: "success"
   };
 }
-function Ee(e) {
+function we(e) {
   const t = typeof e.initialData == "function" ? e.initialData() : e.initialData, s = t !== void 0, r = s ? typeof e.initialDataUpdatedAt == "function" ? e.initialDataUpdatedAt() : e.initialDataUpdatedAt : 0;
   return {
     data: t,
@@ -827,539 +1162,496 @@ function Ee(e) {
     fetchStatus: "idle"
   };
 }
-var U, g, jt, q, pt, Ot, W, st, Ut, Pt, Et, mt, vt, rt, Ft, O, Tt, ne, ae, oe, ue, he, ce, le, Je, je, gs = (je = class extends kt {
+var N, v, At, j, dt, St, J, It, Ct, Ot, ft, yt, et, Pt, w, Tt, Zt, Xt, Yt, te, ee, se, re, ie, Me, ys = (Me = class extends Nt {
   constructor(t, s) {
     super();
-    c(this, O);
-    c(this, U);
-    c(this, g);
-    c(this, jt);
-    c(this, q);
-    c(this, pt);
+    c(this, w);
+    c(this, N);
+    c(this, v);
+    c(this, At);
+    c(this, j);
+    c(this, dt);
+    c(this, St);
+    c(this, J);
+    c(this, It);
+    c(this, Ct);
     c(this, Ot);
-    c(this, W);
-    c(this, st);
-    c(this, Ut);
-    c(this, Pt);
-    // 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.
-    c(this, Et);
-    c(this, mt);
-    c(this, vt);
-    c(this, rt);
-    c(this, Ft, /* @__PURE__ */ new Set());
-    this.options = s, o(this, U, t), o(this, st, null), o(this, W, re()), this.bindMethods(), this.setOptions(s);
+    c(this, ft);
+    c(this, yt);
+    c(this, et);
+    c(this, Pt, /* @__PURE__ */ new Set());
+    this.options = s, o(this, N, t), o(this, J, null), this.bindMethods(), this.setOptions(s);
   }
   bindMethods() {
     this.refetch = this.refetch.bind(this);
   }
   onSubscribe() {
-    this.listeners.size === 1 && (i(this, g).addObserver(this), Fe(i(this, g), this.options) ? p(this, O, Tt).call(this) : this.updateResult(), p(this, O, ue).call(this));
+    this.listeners.size === 1 && (i(this, v).addObserver(this), Se(i(this, v), this.options) ? m(this, w, Tt).call(this) : this.updateResult(), m(this, w, ee).call(this));
   }
   onUnsubscribe() {
     this.hasListeners() || this.destroy();
   }
+  /**
+  * Returns whether the observed query is currently stale and configured
+  * (via the `refetchOnReconnect` option) to refetch when the network
+  * reconnects.
+  */
   shouldFetchOnReconnect() {
-    return de(
-      i(this, g),
-      this.options,
-      this.options.refetchOnReconnect
-    );
+    return ne(i(this, v), this.options, this.options.refetchOnReconnect);
   }
+  /**
+  * Returns whether the observed query is currently stale and configured
+  * (via the `refetchOnWindowFocus` option) to refetch when the window
+  * regains focus.
+  */
   shouldFetchOnWindowFocus() {
-    return de(
-      i(this, g),
-      this.options,
-      this.options.refetchOnWindowFocus
-    );
+    return ne(i(this, v), this.options, this.options.refetchOnWindowFocus);
   }
+  /**
+  * Stops observing the current query: clears all listeners, cancels the
+  * stale and refetch-interval timers, and removes this observer from the
+  * query it was observing.
+  */
   destroy() {
-    this.listeners = /* @__PURE__ */ new Set(), p(this, O, he).call(this), p(this, O, ce).call(this), i(this, g).removeObserver(this);
+    this.listeners = /* @__PURE__ */ new Set(), m(this, w, se).call(this), m(this, w, re).call(this), i(this, v).removeObserver(this);
   }
+  /**
+  * Updates the observer's options. This will re-resolve the query being
+  * observed (switching to a different query if the `queryKey` changed),
+  * trigger a fetch if the new options require one and the observer has
+  * subscribers, recompute the current result, and reschedule the stale and
+  * refetch-interval timers as needed.
+  *
+  * @example
+  * ```ts
+  * observer.setOptions({ queryKey: ['posts', 1], queryFn: () => fetchPost(1) })
+  * // later: switch to a different query, reusing the same observer
+  * observer.setOptions({ queryKey: ['posts', 2], queryFn: () => fetchPost(2) })
+  * ```
+  */
   setOptions(t) {
-    const s = this.options, r = i(this, g);
-    if (this.options = i(this, U).defaultQueryOptions(t), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof L(this.options.enabled, i(this, g)) != "boolean")
-      throw new Error(
-        "Expected enabled to be a boolean or a callback that returns a boolean"
-      );
-    p(this, O, le).call(this), i(this, g).setOptions(this.options), s._defaulted && !te(this.options, s) && i(this, U).getQueryCache().notify({
+    const s = this.options, r = i(this, v);
+    if (this.options = i(this, N).defaultQueryOptions(t), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof P(this.options.enabled, i(this, v)) != "boolean") throw new Error("Expected enabled to be a boolean or a callback that returns a boolean");
+    m(this, w, ie).call(this), i(this, v).setOptions(this.options), s._defaulted && !Vt(this.options, s) && i(this, N).getQueryCache().notify({
       type: "observerOptionsUpdated",
-      query: i(this, g),
+      query: i(this, v),
       observer: this
     });
     const n = this.hasListeners();
-    n && Re(
-      i(this, g),
-      r,
-      this.options,
-      s
-    ) && p(this, O, Tt).call(this), this.updateResult(), n && (i(this, g) !== r || L(this.options.enabled, i(this, g)) !== L(s.enabled, i(this, g)) || ot(this.options.staleTime, i(this, g)) !== ot(s.staleTime, i(this, g))) && p(this, O, ne).call(this);
-    const a = p(this, O, ae).call(this);
-    n && (i(this, g) !== r || L(this.options.enabled, i(this, g)) !== L(s.enabled, i(this, g)) || a !== i(this, rt)) && p(this, O, oe).call(this, a);
+    n && Ce(i(this, v), r, this.options, s) && m(this, w, Tt).call(this), this.updateResult(), n && (i(this, v) !== r || P(this.options.enabled, i(this, v)) !== P(s.enabled, i(this, v)) || P(this.options.staleTime, i(this, v)) !== P(s.staleTime, i(this, v))) && m(this, w, Xt).call(this);
+    const a = m(this, w, Yt).call(this);
+    n && (i(this, v) !== r || P(this.options.enabled, i(this, v)) !== P(s.enabled, i(this, v)) || a !== i(this, et)) && m(this, w, te).call(this, a);
   }
+  /**
+  * Computes the result the observer would produce for the given (already-defaulted) options
+  * right now, building the underlying `Query` if it doesn't exist yet, without waiting for a
+  * subscription callback. Called by framework adapters on every render (e.g. `useQuery`) so the
+  * returned value is available synchronously, ahead of `setOptions` triggering an actual fetch.
+  */
   getOptimisticResult(t) {
-    const s = i(this, U).getQueryCache().build(i(this, U), t), r = this.createResult(s, t);
-    return ws(this, r) && (o(this, q, r), o(this, Ot, this.options), o(this, pt, i(this, g).state)), r;
+    const s = i(this, N).getQueryCache().build(i(this, N), t), r = this.createResult(s, t);
+    return Vt(this.getCurrentResult(), r) || (o(this, j, r), o(this, St, this.options), o(this, dt, i(this, v).state)), r;
   }
+  /**
+  * Returns the most recently computed `QueryObserverResult` for the
+  * observed query. This is a point-in-time read; to be notified of updates
+  * as they happen, subscribe to the observer instead (its inherited
+  * `subscribe` method).
+  *
+  * @example
+  * ```ts
+  * const result = observer.getCurrentResult()
+  * console.log(result.status, result.data)
+  * ```
+  */
   getCurrentResult() {
-    return i(this, q);
+    return i(this, j);
   }
+  /**
+  * Wraps a `QueryObserverResult` in a `Proxy` that records which properties are read, via
+  * {@link QueryObserver#trackProp} (and an optional `onPropTracked` callback). Used by framework
+  * adapters when `notifyOnChangeProps` is not set, to implement its default "only re-render on
+  * properties you actually read" behavior.
+  */
   trackResult(t, s) {
-    return new Proxy(t, {
-      get: (r, n) => (this.trackProp(n), s == null || s(n), n === "promise" && (this.trackProp("data"), !this.options.experimental_prefetchInRender && i(this, W).status === "pending" && i(this, W).reject(
-        new Error(
-          "experimental_prefetchInRender feature flag is not enabled"
-        )
-      )), Reflect.get(r, n))
-    });
+    return new Proxy(t, { get: (r, n) => (this.trackProp(n), s == null || s(n), Reflect.get(r, n)) });
   }
+  /**
+  * Records that the given `QueryObserverResult` property was read, so a subsequent update only
+  * notifies this observer if a tracked property actually changed. Normally called indirectly via
+  * {@link QueryObserver#trackResult}'s proxy; exposed directly for adapters that track property
+  * access themselves (e.g. through their own reactivity system) instead of via the proxy.
+  */
   trackProp(t) {
-    i(this, Ft).add(t);
+    i(this, Pt).add(t);
   }
+  /**
+  * Returns the `Query` instance this observer is currently observing.
+  */
   getCurrentQuery() {
-    return i(this, g);
+    return i(this, v);
   }
+  /**
+  * Refetches the observed query and returns a promise that resolves with
+  * the resulting `QueryObserverResult`.
+  *
+  * @example
+  * ```ts
+  * const result = await observer.refetch({ cancelRefetch: false })
+  * console.log(result.data)
+  * ```
+  */
   refetch({ ...t } = {}) {
-    return this.fetch({
-      ...t
-    });
+    return this.fetch({ ...t });
   }
+  /**
+  * Fetches a query defined by the given options without affecting this
+  * observer's own tracked query or result, and returns a promise that
+  * resolves with the `QueryObserverResult` for that fetch. This is useful
+  * for prefetching data that another observer (e.g. a query about to be
+  * navigated to) will need, ahead of time.
+  *
+  * @example
+  * ```ts
+  * const result = await observer.fetchOptimistic({
+  *   queryKey: ['posts', 2],
+  *   queryFn: () => fetchPost(2),
+  * })
+  * console.log(result.data)
+  * ```
+  */
   fetchOptimistic(t) {
-    const s = i(this, U).defaultQueryOptions(t), r = i(this, U).getQueryCache().build(i(this, U), s);
-    return r.fetch().then(() => this.createResult(r, s));
+    const s = i(this, N).defaultQueryOptions(t), r = i(this, N).getQueryCache().build(i(this, N), s);
+    let n = () => {
+    }, a;
+    const h = new Promise((u) => {
+      a = u, n = i(this, N).getQueryCache().subscribe((d) => {
+        d.type === "updated" && d.query.queryHash === r.queryHash && r.state.data !== void 0 && (n(), u(this.createResult(r, s)));
+      });
+    });
+    return Promise.race([r.fetch().then(() => {
+      const u = this.createResult(r, s);
+      return a == null || a(u), u;
+    }).finally(() => {
+      n();
+    }), h]);
   }
   fetch(t) {
-    return p(this, O, Tt).call(this, {
+    return m(this, w, Tt).call(this, {
       ...t,
       cancelRefetch: t.cancelRefetch ?? !0
-    }).then(() => (this.updateResult(), i(this, q)));
+    }).then(() => (this.updateResult(), i(this, j)));
   }
   createResult(t, s) {
-    var Q;
-    const r = i(this, g), n = this.options, a = i(this, q), h = i(this, pt), u = i(this, Ot), m = t !== r ? t.state : i(this, jt), { state: w } = t;
-    let d = { ...w }, C = !1, y;
+    var x;
+    const r = i(this, v), n = this.options, a = i(this, j), h = i(this, dt), u = i(this, St), d = t !== r ? t.state : i(this, At), { state: p } = t;
+    let f = { ...p }, C = !1, y;
     if (s._optimisticResults) {
-      const x = this.hasListeners(), X = !x && Fe(t, s), Lt = x && Re(t, r, s, n);
-      (X || Lt) && (d = {
-        ...d,
-        ...We(w.data, t.options)
-      }), s._optimisticResults === "isRestoring" && (d.fetchStatus = "idle");
+      const Q = this.hasListeners(), K = !Q && Se(t, s), E = Q && Ce(t, r, s, n);
+      (K || E) && (f = {
+        ...f,
+        ...Ke(p.data, t.options)
+      }), s._optimisticResults === "isRestoring" && (f.fetchStatus = "idle");
     }
-    let { error: P, errorUpdatedAt: v, status: b } = d;
-    y = d.data;
-    let S = !1;
-    if (s.placeholderData !== void 0 && y === void 0 && b === "pending") {
-      let x;
-      a != null && a.isPlaceholderData && s.placeholderData === (u == null ? void 0 : u.placeholderData) ? (x = a.data, S = !0) : x = typeof s.placeholderData == "function" ? s.placeholderData(
-        (Q = i(this, Et)) == null ? void 0 : Q.state.data,
-        i(this, Et)
-      ) : s.placeholderData, x !== void 0 && (b = "success", y = se(
-        a == null ? void 0 : a.data,
-        x,
-        s
-      ), C = !0);
+    let { error: R, errorUpdatedAt: D, status: O } = f;
+    y = f.data;
+    let q = !1;
+    if (s.placeholderData !== void 0 && y === void 0 && O === "pending") {
+      let Q;
+      a != null && a.isPlaceholderData && s.placeholderData === (u == null ? void 0 : u.placeholderData) ? (Q = a.data, q = !0) : Q = typeof s.placeholderData == "function" ? s.placeholderData((x = i(this, Ot)) == null ? void 0 : x.state.data, i(this, Ot)) : s.placeholderData, Q !== void 0 && (O = "success", y = Wt(a == null ? void 0 : a.data, Q, s), C = !0);
     }
-    if (s.select && y !== void 0 && !S)
-      if (a && y === (h == null ? void 0 : h.data) && s.select === i(this, Ut))
-        y = i(this, Pt);
-      else
-        try {
-          o(this, Ut, s.select), y = s.select(y), y = se(a == null ? void 0 : a.data, y, s), o(this, Pt, y), o(this, st, null);
-        } catch (x) {
-          o(this, st, x);
-        }
-    i(this, st) && (P = i(this, st), y = i(this, Pt), v = Date.now(), b = "error");
-    const R = d.fetchStatus === "fetching", F = b === "pending", l = b === "error", D = F && R, j = y !== void 0, E = {
-      status: b,
-      fetchStatus: d.fetchStatus,
-      isPending: F,
-      isSuccess: b === "success",
-      isError: l,
-      isInitialLoading: D,
-      isLoading: D,
+    if (s.select && y !== void 0 && !q)
+      if (a && y === (h == null ? void 0 : h.data) && s.select === i(this, It)) y = i(this, Ct);
+      else try {
+        o(this, It, s.select), y = s.select(y), y = Wt(a == null ? void 0 : a.data, y, s), o(this, Ct, y), o(this, J, null);
+      } catch (Q) {
+        o(this, J, Q);
+      }
+    else y === void 0 && o(this, J, null);
+    i(this, J) && (R = i(this, J), y = i(this, Ct), D = Date.now(), O = "error", C = !1);
+    const M = f.fetchStatus === "fetching", g = O === "pending", b = O === "error", S = g && M, l = y !== void 0;
+    return {
+      status: O,
+      fetchStatus: f.fetchStatus,
+      isPending: g,
+      isSuccess: O === "success",
+      isError: b,
+      isInitialLoading: S,
+      isLoading: S,
       data: y,
-      dataUpdatedAt: d.dataUpdatedAt,
-      error: P,
-      errorUpdatedAt: v,
-      failureCount: d.fetchFailureCount,
-      failureReason: d.fetchFailureReason,
-      errorUpdateCount: d.errorUpdateCount,
+      dataUpdatedAt: f.dataUpdatedAt,
+      error: R,
+      errorUpdatedAt: D,
+      failureCount: f.fetchFailureCount,
+      failureReason: f.fetchFailureReason,
+      errorUpdateCount: f.errorUpdateCount,
       isFetched: t.isFetched(),
-      isFetchedAfterMount: d.dataUpdateCount > m.dataUpdateCount || d.errorUpdateCount > m.errorUpdateCount,
-      isFetching: R,
-      isRefetching: R && !F,
-      isLoadingError: l && !j,
-      isPaused: d.fetchStatus === "paused",
+      isFetchedAfterMount: f.dataUpdateCount > d.dataUpdateCount || f.errorUpdateCount > d.errorUpdateCount,
+      isFetching: M,
+      isRefetching: M && !g,
+      isLoadingError: b && !l,
+      isPaused: f.fetchStatus === "paused",
       isPlaceholderData: C,
-      isRefetchError: l && j,
-      isStale: pe(t, s),
+      isRefetchError: b && l,
+      isStale: he(t, s),
       refetch: this.refetch,
-      promise: i(this, W),
-      isEnabled: L(s.enabled, t) !== !1
+      isEnabled: P(s.enabled, t) !== !1
     };
-    if (this.options.experimental_prefetchInRender) {
-      const x = E.data !== void 0, X = E.status === "error" && !x, Lt = (Ht) => {
-        X ? Ht.reject(E.error) : x && Ht.resolve(E.data);
-      }, me = () => {
-        const Ht = o(this, W, E.promise = re());
-        Lt(Ht);
-      }, Kt = i(this, W);
-      switch (Kt.status) {
-        case "pending":
-          t.queryHash === r.queryHash && Lt(Kt);
-          break;
-        case "fulfilled":
-          (X || E.data !== Kt.value) && me();
-          break;
-        case "rejected":
-          (!X || E.error !== Kt.reason) && me();
-          break;
-      }
-    }
-    return E;
   }
+  /**
+  * Recomputes and stores the current result from the current query/options, notifying listeners
+  * if it changed. Framework adapters call this right after subscribing to make sure no query
+  * update was missed in the gap between creating the observer and subscribing to it.
+  */
   updateResult() {
-    const t = i(this, q), s = this.createResult(i(this, g), this.options);
-    if (o(this, pt, i(this, g).state), o(this, Ot, this.options), i(this, pt).data !== void 0 && o(this, Et, i(this, g)), te(s, t))
-      return;
-    o(this, q, s);
-    const r = () => {
-      if (!t)
-        return !0;
-      const { notifyOnChangeProps: n } = this.options, a = typeof n == "function" ? n() : n;
-      if (a === "all" || !a && !i(this, Ft).size)
-        return !0;
-      const h = new Set(
-        a ?? i(this, Ft)
-      );
-      return this.options.throwOnError && h.add("error"), Object.keys(i(this, q)).some((u) => {
-        const f = u;
-        return i(this, q)[f] !== t[f] && h.has(f);
+    const t = i(this, j), s = this.createResult(i(this, v), this.options);
+    if (o(this, dt, i(this, v).state), o(this, St, this.options), i(this, dt).data !== void 0 && o(this, Ot, i(this, v)), Vt(s, t)) return;
+    o(this, j, s);
+    const n = (() => {
+      if (!t) return !0;
+      const { notifyOnChangeProps: a } = this.options, h = typeof a == "function" ? a() : a;
+      if (h === "all" || !h && !i(this, Pt).size) return !0;
+      const u = new Set(h ?? i(this, Pt));
+      return this.options.throwOnError && u.add("error"), Object.keys(i(this, j)).some((d) => {
+        const p = d;
+        return i(this, j)[p] !== t[p] && u.has(p);
       });
-    };
-    p(this, O, Je).call(this, { listeners: r() });
+    })();
+    A.batch(() => {
+      n && this.listeners.forEach((a) => {
+        a(i(this, j));
+      }), i(this, N).getQueryCache().notify({
+        query: i(this, v),
+        type: "observerResultsUpdated"
+      });
+    });
   }
+  /** @internal */
   onQueryUpdate() {
-    this.updateResult(), this.hasListeners() && p(this, O, ue).call(this);
-  }
-}, U = new WeakMap(), g = new WeakMap(), jt = new WeakMap(), q = new WeakMap(), pt = new WeakMap(), Ot = new WeakMap(), W = new WeakMap(), st = new WeakMap(), Ut = new WeakMap(), Pt = new WeakMap(), Et = new WeakMap(), mt = new WeakMap(), vt = new WeakMap(), rt = new WeakMap(), Ft = new WeakMap(), O = new WeakSet(), Tt = function(t) {
-  p(this, O, le).call(this);
-  let s = i(this, g).fetch(
-    this.options,
-    t
-  );
-  return t != null && t.throwOnError || (s = s.catch(N)), s;
-}, ne = function() {
-  p(this, O, he).call(this);
-  const t = ot(
-    this.options.staleTime,
-    i(this, g)
-  );
-  if (xt.isServer() || i(this, q).isStale || !Xt(t))
-    return;
-  const r = Ke(i(this, q).dataUpdatedAt, t) + 1;
-  o(this, mt, ut.setTimeout(() => {
-    i(this, q).isStale || this.updateResult();
-  }, r));
-}, ae = function() {
-  return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(i(this, g)) : this.options.refetchInterval) ?? !1;
-}, oe = function(t) {
-  p(this, O, ce).call(this), o(this, rt, t), !(xt.isServer() || L(this.options.enabled, i(this, g)) === !1 || !Xt(i(this, rt)) || i(this, rt) === 0) && o(this, vt, ut.setInterval(() => {
-    (this.options.refetchIntervalInBackground || fe.isFocused()) && p(this, O, Tt).call(this);
-  }, i(this, rt)));
-}, ue = function() {
-  p(this, O, ne).call(this), p(this, O, oe).call(this, p(this, O, ae).call(this));
-}, he = function() {
-  i(this, mt) && (ut.clearTimeout(i(this, mt)), o(this, mt, void 0));
-}, ce = function() {
-  i(this, vt) && (ut.clearInterval(i(this, vt)), o(this, vt, void 0));
-}, le = function() {
-  const t = i(this, U).getQueryCache().build(i(this, U), this.options);
-  if (t === i(this, g))
-    return;
-  const s = i(this, g);
-  o(this, g, t), o(this, jt, t.state), this.hasListeners() && (s == null || s.removeObserver(this), t.addObserver(this));
-}, Je = function(t) {
-  I.batch(() => {
-    t.listeners && this.listeners.forEach((s) => {
-      s(i(this, q));
-    }), i(this, U).getQueryCache().notify({
-      query: i(this, g),
-      type: "observerResultsUpdated"
-    });
-  });
-}, je);
-function bs(e, t) {
-  return L(t.enabled, e) !== !1 && e.state.data === void 0 && !(e.state.status === "error" && t.retryOnMount === !1);
+    this.updateResult(), this.hasListeners() && m(this, w, ee).call(this);
+  }
+}, N = new WeakMap(), v = new WeakMap(), At = new WeakMap(), j = new WeakMap(), dt = new WeakMap(), St = new WeakMap(), J = new WeakMap(), It = new WeakMap(), Ct = new WeakMap(), Ot = new WeakMap(), ft = new WeakMap(), yt = new WeakMap(), et = new WeakMap(), Pt = new WeakMap(), w = new WeakSet(), Tt = function(t) {
+  m(this, w, ie).call(this);
+  let s = i(this, v).fetch(this.options, t);
+  return t != null && t.throwOnError || (s = s.catch(k)), s;
+}, Zt = function(t) {
+  return !oe() && P(this.options.enabled, i(this, v)) !== !1 && xe(t);
+}, Xt = function() {
+  m(this, w, se).call(this);
+  const t = P(this.options.staleTime, i(this, v));
+  if (i(this, j).isStale || !m(this, w, Zt).call(this, t)) return;
+  const s = Ue(i(this, j).dataUpdatedAt, t) + 1;
+  o(this, ft, nt.setTimeout(() => {
+    i(this, j).isStale || this.updateResult();
+  }, s));
+}, Yt = function() {
+  return P(this.options.refetchInterval, i(this, v)) ?? !1;
+}, te = function(t) {
+  m(this, w, re).call(this), o(this, et, t), !(i(this, et) === 0 || !m(this, w, Zt).call(this, i(this, et))) && o(this, yt, nt.setInterval(() => {
+    (this.options.refetchIntervalInBackground || ue.isFocused()) && m(this, w, Tt).call(this);
+  }, i(this, et)));
+}, ee = function() {
+  m(this, w, Xt).call(this), m(this, w, te).call(this, m(this, w, Yt).call(this));
+}, se = function() {
+  i(this, ft) !== void 0 && (nt.clearTimeout(i(this, ft)), o(this, ft, void 0));
+}, re = function() {
+  i(this, yt) !== void 0 && (nt.clearInterval(i(this, yt)), o(this, yt, void 0));
+}, ie = function() {
+  const t = i(this, N).getQueryCache().build(i(this, N), this.options);
+  if (t === i(this, v)) return;
+  const s = i(this, v);
+  o(this, v, t), o(this, At, t.state), this.hasListeners() && (s == null || s.removeObserver(this), t.addObserver(this));
+}, Me);
+function ps(e, t) {
+  return P(t.enabled, e) !== !1 && e.state.data === void 0 && !(e.state.status === "error" && P(t.retryOnMount, e) === !1);
 }
-function Fe(e, t) {
-  return bs(e, t) || e.state.data !== void 0 && de(e, t, t.refetchOnMount);
+function Se(e, t) {
+  return ps(e, t) || e.state.data !== void 0 && ne(e, t, t.refetchOnMount);
 }
-function de(e, t, s) {
-  if (L(t.enabled, e) !== !1 && ot(t.staleTime, e) !== "static") {
-    const r = typeof s == "function" ? s(e) : s;
-    return r === "always" || r !== !1 && pe(e, t);
+function ne(e, t, s) {
+  if (P(t.enabled, e) !== !1 && P(t.staleTime, e) !== "static") {
+    const r = P(s, e);
+    return r === "always" || r !== !1 && he(e, t);
   }
   return !1;
 }
-function Re(e, t, s, r) {
-  return (e !== t || L(r.enabled, e) === !1) && (!s.suspense || e.state.status !== "error") && pe(e, s);
-}
-function pe(e, t) {
-  return L(t.enabled, e) !== !1 && e.isStaleByTime(ot(t.staleTime, e));
+function Ce(e, t, s, r) {
+  return (e !== t || P(r.enabled, e) === !1) && (!s.suspense || e.state.status !== "error") && he(e, s);
 }
-function ws(e, t) {
-  return !te(e.getCurrentResult(), t);
+function he(e, t) {
+  return P(t.enabled, e) !== !1 && e.isStaleByTime(P(t.staleTime, e));
 }
-function Me(e) {
-  return {
-    onFetch: (t, s) => {
-      var w, d, C, y, P;
-      const r = t.options, n = (C = (d = (w = t.fetchOptions) == null ? void 0 : w.meta) == null ? void 0 : d.fetchMore) == null ? void 0 : C.direction, a = ((y = t.state.data) == null ? void 0 : y.pages) || [], h = ((P = t.state.data) == null ? void 0 : P.pageParams) || [];
-      let u = { pages: [], pageParams: [] }, f = 0;
-      const m = async () => {
-        let v = !1;
-        const b = (F) => {
-          ds(
-            F,
-            () => t.signal,
-            () => v = !0
-          );
-        }, S = He(t.options, t.fetchOptions), R = async (F, l, D) => {
-          if (v)
-            return Promise.reject();
-          if (l == null && F.pages.length)
-            return Promise.resolve(F);
-          const Z = (() => {
-            const X = {
-              client: t.client,
-              queryKey: t.queryKey,
-              pageParam: l,
-              direction: D ? "backward" : "forward",
-              meta: t.options.meta
-            };
-            return b(X), X;
-          })(), E = await S(Z), { maxPages: Q } = t.options, x = D ? ls : cs;
-          return {
-            pages: x(F.pages, E, Q),
-            pageParams: x(F.pageParams, l, Q)
-          };
-        };
-        if (n && a.length) {
-          const F = n === "backward", l = F ? Ss : De, D = {
-            pages: a,
-            pageParams: h
-          }, j = l(r, D);
-          u = await R(D, j, F);
-        } else {
-          const F = e ?? a.length;
-          do {
-            const l = f === 0 ? h[0] ?? r.initialPageParam : De(r, u);
-            if (f > 0 && l == null)
-              break;
-            u = await R(u, l), f++;
-          } while (f < F);
-        }
-        return u;
-      };
-      t.options.persister ? t.fetchFn = () => {
-        var v, b;
-        return (b = (v = t.options).persister) == null ? void 0 : b.call(
-          v,
-          m,
-          {
-            client: t.client,
-            queryKey: t.queryKey,
-            meta: t.options.meta,
-            signal: t.signal
-          },
-          s
-        );
-      } : t.fetchFn = m;
-    }
-  };
-}
-function De(e, { pages: t, pageParams: s }) {
-  const r = t.length - 1;
-  return t.length > 0 ? e.getNextPageParam(
-    t[r],
-    t,
-    s[r],
-    s
-  ) : void 0;
-}
-function Ss(e, { pages: t, pageParams: s }) {
-  var r;
-  return t.length > 0 ? (r = e.getPreviousPageParam) == null ? void 0 : r.call(e, t[0], t, s[0], s) : void 0;
-}
-var Nt, B, A, gt, V, Y, Ue, Cs = (Ue = class extends ze {
+var xt, V, I, pt, $, X, Qe, ms = (Qe = class extends Le {
   constructor(t) {
     super();
+    c(this, $);
+    c(this, xt);
     c(this, V);
-    c(this, Nt);
-    c(this, B);
-    c(this, A);
-    c(this, gt);
-    o(this, Nt, t.client), this.mutationId = t.mutationId, o(this, A, t.mutationCache), o(this, B, []), this.state = t.state || Os(), this.setOptions(t.options), this.scheduleGc();
+    c(this, I);
+    c(this, pt);
+    o(this, xt, t.client), this.mutationId = t.mutationId, o(this, I, t.mutationCache), o(this, V, []), this.state = t.state || vs(), this.setOptions(t.options), this.scheduleGc();
   }
+  /** @internal */
   setOptions(t) {
     this.options = t, this.updateGcTime(this.options.gcTime);
   }
+  /**
+  * The `meta` object passed in the mutation's options, if any.
+  */
   get meta() {
     return this.options.meta;
   }
+  /** @internal */
   addObserver(t) {
-    i(this, B).includes(t) || (i(this, B).push(t), this.clearGcTimeout(), i(this, A).notify({
+    i(this, V).includes(t) || (i(this, V).push(t), this.clearGcTimeout(), i(this, I).notify({
       type: "observerAdded",
       mutation: this,
       observer: t
     }));
   }
+  /** @internal */
   removeObserver(t) {
-    o(this, B, i(this, B).filter((s) => s !== t)), this.scheduleGc(), i(this, A).notify({
+    o(this, V, i(this, V).filter((s) => s !== t)), this.scheduleGc(), i(this, I).notify({
       type: "observerRemoved",
       mutation: this,
       observer: t
     });
   }
   optionalRemove() {
-    i(this, B).length || (this.state.status === "pending" ? this.scheduleGc() : i(this, A).remove(this));
+    i(this, V).length || (this.state.status === "pending" ? this.scheduleGc() : i(this, I).remove(this));
   }
+  /**
+  * Resumes a mutation that is currently paused or was restored from a
+  * dehydrated, still-`pending` state.
+  *
+  * - If this mutation has an active retryer (it paused mid-attempt, e.g. due
+  *   to the network mode or scope-based queuing), its retryer is resumed.
+  * - Otherwise, if the mutation's status is still `pending` (e.g. it was
+  *   dehydrated while an attempt was in flight and never got a retryer in
+  *   this instance), `execute` is called again with the last known variables.
+  * - Otherwise the mutation has already settled and this resolves immediately
+  *   without running anything again.
+  *
+  * @example
+  * ```ts
+  * // typically driven by reconnect handling, e.g. queryClient.resumePausedMutations()
+  * const mutation = mutationCache.find({ mutationKey: ['addPost'] })
+  * await mutation?.continue()
+  * ```
+  *
+  * @see {@link Mutation#execute}
+  */
   continue() {
     var t;
-    return ((t = i(this, gt)) == null ? void 0 : t.continue()) ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
-    this.execute(this.state.variables);
+    return ((t = i(this, pt)) == null ? void 0 : t.continue()) ?? (this.state.status === "pending" ? this.execute(this.state.variables) : Promise.resolve());
   }
+  /**
+  * Runs the mutation function for the given variables through a retryer, and
+  * drives the mutation's state and lifecycle callbacks through to settlement.
+  *
+  * If this mutation's state is already `pending` when `execute` is called
+  * (i.e. it was restored, still in-flight, from a dehydrated state), the
+  * `onMutate` step is skipped and a `continue` action is dispatched to
+  * unpause it; otherwise a `pending` action is dispatched first, then the
+  * mutation cache's `onMutate` and the mutation's own `onMutate` option are
+  * awaited in that order, and the resulting context is stored.
+  *
+  * The mutation function is then run (subject to `retry`/`retryDelay`/
+  * `networkMode`, and to the mutation cache's scope-based serialization).
+  * On success, the cache's `onSuccess`/`onSettled` callbacks run before the
+  * mutation's own `onSuccess`/`onSettled` options, a `success` action is
+  * dispatched, and the resolved data is returned. On failure, the same
+  * cache-then-option ordering is used for `onError`/`onSettled`, but each of
+  * those four callbacks is individually caught so that a throwing callback
+  * cannot mask the original error; an `error` action is then dispatched and
+  * the original error is re-thrown.
+  *
+  * @example
+  * ```ts
+  * // Called internally by `MutationObserver.mutate` and `Mutation.continue` —
+  * // applications normally trigger mutations through those, not this method.
+  * const data = await mutation.execute(variables)
+  * ```
+  *
+  * @see {@link Mutation#continue}
+  */
   async execute(t) {
-    var h, u, f, m, w, d, C, y, P, v, b, S, R, F, l, D, j, Z;
+    var u, d, p, f, C, y, R, D, O, q, M, g, b, S, l, x, Q, K;
     const s = () => {
-      p(this, V, Y).call(this, { type: "continue" });
+      m(this, $, X).call(this, { type: "continue" });
     }, r = {
-      client: i(this, Nt),
+      client: i(this, xt),
       meta: this.options.meta,
       mutationKey: this.options.mutationKey
-    };
-    o(this, gt, Ve({
-      fn: () => this.options.mutationFn ? this.options.mutationFn(t, r) : Promise.reject(new Error("No mutationFn found")),
-      onFail: (E, Q) => {
-        p(this, V, Y).call(this, { type: "failed", failureCount: E, error: Q });
+    }, n = o(this, pt, _e({
+      fn: () => this.options.mutationFn ? this.options.mutationFn(t, r) : Promise.reject(/* @__PURE__ */ new Error("No mutationFn found")),
+      onFail: (E, U) => {
+        m(this, $, X).call(this, {
+          type: "failed",
+          failureCount: E,
+          error: U
+        });
       },
       onPause: () => {
-        p(this, V, Y).call(this, { type: "pause" });
+        m(this, $, X).call(this, { type: "pause" });
       },
       onContinue: s,
       retry: this.options.retry ?? 0,
       retryDelay: this.options.retryDelay,
       networkMode: this.options.networkMode,
-      canRun: () => i(this, A).canRun(this)
-    }));
-    const n = this.state.status === "pending", a = !i(this, gt).canStart();
+      canRun: () => i(this, I).canRun(this)
+    })), a = this.state.status === "pending", h = !n.canStart();
     try {
-      if (n)
-        s();
+      if (a) s();
       else {
-        p(this, V, Y).call(this, { type: "pending", variables: t, isPaused: a }), i(this, A).config.onMutate && await i(this, A).config.onMutate(
-          t,
-          this,
-          r
-        );
-        const Q = await ((u = (h = this.options).onMutate) == null ? void 0 : u.call(
-          h,
-          t,
-          r
-        ));
-        Q !== this.state.context && p(this, V, Y).call(this, {
+        m(this, $, X).call(this, {
           type: "pending",
-          context: Q,
           variables: t,
-          isPaused: a
+          isPaused: h
+        }), i(this, I).config.onMutate && await i(this, I).config.onMutate(t, this, r);
+        const U = await ((d = (u = this.options).onMutate) == null ? void 0 : d.call(u, t, r));
+        U !== this.state.context && m(this, $, X).call(this, {
+          type: "pending",
+          context: U,
+          variables: t,
+          isPaused: h
         });
       }
-      const E = await i(this, gt).start();
-      return await ((m = (f = i(this, A).config).onSuccess) == null ? void 0 : m.call(
-        f,
-        E,
-        t,
-        this.state.context,
-        this,
-        r
-      )), await ((d = (w = this.options).onSuccess) == null ? void 0 : d.call(
-        w,
-        E,
-        t,
-        this.state.context,
-        r
-      )), await ((y = (C = i(this, A).config).onSettled) == null ? void 0 : y.call(
-        C,
-        E,
-        null,
-        this.state.variables,
-        this.state.context,
-        this,
-        r
-      )), await ((v = (P = this.options).onSettled) == null ? void 0 : v.call(
-        P,
-        E,
-        null,
-        t,
-        this.state.context,
-        r
-      )), p(this, V, Y).call(this, { type: "success", data: E }), E;
+      const E = await n.start();
+      return await ((f = (p = i(this, I).config).onSuccess) == null ? void 0 : f.call(p, E, t, this.state.context, this, r)), await ((y = (C = this.options).onSuccess) == null ? void 0 : y.call(C, E, t, this.state.context, r)), await ((D = (R = i(this, I).config).onSettled) == null ? void 0 : D.call(R, E, null, this.state.variables, this.state.context, this, r)), await ((q = (O = this.options).onSettled) == null ? void 0 : q.call(O, E, null, t, this.state.context, r)), m(this, $, X).call(this, {
+        type: "success",
+        data: E
+      }), E;
     } catch (E) {
       try {
-        await ((S = (b = i(this, A).config).onError) == null ? void 0 : S.call(
-          b,
-          E,
-          t,
-          this.state.context,
-          this,
-          r
-        ));
-      } catch (Q) {
-        Promise.reject(Q);
+        await ((g = (M = i(this, I).config).onError) == null ? void 0 : g.call(M, E, t, this.state.context, this, r));
+      } catch (U) {
+        Promise.reject(U);
       }
       try {
-        await ((F = (R = this.options).onError) == null ? void 0 : F.call(
-          R,
-          E,
-          t,
-          this.state.context,
-          r
-        ));
-      } catch (Q) {
-        Promise.reject(Q);
+        await ((S = (b = this.options).onError) == null ? void 0 : S.call(b, E, t, this.state.context, r));
+      } catch (U) {
+        Promise.reject(U);
       }
       try {
-        await ((D = (l = i(this, A).config).onSettled) == null ? void 0 : D.call(
-          l,
-          void 0,
-          E,
-          this.state.variables,
-          this.state.context,
-          this,
-          r
-        ));
-      } catch (Q) {
-        Promise.reject(Q);
+        await ((x = (l = i(this, I).config).onSettled) == null ? void 0 : x.call(l, void 0, E, this.state.variables, this.state.context, this, r));
+      } catch (U) {
+        Promise.reject(U);
       }
       try {
-        await ((Z = (j = this.options).onSettled) == null ? void 0 : Z.call(
-          j,
-          void 0,
-          E,
-          t,
-          this.state.context,
-          r
-        ));
-      } catch (Q) {
-        Promise.reject(Q);
+        await ((K = (Q = this.options).onSettled) == null ? void 0 : K.call(Q, void 0, E, t, this.state.context, r));
+      } catch (U) {
+        Promise.reject(U);
       }
-      throw p(this, V, Y).call(this, { type: "error", error: E }), E;
+      throw m(this, $, X).call(this, {
+        type: "error",
+        error: E
+      }), E;
     } finally {
-      i(this, A).runNext(this);
+      i(this, pt) === n && o(this, pt, void 0), i(this, I).runNext(this);
     }
   }
-}, Nt = new WeakMap(), B = new WeakMap(), A = new WeakMap(), gt = new WeakMap(), V = new WeakSet(), Y = function(t) {
+}, xt = new WeakMap(), V = new WeakMap(), I = new WeakMap(), pt = new WeakMap(), $ = new WeakSet(), X = function(t) {
   const s = (r) => {
     switch (t.type) {
       case "failed":
@@ -1413,17 +1705,17 @@ var Nt, B, A, gt, V, Y, Ue, Cs = (Ue = class extends ze {
         };
     }
   };
-  this.state = s(this.state), I.batch(() => {
-    i(this, B).forEach((r) => {
+  this.state = s(this.state), A.batch(() => {
+    i(this, V).forEach((r) => {
       r.onMutationUpdate(t);
-    }), i(this, A).notify({
+    }), i(this, I).notify({
       mutation: this,
       type: "updated",
       action: t
     });
   });
-}, Ue);
-function Os() {
+}, Qe);
+function vs() {
   return {
     context: void 0,
     data: void 0,
@@ -1436,115 +1728,191 @@ function Os() {
     submittedAt: 0
   };
 }
-var J, H, _t, Ne, Ps = (Ne = class extends kt {
+var Z, B, Ut, Te, gs = (Te = class extends Nt {
   constructor(t = {}) {
     super();
-    c(this, J);
-    c(this, H);
-    c(this, _t);
-    this.config = t, o(this, J, /* @__PURE__ */ new Set()), o(this, H, /* @__PURE__ */ new Map()), o(this, _t, 0);
+    c(this, Z);
+    c(this, B);
+    c(this, Ut);
+    this.config = t, o(this, Z, /* @__PURE__ */ new Set()), o(this, B, /* @__PURE__ */ new Map()), o(this, Ut, 0);
   }
+  /** @internal */
   build(t, s, r) {
-    const n = new Cs({
+    const n = new ms({
       client: t,
       mutationCache: this,
-      mutationId: ++Gt(this, _t)._,
+      mutationId: ++jt(this, Ut)._,
       options: t.defaultMutationOptions(s),
       state: r
     });
     return this.add(n), n;
   }
+  /** @internal */
   add(t) {
-    i(this, J).add(t);
-    const s = Vt(t);
+    i(this, Z).add(t);
+    const s = _t(t);
     if (typeof s == "string") {
-      const r = i(this, H).get(s);
-      r ? r.push(t) : i(this, H).set(s, [t]);
+      const r = i(this, B).get(s);
+      r ? r.push(t) : i(this, B).set(s, [t]);
     }
-    this.notify({ type: "added", mutation: t });
+    this.notify({
+      type: "added",
+      mutation: t
+    });
   }
+  /** @internal */
   remove(t) {
-    if (i(this, J).delete(t)) {
-      const s = Vt(t);
+    if (i(this, Z).delete(t)) {
+      const s = _t(t);
       if (typeof s == "string") {
-        const r = i(this, H).get(s);
+        const r = i(this, B).get(s);
         if (r)
           if (r.length > 1) {
             const n = r.indexOf(t);
             n !== -1 && r.splice(n, 1);
-          } else r[0] === t && i(this, H).delete(s);
+          } else r[0] === t && i(this, B).delete(s);
       }
     }
-    this.notify({ type: "removed", mutation: t });
+    this.notify({
+      type: "removed",
+      mutation: t
+    });
   }
+  /** @internal */
   canRun(t) {
-    const s = Vt(t);
+    var r;
+    const s = _t(t);
     if (typeof s == "string") {
-      const r = i(this, H).get(s), n = r == null ? void 0 : r.find(
-        (a) => a.state.status === "pending"
-      );
+      const n = (r = i(this, B).get(s)) == null ? void 0 : r.find((a) => a.state.status === "pending");
       return !n || n === t;
-    } else
-      return !0;
+    } else return !0;
   }
+  /** @internal */
   runNext(t) {
-    var r;
-    const s = Vt(t);
-    if (typeof s == "string") {
-      const n = (r = i(this, H).get(s)) == null ? void 0 : r.find((a) => a !== t && a.state.isPaused);
-      return (n == null ? void 0 : n.continue()) ?? Promise.resolve();
-    } else
-      return Promise.resolve();
+    var r, n;
+    const s = _t(t);
+    return typeof s == "string" ? ((n = (r = i(this, B).get(s)) == null ? void 0 : r.find((a) => a !== t && a.state.isPaused)) == null ? void 0 : n.continue()) ?? Promise.resolve() : Promise.resolve();
   }
+  /**
+  * Removes all mutations from the cache.
+  *
+  * @example
+  * ```ts
+  * const mutationCache = queryClient.getMutationCache()
+  *
+  * mutationCache.clear()
+  * ```
+  */
   clear() {
-    I.batch(() => {
-      i(this, J).forEach((t) => {
-        this.notify({ type: "removed", mutation: t });
-      }), i(this, J).clear(), i(this, H).clear();
+    A.batch(() => {
+      i(this, Z).forEach((t) => {
+        this.notify({
+          type: "removed",
+          mutation: t
+        });
+      }), i(this, Z).clear(), i(this, B).clear();
     });
   }
+  /**
+  * Returns all mutations within the cache.
+  *
+  * This is not typically needed for most applications, but can come in handy when needing more
+  * information about a mutation in rare scenarios.
+  *
+  * @example
+  * ```ts
+  * const mutationCache = queryClient.getMutationCache()
+  *
+  * const mutations = mutationCache.getAll()
+  * ```
+  */
   getAll() {
-    return Array.from(i(this, J));
+    return Array.from(i(this, Z));
   }
+  /**
+  * A slightly more advanced method that can be used to get an existing mutation instance from
+  * the cache. If the mutation does not exist, `undefined` is returned.
+  *
+  * This is not typically needed for most applications, but can come in handy when needing more
+  * information about a mutation in rare scenarios.
+  *
+  * @see {@link MutationCache#findAll}
+  * @example
+  * ```ts
+  * const mutationCache = queryClient.getMutationCache()
+  *
+  * const mutation = mutationCache.find({ mutationKey: ['addPost'] })
+  * ```
+  */
   find(t) {
-    const s = { exact: !0, ...t };
-    return this.getAll().find(
-      (r) => Se(s, r)
-    );
+    const s = {
+      exact: !0,
+      ...t
+    };
+    return this.getAll().find((r) => pe(s, r));
   }
+  /**
+  * An even more advanced method that can be used to get existing mutation instances from the
+  * cache that match the given filters. If no mutations match, an empty array is returned.
+  *
+  * This is not typically needed for most applications, but can come in handy when needing more
+  * information about mutations in rare scenarios.
+  *
+  * @see {@link MutationCache#find}
+  * @example
+  * ```ts
+  * const mutationCache = queryClient.getMutationCache()
+  *
+  * const mutations = mutationCache.findAll({ mutationKey: ['addPost'] })
+  * ```
+  */
   findAll(t = {}) {
-    return this.getAll().filter((s) => Se(t, s));
+    return this.getAll().filter((s) => pe(t, s));
   }
+  /** @internal */
   notify(t) {
-    I.batch(() => {
+    A.batch(() => {
       this.listeners.forEach((s) => {
         s(t);
       });
     });
   }
+  /** @internal */
   resumePausedMutations() {
     const t = this.getAll().filter((s) => s.state.isPaused);
-    return I.batch(
-      () => Promise.all(
-        t.map((s) => s.continue().catch(N))
-      )
-    );
-  }
-}, J = new WeakMap(), H = new WeakMap(), _t = new WeakMap(), Ne);
-function Vt(e) {
+    return A.batch(() => Promise.all(t.map((s) => s.continue().catch(k))));
+  }
+}, Z = new WeakMap(), B = new WeakMap(), Ut = new WeakMap(), Te);
+function _t(e) {
   var t;
   return (t = e.options.scope) == null ? void 0 : t.id;
 }
-var z, _e, Es = (_e = class extends kt {
+var z, De, bs = (De = class extends Nt {
   constructor(t = {}) {
     super();
     c(this, z);
     this.config = t, o(this, z, /* @__PURE__ */ new Map());
   }
+  /**
+  * Returns the existing `Query` instance for the given options' `queryKey`/`queryHash`, or
+  * builds and adds a new one to the cache if none exists yet. Used by framework adapters and
+  * plugins (e.g. broadcast/persistence) that need to get-or-create a `Query` directly, bypassing
+  * the reactive `QueryObserver` machinery.
+  *
+  * @example
+  * ```ts
+  * const queryCache = queryClient.getQueryCache()
+  *
+  * const query = queryCache.build(queryClient, {
+  *   queryKey: ['posts'],
+  *   queryFn: fetchPosts,
+  * })
+  * ```
+  */
   build(t, s, r) {
-    const n = s.queryKey, a = s.queryHash ?? ye(n, s);
+    const n = s.queryKey, a = s.queryHash ?? ae(n, s);
     let h = this.get(a);
-    return h || (h = new vs({
+    return h || (h = new fs({
       client: t,
       queryKey: n,
       queryHash: a,
@@ -1553,424 +1921,826 @@ var z, _e, Es = (_e = class extends kt {
       defaultOptions: t.getQueryDefaults(n)
     }), this.add(h)), h;
   }
+  /** @internal */
   add(t) {
     i(this, z).has(t.queryHash) || (i(this, z).set(t.queryHash, t), this.notify({
       type: "added",
       query: t
     }));
   }
+  /**
+  * Destroys the given `Query` and removes it from the cache, notifying subscribers with a
+  * `'removed'` event. A no-op if the query is no longer the one currently stored under its hash
+  * (e.g. it was already replaced). Used by plugins (e.g. the broadcast client) that mirror
+  * removals across `QueryCache` instances.
+  *
+  * @example
+  * ```ts
+  * const queryCache = queryClient.getQueryCache()
+  * const query = queryCache.find({ queryKey: ['posts'] })
+  *
+  * if (query) {
+  *   queryCache.remove(query)
+  * }
+  * ```
+  */
   remove(t) {
     const s = i(this, z).get(t.queryHash);
-    s && (t.destroy(), s === t && i(this, z).delete(t.queryHash), this.notify({ type: "removed", query: t }));
+    s && (t.destroy(), s === t && i(this, z).delete(t.queryHash), this.notify({
+      type: "removed",
+      query: t
+    }));
   }
+  /**
+  * Removes all queries from the cache.
+  *
+  * @example
+  * ```ts
+  * const queryCache = queryClient.getQueryCache()
+  *
+  * queryCache.clear()
+  * ```
+  */
   clear() {
-    I.batch(() => {
+    A.batch(() => {
       this.getAll().forEach((t) => {
         this.remove(t);
       });
     });
   }
+  /**
+  * Returns the `Query` instance stored under the given `queryHash`, or `undefined` if none
+  * exists. Unlike {@link QueryCache#find}, this looks up by the already-computed hash rather
+  * than by `QueryFilters`. Used by plugins (e.g. broadcast/hydration) that already have a hash
+  * to look up directly.
+  *
+  * @example
+  * ```ts
+  * const queryCache = queryClient.getQueryCache()
+  * const queryHash = hashKey(['posts'])
+  *
+  * const query = queryCache.get(queryHash)
+  * ```
+  */
   get(t) {
     return i(this, z).get(t);
   }
+  /**
+  * Returns all queries within the cache.
+  *
+  * @example
+  * ```ts
+  * const queryCache = queryClient.getQueryCache()
+  *
+  * const queries = queryCache.getAll()
+  * ```
+  */
   getAll() {
     return [...i(this, z).values()];
   }
+  /**
+  * A slightly more advanced method that can be used to get an existing query instance from the
+  * cache. This instance not only contains all the state for the query, but all of the instances,
+  * and underlying guts of the query as well. If the query does not exist, `undefined` is
+  * returned.
+  *
+  * This is not typically needed for most applications, but can come in handy when needing more
+  * information about a query in rare scenarios (e.g. looking at `query.state.dataUpdatedAt` to
+  * decide whether a query is fresh enough to be used as an initial value).
+  *
+  * @see {@link QueryCache#findAll}
+  * @example
+  * ```ts
+  * const queryCache = queryClient.getQueryCache()
+  *
+  * const query = queryCache.find({ queryKey: ['posts'] })
+  * ```
+  */
   find(t) {
-    const s = { exact: !0, ...t };
-    return this.getAll().find(
-      (r) => we(s, r)
-    );
+    const s = {
+      exact: !0,
+      ...t
+    };
+    return this.getAll().find((r) => ye(s, r));
   }
+  /**
+  * An even more advanced method that can be used to get existing query instances from the cache
+  * that partially match a query key. If no queries match, an empty array is returned.
+  *
+  * This is not typically needed for most applications, but can come in handy when needing more
+  * information about queries in rare scenarios.
+  *
+  * @see {@link QueryCache#find}
+  * @example
+  * ```ts
+  * const queryCache = queryClient.getQueryCache()
+  *
+  * const queries = queryCache.findAll({ queryKey: ['posts'] })
+  * ```
+  */
   findAll(t = {}) {
     const s = this.getAll();
-    return Object.keys(t).length > 0 ? s.filter((r) => we(t, r)) : s;
+    return Object.keys(t).length > 0 ? s.filter((r) => ye(t, r)) : s;
   }
+  /** @internal */
   notify(t) {
-    I.batch(() => {
+    A.batch(() => {
       this.listeners.forEach((s) => {
         s(t);
       });
     });
   }
+  /** @internal */
   onFocus() {
-    I.batch(() => {
+    A.batch(() => {
       this.getAll().forEach((t) => {
         t.onFocus();
       });
     });
   }
+  /** @internal */
   onOnline() {
-    I.batch(() => {
+    A.batch(() => {
       this.getAll().forEach((t) => {
         t.onOnline();
       });
     });
   }
-}, z = new WeakMap(), _e), M, it, nt, Rt, Mt, at, Dt, Qt, ke, Fs = (ke = class {
+}, z = new WeakMap(), De), F, st, rt, Et, Ft, it, Rt, Mt, qe, ws = (qe = class {
   constructor(e = {}) {
-    c(this, M);
+    c(this, F);
+    c(this, st);
+    c(this, rt);
+    c(this, Et);
+    c(this, Ft);
     c(this, it);
-    c(this, nt);
     c(this, Rt);
     c(this, Mt);
-    c(this, at);
-    c(this, Dt);
-    c(this, Qt);
-    o(this, M, e.queryCache || new Es()), o(this, it, e.mutationCache || new Ps()), o(this, nt, e.defaultOptions || {}), o(this, Rt, /* @__PURE__ */ new Map()), o(this, Mt, /* @__PURE__ */ new Map()), o(this, at, 0);
+    o(this, F, e.queryCache || new bs()), o(this, st, e.mutationCache || new gs()), o(this, rt, e.defaultOptions || {}), o(this, Et, /* @__PURE__ */ new Map()), o(this, Ft, /* @__PURE__ */ new Map()), o(this, it, 0);
   }
+  /**
+  * Called by a framework adapter's `QueryClientProvider`-equivalent when it mounts, to start
+  * listening for focus/online events and resume paused mutations. Ref-counted via an internal
+  * mount count, so nested or multiple providers sharing the same `QueryClient` don't tear down
+  * the shared listeners until the last one unmounts.
+  */
   mount() {
-    Gt(this, at)._++, i(this, at) === 1 && (o(this, Dt, fe.subscribe(async (e) => {
-      e && (await this.resumePausedMutations(), i(this, M).onFocus());
-    })), o(this, Qt, Wt.subscribe(async (e) => {
-      e && (await this.resumePausedMutations(), i(this, M).onOnline());
+    jt(this, it)._++, i(this, it) === 1 && (o(this, Rt, ue.subscribe(async (e) => {
+      e && (await this.resumePausedMutations(), i(this, F).onFocus());
+    })), o(this, Mt, Ht.subscribe(async (e) => {
+      e && (await this.resumePausedMutations(), i(this, F).onOnline());
     })));
   }
+  /**
+  * The inverse of {@link QueryClient#mount} — called by a framework adapter's
+  * `QueryClientProvider`-equivalent when it unmounts. Only tears down the focus/online
+  * listeners once the mount count returns to `0`.
+  */
   unmount() {
     var e, t;
-    Gt(this, at)._--, i(this, at) === 0 && ((e = i(this, Dt)) == null || e.call(this), o(this, Dt, void 0), (t = i(this, Qt)) == null || t.call(this), o(this, Qt, void 0));
+    jt(this, it)._--, i(this, it) === 0 && ((e = i(this, Rt)) == null || e.call(this), o(this, Rt, void 0), (t = i(this, Mt)) == null || t.call(this), o(this, Mt, void 0));
   }
+  /**
+  * Returns the number of queries in the cache that are currently fetching, optionally
+  * matching a set of filters. This includes background-fetching, loading new pages, and
+  * loading more infinite query results.
+  *
+  * @example
+  * ```ts
+  * if (queryClient.isFetching()) {
+  *   console.log('At least one query is fetching!')
+  * }
+  * ```
+  */
   isFetching(e) {
-    return i(this, M).findAll({ ...e, fetchStatus: "fetching" }).length;
+    return i(this, F).findAll({
+      ...e,
+      fetchStatus: "fetching"
+    }).length;
   }
+  /**
+  * Returns the number of mutations in the cache that are currently pending, optionally
+  * matching a set of filters.
+  *
+  * @example
+  * ```ts
+  * if (queryClient.isMutating()) {
+  *   console.log('At least one mutation is pending!')
+  * }
+  * ```
+  */
   isMutating(e) {
-    return i(this, it).findAll({ ...e, status: "pending" }).length;
+    return i(this, st).findAll({
+      ...e,
+      status: "pending"
+    }).length;
   }
   /**
-   * Imperative (non-reactive) way to retrieve data for a QueryKey.
-   * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
-   *
-   * Hint: Do not use this function inside a component, because it won't receive updates.
-   * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
-   */
+  * Imperative (non-reactive) way to retrieve data for a QueryKey.
+  * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
+  *
+  * Hint: Do not use this function inside a component, because it won't receive updates.
+  * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
+  *
+  * @see {@link QueryClient#getQueriesData}
+  */
   getQueryData(e) {
     var s;
     const t = this.defaultQueryOptions({ queryKey: e });
-    return (s = i(this, M).get(t.queryHash)) == null ? void 0 : s.state.data;
+    return (s = i(this, F).get(t.queryHash)) == null ? void 0 : s.state.data;
   }
+  /**
+  * @deprecated Use queryClient.query({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
+  */
   ensureQueryData(e) {
-    const t = this.defaultQueryOptions(e), s = i(this, M).build(this, t), r = s.state.data;
-    return r === void 0 ? this.fetchQuery(e) : (e.revalidateIfStale && s.isStaleByTime(ot(t.staleTime, s)) && this.prefetchQuery(t), Promise.resolve(r));
+    const t = this.defaultQueryOptions(e), s = i(this, F).build(this, t), r = s.state.data;
+    return r === void 0 ? this.fetchQuery(e) : (e.revalidateIfStale && s.isStaleByTime(P(t.staleTime, s)) && this.prefetchQuery(t), Promise.resolve(r));
   }
+  /**
+  * Imperative (non-reactive) way to retrieve the cached data of multiple queries at once.
+  * Only queries matching the given filters are returned; if none match, an empty array is
+  * returned.
+  *
+  * Because the matched queries can hold data of different shapes (e.g. a broad filter can match
+  * queries with unrelated data types), the `TQueryFnData` generic defaults to `unknown` rather
+  * than being inferred. Passing a more specific type is a convenience for call sites that know
+  * every matched query holds the same shape — it is not checked against the actual cache
+  * contents.
+  *
+  * @see {@link QueryClient#getQueryData}
+  * @example
+  * ```ts
+  * const data = queryClient.getQueriesData({ queryKey: ['posts'] })
+  * ```
+  */
   getQueriesData(e) {
-    return i(this, M).findAll(e).map(({ queryKey: t, state: s }) => {
-      const r = s.data;
-      return [t, r];
-    });
+    return i(this, F).findAll(e).map(({ queryKey: t, state: s }) => [t, s.data]);
   }
+  /**
+  * Synchronous way to immediately update a query's cached data. If the updater (or the value
+  * passed) resolves to `undefined`, the cache is left untouched and no query is created;
+  * otherwise, if the query does not exist yet, it will be created. To update multiple queries
+  * at once by partially matching query keys, use {@link QueryClient#setQueriesData} instead.
+  *
+  * Updates must be performed immutably: do not mutate `oldData`, or data previously retrieved
+  * via {@link QueryClient#getQueryData}, in place.
+  *
+  * @param queryKey - The query key to set data for.
+  * @param updater - Either the new data, or a function that receives the current data (which
+  * may be `undefined`) and returns the new data.
+  *
+  * @example
+  * ```ts
+  * queryClient.setQueryData(['posts'], newPosts)
+  *
+  * // Or, using an updater function that receives the current data:
+  * queryClient.setQueryData(['posts'], (oldPosts) => [...oldPosts, newPost])
+  * ```
+  */
   setQueryData(e, t, s) {
-    const r = this.defaultQueryOptions({ queryKey: e }), n = i(this, M).get(
-      r.queryHash
-    ), a = n == null ? void 0 : n.state.data, h = os(t, a);
-    if (h !== void 0)
-      return i(this, M).build(this, r).setData(h, { ...s, manual: !0 });
+    var h;
+    const r = this.defaultQueryOptions({ queryKey: e }), n = (h = i(this, F).get(r.queryHash)) == null ? void 0 : h.state.data, a = Ye(t, n);
+    if (a !== void 0)
+      return i(this, F).build(this, r).setData(a, {
+        ...s,
+        manual: !0
+      });
   }
+  /**
+  * Synchronous way to immediately update the cached data of multiple queries at once, using
+  * filters or partial query key matching. Only queries that already exist and match the given
+  * filters are updated; no new cache entries are created. Internally this calls
+  * {@link QueryClient#setQueryData} for each matching query.
+  *
+  * @example
+  * ```ts
+  * queryClient.setQueriesData({ queryKey: ['posts'] }, (oldPosts) =>
+  *   oldPosts ? oldPosts.filter((post) => post.id !== deletedId) : oldPosts,
+  * )
+  * ```
+  */
   setQueriesData(e, t, s) {
-    return I.batch(
-      () => i(this, M).findAll(e).map(({ queryKey: r }) => [
-        r,
-        this.setQueryData(r, t, s)
-      ])
-    );
+    return A.batch(() => i(this, F).findAll(e).map(({ queryKey: r }) => [r, this.setQueryData(r, t, s)]));
   }
+  /**
+  * Imperative (non-reactive) way to retrieve an existing query's state. If the query does not
+  * exist, `undefined` is returned.
+  *
+  * @example
+  * ```ts
+  * const state = queryClient.getQueryState(['posts'])
+  * console.log(state?.dataUpdatedAt)
+  * ```
+  */
   getQueryState(e) {
     var s;
     const t = this.defaultQueryOptions({ queryKey: e });
-    return (s = i(this, M).get(
-      t.queryHash
-    )) == null ? void 0 : s.state;
+    return (s = i(this, F).get(t.queryHash)) == null ? void 0 : s.state;
   }
+  /**
+  * Removes queries from the cache that match the given filters. Unlike
+  * {@link QueryClient#invalidateQueries} or {@link QueryClient#refetchQueries}, this removes
+  * matching queries from the cache instead of refetching them. Without filters, every query in
+  * the cache is removed.
+  *
+  * @example
+  * ```ts
+  * queryClient.removeQueries({ queryKey: ['posts'], exact: true })
+  * ```
+  */
   removeQueries(e) {
-    const t = i(this, M);
-    I.batch(() => {
+    const t = i(this, F);
+    A.batch(() => {
       t.findAll(e).forEach((s) => {
         t.remove(s);
       });
     });
   }
+  /**
+  * Resets queries matching the given filters back to their initial state (e.g. any
+  * `initialData`), notifying subscribers rather than removing them. Active queries among the
+  * matched set are then refetched, and the returned promise resolves once that refetch settles.
+  *
+  * @example
+  * ```ts
+  * await queryClient.resetQueries({ queryKey: ['posts'], exact: true })
+  * ```
+  */
   resetQueries(e, t) {
-    const s = i(this, M);
-    return I.batch(() => (s.findAll(e).forEach((r) => {
-      r.reset();
-    }), this.refetchQueries(
-      {
+    const s = i(this, F);
+    return A.batch(() => {
+      const r = s.findAll(e), n = new Set(r);
+      return r.forEach((a) => {
+        a.reset();
+      }), this.refetchQueries({
         type: "active",
-        ...e
-      },
-      t
-    )));
+        predicate: (a) => n.has(a)
+      }, t);
+    });
   }
+  /**
+  * Cancels outgoing fetches for queries matching the given filters. Most useful when performing
+  * optimistic updates, since any outgoing refetch that resolves afterwards would otherwise
+  * overwrite the optimistic update. By default (`revert: true`), a cancelled query's data is
+  * reverted to its state before the outgoing fetch started.
+  *
+  * The returned promise never rejects, even if individual cancellations fail.
+  *
+  * @example
+  * ```ts
+  * await queryClient.cancelQueries({ queryKey: ['posts'], exact: true })
+  * ```
+  */
   cancelQueries(e, t = {}) {
-    const s = { revert: !0, ...t }, r = I.batch(
-      () => i(this, M).findAll(e).map((n) => n.cancel(s))
-    );
-    return Promise.all(r).then(N).catch(N);
+    const s = {
+      revert: !0,
+      ...t
+    }, r = A.batch(() => i(this, F).findAll(e).map((n) => n.cancel(s)));
+    return Promise.all(r).then(k).catch(k);
   }
+  /**
+  * Marks queries matching the given filters as invalidated. Unlike
+  * {@link QueryClient#removeQueries}, invalidated queries stay in the cache.
+  *
+  * Unless `filters.refetchType` is `'none'`, matching queries are then refetched via
+  * {@link QueryClient#refetchQueries}, using `filters.refetchType` if set, otherwise
+  * `filters.type`, otherwise `'active'`.
+  *
+  * @example
+  * ```ts
+  * await queryClient.invalidateQueries({ queryKey: ['posts'], refetchType: 'active' })
+  * ```
+  */
   invalidateQueries(e, t = {}) {
-    return I.batch(() => (i(this, M).findAll(e).forEach((s) => {
+    return A.batch(() => (i(this, F).findAll(e).forEach((s) => {
       s.invalidate();
-    }), (e == null ? void 0 : e.refetchType) === "none" ? Promise.resolve() : this.refetchQueries(
-      {
-        ...e,
-        type: (e == null ? void 0 : e.refetchType) ?? (e == null ? void 0 : e.type) ?? "active"
-      },
-      t
-    )));
+    }), (e == null ? void 0 : e.refetchType) === "none" ? Promise.resolve() : this.refetchQueries({
+      ...e,
+      type: (e == null ? void 0 : e.refetchType) ?? (e == null ? void 0 : e.type) ?? "active"
+    }, t)));
   }
+  /**
+  * Refetches queries matching the given filters, regardless of whether they are stale. Without
+  * filters, every query in the cache is refetched. Queries that are disabled, or static (only
+  * have observers with a static `staleTime`), are never refetched.
+  *
+  * By default (`cancelRefetch: true`), a currently running fetch is cancelled before the new
+  * one starts. The returned promise resolves once all matching queries have settled; it does
+  * not reject on individual query failures unless `throwOnError` is set.
+  *
+  * @example
+  * ```ts
+  * // refetch all active queries partially matching a query key:
+  * await queryClient.refetchQueries({ queryKey: ['posts'], type: 'active' })
+  * ```
+  */
   refetchQueries(e, t = {}) {
     const s = {
       ...t,
       cancelRefetch: t.cancelRefetch ?? !0
-    }, r = I.batch(
-      () => i(this, M).findAll(e).filter((n) => !n.isDisabled() && !n.isStatic()).map((n) => {
-        let a = n.fetch(void 0, s);
-        return s.throwOnError || (a = a.catch(N)), n.state.fetchStatus === "paused" ? Promise.resolve() : a;
-      })
-    );
-    return Promise.all(r).then(N);
+    }, r = A.batch(() => i(this, F).findAll(e).filter((n) => !n.isDisabled() && !n.isStatic()).map((n) => {
+      let a = n.fetch(void 0, s);
+      return s.throwOnError || (a = a.catch(k)), n.state.fetchStatus === "paused" ? Promise.resolve() : a;
+    }));
+    return Promise.all(r).then(k);
+  }
+  /**
+  * Asynchronous method to fetch and cache a query, resolving with the data or throwing with
+  * the error.
+  *
+  * If the query already exists in the cache and its data is not stale (per the given
+  * `staleTime`), the cached data is returned without fetching. Otherwise, the query is fetched
+  * and the promise resolves once the fetch settles. If a `select` function is provided, it is
+  * applied to the data in both cases (cached or freshly fetched) before it is returned.
+  *
+  * Unlike a reactive observer, retries are disabled by default here (`retry: false`) unless
+  * explicitly configured, since there is no component to catch a thrown error and retry through
+  * re-render.
+  *
+  * The accepted options are `QueryObserverOptions` minus the fields that only make sense for a
+  * reactive observer — `enabled`, `refetchInterval`, `refetchIntervalInBackground`,
+  * `refetchOnWindowFocus`, `refetchOnReconnect`, `refetchOnMount`, `retryOnMount`,
+  * `notifyOnChangeProps`, `throwOnError`, `suspense`, and `placeholderData` are not part of this
+  * method's options.
+  *
+  * This method replaces the deprecated `fetchQuery`, and — combined with
+  * `{ staleTime: 'static' }` — the deprecated `ensureQueryData`.
+  *
+  * @example
+  * ```ts
+  * try {
+  *   const data = await queryClient.query({ queryKey, queryFn, staleTime: 10000 })
+  * } catch (error) {
+  *   console.log(error)
+  * }
+  * ```
+  */
+  async query(e) {
+    const t = this.defaultQueryOptions(e);
+    t.retry === void 0 && (t.retry = !1);
+    const s = i(this, F).build(this, t), r = s.isStaleByTime(P(t.staleTime, s)) ? await s.fetch(t) : s.state.data, n = t.select;
+    return n ? n(r) : r;
   }
+  /**
+  * @deprecated Use queryClient.query(options) instead. This method will be removed in the next major version.
+  */
   fetchQuery(e) {
     const t = this.defaultQueryOptions(e);
     t.retry === void 0 && (t.retry = !1);
-    const s = i(this, M).build(this, t);
-    return s.isStaleByTime(
-      ot(t.staleTime, s)
-    ) ? s.fetch(t) : Promise.resolve(s.state.data);
+    const s = i(this, F).build(this, t);
+    return s.isStaleByTime(P(t.staleTime, s)) ? s.fetch(t) : Promise.resolve(s.state.data);
   }
+  /**
+  * @deprecated Use queryClient.query(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.
+  */
   prefetchQuery(e) {
-    return this.fetchQuery(e).then(N).catch(N);
+    return this.fetchQuery(e).then(k).catch(k);
+  }
+  /**
+  * Asynchronous method to fetch and cache an infinite query, resolving with an
+  * {@link InfiniteData} object or throwing with the error.
+  *
+  * Behaves like {@link QueryClient#query}, accepting the same options (minus
+  * `initialPageParam`), plus the required `initialPageParam`, and an optional `pages` /
+  * `getNextPageParam` pair used to refetch a fixed number of pages from the start.
+  *
+  * This method replaces the deprecated `fetchInfiniteQuery`, and — combined with
+  * `{ staleTime: 'static' }` — the deprecated `ensureInfiniteQueryData`.
+  *
+  * @example
+  * ```ts
+  * try {
+  *   const data = await queryClient.infiniteQuery({ queryKey, queryFn, initialPageParam: 0 })
+  *   console.log(data.pages)
+  * } catch (error) {
+  *   console.log(error)
+  * }
+  * ```
+  */
+  infiniteQuery(e) {
+    return e._type = "infinite", this.query(e);
   }
+  /**
+  * @deprecated Use queryClient.infiniteQuery(options) instead. This method will be removed in the next major version.
+  */
   fetchInfiniteQuery(e) {
-    return e.behavior = Me(e.pages), this.fetchQuery(e);
+    return e._type = "infinite", this.fetchQuery(e);
   }
+  /**
+  * @deprecated Use queryClient.infiniteQuery(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.
+  */
   prefetchInfiniteQuery(e) {
-    return this.fetchInfiniteQuery(e).then(N).catch(N);
+    return this.fetchInfiniteQuery(e).then(k).catch(k);
   }
+  /**
+  * @deprecated Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
+  */
   ensureInfiniteQueryData(e) {
-    return e.behavior = Me(e.pages), this.ensureQueryData(e);
+    return e._type = "infinite", this.ensureQueryData(e);
   }
+  /**
+  * Resumes mutations that were paused because there was no network connection. Does nothing
+  * (resolving immediately) if the client is currently offline.
+  *
+  * @example
+  * ```ts
+  * import { QueryClient } from '@tanstack/query-core'
+  *
+  * const queryClient = new QueryClient()
+  * await queryClient.resumePausedMutations()
+  * ```
+  */
   resumePausedMutations() {
-    return Wt.isOnline() ? i(this, it).resumePausedMutations() : Promise.resolve();
+    return Ht.isOnline() ? i(this, st).resumePausedMutations() : Promise.resolve();
   }
+  /**
+  * Returns the query cache this client is connected to.
+  *
+  * @example
+  * ```ts
+  * import { QueryClient } from '@tanstack/query-core'
+  *
+  * const queryClient = new QueryClient()
+  * const queryCache = queryClient.getQueryCache()
+  * const queries = queryCache.findAll({ queryKey: ['posts'] })
+  * ```
+  */
   getQueryCache() {
-    return i(this, M);
+    return i(this, F);
   }
+  /**
+  * Returns the mutation cache this client is connected to.
+  *
+  * @example
+  * ```ts
+  * import { QueryClient } from '@tanstack/query-core'
+  *
+  * const queryClient = new QueryClient()
+  * const mutationCache = queryClient.getMutationCache()
+  * const mutations = mutationCache.findAll({ status: 'pending' })
+  * ```
+  */
   getMutationCache() {
-    return i(this, it);
+    return i(this, st);
   }
+  /**
+  * Returns the default options that were set when creating the client, or via
+  * {@link QueryClient#setDefaultOptions}.
+  *
+  * @example
+  * ```ts
+  * import { QueryClient } from '@tanstack/query-core'
+  *
+  * const queryClient = new QueryClient()
+  * const defaultOptions = queryClient.getDefaultOptions()
+  * ```
+  */
   getDefaultOptions() {
-    return i(this, nt);
+    return i(this, rt);
   }
+  /**
+  * Dynamically sets the default options for this client, overwriting any previously defined
+  * default options.
+  *
+  * @see {@link QueryClient#getDefaultOptions}
+  * @example
+  * ```ts
+  * import { QueryClient } from '@tanstack/query-core'
+  *
+  * const queryClient = new QueryClient()
+  * queryClient.setDefaultOptions({
+  *   queries: {
+  *     staleTime: Infinity,
+  *   },
+  * })
+  * ```
+  */
   setDefaultOptions(e) {
-    o(this, nt, e);
+    o(this, rt, e);
   }
+  /**
+  * Sets default options for queries whose query key partially matches the given `queryKey`.
+  *
+  * If several registered query defaults match a given query key, they are merged together in
+  * registration order by {@link QueryClient#getQueryDefaults}, so register defaults from the
+  * most generic key to the least generic one — more specific defaults should be registered
+  * after more generic ones so they take precedence.
+  *
+  * @example
+  * ```ts
+  * queryClient.setQueryDefaults(['posts'], { queryFn: fetchPosts })
+  *
+  * await queryClient.query({ queryKey: ['posts'] })
+  * ```
+  */
   setQueryDefaults(e, t) {
-    i(this, Rt).set(It(e), {
+    i(this, Et).set(Dt(e), {
       queryKey: e,
       defaultOptions: t
     });
   }
+  /**
+  * Returns the default options registered for queries whose query key partially matches the
+  * given `queryKey`, via {@link QueryClient#setQueryDefaults}. If multiple registered defaults
+  * match, they are merged together in registration order.
+  *
+  * @example
+  * ```ts
+  * const defaultOptions = queryClient.getQueryDefaults(['posts'])
+  * ```
+  */
   getQueryDefaults(e) {
-    const t = [...i(this, Rt).values()], s = {};
+    const t = [...i(this, Et).values()], s = {};
     return t.forEach((r) => {
-      At(e, r.queryKey) && Object.assign(s, r.defaultOptions);
+      Qt(e, r.queryKey) && Object.assign(s, r.defaultOptions);
     }), s;
   }
+  /**
+  * Sets default options for mutations whose mutation key partially matches the given
+  * `mutationKey`. As with {@link QueryClient#setQueryDefaults}, the order of registration
+  * matters when several registered defaults match the same mutation key.
+  *
+  * @see {@link QueryClient#getMutationDefaults}
+  * @example
+  * ```ts
+  * queryClient.setMutationDefaults(['addPost'], { mutationFn: addPost })
+  * ```
+  */
   setMutationDefaults(e, t) {
-    i(this, Mt).set(It(e), {
+    i(this, Ft).set(Dt(e), {
       mutationKey: e,
       defaultOptions: t
     });
   }
+  /**
+  * Returns the default options registered for mutations whose mutation key partially matches
+  * the given `mutationKey`, via {@link QueryClient#setMutationDefaults}. If multiple registered
+  * defaults match, they are merged together in registration order.
+  *
+  * @example
+  * ```ts
+  * const defaultOptions = queryClient.getMutationDefaults(['addPost'])
+  * ```
+  */
   getMutationDefaults(e) {
-    const t = [...i(this, Mt).values()], s = {};
+    const t = [...i(this, Ft).values()], s = {};
     return t.forEach((r) => {
-      At(e, r.mutationKey) && Object.assign(s, r.defaultOptions);
+      Qt(e, r.mutationKey) && Object.assign(s, r.defaultOptions);
     }), s;
   }
+  /**
+  * Called by framework adapters (e.g. inside `useQuery`) to resolve the options passed by the
+  * caller into their final, defaulted form: merging `queryClient.setQueryDefaults` for the
+  * given `queryKey`, then the client's own `defaultOptions.queries`, then the caller's options
+  * on top. A no-op if the options are already defaulted (`_defaulted: true`).
+  */
   defaultQueryOptions(e) {
-    if (e._defaulted)
-      return e;
+    if (e._defaulted) return e;
     const t = {
-      ...i(this, nt).queries,
+      ...i(this, rt).queries,
       ...this.getQueryDefaults(e.queryKey),
       ...e,
       _defaulted: !0
     };
-    return t.queryHash || (t.queryHash = ye(
-      t.queryKey,
-      t
-    )), t.refetchOnReconnect === void 0 && (t.refetchOnReconnect = t.networkMode !== "always"), t.throwOnError === void 0 && (t.throwOnError = !!t.suspense), !t.networkMode && t.persister && (t.networkMode = "offlineFirst"), t.queryFn === $t && (t.enabled = !1), t;
+    return t.queryHash || (t.queryHash = ae(t.queryKey, t)), t.refetchOnReconnect === void 0 && (t.refetchOnReconnect = t.networkMode !== "always"), t.throwOnError === void 0 && (t.throwOnError = !!t.suspense), !t.networkMode && t.persister && (t.networkMode = "offlineFirst"), t.queryFn === Kt && (t.enabled = !1), t;
   }
+  /**
+  * The mutation counterpart of {@link QueryClient#defaultQueryOptions}. Called by framework
+  * adapters (e.g. inside `useMutation`) to merge `queryClient.setMutationDefaults` for the
+  * given `mutationKey`, then the client's `defaultOptions.mutations`, then the caller's options
+  * on top. A no-op if the options are already defaulted (`_defaulted: true`).
+  */
   defaultMutationOptions(e) {
     return e != null && e._defaulted ? e : {
-      ...i(this, nt).mutations,
+      ...i(this, rt).mutations,
       ...(e == null ? void 0 : e.mutationKey) && this.getMutationDefaults(e.mutationKey),
       ...e,
       _defaulted: !0
     };
   }
+  /**
+  * Clears both the query cache and the mutation cache this client is connected to.
+  *
+  * @example
+  * ```ts
+  * import { QueryClient } from '@tanstack/query-core'
+  *
+  * const queryClient = new QueryClient()
+  * queryClient.clear()
+  * ```
+  */
   clear() {
-    i(this, M).clear(), i(this, it).clear();
-  }
-}, M = new WeakMap(), it = new WeakMap(), nt = new WeakMap(), Rt = new WeakMap(), Mt = new WeakMap(), at = new WeakMap(), Dt = new WeakMap(), Qt = new WeakMap(), ke), Ze = K.createContext(
-  void 0
-), Rs = (e) => {
-  const t = K.useContext(Ze);
-  if (!t)
-    throw new Error("No QueryClient set, use QueryClientProvider to set one");
-  return t;
-}, Ms = ({
-  client: e,
-  children: t
-}) => (K.useEffect(() => (e.mount(), () => {
-  e.unmount();
-}), [e]), /* @__PURE__ */ zt(Ze.Provider, { value: e, children: t })), Xe = K.createContext(!1), Ds = () => K.useContext(Xe);
-Xe.Provider;
-function Qs() {
+    i(this, F).clear(), i(this, st).clear();
+  }
+}, F = new WeakMap(), st = new WeakMap(), rt = new WeakMap(), Et = new WeakMap(), Ft = new WeakMap(), it = new WeakMap(), Rt = new WeakMap(), Mt = new WeakMap(), qe);
+const He = L.createContext(!1), Ss = () => L.useContext(He);
+He.Provider;
+function Cs() {
   let e = !1;
   return {
+    /**
+    * Clears the reset state, so queries know not to try again until the boundary is reset again.
+    */
     clearReset: () => {
       e = !1;
     },
+    /**
+    * Resets any query errors within the boundary, so queries know they can try again.
+    */
     reset: () => {
       e = !0;
     },
+    /**
+    * Returns whether the boundary has been reset and not yet cleared.
+    */
     isReset: () => e
   };
 }
-var Ts = K.createContext(Qs()), Is = () => K.useContext(Ts), As = (e, t, s) => {
-  const r = s != null && s.state.error && typeof e.throwOnError == "function" ? Ge(e.throwOnError, [s.state.error, s]) : e.throwOnError;
-  (e.suspense || e.experimental_prefetchInRender || r) && (t.isReset() || (e.retryOnMount = !1));
-}, xs = (e) => {
-  K.useEffect(() => {
+const Os = L.createContext(Cs()), Ps = () => L.useContext(Os), Es = (e, t, s) => {
+  const r = s != null && s.state.error && typeof e.throwOnError == "function" ? je(e.throwOnError, [s.state.error, s]) : e.throwOnError;
+  (e.suspense || r) && (t.isReset() || (e.retryOnMount = !1));
+}, Fs = (e) => {
+  L.useEffect(() => {
     e.clearReset();
   }, [e]);
-}, qs = ({
-  result: e,
-  errorResetBoundary: t,
-  throwOnError: s,
-  query: r,
-  suspense: n
-}) => e.isError && !t.isReset() && !e.isFetching && r && (n && e.data === void 0 || Ge(s, [e.error, r])), js = (e) => {
+}, Rs = ({ result: e, errorResetBoundary: t, throwOnError: s, query: r, suspense: n }) => e.isError && !t.isReset() && !e.isFetching && r && (n && e.data === void 0 || je(s, [e.error, r])), Ms = (e) => {
   if (e.suspense) {
     const s = (n) => n === "static" ? n : Math.max(n ?? 1e3, 1e3), r = e.staleTime;
-    e.staleTime = typeof r == "function" ? (...n) => s(r(...n)) : s(r), typeof e.gcTime == "number" && (e.gcTime = Math.max(
-      e.gcTime,
-      1e3
-    ));
+    e.staleTime = typeof r == "function" ? (...n) => s(r(...n)) : s(r), typeof e.gcTime == "number" && (e.gcTime = Math.max(e.gcTime, 1e3));
   }
-}, Us = (e, t) => e.isLoading && e.isFetching && !t, Ns = (e, t) => (e == null ? void 0 : e.suspense) && t.isPending, Qe = (e, t, s) => t.fetchOptimistic(e).catch(() => {
+}, Qs = (e, t) => (e == null ? void 0 : e.suspense) && t.isPending, Ts = (e, t, s) => t.fetchOptimistic(e).catch(() => {
   s.clearReset();
 });
-function _s(e, t, s) {
-  var C, y, P, v;
+function Ds(e, t, s) {
   if (process.env.NODE_ENV !== "production" && (typeof e != "object" || Array.isArray(e)))
-    throw new Error(
-      'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
-    );
-  const r = Ds(), n = Is(), a = Rs(), h = a.defaultQueryOptions(e);
-  (y = (C = a.getDefaultOptions().queries) == null ? void 0 : C._experimental_beforeQuery) == null || y.call(
-    C,
-    h
-  );
-  const u = a.getQueryCache().get(h.queryHash);
-  process.env.NODE_ENV !== "production" && (h.queryFn || console.error(
-    `[${h.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
-  )), h._optimisticResults = r ? "isRestoring" : "optimistic", js(h), As(h, n, u), xs(n);
-  const f = !a.getQueryCache().get(h.queryHash), [m] = K.useState(
-    () => new t(
-      a,
-      h
-    )
-  ), w = m.getOptimisticResult(h), d = !r && e.subscribed !== !1;
-  if (K.useSyncExternalStore(
-    K.useCallback(
-      (b) => {
-        const S = d ? m.subscribe(I.batchCalls(b)) : N;
-        return m.updateResult(), S;
-      },
-      [m, d]
-    ),
-    () => m.getCurrentResult(),
-    () => m.getCurrentResult()
-  ), K.useEffect(() => {
-    m.setOptions(h);
-  }, [h, m]), Ns(h, w))
-    throw Qe(h, m, n);
-  if (qs({
-    result: w,
+    throw new Error('Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object');
+  const r = Ss(), n = Ps(), a = $e(), h = a.defaultQueryOptions(e), u = a.getQueryCache().get(h.queryHash);
+  process.env.NODE_ENV !== "production" && (h.queryFn || console.error(`[${h.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`));
+  const d = e.subscribed !== !1;
+  h._optimisticResults = r ? "isRestoring" : d ? "optimistic" : void 0, Ms(h), Es(h, n, u), Fs(n);
+  const [p] = L.useState(() => new t(a, h)), f = p.getOptimisticResult(h), C = !r && d;
+  if (L.useSyncExternalStore(L.useCallback((y) => {
+    const R = C ? p.subscribe(A.batchCalls(y)) : k;
+    return p.updateResult(), R;
+  }, [p, C]), () => p.getCurrentResult(), () => p.getCurrentResult()), L.useEffect(() => {
+    p.setOptions(h);
+  }, [h, p]), Qs(h, f)) throw Ts(h, p, n);
+  if (Rs({
+    result: f,
     errorResetBoundary: n,
     throwOnError: h.throwOnError,
     query: u,
     suspense: h.suspense
-  }))
-    throw w.error;
-  if ((v = (P = a.getDefaultOptions().queries) == null ? void 0 : P._experimental_afterQuery) == null || v.call(
-    P,
-    h,
-    w
-  ), h.experimental_prefetchInRender && !xt.isServer() && Us(w, r)) {
-    const b = f ? (
-      // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
-      Qe(h, m, n)
-    ) : (
-      // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
-      u == null ? void 0 : u.promise
-    );
-    b == null || b.catch(N).finally(() => {
-      m.updateResult();
-    });
-  }
-  return h.notifyOnChangeProps ? w : m.trackResult(w);
+  })) throw f.error;
+  return h.notifyOnChangeProps ? f : p.trackResult(f);
 }
-function ks(e, t) {
-  return _s(e, gs);
+function qs(e, t) {
+  return Ds(e, ys);
 }
-const Ls = Ye(void 0);
-function Ks({
+const As = Be(void 0);
+function Is({
   fetchSchedule: e,
   initialSchedule: t = [],
   weeks: s,
   handleDateChanged: r = () => !0,
   children: n
 }) {
-  const [a, h] = ge(s[0][0].date), [u, f] = ge(!1), m = Le(Zt(s[0][0].date, "yyyy-MM-dd"));
-  Bt.setNamespace("NetworksUILibrary"), Bt.setComponent("ScheduleContext");
-  const w = ts((S) => {
-    const R = Zt(S, "yyyy-MM-dd");
-    R !== m.current && (f(!0), m.current = R), h(S), r(S);
-  }, [r]), { data: d, isLoading: C, isFetching: y, isError: P, error: v } = ks({
-    queryKey: ["schedule", Zt(a, "yyyy-MM-dd")],
+  const [a, h] = de(s[0][0].date), [u, d] = de(!1), p = Ae(Gt(s[0][0].date, "yyyy-MM-dd"));
+  kt.setNamespace("NetworksUILibrary"), kt.setComponent("ScheduleContext");
+  const f = Ge((M) => {
+    const g = Gt(M, "yyyy-MM-dd");
+    g !== p.current && (d(!0), p.current = g), h(M), r(M);
+  }, [r]), { data: C, isLoading: y, isFetching: R, isError: D, error: O } = qs({
+    queryKey: ["schedule", Gt(a, "yyyy-MM-dd")],
     queryFn: () => e(a),
     staleTime: 1e3 * 60 * 15,
     // 15 minutes
     retry: 1
   });
-  be(() => {
-    if (d !== void 0 && u)
-      if (!y) {
-        const R = setTimeout(() => {
-          f(!1);
+  fe(() => {
+    if (C !== void 0 && u)
+      if (!R) {
+        const g = setTimeout(() => {
+          d(!1);
         }, 500);
-        return () => clearTimeout(R);
+        return () => clearTimeout(g);
       } else
-        f(!1);
-  }, [d, u, y]), be(() => {
-    P && (Bt.log("Error fetching schedule for date:", a), Bt.log("Error detials: ", v));
-  }, [a, P, v]);
-  const b = es(() => ({
-    schedule: d ?? t,
+        d(!1);
+  }, [C, u, R]), fe(() => {
+    D && (kt.log("Error fetching schedule for date:", a), kt.log("Error detials: ", O));
+  }, [a, D, O]);
+  const q = Ve(() => ({
+    schedule: C ?? t,
     weeks: s,
     currentDate: a,
-    isLoading: C || u,
-    isError: P,
-    setCurrentDate: w
-  }), [d, t, s, a, C, u, P, w]);
-  return /* @__PURE__ */ zt(Ls.Provider, { value: b, children: n });
+    isLoading: y || u,
+    isError: D,
+    setCurrentDate: f
+  }), [C, t, s, a, y, u, D, f]);
+  return /* @__PURE__ */ Lt(As.Provider, { value: q, children: n });
 }
-function $s(e) {
-  const t = Le(new Fs({
+function _s(e) {
+  const t = Ae(new ws({
     defaultOptions: {
       queries: {
         retry: 1,
@@ -1980,10 +2750,10 @@ function $s(e) {
       }
     }
   }));
-  return /* @__PURE__ */ zt(Ms, { client: t.current, children: /* @__PURE__ */ zt(Ks, { ...e }) });
+  return /* @__PURE__ */ Lt(ze, { client: t.current, children: /* @__PURE__ */ Lt(Is, { ...e }) });
 }
 export {
-  Ls as ScheduleContext,
-  $s as ScheduleProvider,
-  $s as default
+  As as ScheduleContext,
+  _s as ScheduleProvider,
+  _s as default
 };