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

package/.output/server/_libs/tanstack__react-query.mjs

@@ -1,16 +1,46 @@
 import { i as __toESM } from "../_runtime.mjs";
-import { ht as require_react, mt as require_jsx_runtime } from "./@base-ui/react+[...].mjs";
-import { c as noop, i as notifyManager, l as shouldThrowError, n as MutationObserver, r as QueryObserver, s as environmentManager } from "./tanstack__query-core.mjs";
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.101.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
+import { _t as require_react, gt as require_jsx_runtime } from "./@base-ui/react+[...].mjs";
+import { a as QueryObserver, d as shouldThrowError, i as InfiniteQueryObserver, n as QueriesObserver, o as notifyManager, r as MutationObserver, u as noop } from "./tanstack__query-core.mjs";
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
 var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
 var import_jsx_runtime = require_jsx_runtime();
+/**
+* The context that `useQueryClient` reads from. `QueryClientProvider` is the normal way to set it.
+*/
 var QueryClientContext = import_react.createContext(void 0);
+/**
+* The `useQueryClient` hook returns the current `QueryClient` instance.
+*
+* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+* be used.
+* @returns The current `QueryClient` instance.
+* @throws If no `queryClient` argument is passed and no `QueryClientProvider` is found in the component tree.
+*/
 var useQueryClient = (queryClient) => {
 	const client = import_react.useContext(QueryClientContext);
 	if (queryClient) return queryClient;
 	if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
 	return client;
 };
+/**
+* Use the `QueryClientProvider` component to connect and provide a `QueryClient` to your application. Also
+* calls `client.mount()`/`client.unmount()` as this component mounts/unmounts, which subscribes the client to
+* focus/online events (resuming any paused mutations and refetching as needed when the app regains focus or
+* comes back online).
+*
+* @returns The provided `children`, wrapped so they can read the `QueryClient` via `useQueryClient`.
+*
+* @example
+* ```tsx
+* import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+*
+* const queryClient = new QueryClient()
+*
+* function App() {
+*   return <QueryClientProvider client={queryClient}>...</QueryClientProvider>
+* }
+* ```
+*/
 var QueryClientProvider = ({ client, children }) => {
 	import_react.useEffect(() => {
 		client.mount();
@@ -24,12 +54,22 @@ var QueryClientProvider = ({ client, children }) => {
 	});
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.101.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
 var IsRestoringContext = import_react.createContext(false);
+/**
+* If you are using `PersistQueryClientProvider`, you can also use the `useIsRestoring` hook alongside it to
+* check if a restore is currently in progress. `useQuery` and friends also check this internally to avoid
+* race conditions between the restore and mounting queries.
+*
+* @returns `true` while a persisted client is being restored, `false` otherwise.
+*/
 var useIsRestoring = () => import_react.useContext(IsRestoringContext);
 IsRestoringContext.Provider;
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.101.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
+/**
+* Resets any query errors within the boundary, so queries know they can try again.
+*/
 function createValue() {
 	let isReset = false;
 	return {
@@ -45,12 +85,42 @@ function createValue() {
 	};
 }
 var QueryErrorResetBoundaryContext = import_react.createContext(createValue());
+/**
+* This hook will reset any query errors within the closest `QueryErrorResetBoundary`. If there is no boundary
+* defined it will reset them globally.
+*
+* @returns The boundary's {@link QueryErrorResetBoundaryValue}.
+*
+* @example
+* ```tsx
+* import { ErrorBoundary } from 'react-error-boundary'
+* import { useQueryErrorResetBoundary } from '@tanstack/react-query'
+*
+* function App({ children }: { children: React.ReactNode }) {
+*   const { reset } = useQueryErrorResetBoundary()
+*
+*   return (
+*     <ErrorBoundary
+*       onReset={reset}
+*       fallbackRender={({ resetErrorBoundary }) => (
+*         <div>
+*           There was an error!
+*           <button onClick={() => resetErrorBoundary()}>Try again</button>
+*         </div>
+*       )}
+*     >
+*       {children}
+*     </ErrorBoundary>
+*   )
+* }
+* ```
+*/
 var useQueryErrorResetBoundary = () => import_react.useContext(QueryErrorResetBoundaryContext);
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.101.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
 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 (options.suspense || throwOnError) {
 		if (!errorResetBoundary.isReset()) options.retryOnMount = false;
 	}
 };
@@ -63,7 +133,7 @@ var getHasError = ({ result, errorResetBoundary, throwOnError, query, suspense }
 	return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
 };
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.101.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/suspense.js
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/suspense.js
 var ensureSuspenseTimers = (defaultedOptions) => {
 	if (defaultedOptions.suspense) {
 		const MIN_SUSPENSE_TIME_MS = 1e3;
@@ -73,26 +143,205 @@ var ensureSuspenseTimers = (defaultedOptions) => {
 		if (typeof defaultedOptions.gcTime === "number") defaultedOptions.gcTime = Math.max(defaultedOptions.gcTime, MIN_SUSPENSE_TIME_MS);
 	}
 };
-var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
 var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
 var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
 	errorResetBoundary.clearReset();
 });
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.101.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/useQueries.js
+/**
+* The `useQueries` hook can be used to fetch a variable number of queries.
+*
+* The `queries` key accepts an array with query option objects mostly identical to `useQuery` — the top-level
+* `subscribed` option isn't accepted per query (see `placeholderData` below for another difference). A custom
+* `QueryClient` is supplied once, as `useQueries`' own top-level second argument, rather than per query.
+*
+* Having the same query key more than once in the array of query objects may cause some data to be shared
+* between queries. To avoid this, consider de-duplicating the queries and map the results back to the desired
+* structure.
+*
+* The `combine` option can be used to combine the results of the queries into a single value. The result will
+* be structurally shared to be as referentially stable as possible.
+*
+* @remarks The `combine` function only re-runs if it changed referentially, or if any of the query results
+* changed. An inlined `combine` function, as shown in the example below, therefore runs on every render — wrap
+* it in `useCallback`, or extract it to a stable function reference if it doesn't have any dependencies, to
+* avoid that.
+*
+* Unlike `useQuery`, `useQueries` cannot infer the `data` argument of an _inline_ `select` from its sibling
+* `queryFn`. Because `useQueries` infers the type of the whole `queries` array at once, the `select` parameter
+* of a query object written inline cannot be contextually typed from that same object's `queryFn`, so it falls
+* back to `unknown` — a [known TypeScript limitation](https://github.com/TanStack/query/issues/6556). Annotate
+* the `select` parameter explicitly, or define the query with {@link queryOptions}, which resolves its types in
+* a single object _before_ it reaches `useQueries`, to work around this — see the example below. The same
+* limitation applies to {@link useSuspenseQueries}.
+*
+* `placeholderData` is supported here too, but unlike `useQuery`, it doesn't receive information from
+* previously rendered queries, because the number of queries can differ between renders.
+* @param queryClient - Use this to provide a custom `QueryClient`. Otherwise, the one from the nearest context
+* will be used.
+* @returns The combined result. Without `combine`, this is an array with all the query results, in the same
+* order as the input. When `combine` is provided, this is the value returned by `combine` instead.
+*
+* @example
+* ```tsx
+* import { useQueries } from '@tanstack/react-query'
+*
+* function Posts({ ids }: { ids: Array<number> }) {
+*   const postQueries = useQueries({
+*     queries: ids.map((id) => ({
+*       queryKey: ['post', id],
+*       queryFn: () => fetchPost(id),
+*       staleTime: Infinity,
+*     })),
+*   })
+*
+*   return (
+*     <ul>
+*       {postQueries.map((query, index) => {
+*         if (query.isPending) return <li key={ids[index]}>Loading...</li>
+*         if (query.isError) return <li key={ids[index]}>Error: {query.error.message}</li>
+*         return <li key={ids[index]}>{query.data.title}</li>
+*       })}
+*     </ul>
+*   )
+* }
+* ```
+*
+* @example
+* Combining results into a single value:
+* ```tsx
+* import { useQueries } from '@tanstack/react-query'
+*
+* function Posts({ ids }: { ids: Array<number> }) {
+*   const { data, isPending, isError } = useQueries({
+*     queries: ids.map((id) => ({
+*       queryKey: ['post', id],
+*       queryFn: () => fetchPost(id),
+*     })),
+*     combine: (postQueries) => {
+*       return {
+*         data: postQueries.map((query) => query.data),
+*         isPending: postQueries.some((query) => query.isPending),
+*         isError: postQueries.some((query) => query.isError),
+*       }
+*     },
+*   })
+*
+*   if (isPending) return 'Loading...'
+*   if (isError) return 'Error loading posts'
+*
+*   return (
+*     <ul>
+*       {data.map((post) => (
+*         <li key={post?.id}>{post?.title}</li>
+*       ))}
+*     </ul>
+*   )
+* }
+* ```
+*
+* @example
+* Typing `select` via {@link queryOptions}. Note that spreading a `queryOptions` result and overriding
+* `select` inline still falls back to `unknown` — wrap the spread in `queryOptions` again so the override is
+* resolved before it reaches `useQueries`:
+* ```tsx
+* import { queryOptions, useQueries } from '@tanstack/react-query'
+*
+* const postOptions = (id: number) =>
+*   queryOptions({
+*     queryKey: ['post', id],
+*     queryFn: () => fetchPost(id),
+*   })
+*
+* function PostTitle({ id }: { id: number }) {
+*   const [{ data: broken }] = useQueries({
+*     queries: [
+*       {
+*         ...postOptions(id),
+*         // ❌ `data` is `unknown` here
+*         select: (data) => data.title,
+*       },
+*     ],
+*   })
+*
+*   const [{ data: fixed }] = useQueries({
+*     queries: [
+*       queryOptions({
+*         ...postOptions(id),
+*         // ✅ `data` is `Post`
+*         select: (data) => data.title,
+*       }),
+*     ],
+*   })
+*
+*   return <h1>{fixed}</h1>
+* }
+* ```
+*/
+function useQueries({ queries, ...options }, queryClient) {
+	const client = useQueryClient(queryClient);
+	const isRestoring = useIsRestoring();
+	const errorResetBoundary = useQueryErrorResetBoundary();
+	const subscribed = options.subscribed !== false;
+	const defaultedQueries = import_react.useMemo(() => queries.map((opts) => {
+		const defaultedOptions = client.defaultQueryOptions(opts);
+		defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
+		return defaultedOptions;
+	}), [
+		queries,
+		client,
+		isRestoring,
+		subscribed
+	]);
+	defaultedQueries.forEach((queryOptions) => {
+		ensureSuspenseTimers(queryOptions);
+		ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, client.getQueryCache().get(queryOptions.queryHash));
+	});
+	useClearResetErrorBoundary(errorResetBoundary);
+	const [observer] = import_react.useState(() => new QueriesObserver(client, defaultedQueries, options));
+	const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(defaultedQueries, options.combine);
+	const shouldSubscribe = !isRestoring && subscribed;
+	import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+	import_react.useEffect(() => {
+		observer.setQueries(defaultedQueries, options);
+	}, [
+		defaultedQueries,
+		options,
+		observer
+	]);
+	const suspensePromises = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result)) ? optimisticResult.flatMap((result, index) => {
+		const opts = defaultedQueries[index];
+		if (opts && shouldSuspend(opts, result)) return fetchOptimistic(opts, new QueryObserver(client, opts), errorResetBoundary);
+		return [];
+	}) : [];
+	if (suspensePromises.length > 0) throw Promise.all(suspensePromises);
+	const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
+		const query = defaultedQueries[index];
+		return query && getHasError({
+			result,
+			errorResetBoundary,
+			throwOnError: query.throwOnError,
+			query: client.getQueryCache().get(query.queryHash),
+			suspense: query.suspense
+		});
+	});
+	if (firstSingleResultWhichShouldThrow) throw firstSingleResultWhichShouldThrow.error;
+	return getCombinedResult(trackResult());
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
 function useBaseQuery(options, Observer, queryClient) {
 	const isRestoring = useIsRestoring();
 	const errorResetBoundary = useQueryErrorResetBoundary();
 	const client = useQueryClient(queryClient);
 	const defaultedOptions = client.defaultQueryOptions(options);
-	client.getDefaultOptions().queries?._experimental_beforeQuery?.(defaultedOptions);
 	const query = client.getQueryCache().get(defaultedOptions.queryHash);
 	const subscribed = options.subscribed !== false;
 	defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
 	ensureSuspenseTimers(defaultedOptions);
 	ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
 	useClearResetErrorBoundary(errorResetBoundary);
-	const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
 	const [observer] = import_react.useState(() => new Observer(client, defaultedOptions));
 	const result = observer.getOptimisticResult(defaultedOptions);
 	const shouldSubscribe = !isRestoring && subscribed;
@@ -112,19 +361,192 @@ function useBaseQuery(options, Observer, queryClient) {
 		query,
 		suspense: defaultedOptions.suspense
 	})) throw result.error;
-	client.getDefaultOptions().queries?._experimental_afterQuery?.(defaultedOptions, result);
-	if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) (isNewCacheEntry ? fetchOptimistic(defaultedOptions, observer, errorResetBoundary) : query?.promise)?.catch(noop).finally(() => {
-		observer.updateResult();
-	});
 	return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.101.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/useQuery.js
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/useQuery.js
 function useQuery(options, queryClient) {
 	return useBaseQuery(options, QueryObserver, queryClient);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-query@5.101.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/useMutation.js
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/queryOptions.js
+function queryOptions(options) {
+	return options;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/useMutation.js
+/**
+* Unlike queries, mutations are typically used to create/update/delete data or perform server side-effects.
+* `useMutation` is the hook for that.
+*
+* @see {@link mutationOptions} to share these options across multiple `useMutation` call sites, or to look
+* the mutation up elsewhere via its `mutationKey` (e.g. with `useMutationState`).
+* @param options - The {@link UseMutationOptions} to use — everything you can pass to `useMutation`.
+* @param queryClient - Use this to use a custom `QueryClient`. Otherwise, the one from the nearest context will
+* be used.
+* @returns `mutate`/`mutateAsync` also accept per-call `onSuccess`/`onError`/`onSettled` callbacks as a second
+* argument, useful for triggering call-site side effects (e.g. navigation) without coupling them to the shared
+* mutation definition. Hook-level callbacks (passed to `options`) fire for every mutation; per-call callbacks
+* fire only for the latest call you've made, and only while the component is still mounted — unmounting before
+* the mutation settles removes the subscription and prevents them from firing.
+*
+* @example
+* ```tsx
+* import { useMutation, useQueryClient } from '@tanstack/react-query'
+*
+* function AddTodo() {
+*   const queryClient = useQueryClient()
+*
+*   const addMutation = useMutation({
+*     mutationFn: addTodo,
+*     onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
+*   })
+*
+*   return (
+*     <button
+*       onClick={() =>
+*         addMutation.mutate('Item', {
+*           onError: (error) => console.error('Failed to add item:', error),
+*         })
+*       }
+*     >
+*       Add
+*     </button>
+*   )
+* }
+* ```
+*
+* @example
+* Rendering the mutation's own state, rather than just firing it off:
+* ```tsx
+* import { useMutation, useQueryClient } from '@tanstack/react-query'
+*
+* function AddTodo() {
+*   const queryClient = useQueryClient()
+*
+*   const addMutation = useMutation({
+*     mutationFn: addTodo,
+*     onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
+*   })
+*
+*   return (
+*     <div>
+*       {addMutation.isPending ? (
+*         'Adding todo...'
+*       ) : (
+*         <>
+*           {addMutation.isError ? (
+*             <div>An error occurred: {addMutation.error.message}</div>
+*           ) : null}
+*           <button onClick={() => addMutation.mutate('Item')}>Add</button>
+*         </>
+*       )}
+*     </div>
+*   )
+* }
+* ```
+*
+* @example
+* Optimistic update via `onMutate`, rolling back on `onError`:
+* ```tsx
+* import { useMutation, useQueryClient } from '@tanstack/react-query'
+*
+* function AddTodo() {
+*   const queryClient = useQueryClient()
+*
+*   const addMutation = useMutation({
+*     mutationFn: addTodo,
+*     onMutate: async (newTodo) => {
+*       await queryClient.cancelQueries({ queryKey: ['todos'] })
+*       const previousTodos = queryClient.getQueryData<Array<string>>(['todos'])
+*
+*       queryClient.setQueryData<Array<string>>(['todos'], (old) => [
+*         ...(old ?? []),
+*         newTodo,
+*       ])
+*
+*       // Passed to `onError` as `onMutateResult` if the mutation fails.
+*       return { previousTodos }
+*     },
+*     onError: (_err, _newTodo, onMutateResult) => {
+*       queryClient.setQueryData(['todos'], onMutateResult?.previousTodos)
+*     },
+*     onSettled: () => {
+*       queryClient.invalidateQueries({ queryKey: ['todos'] })
+*     },
+*   })
+*
+*   return (
+*     <button onClick={() => addMutation.mutate('Item')}>Add</button>
+*   )
+* }
+* ```
+*
+* @example
+* Callbacks passed per call to `mutate` only fire for the last call — `mutateAsync` gives you a
+* promise per call instead, so you can wait for all of them when they succeed:
+* ```tsx
+* import { useMutation, useQueryClient } from '@tanstack/react-query'
+*
+* function AddTodos() {
+*   const queryClient = useQueryClient()
+*
+*   const addMutation = useMutation({
+*     mutationFn: addTodo,
+*     onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
+*   })
+*
+*   async function handleAddAll(todos: Array<string>) {
+*     try {
+*       await Promise.all(todos.map((todo) => addMutation.mutateAsync(todo)))
+*     } catch (error) {
+*       console.error('Failed to add todos:', error)
+*     }
+*   }
+*
+*   return (
+*     <button onClick={() => handleAddAll(['Todo 1', 'Todo 2', 'Todo 3'])}>
+*       Add all
+*     </button>
+*   )
+* }
+* ```
+*
+* @example
+* If some of the mutations above can fail independently of the others, and you want to know which ones
+* did — rather than losing that information the moment the first one rejects — swap `Promise.all` for
+* `Promise.allSettled`:
+* ```tsx
+* import { useMutation, useQueryClient } from '@tanstack/react-query'
+*
+* function AddTodos() {
+*   const queryClient = useQueryClient()
+*
+*   const addMutation = useMutation({
+*     mutationFn: addTodo,
+*     onSuccess: () => queryClient.invalidateQueries({ queryKey: ['todos'] }),
+*   })
+*
+*   async function handleAddAll(todos: Array<string>) {
+*     const addResults = await Promise.allSettled(
+*       todos.map((todo) => addMutation.mutateAsync(todo)),
+*     )
+*
+*     addResults.forEach((addResult, index) => {
+*       if (addResult.status === 'rejected') {
+*         console.error(`Failed to add "${todos[index]}":`, addResult.reason)
+*       }
+*     })
+*   }
+*
+*   return (
+*     <button onClick={() => handleAddAll(['Todo 1', 'Todo 2', 'Todo 3'])}>
+*       Add all
+*     </button>
+*   )
+* }
+* ```
+*/
 function useMutation(options, queryClient) {
 	const client = useQueryClient(queryClient);
 	const [observer] = import_react.useState(() => new MutationObserver(client, options));
@@ -132,8 +554,8 @@ function useMutation(options, queryClient) {
 		observer.setOptions(options);
 	}, [observer, options]);
 	const result = import_react.useSyncExternalStore(import_react.useCallback((onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
-	const mutate = import_react.useCallback((variables, mutateOptions) => {
-		observer.mutate(variables, mutateOptions).catch(noop);
+	const mutate = import_react.useCallback((...args) => {
+		observer.mutate(args[0], args[1]).catch(noop);
 	}, [observer]);
 	if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) throw result.error;
 	return {
@@ -143,4 +565,9 @@ function useMutation(options, queryClient) {
 	};
 }
 //#endregion
-export { useQueryClient as i, useQuery as n, QueryClientProvider as r, useMutation as t };
+//#region ../../node_modules/.pnpm/@tanstack+react-query@5.104.0_react@19.2.6/node_modules/@tanstack/react-query/build/modern/useInfiniteQuery.js
+function useInfiniteQuery(options, queryClient) {
+	return useBaseQuery(options, InfiniteQueryObserver, queryClient);
+}
+//#endregion
+export { useQueries as a, useQuery as i, useMutation as n, QueryClientProvider as o, queryOptions as r, useQueryClient as s, useInfiniteQuery as t };

package/.output/server/_libs/verkit.mjs

@@ -68,6 +68,36 @@ function parse(version, options = {}) {
 		prerelease
 	};
 }
+var NUMERIC = /^\d+$/;
+function compareIdentifiers(left, right) {
+	if (typeof left === "number" && typeof right === "number") return left === right ? 0 : left < right ? -1 : 1;
+	const leftNumeric = NUMERIC.test(String(left));
+	const rightNumeric = NUMERIC.test(String(right));
+	const normalizedLeft = leftNumeric ? Number(left) : left;
+	const normalizedRight = rightNumeric ? Number(right) : right;
+	return normalizedLeft === normalizedRight ? 0 : leftNumeric && !rightNumeric ? -1 : rightNumeric && !leftNumeric ? 1 : normalizedLeft < normalizedRight ? -1 : 1;
+}
+function compareMainParsed(left, right) {
+	return left.major === right.major ? left.minor === right.minor ? left.patch === right.patch ? 0 : left.patch < right.patch ? -1 : 1 : left.minor < right.minor ? -1 : 1 : left.major < right.major ? -1 : 1;
+}
+function comparePrereleaseParsed(left, right) {
+	const leftPrerelease = left.prerelease;
+	const rightPrerelease = right.prerelease;
+	if (leftPrerelease?.length && !rightPrerelease?.length) return -1;
+	if (!leftPrerelease?.length && rightPrerelease?.length) return 1;
+	if (!leftPrerelease?.length && !rightPrerelease?.length) return 0;
+	for (let index = 0;; index++) {
+		const leftIdentifier = leftPrerelease?.[index];
+		const rightIdentifier = rightPrerelease?.[index];
+		if (leftIdentifier === void 0 && rightIdentifier === void 0) return 0;
+		if (rightIdentifier === void 0) return 1;
+		if (leftIdentifier === void 0) return -1;
+		if (leftIdentifier !== rightIdentifier) return compareIdentifiers(leftIdentifier, rightIdentifier);
+	}
+}
+function compareParsed(left, right) {
+	return compareMainParsed(left, right) || comparePrereleaseParsed(left, right);
+}
 //#endregion
 //#region ../../node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/set-CC5YeoYX.js
 var STRICT_COMPARATOR = safeRegex(String.raw`^${GREATER_LESS_THAN}\s*(${FULL_PLAIN})$|^$`);
@@ -89,6 +119,40 @@ function parseComparator(comparator, options = {}) {
 		version
 	};
 }
+function testParsedComparator(comparator, version) {
+	if (!comparator.version) return true;
+	const comparison = compareParsed(version, comparator.version);
+	switch (comparator.operator) {
+		case "": return comparison === 0;
+		case ">": return comparison > 0;
+		case ">=": return comparison >= 0;
+		case "<": return comparison < 0;
+		case "<=": return comparison <= 0;
+	}
+}
+function comparatorAllowsPrerelease(comparator, version) {
+	const allowed = comparator.version;
+	return allowed !== null && !!allowed.prerelease?.length && allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch;
+}
+function testComparatorSet(set, version, options) {
+	if (set.some((comparator) => !testParsedComparator(comparator, version))) return false;
+	return !version.prerelease?.length || !!options.includePrerelease || set.some((comparator) => comparatorAllowsPrerelease(comparator, version));
+}
+function parsedComparatorsIntersect(left, right, options = {}) {
+	if (!left.version || !right.version) return true;
+	if (left.operator === "") return testComparatorSet([right], left.version, options);
+	if (right.operator === "") return testComparatorSet([left], right.version, options);
+	const leftValue = formatComparator(left);
+	const rightValue = formatComparator(right);
+	if (options.includePrerelease && (leftValue === "<0.0.0-0" || rightValue === "<0.0.0-0")) return false;
+	if (!options.includePrerelease && (leftValue.startsWith("<0.0.0") || rightValue.startsWith("<0.0.0"))) return false;
+	if (left.operator.startsWith(">") && right.operator.startsWith(">")) return true;
+	if (left.operator.startsWith("<") && right.operator.startsWith("<")) return true;
+	const comparison = compareParsed(left.version, right.version);
+	if (comparison === 0 && left.operator.includes("=") && right.operator.includes("=")) return true;
+	if (comparison < 0 && left.operator.startsWith(">") && right.operator.startsWith("<")) return true;
+	return comparison > 0 && left.operator.startsWith("<") && right.operator.startsWith(">");
+}
 //#endregion
 //#region ../../node_modules/.pnpm/verkit@0.4.0/node_modules/verkit/dist/range-DvX-Y6iv.js
 function formatRange(range) {
@@ -243,9 +307,46 @@ function tryParseRange(range, options = {}) {
 		return null;
 	}
 }
+function exactVersion(set) {
+	for (const comparator of set) if (comparator.operator === "" && comparator.version) return comparator.version;
+	return null;
+}
+function isSatisfiable(comparators, options) {
+	const exact = exactVersion(comparators);
+	if (exact) return testComparatorSet(comparators, exact, options);
+	const remaining = [...comparators];
+	let current = remaining.pop();
+	while (current && remaining.length) {
+		if (remaining.some((other) => !parsedComparatorsIntersect(current, other, options))) return false;
+		current = remaining.pop();
+	}
+	return true;
+}
+function setsIntersect(left, right, options) {
+	const leftExact = exactVersion(left);
+	if (leftExact) return testComparatorSet(right, leftExact, options);
+	const rightExact = exactVersion(right);
+	if (rightExact) return testComparatorSet(left, rightExact, options);
+	return left.every((leftComparator) => right.every((rightComparator) => parsedComparatorsIntersect(leftComparator, rightComparator, options)));
+}
+function parsedRangesIntersect(left, right, options = {}) {
+	return left.sets.some((leftSet) => isSatisfiable(leftSet, options) && right.sets.some((rightSet) => isSatisfiable(rightSet, options) && setsIntersect(leftSet, rightSet, options)));
+}
+function isValidRange(range, options = {}) {
+	return tryParseRange(range, options) !== null;
+}
 function normalizeRange(range, options = {}) {
 	const parsed = tryParseRange(range, options);
 	return parsed ? formatRange(parsed) || "*" : null;
 }
+function rangesIntersect(left, right, options = {}) {
+	const parsedLeft = parseRange(left, options);
+	const parsedRight = parseRange(right, options);
+	return parsedRangesIntersect(parsedLeft, parsedRight, {
+		...parsedLeft.options,
+		...parsedRight.options,
+		...options
+	});
+}
 //#endregion
-export { normalizeRange as t };
+export { normalizeRange as n, rangesIntersect as r, isValidRange as t };