Skip to content

Open-source manufacturing ERP, MES and QMS. Quoting, MRP, inventory, shop floor, quality and lot/serial traceability on one Postgres schema, with a REST API and MCP server. Self-host or use Carbon Cloud.

fix(react): recover from a dropped connection instead of showing a crash

Sidwebworks247bbc299a3e
diff --git a/.ai/lessons.md b/.ai/lessons.md
index d946b54e4c..a2342be0e4 100644
--- a/.ai/lessons.md
+++ b/.ai/lessons.md
@@ -3286,7 +3286,7 @@ of `salesInvoice`; backfilled by `20261006220901_sales-invoice-opportunity-backf
**Rule:** Never call React Router's `revalidate()` directly. Import `useRevalidator` from `@carbon/query`: it holds a call made while a navigation is in flight or a fetcher is submitting and runs it when the router is idle. The `no-raw-revalidator` check (`@carbon/checks`) fails an import of React Router's. Before explaining a skipped loader, log what `shouldRevalidate` received: wrap the route's `shouldRevalidate` on `window.__reactRouterDataRouter.routes` and read `formMethod`, `defaultShouldRevalidate` and both URLs for each call.
-**Applies to:** `packages/query/src/useRevalidator.ts`; every `revalidate()` call (realtime, polling timers, upload callbacks); every route that exports `shouldRevalidate`.
+**Applies to:** `packages/react/src/hooks/useRevalidator.ts`; every `revalidate()` call (realtime, polling timers, upload callbacks); every route that exports `shouldRevalidate`.
## A drag re-rendered every card on the board
@@ -3919,3 +3919,13 @@ The write was then removed (nothing reads it), so the rail always starts collaps
**Rule:** Inside a step, make the request short. Wait between requests with `step.waitForEvent` or `step.sleep`, which hold no slot. Treat a 5xx answer as "unreachable", not as a lost job.
**Applies to:** every Inngest function that polls an external service.
+
+## A fetcher's error goes to the boundary above the component that owns it
+
+**Context:** `CarbonProvider` (`@carbon/auth`, rendered by each app's `x+/_layout`) refreshes the session from a one-minute timer with `useFetcher().submit` to `/refresh-session`. In a background tab the POST failed with `TypeError: Failed to fetch` (the laptop asleep, the connection dropped), and the whole app was replaced by the root "Something broke on our end" screen.
+
+**Problem:** React Router sends a fetcher's error to `findNearestBoundary(state.matches, routeId)`, where `routeId` is the route that RENDERED the fetcher, not the route the request was sent to. `refresh-session.tsx` exports an `ErrorBoundary` that never runs for this; the shell layout has none, so the root took it. A fetch that gets no response is not a `Response`, so the boundary showed it as a 500.
+
+**Rule:** A request a timer or event sends on its own (not one the user started) must not be able to fail into a boundary: skip it while `navigator.onLine` is false and retry on `online`. Both error boundaries treat `isNetworkError` as a lost connection and revalidate when the connection or the tab comes back; a successful revalidation clears `state.errors`.
+
+**Applies to:** every `useFetcher` used from a layout or provider, every background timer that submits or loads, `packages/react/src/ErrorBoundary/`.
diff --git a/packages/auth/src/lib/supabase/provider.tsx b/packages/auth/src/lib/supabase/provider.tsx
index 86c66f843a..e28ad80640 100644
--- a/packages/auth/src/lib/supabase/provider.tsx
+++ b/packages/auth/src/lib/supabase/provider.tsx
@@ -68,6 +68,10 @@ export const CarbonProvider = ({
// shell is told to re-run after a refresh. Without that, every loader on the
// page re-ran each time the tab regained focus.
const refreshIfDue = (canRefresh: boolean) => {
+ // Offline, the reload lands on the browser's error page and the refresh
+ // fails into the app's error screen. The "online" listener checks again.
+ if (!navigator.onLine) return;
+
const expiresAt = session.expiresAt ?? 0;
const now = Date.now() / 1000;
@@ -93,9 +97,11 @@ export const CarbonProvider = ({
const handleVisibilityChange = () => {
if (document.visibilityState === "visible") refreshIfDue(true);
};
+ const handleOnline = () => refreshIfDue(true);
if (isBrowser) {
document.addEventListener("visibilitychange", handleVisibilityChange);
+ window.addEventListener("online", handleOnline);
}
return () => {
@@ -104,6 +110,7 @@ export const CarbonProvider = ({
"visibilitychange",
handleVisibilityChange
);
+ window.removeEventListener("online", handleOnline);
}
};
}, [refresh, session.expiresAt]);
diff --git a/packages/checks/src/conformance/no-raw-revalidator.test.ts b/packages/checks/src/conformance/no-raw-revalidator.test.ts
index 7a2ff824bb..cf89074147 100644
--- a/packages/checks/src/conformance/no-raw-revalidator.test.ts
+++ b/packages/checks/src/conformance/no-raw-revalidator.test.ts
@@ -34,7 +34,7 @@ describe("noRawRevalidator", () => {
expect(
scan(
`import { useRevalidator as useRouterRevalidator } from "react-router";\n`,
- "packages/query/src/useRevalidator.ts"
+ "packages/react/src/hooks/useRevalidator.ts"
)
).toEqual([]);
});
diff --git a/packages/checks/src/conformance/no-raw-revalidator.ts b/packages/checks/src/conformance/no-raw-revalidator.ts
index 8ae33f2226..71a708f670 100644
--- a/packages/checks/src/conformance/no-raw-revalidator.ts
+++ b/packages/checks/src/conformance/no-raw-revalidator.ts
@@ -11,7 +11,7 @@ import type { ConformanceCheck, Violation } from "../check";
const ROUTER_IMPORT =
/import\s*(?:type\s*)?\{([^}]*)\}\s*from\s*["']react-router["']/g;
// The wrapper itself: the one place that takes React Router's.
-const DEFINITION = "packages/query/src/useRevalidator.ts";
+const DEFINITION = "packages/react/src/hooks/useRevalidator.ts";
export const noRawRevalidator: ConformanceCheck = {
id: "no-raw-revalidator",
diff --git a/packages/query/AGENTS.md b/packages/query/AGENTS.md
index 7635ce478a..be3ad7c524 100644
--- a/packages/query/AGENTS.md
+++ b/packages/query/AGENTS.md
@@ -39,7 +39,7 @@ pnpm --filter @carbon/query test
| `cachedApiQuery(url)` | The same read from an event handler or an effect |
| `useAction({ onSuccess, onError, onSettled })` | A mutation fetcher with callbacks. `onSettled` runs whenever a submission finishes, also when the action redirects and returns no data; `onSuccess` / `onError` need data |
| `setClientCompanyId(companyId, userId)` / `getCompanyId` | The shell layout sets both during render; the `companyId` cookie is httpOnly and unreadable in the browser. A different user empties the cache; leaving a company drops its loader entries |
-| `useRevalidator()` | React Router's `useRevalidator`, held while a fetcher is submitting or a navigation is in flight. The only one app code may import (`no-raw-revalidator` check): a revalidation during an action drops the fetcher's redirect, and one during the navigation after a save restarts that navigation |
+| `useRevalidator()` | Defined in `@carbon/react` (the error boundaries need it) and re-exported here. React Router's `useRevalidator`, held while a fetcher is submitting or a navigation is in flight. The only one app code may import (`no-raw-revalidator` check): a revalidation during an action drops the fetcher's redirect, and one during the navigation after a save restarts that navigation |
| `createInvalidationMiddleware({ getCache, skipPaths })` | Root `clientMiddleware`; skip POSTs that change no data (`/refresh-session`) |
| `RouteRealtime`, `useRealtimeTable`, `useTableChanges`, `useRealtimeRevalidator` | Realtime over private broadcast topics. Reloads go through `useRevalidator`, so they wait for a save in flight. A route entry `{ table, column, param }` and a `<name>Id=eq.` filter follow one record's rows only (`matchesFilter`) |
| `useRealtimeChannel` | One channel with retry, `private` and `onSubscribed(isReconnect)`. It reconnects when the tab returns after 5 minutes hidden or with a channel that is not joined — every reconnect reloads the page's data, so time in another tab does not |
diff --git a/packages/query/src/index.ts b/packages/query/src/index.ts
index ee60243b48..ceb069b928 100644
--- a/packages/query/src/index.ts
+++ b/packages/query/src/index.ts
@@ -2,6 +2,7 @@
// Carbon (github.com/crbnos/carbon). Modified or adapted versions of this file,
// including ports, remain AGPLv3; serving them over a network requires releasing their source.
+export { useRevalidator } from "@carbon/react";
export * from "./cache";
export type { Cursor } from "./liveList";
export { matchesFilter } from "./realtimeFilter";
@@ -22,4 +23,3 @@ export {
useTopic
} from "./useRealtime";
export { useRealtimeChannel } from "./useRealtimeChannel";
-export { useRevalidator } from "./useRevalidator";
diff --git a/packages/query/src/useRealtime.tsx b/packages/query/src/useRealtime.tsx
index 392d3973ef..6e49811977 100644
--- a/packages/query/src/useRealtime.tsx
+++ b/packages/query/src/useRealtime.tsx
@@ -6,6 +6,7 @@ import type {
RealtimeTable,
RouteRealtimeTable
} from "@carbon/database/realtime-tables";
+import { useRevalidator } from "@carbon/react";
import {
useCallback,
useEffect,
@@ -18,7 +19,6 @@ import { getClientCache } from "./cache";
import { invalidateLoaderEntries } from "./invalidation";
import { matchesFilter } from "./realtimeFilter";
import { useRealtimeChannel } from "./useRealtimeChannel";
-import { useRevalidator } from "./useRevalidator";
/** What `broadcast_table_changes` sends: no row data, only which rows changed. */
export type BroadcastChange = {
diff --git a/packages/react/AGENTS.md b/packages/react/AGENTS.md
index 01a0333b28..80ddbcde91 100644
--- a/packages/react/AGENTS.md
+++ b/packages/react/AGENTS.md
@@ -48,7 +48,7 @@ import { Button, Card, HStack, VStack, IconButton, cn } from "@carbon/react";
- **Record outlet**: `RecordOutlet` is the `<Outlet>` of every route under `/x`. It remounts the page inside it when that page is shown for a different record (the params of the route in the outlet, not of a drawer below it), so nothing seeded from the previous record survives. A plain `<Outlet>` there fails the `no-bare-outlet` check
- **Data**: `Table` (TanStack), chart components via sub-exports (`@carbon/react/Chart`)
- **Rich text**: `@carbon/react/Editor` and `@carbon/react/RichText` (wraps `@carbon/tiptap`)
-- **Error boundary**: `@carbon/react/ErrorBoundary` — `RouteErrorBoundary` (exported as `ErrorBoundary` from a module layout so a failed loader shows inside the app shell; it shows the status code and, for a 4xx, the message the server threw — `routeErrorCopy` — so throw a `Response` whose body says what was wrong. A 5xx or thrown `Error` gets generic copy) and `RootErrorBoundary` (drop-in root `ErrorBoundary` for RR v7 that maps 404 / 503 (the maintenance screen) / other HTTP / thrown `Error` to a styled screen) plus its parts (`ErrorScreen`, `GlitchHeading`, `StatusReadout`, `MagneticLink`, `NoiseOverlay`). Wrap it in the app's `Document` and pass `env` so `window.env` is set (the client crashes hydration otherwise). Copy is intentionally hardcoded English, not i18n.
+- **Error boundary**: `@carbon/react/ErrorBoundary` — `RouteErrorBoundary` (exported as `ErrorBoundary` from a module layout so a failed loader shows inside the app shell; it shows the status code and, for a 4xx, the message the server threw — `routeErrorCopy` — so throw a `Response` whose body says what was wrong. A 5xx or thrown `Error` gets generic copy) and `RootErrorBoundary` (drop-in root `ErrorBoundary` for RR v7 that maps 404 / 503 (the maintenance screen) / other HTTP / thrown `Error` to a styled screen) plus its parts (`ErrorScreen`, `GlitchHeading`, `StatusReadout`, `MagneticLink`, `NoiseOverlay`). Both read a request that got no response (`isNetworkError`: a `TypeError` with one of the browsers' fetch-failure messages) as a lost connection, not a fault, and `useNetworkRetry` revalidates when the browser is back online or the tab is shown again, which clears the error. Wrap it in the app's `Document` and pass `env` so `window.env` is set (the client crashes hydration otherwise). Copy is intentionally hardcoded English, not i18n.
- **Avatar**: `src` may be a URL or a generated-avatar value from `user.avatarUrl` (`dicebear:<style>:<seed>[:<rrggbb>]`; the styles and value helpers are in `@carbon/utils` `avatar.ts`). A generated value renders as a plain `<img>` of `generatedAvatarUrl(value)` (`utils/generatedAvatarImage.ts`, which `Avatar` imports instead of the renderer so no bundle that shows an avatar carries DiceBear) — `/file/avatar/:value?v=<GENERATED_AVATAR_RENDER_VERSION>` — so it is in the server-rendered HTML and needs no client JavaScript. Every app (ERP, MES, academy) serves that path with a one-line route re-exporting `generatedAvatarLoader` from `@carbon/react/GeneratedAvatar`: it draws the SVG on the server with DiceBear 10 and answers `Cache-Control: public, max-age=31536000, immutable`, so a refresh reads it from the browser cache. **Bump `GENERATED_AVATAR_RENDER_VERSION` whenever the same value would draw differently** (a DiceBear upgrade, a change to the rendering options), or browsers keep the old image. The avatar picker draws in the browser instead (`GeneratedAvatarPreview`, `useGeneratedAvatar`), because a color drag makes a new value per step; there the DiceBear core and each style's JSON load with `import()` (`STYLE_LOADERS`, typed `Record<GeneratedAvatarStyle, …>`), never with a `with: { type: "json" }` attribute (Vite passes it to the browser, which rejects the JSON Vite serves as JavaScript, and the picker stays grey); the server side instead bundles `@dicebear/styles` through `ssrNoExternal` in each app's `vite.config.ts`, because Node refuses a package's JSON without the attribute. `generatedAvatarClassName(style)` picks the image classes: line-art styles on white (`bg-white`) in both themes, color styles on `bg-muted`. A value's optional background goes to DiceBear as `backgroundColor`; on a dark one (`isDarkBackground`, WCAG contrast) the styles that draw lines straight onto the background (`INK_OPTIONS`) get white ink. The app `Avatar` wrappers turn a stored value into `src` with `avatarSrc` (`@carbon/utils`); a new user has no avatar (initials) until they choose one
- **Announcement**: `AnnouncementBar` is the one-line bar both shells render above their page area for the deployment's announcement. It remembers a dismissal in localStorage per user and announcement id, and while shown sets `--announcement-height` on `<html>`; the ERP's `--content-inset` includes it, and a page sized from `100dvh` outside that variable must subtract it
- **Polish**: shadows over borders, `tabular-nums` for dynamic numbers, `active:scale-[0.98]` on pressables, `text-balance`/`text-pretty` for text wrapping
diff --git a/packages/react/src/ErrorBoundary/RootErrorBoundary.tsx b/packages/react/src/ErrorBoundary/RootErrorBoundary.tsx
index 86f6d6cb53..234ca1c7c4 100644
--- a/packages/react/src/ErrorBoundary/RootErrorBoundary.tsx
+++ b/packages/react/src/ErrorBoundary/RootErrorBoundary.tsx
@@ -5,6 +5,8 @@
import { useEffect } from "react";
import { isRouteErrorResponse, useNavigate } from "react-router";
import { ErrorScreen, type ErrorScreenProps } from "./ErrorScreen";
+import { isNetworkError } from "./routeErrorCopy";
+import { useNetworkRetry } from "./useNetworkRetry";
/**
* VOID//SYS — drop-in root ErrorBoundary for React Router v7 (framework mode).
@@ -18,14 +20,17 @@ import { ErrorScreen, type ErrorScreenProps } from "./ErrorScreen";
* return <RootErrorBoundary error={error} />;
* }
*
- * It handles three cases:
+ * It handles four cases:
* 1. Route error responses (thrown `Response` / `data()` — includes 404s and
* any other HTTP status like 401 / 403 / 500).
* 2. Real `Error` instances thrown during render / loaders / actions.
- * 3. Anything else that got thrown (strings, unknown values).
+ * 3. A request that never reached the server (offline, asleep): it retries
+ * on its own once the connection or the tab is back.
+ * 4. Anything else that got thrown (strings, unknown values).
*/
export function RootErrorBoundary({ error }: { error: unknown }) {
const navigate = useNavigate();
+ const { offline, retry } = useNetworkRetry(error);
// Route errors (e.g. an unmatched fetcher.load) are otherwise invisible —
// React Router hands them to the boundary without logging anywhere.
@@ -39,7 +44,7 @@ export function RootErrorBoundary({ error }: { error: unknown }) {
console.error(`[ErrorBoundary] ${summary}`, error);
}, [error]);
- const config = resolveConfig(error, () => navigate(0));
+ const config = resolveConfig(error, offline ? retry : () => navigate(0));
return <ErrorScreen {...config} />;
}
@@ -118,7 +123,29 @@ function resolveConfig(error: unknown, retry: () => void): ErrorScreenProps {
};
}
- // 2. Real Error instances thrown during render / loaders / actions.
+ // 2. The request never reached the server. `retry` reloads the data in
+ // place: a full reload while offline would land on the browser's own page.
+ if (isNetworkError(error)) {
+ return {
+ code: "000",
+ eyebrow: "— connection lost",
+ title: "Carbon could not reach the server.",
+ message:
+ "The connection dropped or the computer was asleep. Nothing you saved is lost; Carbon tries again when the connection returns or when you come back to this tab.",
+ highlightIndex: 3,
+ logLines: [
+ "> opening channel to server ...",
+ "> transmitting request payload",
+ "> no response from remote host",
+ "> status_code: 000 / NO_RESPONSE",
+ "> waiting for the connection",
+ "> recommendation: retry once online"
+ ],
+ actions: [{ label: "retry", onClick: retry }]
+ };
+ }
+
+ // 3. Real Error instances thrown during render / loaders / actions.
// SI-11: never reveal internal error detail (message / source location) to end
// users in production — it aids reconnaissance. Show it only in development.
// Vite replaces `import.meta.env.DEV` at build; this shared package has no Vite
diff --git a/packages/react/src/ErrorBoundary/RouteErrorBoundary.tsx b/packages/react/src/ErrorBoundary/RouteErrorBoundary.tsx
index 57607680c7..3b12a5079e 100644
--- a/packages/react/src/ErrorBoundary/RouteErrorBoundary.tsx
+++ b/packages/react/src/ErrorBoundary/RouteErrorBoundary.tsx
@@ -6,6 +6,7 @@ import { useEffect } from "react";
import { useNavigate, useRouteError } from "react-router";
import { Button } from "../Button";
import { routeErrorCopy } from "./routeErrorCopy";
+import { useNetworkRetry } from "./useNetworkRetry";
/**
* The boundary for a route that renders inside the app shell:
@@ -19,6 +20,7 @@ import { routeErrorCopy } from "./routeErrorCopy";
export function RouteErrorBoundary() {
const error = useRouteError();
const navigate = useNavigate();
+ const { offline, retry } = useNetworkRetry(error);
// React Router hands a route error to the boundary without logging it.
useEffect(() => {
@@ -46,7 +48,10 @@ export function RouteErrorBoundary() {
</div>
<div className="flex gap-2">
{canRetry && (
- <Button variant="primary" onClick={() => navigate(0)}>
+ <Button
+ variant="primary"
+ onClick={() => (offline ? retry() : navigate(0))}
+ >
Try again
</Button>
)}
diff --git a/packages/react/src/ErrorBoundary/routeErrorCopy.test.ts b/packages/react/src/ErrorBoundary/routeErrorCopy.test.ts
index ecca50dda9..b3ee109db0 100644
--- a/packages/react/src/ErrorBoundary/routeErrorCopy.test.ts
+++ b/packages/react/src/ErrorBoundary/routeErrorCopy.test.ts
@@ -3,7 +3,7 @@
// including ports, remain AGPLv3; serving them over a network requires releasing their source.
import { describe, expect, it } from "vitest";
-import { routeErrorCopy } from "./routeErrorCopy";
+import { isNetworkError, routeErrorCopy } from "./routeErrorCopy";
// The shape `isRouteErrorResponse` accepts.
const response = (status: number, data: unknown) => ({
@@ -58,4 +58,23 @@ describe("routeErrorCopy", () => {
expect(routeErrorCopy(response(500, "x")).status).toBe(500);
expect(routeErrorCopy(new Error("x")).status).toBeUndefined();
});
+
+ it("reads a fetch that got no response as a lost connection", () => {
+ for (const message of [
+ "Failed to fetch",
+ "NetworkError when attempting to fetch resource.",
+ "Load failed"
+ ]) {
+ expect(isNetworkError(new TypeError(message))).toBe(true);
+ expect(routeErrorCopy(new TypeError(message))).toMatchObject({
+ title: "Connection lost",
+ canRetry: true
+ });
+ }
+ // A render bug is a TypeError too, and stays a fault on our side.
+ const bug = new TypeError("Cannot read properties of undefined");
+ expect(isNetworkError(bug)).toBe(false);
+ expect(routeErrorCopy(bug).message).toMatch(/on our side/);
+ expect(isNetworkError(new Error("Failed to fetch"))).toBe(false);
+ });
});
diff --git a/packages/react/src/ErrorBoundary/routeErrorCopy.ts b/packages/react/src/ErrorBoundary/routeErrorCopy.ts
index f1aab3279c..de4e874b21 100644
--- a/packages/react/src/ErrorBoundary/routeErrorCopy.ts
+++ b/packages/react/src/ErrorBoundary/routeErrorCopy.ts
@@ -27,6 +27,28 @@ const MESSAGES: Record<number, string> = {
404: "This page may have been moved or deleted, or it belongs to another company."
};
+// What each browser's `fetch` rejects with when no response arrived: Chrome,
+// Firefox, Safari, and the connection dropping mid-body.
+const NETWORK_ERROR_MESSAGES = new Set([
+ "Failed to fetch",
+ "network error",
+ "NetworkError when attempting to fetch resource.",
+ "Load failed",
+ "The Internet connection appears to be offline.",
+ "The network connection was lost."
+]);
+
+/**
+ * The request never reached the server: offline, a laptop waking from sleep,
+ * a dropped connection. Nothing on the page failed, so trying again once the
+ * connection is back is the fix.
+ */
+export function isNetworkError(error: unknown): boolean {
+ return (
+ error instanceof TypeError && NETWORK_ERROR_MESSAGES.has(error.message)
+ );
+}
+
/**
* What the route error screen says for a thrown value.
*
@@ -35,6 +57,15 @@ const MESSAGES: Record<number, string> = {
* thrown `Error` keeps the generic copy, since its text is internal detail.
*/
export function routeErrorCopy(error: unknown): RouteErrorCopy {
+ if (isNetworkError(error)) {
+ return {
+ title: "Connection lost",
+ message:
+ "Carbon could not reach the server. It tries again when the connection returns or when you come back to this tab.",
+ canRetry: true
+ };
+ }
+
if (
!isRouteErrorResponse(error) ||
error.status < 400 ||
diff --git a/packages/react/src/ErrorBoundary/useNetworkRetry.ts b/packages/react/src/ErrorBoundary/useNetworkRetry.ts
new file mode 100644
index 0000000000..31e622f1fb
--- /dev/null
+++ b/packages/react/src/ErrorBoundary/useNetworkRetry.ts
@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Carbon (github.com/crbnos/carbon). Modified or adapted versions of this file,
+// including ports, remain AGPLv3; serving them over a network requires releasing their source.
+
+import { useEffect } from "react";
+import { useRevalidator } from "../hooks/useRevalidator";
+import { isNetworkError } from "./routeErrorCopy";
+
+/**
+ * A boundary showing a network failure reloads the page's data when the
+ * browser comes back online or the tab is shown again. A background tab hits
+ * this on its own: a timer's request lands while the laptop sleeps or the
+ * connection drops. A successful reload clears the error, so the page returns
+ * without a full reload.
+ */
+export function useNetworkRetry(error: unknown) {
+ const { revalidate } = useRevalidator();
+ const offline = isNetworkError(error);
+
+ useEffect(() => {
+ if (!offline) return;
+ const retry = () => {
+ if (document.visibilityState === "visible") void revalidate();
+ };
+ window.addEventListener("online", retry);
+ document.addEventListener("visibilitychange", retry);
+ return () => {
+ window.removeEventListener("online", retry);
+ document.removeEventListener("visibilitychange", retry);
+ };
+ }, [offline, revalidate]);
+
+ return { offline, retry: revalidate };
+}
diff --git a/packages/react/src/hooks/index.ts b/packages/react/src/hooks/index.ts
index 0dc57c2966..0d2d6052f4 100644
--- a/packages/react/src/hooks/index.ts
+++ b/packages/react/src/hooks/index.ts
@@ -25,6 +25,7 @@ import { useNProgress } from "./useNProgress";
import { useOptimisticLocation } from "./useOptimisticLocation";
import useOutsideClick from "./useOutsideClick";
import { usePlan } from "./usePlan";
+import { useRevalidator } from "./useRevalidator";
import { useRouteData } from "./useRouteData";
import type { Shortcut, ShortcutDefinition } from "./useShortcutKeys";
import { useShortcutKeyMap, useShortcutKeys } from "./useShortcutKeys";
@@ -55,6 +56,7 @@ export {
useOptimisticMode,
useOutsideClick,
usePlan,
+ useRevalidator,
useRouteData,
useShortcutKeyMap,
useShortcutKeys,
diff --git a/packages/query/src/useRevalidator.ts b/packages/react/src/hooks/useRevalidator.ts
similarity index 100%
rename from packages/query/src/useRevalidator.ts
rename to packages/react/src/hooks/useRevalidator.ts