@nifrajs/web 2.2.0 → 2.4.0

package/dist/navigation.d.ts

@@ -1,31 +1,146 @@
 /**
- * `@nifrajs/web` navigation bridge — a tiny, DOM-free seam that lets an adapter's `useNavigate`
- * (a route component, which must import only from the agnostic `@nifrajs/web` main entry — never the
+ * `@nifrajs/web` navigation bridge - a tiny, DOM-free seam that lets an adapter's `useNavigate`
+ * (a route component, which must import only from the agnostic `@nifrajs/web` main entry - never the
  * DOM-only `/client`) reach the browser's history-aware navigate, WITHOUT the route component pulling
  * `@nifrajs/web/client` (and its `document`/`history` access) into a bundle that also renders on the
  * server.
  *
  * The browser layer (`installHistory`, in `./client.ts`) populates this on setup and clears it on
- * teardown; a framework binding reads it via {@link getBrowserNavigate}. Module-level singleton — the
+ * teardown; a framework binding reads it via {@link getBrowserNavigate}. Module-level singleton - the
  * browser mounts exactly one app per page (the same convention the adapters' `setMountedRouter` uses).
  * On the server (and before hydration) the getter returns `undefined`, so a binding degrades to the
- * native `<a href>` full-page navigation — progressive enhancement, no throw.
+ * native `<a href>` full-page navigation - progressive enhancement, no throw.
  */
 /** Options for a programmatic navigation. */
 export interface NavigateOptions {
     /** Replace the current history entry instead of pushing a new one (like `history.replaceState`). */
     readonly replace?: boolean;
 }
+/**
+ * The augmentable route -> search-type map for typed cross-route navigation. Empty by default (so an
+ * object-form navigate to any path is allowed with a loose `search`). A build step (`nifra sync-routes`)
+ * OR the app declares one entry per route path against its `searchSchema` output:
+ *
+ * ```ts
+ * declare module "@nifrajs/web" {
+ *   interface RouteSearch {
+ *     "/reports": { page: number; q: string }
+ *   }
+ * }
+ * ```
+ *
+ * With that, `navigate({ to: "/reports", search: { page: 2 } })` type-checks `search` against
+ * `/reports`'s schema, and a wrong shape is a compile error. See {@link NavigateTarget}.
+ */
+export interface RouteSearch {
+}
+/**
+ * The `search` type for a navigate to `To`: the route's schema output when `To` is a mapped
+ * {@link RouteSearch} key, otherwise the loose `Record<string, unknown>` (so a navigate to any path is
+ * always allowed). Keyed on `To` rather than a union, so a mapped route can't fall back to the loose form
+ * with a wrong shape - `navigate({ to: "/reports", search: { page: "x" } })` is a compile error.
+ */
+export type NavigateSearchOf<To extends string> = To extends keyof RouteSearch ? RouteSearch[To] : Record<string, unknown>;
+/** The runtime shape of an object-form navigate target (loose - the typed narrowing lives in
+ * {@link NavigateFunction}'s generic call signature). `to` is a bare pathname; `search` is serialized
+ * onto it; `replace` folds into the options. */
+export interface NavigateTargetInput {
+    readonly to: string;
+    readonly search?: Record<string, unknown>;
+    readonly replace?: boolean;
+}
+/**
+ * A programmatic navigate, shared by every adapter's `useNavigate`. Three forms: a string path (push, or
+ * replace via `{ replace: true }`), a history delta (`-1`/`1`), or an object target `{ to, search, replace }`
+ * whose `search` is typed against `to`'s route schema via {@link NavigateSearchOf} (a wrong shape for a
+ * mapped route is a compile error; an unmapped path takes a loose `search`). The object form's `search` is
+ * serialized onto `to`. A no-op on the server / before hydration.
+ */
+export interface NavigateFunction {
+    (to: string | number, options?: NavigateOptions): void;
+    <To extends string>(target: {
+        readonly to: To;
+        readonly search?: NavigateSearchOf<To>;
+        readonly replace?: boolean;
+    }): void;
+}
+/**
+ * Normalize a navigate argument to the bridge's `(to, options)`: a string path or history-delta passes
+ * through; an object target has its `search` serialized onto `to` and its `replace` folded into the
+ * options. The one place the object form becomes a URL, so every adapter's `navigate` resolves it
+ * identically.
+ */
+export declare function resolveNavigate(to: string | number | NavigateTargetInput, options?: NavigateOptions): {
+    readonly to: string | number;
+    readonly options: NavigateOptions | undefined;
+};
 /**
  * A history-aware navigate. A **string** `to` is a same-origin path (`/users/7?tab=a`) navigated to
  * (push, or replace with `{ replace: true }`); a **number** is a history delta (`-1` back, `1`
  * forward), matching the browser's `history.go`. Registered by `installHistory`.
  */
 export type BrowserNavigate = (to: string | number, options?: NavigateOptions) => void;
-/** Register (or clear, with `undefined`) the browser navigate — called by `installHistory`. Not for
+/** Register (or clear, with `undefined`) the browser navigate - called by `installHistory`. Not for
  * app use. */
 export declare function setBrowserNavigate(navigate: BrowserNavigate | undefined): void;
 /** The active browser navigate, or `undefined` on the server / before `installHistory` has run. A
  * binding calls it when present and falls back to native navigation otherwise. */
 export declare function getBrowserNavigate(): BrowserNavigate | undefined;
+/** A parsed navigation target the {@link BlockerFunction} decides on. `pathname`/`search`/`hash` match
+ * the DOM `Location` shape (search keeps its `?`, hash its `#`). */
+export interface BlockerLocation {
+    readonly pathname: string;
+    readonly search: string;
+    readonly hash: string;
+}
+/**
+ * Decide whether a navigation should be halted. Receives where the app is (`currentLocation`) and where
+ * it's heading (`nextLocation`), so a guard can allow same-section moves and block only real exits. A
+ * boolean form (`useBlocker(isDirty)`) is sugar for `() => isDirty`. Runs synchronously at navigation
+ * time - return the current answer; the async "are you sure?" happens afterward via {@link Blocker}'s
+ * `proceed`/`reset`.
+ */
+export type BlockerFunction = (args: {
+    readonly currentLocation: BlockerLocation;
+    readonly nextLocation: BlockerLocation;
+}) => boolean;
+/**
+ * The blocker's lifecycle. `unblocked` - idle, nothing intercepted. `blocked` - a navigation was halted
+ * and is awaiting the app's decision (`proceed`/`reset` are live). `proceeding` - the app called
+ * `proceed`; the held navigation is being replayed.
+ */
+export type BlockerState = "unblocked" | "blocked" | "proceeding";
+/**
+ * A navigation guard, mirroring react-router's shape. When `state` is `blocked`, `proceed()` lets the
+ * held navigation through and `reset()` cancels it (staying put); both are `undefined` otherwise. The
+ * pair is what a boolean `when` can't express - the app shows its OWN async confirmation UI, then calls
+ * one of them, instead of the browser's synchronous `confirm()`.
+ */
+export interface Blocker {
+    readonly state: BlockerState;
+    readonly proceed: (() => void) | undefined;
+    readonly reset: (() => void) | undefined;
+}
+/** The idle blocker - a stable reference (no needless adapter re-renders while unblocked). */
+export declare const IDLE_BLOCKER: Blocker;
+/**
+ * The browser layer's blocker registry - installed by `installHistory` (which owns navigation and can
+ * therefore halt, restore, and replay it) and read by an adapter's `useBlocker` through
+ * {@link registerBlocker}. Kept here, DOM-free, for the same reason as {@link BrowserNavigate}: a route
+ * component's blocker hook must import only this agnostic entry.
+ */
+export interface BlockerController {
+    register(shouldBlock: BlockerFunction, onChange: (blocker: Blocker) => void): () => void;
+}
+/** Register (or clear, with `undefined`) the blocker controller - called by `installHistory`. Not for
+ * app use. */
+export declare function setBlockerController(controller: BlockerController | undefined): void;
+/**
+ * Register a navigation guard, returning an unregister function. `onChange` is called with the current
+ * {@link Blocker} whenever its state changes (so the adapter can re-render its confirmation UI). Before
+ * `installHistory` has run (SSR, pre-hydration), there's no controller: registration is a no-op and the
+ * caller stays on {@link IDLE_BLOCKER}, degrading to native navigation. Called by an adapter's
+ * `useBlocker`, not by app code directly.
+ */
+export declare function registerBlocker(shouldBlock: BlockerFunction, onChange: (blocker: Blocker) => void): () => void;
 //# sourceMappingURL=navigation.d.ts.map

package/dist/navigation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../src/navigation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,6CAA6C;AAC7C,MAAM,WAAW,eAAe;IAC9B,oGAAoG;IACpG,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,IAAI,CAAA;AAMtF;cACc;AACd,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,GAAG,IAAI,CAE9E;AAED;kFACkF;AAClF,wBAAgB,kBAAkB,IAAI,eAAe,GAAG,SAAS,CAEhE"}
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../src/navigation.ts"],"names":[],"mappings":"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"}

package/dist/navigation.js

@@ -1,20 +1,33 @@
 /**
- * `@nifrajs/web` navigation bridge — a tiny, DOM-free seam that lets an adapter's `useNavigate`
- * (a route component, which must import only from the agnostic `@nifrajs/web` main entry — never the
+ * `@nifrajs/web` navigation bridge - a tiny, DOM-free seam that lets an adapter's `useNavigate`
+ * (a route component, which must import only from the agnostic `@nifrajs/web` main entry - never the
  * DOM-only `/client`) reach the browser's history-aware navigate, WITHOUT the route component pulling
  * `@nifrajs/web/client` (and its `document`/`history` access) into a bundle that also renders on the
  * server.
  *
  * The browser layer (`installHistory`, in `./client.ts`) populates this on setup and clears it on
- * teardown; a framework binding reads it via {@link getBrowserNavigate}. Module-level singleton — the
+ * teardown; a framework binding reads it via {@link getBrowserNavigate}. Module-level singleton - the
  * browser mounts exactly one app per page (the same convention the adapters' `setMountedRouter` uses).
  * On the server (and before hydration) the getter returns `undefined`, so a binding degrades to the
- * native `<a href>` full-page navigation — progressive enhancement, no throw.
+ * native `<a href>` full-page navigation - progressive enhancement, no throw.
  */
+import { serializeSearch } from "./search.js";
+/**
+ * Normalize a navigate argument to the bridge's `(to, options)`: a string path or history-delta passes
+ * through; an object target has its `search` serialized onto `to` and its `replace` folded into the
+ * options. The one place the object form becomes a URL, so every adapter's `navigate` resolves it
+ * identically.
+ */
+export function resolveNavigate(to, options) {
+    if (typeof to !== "object")
+        return { to, options };
+    const query = to.search !== undefined ? serializeSearch(to.search) : "";
+    return { to: to.to + query, options: to.replace === true ? { replace: true } : options };
+}
 // The active browser navigate (set by `installHistory`, cleared on teardown). Module-scoped: one app
 // per page; absent on the server and before hydration.
 let browserNavigate;
-/** Register (or clear, with `undefined`) the browser navigate — called by `installHistory`. Not for
+/** Register (or clear, with `undefined`) the browser navigate - called by `installHistory`. Not for
  * app use. */
 export function setBrowserNavigate(navigate) {
     browserNavigate = navigate;
@@ -24,4 +37,23 @@ export function setBrowserNavigate(navigate) {
 export function getBrowserNavigate() {
     return browserNavigate;
 }
+/** The idle blocker - a stable reference (no needless adapter re-renders while unblocked). */
+export const IDLE_BLOCKER = { state: "unblocked", proceed: undefined, reset: undefined };
+// The active controller (set by `installHistory`, cleared on teardown). Module-scoped: one app per page.
+let blockerController;
+/** Register (or clear, with `undefined`) the blocker controller - called by `installHistory`. Not for
+ * app use. */
+export function setBlockerController(controller) {
+    blockerController = controller;
+}
+/**
+ * Register a navigation guard, returning an unregister function. `onChange` is called with the current
+ * {@link Blocker} whenever its state changes (so the adapter can re-render its confirmation UI). Before
+ * `installHistory` has run (SSR, pre-hydration), there's no controller: registration is a no-op and the
+ * caller stays on {@link IDLE_BLOCKER}, degrading to native navigation. Called by an adapter's
+ * `useBlocker`, not by app code directly.
+ */
+export function registerBlocker(shouldBlock, onChange) {
+    return blockerController?.register(shouldBlock, onChange) ?? (() => { });
+}
 //# sourceMappingURL=navigation.js.map

package/dist/navigation.js.map

@@ -1 +1 @@
-{"version":3,"file":"navigation.js","sourceRoot":"","sources":["../src/navigation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAeH,qGAAqG;AACrG,uDAAuD;AACvD,IAAI,eAA4C,CAAA;AAEhD;cACc;AACd,MAAM,UAAU,kBAAkB,CAAC,QAAqC;IACtE,eAAe,GAAG,QAAQ,CAAA;AAC5B,CAAC;AAED;kFACkF;AAClF,MAAM,UAAU,kBAAkB;IAChC,OAAO,eAAe,CAAA;AACxB,CAAC"}
+{"version":3,"file":"navigation.js","sourceRoot":"","sources":["../src/navigation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AA8D7C;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAC7B,EAAyC,EACzC,OAAyB;IAEzB,IAAI,OAAO,EAAE,KAAK,QAAQ;QAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,CAAA;IAClD,MAAM,KAAK,GAAG,EAAE,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;IACvE,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,OAAO,EAAE,CAAA;AAC1F,CAAC;AASD,qGAAqG;AACrG,uDAAuD;AACvD,IAAI,eAA4C,CAAA;AAEhD;cACc;AACd,MAAM,UAAU,kBAAkB,CAAC,QAAqC;IACtE,eAAe,GAAG,QAAQ,CAAA;AAC5B,CAAC;AAED;kFACkF;AAClF,MAAM,UAAU,kBAAkB;IAChC,OAAO,eAAe,CAAA;AACxB,CAAC;AAyCD,8FAA8F;AAC9F,MAAM,CAAC,MAAM,YAAY,GAAY,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAA;AAYjG,yGAAyG;AACzG,IAAI,iBAAgD,CAAA;AAEpD;cACc;AACd,MAAM,UAAU,oBAAoB,CAAC,UAAyC;IAC5E,iBAAiB,GAAG,UAAU,CAAA;AAChC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,WAA4B,EAC5B,QAAoC;IAEpC,OAAO,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAA;AACzE,CAAC"}

package/dist/plugins/css-modules.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web/plugins/css-modules` — a dependency-free CSS Modules (`*.module.css`) Bun plugin, in its
+ * `@nifrajs/web/plugins/css-modules` - a dependency-free CSS Modules (`*.module.css`) Bun plugin, in its
  * OWN module so the SSR preload registers it BEFORE any `.module.css` file loads. Mirrors the
  * `@nifrajs/web-vue/plugin` seam exactly: pass `"dom"` for the client bundle
  * (`buildClient({ plugins: [...] })`) and preload `"ssr"` for the server (`bun --preload`).
@@ -7,7 +7,7 @@
  * Each `import styles from "./x.module.css"` becomes a JS module whose **default export** is the
  * `{ originalClassName: scopedClassName }` map; the rewritten (scoped) CSS is emitted into the client
  * stylesheet via the `?nifra-css-module` virtual-module idiom (the same trick the Vue plugin uses for
- * `?vue-css`). The `"ssr"` form emits **no** CSS — the stylesheet ships from the client build — but
+ * `?vue-css`). The `"ssr"` form emits **no** CSS - the stylesheet ships from the client build - but
  * produces the **identical** class map, so SSR markup's `class={styles.foo}` matches the bundled
  * selectors (scoped names are a pure function of file path + class name, so both builds agree).
  *
@@ -17,7 +17,7 @@
  * pseudo-classes/`:not(...)`, native nesting, at-rules (`@media`/`@supports`/`@container`/`@layer`),
  * `:global(...)`/`:local(...)` (function form), and **`@keyframes` names + their `animation`/
  * `animation-name` references** (scoped together, so two modules' same-named keyframes don't clash).
- * Not handled: the bare `:global`/`:local` *switch* form and `composes:` — out of scope by design.
+ * Not handled: the bare `:global`/`:local` *switch* form and `composes:` - out of scope by design.
  */
 import type { BunPlugin } from "bun";
 /** The transform result: the `{ original: scoped }` export map + the rewritten (scoped) stylesheet. */

package/dist/plugins/kit.d.ts

@@ -1,24 +1,24 @@
 import type { BunPlugin } from "bun";
-/** The argument Bun passes to a plugin's `setup` — Bun doesn't export the type, so derive it. */
+/** The argument Bun passes to a plugin's `setup` - Bun doesn't export the type, so derive it. */
 export type PluginBuilder = Parameters<BunPlugin["setup"]>[0];
 /**
- * A **package-root-relative**, forward-slashed form of an absolute path — the input to {@link hash8} for
+ * A **package-root-relative**, forward-slashed form of an absolute path - the input to {@link hash8} for
  * any build-stable identifier (e.g. CSS-module scoped names). Anchoring on the file's nearest
  * `package.json` (not the absolute path, not `process.cwd()`) makes the result independent of BOTH the
- * machine's directory layout AND the working directory: the dom build and the ssr runtime — even on
- * different machines or from different cwds — derive the SAME relative path for a given file, so their
+ * machine's directory layout AND the working directory: the dom build and the ssr runtime - even on
+ * different machines or from different cwds - derive the SAME relative path for a given file, so their
  * scoped class maps always agree. (Hashing the absolute path would differ across CI/host; a
  * cwd-relative path would silently desync if the SSR server started from a non-project-root cwd.)
  */
 export declare function reproduciblePath(absolutePath: string): string;
 /**
- * Deterministic 8-hex hash (djb2/xor). Stable across builds — no `Date.now`/`Math.random` — so build
+ * Deterministic 8-hex hash (djb2/xor). Stable across builds - no `Date.now`/`Math.random` - so build
  * output is reproducible. The single hash implementation behind CSS-module scoped names (and a drop-in
  * for any SFC scope id).
  */
 export declare function hash8(input: string): string;
 /**
- * Records compiled CSS and wires it into the client bundle through a virtual `?<namespace>` module —
+ * Records compiled CSS and wires it into the client bundle through a virtual `?<namespace>` module -
  * the idiom the Vue plugin established (`?vue-css`). Register one per plugin `setup`; call `emit` per
  * file to stash its CSS and get back the `import` line to append to the JS module.
  */
@@ -29,12 +29,12 @@ export interface StylesheetEmitter {
 /**
  * Wire the virtual-CSS-module handlers onto `build` for `namespace`, returning an {@link StylesheetEmitter}.
  * The `namespace` must be a plain identifier (letters/`-`); it's used verbatim as the import suffix and
- * the Bun namespace. Only the `"dom"` build should emit CSS — the `"ssr"` build ships no stylesheet.
+ * the Bun namespace. Only the `"dom"` build should emit CSS - the `"ssr"` build ships no stylesheet.
  */
 export declare function createStylesheetEmitter(build: PluginBuilder, namespace: string): StylesheetEmitter;
 /**
  * Load an optional peer compiler at build time, throwing a consistent, actionable install-hint error if
- * it's absent — the `@vue/compiler-sfc` peer pattern, centralized. Build-time only, so the dynamic
+ * it's absent - the `@vue/compiler-sfc` peer pattern, centralized. Build-time only, so the dynamic
  * `import` (which keeps the peer out of the package's hard dependencies) is correct here.
  */
 export declare function requirePeer<T>(specifier: string, hint: {

package/dist/plugins/kit.js

@@ -7,7 +7,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 /**
- * `@nifrajs/web/plugins` shared kit — the small infrastructure every CSS-bearing asset plugin reuses, so
+ * `@nifrajs/web/plugins` shared kit - the small infrastructure every CSS-bearing asset plugin reuses, so
  * P1 (CSS Modules), P2 (SCSS), and any future P4 (LESS/Stylus/PostCSS) don't each re-implement the
  * CSS→client-bundle wiring, the deterministic hash, or the optional-peer guard. Internal to
  * `@nifrajs/web` (imported by the sibling plugin modules); not a public subpath.
@@ -27,7 +27,7 @@ function packageRootOf(startDir) {
             break;
         const parent = dirname(dir);
         if (parent === dir) {
-            dir = startDir; // reached the filesystem root with no package.json — anchor on the file's own dir
+            dir = startDir; // reached the filesystem root with no package.json - anchor on the file's own dir
             break;
         }
         dir = parent;
@@ -36,11 +36,11 @@ function packageRootOf(startDir) {
     return dir;
 }
 /**
- * A **package-root-relative**, forward-slashed form of an absolute path — the input to {@link hash8} for
+ * A **package-root-relative**, forward-slashed form of an absolute path - the input to {@link hash8} for
  * any build-stable identifier (e.g. CSS-module scoped names). Anchoring on the file's nearest
  * `package.json` (not the absolute path, not `process.cwd()`) makes the result independent of BOTH the
- * machine's directory layout AND the working directory: the dom build and the ssr runtime — even on
- * different machines or from different cwds — derive the SAME relative path for a given file, so their
+ * machine's directory layout AND the working directory: the dom build and the ssr runtime - even on
+ * different machines or from different cwds - derive the SAME relative path for a given file, so their
  * scoped class maps always agree. (Hashing the absolute path would differ across CI/host; a
  * cwd-relative path would silently desync if the SSR server started from a non-project-root cwd.)
  */
@@ -49,7 +49,7 @@ export function reproduciblePath(absolutePath) {
     return relative(root, absolutePath).replaceAll("\\", "/");
 }
 /**
- * Deterministic 8-hex hash (djb2/xor). Stable across builds — no `Date.now`/`Math.random` — so build
+ * Deterministic 8-hex hash (djb2/xor). Stable across builds - no `Date.now`/`Math.random` - so build
  * output is reproducible. The single hash implementation behind CSS-module scoped names (and a drop-in
  * for any SFC scope id).
  */
@@ -62,7 +62,7 @@ export function hash8(input) {
 /**
  * Wire the virtual-CSS-module handlers onto `build` for `namespace`, returning an {@link StylesheetEmitter}.
  * The `namespace` must be a plain identifier (letters/`-`); it's used verbatim as the import suffix and
- * the Bun namespace. Only the `"dom"` build should emit CSS — the `"ssr"` build ships no stylesheet.
+ * the Bun namespace. Only the `"dom"` build should emit CSS - the `"ssr"` build ships no stylesheet.
  */
 export function createStylesheetEmitter(build, namespace) {
     const suffix = `?${namespace}`;
@@ -85,7 +85,7 @@ export function createStylesheetEmitter(build, namespace) {
 }
 /**
  * Load an optional peer compiler at build time, throwing a consistent, actionable install-hint error if
- * it's absent — the `@vue/compiler-sfc` peer pattern, centralized. Build-time only, so the dynamic
+ * it's absent - the `@vue/compiler-sfc` peer pattern, centralized. Build-time only, so the dynamic
  * `import` (which keeps the peer out of the package's hard dependencies) is correct here.
  */
 export async function requirePeer(specifier, hint) {
@@ -93,7 +93,7 @@ export async function requirePeer(specifier, hint) {
         return (await import(__rewriteRelativeImportExtension(specifier)));
     }
     catch (err) {
-        // Only a genuine resolution failure means "not installed" — surface anything else (a corrupt
+        // Only a genuine resolution failure means "not installed" - surface anything else (a corrupt
         // install, a native-binding error, a throw at module top-level) as the real error rather than
         // masking it behind a misleading "please install it" hint.
         if (err.code === "ERR_MODULE_NOT_FOUND") {

package/dist/plugins/scss.js

@@ -1,17 +1,17 @@
 /**
- * `@nifrajs/web/plugins/scss` — a SASS/SCSS (`*.scss`, `*.sass`) Bun plugin, in its OWN module so the SSR
+ * `@nifrajs/web/plugins/scss` - a SASS/SCSS (`*.scss`, `*.sass`) Bun plugin, in its OWN module so the SSR
  * preload registers it BEFORE any Sass file loads. Mirrors the `@nifrajs/web-vue/plugin` seam: pass
  * `"dom"` for the client bundle (`buildClient({ plugins: [...] })`) and preload `"ssr"` for the server
  * (`bun --preload`).
  *
- * The Dart Sass compiler is an **optional peer** (`sass`, or the faster `sass-embedded` — same API), not
+ * The Dart Sass compiler is an **optional peer** (`sass`, or the faster `sass-embedded` - same API), not
  * a hard dependency: it's loaded on first Sass file and fails loud with an install hint if absent. Pass
  * your own `compiler` to override (e.g. `sass-embedded`, or a stub in tests).
  *
  * Composes with CSS Modules: a `*.module.scss` / `*.module.sass` file is compiled to CSS and then run
  * through the same scoped-class transform as `@nifrajs/web/plugins/css-modules`, so its `import styles`
  * yields the `{ original: scoped }` map (SSR/dom class-map parity included). A plain `*.scss` is a
- * side-effect import — its CSS is bundled (dom) and it resolves to an empty module (ssr).
+ * side-effect import - its CSS is bundled (dom) and it resolves to an empty module (ssr).
  */
 import { dirname } from "node:path";
 import { pathToFileURL } from "node:url";

package/dist/plugins/vite-leak-guard.d.ts

@@ -19,7 +19,7 @@ interface RollupPluginContext {
      */
     error(error: Error): never;
 }
-/** The minimal Rollup plugin shape this returns — `generateBundle` bound to the plugin context. */
+/** The minimal Rollup plugin shape this returns - `generateBundle` bound to the plugin context. */
 export interface LeakGuardPlugin {
     readonly name: string;
     /**

package/dist/plugins/vite-leak-guard.js

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web/plugins/vite-leak-guard` — nifra's two client-leak guards, for a Vite/Rollup production
+ * `@nifrajs/web/plugins/vite-leak-guard` - nifra's two client-leak guards, for a Vite/Rollup production
  * build.
  *
  * ## Why this exists

package/dist/plugins/vite-server-fn.d.ts

@@ -0,0 +1,23 @@
+/** The slice of a Vite/Rollup plugin this returns. Structural, so `vite` stays an optional peer. */
+export interface ServerFnStubPlugin {
+    readonly name: string;
+    readonly enforce: "pre";
+    /** Applied only to the CLIENT build; the server build keeps the real module. */
+    readonly applyToEnvironment?: (environment: {
+        readonly name: string;
+    }) => boolean;
+    transform(code: string, id: string, options?: {
+        readonly ssr?: boolean;
+    }): {
+        code: string;
+        map: null;
+    } | null;
+}
+/**
+ * Replace every `*.fn` module with its client stubs.
+ *
+ * Client-only by construction: nifra passes this to the client build and the dev server, never to the
+ * SSR build, because the server is what actually runs these functions.
+ */
+export declare function viteServerFnStub(): ServerFnStubPlugin;
+//# sourceMappingURL=vite-server-fn.d.ts.map

package/dist/plugins/vite-server-fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-server-fn.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-server-fn.ts"],"names":[],"mappings":"AA2BA,oGAAoG;AACpG,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAA;IACvB,gFAAgF;IAChF,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,WAAW,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAA;IACjF,SAAS,CACP,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE,GACnC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,IAAI,CAAA;KAAE,GAAG,IAAI,CAAA;CACtC;AAKD;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,kBAAkB,CAiBrD"}

package/dist/plugins/vite-server-fn.js

@@ -0,0 +1,51 @@
+/**
+ * `@nifrajs/web/plugins/vite-server-fn` - the Vite half of the server-function client transform.
+ *
+ * A `*.fn` module must never reach a browser: it holds the function bodies and everything they import.
+ * The Bun build replaces each one with client stubs, and this does the same for Vite, in both the dev
+ * server and the production build.
+ *
+ * ## Why the generation is not in here
+ *
+ * The stub text comes from `internal/server-boundary.ts`, shared verbatim with the Bun plugin. Two
+ * implementations of "what a stub looks like" would drift, and the drift would be invisible until a
+ * client that worked in dev 404'd in production - the exact shape of failure this codebase has already
+ * paid for once. A parity test asserts both pipelines emit the same bytes.
+ *
+ * ## Why `transform` and not `load`
+ *
+ * Vite resolves and reads the file itself; taking `load` would mean re-implementing its resolution.
+ * `transform` receives the source Vite already read, and returning replacement code discards the
+ * original along with its imports - so the server subtree is never followed. `enforce: "pre"` puts this
+ * ahead of framework transforms, which have no business seeing server code either.
+ */
+import { generateServerFnStub, SERVER_FN_MODULE, serverFnNamespace, } from "../internal/server-boundary.js";
+/** Strips a Vite id's `?query` and `#hash` so the suffix test sees a plain path. */
+const bare = (id) => id.split("?")[0]?.split("#")[0] ?? id;
+/**
+ * Replace every `*.fn` module with its client stubs.
+ *
+ * Client-only by construction: nifra passes this to the client build and the dev server, never to the
+ * SSR build, because the server is what actually runs these functions.
+ */
+export function viteServerFnStub() {
+    return {
+        name: "nifra:server-fn-stub",
+        enforce: "pre",
+        // Vite 6+ environments: the SSR environment must keep the real module. Older Vite ignores this and
+        // relies on nifra only registering the plugin on the client side.
+        applyToEnvironment: (environment) => environment.name === "client",
+        transform(code, id, options) {
+            // Vite 5 ignores `applyToEnvironment` but supplies this transform context for SSR.
+            if (options?.ssr === true)
+                return null;
+            const path = bare(id);
+            if (!SERVER_FN_MODULE.test(path))
+                return null;
+            // `map: null` is honest rather than lazy: the stub shares no lines with the source, so any
+            // mapping would point a debugger at unrelated code.
+            return { code: generateServerFnStub(code, serverFnNamespace(path)), map: null };
+        },
+    };
+}
+//# sourceMappingURL=vite-server-fn.js.map

package/dist/plugins/vite-server-fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-server-fn.js","sourceRoot":"","sources":["../../src/plugins/vite-server-fn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,gCAAgC,CAAA;AAevC,oFAAoF;AACpF,MAAM,IAAI,GAAG,CAAC,EAAU,EAAU,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;AAE1E;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO;QACL,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EAAE,KAAK;QACd,mGAAmG;QACnG,kEAAkE;QAClE,kBAAkB,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,KAAK,QAAQ;QAClE,SAAS,CAAC,IAAI,EAAE,EAAE,EAAE,OAAO;YACzB,mFAAmF;YACnF,IAAI,OAAO,EAAE,GAAG,KAAK,IAAI;gBAAE,OAAO,IAAI,CAAA;YACtC,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,CAAA;YACrB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAA;YAC7C,2FAA2F;YAC3F,oDAAoD;YACpD,OAAO,EAAE,IAAI,EAAE,oBAAoB,CAAC,IAAI,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAA;QACjF,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/plugins/vite-server-only.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `@nifrajs/web/plugins/vite-server-only` - the Vite half of the `.server` convention.
+ *
+ * A module named `*.server.ts(x)` is server-only: the Bun client build empties it so its import
+ * subtree - `node:` builtins, native modules, secrets - never reaches a browser. This does the same
+ * for Vite, in both the dev server and the production build.
+ *
+ * ## Why this exists separately
+ *
+ * The convention was implemented once, as a `Bun.build` plugin, which meant it held in exactly one of
+ * the four pipelines. `nifra build` emptied the module; `nifra dev` (Vite), a Vite production build,
+ * and `nifra dev --bun` all shipped it whole. A guard that holds in one pipeline and not the others is
+ * worse than none, because the file name reads as protection everywhere.
+ *
+ * `*.fn` already had this shape - a Bun plugin, a Vite plugin, and a refusal in the one pipeline that
+ * cannot transform. `.server` now matches it.
+ *
+ * ## Why `transform` and not `load`
+ *
+ * Vite resolves and reads the file itself; taking `load` would mean re-implementing its resolution.
+ * `transform` receives the source Vite already read, and returning replacement code discards the
+ * original along with its imports - so the server subtree is never followed. `enforce: "pre"` puts
+ * this ahead of framework transforms, which have no business seeing server code either.
+ */
+import { SERVER_ONLY_MODULE, SERVER_ONLY_REPLACEMENT, viteServerOnlyReplacement } from "../internal/server-boundary.js";
+export { SERVER_ONLY_MODULE, SERVER_ONLY_REPLACEMENT, viteServerOnlyReplacement };
+/** The slice of a Vite/Rollup plugin this returns. Structural, so `vite` stays an optional peer. */
+export interface ServerOnlyEmptyPlugin {
+    readonly name: string;
+    readonly enforce: "pre";
+    /** Applied only to the CLIENT build; the server build keeps the real module. */
+    readonly applyToEnvironment?: (environment: {
+        readonly name: string;
+    }) => boolean;
+    transform(code: string, id: string, options?: {
+        readonly ssr?: boolean;
+    }): {
+        code: string;
+        map: null;
+    } | null;
+}
+/**
+ * Empty every `*.server` module in the client build.
+ *
+ * Client-only by construction: nifra passes this to the client build and the dev server, never to the
+ * SSR build, where the real module is what runs.
+ */
+export declare function viteServerOnlyEmpty(): ServerOnlyEmptyPlugin;
+//# sourceMappingURL=vite-server-only.d.ts.map

package/dist/plugins/vite-server-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-server-only.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-server-only.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,yBAAyB,EAC1B,MAAM,gCAAgC,CAAA;AAIvC,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,CAAA;AAEjF,oGAAoG;AACpG,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAA;IACvB,gFAAgF;IAChF,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC,WAAW,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAA;IACjF,SAAS,CACP,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAA;KAAE,GACnC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,IAAI,CAAA;KAAE,GAAG,IAAI,CAAA;CACtC;AAKD;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,qBAAqB,CAiB3D"}

package/dist/plugins/vite-server-only.js

@@ -0,0 +1,57 @@
+/**
+ * `@nifrajs/web/plugins/vite-server-only` - the Vite half of the `.server` convention.
+ *
+ * A module named `*.server.ts(x)` is server-only: the Bun client build empties it so its import
+ * subtree - `node:` builtins, native modules, secrets - never reaches a browser. This does the same
+ * for Vite, in both the dev server and the production build.
+ *
+ * ## Why this exists separately
+ *
+ * The convention was implemented once, as a `Bun.build` plugin, which meant it held in exactly one of
+ * the four pipelines. `nifra build` emptied the module; `nifra dev` (Vite), a Vite production build,
+ * and `nifra dev --bun` all shipped it whole. A guard that holds in one pipeline and not the others is
+ * worse than none, because the file name reads as protection everywhere.
+ *
+ * `*.fn` already had this shape - a Bun plugin, a Vite plugin, and a refusal in the one pipeline that
+ * cannot transform. `.server` now matches it.
+ *
+ * ## Why `transform` and not `load`
+ *
+ * Vite resolves and reads the file itself; taking `load` would mean re-implementing its resolution.
+ * `transform` receives the source Vite already read, and returning replacement code discards the
+ * original along with its imports - so the server subtree is never followed. `enforce: "pre"` puts
+ * this ahead of framework transforms, which have no business seeing server code either.
+ */
+import { SERVER_ONLY_MODULE, SERVER_ONLY_REPLACEMENT, viteServerOnlyReplacement, } from "../internal/server-boundary.js";
+// Re-exported so a caller wiring its own bundler gets the matcher from the same owner the pipelines
+// use, rather than writing a fifth copy of the regex.
+export { SERVER_ONLY_MODULE, SERVER_ONLY_REPLACEMENT, viteServerOnlyReplacement };
+/** Strips a Vite id's `?query` and `#hash` so the suffix test sees a plain path. */
+const bare = (id) => id.split("?")[0]?.split("#")[0] ?? id;
+/**
+ * Empty every `*.server` module in the client build.
+ *
+ * Client-only by construction: nifra passes this to the client build and the dev server, never to the
+ * SSR build, where the real module is what runs.
+ */
+export function viteServerOnlyEmpty() {
+    return {
+        name: "nifra:server-only-empty",
+        enforce: "pre",
+        // Vite 6+ environments: the SSR environment must keep the real module. Older Vite ignores this and
+        // relies on nifra only registering the plugin on the client side.
+        applyToEnvironment: (environment) => environment.name === "client",
+        transform(code, id, options) {
+            // Vite 5 ignores `applyToEnvironment` but supplies this transform context for SSR.
+            if (options?.ssr === true)
+                return null;
+            const path = bare(id);
+            if (!SERVER_ONLY_MODULE.test(path))
+                return null;
+            // `map: null` is honest rather than lazy: the replacement shares no lines with the source, so any
+            // mapping would point a debugger at unrelated code.
+            return { code: viteServerOnlyReplacement(code), map: null };
+        },
+    };
+}
+//# sourceMappingURL=vite-server-only.js.map

package/dist/plugins/vite-server-only.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-server-only.js","sourceRoot":"","sources":["../../src/plugins/vite-server-only.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,gCAAgC,CAAA;AAEvC,oGAAoG;AACpG,sDAAsD;AACtD,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,yBAAyB,EAAE,CAAA;AAejF,oFAAoF;AACpF,MAAM,IAAI,GAAG,CAAC,EAAU,EAAU,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;AAE1E;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB;IACjC,OAAO;QACL,IAAI,EAAE,yBAAyB;QAC/B,OAAO,EAAE,KAAK;QACd,mGAAmG;QACnG,kEAAkE;QAClE,kBAAkB,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,KAAK,QAAQ;QAClE,SAAS,CAAC,IAAI,EAAE,EAAE,EAAE,OAAO;YACzB,mFAAmF;YACnF,IAAI,OAAO,EAAE,GAAG,KAAK,IAAI;gBAAE,OAAO,IAAI,CAAA;YACtC,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,CAAA;YACrB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAA;YAC/C,kGAAkG;YAClG,oDAAoD;YACpD,OAAO,EAAE,IAAI,EAAE,yBAAyB,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,CAAA;QAC7D,CAAC;KACF,CAAA;AACH,CAAC"}