@nifrajs/web-react 2.1.0 → 2.3.0

package/README.md

@@ -1,8 +1,8 @@
 # @nifrajs/web-react
 
-React render adapter for @nifrajs/web — SSR + hydration (Bun-native JSX, no Babel).
+React render adapter for @nifrajs/web - SSR + hydration (Bun-native JSX, no Babel).
 
-Part of the **[nifra](https://nifra.dev)** full-stack TypeScript framework — one core, five UI libraries, every runtime. Scaffold a new app with `bun create nifra`.
+Part of the **[nifra](https://nifra.dev)** full-stack TypeScript framework - one core, five UI libraries, every runtime. Scaffold a new app with `bun create nifra`.
 
 ## Install
 
@@ -19,7 +19,7 @@ MIT
 
 ## For AI agents
 
-Start with [`LLM.md`](./LLM.md) — this package's contract card (the exports you call + its footguns),
+Start with [`LLM.md`](./LLM.md) - this package's contract card (the exports you call + its footguns),
 one cheap read instead of the whole corpus. For the wider framework: the repo's
 [`AGENTS.md`](../../AGENTS.md) is the copy-paste quick reference, and
 [`llms-full.txt`](../../llms-full.txt) is the full machine-readable corpus. Run `nifra check` as the

package/dist/await.d.ts

@@ -1,6 +1,6 @@
 import type { Deferred } from "@nifrajs/web";
 /**
- * `@nifrajs/web-react/await` — the `<Await>` primitive for deferred loader data (`defer()`). Isomorphic
+ * `@nifrajs/web-react/await` - the `<Await>` primitive for deferred loader data (`defer()`). Isomorphic
  * and imports only `react` + a type from `@nifrajs/web` (never `react-dom/server`), so route components
  * can use it without dragging server code into the client bundle. No JSX (the package builds with
  * plain `tsc`).
@@ -8,7 +8,7 @@ import type { Deferred } from "@nifrajs/web";
  * The server streams the boundary: `use(promise)` suspends, React flushes the fallback then the
  * resolved content mid-stream. On the client the registry promise is already settled (the core's
  * streamed `__nifraResolve` script tagged it `fulfilled`), so `use()` returns the value synchronously
- * — React hydrates the server-revealed boundary's content directly (no re-fetch, no fallback flash).
+ * - React hydrates the server-revealed boundary's content directly (no re-fetch, no fallback flash).
  */
 import { type ReactNode } from "react";
 export interface AwaitProps<T> {

package/dist/await.js

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-react/await` — the `<Await>` primitive for deferred loader data (`defer()`). Isomorphic
+ * `@nifrajs/web-react/await` - the `<Await>` primitive for deferred loader data (`defer()`). Isomorphic
  * and imports only `react` + a type from `@nifrajs/web` (never `react-dom/server`), so route components
  * can use it without dragging server code into the client bundle. No JSX (the package builds with
  * plain `tsc`).
@@ -7,7 +7,7 @@
  * The server streams the boundary: `use(promise)` suspends, React flushes the fallback then the
  * resolved content mid-stream. On the client the registry promise is already settled (the core's
  * streamed `__nifraResolve` script tagged it `fulfilled`), so `use()` returns the value synchronously
- * — React hydrates the server-revealed boundary's content directly (no re-fetch, no fallback flash).
+ * - React hydrates the server-revealed boundary's content directly (no re-fetch, no fallback flash).
  */
 import { Component, createElement, Suspense, use } from "react";
 // Catches the rejection `use()` throws when the deferred rejects → renders `errorFallback`. A class

package/dist/client.d.ts

@@ -1,10 +1,10 @@
-import type { MountRouterOptions, RenderProps } from "@nifrajs/web";
+import { type MountRouterOptions, type RenderProps } from "@nifrajs/web";
 export { errorBoundary } from "./error.js";
 /** Hydrate a server-rendered React layout `chain` (with the loader `props`) inside `container`. */
 export declare function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown): void;
 /**
  * Hydrate a stateful React Router. `useSyncExternalStore` subscribes to the agnostic store and
- * re-renders the matched layout chain on each store change — so client navigations swap routes
+ * re-renders the matched layout chain on each store change - so client navigations swap routes
  * without a full reload. `getServerSnapshot` (3rd arg) returns the initial state, matching the
  * SSR markup on hydration.
  */

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAcnE,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,mGAAmG;AACnG,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI,CAE/F;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAmB7D"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAiB,MAAM,cAAc,CAAA;AAcvF,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,mGAAmG;AACnG,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI,CAE/F;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAyB7D"}

package/dist/client.js

@@ -1,5 +1,6 @@
+import { searchOfChain } from "@nifrajs/web";
 /**
- * @nifrajs/web-react/client — React client runtime. `hydrate` hydrates a single SSR'd route;
+ * @nifrajs/web-react/client - React client runtime. `hydrate` hydrates a single SSR'd route;
  * `mountRouter` hydrates a stateful Router that subscribes to the agnostic store (via
  * `useSyncExternalStore`) and re-renders the matched chain on every client navigation (no full
  * reload). Kept in its own entry so server code stays out of the client bundle.
@@ -8,7 +9,7 @@ import { createElement, useSyncExternalStore } from "react";
 import { hydrateRoot } from "react-dom/client";
 import { compose } from "./compose.js";
 import { setMountedRouter } from "./fetcher.js";
-// The `_error` boundary chain element — defined in its own (react-dom-free) module, re-exported here so
+// The `_error` boundary chain element - defined in its own (react-dom-free) module, re-exported here so
 // nifra's client codegen resolves it from `@nifrajs/web-react/client` alongside `mountRouter`.
 export { errorBoundary } from "./error.js";
 /** Hydrate a server-rendered React layout `chain` (with the loader `props`) inside `container`. */
@@ -17,25 +18,31 @@ export function hydrate(chain, props, container) {
 }
 /**
  * Hydrate a stateful React Router. `useSyncExternalStore` subscribes to the agnostic store and
- * re-renders the matched layout chain on each store change — so client navigations swap routes
+ * re-renders the matched layout chain on each store change - so client navigations swap routes
  * without a full reload. `getServerSnapshot` (3rd arg) returns the initial state, matching the
  * SSR markup on hydration.
  */
 export function mountRouter(options) {
-    const { router, routes, container } = options;
+    const { router, routes, searchSchemas, container } = options;
     setMountedRouter(router); // expose it to useFetcher/useFetchers (same page, client-only)
     const Router = () => {
         const state = useSyncExternalStore(router.subscribe, router.snapshot, router.snapshot);
+        // Derive this route's typed `search` from the URL query + the route's schema CHAIN (layout schemas +
+        // page, merged page-wins), the SAME `searchOfChain` the server ran, so `useSearch` reads an identical
+        // value and hydrates with no drift.
+        const q = state.path.indexOf("?");
+        const rawSearch = q === -1 ? "" : state.path.slice(q);
         return compose(routes[state.routeId] ?? [], {
             data: state.data,
             actionData: state.actionData,
             pending: state.pending,
             ...(state.pendingPath !== undefined ? { pendingPath: state.pendingPath } : {}),
-            // `params`/`path` feed the routing hooks (useParams/useLocation) via compose's RouterContext —
+            // `params`/`path` feed the routing hooks (useParams/useLocation) via compose's RouterContext -
             // sourced from router state here, matching the SSR render's request-derived values on hydration.
             params: state.params,
             path: state.path,
-            // The in-flight submission (for optimistic UI) — spread only when present.
+            search: searchOfChain(searchSchemas?.[state.routeId] ?? [], rawSearch),
+            // The in-flight submission (for optimistic UI) - spread only when present.
             ...(state.submission ? { submission: state.submission } : {}),
         });
     };

package/dist/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AACH,OAAO,EAAE,aAAa,EAA0B,oBAAoB,EAAE,MAAM,OAAO,CAAA;AACnF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE/C,wGAAwG;AACxG,+FAA+F;AAC/F,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,mGAAmG;AACnG,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB,EAAE,SAAkB;IACvF,WAAW,CAAC,SAAoB,EAAE,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;AAC1D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,OAA2B;IACrD,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAA;IAC7C,gBAAgB,CAAC,MAAM,CAAC,CAAA,CAAC,+DAA+D;IACxF,MAAM,MAAM,GAAsB,GAAG,EAAE;QACrC,MAAM,KAAK,GAAG,oBAAoB,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAA;QACtF,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE;YAC1C,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,GAAG,CAAC,KAAK,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9E,+FAA+F;YAC/F,iGAAiG;YACjG,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,2EAA2E;YAC3E,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC9D,CAAC,CAAA;IACJ,CAAC,CAAA;IACD,WAAW,CAAC,SAAoB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAA;AAC1D,CAAC"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6C,aAAa,EAAE,MAAM,cAAc,CAAA;AACvF;;;;;GAKG;AACH,OAAO,EAAE,aAAa,EAA0B,oBAAoB,EAAE,MAAM,OAAO,CAAA;AACnF,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE/C,wGAAwG;AACxG,+FAA+F;AAC/F,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,mGAAmG;AACnG,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB,EAAE,SAAkB;IACvF,WAAW,CAAC,SAAoB,EAAE,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;AAC1D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,OAA2B;IACrD,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,GAAG,OAAO,CAAA;IAC5D,gBAAgB,CAAC,MAAM,CAAC,CAAA,CAAC,+DAA+D;IACxF,MAAM,MAAM,GAAsB,GAAG,EAAE;QACrC,MAAM,KAAK,GAAG,oBAAoB,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAA;QACtF,qGAAqG;QACrG,sGAAsG;QACtG,oCAAoC;QACpC,MAAM,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QACjC,MAAM,SAAS,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QACrD,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE;YAC1C,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,GAAG,CAAC,KAAK,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9E,+FAA+F;YAC/F,iGAAiG;YACjG,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,MAAM,EAAE,aAAa,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,SAAS,CAAC;YACtE,2EAA2E;YAC3E,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC9D,CAAC,CAAA;IACJ,CAAC,CAAA;IACD,WAAW,CAAC,SAAoB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAA;AAC1D,CAAC"}

package/dist/compose.d.ts

@@ -6,9 +6,10 @@ import { type ReactNode } from "react";
  * `children`. Shared by the server adapter (renderToString) and the client (hydrateRoot).
  *
  * The whole tree is wrapped in a {@link RouterContext} provider carrying the matched `params`, the
- * current `path`, and the client `pending` flag (all threaded through `RenderProps` identically on SSR
- * and client), so the routing hooks (`useParams`/`useLocation`/`useNavigation`) read the same value on
- * both sides - no hydration mismatch (`pending` is `false` on SSR and on the initial client render).
+ * current `path`, the validated `search`, and the client `pending` flag (all threaded through
+ * `RenderProps` identically on SSR and client), so the routing hooks
+ * (`useParams`/`useLocation`/`useSearch`/`useNavigation`) read the same value on both sides - no
+ * hydration mismatch (`pending` is `false` on SSR and on the initial client render).
  * A render with no routing fields (a non-router adapter usage) provides the empty default.
  */
 export declare function compose(chain: readonly unknown[], props: RenderProps): ReactNode;

package/dist/compose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAyC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAM7E;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,SAAS,CAmBhF"}
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAyC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAS7E;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,SAAS,CA2BhF"}

package/dist/compose.js

@@ -2,28 +2,35 @@ import { createElement } from "react";
 import { RouterContext } from "./router.js";
 // Stable empty params so the provider value's `params` has a fixed reference when a route has none.
 const EMPTY_PARAMS = Object.freeze({});
+// Stable empty search for the same reason: a render with no search context (or a non-router usage).
+const EMPTY_SEARCH = Object.freeze({});
 /**
  * Fold a layout chain (outermost layout → page) into a single React tree: the page
  * (innermost) receives `props` (the loader data); each layout wraps the child via its
  * `children`. Shared by the server adapter (renderToString) and the client (hydrateRoot).
  *
  * The whole tree is wrapped in a {@link RouterContext} provider carrying the matched `params`, the
- * current `path`, and the client `pending` flag (all threaded through `RenderProps` identically on SSR
- * and client), so the routing hooks (`useParams`/`useLocation`/`useNavigation`) read the same value on
- * both sides - no hydration mismatch (`pending` is `false` on SSR and on the initial client render).
+ * current `path`, the validated `search`, and the client `pending` flag (all threaded through
+ * `RenderProps` identically on SSR and client), so the routing hooks
+ * (`useParams`/`useLocation`/`useSearch`/`useNavigation`) read the same value on both sides - no
+ * hydration mismatch (`pending` is `false` on SSR and on the initial client render).
  * A render with no routing fields (a non-router adapter usage) provides the empty default.
  */
 export function compose(chain, props) {
     const last = chain.length - 1;
     let node = createElement(chain[last], props);
     for (let i = last - 1; i >= 0; i--) {
-        // children passed as the 3rd arg (not a `children` prop) — React's canonical form.
-        node = createElement(chain[i], null, node);
+        // children passed as the 3rd arg (not a `children` prop) - React's canonical form.
+        // Each layout receives its own loader data at its own index. Layouts are the chain's leading
+        // prefix, so `layoutData[i]` belongs to `chain[i]`; anything past that end (a client-only `_error`
+        // boundary marker, the page) reads `undefined` and is unaffected.
+        node = createElement(chain[i], { data: props.layoutData?.[i] ?? null }, node);
     }
     return createElement(RouterContext.Provider, {
         value: {
             params: props.params ?? EMPTY_PARAMS,
             path: props.path ?? "",
+            search: props.search ?? EMPTY_SEARCH,
             pending: props.pending ?? false,
             pendingPath: props.pendingPath,
         },

package/dist/compose.js.map

@@ -1 +1 @@
-{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAA0C,MAAM,OAAO,CAAA;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,oGAAoG;AACpG,MAAM,YAAY,GAAqC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AAExE;;;;;;;;;;GAUG;AACH,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB;IACnE,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAA;IAC7B,IAAI,IAAI,GAAc,aAAa,CAAC,KAAK,CAAC,IAAI,CAAmC,EAAE,KAAK,CAAC,CAAA;IACzF,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,mFAAmF;QACnF,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,CAAsB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;IACjE,CAAC;IACD,OAAO,aAAa,CAClB,aAAa,CAAC,QAAQ,EACtB;QACE,KAAK,EAAE;YACL,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,YAAY;YACpC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE;YACtB,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,KAAK;YAC/B,WAAW,EAAE,KAAK,CAAC,WAAW;SAC/B;KACF,EACD,IAAI,CACL,CAAA;AACH,CAAC"}
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAA0C,MAAM,OAAO,CAAA;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,oGAAoG;AACpG,MAAM,YAAY,GAAqC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AAExE,oGAAoG;AACpG,MAAM,YAAY,GAAsC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AAEzE;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB;IACnE,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAA;IAC7B,IAAI,IAAI,GAAc,aAAa,CAAC,KAAK,CAAC,IAAI,CAAmC,EAAE,KAAK,CAAC,CAAA;IACzF,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,mFAAmF;QACnF,6FAA6F;QAC7F,mGAAmG;QACnG,kEAAkE;QAClE,IAAI,GAAG,aAAa,CAClB,KAAK,CAAC,CAAC,CAAyC,EAChD,EAAE,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,EACvC,IAAI,CACL,CAAA;IACH,CAAC;IACD,OAAO,aAAa,CAClB,aAAa,CAAC,QAAQ,EACtB;QACE,KAAK,EAAE;YACL,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,YAAY;YACpC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE;YACtB,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,YAAY;YACpC,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,KAAK;YAC/B,WAAW,EAAE,KAAK,CAAC,WAAW;SAC/B;KACF,EACD,IAAI,CACL,CAAA;AACH,CAAC"}

package/dist/content.d.ts

@@ -1,10 +1,10 @@
 /**
- * `@nifrajs/web-react/content` — render pre-rendered HTML (e.g. a `@nifrajs/content` collection entry's
+ * `@nifrajs/web-react/content` - render pre-rendered HTML (e.g. a `@nifrajs/content` collection entry's
  * `.html`, or any Markdown→HTML string) into the DOM via `dangerouslySetInnerHTML`. Pairs with content
  * collections: `<Content html={entry.html} />`.
  *
  * Security: this injects raw HTML, so the `html` MUST be trusted (your own Markdown/content, rendered
- * at build/server time) — never pass user-supplied HTML without sanitizing it first.
+ * at build/server time) - never pass user-supplied HTML without sanitizing it first.
  */
 import { type ComponentPropsWithoutRef, type ElementType, type ReactElement } from "react";
 export interface ContentProps extends Omit<ComponentPropsWithoutRef<"div">, "dangerouslySetInnerHTML" | "children"> {

package/dist/content.js

@@ -1,10 +1,10 @@
 /**
- * `@nifrajs/web-react/content` — render pre-rendered HTML (e.g. a `@nifrajs/content` collection entry's
+ * `@nifrajs/web-react/content` - render pre-rendered HTML (e.g. a `@nifrajs/content` collection entry's
  * `.html`, or any Markdown→HTML string) into the DOM via `dangerouslySetInnerHTML`. Pairs with content
  * collections: `<Content html={entry.html} />`.
  *
  * Security: this injects raw HTML, so the `html` MUST be trusted (your own Markdown/content, rendered
- * at build/server time) — never pass user-supplied HTML without sanitizing it first.
+ * at build/server time) - never pass user-supplied HTML without sanitizing it first.
  */
 import { createElement, } from "react";
 /** Render trusted HTML into a wrapper element. Extra props (`className`, `id`, `style`, …) pass through. */

package/dist/error.d.ts

@@ -2,7 +2,7 @@
  * Build an error-boundary chain element bound to `fallback` (a route's `_error` component). nifra's
  * client codegen inserts it before the page in the matched chain; a render error in the subtree renders
  * `fallback` with `{ data: { name, message } }` instead of crashing the app. DOM-transparent (it renders
- * its children directly — no wrapper element), so it adds no markup and never disturbs hydration.
+ * its children directly - no wrapper element), so it adds no markup and never disturbs hydration.
  */
 export declare function errorBoundary(fallback: unknown): unknown;
 //# sourceMappingURL=error.d.ts.map

package/dist/error.js

@@ -1,5 +1,5 @@
 /**
- * `errorBoundary` — the React error-boundary chain element for nifra's `_error.tsx`. Kept in its own
+ * `errorBoundary` - the React error-boundary chain element for nifra's `_error.tsx`. Kept in its own
  * module (imports only `react`, never `react-dom/client`) so it's unit-testable off the DOM and the
  * client codegen can import it from `@nifrajs/web-react/client` (which re-exports it).
  */
@@ -8,7 +8,7 @@ import { Component, createElement } from "react";
  * Build an error-boundary chain element bound to `fallback` (a route's `_error` component). nifra's
  * client codegen inserts it before the page in the matched chain; a render error in the subtree renders
  * `fallback` with `{ data: { name, message } }` instead of crashing the app. DOM-transparent (it renders
- * its children directly — no wrapper element), so it adds no markup and never disturbs hydration.
+ * its children directly - no wrapper element), so it adds no markup and never disturbs hydration.
  */
 export function errorBoundary(fallback) {
     return class NifraErrorBoundary extends Component {
@@ -23,7 +23,7 @@ export function errorBoundary(fallback) {
             const { error } = this.state;
             if (error === null)
                 return this.props.children;
-            // `fallback` is the route's `_error` default export — opaque to the core, a component here.
+            // `fallback` is the route's `_error` default export - opaque to the core, a component here.
             const Fallback = fallback;
             return createElement(Fallback, { data: { name: error.name, message: error.message } });
         }

package/dist/fetcher.d.ts

@@ -1,5 +1,5 @@
 import type { ClientRouter, Fetcher, FetcherState } from "@nifrajs/web";
-/** Register (or clear) the router that owns fetchers — called by `mountRouter`. Not for app use. */
+/** Register (or clear) the router that owns fetchers - called by `mountRouter`. Not for app use. */
 export declare function setMountedRouter(router: ClientRouter | undefined): void;
 /** A fetcher's reactive {@link FetcherState} plus its imperative `load`/`submit`. */
 export interface FetcherHandle extends FetcherState {
@@ -15,7 +15,7 @@ export interface FetcherHandle extends FetcherState {
  */
 export declare function useFetcher(key: string): FetcherHandle;
 /**
- * Subscribe to the whole live fetcher collection — for a global busy view (e.g. "3 saving…"). Read
+ * Subscribe to the whole live fetcher collection - for a global busy view (e.g. "3 saving…"). Read
  * each entry's `.snapshot()` for its state. Re-renders whenever any fetcher transitions or a new one
  * is created.
  */

package/dist/fetcher.js

@@ -1,11 +1,11 @@
 /**
- * `@nifrajs/web-react/fetcher` — React bindings for concurrent fetchers. `useFetcher(key)` subscribes a
+ * `@nifrajs/web-react/fetcher` - React bindings for concurrent fetchers. `useFetcher(key)` subscribes a
  * component to an independent {@link Fetcher} (via `useSyncExternalStore`) and returns its reactive
  * state plus `load`/`submit`; `useFetchers()` subscribes to the whole live collection. Imports only
  * `react` (never `react-dom/*`), so route components can use it on the server *and* client without
  * dragging either DOM build into the wrong bundle. No JSX (the package builds with plain `tsc`).
  *
- * The router that owns the fetchers is the one `mountRouter` hydrated — it registers itself here via
+ * The router that owns the fetchers is the one `mountRouter` hydrated - it registers itself here via
  * `setMountedRouter`. On the server (no mount) there is no router, so the hooks return an idle state
  * (fetchers are client-only); the first client render after `mountRouter` sees the real fetcher, so
  * there's no hydration mismatch.
@@ -14,7 +14,7 @@ import { useSyncExternalStore } from "react";
 // The active client router (set by `mountRouter`). Module-scoped: the browser mounts one app per
 // page, and fetchers never exist on the server. Shared with `client.ts`'s `mountRouter`.
 let mountedRouter;
-/** Register (or clear) the router that owns fetchers — called by `mountRouter`. Not for app use. */
+/** Register (or clear) the router that owns fetchers - called by `mountRouter`. Not for app use. */
 export function setMountedRouter(router) {
     mountedRouter = router;
 }
@@ -35,7 +35,7 @@ export function useFetcher(key) {
     return { ...state, load: fetcher?.load ?? noopAsync, submit: fetcher?.submit ?? noopAsync };
 }
 /**
- * Subscribe to the whole live fetcher collection — for a global busy view (e.g. "3 saving…"). Read
+ * Subscribe to the whole live fetcher collection - for a global busy view (e.g. "3 saving…"). Read
  * each entry's `.snapshot()` for its state. Re-renders whenever any fetcher transitions or a new one
  * is created.
  */

package/dist/fn.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `@nifrajs/web-react/fn` - React binding for a server function's pending/error state.
+ *
+ * Calling a server function needs no hook: the client stub is `(input) => Promise<Output>`. This adds
+ * the part a component usually wants around it - in flight, last result, last error - and nothing more.
+ *
+ * The state machine is `@nifrajs/web`'s `createServerFnStore`, shared with every other adapter, so
+ * "is it pending" has one answer rather than five that drift. This file contributes only the `useSyncExternalStore` subscription.
+ */
+import type { ServerFnReference } from "@nifrajs/web/fn";
+import { type ServerFnState } from "@nifrajs/web/fn-state";
+/** A server function's state plus the call itself. */
+export interface ServerFnHandle<Input, Output> extends ServerFnState<Output> {
+    /** Invoke it. Records state, and rejects on failure - attach `.catch` if you only render state. */
+    readonly call: (input: Input) => Promise<Output>;
+    /** Back to idle. */
+    readonly reset: () => void;
+}
+/**
+ * Track one server function's call state.
+ *
+ *     const addTodo = useServerFn(fns.addTodo)
+ *     <button disabled={addTodo.pending} onClick={() => addTodo.call({ text }).catch(() => {})}>
+ *
+ * The store is per component instance and created once; `fn` is read on the first render only, so a
+ * freshly-created inline function neither resets the state nor goes stale.
+ */
+export declare function useServerFn<Input, Output>(fn: ServerFnReference<Input, Output>): ServerFnHandle<Input, Output>;
+//# sourceMappingURL=fn.d.ts.map

package/dist/fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.d.ts","sourceRoot":"","sources":["../src/fn.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxE,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAG/E,sDAAsD;AACtD,MAAM,WAAW,cAAc,CAAC,KAAK,EAAE,MAAM,CAAE,SAAQ,aAAa,CAAC,MAAM,CAAC;IAC1E,mGAAmG;IACnG,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAChD,oBAAoB;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EACvC,EAAE,EAAE,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,GACnC,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAS/B"}

package/dist/fn.js

@@ -0,0 +1,31 @@
+/**
+ * `@nifrajs/web-react/fn` - React binding for a server function's pending/error state.
+ *
+ * Calling a server function needs no hook: the client stub is `(input) => Promise<Output>`. This adds
+ * the part a component usually wants around it - in flight, last result, last error - and nothing more.
+ *
+ * The state machine is `@nifrajs/web`'s `createServerFnStore`, shared with every other adapter, so
+ * "is it pending" has one answer rather than five that drift. This file contributes only the `useSyncExternalStore` subscription.
+ */
+import { createServerFnStore } from "@nifrajs/web/fn-state";
+import { useMemo, useRef, useSyncExternalStore } from "react";
+/**
+ * Track one server function's call state.
+ *
+ *     const addTodo = useServerFn(fns.addTodo)
+ *     <button disabled={addTodo.pending} onClick={() => addTodo.call({ text }).catch(() => {})}>
+ *
+ * The store is per component instance and created once; `fn` is read on the first render only, so a
+ * freshly-created inline function neither resets the state nor goes stale.
+ */
+export function useServerFn(fn) {
+    // The store is created once, but always calls the CURRENT `fn`. Capturing `fn` directly would
+    // either recreate the store on every render (losing the state) or hold the first render's closure
+    // (calling a stale one); the ref is what makes "created once" and "never stale" both true.
+    const latest = useRef(fn);
+    latest.current = fn;
+    const store = useMemo(() => createServerFnStore((input) => latest.current(input)), []);
+    const state = useSyncExternalStore(store.subscribe, store.snapshot, store.snapshot);
+    return { ...state, call: store.call, reset: store.reset };
+}
+//# sourceMappingURL=fn.js.map

package/dist/fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.js","sourceRoot":"","sources":["../src/fn.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,mBAAmB,EAAsB,MAAM,uBAAuB,CAAA;AAC/E,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,OAAO,CAAA;AAU7D;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CACzB,EAAoC;IAEpC,8FAA8F;IAC9F,kGAAkG;IAClG,2FAA2F;IAC3F,MAAM,MAAM,GAAG,MAAM,CAAC,EAAmC,CAAC,CAAA;IAC1D,MAAM,CAAC,OAAO,GAAG,EAAmC,CAAA;IACpD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,mBAAmB,CAAC,CAAC,KAAY,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IAC7F,MAAM,KAAK,GAAG,oBAAoB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;IACnF,OAAO,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAA;AAC3D,CAAC"}

package/dist/i18n.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-react/i18n` — React bindings for `@nifrajs/i18n`. `<I18nProvider locale messages>` builds a
+ * `@nifrajs/web-react/i18n` - React bindings for `@nifrajs/i18n`. `<I18nProvider locale messages>` builds a
  * `Formatter` (memoized) and provides it; `useT()` reads it. Both `locale` + `messages` are
  * serializable, so a loader returns them, the page renders with the negotiated catalog on the server,
  * and the client rebuilds the same formatter from the same props (no mismatch). Imports only `react` +

package/dist/i18n.js

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-react/i18n` — React bindings for `@nifrajs/i18n`. `<I18nProvider locale messages>` builds a
+ * `@nifrajs/web-react/i18n` - React bindings for `@nifrajs/i18n`. `<I18nProvider locale messages>` builds a
  * `Formatter` (memoized) and provides it; `useT()` reads it. Both `locale` + `messages` are
  * serializable, so a loader returns them, the page renders with the negotiated catalog on the server,
  * and the client rebuilds the same formatter from the same props (no mismatch). Imports only `react` +

package/dist/image.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-react/image` — a CLS-safe responsive React `<Image>`. A thin wrapper over
+ * `@nifrajs/web-react/image` - a CLS-safe responsive React `<Image>`. A thin wrapper over
  * `resolveImage` from `@nifrajs/image`: it computes `src`/`srcSet`/`sizes`/`width`/`height`/`loading`/
  * `decoding`/`fetchpriority` and renders a plain `<img>`, forwarding any extra DOM props
  * (`className`, `style`, `id`, event handlers, `data-*`, …). Resizing is delegated to the `loader`
@@ -7,10 +7,10 @@
  */
 import { type ImageLoader, type ImageProps } from "@nifrajs/image";
 import { type ComponentPropsWithoutRef, type ReactElement } from "react";
-/** Attributes `resolveImage` computes — callers can't override them via DOM passthrough. */
+/** Attributes `resolveImage` computes - callers can't override them via DOM passthrough. */
 type ComputedAttrs = "src" | "srcSet" | "sizes" | "width" | "height" | "alt" | "loading" | "decoding" | "fetchPriority";
 export interface ImageComponentProps extends ImageProps, Omit<ComponentPropsWithoutRef<"img">, ComputedAttrs | keyof ImageProps> {
-    /** CDN URL builder. Defaults to the identity loader (no transform — still CLS-safe + lazy). */
+    /** CDN URL builder. Defaults to the identity loader (no transform - still CLS-safe + lazy). */
     readonly loader?: ImageLoader;
     /** `data-*` attributes pass through to the `<img>` (React doesn't auto-allow these on a custom
      * component, so they're declared explicitly). */

package/dist/image.js

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-react/image` — a CLS-safe responsive React `<Image>`. A thin wrapper over
+ * `@nifrajs/web-react/image` - a CLS-safe responsive React `<Image>`. A thin wrapper over
  * `resolveImage` from `@nifrajs/image`: it computes `src`/`srcSet`/`sizes`/`width`/`height`/`loading`/
  * `decoding`/`fetchpriority` and renders a plain `<img>`, forwarding any extra DOM props
  * (`className`, `style`, `id`, event handlers, `data-*`, …). Resizing is delegated to the `loader`

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 import type { RenderAdapter } from "@nifrajs/web";
-/** The React server render adapter — pass to @nifrajs/web's `renderPage`. */
+/** The React server render adapter - pass to @nifrajs/web's `renderPage`. */
 export declare const reactAdapter: RenderAdapter;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,19 +1,19 @@
 /**
- * @nifrajs/web-react — the React render adapter for @nifrajs/web (server side). Streaming SSR via
+ * @nifrajs/web-react - the React render adapter for @nifrajs/web (server side). Streaming SSR via
  * `renderToReadableStream`; the layout-chain fold is in `./compose`. Client hydration lives in
- * `@nifrajs/web-react/client`. React's JSX is Bun-native — no build plugin needed.
+ * `@nifrajs/web-react/client`. React's JSX is Bun-native - no build plugin needed.
  */
 import { compose } from "./compose.js";
 import { reactDomServer } from "./react-dom-server.js";
-/** The React server render adapter — pass to @nifrajs/web's `renderPage`. */
+/** The React server render adapter - pass to @nifrajs/web's `renderPage`. */
 export const reactAdapter = {
     // Synchronous one-pass render for non-deferred pages (renderPage's buffered fast path). React's
     // `renderToString` emits the same hydration-compatible markup as the Fizz stream for non-Suspense
-    // content and is markedly cheaper than `renderToReadableStream` — most visibly on Bun, where Fizz's
+    // content and is markedly cheaper than `renderToReadableStream` - most visibly on Bun, where Fizz's
     // streaming machinery is the heaviest. A page that defer()s/Suspends takes `renderToStream` below.
     //
     // Async because the `react-dom/server` module is resolved lazily (from the consumer app's node_modules
-    // under Bun runtime SSR — see ./react-dom-server). `RenderAdapter.renderToString` permits a Promise;
+    // under Bun runtime SSR - see ./react-dom-server). `RenderAdapter.renderToString` permits a Promise;
     // renderPage awaits it.
     async renderToString(chain, props) {
         const { renderToString } = await reactDomServer();
@@ -21,13 +21,13 @@ export const reactAdapter = {
     },
     async renderToStream(chain, props) {
         // Resolves a Web `ReadableStream<Uint8Array>` once the shell is renderable; Suspense
-        // boundaries stream as they resolve. No `bootstrapModules` — nifra injects the client entry in
+        // boundaries stream as they resolve. No `bootstrapModules` - nifra injects the client entry in
         // the document tail. React's default `onError` logs to console.error (errors aren't swallowed).
         const { renderToReadableStream } = await reactDomServer();
         return renderToReadableStream(compose(chain, props));
     },
     // React reconciles against the existing DOM on hydrate, so no per-document bootstrap
-    // script is needed (contrast Solid's generateHydrationScript) — the seam allows both.
+    // script is needed (contrast Solid's generateHydrationScript) - the seam allows both.
     hydrationHead() {
         return "";
     },

package/dist/island.d.ts

@@ -1,8 +1,8 @@
 import type { IslandStrategy } from "@nifrajs/web/islands";
 /**
- * `@nifrajs/web-react/island` — the `<Island>` marker for no-framework islands. Server-renders its
+ * `@nifrajs/web-react/island` - the `<Island>` marker for no-framework islands. Server-renders its
  * children inside a `<nifra-island>` element that the framework-agnostic `mountIslands` runtime
- * (`@nifrajs/web/islands`) picks up on the client. Imports only `react` (+ a type) — no `react-dom`,
+ * (`@nifrajs/web/islands`) picks up on the client. Imports only `react` (+ a type) - no `react-dom`,
  * no JSX (the package builds with plain `tsc`).
  *
  * Use on a route with `export const hydrate = false`: the page ships zero framework JS, and only the
@@ -17,7 +17,7 @@ export interface IslandProps {
     readonly props?: unknown;
     /** When the enhancer runs (default `load`). `visible` (IntersectionObserver) wins TTI on long pages. */
     readonly strategy?: IslandStrategy;
-    /** The island's server-rendered content — real HTML, present with JS off. */
+    /** The island's server-rendered content - real HTML, present with JS off. */
     readonly children?: ReactNode;
 }
 /** Render a `<nifra-island>` marker around server-rendered `children`. The client enhancer mounts the

package/dist/island.js

@@ -1,7 +1,7 @@
 /**
- * `@nifrajs/web-react/island` — the `<Island>` marker for no-framework islands. Server-renders its
+ * `@nifrajs/web-react/island` - the `<Island>` marker for no-framework islands. Server-renders its
  * children inside a `<nifra-island>` element that the framework-agnostic `mountIslands` runtime
- * (`@nifrajs/web/islands`) picks up on the client. Imports only `react` (+ a type) — no `react-dom`,
+ * (`@nifrajs/web/islands`) picks up on the client. Imports only `react` (+ a type) - no `react-dom`,
  * no JSX (the package builds with plain `tsc`).
  *
  * Use on a route with `export const hydrate = false`: the page ships zero framework JS, and only the

package/dist/query.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-react/query` — React bindings for the keyed query-cache + mutations: `useQuery`,
+ * `@nifrajs/web-react/query` - React bindings for the keyed query-cache + mutations: `useQuery`,
  * `useInfiniteQuery`, `useMutation`, `useQueryClient`, `QueryClientProvider`, and the SSR
  * `HydrationBoundary` (+ `dehydrate` re-exported). A drop-in for the TanStack Query surface,
  * backed by `@nifrajs/web`'s agnostic engine. Imports only `react` + `@nifrajs/web` (never `react-dom/*`),
@@ -7,13 +7,13 @@
  *
  * Resolution order for the client a hook uses: a `QueryClientProvider` in the tree (required for SSR
  * dehydrate/hydrate and for tests), else a lazily-created **client-side** module singleton (the simple
- * client-only app — the `typeof window` guard means the server has none, so hooks render idle/pending
+ * client-only app - the `typeof window` guard means the server has none, so hooks render idle/pending
  * and the first client render matches for a clean hydration).
  */
 import { type DehydratedState, type InfiniteData, type InfiniteQueryOptions, type MutationCallbacks, type MutationState, type QueryClient, type QueryOptions, type QueryState } from "@nifrajs/web";
 import { type ReactNode } from "react";
 export type { DehydratedState } from "@nifrajs/web";
-/** Provide a {@link QueryClient} to the tree — required for SSR dehydrate/hydrate and for tests; a
+/** Provide a {@link QueryClient} to the tree - required for SSR dehydrate/hydrate and for tests; a
  * client-only app can omit it and rely on the built-in client-side singleton. */
 export declare function QueryClientProvider(props: {
     readonly client: QueryClient;
@@ -24,12 +24,12 @@ export declare function QueryClientProvider(props: {
 export declare function useQueryClient(): QueryClient;
 /** Options for {@link useQuery}. */
 export interface UseQueryOptions extends QueryOptions {
-    /** When `false`, don't fetch (the query stays idle) — for dependent queries. Default `true`. */
+    /** When `false`, don't fetch (the query stays idle) - for dependent queries. Default `true`. */
     readonly enabled?: boolean;
 }
 /** A query's reactive {@link QueryState} plus `isPending` + `refetch`. */
 export interface UseQueryResult<T> extends QueryState<T> {
-    /** `status === "pending"` — no data yet (initial load). */
+    /** `status === "pending"` - no data yet (initial load). */
     readonly isPending: boolean;
     /** `status === "error"`. */
     readonly isError: boolean;
@@ -54,7 +54,7 @@ export interface UseMutationResult<TData, TVariables> extends MutationState<TDat
     readonly isSuccess: boolean;
     /** Fire-and-forget: runs the mutation and swallows rejection (read `error`/`isError` for failures). */
     readonly mutate: (variables: TVariables) => void;
-    /** Run the mutation and return the promise (rejects on failure) — for `await`. */
+    /** Run the mutation and return the promise (rejects on failure) - for `await`. */
     readonly mutateAsync: (variables: TVariables) => Promise<TData>;
     /** Reset back to idle. */
     readonly reset: () => void;
@@ -66,7 +66,7 @@ export interface UseMutationResult<TData, TVariables> extends MutationState<TDat
  * callbacks re-bind each render.
  */
 export declare function useMutation<TData, TVariables = void>(fn: (variables: TVariables) => Promise<TData>, callbacks?: MutationCallbacks<TData, TVariables>): UseMutationResult<TData, TVariables>;
-/** Options for {@link useInfiniteQuery} — the engine's {@link InfiniteQueryOptions} plus `enabled`. */
+/** Options for {@link useInfiniteQuery} - the engine's {@link InfiniteQueryOptions} plus `enabled`. */
 export interface UseInfiniteQueryOptions<T, P> extends InfiniteQueryOptions<T, P> {
     readonly enabled?: boolean;
 }
@@ -88,7 +88,7 @@ export interface UseInfiniteQueryResult<T, P> extends QueryState<InfiniteData<T,
  */
 export declare function useInfiniteQuery<T, P>(key: unknown, fn: (pageParam: P) => Promise<T>, options: UseInfiniteQueryOptions<T, P>): UseInfiniteQueryResult<T, P>;
 /**
- * Seed the context's {@link QueryClient} from a server {@link dehydrate} snapshot — the SSR data bridge.
+ * Seed the context's {@link QueryClient} from a server {@link dehydrate} snapshot - the SSR data bridge.
  * Wrap the app (inside `QueryClientProvider`) so server-prefetched queries are in the cache before the
  * first client render, avoiding a loading flash. Hydration runs during render (idempotent, fresher-wins),
  * so the data is available synchronously to child `useQuery`s.