@nifrajs/web-preact 2.1.0 → 2.3.0

package/README.md

@@ -1,8 +1,8 @@
 # @nifrajs/web-preact
 
-Preact render adapter for @nifrajs/web — streaming SSR + hydration (no build plugin).
+Preact render adapter for @nifrajs/web - streaming SSR + hydration (no build plugin).
 
-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.js

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-preact/await` — the `<Await>` primitive for deferred loader data (`defer()`). Isomorphic
+ * `@nifrajs/web-preact/await` - the `<Await>` primitive for deferred loader data (`defer()`). Isomorphic
  * and imports only `preact`/`preact/compat` + a type from `@nifrajs/web` (never the server renderer), so
  * route components can use it without dragging server code into the client bundle. No JSX (the package
  * builds with plain `tsc`).

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 Preact layout `chain` (with the loader `props`) inside `container`. */
 export declare function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown): void;
 /**
  * Hydrate a stateful Preact Router. `useSyncExternalStore` (preact/compat) subscribes to the
- * agnostic store and re-renders the matched layout chain on each store change — so client
+ * agnostic store and re-renders the matched layout chain on each store change - so client
  * navigations swap routes without a full reload. Preact's compat `useSyncExternalStore` is 2-arg
  * (no `getServerSnapshot`); `router.snapshot` is deterministic, so hydration matches the SSR markup.
  */

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;AAenE,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,oGAAoG;AACpG,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,CAc7D"}
+{"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;AAevF,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,oGAAoG;AACpG,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"}

package/dist/client.js

@@ -1,5 +1,6 @@
+import { searchOfChain } from "@nifrajs/web";
 /**
- * @nifrajs/web-preact/client — Preact client runtime. `hydrate` hydrates a single SSR'd route;
+ * @nifrajs/web-preact/client - Preact client runtime. `hydrate` hydrates a single SSR'd route;
  * `mountRouter` hydrates a stateful Router that subscribes to the agnostic store (via
  * `useSyncExternalStore` from preact/compat) and re-renders the matched chain on every client
  * navigation (no full reload). Kept in its own entry so server code (preact-render-to-string) stays
@@ -9,7 +10,7 @@ import { h, hydrate as preactHydrate } from "preact";
 import { useSyncExternalStore } from "preact/compat";
 import { compose } from "./compose.js";
 import { setMountedRouter } from "./fetcher.js";
-// The `_error` boundary chain element — defined in its own (DOM-free) module, re-exported here so
+// The `_error` boundary chain element - defined in its own (DOM-free) module, re-exported here so
 // nifra's client codegen resolves it from `@nifrajs/web-preact/client` alongside `mountRouter`.
 export { errorBoundary } from "./error.js";
 /** Hydrate a server-rendered Preact layout `chain` (with the loader `props`) inside `container`. */
@@ -18,20 +19,25 @@ export function hydrate(chain, props, container) {
 }
 /**
  * Hydrate a stateful Preact Router. `useSyncExternalStore` (preact/compat) subscribes to the
- * agnostic store and re-renders the matched layout chain on each store change — so client
+ * agnostic store and re-renders the matched layout chain on each store change - so client
  * navigations swap routes without a full reload. Preact's compat `useSyncExternalStore` is 2-arg
  * (no `getServerSnapshot`); `router.snapshot` is deterministic, so hydration matches the SSR markup.
  */
 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);
+        // Derive this route's typed `search` from the URL + the route's schema chain (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,
-            // 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;;;;;;GAMG;AACH,OAAO,EAA0B,CAAC,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,QAAQ,CAAA;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE/C,kGAAkG;AAClG,gGAAgG;AAChG,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,oGAAoG;AACpG,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB,EAAE,SAAkB;IACvF,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,SAAoB,CAAC,CAAA;AAC5D,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,CAAC,CAAA;QACrE,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,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,aAAa,CAAC,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,SAAoB,CAAC,CAAA;AACtD,CAAC"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6C,aAAa,EAAE,MAAM,cAAc,CAAA;AACvF;;;;;;GAMG;AACH,OAAO,EAA0B,CAAC,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,QAAQ,CAAA;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE/C,kGAAkG;AAClG,gGAAgG;AAChG,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,oGAAoG;AACpG,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB,EAAE,SAAkB;IACvF,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,SAAoB,CAAC,CAAA;AAC5D,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,CAAC,CAAA;QACrE,uGAAuG;QACvG,uFAAuF;QACvF,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,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,aAAa,CAAC,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,SAAoB,CAAC,CAAA;AACtD,CAAC"}

package/dist/compose.d.ts

@@ -3,8 +3,10 @@ import { type VNode } from "preact";
 /**
  * Fold a layout chain (outermost layout → page) into a single Preact tree: the page (innermost)
  * receives `props` (the loader data); each layout wraps the child via its `children` (Preact passes
- * the 3rd `h` arg as `props.children`). Shared by the server adapter (renderToReadableStream) and
- * the client (hydrate / mountRouter) — the Preact analogue of the React adapter's `compose`.
+ * the 3rd `h` arg as `props.children`). The whole tree is wrapped in a {@link SearchContext} provider
+ * carrying the validated `search` (threaded through `RenderProps` identically on SSR + client), so
+ * `useSearch` reads the same value on both sides - no hydration mismatch. Shared by the server adapter
+ * (renderToReadableStream) and the client (hydrate / mountRouter) - the Preact analogue of React's `compose`.
  */
 export declare function compose(chain: readonly unknown[], props: RenderProps): VNode;
 //# sourceMappingURL=compose.d.ts.map

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,EAAyB,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAA;AAE1D;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,KAAK,CAa5E"}
+{"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,EAAgE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAA;AAejG;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,KAAK,CAoB5E"}

package/dist/compose.js

@@ -1,9 +1,18 @@
-import { h } from "preact";
+import { createElement, h } from "preact";
+import { SearchContext } from "./router.js";
+// Frozen empty search so a render with no search context has a stable provider value.
+const EMPTY_SEARCH = Object.freeze({});
+// Preact's `createElement` overloads drop a typed `Context.Provider`'s required `value` under
+// exactOptionalPropertyTypes (same issue i18n's provider hits); invoke it through a precisely-typed
+// factory that states the real `{ value }` + children contract rather than scatter `any`.
+const createSearchProvider = createElement;
 /**
  * Fold a layout chain (outermost layout → page) into a single Preact tree: the page (innermost)
  * receives `props` (the loader data); each layout wraps the child via its `children` (Preact passes
- * the 3rd `h` arg as `props.children`). Shared by the server adapter (renderToReadableStream) and
- * the client (hydrate / mountRouter) — the Preact analogue of the React adapter's `compose`.
+ * the 3rd `h` arg as `props.children`). The whole tree is wrapped in a {@link SearchContext} provider
+ * carrying the validated `search` (threaded through `RenderProps` identically on SSR + client), so
+ * `useSearch` reads the same value on both sides - no hydration mismatch. Shared by the server adapter
+ * (renderToReadableStream) and the client (hydrate / mountRouter) - the Preact analogue of React's `compose`.
  */
 export function compose(chain, props) {
     const last = chain.length - 1;
@@ -11,12 +20,15 @@ export function compose(chain, props) {
     // loader props (typed via ComponentType<RenderProps>), then we widen `h`'s VNode<Attributes &
     // RenderProps> to the uniform VNode the fold accumulates into. Preact's VNode<P> is invariant in P
     // under exactOptionalPropertyTypes, so the widen needs the explicit `as VNode` (a comparability
-    // cast — Attributes & RenderProps is assignable to {}, so this is not an unsafe coercion).
+    // cast - Attributes & RenderProps is assignable to {}, so this is not an unsafe coercion).
     let node = h(chain[last], props);
     for (let i = last - 1; i >= 0; i--) {
-        // children passed as the 3rd arg — Preact's canonical form (mirrors the React adapter).
-        node = h(chain[i], null, node);
+        // children passed as the 3rd arg - Preact's canonical form (mirrors the React adapter).
+        // 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 = h(chain[i], { data: props.layoutData?.[i] ?? null }, node);
     }
-    return node;
+    return createSearchProvider(SearchContext.Provider, { value: props.search ?? EMPTY_SEARCH }, node);
 }
 //# sourceMappingURL=compose.js.map

package/dist/compose.js.map

@@ -1 +1 @@
-{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,CAAC,EAAc,MAAM,QAAQ,CAAA;AAE1D;;;;;GAKG;AACH,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB;IACnE,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAA;IAC7B,iGAAiG;IACjG,8FAA8F;IAC9F,mGAAmG;IACnG,gGAAgG;IAChG,2FAA2F;IAC3F,IAAI,IAAI,GAAU,CAAC,CAAC,KAAK,CAAC,IAAI,CAA+B,EAAE,KAAK,CAAU,CAAA;IAC9E,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,wFAAwF;QACxF,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAkB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;IACjD,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,EAA8C,aAAa,EAAE,CAAC,EAAc,MAAM,QAAQ,CAAA;AACjG,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,sFAAsF;AACtF,MAAM,YAAY,GAAsC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AAEzE,8FAA8F;AAC9F,oGAAoG;AACpG,0FAA0F;AAC1F,MAAM,oBAAoB,GAAG,aAInB,CAAA;AAEV;;;;;;;GAOG;AACH,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB;IACnE,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAA;IAC7B,iGAAiG;IACjG,8FAA8F;IAC9F,mGAAmG;IACnG,gGAAgG;IAChG,2FAA2F;IAC3F,IAAI,IAAI,GAAU,CAAC,CAAC,KAAK,CAAC,IAAI,CAA+B,EAAE,KAAK,CAAU,CAAA;IAC9E,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,wFAAwF;QACxF,6FAA6F;QAC7F,mGAAmG;QACnG,kEAAkE;QAClE,IAAI,GAAG,CAAC,CACN,KAAK,CAAC,CAAC,CAAqC,EAC5C,EAAE,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,EACvC,IAAI,CACI,CAAA;IACZ,CAAC;IACD,OAAO,oBAAoB,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,IAAI,YAAY,EAAE,EAAE,IAAI,CAAC,CAAA;AACpG,CAAC"}

package/dist/content.d.ts

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

package/dist/content.js

@@ -1,10 +1,10 @@
 /**
- * `@nifrajs/web-preact/content` — render pre-rendered HTML (e.g. a `@nifrajs/content` collection entry's
+ * `@nifrajs/web-preact/content` - render pre-rendered HTML (e.g. a `@nifrajs/content` collection entry's
  * `.html`) into the DOM via `dangerouslySetInnerHTML`. Pairs with content collections:
  * `<Content html={entry.html} />`.
  *
  * Security: injects raw HTML, so `html` MUST be trusted (your own Markdown/content, rendered at
- * build/server time) — never pass user-supplied HTML without sanitizing it first.
+ * build/server time) - never pass user-supplied HTML without sanitizing it first.
  */
 import { createElement } from "preact";
 /** Render trusted HTML into a wrapper element. Extra props (`class`, `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 Preact error-boundary chain element for nifra's `_error.tsx`. Its own module
+ * `errorBoundary` - the Preact error-boundary chain element for nifra's `_error.tsx`. Its own module
  * (imports only `preact`) so it's unit-testable off the DOM and the client codegen can import it from
  * `@nifrajs/web-preact/client` (which re-exports it).
  */
@@ -8,7 +8,7 @@ import { Component, createElement } from "preact";
  * 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,21 +1,21 @@
 /**
- * `@nifrajs/web-preact/fetcher` — Preact bindings for concurrent fetchers. `useFetcher(key)` subscribes a
+ * `@nifrajs/web-preact/fetcher` - Preact bindings for concurrent fetchers. `useFetcher(key)` subscribes a
  * component to an independent {@link Fetcher} (via `useSyncExternalStore` from preact/compat) and
  * returns its reactive state plus `load`/`submit`; `useFetchers()` subscribes to the whole live
  * collection. Imports only `preact/compat` + `@nifrajs/web` types, so route components can use it on the
  * server *and* client. 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). Preact's compat `useSyncExternalStore` is 2-arg (no `getServerSnapshot`);
  * with no router the `getSnapshot` already returns idle, so the first client render after `mountRouter`
- * matches the SSR markup — no hydration mismatch.
+ * matches the SSR markup - no hydration mismatch.
  */
 import { useSyncExternalStore } from "preact/compat";
 // 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;
 }
@@ -38,7 +38,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,26 @@
+/**
+ * `@nifrajs/web-preact/fn` - Preact 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.
+ *
+ * Preact's compat `useSyncExternalStore` takes two arguments (no server snapshot); the store's idle
+ * state is shared by reference anyway, so a server render and the first client render agree.
+ */
+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;;;;;GAKG;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,28 @@
+/**
+ * `@nifrajs/web-preact/fn` - Preact 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 "preact/compat";
+/**
+ * Track one server function's call state.
+ *
+ * Preact's compat `useSyncExternalStore` takes two arguments (no server snapshot); the store's idle
+ * state is shared by reference anyway, so a server render and the first client render agree.
+ */
+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);
+    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,eAAe,CAAA;AAUrE;;;;;GAKG;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,CAAC,CAAA;IACnE,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,9 +1,9 @@
 /**
- * `@nifrajs/web-preact/i18n` — Preact bindings for `@nifrajs/i18n`. `<I18nProvider locale messages>` builds a
+ * `@nifrajs/web-preact/i18n` - Preact 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). Uses `preact` +
- * `preact/hooks` — no JSX.
+ * `preact/hooks` - no JSX.
  */
 import { type Formatter, type Messages } from "@nifrajs/i18n";
 import { type ComponentChildren, type VNode } from "preact";

package/dist/i18n.js

@@ -1,16 +1,16 @@
 /**
- * `@nifrajs/web-preact/i18n` — Preact bindings for `@nifrajs/i18n`. `<I18nProvider locale messages>` builds a
+ * `@nifrajs/web-preact/i18n` - Preact 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). Uses `preact` +
- * `preact/hooks` — no JSX.
+ * `preact/hooks` - no JSX.
  */
 import { createFormatter } from "@nifrajs/i18n";
 import { createContext, createElement } from "preact";
 import { useContext, useMemo } from "preact/hooks";
 const I18nContext = createContext(null);
 // Preact's `createElement` overloads don't reconcile a typed `Context.Provider` (required `value`)
-// under `exactOptionalPropertyTypes` — overload resolution drops `value` and infers the props as `{}`.
+// under `exactOptionalPropertyTypes` - overload resolution drops `value` and infers the props as `{}`.
 // The call is correct at runtime (proven by the tests), so invoke it through a precisely-typed element
 // factory that states the real contract (`{ value }` + children), rather than scatter `any`.
 const createProvider = createElement;

package/dist/image.d.ts

@@ -1,16 +1,16 @@
 /**
- * `@nifrajs/web-preact/image` — a CLS-safe responsive Preact `<Image>`. A thin wrapper over `resolveImage`
+ * `@nifrajs/web-preact/image` - a CLS-safe responsive Preact `<Image>`. A thin wrapper over `resolveImage`
  * from `@nifrajs/image`: it computes the responsive `<img>` attributes (`src`/`srcset`/`sizes`/`width`/
- * `height`/`loading`/`decoding`/`fetchpriority` — Preact uses lowercase HTML attribute names, so it
+ * `height`/`loading`/`decoding`/`fetchpriority` - Preact uses lowercase HTML attribute names, so it
  * spreads `toHtmlAttrs`) and forwards any extra DOM props (`class`, `style`, `id`, `data-*`, handlers).
  * Resizing is delegated to the `loader` (an image CDN); nifra bundles no codec. No JSX (`h`).
  */
 import { type ImageLoader, type ImageProps } from "@nifrajs/image";
 import { type JSX, type VNode } from "preact";
-/** 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<JSX.IntrinsicElements["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;
 }
 /**

package/dist/image.js

@@ -1,7 +1,7 @@
 /**
- * `@nifrajs/web-preact/image` — a CLS-safe responsive Preact `<Image>`. A thin wrapper over `resolveImage`
+ * `@nifrajs/web-preact/image` - a CLS-safe responsive Preact `<Image>`. A thin wrapper over `resolveImage`
  * from `@nifrajs/image`: it computes the responsive `<img>` attributes (`src`/`srcset`/`sizes`/`width`/
- * `height`/`loading`/`decoding`/`fetchpriority` — Preact uses lowercase HTML attribute names, so it
+ * `height`/`loading`/`decoding`/`fetchpriority` - Preact uses lowercase HTML attribute names, so it
  * spreads `toHtmlAttrs`) and forwards any extra DOM props (`class`, `style`, `id`, `data-*`, handlers).
  * Resizing is delegated to the `loader` (an image CDN); nifra bundles no codec. No JSX (`h`).
  */

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @nifrajs/web-preact — the Preact render adapter for @nifrajs/web (server side). Streaming SSR via
+ * @nifrajs/web-preact - the Preact render adapter for @nifrajs/web (server side). Streaming SSR via
  * `renderToReadableStream` from `preact-render-to-string/stream` (a Web `ReadableStream<Uint8Array>`,
  * the seam's native shape); the layout-chain fold is in `./compose`. Client hydration lives in
  * `@nifrajs/web-preact/client`. Preact uses `h()` render functions, so no JSX/build plugin is needed
@@ -7,13 +7,13 @@
  */
 import { compose } from "./compose.js";
 import { preactRenderToStream, preactRenderToString } from "./preact-render.js";
-/** The Preact server render adapter — pass to @nifrajs/web's `renderPage`. */
+/** The Preact server render adapter - pass to @nifrajs/web's `renderPage`. */
 export const preactAdapter = {
     // Synchronous one-pass render for non-deferred pages (renderPage's buffered fast path). The sync
     // `renderToString` emits the same markup as the stream renderer without the chunking machinery.
     //
     // Async because the renderer module is resolved lazily (from the consumer app's node_modules under Bun
-    // runtime SSR — see ./preact-render). `RenderAdapter.renderToString` permits a Promise; renderPage awaits.
+    // runtime SSR - see ./preact-render). `RenderAdapter.renderToString` permits a Promise; renderPage awaits.
     async renderToString(chain, props) {
         const { renderToString } = await preactRenderToString();
         return renderToString(compose(chain, props));
@@ -25,7 +25,7 @@ export const preactAdapter = {
         return renderToReadableStream(compose(chain, props));
     },
     // Preact reconciles against the existing DOM on hydrate (like React), so there's no per-document
-    // bootstrap script — the seam allows the empty string (contrast Solid's generateHydrationScript).
+    // bootstrap script - the seam allows the empty string (contrast Solid's generateHydrationScript).
     hydrationHead() {
         return "";
     },

package/dist/preact-render.d.ts

@@ -1,17 +1,17 @@
 /**
  * Resolve `preact-render-to-string` (+ its `/stream` subpath) so the renderer shares ONE `preact`
- * module-global with the route components — the fix for the dual-Preact SSR crash (`undefined is not an
+ * module-global with the route components - the fix for the dual-Preact SSR crash (`undefined is not an
  * object (evaluating '…__H')` / silently-empty hook output).
  *
  * WHY this exists: `preact-render-to-string` imports `options` and `h` from `preact` and mutates the
  * shared `options` hooks; `preact/hooks` registers its render hook on the SAME `options` global. Under Bun
  * **runtime** SSR (`nifra dev`, `nifra start`, `nifra_render`, all in-process), a static
  * `import "preact-render-to-string"` in this adapter is resolved from THIS package's own (symlinked)
- * node_modules — which can be a DIFFERENT physical `preact` than the consumer app's components import. Two
+ * node_modules - which can be a DIFFERENT physical `preact` than the consumer app's components import. Two
  * `preact` copies → two `options` globals → the renderer walks one while `preact/hooks` wrote the other →
  * the vnode never gets its hook-state list → the crash. Resolving the renderer from the consumer **app
  * root** makes it pull the app's `preact` transitively, matching the components: one `options`, one core,
- * no crash. (Empirically verified against a two-copy install fixture — see test/dual-preact.test.ts.)
+ * no crash. (Empirically verified against a two-copy install fixture - see test/dual-preact.test.ts.)
  *
  * Guarding precisely so the PRODUCTION/BUILT path is untouched: when `Bun.resolveSync` is unavailable
  * (Node / Deno / Cloudflare / Vercel / any bundled output), the build has already bundled a single

package/dist/preact-render.js

@@ -1,17 +1,17 @@
 /**
  * Resolve `preact-render-to-string` (+ its `/stream` subpath) so the renderer shares ONE `preact`
- * module-global with the route components — the fix for the dual-Preact SSR crash (`undefined is not an
+ * module-global with the route components - the fix for the dual-Preact SSR crash (`undefined is not an
  * object (evaluating '…__H')` / silently-empty hook output).
  *
  * WHY this exists: `preact-render-to-string` imports `options` and `h` from `preact` and mutates the
  * shared `options` hooks; `preact/hooks` registers its render hook on the SAME `options` global. Under Bun
  * **runtime** SSR (`nifra dev`, `nifra start`, `nifra_render`, all in-process), a static
  * `import "preact-render-to-string"` in this adapter is resolved from THIS package's own (symlinked)
- * node_modules — which can be a DIFFERENT physical `preact` than the consumer app's components import. Two
+ * node_modules - which can be a DIFFERENT physical `preact` than the consumer app's components import. Two
  * `preact` copies → two `options` globals → the renderer walks one while `preact/hooks` wrote the other →
  * the vnode never gets its hook-state list → the crash. Resolving the renderer from the consumer **app
  * root** makes it pull the app's `preact` transitively, matching the components: one `options`, one core,
- * no crash. (Empirically verified against a two-copy install fixture — see test/dual-preact.test.ts.)
+ * no crash. (Empirically verified against a two-copy install fixture - see test/dual-preact.test.ts.)
  *
  * Guarding precisely so the PRODUCTION/BUILT path is untouched: when `Bun.resolveSync` is unavailable
  * (Node / Deno / Cloudflare / Vercel / any bundled output), the build has already bundled a single

package/dist/query.d.ts

@@ -3,7 +3,7 @@ import { type QueryClient, type QueryState } from "@nifrajs/web";
 export declare function useQueryClient(): Pick<QueryClient, "invalidateQueries">;
 /** 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;
     /** Force a refetch (ignores `staleTime`). */
     readonly refetch: () => Promise<T>;

package/dist/query.js

@@ -1,11 +1,11 @@
 import { createQueryClient, } from "@nifrajs/web";
 /**
- * `@nifrajs/web-preact/query` — Preact bindings for the keyed query-cache. `useQuery(key, fn)` subscribes a
+ * `@nifrajs/web-preact/query` - Preact bindings for the keyed query-cache. `useQuery(key, fn)` subscribes a
  * component to a query (via `useSyncExternalStore` from preact/compat) and fetches on mount / key change;
  * `useQueryClient` exposes `invalidateQueries` for after a mutation. Imports only `preact/compat` +
  * `preact/hooks` + `@nifrajs/web`, so route components use it on the server *and* client. No JSX.
  *
- * The query client is created lazily **client-side only** (the `typeof window` guard) — on the server
+ * The query client is created lazily **client-side only** (the `typeof window` guard) - on the server
  * there is none, so `useQuery` renders the idle/pending state (queries are client-first; loaders are
  * the SSR data source). The first client render uses the same idle snapshot, so no mismatch.
  */

package/dist/read-deferred.d.ts

@@ -1,10 +1,10 @@
 /**
- * `readDeferred` — Preact's analogue of React 19's `use()` for a deferred promise (preact/compat has
+ * `readDeferred` - Preact's analogue of React 19's `use()` for a deferred promise (preact/compat has
  * no `use`). Reads a React-style tagged thenable synchronously: returns the value if fulfilled, throws
  * the reason if rejected, else throws the promise so `<Suspense>` awaits it. The core tags
  * `status`/`value`/`reason` via the streamed `__nifraResolve`/`__nifraReject`; this also self-tags on
  * settle so a server re-render (which has no `__nifraResolve`) reads "fulfilled" and stops re-throwing
- * the already-resolved promise. Pure + isomorphic — no `preact` import, so it unit-tests directly.
+ * the already-resolved promise. Pure + isomorphic - no `preact` import, so it unit-tests directly.
  */
 export type Thenable<T> = Promise<T> & {
     status?: "pending" | "fulfilled" | "rejected";

package/dist/read-deferred.js

@@ -13,6 +13,6 @@ export function readDeferred(promise) {
             promise.reason = e;
         });
     }
-    throw promise; // pending — <Suspense> awaits it; the self-tag above wakes the re-render.
+    throw promise; // pending - <Suspense> awaits it; the self-tag above wakes the re-render.
 }
 //# sourceMappingURL=read-deferred.js.map

package/dist/router.d.ts

@@ -0,0 +1,34 @@
+import type { InferOutput, StandardSchemaV1 } from "@nifrajs/core/server";
+import { type Blocker, type BlockerFunction, type NavigateFunction } from "@nifrajs/web";
+export type { Blocker, BlockerFunction, BlockerState, NavigateFunction } from "@nifrajs/web";
+/** The current route's validated search, provided by `compose` on SSR + client mount alike (derived from
+ * the URL via the shared `searchOfChain`). `{}` outside a nifra route tree. Read via {@link useSearch}. */
+export declare const SearchContext: import("preact").Context<Record<string, unknown>>;
+/**
+ * The route's typed, validated search params - the SAME value the loader received as `ctx.search`.
+ * SSR-correct: `compose` provides it from the URL server-side and from the identical derivation on the
+ * client mount, so a value rendered from it doesn't flash on hydration. Hostile input already failed
+ * closed to the schema's defaults at match time. Pass the route's `searchSchema` as the type argument to
+ * get its output type; bare, it's the raw parsed query (`Record<string, unknown>`).
+ *
+ * ```tsx
+ * export const searchSchema = v.object({ page: v.optional(v.fallback(v.number(), 1), 1) })
+ * const { page } = useSearch<typeof searchSchema>() // page: number
+ * ```
+ */
+export declare function useSearch<Schema extends StandardSchemaV1 | undefined = undefined>(): Schema extends StandardSchemaV1 ? InferOutput<Schema> : Record<string, unknown>;
+/** Get the {@link NavigateFunction} (a string path, a history delta, or a typed `{ to, search }` object).
+ * Stable across renders; resolves the browser navigate at call time, so it works as soon as
+ * `installHistory` has run and no-ops before then / on the server. */
+export declare function useNavigate(): NavigateFunction;
+/**
+ * Guard navigation away from a page with unsaved work, confirming with your OWN async UI. Mirrors
+ * react-router's `useBlocker`: pass a boolean (`useBlocker(isDirty)`) or a predicate
+ * `({ currentLocation, nextLocation }) => boolean`, and get back a {@link Blocker}. When a navigation
+ * (an anchor click, `useNavigate`, or a browser back/forward) is intercepted, `blocker.state` becomes
+ * `"blocked"` and `proceed`/`reset` go live - render a dialog and call `proceed()` to continue or
+ * `reset()` to stay put. It also arms the browser's native "Leave site?" prompt on tab close / reload.
+ * Idle (never blocks) on the server and before hydration.
+ */
+export declare function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker;
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACzE,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,eAAe,EAGpB,KAAK,gBAAgB,EAKtB,MAAM,cAAc,CAAA;AAWrB,YAAY,EAAE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAK5F;2GAC2G;AAC3G,eAAO,MAAM,aAAa,mDAAuD,CAAA;AAEjF;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,MAAM,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,KACpD,MAAM,SAAS,gBAAgB,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAInF;AAED;;sEAEsE;AACtE,wBAAgB,WAAW,IAAI,gBAAgB,CAO9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,WAAW,EAAE,OAAO,GAAG,eAAe,GAAG,OAAO,CAe1E"}