autumn-js 1.2.32 → 1.2.34

package/dist/react/{chunk-P23GII4V.mjs → chunk-FU6VEECB.mjs}

@@ -1,6 +1,71 @@
 "use client";
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/utils.js
+// ../../node_modules/@tanstack/query-core/build/modern/timeoutManager.js
+var defaultTimeoutProvider = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (callback, delay) => setTimeout(callback, delay),
+  clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+  setInterval: (callback, delay) => setInterval(callback, delay),
+  clearInterval: (intervalId) => clearInterval(intervalId)
+};
+var TimeoutManager = class {
+  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+  // type at app boot; and if we leave that type, then any new timer provider
+  // would need to support the default provider's concrete timer ID, which is
+  // infeasible across environments.
+  //
+  // We settle for type safety for the TimeoutProvider type, and accept that
+  // this class is unsafe internally to allow for extension.
+  #provider = defaultTimeoutProvider;
+  #providerCalled = false;
+  setTimeoutProvider(provider) {
+    if (process.env.NODE_ENV !== "production") {
+      if (this.#providerCalled && provider !== this.#provider) {
+        console.error(
+          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
+          { previous: this.#provider, provider }
+        );
+      }
+    }
+    this.#provider = provider;
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = false;
+    }
+  }
+  setTimeout(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = true;
+    }
+    return this.#provider.setTimeout(callback, delay);
+  }
+  clearTimeout(timeoutId) {
+    this.#provider.clearTimeout(timeoutId);
+  }
+  setInterval(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = true;
+    }
+    return this.#provider.setInterval(callback, delay);
+  }
+  clearInterval(intervalId) {
+    this.#provider.clearInterval(intervalId);
+  }
+};
+var timeoutManager = new TimeoutManager();
+function systemSetTimeoutZero(callback) {
+  setTimeout(callback, 0);
+}
+
+// ../../node_modules/@tanstack/query-core/build/modern/utils.js
 var isServer = typeof window === "undefined" || "Deno" in globalThis;
 function noop() {
 }
@@ -16,8 +81,8 @@ function timeUntilStale(updatedAt, staleTime) {
 function resolveStaleTime(staleTime, query) {
   return typeof staleTime === "function" ? staleTime(query) : staleTime;
 }
-function resolveEnabled(enabled, query) {
-  return typeof enabled === "function" ? enabled(query) : enabled;
+function resolveQueryBoolean(option, query) {
+  return typeof option === "function" ? option(query) : option;
 }
 function matchQuery(filters, query) {
   const {
@@ -104,34 +169,38 @@ function partialMatchKey(a, b) {
   }
   return false;
 }
-function replaceEqualDeep(a, b) {
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(a, b, depth = 0) {
   if (a === b) {
     return a;
   }
+  if (depth > 500) return b;
   const array = isPlainArray(a) && isPlainArray(b);
-  if (array || isPlainObject(a) && isPlainObject(b)) {
-    const aItems = array ? a : Object.keys(a);
-    const aSize = aItems.length;
-    const bItems = array ? b : Object.keys(b);
-    const bSize = bItems.length;
-    const copy = array ? [] : {};
-    const aItemsSet = new Set(aItems);
-    let equalItems = 0;
-    for (let i = 0; i < bSize; i++) {
-      const key = array ? i : bItems[i];
-      if ((!array && aItemsSet.has(key) || array) && a[key] === void 0 && b[key] === void 0) {
-        copy[key] = void 0;
-        equalItems++;
-      } else {
-        copy[key] = replaceEqualDeep(a[key], b[key]);
-        if (copy[key] === a[key] && a[key] !== void 0) {
-          equalItems++;
-        }
-      }
-    }
-    return aSize === bSize && equalItems === aSize ? a : copy;
-  }
-  return b;
+  if (!array && !(isPlainObject(a) && isPlainObject(b))) return b;
+  const aItems = array ? a : Object.keys(a);
+  const aSize = aItems.length;
+  const bItems = array ? b : Object.keys(b);
+  const bSize = bItems.length;
+  const copy = array ? new Array(bSize) : {};
+  let equalItems = 0;
+  for (let i = 0; i < bSize; i++) {
+    const key = array ? i : bItems[i];
+    const aItem = a[key];
+    const bItem = b[key];
+    if (aItem === bItem) {
+      copy[key] = aItem;
+      if (array ? i < aSize : hasOwn.call(a, key)) equalItems++;
+      continue;
+    }
+    if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
+      copy[key] = bItem;
+      continue;
+    }
+    const v = replaceEqualDeep(aItem, bItem, depth + 1);
+    copy[key] = v;
+    if (v === aItem) equalItems++;
+  }
+  return aSize === bSize && equalItems === aSize ? a : copy;
 }
 function shallowEqualObjects(a, b) {
   if (!b || Object.keys(a).length !== Object.keys(b).length) {
@@ -172,7 +241,7 @@ function hasObjectPrototype(o) {
 }
 function sleep(timeout) {
   return new Promise((resolve) => {
-    setTimeout(resolve, timeout);
+    timeoutManager.setTimeout(resolve, timeout);
   });
 }
 function replaceData(prevData, data, options) {
@@ -201,7 +270,7 @@ function addToStart(items, item, max = 0) {
   const newItems = [item, ...items];
   return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
 }
-var skipToken = Symbol();
+var skipToken = /* @__PURE__ */ Symbol();
 function ensureQueryFn(options, fetchOptions) {
   if (process.env.NODE_ENV !== "production") {
     if (options.queryFn === skipToken) {
@@ -224,9 +293,30 @@ function shouldThrowError(throwOnError, params) {
   }
   return !!throwOnError;
 }
+function addConsumeAwareSignal(object, getSignal, onCancelled) {
+  let consumed = false;
+  let signal;
+  Object.defineProperty(object, "signal", {
+    enumerable: true,
+    get: () => {
+      signal ??= getSignal();
+      if (consumed) {
+        return signal;
+      }
+      consumed = true;
+      if (signal.aborted) {
+        onCancelled();
+      } else {
+        signal.addEventListener("abort", onCancelled, { once: true });
+      }
+      return signal;
+    }
+  });
+  return object;
+}
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/notifyManager.js
-var defaultScheduler = (cb) => setTimeout(cb, 0);
+// ../../node_modules/@tanstack/query-core/build/modern/notifyManager.js
+var defaultScheduler = systemSetTimeoutZero;
 function createNotifyManager() {
   let queue = [];
   let transactions = 0;
@@ -305,7 +395,7 @@ function createNotifyManager() {
 }
 var notifyManager = createNotifyManager();
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/subscribable.js
+// ../../node_modules/@tanstack/query-core/build/modern/subscribable.js
 var Subscribable = class {
   constructor() {
     this.listeners = /* @__PURE__ */ new Set();
@@ -328,7 +418,7 @@ var Subscribable = class {
   }
 };
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/focusManager.js
+// ../../node_modules/@tanstack/query-core/build/modern/focusManager.js
 var FocusManager = class extends Subscribable {
   #focused;
   #cleanup;
@@ -336,7 +426,7 @@ var FocusManager = class extends Subscribable {
   constructor() {
     super();
     this.#setup = (onFocus) => {
-      if (!isServer && window.addEventListener) {
+      if (typeof window !== "undefined" && window.addEventListener) {
         const listener = () => onFocus();
         window.addEventListener("visibilitychange", listener, false);
         return () => {
@@ -390,7 +480,7 @@ var FocusManager = class extends Subscribable {
 };
 var focusManager = new FocusManager();
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/onlineManager.js
+// ../../node_modules/@tanstack/query-core/build/modern/onlineManager.js
 var OnlineManager = class extends Subscribable {
   #online = true;
   #cleanup;
@@ -398,7 +488,7 @@ var OnlineManager = class extends Subscribable {
   constructor() {
     super();
     this.#setup = (onOnline) => {
-      if (!isServer && window.addEventListener) {
+      if (typeof window !== "undefined" && window.addEventListener) {
         const onlineListener = () => onOnline(true);
         const offlineListener = () => onOnline(false);
         window.addEventListener("online", onlineListener, false);
@@ -442,7 +532,7 @@ var OnlineManager = class extends Subscribable {
 };
 var onlineManager = new OnlineManager();
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/thenable.js
+// ../../node_modules/@tanstack/query-core/build/modern/thenable.js
 function pendingThenable() {
   let resolve;
   let reject;
@@ -475,7 +565,26 @@ function pendingThenable() {
   return thenable;
 }
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/retryer.js
+// ../../node_modules/@tanstack/query-core/build/modern/environmentManager.js
+var environmentManager = /* @__PURE__ */ (() => {
+  let isServerFn = () => isServer;
+  return {
+    /**
+     * Returns whether the current runtime should be treated as a server environment.
+     */
+    isServer() {
+      return isServerFn();
+    },
+    /**
+     * Overrides the server check globally.
+     */
+    setIsServer(isServerValue) {
+      isServerFn = isServerValue;
+    }
+  };
+})();
+
+// ../../node_modules/@tanstack/query-core/build/modern/retryer.js
 function defaultRetryDelay(failureCount) {
   return Math.min(1e3 * 2 ** failureCount, 3e4);
 }
@@ -552,7 +661,7 @@ function createRetryer(config) {
       if (isResolved()) {
         return;
       }
-      const retry = config.retry ?? (isServer ? 0 : 3);
+      const retry = config.retry ?? (environmentManager.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);
@@ -595,7 +704,7 @@ function createRetryer(config) {
   };
 }
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/removable.js
+// ../../node_modules/@tanstack/query-core/build/modern/removable.js
 var Removable = class {
   #gcTimeout;
   destroy() {
@@ -604,7 +713,7 @@ var Removable = class {
   scheduleGc() {
     this.clearGcTimeout();
     if (isValidTimeout(this.gcTime)) {
-      this.#gcTimeout = setTimeout(() => {
+      this.#gcTimeout = timeoutManager.setTimeout(() => {
         this.optionalRemove();
       }, this.gcTime);
     }
@@ -612,19 +721,121 @@ var Removable = class {
   updateGcTime(newGcTime) {
     this.gcTime = Math.max(
       this.gcTime || 0,
-      newGcTime ?? (isServer ? Infinity : 5 * 60 * 1e3)
+      newGcTime ?? (environmentManager.isServer() ? Infinity : 5 * 60 * 1e3)
     );
   }
   clearGcTimeout() {
-    if (this.#gcTimeout) {
-      clearTimeout(this.#gcTimeout);
+    if (this.#gcTimeout !== void 0) {
+      timeoutManager.clearTimeout(this.#gcTimeout);
       this.#gcTimeout = void 0;
     }
   }
 };
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/query.js
+// ../../node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
+function infiniteQueryBehavior(pages) {
+  return {
+    onFetch: (context, query) => {
+      const options = context.options;
+      const direction = context.fetchOptions?.meta?.fetchMore?.direction;
+      const oldPages = context.state.data?.pages || [];
+      const oldPageParams = context.state.data?.pageParams || [];
+      let result = { pages: [], pageParams: [] };
+      let currentPage = 0;
+      const fetchFn = async () => {
+        let cancelled = false;
+        const addSignalProperty = (object) => {
+          addConsumeAwareSignal(
+            object,
+            () => context.signal,
+            () => cancelled = true
+          );
+        };
+        const queryFn = ensureQueryFn(context.options, context.fetchOptions);
+        const fetchPage = async (data, param, previous) => {
+          if (cancelled) {
+            return Promise.reject(context.signal.reason);
+          }
+          if (param == null && data.pages.length) {
+            return Promise.resolve(data);
+          }
+          const createQueryFnContext = () => {
+            const queryFnContext2 = {
+              client: context.client,
+              queryKey: context.queryKey,
+              pageParam: param,
+              direction: previous ? "backward" : "forward",
+              meta: context.options.meta
+            };
+            addSignalProperty(queryFnContext2);
+            return queryFnContext2;
+          };
+          const queryFnContext = createQueryFnContext();
+          const page = await queryFn(queryFnContext);
+          const { maxPages } = context.options;
+          const addTo = previous ? addToStart : addToEnd;
+          return {
+            pages: addTo(data.pages, page, maxPages),
+            pageParams: addTo(data.pageParams, param, maxPages)
+          };
+        };
+        if (direction && oldPages.length) {
+          const previous = direction === "backward";
+          const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+          const oldData = {
+            pages: oldPages,
+            pageParams: oldPageParams
+          };
+          const param = pageParamFn(options, oldData);
+          result = await fetchPage(oldData, param, previous);
+        } else {
+          const remainingPages = pages ?? oldPages.length;
+          do {
+            const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result);
+            if (currentPage > 0 && param == null) {
+              break;
+            }
+            result = await fetchPage(result, param);
+            currentPage++;
+          } while (currentPage < remainingPages);
+        }
+        return result;
+      };
+      if (context.options.persister) {
+        context.fetchFn = () => {
+          return context.options.persister?.(
+            fetchFn,
+            {
+              client: context.client,
+              queryKey: context.queryKey,
+              meta: context.options.meta,
+              signal: context.signal
+            },
+            query
+          );
+        };
+      } else {
+        context.fetchFn = fetchFn;
+      }
+    }
+  };
+}
+function getNextPageParam(options, { pages, pageParams }) {
+  const lastIndex = pages.length - 1;
+  return pages.length > 0 ? options.getNextPageParam(
+    pages[lastIndex],
+    pages,
+    pageParams[lastIndex],
+    pageParams
+  ) : void 0;
+}
+function getPreviousPageParam(options, { pages, pageParams }) {
+  return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0;
+}
+
+// ../../node_modules/@tanstack/query-core/build/modern/query.js
 var Query = class extends Removable {
+  #queryType;
   #initialState;
   #revertState;
   #cache;
@@ -649,12 +860,27 @@ var Query = class extends Removable {
   get meta() {
     return this.options.meta;
   }
+  get queryType() {
+    return this.#queryType;
+  }
   get promise() {
     return this.#retryer?.promise;
   }
   setOptions(options) {
     this.options = { ...this.#defaultOptions, ...options };
+    if (options?._type) {
+      this.#queryType = options._type;
+    }
     this.updateGcTime(this.options.gcTime);
+    if (this.state && this.state.data === void 0) {
+      const defaultState = getDefaultState(this.options);
+      if (defaultState.data !== void 0) {
+        this.setState(
+          successState(defaultState.data, defaultState.dataUpdatedAt)
+        );
+        this.#initialState = defaultState;
+      }
+    }
   }
   optionalRemove() {
     if (!this.observers.length && this.state.fetchStatus === "idle") {
@@ -671,8 +897,8 @@ var Query = class extends Removable {
     });
     return data;
   }
-  setState(state, setStateOptions) {
-    this.#dispatch({ type: "setState", state, setStateOptions });
+  setState(state) {
+    this.#dispatch({ type: "setState", state });
   }
   cancel(options) {
     const promise = this.#retryer?.promise;
@@ -683,20 +909,26 @@ var Query = class extends Removable {
     super.destroy();
     this.cancel({ silent: true });
   }
+  get resetState() {
+    return this.#initialState;
+  }
   reset() {
     this.destroy();
-    this.setState(this.#initialState);
+    this.setState(this.resetState);
   }
   isActive() {
     return this.observers.some(
-      (observer) => resolveEnabled(observer.options.enabled, this) !== false
+      (observer) => resolveQueryBoolean(observer.options.enabled, this) !== false
     );
   }
   isDisabled() {
     if (this.getObserversCount() > 0) {
       return !this.isActive();
     }
-    return this.options.queryFn === skipToken || this.state.dataUpdateCount + this.state.errorUpdateCount === 0;
+    return this.options.queryFn === skipToken || !this.isFetched();
+  }
+  isFetched() {
+    return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
   }
   isStatic() {
     if (this.getObserversCount() > 0) {
@@ -748,7 +980,7 @@ var Query = class extends Removable {
       this.observers = this.observers.filter((x) => x !== observer);
       if (!this.observers.length) {
         if (this.#retryer) {
-          if (this.#abortSignalConsumed) {
+          if (this.#abortSignalConsumed || this.#isInitialPausedFetch()) {
             this.#retryer.cancel({ revert: true });
           } else {
             this.#retryer.cancelRetry();
@@ -762,13 +994,16 @@ var Query = class extends Removable {
   getObserversCount() {
     return this.observers.length;
   }
+  #isInitialPausedFetch() {
+    return this.state.fetchStatus === "paused" && this.state.status === "pending";
+  }
   invalidate() {
     if (!this.state.isInvalidated) {
       this.#dispatch({ type: "invalidate" });
     }
   }
   async fetch(options, fetchOptions) {
-    if (this.state.fetchStatus !== "idle" && // If the promise in the retyer is already rejected, we have to definitely
+    if (this.state.fetchStatus !== "idle" && // If the promise in the retryer is already rejected, we have to definitely
     // re-start the fetch; there is a chance that the query is still in a
     // pending state when that happens
     this.#retryer?.status() !== "rejected") {
@@ -840,7 +1075,10 @@ var Query = class extends Removable {
       return context2;
     };
     const context = createFetchContext();
-    this.options.behavior?.onFetch(context, this);
+    const behavior = this.#queryType === "infinite" ? infiniteQueryBehavior(
+      this.options.pages
+    ) : this.options.behavior;
+    behavior?.onFetch(context, this);
     this.#revertState = this.state;
     if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== context.fetchOptions?.meta) {
       this.#dispatch({ type: "fetch", meta: context.fetchOptions?.meta });
@@ -946,12 +1184,8 @@ var Query = class extends Removable {
         case "success":
           const newState = {
             ...state,
-            data: action.data,
+            ...successState(action.data, action.dataUpdatedAt),
             dataUpdateCount: state.dataUpdateCount + 1,
-            dataUpdatedAt: action.dataUpdatedAt ?? Date.now(),
-            error: null,
-            isInvalidated: false,
-            status: "success",
             ...!action.manual && {
               fetchStatus: "idle",
               fetchFailureCount: 0,
@@ -970,7 +1204,10 @@ var Query = class extends Removable {
             fetchFailureCount: state.fetchFailureCount + 1,
             fetchFailureReason: error,
             fetchStatus: "idle",
-            status: "error"
+            status: "error",
+            // flag existing data as invalidated if we get a background error
+            // note that "no data" always means stale so we can set unconditionally here
+            isInvalidated: true
           };
         case "invalidate":
           return {
@@ -1004,6 +1241,15 @@ function fetchState(data, options) {
     }
   };
 }
+function successState(data, dataUpdatedAt) {
+  return {
+    data,
+    dataUpdatedAt: dataUpdatedAt ?? Date.now(),
+    error: null,
+    isInvalidated: false,
+    status: "success"
+  };
+}
 function getDefaultState(options) {
   const data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
   const hasData = data !== void 0;
@@ -1024,7 +1270,7 @@ function getDefaultState(options) {
   };
 }
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/queryCache.js
+// ../../node_modules/@tanstack/query-core/build/modern/queryCache.js
 var QueryCache = class extends Subscribable {
   constructor(config = {}) {
     super();
@@ -1114,13 +1360,15 @@ var QueryCache = class extends Subscribable {
   }
 };
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/mutation.js
+// ../../node_modules/@tanstack/query-core/build/modern/mutation.js
 var Mutation = class extends Removable {
+  #client;
   #observers;
   #mutationCache;
   #retryer;
   constructor(config) {
     super();
+    this.#client = config.client;
     this.mutationId = config.mutationId;
     this.#mutationCache = config.mutationCache;
     this.#observers = [];
@@ -1172,12 +1420,17 @@ var Mutation = class extends Removable {
     const onContinue = () => {
       this.#dispatch({ type: "continue" });
     };
+    const mutationFnContext = {
+      client: this.#client,
+      meta: this.options.meta,
+      mutationKey: this.options.mutationKey
+    };
     this.#retryer = createRetryer({
       fn: () => {
         if (!this.options.mutationFn) {
           return Promise.reject(new Error("No mutationFn found"));
         }
-        return this.options.mutationFn(variables);
+        return this.options.mutationFn(variables, mutationFnContext);
       },
       onFail: (failureCount, error) => {
         this.#dispatch({ type: "failed", failureCount, error });
@@ -1198,11 +1451,17 @@ var Mutation = class extends Removable {
         onContinue();
       } else {
         this.#dispatch({ type: "pending", variables, isPaused });
-        await this.#mutationCache.config.onMutate?.(
+        if (this.#mutationCache.config.onMutate) {
+          await this.#mutationCache.config.onMutate(
+            variables,
+            this,
+            mutationFnContext
+          );
+        }
+        const context = await this.options.onMutate?.(
           variables,
-          this
+          mutationFnContext
         );
-        const context = await this.options.onMutate?.(variables);
         if (context !== this.state.context) {
           this.#dispatch({
             type: "pending",
@@ -1217,17 +1476,30 @@ var Mutation = class extends Removable {
         data,
         variables,
         this.state.context,
-        this
+        this,
+        mutationFnContext
+      );
+      await this.options.onSuccess?.(
+        data,
+        variables,
+        this.state.context,
+        mutationFnContext
       );
-      await this.options.onSuccess?.(data, variables, this.state.context);
       await this.#mutationCache.config.onSettled?.(
         data,
         null,
         this.state.variables,
         this.state.context,
-        this
+        this,
+        mutationFnContext
+      );
+      await this.options.onSettled?.(
+        data,
+        null,
+        variables,
+        this.state.context,
+        mutationFnContext
       );
-      await this.options.onSettled?.(data, null, variables, this.state.context);
       this.#dispatch({ type: "success", data });
       return data;
     } catch (error) {
@@ -1236,30 +1508,47 @@ var Mutation = class extends Removable {
           error,
           variables,
           this.state.context,
-          this
+          this,
+          mutationFnContext
         );
+      } catch (e) {
+        void Promise.reject(e);
+      }
+      try {
         await this.options.onError?.(
           error,
           variables,
-          this.state.context
+          this.state.context,
+          mutationFnContext
         );
+      } catch (e) {
+        void Promise.reject(e);
+      }
+      try {
         await this.#mutationCache.config.onSettled?.(
           void 0,
           error,
           this.state.variables,
           this.state.context,
-          this
+          this,
+          mutationFnContext
         );
+      } catch (e) {
+        void Promise.reject(e);
+      }
+      try {
         await this.options.onSettled?.(
           void 0,
           error,
           variables,
-          this.state.context
+          this.state.context,
+          mutationFnContext
         );
-        throw error;
-      } finally {
-        this.#dispatch({ type: "error", error });
+      } catch (e) {
+        void Promise.reject(e);
       }
+      this.#dispatch({ type: "error", error });
+      throw error;
     } finally {
       this.#mutationCache.runNext(this);
     }
@@ -1345,7 +1634,7 @@ function getDefaultState2() {
   };
 }
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/mutationCache.js
+// ../../node_modules/@tanstack/query-core/build/modern/mutationCache.js
 var MutationCache = class extends Subscribable {
   constructor(config = {}) {
     super();
@@ -1359,6 +1648,7 @@ var MutationCache = class extends Subscribable {
   #mutationId;
   build(client, options, state) {
     const mutation = new Mutation({
+      client,
       mutationCache: this,
       mutationId: ++this.#mutationId,
       options: client.defaultMutationOptions(options),
@@ -1461,116 +1751,7 @@ function scopeFor(mutation) {
   return mutation.options.scope?.id;
 }
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
-function infiniteQueryBehavior(pages) {
-  return {
-    onFetch: (context, query) => {
-      const options = context.options;
-      const direction = context.fetchOptions?.meta?.fetchMore?.direction;
-      const oldPages = context.state.data?.pages || [];
-      const oldPageParams = context.state.data?.pageParams || [];
-      let result = { pages: [], pageParams: [] };
-      let currentPage = 0;
-      const fetchFn = async () => {
-        let cancelled = false;
-        const addSignalProperty = (object) => {
-          Object.defineProperty(object, "signal", {
-            enumerable: true,
-            get: () => {
-              if (context.signal.aborted) {
-                cancelled = true;
-              } else {
-                context.signal.addEventListener("abort", () => {
-                  cancelled = true;
-                });
-              }
-              return context.signal;
-            }
-          });
-        };
-        const queryFn = ensureQueryFn(context.options, context.fetchOptions);
-        const fetchPage = async (data, param, previous) => {
-          if (cancelled) {
-            return Promise.reject();
-          }
-          if (param == null && data.pages.length) {
-            return Promise.resolve(data);
-          }
-          const createQueryFnContext = () => {
-            const queryFnContext2 = {
-              client: context.client,
-              queryKey: context.queryKey,
-              pageParam: param,
-              direction: previous ? "backward" : "forward",
-              meta: context.options.meta
-            };
-            addSignalProperty(queryFnContext2);
-            return queryFnContext2;
-          };
-          const queryFnContext = createQueryFnContext();
-          const page = await queryFn(queryFnContext);
-          const { maxPages } = context.options;
-          const addTo = previous ? addToStart : addToEnd;
-          return {
-            pages: addTo(data.pages, page, maxPages),
-            pageParams: addTo(data.pageParams, param, maxPages)
-          };
-        };
-        if (direction && oldPages.length) {
-          const previous = direction === "backward";
-          const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
-          const oldData = {
-            pages: oldPages,
-            pageParams: oldPageParams
-          };
-          const param = pageParamFn(options, oldData);
-          result = await fetchPage(oldData, param, previous);
-        } else {
-          const remainingPages = pages ?? oldPages.length;
-          do {
-            const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result);
-            if (currentPage > 0 && param == null) {
-              break;
-            }
-            result = await fetchPage(result, param);
-            currentPage++;
-          } while (currentPage < remainingPages);
-        }
-        return result;
-      };
-      if (context.options.persister) {
-        context.fetchFn = () => {
-          return context.options.persister?.(
-            fetchFn,
-            {
-              client: context.client,
-              queryKey: context.queryKey,
-              meta: context.options.meta,
-              signal: context.signal
-            },
-            query
-          );
-        };
-      } else {
-        context.fetchFn = fetchFn;
-      }
-    }
-  };
-}
-function getNextPageParam(options, { pages, pageParams }) {
-  const lastIndex = pages.length - 1;
-  return pages.length > 0 ? options.getNextPageParam(
-    pages[lastIndex],
-    pages,
-    pageParams[lastIndex],
-    pageParams
-  ) : void 0;
-}
-function getPreviousPageParam(options, { pages, pageParams }) {
-  return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0;
-}
-
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/queryClient.js
+// ../../node_modules/@tanstack/query-core/build/modern/queryClient.js
 var QueryClient = class {
   #queryCache;
   #mutationCache;
@@ -1750,14 +1931,14 @@ var QueryClient = class {
     return this.fetchQuery(options).then(noop).catch(noop);
   }
   fetchInfiniteQuery(options) {
-    options.behavior = infiniteQueryBehavior(options.pages);
+    options._type = "infinite";
     return this.fetchQuery(options);
   }
   prefetchInfiniteQuery(options) {
     return this.fetchInfiniteQuery(options).then(noop).catch(noop);
   }
   ensureInfiniteQueryData(options) {
-    options.behavior = infiniteQueryBehavior(options.pages);
+    options._type = "infinite";
     return this.ensureQueryData(options);
   }
   resumePausedMutations() {
@@ -1857,7 +2038,7 @@ var QueryClient = class {
   }
 };
 
-// ../../node_modules/.bun/@tanstack+query-core@5.85.6/node_modules/@tanstack/query-core/build/modern/queryObserver.js
+// ../../node_modules/@tanstack/query-core/build/modern/queryObserver.js
 var QueryObserver = class extends Subscribable {
   constructor(client, options) {
     super();
@@ -1928,7 +2109,7 @@ var QueryObserver = class extends Subscribable {
     const prevOptions = this.options;
     const prevQuery = this.#currentQuery;
     this.options = this.#client.defaultQueryOptions(options);
-    if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, this.#currentQuery) !== "boolean") {
+    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"
       );
@@ -1952,11 +2133,11 @@ var QueryObserver = class extends Subscribable {
       this.#executeFetch();
     }
     this.updateResult();
-    if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || resolveStaleTime(this.options.staleTime, this.#currentQuery) !== resolveStaleTime(prevOptions.staleTime, this.#currentQuery))) {
+    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();
     }
     const nextRefetchInterval = this.#computeRefetchInterval();
-    if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) {
+    if (mounted && (this.#currentQuery !== prevQuery || resolveQueryBoolean(this.options.enabled, this.#currentQuery) !== resolveQueryBoolean(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) {
       this.#updateRefetchInterval(nextRefetchInterval);
     }
   }
@@ -1978,12 +2159,15 @@ var QueryObserver = class extends Subscribable {
       get: (target, key) => {
         this.trackProp(key);
         onPropTracked?.(key);
-        if (key === "promise" && !this.options.experimental_prefetchInRender && this.#currentThenable.status === "pending") {
-          this.#currentThenable.reject(
-            new Error(
-              "experimental_prefetchInRender feature flag is not enabled"
-            )
-          );
+        if (key === "promise") {
+          this.trackProp("data");
+          if (!this.options.experimental_prefetchInRender && this.#currentThenable.status === "pending") {
+            this.#currentThenable.reject(
+              new Error(
+                "experimental_prefetchInRender feature flag is not enabled"
+              )
+            );
+          }
         }
         return Reflect.get(target, key);
       }
@@ -2031,12 +2215,12 @@ var QueryObserver = class extends Subscribable {
       this.options.staleTime,
       this.#currentQuery
     );
-    if (isServer || this.#currentResult.isStale || !isValidTimeout(staleTime)) {
+    if (environmentManager.isServer() || this.#currentResult.isStale || !isValidTimeout(staleTime)) {
       return;
     }
     const time = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime);
     const timeout = time + 1;
-    this.#staleTimeoutId = setTimeout(() => {
+    this.#staleTimeoutId = timeoutManager.setTimeout(() => {
       if (!this.#currentResult.isStale) {
         this.updateResult();
       }
@@ -2048,10 +2232,10 @@ var QueryObserver = class extends Subscribable {
   #updateRefetchInterval(nextInterval) {
     this.#clearRefetchInterval();
     this.#currentRefetchInterval = nextInterval;
-    if (isServer || resolveEnabled(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {
+    if (environmentManager.isServer() || resolveQueryBoolean(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {
       return;
     }
-    this.#refetchIntervalId = setInterval(() => {
+    this.#refetchIntervalId = timeoutManager.setInterval(() => {
       if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
         this.#executeFetch();
       }
@@ -2062,14 +2246,14 @@ var QueryObserver = class extends Subscribable {
     this.#updateRefetchInterval(this.#computeRefetchInterval());
   }
   #clearStaleTimeout() {
-    if (this.#staleTimeoutId) {
-      clearTimeout(this.#staleTimeoutId);
+    if (this.#staleTimeoutId !== void 0) {
+      timeoutManager.clearTimeout(this.#staleTimeoutId);
       this.#staleTimeoutId = void 0;
     }
   }
   #clearRefetchInterval() {
-    if (this.#refetchIntervalId) {
-      clearInterval(this.#refetchIntervalId);
+    if (this.#refetchIntervalId !== void 0) {
+      timeoutManager.clearInterval(this.#refetchIntervalId);
       this.#refetchIntervalId = void 0;
     }
   }
@@ -2164,7 +2348,7 @@ var QueryObserver = class extends Subscribable {
       failureCount: newState.fetchFailureCount,
       failureReason: newState.fetchFailureReason,
       errorUpdateCount: newState.errorUpdateCount,
-      isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,
+      isFetched: query.isFetched(),
       isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
       isFetching,
       isRefetching: isFetching && !isPending,
@@ -2175,14 +2359,16 @@ var QueryObserver = class extends Subscribable {
       isStale: isStale(query, options),
       refetch: this.refetch,
       promise: this.#currentThenable,
-      isEnabled: resolveEnabled(options.enabled, query) !== false
+      isEnabled: resolveQueryBoolean(options.enabled, query) !== false
     };
     const nextResult = result;
     if (this.options.experimental_prefetchInRender) {
+      const hasResultData = nextResult.data !== void 0;
+      const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
       const finalizeThenableIfPossible = (thenable) => {
-        if (nextResult.status === "error") {
+        if (isErrorWithoutData) {
           thenable.reject(nextResult.error);
-        } else if (nextResult.data !== void 0) {
+        } else if (hasResultData) {
           thenable.resolve(nextResult.data);
         }
       };
@@ -2198,12 +2384,12 @@ var QueryObserver = class extends Subscribable {
           }
           break;
         case "fulfilled":
-          if (nextResult.status === "error" || nextResult.data !== prevThenable.value) {
+          if (isErrorWithoutData || nextResult.data !== prevThenable.value) {
             recreateThenable();
           }
           break;
         case "rejected":
-          if (nextResult.status !== "error" || nextResult.error !== prevThenable.reason) {
+          if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) {
             recreateThenable();
           }
           break;
@@ -2280,23 +2466,23 @@ var QueryObserver = class extends Subscribable {
   }
 };
 function shouldLoadOnMount(query, options) {
-  return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false);
+  return resolveQueryBoolean(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && resolveQueryBoolean(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 (resolveEnabled(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
+  if (resolveQueryBoolean(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
     const value = typeof field === "function" ? field(query) : field;
     return value === "always" || value !== false && isStale(query, options);
   }
   return false;
 }
 function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
-  return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+  return (query !== prevQuery || resolveQueryBoolean(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
 }
 function isStale(query, options) {
-  return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
+  return resolveQueryBoolean(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
 }
 function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
   if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
@@ -2305,7 +2491,7 @@ function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
   return false;
 }
 
-// ../../node_modules/.bun/@tanstack+react-query@5.85.6+e14d3f224186685e/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
+// ../../node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
 import * as React from "react";
 import { jsx } from "react/jsx-runtime";
 var QueryClientContext = React.createContext(
@@ -2334,10 +2520,10 @@ var QueryClientProvider = ({
   return /* @__PURE__ */ jsx(QueryClientContext.Provider, { value: client, children });
 };
 
-// ../../node_modules/.bun/@tanstack+react-query@5.85.6+e14d3f224186685e/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
+// ../../node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
 import * as React5 from "react";
 
-// ../../node_modules/.bun/@tanstack+react-query@5.85.6+e14d3f224186685e/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
+// ../../node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
 import * as React2 from "react";
 import { jsx as jsx2 } from "react/jsx-runtime";
 function createValue() {
@@ -2357,10 +2543,11 @@ function createValue() {
 var QueryErrorResetBoundaryContext = React2.createContext(createValue());
 var useQueryErrorResetBoundary = () => React2.useContext(QueryErrorResetBoundaryContext);
 
-// ../../node_modules/.bun/@tanstack+react-query@5.85.6+e14d3f224186685e/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
+// ../../node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
 import * as React3 from "react";
-var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
-  if (options.suspense || options.throwOnError || options.experimental_prefetchInRender) {
+var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
+  const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
+  if (options.suspense || options.experimental_prefetchInRender || throwOnError) {
     if (!errorResetBoundary.isReset()) {
       options.retryOnMount = false;
     }
@@ -2381,20 +2568,24 @@ var getHasError = ({
   return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
 };
 
-// ../../node_modules/.bun/@tanstack+react-query@5.85.6+e14d3f224186685e/node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
+// ../../node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
 import * as React4 from "react";
 var IsRestoringContext = React4.createContext(false);
 var useIsRestoring = () => React4.useContext(IsRestoringContext);
 var IsRestoringProvider = IsRestoringContext.Provider;
 
-// ../../node_modules/.bun/@tanstack+react-query@5.85.6+e14d3f224186685e/node_modules/@tanstack/react-query/build/modern/suspense.js
+// ../../node_modules/@tanstack/react-query/build/modern/suspense.js
 var ensureSuspenseTimers = (defaultedOptions) => {
   if (defaultedOptions.suspense) {
-    const clamp = (value) => value === "static" ? value : Math.max(value ?? 1e3, 1e3);
+    const MIN_SUSPENSE_TIME_MS = 1e3;
+    const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
     const originalStaleTime = defaultedOptions.staleTime;
     defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime);
     if (typeof defaultedOptions.gcTime === "number") {
-      defaultedOptions.gcTime = Math.max(defaultedOptions.gcTime, 1e3);
+      defaultedOptions.gcTime = Math.max(
+        defaultedOptions.gcTime,
+        MIN_SUSPENSE_TIME_MS
+      );
     }
   }
 };
@@ -2404,7 +2595,7 @@ var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observ
   errorResetBoundary.clearReset();
 });
 
-// ../../node_modules/.bun/@tanstack+react-query@5.85.6+e14d3f224186685e/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
+// ../../node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
 function useBaseQuery(options, Observer, queryClient) {
   if (process.env.NODE_ENV !== "production") {
     if (typeof options !== "object" || Array.isArray(options)) {
@@ -2420,6 +2611,7 @@ function useBaseQuery(options, Observer, queryClient) {
   client.getDefaultOptions().queries?._experimental_beforeQuery?.(
     defaultedOptions
   );
+  const query = client.getQueryCache().get(defaultedOptions.queryHash);
   if (process.env.NODE_ENV !== "production") {
     if (!defaultedOptions.queryFn) {
       console.error(
@@ -2427,9 +2619,10 @@ function useBaseQuery(options, Observer, queryClient) {
       );
     }
   }
-  defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
+  const subscribed = options.subscribed !== false;
+  defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
   ensureSuspenseTimers(defaultedOptions);
-  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
   useClearResetErrorBoundary(errorResetBoundary);
   const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
   const [observer] = React5.useState(
@@ -2439,7 +2632,7 @@ function useBaseQuery(options, Observer, queryClient) {
     )
   );
   const result = observer.getOptimisticResult(defaultedOptions);
-  const shouldSubscribe = !isRestoring && options.subscribed !== false;
+  const shouldSubscribe = !isRestoring && subscribed;
   React5.useSyncExternalStore(
     React5.useCallback(
       (onStoreChange) => {
@@ -2462,7 +2655,7 @@ function useBaseQuery(options, Observer, queryClient) {
     result,
     errorResetBoundary,
     throwOnError: defaultedOptions.throwOnError,
-    query: client.getQueryCache().get(defaultedOptions.queryHash),
+    query,
     suspense: defaultedOptions.suspense
   })) {
     throw result.error;
@@ -2472,13 +2665,13 @@ function useBaseQuery(options, Observer, queryClient) {
     defaultedOptions,
     result
   );
-  if (defaultedOptions.experimental_prefetchInRender && !isServer && willFetch(result, isRestoring)) {
+  if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) {
     const promise = isNewCacheEntry ? (
       // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
       fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
     ) : (
       // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
-      client.getQueryCache().get(defaultedOptions.queryHash)?.promise
+      query?.promise
     );
     promise?.catch(noop).finally(() => {
       observer.updateResult();
@@ -2487,7 +2680,7 @@ function useBaseQuery(options, Observer, queryClient) {
   return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
 }
 
-// ../../node_modules/.bun/@tanstack+react-query@5.85.6+e14d3f224186685e/node_modules/@tanstack/react-query/build/modern/useQuery.js
+// ../../node_modules/@tanstack/react-query/build/modern/useQuery.js
 function useQuery(options, queryClient) {
   return useBaseQuery(options, QueryObserver, queryClient);
 }