@hot-updater/console 1.0.0-rc.2 → 1.0.0-rc.21

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

@@ -1,16 +1,46 @@
-import { r as __toESM } from "../_runtime.mjs";
-import { J as require_react, q 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 { i as __toESM } from "../_runtime.mjs";
+import { mt as require_react, pt as require_jsx_runtime } from "./@base-ui/react+[...].mjs";
+import { c as shouldThrowError, i as notifyManager, n as MutationObserver, r as QueryObserver, s 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,23 @@ 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/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 +179,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 +372,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 +383,4 @@ function useMutation(options, queryClient) {
 	};
 }
 //#endregion
-export { useQueryClient as i, useQuery as n, QueryClientProvider as r, useMutation as t };
+export { useQueryClient as a, QueryClientProvider as i, queryOptions as n, useQuery as r, useMutation 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,43 @@ 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 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 { rangesIntersect as n, normalizeRange as t };

package/.output/server/_runtime.mjs

@@ -7,6 +7,15 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -23,4 +32,4 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
-export { __require as n, __toESM as r, __commonJSMin as t };
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };

package/.output/server/_ssr/ConsoleFeatureUnavailable-Du7jNPNS.mjs

@@ -0,0 +1,58 @@
+import { a as unavailableReason, n as consoleFeatures } from "./console-features-Dzu2iUGD.mjs";
+import { pt as require_jsx_runtime } from "../_libs/@base-ui/react+[...].mjs";
+import { L as ArrowUpRight } from "../_libs/lucide-react.mjs";
+import { D as buttonVariants, x as SidebarTrigger } from "./sidebar-DKbx2ach.mjs";
+import { a as useConsoleFeatures, n as notFoundFeature } from "./console-features-api-xAsSgFa_.mjs";
+import { t as NotFoundPage } from "./NotFoundPage-DsF4Vrhg.mjs";
+import { a as EmptyTitle, i as EmptyHeader, n as EmptyContent, r as EmptyDescription, t as Empty } from "./empty-DcBTAooP.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/ConsoleFeatureUnavailable-Du7jNPNS.js
+var import_jsx_runtime = require_jsx_runtime();
+var CONSOLE_DEPLOYMENT_GUIDE_URL = "https://hot-updater.dev/docs/guides/console-deployment";
+/**
+* A feature route's not-found state: the plugin to add, or, for a feature a
+* self-hosted server does not serve, the database config it needs.
+*/
+function ConsoleFeatureUnavailable({ data }) {
+	const feature = notFoundFeature(data);
+	const remote = useConsoleFeatures().data?.remote === true;
+	if (feature === void 0) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NotFoundPage, {});
+	const { label, plugin } = consoleFeatures[feature];
+	const pluginCall = /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", {
+		className: "font-mono",
+		children: `${plugin}()`
+	});
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+		className: "flex h-svh min-h-0 flex-col",
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("header", {
+			className: "sticky top-0 z-10 flex shrink-0 items-center gap-3 border-b bg-background px-3 py-3 sm:min-h-12 sm:bg-card/70 sm:px-4 sm:backdrop-blur-sm",
+			children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(SidebarTrigger, { className: "-ml-1" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h1", {
+				className: "text-sm font-medium",
+				children: label
+			})]
+		}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+			className: "flex min-h-0 min-w-0 flex-1 overflow-y-auto bg-muted/5 p-3 sm:p-6",
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Empty, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(EmptyHeader, { children: unavailableReason(feature, { remote }) === "remote" ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(EmptyTitle, { children: "Needs the server's database" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(EmptyDescription, { children: "This console reaches a self-hosted server through its admin API, which does not serve this page. Configure the console with the database the server uses." })] }) : /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)(EmptyTitle, { children: [label, " not installed"] }), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(EmptyDescription, { children: [
+				"Add ",
+				pluginCall,
+				" to ",
+				/* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", {
+					className: "font-mono",
+					children: "plugins"
+				}),
+				" ",
+				"where you create the server and in the console config."
+			] })] }) }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(EmptyContent, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("a", {
+				className: buttonVariants({ variant: "outline" }),
+				href: CONSOLE_DEPLOYMENT_GUIDE_URL,
+				rel: "noreferrer",
+				target: "_blank",
+				children: ["Console setup guide", /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ArrowUpRight, {
+					"aria-hidden": "true",
+					"data-icon": "inline-end"
+				})]
+			}) })] })
+		})]
+	});
+}
+//#endregion
+export { ConsoleFeatureUnavailable as t };

package/.output/server/_ssr/{HashValueDisplay-DwpGLfrl.mjs → HashValueDisplay-GQvFkXoi.mjs}

@@ -1,7 +1,7 @@
-import { q as require_jsx_runtime } from "../_libs/@base-ui/react+[...].mjs";
-import { C as cn, v as Tooltip$1, x as TooltipTrigger, y as TooltipContent } from "./createSsrRpc-DjWNJ0uc.mjs";
+import { pt as require_jsx_runtime } from "../_libs/@base-ui/react+[...].mjs";
+import { C as Tooltip$1, E as TooltipTrigger, O as cn, w as TooltipContent } from "./sidebar-DKbx2ach.mjs";
 import { n as toast } from "../_libs/sonner.mjs";
-//#region node_modules/.nitro/vite/services/ssr/assets/HashValueDisplay-DwpGLfrl.js
+//#region node_modules/.nitro/vite/services/ssr/assets/HashValueDisplay-GQvFkXoi.js
 var import_jsx_runtime = require_jsx_runtime();
 var shortenIdentifier = (value, maxLength = 12) => value.length > maxLength ? `${value.slice(0, Math.max(1, maxLength - 4))}…${value.slice(-4)}` : value;
 function HashValueDisplay({ value, maxLength = 12, className, buttonClassName }) {

package/.output/server/_ssr/InsightsInfo-Do7QSaFR.mjs

@@ -0,0 +1,37 @@
+import { i as __toESM } from "../_runtime.mjs";
+import { mt as require_react, pt as require_jsx_runtime } from "../_libs/@base-ui/react+[...].mjs";
+import { S as Info } from "../_libs/lucide-react.mjs";
+import { C as Tooltip$1, E as TooltipTrigger, t as Button$1, w as TooltipContent } from "./sidebar-DKbx2ach.mjs";
+//#region node_modules/.nitro/vite/services/ssr/assets/InsightsInfo-Do7QSaFR.js
+var import_react = /* @__PURE__ */ __toESM(require_react());
+var import_jsx_runtime = require_jsx_runtime();
+function InsightsInfo({ label, children }) {
+	const id = (0, import_react.useId)();
+	const [open, setOpen] = (0, import_react.useState)(false);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Tooltip$1, {
+		open,
+		onOpenChange: setOpen,
+		triggerId: id,
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(TooltipTrigger, {
+			id,
+			"aria-describedby": open ? `${id}-description` : void 0,
+			closeOnClick: false,
+			onClick: () => setOpen((value) => !value),
+			render: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Button$1, {
+				"aria-label": label,
+				className: "size-11 sm:size-7",
+				size: "icon",
+				variant: "ghost"
+			}),
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Info, {})
+		}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TooltipContent, {
+			id: `${id}-description`,
+			role: "tooltip",
+			className: "max-w-64",
+			side: "bottom",
+			children
+		})]
+	});
+}
+//#endregion
+export { InsightsInfo as t };