@nifrajs/web-react 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nifra Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @nifrajs/web-react
+
+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`.
+
+## Install
+
+```sh
+bun add @nifrajs/web-react
+```
+
+## Docs
+
+- Reference: <https://nifra.dev/docs>
+- AI-readable: <https://nifra.dev/llms.txt>
+
+MIT

package/dist/await.d.ts

@@ -0,0 +1,29 @@
+import type { Deferred } from "@nifrajs/web";
+/**
+ * `@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`).
+ *
+ * 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).
+ */
+import { type ReactNode } from "react";
+export interface AwaitProps<T> {
+    /** A `Deferred<T>` from a loader's `defer(...)`, or an already-resolved value (client nav). */
+    readonly resolve: Deferred<T> | T;
+    readonly fallback?: ReactNode;
+    /** Rendered if the deferred rejects (the streamed `__nifraReject`). Without it the error
+     * propagates to the nearest error boundary. */
+    readonly errorFallback?: (error: unknown) => ReactNode;
+    readonly children: (value: T) => ReactNode;
+}
+/**
+ * Render deferred loader data: show `fallback` until the `Deferred` settles (streamed in by the
+ * server), then `children(value)`. An already-resolved `resolve` (a client navigation awaited it)
+ * renders immediately. Pairs with a loader's `defer(...)`.
+ */
+export declare function Await<T>(props: AwaitProps<T>): ReactNode;
+//# sourceMappingURL=await.d.ts.map

package/dist/await.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"await.d.ts","sourceRoot":"","sources":["../src/await.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C;;;;;;;;;;GAUG;AACH,OAAO,EAA4B,KAAK,SAAS,EAAiB,MAAM,OAAO,CAAA;AAE/E,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,+FAA+F;IAC/F,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;IACjC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;IAC7B;mDAC+C;IAC/C,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,SAAS,CAAA;IACtD,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,SAAS,CAAA;CAC3C;AAiCD;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAcxD"}

package/dist/await.js

@@ -0,0 +1,50 @@
+/**
+ * `@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`).
+ *
+ * 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).
+ */
+import { Component, createElement, Suspense, use } from "react";
+// Catches the rejection `use()` throws when the deferred rejects → renders `errorFallback`. A class
+// is required (React error boundaries have no hook form). Local so `<Await>` is self-contained.
+class AwaitBoundary extends Component {
+    state = { caught: false, error: undefined };
+    static getDerivedStateFromError(error) {
+        return { caught: true, error };
+    }
+    render() {
+        return this.state.caught ? this.props.fallback(this.state.error) : this.props.children;
+    }
+}
+function isDeferred(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.__nifra_deferred === true);
+}
+// Type-erased (non-generic) so `createElement` infers cleanly; `Await<T>` casts at the call site.
+function Resolved(props) {
+    return props.render(use(props.marker.promise));
+}
+/**
+ * Render deferred loader data: show `fallback` until the `Deferred` settles (streamed in by the
+ * server), then `children(value)`. An already-resolved `resolve` (a client navigation awaited it)
+ * renders immediately. Pairs with a loader's `defer(...)`.
+ */
+export function Await(props) {
+    if (!isDeferred(props.resolve))
+        return props.children(props.resolve);
+    const suspense = createElement(Suspense, { fallback: props.fallback }, createElement(Resolved, {
+        marker: props.resolve,
+        // safe: the registry promise resolves to T; Resolved is type-erased to satisfy createElement.
+        render: props.children,
+    }));
+    return props.errorFallback
+        ? createElement(AwaitBoundary, { fallback: props.errorFallback }, suspense)
+        : suspense;
+}
+//# sourceMappingURL=await.js.map

package/dist/await.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"await.js","sourceRoot":"","sources":["../src/await.ts"],"names":[],"mappings":"AACA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAkB,QAAQ,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAY/E,oGAAoG;AACpG,gGAAgG;AAChG,MAAM,aAAc,SAAQ,SAG3B;IACU,KAAK,GAAwC,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAA;IACzF,MAAM,CAAC,wBAAwB,CAAC,KAAc;QAC5C,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,CAAA;IAChC,CAAC;IACQ,MAAM;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAA;IACxF,CAAC;CACF;AAED,SAAS,UAAU,CAAI,KAAsB;IAC3C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACb,KAAwC,CAAC,gBAAgB,KAAK,IAAI,CACpE,CAAA;AACH,CAAC;AAED,kGAAkG;AAClG,SAAS,QAAQ,CAAC,KAGjB;IACC,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAA;AAChD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,KAAK,CAAI,KAAoB;IAC3C,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC;QAAE,OAAO,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;IACpE,MAAM,QAAQ,GAAG,aAAa,CAC5B,QAAQ,EACR,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,EAC5B,aAAa,CAAC,QAAQ,EAAE;QACtB,MAAM,EAAE,KAAK,CAAC,OAAO;QACrB,8FAA8F;QAC9F,MAAM,EAAE,KAAK,CAAC,QAAyC;KACxD,CAAC,CACH,CAAA;IACD,OAAO,KAAK,CAAC,aAAa;QACxB,CAAC,CAAC,aAAa,CAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,aAAa,EAAE,EAAE,QAAQ,CAAC;QAC3E,CAAC,CAAC,QAAQ,CAAA;AACd,CAAC"}

package/dist/client.d.ts

@@ -0,0 +1,12 @@
+import type { MountRouterOptions, 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
+ * without a full reload. `getServerSnapshot` (3rd arg) returns the initial state, matching the
+ * SSR markup on hydration.
+ */
+export declare function mountRouter(options: MountRouterOptions): void;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +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,CAc7D"}

package/dist/client.js

@@ -0,0 +1,39 @@
+/**
+ * @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.
+ */
+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
+// 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`. */
+export function hydrate(chain, props, container) {
+    hydrateRoot(container, compose(chain, props));
+}
+/**
+ * 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
+ * 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;
+    setMountedRouter(router); // expose it to useFetcher/useFetchers (same page, client-only)
+    const Router = () => {
+        const state = useSyncExternalStore(router.subscribe, router.snapshot, router.snapshot);
+        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.
+            ...(state.submission ? { submission: state.submission } : {}),
+        });
+    };
+    hydrateRoot(container, createElement(Router));
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +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,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

@@ -0,0 +1,9 @@
+import type { RenderProps } from "@nifrajs/web";
+import { type ReactNode } from "react";
+/**
+ * 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).
+ */
+export declare function compose(chain: readonly unknown[], props: RenderProps): ReactNode;
+//# sourceMappingURL=compose.d.ts.map

package/dist/compose.d.ts.map

@@ -0,0 +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;AAE7E;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,SAAS,CAQhF"}

package/dist/compose.js

@@ -0,0 +1,16 @@
+import { createElement } from "react";
+/**
+ * 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).
+ */
+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);
+    }
+    return node;
+}
+//# sourceMappingURL=compose.js.map

package/dist/compose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAA0C,MAAM,OAAO,CAAA;AAE7E;;;;GAIG;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,IAAI,CAAA;AACb,CAAC"}

package/dist/content.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@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.
+ */
+import { type ComponentPropsWithoutRef, type ElementType, type ReactElement } from "react";
+export interface ContentProps extends Omit<ComponentPropsWithoutRef<"div">, "dangerouslySetInnerHTML" | "children"> {
+    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */
+    readonly html: string;
+    /** Wrapper element (default `"div"`). */
+    readonly as?: ElementType;
+}
+/** Render trusted HTML into a wrapper element. Extra props (`className`, `id`, `style`, …) pass through. */
+export declare function Content({ html, as, ...rest }: ContentProps): ReactElement;
+//# sourceMappingURL=content.d.ts.map

package/dist/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../src/content.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,KAAK,wBAAwB,EAE7B,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,OAAO,CAAA;AAEd,MAAM,WAAW,YACf,SAAQ,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,EAAE,yBAAyB,GAAG,UAAU,CAAC;IACrF,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,CAAC,EAAE,WAAW,CAAA;CAC1B;AAED,4GAA4G;AAC5G,wBAAgB,OAAO,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,YAAY,GAAG,YAAY,CAEzE"}

package/dist/content.js

@@ -0,0 +1,14 @@
+/**
+ * `@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.
+ */
+import { createElement, } from "react";
+/** Render trusted HTML into a wrapper element. Extra props (`className`, `id`, `style`, …) pass through. */
+export function Content({ html, as, ...rest }) {
+    return createElement(as ?? "div", { ...rest, dangerouslySetInnerHTML: { __html: html } });
+}
+//# sourceMappingURL=content.js.map

package/dist/content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.js","sourceRoot":"","sources":["../src/content.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAEL,aAAa,GAGd,MAAM,OAAO,CAAA;AAUd,4GAA4G;AAC5G,MAAM,UAAU,OAAO,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,IAAI,EAAgB;IACzD,OAAO,aAAa,CAAC,EAAE,IAAI,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,uBAAuB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAA;AAC3F,CAAC"}

package/dist/error.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export declare function errorBoundary(fallback: unknown): unknown;
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAmBxD"}

package/dist/error.js

@@ -0,0 +1,32 @@
+/**
+ * `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).
+ */
+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.
+ */
+export function errorBoundary(fallback) {
+    return class NifraErrorBoundary extends Component {
+        constructor(props) {
+            super(props);
+            this.state = { error: null };
+        }
+        static getDerivedStateFromError(error) {
+            return { error };
+        }
+        render() {
+            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.
+            const Fallback = fallback;
+            return createElement(Fallback, { data: { name: error.name, message: error.message } });
+        }
+    };
+}
+//# sourceMappingURL=error.js.map

package/dist/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,SAAS,EAAE,aAAa,EAA0C,MAAM,OAAO,CAAA;AAExF;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,QAAiB;IAG7C,OAAO,MAAM,kBAAmB,SAAQ,SAAuB;QAC7D,YAAY,KAAY;YACtB,KAAK,CAAC,KAAK,CAAC,CAAA;YACZ,IAAI,CAAC,KAAK,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,CAAA;QAC9B,CAAC;QACD,MAAM,CAAC,wBAAwB,CAAC,KAAY;YAC1C,OAAO,EAAE,KAAK,EAAE,CAAA;QAClB,CAAC;QACQ,MAAM;YACb,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAA;YAC5B,IAAI,KAAK,KAAK,IAAI;gBAAE,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAA;YAC9C,4FAA4F;YAC5F,MAAM,QAAQ,GAAG,QAA0E,CAAA;YAC3F,OAAO,aAAa,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;QACxF,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/fetcher.d.ts

@@ -0,0 +1,23 @@
+import type { ClientRouter, Fetcher, FetcherState } from "@nifrajs/web";
+/** 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 {
+    /** Load a route path's loader data into this fetcher (concurrent; doesn't touch the active view). */
+    readonly load: (path: string) => Promise<void>;
+    /** Submit an action into this fetcher (concurrent); honors `X-Nifra-Revalidate`. */
+    readonly submit: (action: string, body: NonNullable<RequestInit["body"]>) => Promise<void>;
+}
+/**
+ * Subscribe to the independent fetcher for `key` (created lazily, stable across renders). Returns its
+ * state (`pending`/`data`/`actionData`/`submission`) + `load`/`submit`. Multiple `useFetcher` calls
+ * with different keys run concurrently without disturbing the active route or each other.
+ */
+export declare function useFetcher(key: string): FetcherHandle;
+/**
+ * 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.
+ */
+export declare function useFetchers(): readonly Fetcher[];
+//# sourceMappingURL=fetcher.d.ts.map

package/dist/fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher.d.ts","sourceRoot":"","sources":["../src/fetcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAmBvE,oGAAoG;AACpG,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,CAEvE;AASD,qFAAqF;AACrF,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD,qGAAqG;IACrG,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9C,oFAAoF;IACpF,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3F;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAQrD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,SAAS,OAAO,EAAE,CAMhD"}

package/dist/fetcher.js

@@ -0,0 +1,45 @@
+/**
+ * `@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
+ * `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.
+ */
+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. */
+export function setMountedRouter(router) {
+    mountedRouter = router;
+}
+// Stable idle values for the server / pre-mount snapshot (stable refs → no `useSyncExternalStore`
+// loop, no hydration mismatch).
+const IDLE = { pending: false, data: undefined };
+const NO_FETCHERS = [];
+const noopSubscribe = () => () => { };
+const noopAsync = async () => { };
+/**
+ * Subscribe to the independent fetcher for `key` (created lazily, stable across renders). Returns its
+ * state (`pending`/`data`/`actionData`/`submission`) + `load`/`submit`. Multiple `useFetcher` calls
+ * with different keys run concurrently without disturbing the active route or each other.
+ */
+export function useFetcher(key) {
+    const fetcher = mountedRouter?.fetcher(key);
+    const state = useSyncExternalStore(fetcher?.subscribe ?? noopSubscribe, fetcher?.snapshot ?? (() => IDLE), () => IDLE);
+    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
+ * each entry's `.snapshot()` for its state. Re-renders whenever any fetcher transitions or a new one
+ * is created.
+ */
+export function useFetchers() {
+    return useSyncExternalStore(mountedRouter?.subscribeFetchers ?? noopSubscribe, mountedRouter?.fetchers ?? (() => NO_FETCHERS), () => NO_FETCHERS);
+}
+//# sourceMappingURL=fetcher.js.map

package/dist/fetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher.js","sourceRoot":"","sources":["../src/fetcher.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,OAAO,CAAA;AAE5C,iGAAiG;AACjG,yFAAyF;AACzF,IAAI,aAAuC,CAAA;AAE3C,oGAAoG;AACpG,MAAM,UAAU,gBAAgB,CAAC,MAAgC;IAC/D,aAAa,GAAG,MAAM,CAAA;AACxB,CAAC;AAED,kGAAkG;AAClG,gCAAgC;AAChC,MAAM,IAAI,GAAiB,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,CAAA;AAC9D,MAAM,WAAW,GAAuB,EAAE,CAAA;AAC1C,MAAM,aAAa,GAAG,GAAiB,EAAE,CAAC,GAAG,EAAE,GAAE,CAAC,CAAA;AAClD,MAAM,SAAS,GAAG,KAAK,IAAmB,EAAE,GAAE,CAAC,CAAA;AAU/C;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,GAAW;IACpC,MAAM,OAAO,GAAG,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;IAC3C,MAAM,KAAK,GAAG,oBAAoB,CAChC,OAAO,EAAE,SAAS,IAAI,aAAa,EACnC,OAAO,EAAE,QAAQ,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,EACjC,GAAG,EAAE,CAAC,IAAI,CACX,CAAA;IACD,OAAO,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,SAAS,EAAE,CAAA;AAC7F,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW;IACzB,OAAO,oBAAoB,CACzB,aAAa,EAAE,iBAAiB,IAAI,aAAa,EACjD,aAAa,EAAE,QAAQ,IAAI,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,EAC9C,GAAG,EAAE,CAAC,WAAW,CAClB,CAAA;AACH,CAAC"}

package/dist/i18n.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@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` +
+ * `@nifrajs/i18n`; no JSX (the package builds with plain `tsc`).
+ */
+import { type Formatter, type Messages } from "@nifrajs/i18n";
+import { type ReactNode } from "react";
+export interface I18nProviderProps {
+    readonly locale: string;
+    readonly messages: Messages;
+    readonly children?: ReactNode;
+}
+/** Provide a {@link Formatter} (built from `locale` + `messages`) to the subtree. Memoized on
+ * `locale`/`messages`, so switching locale rebuilds it and re-renders consumers. */
+export declare function I18nProvider(props: I18nProviderProps): ReactNode;
+/** Read the current {@link Formatter} (`{ locale, t, n, d }`). Throws if no `<I18nProvider>` is above. */
+export declare function useT(): Formatter;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAmB,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC9E,OAAO,EAAgC,KAAK,SAAS,EAAuB,MAAM,OAAO,CAAA;AAIzF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAC9B;AAED;oFACoF;AACpF,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,SAAS,CAMhE;AAED,0GAA0G;AAC1G,wBAAgB,IAAI,IAAI,SAAS,CAMhC"}

package/dist/i18n.js

@@ -0,0 +1,25 @@
+/**
+ * `@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` +
+ * `@nifrajs/i18n`; no JSX (the package builds with plain `tsc`).
+ */
+import { createFormatter } from "@nifrajs/i18n";
+import { createContext, createElement, useContext, useMemo } from "react";
+const I18nContext = createContext(null);
+/** Provide a {@link Formatter} (built from `locale` + `messages`) to the subtree. Memoized on
+ * `locale`/`messages`, so switching locale rebuilds it and re-renders consumers. */
+export function I18nProvider(props) {
+    const formatter = useMemo(() => createFormatter(props.locale, props.messages), [props.locale, props.messages]);
+    return createElement(I18nContext.Provider, { value: formatter }, props.children);
+}
+/** Read the current {@link Formatter} (`{ locale, t, n, d }`). Throws if no `<I18nProvider>` is above. */
+export function useT() {
+    const formatter = useContext(I18nContext);
+    if (formatter === null) {
+        throw new Error("[nifra/web-react] useT() must be used within an <I18nProvider>");
+    }
+    return formatter;
+}
+//# sourceMappingURL=i18n.js.map

package/dist/i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.js","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,eAAe,EAAiC,MAAM,eAAe,CAAA;AAC9E,OAAO,EAAE,aAAa,EAAE,aAAa,EAAkB,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAEzF,MAAM,WAAW,GAAG,aAAa,CAAmB,IAAI,CAAC,CAAA;AAQzD;oFACoF;AACpF,MAAM,UAAU,YAAY,CAAC,KAAwB;IACnD,MAAM,SAAS,GAAG,OAAO,CACvB,GAAG,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,EACnD,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,CAC/B,CAAA;IACD,OAAO,aAAa,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AAClF,CAAC;AAED,0GAA0G;AAC1G,MAAM,UAAU,IAAI;IAClB,MAAM,SAAS,GAAG,UAAU,CAAC,WAAW,CAAC,CAAA;IACzC,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAA;IACnF,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC"}

package/dist/image.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `@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`
+ * (an image CDN); nifra bundles no codec. Imports only `react` + `@nifrajs/image`; no JSX.
+ */
+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. */
+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). */
+    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). */
+    readonly [key: `data-${string}`]: string | number | boolean | undefined;
+}
+/**
+ * Render a responsive, CLS-safe `<img>`. `width`+`height` are required (reserve layout space);
+ * `priority` marks the LCP image (`eager` + `fetchpriority="high"`). Extra DOM props pass through.
+ */
+export declare function Image(props: ImageComponentProps): ReactElement;
+export {};
+//# sourceMappingURL=image.d.ts.map

package/dist/image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../src/image.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAgB,MAAM,gBAAgB,CAAA;AAChF,OAAO,EAAE,KAAK,wBAAwB,EAAiB,KAAK,YAAY,EAAE,MAAM,OAAO,CAAA;AAEvF,4FAA4F;AAC5F,KAAK,aAAa,GACd,KAAK,GACL,QAAQ,GACR,OAAO,GACP,OAAO,GACP,QAAQ,GACR,KAAK,GACL,SAAS,GACT,UAAU,GACV,eAAe,CAAA;AAEnB,MAAM,WAAW,mBACf,SAAQ,UAAU,EAChB,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,MAAM,UAAU,CAAC;IACzE,+FAA+F;IAC/F,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;IAC7B;qDACiD;IACjD,QAAQ,EAAE,GAAG,EAAE,QAAQ,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAA;CACxE;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,mBAAmB,GAAG,YAAY,CAM9D"}

package/dist/image.js

@@ -0,0 +1,21 @@
+/**
+ * `@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`
+ * (an image CDN); nifra bundles no codec. Imports only `react` + `@nifrajs/image`; no JSX.
+ */
+import { resolveImage } from "@nifrajs/image";
+import { createElement } from "react";
+/**
+ * Render a responsive, CLS-safe `<img>`. `width`+`height` are required (reserve layout space);
+ * `priority` marks the LCP image (`eager` + `fetchpriority="high"`). Extra DOM props pass through.
+ */
+export function Image(props) {
+    // Strip the nifra-only props (not valid DOM attributes) before forwarding the rest to <img>.
+    const { loader, widths, quality, priority, ...rest } = props;
+    const resolved = resolveImage(props, loader);
+    // `resolved` wins over the raw src/width/height/alt/sizes/loading still present in `rest`.
+    return createElement("img", { ...rest, ...resolved });
+}
+//# sourceMappingURL=image.js.map

package/dist/image.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","sourceRoot":"","sources":["../src/image.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAqC,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAChF,OAAO,EAAiC,aAAa,EAAqB,MAAM,OAAO,CAAA;AAwBvF;;;GAGG;AACH,MAAM,UAAU,KAAK,CAAC,KAA0B;IAC9C,6FAA6F;IAC7F,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAA;IAC5D,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;IAC5C,2FAA2F;IAC3F,OAAO,aAAa,CAAC,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,GAAG,QAAQ,EAAE,CAAC,CAAA;AACvD,CAAC"}

package/dist/index.d.ts

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

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AASjD,6EAA6E;AAC7E,eAAO,MAAM,YAAY,EAAE,aAmB1B,CAAA"}

package/dist/index.js

@@ -0,0 +1,29 @@
+/**
+ * @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.
+ */
+import { renderToString as reactRenderToString, renderToReadableStream } from "react-dom/server";
+import { compose } from "./compose.js";
+/** 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
+    // streaming machinery is the heaviest. A page that defer()s/Suspends takes `renderToStream` below.
+    renderToString(chain, props) {
+        return reactRenderToString(compose(chain, props));
+    },
+    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
+        // the document tail. React's default `onError` logs to console.error (errors aren't swallowed).
+        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.
+    hydrationHead() {
+        return "";
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA;;;;GAIG;AACH,OAAO,EAAE,cAAc,IAAI,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAA;AAChG,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,6EAA6E;AAC7E,MAAM,CAAC,MAAM,YAAY,GAAkB;IACzC,gGAAgG;IAChG,kGAAkG;IAClG,oGAAoG;IACpG,mGAAmG;IACnG,cAAc,CAAC,KAAK,EAAE,KAAK;QACzB,OAAO,mBAAmB,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;IACnD,CAAC;IACD,cAAc,CAAC,KAAK,EAAE,KAAK;QACzB,qFAAqF;QACrF,+FAA+F;QAC/F,gGAAgG;QAChG,OAAO,sBAAsB,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;IACtD,CAAC;IACD,qFAAqF;IACrF,sFAAsF;IACtF,aAAa;QACX,OAAO,EAAE,CAAA;IACX,CAAC;CACF,CAAA"}

package/dist/island.d.ts

@@ -0,0 +1,27 @@
+import type { IslandStrategy } from "@nifrajs/web/islands";
+/**
+ * `@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`,
+ * 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
+ * island bundle (your enhancers + the tiny runtime) loads via the route's `islandScripts`. The island's
+ * SSR markup is real content (works with JS off); the enhancer upgrades it when it loads.
+ */
+import { type ReactNode } from "react";
+export interface IslandProps {
+    /** Stable id matching the key in the client's `mountIslands({ <id>: enhancer })`. */
+    readonly id: string;
+    /** Serializable props handed to the enhancer (JSON-encoded inline in `data-props`; no closures). */
+    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. */
+    readonly children?: ReactNode;
+}
+/** Render a `<nifra-island>` marker around server-rendered `children`. The client enhancer mounts the
+ * interactivity (see `mountIslands`). Props are JSON-encoded into `data-props`; React escapes the
+ * attribute value and the client reads the decoded `dataset.props`. */
+export declare function Island({ id, props, strategy, children }: IslandProps): ReactNode;
+//# sourceMappingURL=island.d.ts.map

package/dist/island.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"island.d.ts","sourceRoot":"","sources":["../src/island.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D;;;;;;;;;GASG;AACH,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAErD,MAAM,WAAW,WAAW;IAC1B,qFAAqF;IACrF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,oGAAoG;IACpG,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;IACxB,wGAAwG;IACxG,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAA;IAClC,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAC9B;AAED;;uEAEuE;AACvE,wBAAgB,MAAM,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,QAAiB,EAAE,QAAQ,EAAE,EAAE,WAAW,GAAG,SAAS,CAWzF"}