@hot-updater/console 1.0.0-rc.9 → 1.0.0

package/.output/server/_libs/tanstack__query-core.mjs

@@ -1,110 +1,156 @@
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/subscribable.js
-var Subscribable = class {
-	constructor() {
-		this.listeners = /* @__PURE__ */ new Set();
-		this.subscribe = this.subscribe.bind(this);
-	}
-	subscribe(listener) {
-		this.listeners.add(listener);
-		this.onSubscribe();
-		return () => {
-			this.listeners.delete(listener);
-			this.onUnsubscribe();
-		};
-	}
-	hasListeners() {
-		return this.listeners.size > 0;
-	}
-	onSubscribe() {}
-	onUnsubscribe() {}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/focusManager.js
-var FocusManager = class extends Subscribable {
-	#focused;
-	#cleanup;
-	#setup;
-	constructor() {
-		super();
-		this.#setup = (onFocus) => {
-			if (typeof window !== "undefined" && window.addEventListener) {
-				const listener = () => onFocus();
-				window.addEventListener("visibilitychange", listener, false);
-				return () => {
-					window.removeEventListener("visibilitychange", listener);
-				};
-			}
-		};
-	}
-	onSubscribe() {
-		if (!this.#cleanup) this.setEventListener(this.#setup);
-	}
-	onUnsubscribe() {
-		if (!this.hasListeners()) {
-			this.#cleanup?.();
-			this.#cleanup = void 0;
-		}
-	}
-	setEventListener(setup) {
-		this.#setup = setup;
-		this.#cleanup?.();
-		this.#cleanup = setup((focused) => {
-			if (typeof focused === "boolean") this.setFocused(focused);
-			else this.onFocus();
-		});
-	}
-	setFocused(focused) {
-		if (this.#focused !== focused) {
-			this.#focused = focused;
-			this.onFocus();
-		}
-	}
-	onFocus() {
-		const isFocused = this.isFocused();
-		this.listeners.forEach((listener) => {
-			listener(isFocused);
-		});
-	}
-	isFocused() {
-		if (typeof this.#focused === "boolean") return this.#focused;
-		return globalThis.document?.visibilityState !== "hidden";
-	}
-};
-var focusManager = new FocusManager();
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/timeoutManager.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/timeoutManager.js
 var defaultTimeoutProvider = {
 	setTimeout: (callback, delay) => setTimeout(callback, delay),
 	clearTimeout: (timeoutId) => clearTimeout(timeoutId),
 	setInterval: (callback, delay) => setInterval(callback, delay),
 	clearInterval: (intervalId) => clearInterval(intervalId)
 };
+/**
+* Allows customization of how timeouts are created.
+*
+* @tanstack/query-core makes liberal use of timeouts to implement `staleTime`
+* and `gcTime`. The default TimeoutManager provider uses the platform's global
+* `setTimeout` implementation, which is known to have scalability issues with
+* thousands of timeouts on the event loop.
+*
+* If you hit this limitation, consider providing a custom TimeoutProvider that
+* coalesces timeouts.
+*/
 var TimeoutManager = class {
 	#provider = defaultTimeoutProvider;
 	#providerCalled = false;
+	/**
+	* `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(provider) {
 		this.#provider = provider;
 	}
+	/**
+	* `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(callback, delay) {
 		return this.#provider.setTimeout(callback, delay);
 	}
+	/**
+	* `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(timeoutId) {
 		this.#provider.clearTimeout(timeoutId);
 	}
+	/**
+	* `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(callback, delay) {
 		return this.#provider.setInterval(callback, delay);
 	}
+	/**
+	* `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(intervalId) {
 		this.#provider.clearInterval(intervalId);
 	}
 };
+/**
+* Singleton instance of {@link TimeoutManager}, used throughout TanStack Query to schedule and cancel timers.
+*/
 var timeoutManager = new TimeoutManager();
+/**
+* In many cases code wants to delay to the next event loop tick; this is not
+* mediated by {@link timeoutManager}.
+*
+* This function is provided to make auditing the `tanstack/query-core` for
+* incorrect use of system `setTimeout` easier.
+*/
 function systemSetTimeoutZero(callback) {
 	setTimeout(callback, 0);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/utils.js
-var isServer = typeof window === "undefined" || "Deno" in globalThis;
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/utils.js
+/** @deprecated
+* use `environmentManager.isServer()` instead.
+*/
+var isServer$1 = typeof window === "undefined" || "Deno" in globalThis;
 function noop() {}
 function functionalUpdate(updater, input) {
 	return typeof updater === "function" ? updater(input) : updater;
@@ -115,12 +161,22 @@ function isValidTimeout(value) {
 function timeUntilStale(updatedAt, staleTime) {
 	return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
 }
-function resolveStaleTime(staleTime, query) {
-	return typeof staleTime === "function" ? staleTime(query) : staleTime;
-}
-function resolveQueryBoolean(option, query) {
-	return typeof option === "function" ? option(query) : option;
+function resolveQueryValue(value, query) {
+	return typeof value === "function" ? value(query) : value;
 }
+/**
+* Checks whether a query matches the given {@link QueryFilters}.
+* Every filter that is specified must match; filters that are left unspecified are ignored.
+*
+* @example
+* ```ts
+* const queryCache = queryClient.getQueryCache()
+*
+* const matchingQueries = queryCache
+*   .getAll()
+*   .filter((query) => matchQuery({ queryKey: ['posts'] }, query))
+* ```
+*/
 function matchQuery(filters, query) {
 	const { type = "all", exact, fetchStatus, predicate, queryKey, stale } = filters;
 	if (queryKey) {
@@ -138,6 +194,20 @@ function matchQuery(filters, query) {
 	if (predicate && !predicate(query)) return false;
 	return true;
 }
+/**
+* Checks whether a mutation matches the given {@link MutationFilters}.
+* Every filter that is specified must match; filters that are left unspecified are ignored.
+* If a `mutationKey` filter is provided but the mutation has no `mutationKey` of its own, it does not match.
+*
+* @example
+* ```ts
+* const mutationCache = queryClient.getMutationCache()
+*
+* const matchingMutations = mutationCache
+*   .getAll()
+*   .filter((mutation) => matchMutation({ mutationKey: ['addPost'] }, mutation))
+* ```
+*/
 function matchMutation(filters, mutation) {
 	const { exact, status, predicate, mutationKey } = filters;
 	if (mutationKey) {
@@ -153,6 +223,16 @@ function matchMutation(filters, mutation) {
 function hashQueryKeyByOptions(queryKey, options) {
 	return (options?.queryKeyHashFn || hashKey)(queryKey);
 }
+/**
+* Default query & mutation keys hash function.
+* Hashes the value into a stable hash.
+*
+* @example
+* ```ts
+* // Object keys are sorted, so key order doesn't affect the hash:
+* hashKey(['todos', { page: 1, filter: 'done' }]) // === '["todos",{"filter":"done","page":1}]'
+* ```
+*/
 function hashKey(queryKey) {
 	return JSON.stringify(queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
 		result[key] = val[key];
@@ -162,7 +242,16 @@ function hashKey(queryKey) {
 function partialMatchKey(a, b) {
 	if (a === b) return true;
 	if (typeof a !== typeof b) return false;
-	if (a && b && typeof a === "object" && typeof b === "object") return Object.keys(b).every((key) => partialMatchKey(a[key], b[key]));
+	if (a && b && typeof a === "object" && typeof b === "object") {
+		if (Array.isArray(a) && Array.isArray(b)) {
+			if (b.length > a.length) return false;
+			for (let i = 0; i < b.length; i++) if (!partialMatchKey(a[i], b[i])) return false;
+			return true;
+		}
+		const bKeys = Object.keys(b);
+		for (const key of bKeys) if (!partialMatchKey(a[key], b[key])) return false;
+		return true;
+	}
 	return false;
 }
 var hasOwn = Object.prototype.hasOwnProperty;
@@ -195,6 +284,9 @@ function replaceEqualDeep(a, b, depth = 0) {
 	}
 	return aSize === bSize && equalItems === aSize ? a : copy;
 }
+/**
+* Shallow compare objects.
+*/
 function shallowEqualObjects(a, b) {
 	if (!b || Object.keys(a).length !== Object.keys(b).length) return false;
 	for (const key in a) if (a[key] !== b[key]) return false;
@@ -205,12 +297,14 @@ function isPlainArray(value) {
 }
 function isPlainObject(o) {
 	if (!hasObjectPrototype(o)) return false;
-	const ctor = o.constructor;
+	const objectPrototype = Object.getPrototypeOf(o);
+	const ctor = objectPrototype?.constructor;
 	if (ctor === void 0) return true;
+	if (typeof ctor !== "function") return false;
 	const prot = ctor.prototype;
 	if (!hasObjectPrototype(prot)) return false;
 	if (!prot.hasOwnProperty("isPrototypeOf")) return false;
-	if (Object.getPrototypeOf(o) !== Object.prototype) return false;
+	if (objectPrototype !== Object.prototype) return false;
 	return true;
 }
 function hasObjectPrototype(o) {
@@ -226,6 +320,23 @@ function replaceData(prevData, data, options) {
 	else if (options.structuralSharing !== false) return replaceEqualDeep(prevData, data);
 	return data;
 }
+/**
+* Intended to be passed as a query's `placeholderData` option, for example
+* `placeholderData: keepPreviousData`. Instead of resetting the query's data to `undefined` while a new
+* query key is fetching, it keeps displaying the previously fetched data until the new data arrives.
+*
+* @example
+* ```ts
+* new QueryObserver(queryClient, {
+*   queryKey: ['posts', page],
+*   queryFn: () => fetchPosts(page),
+*   placeholderData: keepPreviousData,
+* })
+* ```
+*/
+function keepPreviousData(previousData) {
+	return previousData;
+}
 function addToEnd(items, item, max = 0) {
 	const newItems = [...items, item];
 	return max && newItems.length > max ? newItems.slice(1) : newItems;
@@ -234,12 +345,40 @@ function addToStart(items, item, max = 0) {
 	const newItems = [item, ...items];
 	return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
 }
-var skipToken = /* @__PURE__ */ Symbol();
+/**
+* Sentinel value that can be passed as a query's `queryFn` to conditionally disable the query (equivalent
+* to `enabled: false`) while preserving full type inference for the query's data. Unlike `enabled: false`,
+* a query disabled via `skipToken` cannot be triggered with `refetch`.
+*
+* @example
+* ```ts
+* new QueryObserver(queryClient, {
+*   queryKey: ['post', postId],
+*   queryFn: postId != null ? () => fetchPost(postId) : skipToken,
+* })
+* ```
+*/
+var skipToken = Symbol();
 function ensureQueryFn(options, fetchOptions) {
 	if (!options.queryFn && fetchOptions?.initialPromise) return () => fetchOptions.initialPromise;
 	if (!options.queryFn || options.queryFn === skipToken) return () => Promise.reject(/* @__PURE__ */ new Error(`Missing queryFn: '${options.queryHash}'`));
 	return options.queryFn;
 }
+/**
+* Resolves a `throwOnError` option to a boolean.
+* If `throwOnError` is a function, it is called with `params` (e.g. the error and, depending on the caller,
+* additional context such as the query or mutation) and its result is returned, allowing the throwing
+* behavior to be decided per error. Otherwise, `throwOnError` itself is coerced to a boolean (`undefined`
+* resolves to `false`).
+*
+* @example
+* ```ts
+* const throwOnError =
+*   query.state.error && typeof options.throwOnError === 'function'
+*     ? shouldThrowError(options.throwOnError, [query.state.error, query])
+*     : options.throwOnError
+* ```
+*/
 function shouldThrowError(throwOnError, params) {
 	if (typeof throwOnError === "function") return throwOnError(...params);
 	return !!throwOnError;
@@ -261,136 +400,244 @@ function addConsumeAwareSignal(object, getSignal, onCancelled) {
 	return object;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/environmentManager.js
-var environmentManager = /* @__PURE__ */ (() => {
-	let isServerFn = () => isServer;
-	return {
-		isServer() {
-			return isServerFn();
-		},
-		setIsServer(isServerValue) {
-			isServerFn = isServerValue;
-		}
-	};
-})();
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/environmentManager.js
+var isServerFn = () => isServer$1;
+/**
+* Returns whether the current runtime should be treated as a server environment.
+*/
+var isServer = () => isServerFn();
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/thenable.js
-function pendingThenable() {
-	let resolve;
-	let reject;
-	const thenable = new Promise((_resolve, _reject) => {
-		resolve = _resolve;
-		reject = _reject;
-	});
-	thenable.status = "pending";
-	thenable.catch(() => {});
-	function finalize(data) {
-		Object.assign(thenable, data);
-		delete thenable.resolve;
-		delete thenable.reject;
-	}
-	thenable.resolve = (value) => {
-		finalize({
-			status: "fulfilled",
-			value
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/subscribable.js
+/**
+* The base class behind everything in Query that you can subscribe to: `QueryCache`, `MutationCache`,
+* the observers, and the `FocusManager`/`OnlineManager` behind `focusManager` and `onlineManager`.
+* Subclasses decide what a listener receives and when it is called.
+*/
+var Subscribable = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Set();
+		this.subscribe = this.subscribe.bind(this);
+	}
+	/**
+	* Registers a listener to be called on every update this object notifies about. Returns a function
+	* that removes the listener again — call it to stop listening. The base class never drops a listener
+	* on its own, though some subclasses clear all of theirs in `destroy()`.
+	* @param listener - Called on each update, with whatever the subclass passes to its subscribers.
+	* @example
+	* ```ts
+	* const unsubscribe = subscribable.subscribe(() => {
+	*   // react to the update
+	* })
+	*
+	* unsubscribe()
+	* ```
+	*/
+	subscribe(listener) {
+		this.listeners.add(listener);
+		this.onSubscribe();
+		return () => {
+			this.listeners.delete(listener);
+			this.onUnsubscribe();
+		};
+	}
+	/**
+	* Returns `true` while at least one listener is registered, `false` once they have all unsubscribed.
+	*/
+	hasListeners() {
+		return this.listeners.size > 0;
+	}
+	onSubscribe() {}
+	onUnsubscribe() {}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/focusManager.js
+/**
+* The `FocusManager` manages the focus state within TanStack Query.
+*
+* It can be used to change the default event listeners or to manually change the focus state.
+*/
+var FocusManager = class extends Subscribable {
+	#focused;
+	#cleanup;
+	#setup;
+	constructor() {
+		super();
+		this.#setup = (onFocus) => {
+			if (typeof window !== "undefined" && window.addEventListener) {
+				const listener = () => onFocus();
+				window.addEventListener("visibilitychange", listener, false);
+				return () => {
+					window.removeEventListener("visibilitychange", listener);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		if (!this.#cleanup) this.setEventListener(this.#setup);
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) {
+			this.#cleanup?.();
+			this.#cleanup = 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(setup) {
+		this.#setup = setup;
+		this.#cleanup?.();
+		this.#cleanup = setup((focused) => {
+			if (typeof focused === "boolean") this.setFocused(focused);
+			else this.onFocus();
 		});
-		resolve(value);
-	};
-	thenable.reject = (reason) => {
-		finalize({
-			status: "rejected",
-			reason
+	}
+	/**
+	* `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(focused) {
+		if (this.#focused !== focused) {
+			this.#focused = focused;
+			this.onFocus();
+		}
+	}
+	/**
+	* `onFocus` notifies all subscribed listeners with the current focus state.
+	*/
+	onFocus() {
+		const isFocused = this.isFocused();
+		this.listeners.forEach((listener) => {
+			listener(isFocused);
 		});
-		reject(reason);
-	};
-	return thenable;
-}
+	}
+	/**
+	* `isFocused` can be used to get the current focus state.
+	*/
+	isFocused() {
+		if (typeof this.#focused === "boolean") return this.#focused;
+		return globalThis.document?.visibilityState !== "hidden";
+	}
+};
+/**
+* Singleton instance of {@link FocusManager}, used to manage and observe the focus state within TanStack Query.
+*/
+var focusManager = new FocusManager();
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/hydration.js
 function tryResolveSync(promise) {
 	let data;
 	promise.then((result) => {
 		data = result;
 		return result;
-	}, noop)?.catch(noop);
+	}, noop)?.catch?.(noop);
 	if (data !== void 0) return { data };
 }
-//#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/hydration.js
-function defaultTransformerFn(data) {
-	return data;
-}
-function dehydrateMutation(mutation) {
-	return {
-		mutationKey: mutation.options.mutationKey,
-		state: mutation.state,
-		...mutation.options.scope && { scope: mutation.options.scope },
-		...mutation.meta && { meta: mutation.meta }
-	};
+function dehydratePromise(query, serializeData, shouldRedactErrors) {
+	const promise = query.promise?.then(serializeData).catch((error) => {
+		if (shouldRedactErrors?.(error) === false) return Promise.reject(error);
+		return Promise.reject(/* @__PURE__ */ new Error("redacted"));
+	});
+	promise?.catch(noop);
+	return promise;
 }
+/**
+* Dehydrates a single `Query` into a serializable `DehydratedQuery` snapshot. Note that most query config (e.g.
+* `queryFn`, `staleTime`) is not dehydrated but instead meant to be configured again when consuming the
+* de/rehydrated data, typically with `useQuery` on the client. If the query is still `pending`, its in-flight
+* promise is dehydrated too so it can be resumed on the other side instead of re-fetched.
+* @param query - The query to dehydrate.
+* @param serializeData - Optional transform applied to `query.state.data` before it is included in the snapshot.
+* @param shouldRedactErrors - Optional predicate; if it returns `false` for the promise's rejection error, that
+* error is kept as-is instead of being redacted.
+*/
 function dehydrateQuery(query, serializeData, shouldRedactErrors) {
-	const dehydratePromise = () => {
-		const promise = query.promise?.then(serializeData).catch((error) => {
-			if (!shouldRedactErrors(error)) return Promise.reject(error);
-			return Promise.reject(/* @__PURE__ */ new Error("redacted"));
-		});
-		promise?.catch(noop);
-		return promise;
-	};
 	return {
 		dehydratedAt: Date.now(),
 		state: {
 			...query.state,
-			...query.state.data !== void 0 && { data: serializeData(query.state.data) }
+			...query.state.data !== void 0 && { data: serializeData ? serializeData(query.state.data) : query.state.data }
 		},
 		queryKey: query.queryKey,
 		queryHash: query.queryHash,
-		...query.state.status === "pending" && { promise: dehydratePromise() },
+		...query.state.status === "pending" && { promise: dehydratePromise(query, serializeData, shouldRedactErrors) },
 		...query.meta && { meta: query.meta },
 		...query.queryType && { queryType: query.queryType }
 	};
 }
-function defaultShouldDehydrateMutation(mutation) {
-	return mutation.state.isPaused;
-}
-function defaultShouldDehydrateQuery(query) {
-	return query.state.status === "success";
-}
-function defaultShouldRedactErrors(_) {
-	return true;
-}
-function dehydrate(client, options = {}) {
-	const filterMutation = options.shouldDehydrateMutation ?? client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ?? defaultShouldDehydrateMutation;
-	const mutations = client.getMutationCache().getAll().flatMap((mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []);
-	const filterQuery = options.shouldDehydrateQuery ?? client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ?? defaultShouldDehydrateQuery;
-	const shouldRedactErrors = options.shouldRedactErrors ?? client.getDefaultOptions().dehydrate?.shouldRedactErrors ?? defaultShouldRedactErrors;
-	const serializeData = options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData ?? defaultTransformerFn;
-	return {
-		mutations,
-		queries: client.getQueryCache().getAll().flatMap((query) => filterQuery(query) ? [dehydrateQuery(query, serializeData, shouldRedactErrors)] : [])
-	};
-}
+/**
+* Restores a `DehydratedState` (as produced by `dehydrate`) into a `QueryClient`'s cache, typically to seed the
+* client with data already fetched on the server. `mutations` and `queries` are each optional on `dehydratedState`.
+* Queries not yet in the cache are built from the dehydrated snapshot; queries that already exist are only updated
+* when the dehydrated data is newer than what's already cached. Newly built queries have their `fetchStatus` reset
+* to `'idle'` so they don't hydrate stuck in a fetching state. If a dehydrated query still had an in-flight
+* promise, it is resumed via `query.fetch()` (reusing that promise as `initialPromise`) rather than re-invoking
+* `queryFn`.
+* @example
+* ```ts
+* // dehydratedState was produced by `dehydrate` on the server
+* // and sent to the client, e.g. embedded in server-rendered markup.
+* const queryClient = new QueryClient()
+*
+* hydrate(queryClient, dehydratedState)
+* ```
+*/
 function hydrate(client, dehydratedState, options) {
-	if (typeof dehydratedState !== "object" || dehydratedState === null) return;
 	const mutationCache = client.getMutationCache();
 	const queryCache = client.getQueryCache();
-	const deserializeData = options?.defaultOptions?.deserializeData ?? client.getDefaultOptions().hydrate?.deserializeData ?? defaultTransformerFn;
-	const mutations = dehydratedState.mutations || [];
-	const queries = dehydratedState.queries || [];
-	mutations.forEach(({ state, ...mutationOptions }) => {
+	const deserializeData = options?.defaultOptions?.deserializeData ?? client.getDefaultOptions().hydrate?.deserializeData;
+	dehydratedState.mutations?.forEach(({ state, ...mutationOptions }) => {
 		mutationCache.build(client, {
 			...client.getDefaultOptions().hydrate?.mutations,
 			...options?.defaultOptions?.mutations,
 			...mutationOptions
 		}, state);
 	});
-	queries.forEach(({ queryKey, state, queryHash, meta, promise, dehydratedAt, queryType }) => {
+	dehydratedState.queries?.forEach(({ queryKey, state, queryHash, meta, promise, dehydratedAt, queryType }) => {
 		const syncData = promise ? tryResolveSync(promise) : void 0;
 		const rawData = state.data === void 0 ? syncData?.data : state.data;
-		const data = rawData === void 0 ? rawData : deserializeData(rawData);
+		const data = rawData === void 0 ? rawData : deserializeData ? deserializeData(rawData) : rawData;
 		let query = queryCache.get(queryHash);
 		const existingQueryIsPending = query?.state.status === "pending";
 		const existingQueryIsFetching = query?.state.fetchStatus === "fetching";
 		if (query) {
-			const hasNewerSyncData = syncData && dehydratedAt !== void 0 && dehydratedAt > query.state.dataUpdatedAt;
+			const hasNewerSyncData = syncData && dehydratedAt > query.state.dataUpdatedAt;
 			if (state.dataUpdatedAt > query.state.dataUpdatedAt || hasNewerSyncData) {
 				const { fetchStatus: _ignored, ...serializedState } = state;
 				query.setState({
@@ -398,6 +645,7 @@ function hydrate(client, dehydratedState, options) {
 					data,
 					...state.status === "pending" && data !== void 0 && {
 						status: "success",
+						dataUpdatedAt: dehydratedAt,
 						...!existingQueryIsFetching && { fetchStatus: "idle" }
 					}
 				});
@@ -413,13 +661,18 @@ function hydrate(client, dehydratedState, options) {
 			...state,
 			data,
 			fetchStatus: "idle",
-			status: state.status === "pending" && data !== void 0 ? "success" : state.status
+			status: state.status === "pending" && data !== void 0 ? "success" : state.status,
+			...state.status === "pending" && data !== void 0 && { dataUpdatedAt: dehydratedAt }
 		});
-		if (promise && !syncData && !existingQueryIsPending && !existingQueryIsFetching && (dehydratedAt === void 0 || dehydratedAt > query.state.dataUpdatedAt)) query.fetch(void 0, { initialPromise: Promise.resolve(promise).then(deserializeData) }).catch(noop);
+		if (promise && !syncData && !existingQueryIsPending && !existingQueryIsFetching && dehydratedAt > query.state.dataUpdatedAt) query.fetch(void 0, { initialPromise: Promise.resolve(promise).then(deserializeData) }).catch(noop);
 	});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/notifyManager.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/notifyManager.js
+/**
+* Default scheduling function used by the notify manager.
+* Schedules the callback with the system's `setTimeout(callback, 0)`.
+*/
 var defaultScheduler = systemSetTimeoutZero;
 function createNotifyManager() {
 	let queue = [];
@@ -479,9 +732,21 @@ function createNotifyManager() {
 		}
 	};
 }
+/**
+* Handles scheduling and batching callbacks in TanStack Query.
+*/
 var notifyManager = createNotifyManager();
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/onlineManager.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/onlineManager.js
+/**
+* The `OnlineManager` manages the online state within TanStack Query. It can
+* be used to change the default event listeners or to manually change the
+* online state.
+*
+* By default, the `onlineManager` assumes an active network connection, and
+* listens to the `online` and `offline` events on the `window` object to
+* detect changes.
+*/
 var OnlineManager = class extends Subscribable {
 	#online = true;
 	#cleanup;
@@ -510,11 +775,43 @@ var OnlineManager = class extends Subscribable {
 			this.#cleanup = 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(setup) {
 		this.#setup = setup;
 		this.#cleanup?.();
 		this.#cleanup = setup(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(online) {
 		if (this.#online !== online) {
 			this.#online = online;
@@ -523,19 +820,43 @@ var OnlineManager = class extends Subscribable {
 			});
 		}
 	}
+	/**
+	* `isOnline` can be used to get the current online state.
+	*/
 	isOnline() {
 		return this.#online;
 	}
 };
+/**
+* Singleton instance of {@link OnlineManager}, used to manage and observe the online state within TanStack Query.
+*/
 var onlineManager = new OnlineManager();
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/retryer.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/retryer.js
 function defaultRetryDelay(failureCount) {
 	return Math.min(1e3 * 2 ** failureCount, 3e4);
 }
 function canFetch(networkMode) {
 	return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
 }
+/**
+* The error thrown by a `Retryer` (and surfaced to `query.promise`/`mutation`) when a fetch is cancelled, e.g. via
+* `query.cancel()`. `revert`, if `true`, tells the caller to restore the state the query was in before the fetch
+* started instead of surfacing the error. `silent`, if `true`, tells the caller to suppress this error and instead
+* resolve with the promise of the fetch that triggered the cancellation.
+* @example
+* ```ts
+* query.cancel()
+*
+* try {
+*   await query.promise
+* } catch (error) {
+*   if (error instanceof CancelledError) {
+*     // the fetch was cancelled, e.g. via `query.cancel()`
+*   }
+* }
+* ```
+*/
 var CancelledError = class extends Error {
 	constructor(options) {
 		super("CancelledError");
@@ -547,8 +868,15 @@ function createRetryer(config) {
 	let isRetryCancelled = false;
 	let failureCount = 0;
 	let continueFn;
-	const thenable = pendingThenable();
-	const isResolved = () => thenable.status !== "pending";
+	let status = "pending";
+	let promiseResolve;
+	let promiseReject;
+	const promise = new Promise((resolve, reject) => {
+		promiseResolve = resolve;
+		promiseReject = reject;
+	});
+	promise.catch(noop);
+	const isResolved = () => status !== "pending";
 	const cancel = (cancelOptions) => {
 		if (!isResolved()) {
 			const error = new CancelledError(cancelOptions);
@@ -567,13 +895,15 @@ function createRetryer(config) {
 	const resolve = (value) => {
 		if (!isResolved()) {
 			continueFn?.();
-			thenable.resolve(value);
+			status = "resolved";
+			promiseResolve(value);
 		}
 	};
 	const reject = (value) => {
 		if (!isResolved()) {
 			continueFn?.();
-			thenable.reject(value);
+			status = "rejected";
+			promiseReject(value);
 		}
 	};
 	const pause = () => {
@@ -598,7 +928,7 @@ function createRetryer(config) {
 		}
 		Promise.resolve(promiseOrValue).then(resolve).catch((error) => {
 			if (isResolved()) return;
-			const retry = config.retry ?? (environmentManager.isServer() ? 0 : 3);
+			const retry = config.retry ?? (isServer() ? 0 : 3);
 			const retryDelay = config.retryDelay ?? defaultRetryDelay;
 			const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay;
 			const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error);
@@ -617,12 +947,12 @@ function createRetryer(config) {
 		});
 	};
 	return {
-		promise: thenable,
-		status: () => thenable.status,
+		promise,
+		status: () => status,
 		cancel,
 		continue: () => {
 			continueFn?.();
-			return thenable;
+			return promise;
 		},
 		cancelRetry,
 		continueRetry,
@@ -630,14 +960,23 @@ function createRetryer(config) {
 		start: () => {
 			if (canStart()) run();
 			else pause().then(run);
-			return thenable;
+			return promise;
 		}
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/removable.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/removable.js
+/**
+* The base class for cache entries that are garbage collected once nothing is using them —
+* `Query` and `Mutation` both extend it. `gcTime` controls how long an unused entry is kept.
+*/
 var Removable = class {
 	#gcTimeout;
+	/**
+	* Clears the pending garbage collection timeout, so the entry is no longer scheduled for removal.
+	* A subclass may override this to release what it holds on to as well — `Query` also cancels any
+	* in-flight fetch.
+	*/
 	destroy() {
 		this.clearGcTimeout();
 	}
@@ -648,7 +987,7 @@ var Removable = class {
 		}, this.gcTime);
 	}
 	updateGcTime(newGcTime) {
-		this.gcTime = Math.max(this.gcTime || 0, newGcTime ?? (environmentManager.isServer() ? Infinity : 300 * 1e3));
+		this.gcTime = Math.max(this.gcTime || 0, newGcTime ?? (isServer() ? Infinity : 3e5));
 	}
 	clearGcTimeout() {
 		if (this.#gcTimeout !== void 0) {
@@ -658,7 +997,7 @@ var Removable = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
 function infiniteQueryBehavior(pages) {
 	return { onFetch: (context, query) => {
 		const options = context.options;
@@ -680,15 +1019,15 @@ function infiniteQueryBehavior(pages) {
 				if (cancelled) return Promise.reject(context.signal.reason);
 				if (param == null && data.pages.length) return Promise.resolve(data);
 				const createQueryFnContext = () => {
-					const queryFnContext2 = {
+					const queryFnContext = {
 						client: context.client,
 						queryKey: context.queryKey,
 						pageParam: param,
 						direction: previous ? "backward" : "forward",
 						meta: context.options.meta
 					};
-					addSignalProperty(queryFnContext2);
-					return queryFnContext2;
+					addSignalProperty(queryFnContext);
+					return queryFnContext;
 				};
 				const page = await queryFn(createQueryFnContext());
 				const { maxPages } = context.options;
@@ -735,8 +1074,41 @@ function getNextPageParam(options, { pages, pageParams }) {
 function getPreviousPageParam(options, { pages, pageParams }) {
 	return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0;
 }
+/**
+* Checks if there is a next page.
+*/
+function hasNextPage(options, data) {
+	if (!data) return false;
+	return getNextPageParam(options, data) != null;
+}
+/**
+* Checks if there is a previous page.
+*/
+function hasPreviousPage(options, data) {
+	if (!data || !options.getPreviousPageParam) return false;
+	return getPreviousPageParam(options, data) != null;
+}
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/query.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/query.js
+/**
+* Represents a single cached query. A `Query` holds the query's key, options,
+* state (data/error/status), and the observers currently subscribed to it.
+*
+* Instances are created and managed internally by `QueryCache`; application
+* code typically interacts with queries indirectly through `QueryClient` or
+* a framework hook like `useQuery`. Direct access to a `Query` instance is
+* possible via `queryCache.find()`/`findAll()` for inspecting cache state.
+*
+* @example
+* ```ts
+* const queryCache = queryClient.getQueryCache()
+* const query = queryCache.find({ queryKey: ['posts'] })
+*
+* if (query) {
+*   console.log(query.state.dataUpdatedAt)
+* }
+* ```
+*/
 var Query = class extends Removable {
 	#queryType;
 	#initialState;
@@ -760,15 +1132,24 @@ var Query = class extends Removable {
 		this.state = config.state ?? this.#initialState;
 		this.scheduleGc();
 	}
+	/**
+	* The `meta` object passed in the query's options, if any.
+	*/
 	get meta() {
 		return this.options.meta;
 	}
+	/** @internal */
 	get queryType() {
 		return this.#queryType;
 	}
+	/**
+	* The promise for the currently in-flight fetch, if the query is fetching.
+	* `undefined` when the query is not fetching.
+	*/
 	get promise() {
 		return this.#retryer?.promise;
 	}
+	/** @internal */
 	setOptions(options) {
 		this.options = {
 			...this.#defaultOptions,
@@ -787,6 +1168,7 @@ var Query = class extends Removable {
 	optionalRemove() {
 		if (!this.observers.length && this.state.fetchStatus === "idle") this.#cache.remove(this);
 	}
+	/** @internal */
 	setData(newData, options) {
 		const data = replaceData(this.state.data, newData, this.options);
 		this.#dispatch({
@@ -797,60 +1179,141 @@ var Query = class extends Removable {
 		});
 		return data;
 	}
+	/**
+	* 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(state) {
 		this.#dispatch({
 			type: "setState",
 			state
 		});
 	}
+	/**
+	* 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(options) {
 		const promise = this.#retryer?.promise;
 		this.#retryer?.cancel(options);
 		return promise ? promise.then(noop).catch(noop) : 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: true });
 	}
+	/** @internal */
 	get resetState() {
 		return this.#initialState;
 	}
+	/**
+	* 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((observer) => resolveQueryBoolean(observer.options.enabled, this) !== false);
+		return this.observers.some((observer) => resolveQueryValue(observer.options.enabled, this) !== false);
 	}
+	/**
+	* 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() {
 		if (this.getObserversCount() > 0) return !this.isActive();
 		return this.options.queryFn === skipToken || !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() {
-		if (this.getObserversCount() > 0) return this.observers.some((observer) => resolveStaleTime(observer.options.staleTime, this) === "static");
+		if (this.getObserversCount() > 0) return this.observers.some((observer) => resolveQueryValue(observer.options.staleTime, this) === "static");
 		return false;
 	}
+	/**
+	* 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() {
 		if (this.getObserversCount() > 0) return this.observers.some((observer) => observer.getCurrentResult().isStale);
 		return 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(staleTime = 0) {
 		if (this.state.data === void 0) return true;
 		if (staleTime === "static") return false;
 		if (this.state.isInvalidated) return true;
 		return !timeUntilStale(this.state.dataUpdatedAt, staleTime);
 	}
+	/** @internal */
 	onFocus() {
 		this.observers.find((x) => x.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: false });
 		this.#retryer?.continue();
 	}
+	/** @internal */
 	onOnline() {
 		this.observers.find((x) => x.shouldFetchOnReconnect())?.refetch({ cancelRefetch: false });
 		this.#retryer?.continue();
 	}
+	/** @internal */
 	addObserver(observer) {
 		if (!this.observers.includes(observer)) {
 			this.observers.push(observer);
@@ -862,11 +1325,13 @@ var Query = class extends Removable {
 			});
 		}
 	}
+	/** @internal */
 	removeObserver(observer) {
-		if (this.observers.includes(observer)) {
-			this.observers = this.observers.filter((x) => x !== observer);
+		const index = this.observers.indexOf(observer);
+		if (index !== -1) {
+			this.observers.splice(index, 1);
 			if (!this.observers.length) {
-				if (this.#retryer) if (this.#abortSignalConsumed || this.#isInitialPausedFetch()) this.#retryer.cancel({ revert: true });
+				if (this.#retryer) if (this.#abortSignalConsumed || this.state.fetchStatus === "paused" && this.state.status === "pending") this.#retryer.cancel({ revert: true });
 				else this.#retryer.cancelRetry();
 				this.scheduleGc();
 			}
@@ -877,15 +1342,42 @@ var Query = class extends Removable {
 			});
 		}
 	}
+	/**
+	* 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;
 	}
-	#isInitialPausedFetch() {
-		return this.state.fetchStatus === "paused" && this.state.status === "pending";
-	}
+	/**
+	* 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() {
 		if (!this.state.isInvalidated) this.#dispatch({ 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(options, fetchOptions) {
 		if (this.state.fetchStatus !== "idle" && this.#retryer?.status() !== "rejected") {
 			if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) this.cancel({ silent: true });
@@ -912,13 +1404,13 @@ var Query = class extends Removable {
 		const fetchFn = () => {
 			const queryFn = ensureQueryFn(this.options, fetchOptions);
 			const createQueryFnContext = () => {
-				const queryFnContext2 = {
+				const queryFnContext = {
 					client: this.#client,
 					queryKey: this.queryKey,
 					meta: this.meta
 				};
-				addSignalProperty(queryFnContext2);
-				return queryFnContext2;
+				addSignalProperty(queryFnContext);
+				return queryFnContext;
 			};
 			const queryFnContext = createQueryFnContext();
 			this.#abortSignalConsumed = false;
@@ -926,7 +1418,7 @@ var Query = class extends Removable {
 			return queryFn(queryFnContext);
 		};
 		const createFetchContext = () => {
-			const context2 = {
+			const context = {
 				fetchOptions,
 				options: this.options,
 				queryKey: this.queryKey,
@@ -934,8 +1426,8 @@ var Query = class extends Removable {
 				state: this.state,
 				fetchFn
 			};
-			addSignalProperty(context2);
-			return context2;
+			addSignalProperty(context);
+			return context;
 		};
 		const context = createFetchContext();
 		(this.#queryType === "infinite" ? infiniteQueryBehavior(this.options.pages) : this.options.behavior)?.onFetch(context, this);
@@ -944,7 +1436,7 @@ var Query = class extends Removable {
 			type: "fetch",
 			meta: context.fetchOptions?.meta
 		});
-		this.#retryer = createRetryer({
+		const retryer = this.#retryer = createRetryer({
 			initialPromise: fetchOptions?.initialPromise,
 			fn: context.fetchFn,
 			onCancel: (error) => {
@@ -973,7 +1465,7 @@ var Query = class extends Removable {
 			canRun: () => true
 		});
 		try {
-			const data = await this.#retryer.start();
+			const data = await retryer.start();
 			if (data === void 0) throw new Error(`${this.queryHash} data is undefined`);
 			this.setData(data);
 			this.#cache.config.onSuccess?.(data, this);
@@ -995,6 +1487,7 @@ var Query = class extends Removable {
 			this.#cache.config.onSettled?.(this.state.data, error, this);
 			throw error;
 		} finally {
+			if (this.#retryer === retryer) this.#retryer = void 0;
 			this.scheduleGc();
 		}
 	}
@@ -1057,7 +1550,7 @@ var Query = class extends Removable {
 		};
 		this.state = reducer(this.state);
 		notifyManager.batch(() => {
-			this.observers.forEach((observer) => {
+			this.observers.slice().forEach((observer) => {
 				observer.onQueryUpdate();
 			});
 			this.#cache.notify({
@@ -1108,24 +1601,34 @@ function getDefaultState$1(options) {
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/queryObserver.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/queryObserver.js
+/**
+* A `QueryObserver` watches a single query in the `QueryCache` and computes a
+* `QueryObserverResult` from its state, recomputing and notifying subscribers
+* whenever the underlying query (or the observer's options) changes. It is
+* the primitive that framework adapters (e.g. `useQuery`) build their hooks
+* on top of, but it can also be used directly to observe and switch between
+* queries outside of any framework.
+*
+* @example
+* ```ts
+* const observer = new QueryObserver(queryClient, {
+*   queryKey: ['posts'],
+*   queryFn: fetchPosts,
+* })
+*
+* const unsubscribe = observer.subscribe((result) => {
+*   console.log(result.data)
+* })
+* ```
+*/
 var QueryObserver = class extends Subscribable {
-	constructor(client, options) {
-		super();
-		this.options = options;
-		this.#client = client;
-		this.#selectError = null;
-		this.#currentThenable = pendingThenable();
-		this.bindMethods();
-		this.setOptions(options);
-	}
 	#client;
 	#currentQuery = void 0;
 	#currentQueryInitialState = void 0;
 	#currentResult = void 0;
 	#currentResultState;
 	#currentResultOptions;
-	#currentThenable;
 	#selectError;
 	#selectFn;
 	#selectResult;
@@ -1134,6 +1637,14 @@ var QueryObserver = class extends Subscribable {
 	#refetchIntervalId;
 	#currentRefetchInterval;
 	#trackedProps = /* @__PURE__ */ new Set();
+	constructor(client, options) {
+		super();
+		this.options = options;
+		this.#client = client;
+		this.#selectError = null;
+		this.bindMethods();
+		this.setOptions(options);
+	}
 	bindMethods() {
 		this.refetch = this.refetch.bind(this);
 	}
@@ -1148,23 +1659,52 @@ var QueryObserver = class extends Subscribable {
 	onUnsubscribe() {
 		if (!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 shouldFetchOn(this.#currentQuery, 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 shouldFetchOn(this.#currentQuery, 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();
 		this.#clearStaleTimeout();
 		this.#clearRefetchInterval();
 		this.#currentQuery.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(options) {
 		const prevOptions = this.options;
 		const prevQuery = this.#currentQuery;
 		this.options = this.#client.defaultQueryOptions(options);
-		if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveQueryBoolean(this.options.enabled, this.#currentQuery) !== "boolean") throw new Error("Expected enabled to be a boolean or a callback that returns a boolean");
+		if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveQueryValue(this.options.enabled, this.#currentQuery) !== "boolean") throw new Error("Expected enabled to be a boolean or a callback that returns a boolean");
 		this.#updateQuery();
 		this.#currentQuery.setOptions(this.options);
 		if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) this.#client.getQueryCache().notify({
@@ -1175,47 +1715,119 @@ var QueryObserver = class extends Subscribable {
 		const mounted = this.hasListeners();
 		if (mounted && shouldFetchOptionally(this.#currentQuery, prevQuery, this.options, prevOptions)) this.#executeFetch();
 		this.updateResult();
-		if (mounted && (this.#currentQuery !== prevQuery || resolveQueryBoolean(this.options.enabled, this.#currentQuery) !== resolveQueryBoolean(prevOptions.enabled, this.#currentQuery) || resolveStaleTime(this.options.staleTime, this.#currentQuery) !== resolveStaleTime(prevOptions.staleTime, this.#currentQuery))) this.#updateStaleTimeout();
+		if (mounted && (this.#currentQuery !== prevQuery || resolveQueryValue(this.options.enabled, this.#currentQuery) !== resolveQueryValue(prevOptions.enabled, this.#currentQuery) || resolveQueryValue(this.options.staleTime, this.#currentQuery) !== resolveQueryValue(prevOptions.staleTime, this.#currentQuery))) this.#updateStaleTimeout();
 		const nextRefetchInterval = this.#computeRefetchInterval();
-		if (mounted && (this.#currentQuery !== prevQuery || resolveQueryBoolean(this.options.enabled, this.#currentQuery) !== resolveQueryBoolean(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) this.#updateRefetchInterval(nextRefetchInterval);
+		if (mounted && (this.#currentQuery !== prevQuery || resolveQueryValue(this.options.enabled, this.#currentQuery) !== resolveQueryValue(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) this.#updateRefetchInterval(nextRefetchInterval);
 	}
+	/**
+	* 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(options) {
 		const query = this.#client.getQueryCache().build(this.#client, options);
 		const result = this.createResult(query, options);
-		if (shouldAssignObserverCurrentProperties(this, result)) {
+		if (!shallowEqualObjects(this.getCurrentResult(), result)) {
 			this.#currentResult = result;
 			this.#currentResultOptions = this.options;
 			this.#currentResultState = this.#currentQuery.state;
 		}
 		return result;
 	}
+	/**
+	* 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 this.#currentResult;
 	}
+	/**
+	* 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(result, onPropTracked) {
 		return new Proxy(result, { get: (target, key) => {
 			this.trackProp(key);
 			onPropTracked?.(key);
-			if (key === "promise") {
-				this.trackProp("data");
-				if (!this.options.experimental_prefetchInRender && this.#currentThenable.status === "pending") this.#currentThenable.reject(/* @__PURE__ */ new Error("experimental_prefetchInRender feature flag is not enabled"));
-			}
 			return Reflect.get(target, key);
 		} });
 	}
+	/**
+	* 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(key) {
 		this.#trackedProps.add(key);
 	}
+	/**
+	* Returns the `Query` instance this observer is currently observing.
+	*/
 	getCurrentQuery() {
 		return this.#currentQuery;
 	}
+	/**
+	* 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({ ...options } = {}) {
 		return this.fetch({ ...options });
 	}
+	/**
+	* 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(options) {
 		const defaultedOptions = this.#client.defaultQueryOptions(options);
 		const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
-		return query.fetch().then(() => this.createResult(query, defaultedOptions));
+		let unsubscribe = () => {};
+		let resolveEarly;
+		const cachePromise = new Promise((resolve) => {
+			resolveEarly = resolve;
+			unsubscribe = this.#client.getQueryCache().subscribe((event) => {
+				if (event.type === "updated" && event.query.queryHash === query.queryHash && query.state.data !== void 0) {
+					unsubscribe();
+					resolve(this.createResult(query, defaultedOptions));
+				}
+			});
+		});
+		return Promise.race([query.fetch().then(() => {
+			const result = this.createResult(query, defaultedOptions);
+			resolveEarly?.(result);
+			return result;
+		}).finally(() => {
+			unsubscribe();
+		}), cachePromise]);
 	}
 	fetch(fetchOptions) {
 		return this.#executeFetch({
@@ -1232,22 +1844,25 @@ var QueryObserver = class extends Subscribable {
 		if (!fetchOptions?.throwOnError) promise = promise.catch(noop);
 		return promise;
 	}
+	#shouldScheduleTimer(timeout) {
+		return !isServer() && resolveQueryValue(this.options.enabled, this.#currentQuery) !== false && isValidTimeout(timeout);
+	}
 	#updateStaleTimeout() {
 		this.#clearStaleTimeout();
-		const staleTime = resolveStaleTime(this.options.staleTime, this.#currentQuery);
-		if (environmentManager.isServer() || this.#currentResult.isStale || !isValidTimeout(staleTime)) return;
+		const staleTime = resolveQueryValue(this.options.staleTime, this.#currentQuery);
+		if (this.#currentResult.isStale || !this.#shouldScheduleTimer(staleTime)) return;
 		const timeout = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime) + 1;
 		this.#staleTimeoutId = timeoutManager.setTimeout(() => {
 			if (!this.#currentResult.isStale) this.updateResult();
 		}, timeout);
 	}
 	#computeRefetchInterval() {
-		return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false;
+		return resolveQueryValue(this.options.refetchInterval, this.#currentQuery) ?? false;
 	}
 	#updateRefetchInterval(nextInterval) {
 		this.#clearRefetchInterval();
 		this.#currentRefetchInterval = nextInterval;
-		if (environmentManager.isServer() || resolveQueryBoolean(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) return;
+		if (this.#currentRefetchInterval === 0 || !this.#shouldScheduleTimer(this.#currentRefetchInterval)) return;
 		this.#refetchIntervalId = timeoutManager.setInterval(() => {
 			if (this.options.refetchIntervalInBackground || focusManager.isFocused()) this.#executeFetch();
 		}, this.#currentRefetchInterval);
@@ -1314,18 +1929,20 @@ var QueryObserver = class extends Subscribable {
 		} catch (selectError) {
 			this.#selectError = selectError;
 		}
+		else if (data === void 0) this.#selectError = null;
 		if (this.#selectError) {
 			error = this.#selectError;
 			data = this.#selectResult;
 			errorUpdatedAt = Date.now();
 			status = "error";
+			isPlaceholderData = false;
 		}
 		const isFetching = newState.fetchStatus === "fetching";
 		const isPending = status === "pending";
 		const isError = status === "error";
 		const isLoading = isPending && isFetching;
 		const hasData = data !== void 0;
-		const nextResult = {
+		return {
 			status,
 			fetchStatus: newState.fetchStatus,
 			isPending,
@@ -1350,34 +1967,14 @@ var QueryObserver = class extends Subscribable {
 			isRefetchError: isError && hasData,
 			isStale: isStale(query, options),
 			refetch: this.refetch,
-			promise: this.#currentThenable,
-			isEnabled: resolveQueryBoolean(options.enabled, query) !== false
+			isEnabled: resolveQueryValue(options.enabled, query) !== false
 		};
-		if (this.options.experimental_prefetchInRender) {
-			const hasResultData = nextResult.data !== void 0;
-			const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
-			const finalizeThenableIfPossible = (thenable) => {
-				if (isErrorWithoutData) thenable.reject(nextResult.error);
-				else if (hasResultData) thenable.resolve(nextResult.data);
-			};
-			const recreateThenable = () => {
-				finalizeThenableIfPossible(this.#currentThenable = nextResult.promise = pendingThenable());
-			};
-			const prevThenable = this.#currentThenable;
-			switch (prevThenable.status) {
-				case "pending":
-					if (query.queryHash === prevQuery.queryHash) finalizeThenableIfPossible(prevThenable);
-					break;
-				case "fulfilled":
-					if (isErrorWithoutData || nextResult.data !== prevThenable.value) recreateThenable();
-					break;
-				case "rejected":
-					if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) recreateThenable();
-					break;
-			}
-		}
-		return nextResult;
 	}
+	/**
+	* 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 prevResult = this.#currentResult;
 		const nextResult = this.createResult(this.#currentQuery, this.options);
@@ -1398,7 +1995,16 @@ var QueryObserver = class extends Subscribable {
 				return this.#currentResult[typedKey] !== prevResult[typedKey] && includedProps.has(typedKey);
 			});
 		};
-		this.#notify({ listeners: shouldNotifyListeners() });
+		const notifyListeners = shouldNotifyListeners();
+		notifyManager.batch(() => {
+			if (notifyListeners) this.listeners.forEach((listener) => {
+				listener(this.#currentResult);
+			});
+			this.#client.getQueryCache().notify({
+				query: this.#currentQuery,
+				type: "observerResultsUpdated"
+			});
+		});
 	}
 	#updateQuery() {
 		const query = this.#client.getQueryCache().build(this.#client, this.options);
@@ -1411,47 +2017,172 @@ var QueryObserver = class extends Subscribable {
 			query.addObserver(this);
 		}
 	}
+	/** @internal */
 	onQueryUpdate() {
 		this.updateResult();
 		if (this.hasListeners()) this.#updateTimers();
 	}
-	#notify(notifyOptions) {
-		notifyManager.batch(() => {
-			if (notifyOptions.listeners) this.listeners.forEach((listener) => {
-				listener(this.#currentResult);
-			});
-			this.#client.getQueryCache().notify({
-				query: this.#currentQuery,
-				type: "observerResultsUpdated"
-			});
-		});
-	}
 };
 function shouldLoadOnMount(query, options) {
-	return resolveQueryBoolean(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && resolveQueryBoolean(options.retryOnMount, query) === false);
+	return resolveQueryValue(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && resolveQueryValue(options.retryOnMount, query) === false);
 }
 function shouldFetchOnMount(query, options) {
 	return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
 }
 function shouldFetchOn(query, options, field) {
-	if (resolveQueryBoolean(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
-		const value = typeof field === "function" ? field(query) : field;
+	if (resolveQueryValue(options.enabled, query) !== false && resolveQueryValue(options.staleTime, query) !== "static") {
+		const value = resolveQueryValue(field, query);
 		return value === "always" || value !== false && isStale(query, options);
 	}
 	return false;
 }
 function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
-	return (query !== prevQuery || resolveQueryBoolean(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+	return (query !== prevQuery || resolveQueryValue(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
 }
 function isStale(query, options) {
-	return resolveQueryBoolean(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
-}
-function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
-	if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) return true;
-	return false;
+	return resolveQueryValue(options.enabled, query) !== false && query.isStaleByTime(resolveQueryValue(options.staleTime, query));
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/mutation.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/infiniteQueryObserver.js
+/**
+* An `InfiniteQueryObserver` extends `QueryObserver` to observe and switch
+* between infinite queries. It augments the base `QueryObserverResult` with
+* infinite-query-specific fields and methods, such as `hasNextPage` and
+* `fetchNextPage`, and is the primitive that framework adapters (e.g.
+* `useInfiniteQuery`) build their hooks on top of.
+*
+* @example
+* ```ts
+* const observer = new InfiniteQueryObserver(queryClient, {
+*   queryKey: ['projects'],
+*   queryFn: ({ pageParam }) => fetchProjects(pageParam),
+*   initialPageParam: 0,
+*   getNextPageParam: (lastPage) => lastPage.nextCursor,
+* })
+*
+* const unsubscribe = observer.subscribe((result) => console.log(result))
+* ```
+*/
+var InfiniteQueryObserver = class extends QueryObserver {
+	constructor(client, options) {
+		super(client, options);
+	}
+	bindMethods() {
+		super.bindMethods();
+		this.fetchNextPage = this.fetchNextPage.bind(this);
+		this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
+	}
+	/**
+	* Updates the observer's options. Behaves the same as
+	* `QueryObserver.setOptions`, additionally marking the options as
+	* belonging to an infinite query before delegating to the base
+	* implementation.
+	*/
+	setOptions(options) {
+		options._type = "infinite";
+		super.setOptions(options);
+	}
+	/**
+	* The infinite-query counterpart of {@link QueryObserver#getOptimisticResult}, marking the
+	* options as an infinite query before delegating to it. Called by framework adapters (e.g.
+	* `useInfiniteQuery`) ahead of subscribing, to compute the current `InfiniteQueryObserverResult`
+	* synchronously.
+	*/
+	getOptimisticResult(options) {
+		options._type = "infinite";
+		return super.getOptimisticResult(options);
+	}
+	/**
+	* Fetches the next page of the infinite query and returns a promise that
+	* resolves with the resulting `InfiniteQueryObserverResult`. The page
+	* param used for the fetch is determined by `getNextPageParam`, which
+	* receives the current pages/page params and whose result also determines
+	* `hasNextPage`.
+	*
+	* @example
+	* ```ts
+	* const { hasNextPage } = observer.getCurrentResult()
+	*
+	* if (hasNextPage) {
+	*   await observer.fetchNextPage()
+	* }
+	* ```
+	*
+	* @see {@link InfiniteQueryObserver#fetchPreviousPage}
+	*/
+	fetchNextPage(options) {
+		return this.fetch({
+			...options,
+			meta: { fetchMore: { direction: "forward" } }
+		});
+	}
+	/**
+	* Fetches the previous page of the infinite query and returns a promise
+	* that resolves with the resulting `InfiniteQueryObserverResult`. The page
+	* param used for the fetch is determined by `getPreviousPageParam`, which
+	* receives the current pages/page params and whose result also determines
+	* `hasPreviousPage`.
+	*
+	* @example
+	* ```ts
+	* const { hasPreviousPage } = observer.getCurrentResult()
+	*
+	* if (hasPreviousPage) {
+	*   await observer.fetchPreviousPage()
+	* }
+	* ```
+	*
+	* @see {@link InfiniteQueryObserver#fetchNextPage}
+	*/
+	fetchPreviousPage(options) {
+		return this.fetch({
+			...options,
+			meta: { fetchMore: { direction: "backward" } }
+		});
+	}
+	createResult(query, options) {
+		const { state } = query;
+		const parentResult = super.createResult(query, options);
+		const { isFetching, isRefetching, isError, isRefetchError } = parentResult;
+		const fetchDirection = state.fetchMeta?.fetchMore?.direction;
+		const isFetchNextPageError = isError && fetchDirection === "forward";
+		const isFetchingNextPage = isFetching && fetchDirection === "forward";
+		const isFetchPreviousPageError = isError && fetchDirection === "backward";
+		const isFetchingPreviousPage = isFetching && fetchDirection === "backward";
+		return {
+			...parentResult,
+			fetchNextPage: this.fetchNextPage,
+			fetchPreviousPage: this.fetchPreviousPage,
+			hasNextPage: hasNextPage(options, state.data),
+			hasPreviousPage: hasPreviousPage(options, state.data),
+			isFetchNextPageError,
+			isFetchingNextPage,
+			isFetchPreviousPageError,
+			isFetchingPreviousPage,
+			isRefetchError: isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,
+			isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
+		};
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/mutation.js
+/**
+* Represents a single mutation attempt. A `Mutation` holds the mutation's
+* options, state (data/error/status), and the `MutationObserver`s currently
+* subscribed to it.
+*
+* Instances are created and managed internally by `MutationCache`; application
+* code typically interacts with mutations indirectly through `QueryClient` or
+* a framework hook like `useMutation`. Direct access to a `Mutation` instance
+* is possible via `mutationCache.find()`/`getAll()` for inspecting cache state.
+*
+* @example
+* ```ts
+* const mutationCache = queryClient.getMutationCache()
+*
+* const mutation = mutationCache.find({ mutationKey: ['addPost'] })
+* ```
+*/
 var Mutation = class extends Removable {
 	#client;
 	#observers;
@@ -1467,13 +2198,18 @@ var Mutation = class extends Removable {
 		this.setOptions(config.options);
 		this.scheduleGc();
 	}
+	/** @internal */
 	setOptions(options) {
 		this.options = options;
 		this.updateGcTime(this.options.gcTime);
 	}
+	/**
+	* The `meta` object passed in the mutation's options, if any.
+	*/
 	get meta() {
 		return this.options.meta;
 	}
+	/** @internal */
 	addObserver(observer) {
 		if (!this.#observers.includes(observer)) {
 			this.#observers.push(observer);
@@ -1485,6 +2221,7 @@ var Mutation = class extends Removable {
 			});
 		}
 	}
+	/** @internal */
 	removeObserver(observer) {
 		this.#observers = this.#observers.filter((x) => x !== observer);
 		this.scheduleGc();
@@ -1498,9 +2235,60 @@ var Mutation = class extends Removable {
 		if (!this.#observers.length) if (this.state.status === "pending") this.scheduleGc();
 		else this.#mutationCache.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() {
-		return this.#retryer?.continue() ?? this.execute(this.state.variables);
+		return this.#retryer?.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(variables) {
 		const onContinue = () => {
 			this.#dispatch({ type: "continue" });
@@ -1510,7 +2298,7 @@ var Mutation = class extends Removable {
 			meta: this.options.meta,
 			mutationKey: this.options.mutationKey
 		};
-		this.#retryer = createRetryer({
+		const retryer = this.#retryer = createRetryer({
 			fn: () => {
 				if (!this.options.mutationFn) return Promise.reject(/* @__PURE__ */ new Error("No mutationFn found"));
 				return this.options.mutationFn(variables, mutationFnContext);
@@ -1532,7 +2320,7 @@ var Mutation = class extends Removable {
 			canRun: () => this.#mutationCache.canRun(this)
 		});
 		const restored = this.state.status === "pending";
-		const isPaused = !this.#retryer.canStart();
+		const isPaused = !retryer.canStart();
 		try {
 			if (restored) onContinue();
 			else {
@@ -1550,7 +2338,7 @@ var Mutation = class extends Removable {
 					isPaused
 				});
 			}
-			const data = await this.#retryer.start();
+			const data = await retryer.start();
 			await this.#mutationCache.config.onSuccess?.(data, variables, this.state.context, this, mutationFnContext);
 			await this.options.onSuccess?.(data, variables, this.state.context, mutationFnContext);
 			await this.#mutationCache.config.onSettled?.(data, null, this.state.variables, this.state.context, this, mutationFnContext);
@@ -1587,6 +2375,7 @@ var Mutation = class extends Removable {
 			});
 			throw error;
 		} finally {
+			if (this.#retryer === retryer) this.#retryer = void 0;
 			this.#mutationCache.runNext(this);
 		}
 	}
@@ -1665,8 +2454,25 @@ function getDefaultState() {
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/mutationCache.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/mutationCache.js
+/**
+* The `MutationCache` is the storage for mutations.
+*
+* Normally, you will not interact with the `MutationCache` directly and instead use a
+* `QueryClient`. You can subscribe to it (inherited from `Subscribable`) to be informed of
+* safe/known updates to the cache, such as mutations being added, removed, or updated.
+*
+* @example
+* ```ts
+* const unsubscribe = mutationCache.subscribe((event) => {
+*   console.log(event.type, event.mutation)
+* })
+* ```
+*/
 var MutationCache = class extends Subscribable {
+	#mutations;
+	#scopes;
+	#mutationId;
 	constructor(config = {}) {
 		super();
 		this.config = config;
@@ -1674,9 +2480,7 @@ var MutationCache = class extends Subscribable {
 		this.#scopes = /* @__PURE__ */ new Map();
 		this.#mutationId = 0;
 	}
-	#mutations;
-	#scopes;
-	#mutationId;
+	/** @internal */
 	build(client, options, state) {
 		const mutation = new Mutation({
 			client,
@@ -1688,6 +2492,7 @@ var MutationCache = class extends Subscribable {
 		this.add(mutation);
 		return mutation;
 	}
+	/** @internal */
 	add(mutation) {
 		this.#mutations.add(mutation);
 		const scope = scopeFor(mutation);
@@ -1701,6 +2506,7 @@ var MutationCache = class extends Subscribable {
 			mutation
 		});
 	}
+	/** @internal */
 	remove(mutation) {
 		if (this.#mutations.delete(mutation)) {
 			const scope = scopeFor(mutation);
@@ -1719,6 +2525,7 @@ var MutationCache = class extends Subscribable {
 			mutation
 		});
 	}
+	/** @internal */
 	canRun(mutation) {
 		const scope = scopeFor(mutation);
 		if (typeof scope === "string") {
@@ -1726,11 +2533,22 @@ var MutationCache = class extends Subscribable {
 			return !firstPendingMutation || firstPendingMutation === mutation;
 		} else return true;
 	}
+	/** @internal */
 	runNext(mutation) {
 		const scope = scopeFor(mutation);
 		if (typeof scope === "string") return (this.#scopes.get(scope)?.find((m) => m !== mutation && m.state.isPaused))?.continue() ?? Promise.resolve();
 		else return Promise.resolve();
 	}
+	/**
+	* Removes all mutations from the cache.
+	*
+	* @example
+	* ```ts
+	* const mutationCache = queryClient.getMutationCache()
+	*
+	* mutationCache.clear()
+	* ```
+	*/
 	clear() {
 		notifyManager.batch(() => {
 			this.#mutations.forEach((mutation) => {
@@ -1743,9 +2561,37 @@ var MutationCache = class extends Subscribable {
 			this.#scopes.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(this.#mutations);
 	}
+	/**
+	* 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(filters) {
 		const defaultedFilters = {
 			exact: true,
@@ -1753,9 +2599,25 @@ var MutationCache = class extends Subscribable {
 		};
 		return this.getAll().find((mutation) => matchMutation(defaultedFilters, mutation));
 	}
+	/**
+	* 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(filters = {}) {
 		return this.getAll().filter((mutation) => matchMutation(filters, mutation));
 	}
+	/** @internal */
 	notify(event) {
 		notifyManager.batch(() => {
 			this.listeners.forEach((listener) => {
@@ -1763,6 +2625,7 @@ var MutationCache = class extends Subscribable {
 			});
 		});
 	}
+	/** @internal */
 	resumePausedMutations() {
 		const pausedMutations = this.getAll().filter((x) => x.state.isPaused);
 		return notifyManager.batch(() => Promise.all(pausedMutations.map((mutation) => mutation.continue().catch(noop))));
@@ -1772,7 +2635,22 @@ function scopeFor(mutation) {
 	return mutation.options.scope?.id;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/mutationObserver.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/mutationObserver.js
+/**
+* Observes a single mutation and derives a `MutationObserverResult` from it.
+* A framework hook like `useMutation` creates one `MutationObserver` per hook
+* call, keeps it stable across re-renders, calls `setOptions` when the options
+* passed to the hook change, subscribes to it to re-render on updates, and
+* reads `getCurrentResult()` for the value to return. Calling `mutate()`
+* builds a new underlying `Mutation` in the `MutationCache` and executes it.
+*
+* @example
+* ```ts
+* const observer = new MutationObserver(queryClient, {
+*   mutationFn: (variables: { title: string }) => addPost(variables),
+* })
+* ```
+*/
 var MutationObserver = class extends Subscribable {
 	#client;
 	#currentResult = void 0;
@@ -1789,6 +2667,22 @@ var MutationObserver = class extends Subscribable {
 		this.mutate = this.mutate.bind(this);
 		this.reset = this.reset.bind(this);
 	}
+	/**
+	* Updates the observer's options.
+	*
+	* If the new `mutationKey` differs from the previous one (and both were
+	* defined), the observer is reset, detaching it from the mutation it was
+	* observing. Otherwise, if the currently observed mutation is still
+	* `pending`, its options are updated in place as well.
+	*
+	* @example
+	* ```ts
+	* observer.setOptions({
+	*   mutationFn: (variables: { title: string }) => addPost(variables),
+	*   onSuccess: (data) => console.log(data),
+	* })
+	* ```
+	*/
 	setOptions(options) {
 		const prevOptions = this.options;
 		this.options = this.#client.defaultMutationOptions(options);
@@ -1800,22 +2694,68 @@ var MutationObserver = class extends Subscribable {
 		if (prevOptions?.mutationKey && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) this.reset();
 		else if (this.#currentMutation?.state.status === "pending") this.#currentMutation.setOptions(this.options);
 	}
+	onSubscribe() {
+		if (this.listeners.size === 1 && this.#currentMutation) {
+			this.#currentMutation.addObserver(this);
+			this.#updateResult();
+		}
+	}
 	onUnsubscribe() {
 		if (!this.hasListeners()) this.#currentMutation?.removeObserver(this);
 	}
+	/** @internal */
 	onMutationUpdate(action) {
 		this.#updateResult();
 		this.#notify(action);
 	}
+	/**
+	* Returns the observer's current result, derived from the observed
+	* mutation's state (or the default, `idle` state if no mutation has been
+	* built yet, e.g. before the first `mutate()` call or after `reset()`).
+	*/
 	getCurrentResult() {
 		return this.#currentResult;
 	}
+	/**
+	* Detaches the observer from the mutation it is currently observing (if
+	* any) and resets the observed result back to its default, `idle` state.
+	*
+	* This does not cancel an in-flight mutation; the mutation itself keeps
+	* running to completion and its own callbacks still fire, but this
+	* observer stops reflecting its state and a subsequent `mutate()` call
+	* will build a brand new mutation.
+	*
+	* @example
+	* ```ts
+	* observer.reset()
+	* ```
+	*
+	* @see {@link MutationObserver#mutate}
+	*/
 	reset() {
 		this.#currentMutation?.removeObserver(this);
 		this.#currentMutation = void 0;
 		this.#updateResult();
 		this.#notify();
 	}
+	/**
+	* Builds a new `Mutation` in the `MutationCache` using the observer's
+	* current options, detaches this observer from any previously observed
+	* mutation, attaches it to the new one, and executes it with the given
+	* variables.
+	*
+	* The optional per-call `options` (`onSuccess`/`onError`/`onSettled`) are
+	* invoked once the mutation settles, in addition to any callbacks defined
+	* on the observer's own options.
+	*
+	* @example
+	* ```ts
+	* await observer.mutate(
+	*   { title: 'New post' },
+	*   { onSuccess: (data) => console.log(data) },
+	* )
+	* ```
+	*/
 	mutate(variables, options) {
 		this.#mutateOptions = options;
 		this.#currentMutation?.removeObserver(this);
@@ -1876,14 +2816,286 @@ var MutationObserver = class extends Subscribable {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/queryCache.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/queriesObserver.js
+function difference(array1, array2) {
+	const excludeSet = new Set(array2);
+	return array1.filter((x) => !excludeSet.has(x));
+}
+/**
+* A `QueriesObserver` watches an array of queries at once, exposing them as
+* a single array of `QueryObserverResult`s (or, when a `combine` option is
+* given, as a combined value derived from that array). It manages one
+* internal `QueryObserver` per query, and is the primitive that framework
+* adapters (e.g. `useQueries`) build their hooks on top of.
+*
+* @example
+* ```ts
+* const observer = new QueriesObserver(queryClient, [
+*   { queryKey: ['post', 1], queryFn: fetchPost },
+*   { queryKey: ['post', 2], queryFn: fetchPost },
+* ])
+*
+* const unsubscribe = observer.subscribe((result) => {
+*   console.log(result)
+* })
+* ```
+*/
+var QueriesObserver = class extends Subscribable {
+	#client;
+	#result;
+	#queries;
+	#options;
+	#observers;
+	#combinedResult;
+	#lastCombine;
+	#lastResult;
+	#lastQueryHashes;
+	#observerMatches = [];
+	constructor(client, queries, options) {
+		super();
+		this.#client = client;
+		this.#options = options;
+		this.#queries = [];
+		this.#observers = [];
+		this.#result = [];
+		this.setQueries(queries);
+	}
+	onSubscribe() {
+		if (this.listeners.size === 1) this.#observers.forEach((observer) => {
+			observer.subscribe((result) => {
+				this.#onUpdate(observer, result);
+			});
+		});
+	}
+	onUnsubscribe() {
+		if (!this.listeners.size) this.destroy();
+	}
+	/**
+	* Stops observing all queries: clears all listeners and destroys every
+	* underlying `QueryObserver` this observer manages.
+	*/
+	destroy() {
+		this.listeners = /* @__PURE__ */ new Set();
+		this.#observers.forEach((observer) => {
+			observer.destroy();
+		});
+	}
+	/**
+	* Replaces the set of queries being observed. Existing `QueryObserver`s
+	* are reused for queries that match an already-observed query hash;
+	* observers for queries that are no longer present are destroyed, and new
+	* observers are created and subscribed to for newly added queries.
+	*
+	* @example
+	* ```ts
+	* observer.setQueries([
+	*   { queryKey: ['post', 1], queryFn: fetchPost },
+	*   { queryKey: ['post', 3], queryFn: fetchPost },
+	* ])
+	* ```
+	*/
+	setQueries(queries, options) {
+		this.#queries = queries;
+		this.#options = options;
+		notifyManager.batch(() => {
+			const prevObservers = this.#observers;
+			const newObserverMatches = this.#findMatchingObservers(this.#queries);
+			newObserverMatches.forEach((match) => match.observer.setOptions(match.defaultedQueryOptions));
+			const newObservers = newObserverMatches.map((match) => match.observer);
+			const newResult = newObservers.map((observer) => observer.getCurrentResult());
+			const hasLengthChange = prevObservers.length !== newObservers.length;
+			const hasIndexChange = newObservers.some((observer, index) => observer !== prevObservers[index]);
+			const hasStructuralChange = hasLengthChange || hasIndexChange;
+			const hasResultChange = hasStructuralChange ? true : newResult.some((result, index) => {
+				const prev = this.#result[index];
+				return !prev || !shallowEqualObjects(result, prev);
+			});
+			if (!hasStructuralChange && !hasResultChange) return;
+			if (hasStructuralChange) {
+				this.#observerMatches = newObserverMatches;
+				this.#observers = newObservers;
+			}
+			this.#result = newResult;
+			if (!this.hasListeners()) return;
+			if (hasStructuralChange) {
+				difference(prevObservers, newObservers).forEach((observer) => {
+					observer.destroy();
+				});
+				difference(newObservers, prevObservers).forEach((observer) => {
+					observer.subscribe((result) => {
+						this.#onUpdate(observer, result);
+					});
+				});
+			}
+			this.#notify();
+		});
+	}
+	/**
+	* Returns the most recently computed array of `QueryObserverResult`s, one
+	* per observed query, in the same order as the queries passed to the
+	* constructor or `setQueries`.
+	*
+	* @example
+	* ```ts
+	* const results = observer.getCurrentResult()
+	* const data = results.map((result) => result.data)
+	* ```
+	*/
+	getCurrentResult() {
+		return this.#result;
+	}
+	/**
+	* Returns the underlying `Query` instances currently being observed, in
+	* the same order as the queries passed to the constructor or `setQueries`.
+	*/
+	getQueries() {
+		return this.#observers.map((observer) => observer.getCurrentQuery());
+	}
+	/**
+	* Returns the underlying `QueryObserver` instances this observer manages,
+	* in the same order as the queries passed to the constructor or
+	* `setQueries`.
+	*/
+	getObservers() {
+		return this.#observers;
+	}
+	/**
+	* The `QueriesObserver` counterpart of {@link QueryObserver#getOptimisticResult} — computes
+	* the result for the given (already-defaulted) queries right now, synchronously. Called by
+	* framework adapters (e.g. `useQueries`) ahead of subscribing, returning a tuple of the raw
+	* per-query results, a function to compute the combined result from them, and a function to
+	* wrap the results for property-access tracking.
+	*/
+	getOptimisticResult(queries, combine) {
+		const matches = this.#findMatchingObservers(queries);
+		const result = matches.map((match) => match.observer.getOptimisticResult(match.defaultedQueryOptions));
+		const queryHashes = matches.map((match) => match.defaultedQueryOptions.queryHash);
+		return [
+			result,
+			(r) => {
+				return this.#combineResult(r ?? result, combine, queryHashes);
+			},
+			() => {
+				return this.#trackResult(result, matches);
+			}
+		];
+	}
+	#trackResult(result, matches) {
+		const trackedProps = /* @__PURE__ */ new Set();
+		return matches.map((match, index) => {
+			const observerResult = result[index];
+			return !match.defaultedQueryOptions.notifyOnChangeProps ? match.observer.trackResult(observerResult, (accessedProp) => {
+				if (!trackedProps.has(accessedProp)) {
+					trackedProps.add(accessedProp);
+					matches.forEach((m) => {
+						m.observer.trackProp(accessedProp);
+					});
+				}
+			}) : observerResult;
+		});
+	}
+	#combineResult(input, combine, queryHashes) {
+		if (combine) {
+			const lastHashes = this.#lastQueryHashes;
+			const queryHashesChanged = queryHashes !== void 0 && lastHashes !== void 0 && (lastHashes.length !== queryHashes.length || queryHashes.some((hash, i) => hash !== lastHashes[i]));
+			if (this.#result !== this.#lastResult || queryHashesChanged || combine !== this.#lastCombine) {
+				this.#lastCombine = combine;
+				this.#lastResult = this.#result;
+				if (queryHashes !== void 0) this.#lastQueryHashes = queryHashes;
+				this.#combinedResult = replaceEqualDeep(this.#combinedResult, combine(input));
+			}
+			return this.#combinedResult;
+		}
+		return input;
+	}
+	#shouldSkipCombine() {
+		return !this.#options?.combine || this.#observers.some((observer, index) => {
+			return observer.options.suspense && this.#result[index]?.data === void 0;
+		});
+	}
+	#findMatchingObservers(queries) {
+		const prevObserversMap = /* @__PURE__ */ new Map();
+		this.#observers.forEach((observer) => {
+			const key = observer.options.queryHash;
+			if (!key) return;
+			const previousObservers = prevObserversMap.get(key);
+			if (previousObservers) previousObservers.push(observer);
+			else prevObserversMap.set(key, [observer]);
+		});
+		const observers = [];
+		queries.forEach((options) => {
+			const defaultedOptions = this.#client.defaultQueryOptions(options);
+			const observer = prevObserversMap.get(defaultedOptions.queryHash)?.shift() ?? new QueryObserver(this.#client, defaultedOptions);
+			observers.push({
+				defaultedQueryOptions: defaultedOptions,
+				observer
+			});
+		});
+		return observers;
+	}
+	#onUpdate(observer, result) {
+		const index = this.#observers.indexOf(observer);
+		if (index !== -1) {
+			this.#result = this.#result.slice();
+			this.#result[index] = result;
+			this.#notify();
+		}
+	}
+	#notify() {
+		if (this.hasListeners()) {
+			const shouldSkipCombine = this.#shouldSkipCombine();
+			const previousResult = this.#combinedResult;
+			const newResult = shouldSkipCombine ? previousResult : this.#combineResult(this.#trackResult(this.#result, this.#observerMatches), this.#options?.combine);
+			if (shouldSkipCombine || previousResult !== newResult) notifyManager.batch(() => {
+				this.listeners.forEach((listener) => {
+					listener(this.#result);
+				});
+			});
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/queryCache.js
+/**
+* The `QueryCache` is the storage mechanism for TanStack Query. It stores all the data, meta
+* information, and state of the queries it contains.
+*
+* Normally, you will not interact with the `QueryCache` directly and instead use a `QueryClient`
+* for a specific cache. You can subscribe to it (inherited from `Subscribable`) to be informed of
+* safe/known updates to the cache, such as queries being added, removed, or updated — updates made
+* outside of the cache's own tracked mechanisms (e.g. mutating a query's state object directly) do
+* not notify subscribers.
+*
+* @example
+* ```ts
+* const unsubscribe = queryCache.subscribe((event) => {
+*   console.log(event.type, event.query)
+* })
+* ```
+*/
 var QueryCache = class extends Subscribable {
+	#queries;
 	constructor(config = {}) {
 		super();
 		this.config = config;
 		this.#queries = /* @__PURE__ */ new Map();
 	}
-	#queries;
+	/**
+	* 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(client, options, state) {
 		const queryKey = options.queryKey;
 		const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options);
@@ -1901,6 +3113,7 @@ var QueryCache = class extends Subscribable {
 		}
 		return query;
 	}
+	/** @internal */
 	add(query) {
 		if (!this.#queries.has(query.queryHash)) {
 			this.#queries.set(query.queryHash, query);
@@ -1910,17 +3123,42 @@ var QueryCache = class extends Subscribable {
 			});
 		}
 	}
+	/**
+	* 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(query) {
-		const queryInMap = this.#queries.get(query.queryHash);
-		if (queryInMap) {
+		if (this.#queries.get(query.queryHash) === query) {
 			query.destroy();
-			if (queryInMap === query) this.#queries.delete(query.queryHash);
+			this.#queries.delete(query.queryHash);
 			this.notify({
 				type: "removed",
 				query
 			});
 		}
 	}
+	/**
+	* Removes all queries from the cache.
+	*
+	* @example
+	* ```ts
+	* const queryCache = queryClient.getQueryCache()
+	*
+	* queryCache.clear()
+	* ```
+	*/
 	clear() {
 		notifyManager.batch(() => {
 			this.getAll().forEach((query) => {
@@ -1928,12 +3166,54 @@ var QueryCache = class extends Subscribable {
 			});
 		});
 	}
+	/**
+	* 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(queryHash) {
 		return this.#queries.get(queryHash);
 	}
+	/**
+	* Returns all queries within the cache.
+	*
+	* @example
+	* ```ts
+	* const queryCache = queryClient.getQueryCache()
+	*
+	* const queries = queryCache.getAll()
+	* ```
+	*/
 	getAll() {
 		return [...this.#queries.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(filters) {
 		const defaultedFilters = {
 			exact: true,
@@ -1941,10 +3221,26 @@ var QueryCache = class extends Subscribable {
 		};
 		return this.getAll().find((query) => matchQuery(defaultedFilters, query));
 	}
+	/**
+	* 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(filters = {}) {
 		const queries = this.getAll();
 		return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries;
 	}
+	/** @internal */
 	notify(event) {
 		notifyManager.batch(() => {
 			this.listeners.forEach((listener) => {
@@ -1952,6 +3248,7 @@ var QueryCache = class extends Subscribable {
 			});
 		});
 	}
+	/** @internal */
 	onFocus() {
 		notifyManager.batch(() => {
 			this.getAll().forEach((query) => {
@@ -1959,6 +3256,7 @@ var QueryCache = class extends Subscribable {
 			});
 		});
 	}
+	/** @internal */
 	onOnline() {
 		notifyManager.batch(() => {
 			this.getAll().forEach((query) => {
@@ -1968,7 +3266,25 @@ var QueryCache = class extends Subscribable {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+query-core@5.101.0/node_modules/@tanstack/query-core/build/modern/queryClient.js
+//#region ../../node_modules/.pnpm/@tanstack+query-core@5.104.0/node_modules/@tanstack/query-core/build/modern/queryClient.js
+/**
+* `QueryClient` is used to interact with a cache of queries and mutations. It owns a
+* `QueryCache` and a `MutationCache` (creating default ones if none are passed in) and holds
+* the default options that are applied to queries and mutations created through it.
+*
+* @example
+* ```ts
+* const queryClient = new QueryClient({
+*   defaultOptions: {
+*     queries: {
+*       staleTime: Infinity,
+*     },
+*   },
+* })
+*
+* await queryClient.query({ queryKey: ['posts'], queryFn: fetchPosts })
+* ```
+*/
 var QueryClient = class {
 	#queryCache;
 	#mutationCache;
@@ -1986,6 +3302,12 @@ var QueryClient = class {
 		this.#mutationDefaults = /* @__PURE__ */ new Map();
 		this.#mountCount = 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() {
 		this.#mountCount++;
 		if (this.#mountCount !== 1) return;
@@ -2002,6 +3324,11 @@ var QueryClient = class {
 			}
 		});
 	}
+	/**
+	* 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() {
 		this.#mountCount--;
 		if (this.#mountCount !== 0) return;
@@ -2010,12 +3337,35 @@ var QueryClient = class {
 		this.#unsubscribeOnline?.();
 		this.#unsubscribeOnline = 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(filters) {
 		return this.#queryCache.findAll({
 			...filters,
 			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(filters) {
 		return this.#mutationCache.findAll({
 			...filters,
@@ -2028,24 +3378,72 @@ var QueryClient = class {
 	*
 	* 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.
+	*
+	* @returns The cached data for the query, or `undefined` if no query with this key has been observed yet.
+	* @see {@link QueryClient#getQueriesData}
 	*/
 	getQueryData(queryKey) {
 		const options = this.defaultQueryOptions({ queryKey });
 		return this.#queryCache.get(options.queryHash)?.state.data;
 	}
+	/**
+	* @deprecated Use queryClient.query({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
+	*/
 	ensureQueryData(options) {
 		const defaultedOptions = this.defaultQueryOptions(options);
 		const query = this.#queryCache.build(this, defaultedOptions);
 		const cachedData = query.state.data;
 		if (cachedData === void 0) return this.fetchQuery(options);
-		if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) this.prefetchQuery(defaultedOptions);
+		if (options.revalidateIfStale && query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime, query))) this.prefetchQuery(defaultedOptions);
 		return Promise.resolve(cachedData);
 	}
+	/**
+	* 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.
+	*
+	* @returns An array of query key and data pairs. The data is `undefined` for a query with no cached data.
+	* @see {@link QueryClient#getQueryData}
+	* @example
+	* ```ts
+	* const data = queryClient.getQueriesData({ queryKey: ['posts'] })
+	* ```
+	*/
 	getQueriesData(filters) {
 		return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {
 			return [queryKey, state.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.
+	* @param options - Set `updatedAt` to override the timestamp the written data is recorded with.
+	* @returns The data that was written, or `undefined` if the updater returned `undefined` — in that case
+	* the write is skipped and the cache is left unchanged.
+	*
+	* @example
+	* ```ts
+	* queryClient.setQueryData(['posts'], newPosts)
+	*
+	* // Or, using an updater function that receives the current data:
+	* queryClient.setQueryData(['posts'], (oldPosts) => [...oldPosts, newPost])
+	* ```
+	*/
 	setQueryData(queryKey, updater, options) {
 		const defaultedOptions = this.defaultQueryOptions({ queryKey });
 		const prevData = this.#queryCache.get(defaultedOptions.queryHash)?.state.data;
@@ -2056,13 +3454,49 @@ var QueryClient = class {
 			manual: true
 		});
 	}
+	/**
+	* 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.
+	*
+	* @returns One `[queryKey, data]` tuple per matched query, in the same shape and with the same
+	* `undefined` case as {@link QueryClient#setQueryData}.
+	* @example
+	* ```ts
+	* queryClient.setQueriesData({ queryKey: ['posts'] }, (oldPosts) =>
+	*   oldPosts ? oldPosts.filter((post) => post.id !== deletedId) : oldPosts,
+	* )
+	* ```
+	*/
 	setQueriesData(filters, updater, options) {
 		return notifyManager.batch(() => this.#queryCache.findAll(filters).map(({ queryKey }) => [queryKey, this.setQueryData(queryKey, updater, options)]));
 	}
+	/**
+	* 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(queryKey) {
 		const options = this.defaultQueryOptions({ queryKey });
 		return this.#queryCache.get(options.queryHash)?.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(filters) {
 		const queryCache = this.#queryCache;
 		notifyManager.batch(() => {
@@ -2071,18 +3505,43 @@ var QueryClient = class {
 			});
 		});
 	}
+	/**
+	* 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(filters, options) {
 		const queryCache = this.#queryCache;
 		return notifyManager.batch(() => {
-			queryCache.findAll(filters).forEach((query) => {
+			const matched = queryCache.findAll(filters);
+			const queriesToRefetch = new Set(matched);
+			matched.forEach((query) => {
 				query.reset();
 			});
 			return this.refetchQueries({
 				type: "active",
-				...filters
+				predicate: (query) => queriesToRefetch.has(query)
 			}, options);
 		});
 	}
+	/**
+	* 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(filters, cancelOptions = {}) {
 		const defaultedCancelOptions = {
 			revert: true,
@@ -2091,6 +3550,19 @@ var QueryClient = class {
 		const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map((query) => query.cancel(defaultedCancelOptions)));
 		return Promise.all(promises).then(noop).catch(noop);
 	}
+	/**
+	* 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(filters, options = {}) {
 		return notifyManager.batch(() => {
 			this.#queryCache.findAll(filters).forEach((query) => {
@@ -2103,6 +3575,21 @@ var QueryClient = class {
 			}, options);
 		});
 	}
+	/**
+	* 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(filters, options = {}) {
 		const fetchOptions = {
 			...options,
@@ -2115,48 +3602,218 @@ var QueryClient = class {
 		}));
 		return Promise.all(promises).then(noop);
 	}
+	/**
+	* 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(options) {
+		const defaultedOptions = this.defaultQueryOptions(options);
+		if (defaultedOptions.retry === void 0) defaultedOptions.retry = false;
+		const query = this.#queryCache.build(this, defaultedOptions);
+		const queryData = query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime, query)) ? await query.fetch(defaultedOptions) : query.state.data;
+		const select = defaultedOptions.select;
+		if (select) return select(queryData);
+		return queryData;
+	}
+	/**
+	* @deprecated Use queryClient.query(options) instead. This method will be removed in the next major version.
+	*/
 	fetchQuery(options) {
 		const defaultedOptions = this.defaultQueryOptions(options);
 		if (defaultedOptions.retry === void 0) defaultedOptions.retry = false;
 		const query = this.#queryCache.build(this, defaultedOptions);
-		return query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query)) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
+		return query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime, query)) ? query.fetch(defaultedOptions) : Promise.resolve(query.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(options) {
 		return this.fetchQuery(options).then(noop).catch(noop);
 	}
+	/**
+	* 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(options) {
+		options._type = "infinite";
+		return this.query(options);
+	}
+	/**
+	* @deprecated Use queryClient.infiniteQuery(options) instead. This method will be removed in the next major version.
+	*/
 	fetchInfiniteQuery(options) {
 		options._type = "infinite";
 		return this.fetchQuery(options);
 	}
+	/**
+	* @deprecated Use queryClient.infiniteQuery(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.
+	*/
 	prefetchInfiniteQuery(options) {
 		return this.fetchInfiniteQuery(options).then(noop).catch(noop);
 	}
+	/**
+	* @deprecated Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
+	*/
 	ensureInfiniteQueryData(options) {
 		options._type = "infinite";
 		return this.ensureQueryData(options);
 	}
+	/**
+	* 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() {
 		if (onlineManager.isOnline()) return this.#mutationCache.resumePausedMutations();
 		return 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 this.#queryCache;
 	}
+	/**
+	* 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 this.#mutationCache;
 	}
+	/**
+	* 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 this.#defaultOptions;
 	}
+	/**
+	* 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(options) {
 		this.#defaultOptions = options;
 	}
+	/**
+	* 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(queryKey, options) {
 		this.#queryDefaults.set(hashKey(queryKey), {
 			queryKey,
 			defaultOptions: options
 		});
 	}
+	/**
+	* 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(queryKey) {
 		const defaults = [...this.#queryDefaults.values()];
 		const result = {};
@@ -2165,12 +3822,33 @@ var QueryClient = class {
 		});
 		return result;
 	}
+	/**
+	* 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(mutationKey, options) {
 		this.#mutationDefaults.set(hashKey(mutationKey), {
 			mutationKey,
 			defaultOptions: options
 		});
 	}
+	/**
+	* 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(mutationKey) {
 		const defaults = [...this.#mutationDefaults.values()];
 		const result = {};
@@ -2179,6 +3857,12 @@ var QueryClient = class {
 		});
 		return result;
 	}
+	/**
+	* 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(options) {
 		if (options._defaulted) return options;
 		const defaultedOptions = {
@@ -2194,6 +3878,12 @@ var QueryClient = class {
 		if (defaultedOptions.queryFn === skipToken) defaultedOptions.enabled = false;
 		return defaultedOptions;
 	}
+	/**
+	* 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(options) {
 		if (options?._defaulted) return options;
 		return {
@@ -2203,10 +3893,21 @@ var QueryClient = class {
 			_defaulted: true
 		};
 	}
+	/**
+	* 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() {
 		this.#queryCache.clear();
 		this.#mutationCache.clear();
 	}
 };
 //#endregion
-export { dehydrate as a, noop as c, notifyManager as i, shouldThrowError as l, MutationObserver as n, hydrate as o, QueryObserver as r, environmentManager as s, QueryClient as t };
+export { QueryObserver as a, hydrate as c, shouldThrowError as d, InfiniteQueryObserver as i, keepPreviousData as l, QueriesObserver as n, notifyManager as o, MutationObserver as r, dehydrateQuery as s, QueryClient as t, noop as u };