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

package/dist/await.d.ts

@@ -0,0 +1,18 @@
+import type { Deferred } from "@nifrajs/web";
+import type { ComponentChildren, VNode } from "preact";
+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?: ComponentChildren;
+    /** Rendered if the deferred rejects (the streamed `__nifraReject`). Without it the error
+     * propagates to the nearest error boundary. */
+    readonly errorFallback?: (error: unknown) => ComponentChildren;
+    readonly children: (value: T) => ComponentChildren;
+}
+/**
+ * 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>): VNode | ComponentChildren;
+//# 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,OAAO,KAAK,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAgBtD,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,iBAAiB,CAAA;IACrC;mDAC+C;IAC/C,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,iBAAiB,CAAA;IAC9D,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,iBAAiB,CAAA;CACnD;AAiCD;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,iBAAiB,CAcxE"}

package/dist/await.js

@@ -0,0 +1,52 @@
+/**
+ * `@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`).
+ *
+ * Preact's compat has no React 19 `use()` hook, so `readDeferred` (in `./read-deferred`) reads the
+ * React-style thenable the core tags (`status`/`value`/`reason`, via the streamed
+ * `__nifraResolve`/`__nifraReject`) synchronously: on the client a settled deferred renders its content
+ * directly into the boundary the server streamed (no re-suspend, no fallback flash). While pending it
+ * throws the promise so `<Suspense>` streams the fallback (server) / shows it until settle (client).
+ */
+import { Component, createElement, Suspense } from "preact/compat";
+import { readDeferred } from "./read-deferred.js";
+// Catches the rejection `readDeferred` throws when the deferred rejects → renders `errorFallback`. A
+// class is required (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(readDeferred(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":"AAEA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAClE,OAAO,EAAE,YAAY,EAAiB,MAAM,oBAAoB,CAAA;AAYhE,qGAAqG;AACrG,gGAAgG;AAChG,MAAM,aAAc,SAAQ,SAG3B;IACU,KAAK,GAAwC,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAA;IACzF,MAAM,CAAU,wBAAwB,CAAC,KAAc;QACrD,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,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,OAA4B,CAAC,CAAC,CAAA;AAC9E,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,QAAiD;KAChE,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 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
+ * 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 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;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"}

package/dist/client.js

@@ -0,0 +1,40 @@
+/**
+ * @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
+ * out of the client bundle.
+ */
+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
+// 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`. */
+export function hydrate(chain, props, container) {
+    preactHydrate(compose(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
+ * 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;
+    setMountedRouter(router); // expose it to useFetcher/useFetchers (same page, client-only)
+    const Router = () => {
+        const state = useSyncExternalStore(router.subscribe, 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 } : {}),
+        });
+    };
+    preactHydrate(h(Router, null), container);
+}
+//# 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;;;;;;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"}

package/dist/compose.d.ts

@@ -0,0 +1,10 @@
+import type { RenderProps } from "@nifrajs/web";
+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`.
+ */
+export declare function compose(chain: readonly unknown[], props: RenderProps): VNode;
+//# 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,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"}

package/dist/compose.js

@@ -0,0 +1,22 @@
+import { h } 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`.
+ */
+export function compose(chain, props) {
+    const last = chain.length - 1;
+    // The chain holds opaque framework components; cast at this plumbing boundary. The page gets the
+    // 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).
+    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);
+    }
+    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,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"}

package/dist/content.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@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.
+ */
+import { type JSX, type VNode } from "preact";
+export interface ContentProps extends Omit<JSX.HTMLAttributes<HTMLElement>, "dangerouslySetInnerHTML"> {
+    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */
+    readonly html: string;
+    /** Wrapper element (default `"div"`). */
+    readonly as?: string;
+}
+/** Render trusted HTML into a wrapper element. Extra props (`class`, `id`, `style`, …) pass through. */
+export declare function Content({ html, as, ...rest }: ContentProps): VNode;
+//# 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,EAAiB,KAAK,GAAG,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAA;AAE5D,MAAM,WAAW,YACf,SAAQ,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,EAAE,yBAAyB,CAAC;IACxE,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,wGAAwG;AACxG,wBAAgB,OAAO,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,EAAE,YAAY,GAAG,KAAK,CAQlE"}

package/dist/content.js

@@ -0,0 +1,20 @@
+/**
+ * `@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.
+ */
+import { createElement } from "preact";
+/** Render trusted HTML into a wrapper element. Extra props (`class`, `id`, `style`, …) pass through. */
+export function Content({ html, as, ...rest }) {
+    // Typed intermediate (like `<Image>`) keeps the inferred `VNode` generic stable under
+    // exactOptionalPropertyTypes (a bare object literal infers an over-specific, non-assignable VNode).
+    const props = {
+        ...rest,
+        dangerouslySetInnerHTML: { __html: html },
+    };
+    return createElement(as ?? "div", props);
+}
+//# 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,EAAE,aAAa,EAAwB,MAAM,QAAQ,CAAA;AAU5D,wGAAwG;AACxG,MAAM,UAAU,OAAO,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,IAAI,EAAgB;IACzD,sFAAsF;IACtF,oGAAoG;IACpG,MAAM,KAAK,GAAoC;QAC7C,GAAG,IAAI;QACP,uBAAuB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;KAC1C,CAAA;IACD,OAAO,aAAa,CAAC,EAAE,IAAI,KAAK,EAAE,KAAK,CAAC,CAAA;AAC1C,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 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).
+ */
+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.
+ */
+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,EAA0B,aAAa,EAA0B,MAAM,QAAQ,CAAA;AAEjG;;;;;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,CAAU,wBAAwB,CAAC,KAAY;YACnD,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;AAoBvE,oGAAoG;AACpG,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,CAEvE;AAWD,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,CAOrD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,SAAS,OAAO,EAAE,CAKhD"}

package/dist/fetcher.js

@@ -0,0 +1,48 @@
+/**
+ * `@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
+ * `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.
+ */
+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. */
+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 () => { };
+const idleSnapshot = () => IDLE;
+const noFetchers = () => NO_FETCHERS;
+/**
+ * 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 ?? idleSnapshot);
+    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 ?? noFetchers);
+}
+//# 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;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AAEpD,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;AAC/C,MAAM,YAAY,GAAG,GAAiB,EAAE,CAAC,IAAI,CAAA;AAC7C,MAAM,UAAU,GAAG,GAAuB,EAAE,CAAC,WAAW,CAAA;AAUxD;;;;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,YAAY,CAClC,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,UAAU,CACtC,CAAA;AACH,CAAC"}

package/dist/i18n.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@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.
+ */
+import { type Formatter, type Messages } from "@nifrajs/i18n";
+import { type ComponentChildren, type VNode } from "preact";
+export interface I18nProviderProps {
+    readonly locale: string;
+    readonly messages: Messages;
+    readonly children?: ComponentChildren;
+}
+/** 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): VNode;
+/** 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,EAAE,KAAK,iBAAiB,EAAgC,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAA;AAezF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CACtC;AAED;oFACoF;AACpF,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,KAAK,CAM5D;AAED,0GAA0G;AAC1G,wBAAgB,IAAI,IAAI,SAAS,CAMhC"}

package/dist/i18n.js

@@ -0,0 +1,31 @@
+/**
+ * `@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.
+ */
+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 `{}`.
+// 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;
+/** 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 createProvider(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-preact] 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,EAA0B,aAAa,EAAE,aAAa,EAAc,MAAM,QAAQ,CAAA;AACzF,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAElD,MAAM,WAAW,GAAG,aAAa,CAAmB,IAAI,CAAC,CAAA;AAEzD,mGAAmG;AACnG,uGAAuG;AACvG,uGAAuG;AACvG,6FAA6F;AAC7F,MAAM,cAAc,GAAG,aAIb,CAAA;AAQV;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,cAAc,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AACnF,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,iEAAiE,CAAC,CAAA;IACpF,CAAC;IACD,OAAO,SAAS,CAAA;AAClB,CAAC"}

package/dist/image.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `@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
+ * 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. */
+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). */
+    readonly loader?: ImageLoader;
+}
+/**
+ * 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): VNode;
+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,EAA6B,MAAM,gBAAgB,CAAA;AAC7F,OAAO,EAAK,KAAK,GAAG,EAAE,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAA;AAEhD,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,GAAG,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,MAAM,UAAU,CAAC;IACtE,+FAA+F;IAC/F,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAC9B;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,mBAAmB,GAAG,KAAK,CAQvD"}

package/dist/image.js

@@ -0,0 +1,23 @@
+/**
+ * `@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
+ * 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 { resolveImage, toHtmlAttrs } from "@nifrajs/image";
+import { h } from "preact";
+/**
+ * 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 attrs = toHtmlAttrs(resolveImage(props, loader));
+    // `attrs` wins over the raw src/width/height/alt/sizes/loading still present in `rest`. The typed
+    // local pins Preact's `h` to its string-tag overload (spreads skip excess-property checks).
+    const imgProps = { ...rest, ...attrs };
+    return h("img", imgProps);
+}
+//# 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,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC7F,OAAO,EAAE,CAAC,EAAwB,MAAM,QAAQ,CAAA;AAqBhD;;;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,KAAK,GAAG,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAA;IACtD,kGAAkG;IAClG,4FAA4F;IAC5F,MAAM,QAAQ,GAAiC,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,EAAE,CAAA;IACpE,OAAO,CAAC,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;AAC3B,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { RenderAdapter } from "@nifrajs/web";
+/** The Preact server render adapter — pass to @nifrajs/web's `renderPage`. */
+export declare const preactAdapter: 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;AAYjD,8EAA8E;AAC9E,eAAO,MAAM,aAAa,EAAE,aAgB3B,CAAA"}

package/dist/index.js

@@ -0,0 +1,29 @@
+/**
+ * @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
+ * (contrast `@nifrajs/web-solid`'s Babel plugin).
+ */
+import { renderToString as preactRenderToString } from "preact-render-to-string";
+import { renderToReadableStream } from "preact-render-to-string/stream";
+import { compose } from "./compose.js";
+/** 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.
+    renderToString(chain, props) {
+        return preactRenderToString(compose(chain, props));
+    },
+    renderToStream(chain, props) {
+        // `renderToReadableStream` yields a Web ReadableStream<Uint8Array>; <Suspense> boundaries
+        // (preact/compat) stream as they resolve, mirroring the React adapter.
+        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).
+    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;;;;;;GAMG;AACH,OAAO,EAAE,cAAc,IAAI,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAChF,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAA;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,8EAA8E;AAC9E,MAAM,CAAC,MAAM,aAAa,GAAkB;IAC1C,iGAAiG;IACjG,gGAAgG;IAChG,cAAc,CAAC,KAAK,EAAE,KAAK;QACzB,OAAO,oBAAoB,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;IACpD,CAAC;IACD,cAAc,CAAC,KAAK,EAAE,KAAK;QACzB,0FAA0F;QAC1F,uEAAuE;QACvE,OAAO,sBAAsB,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;IACtD,CAAC;IACD,iGAAiG;IACjG,kGAAkG;IAClG,aAAa;QACX,OAAO,EAAE,CAAA;IACX,CAAC;CACF,CAAA"}

package/dist/query.d.ts

@@ -0,0 +1,17 @@
+import { type QueryClient, type QueryState } from "@nifrajs/web";
+/** Access the query client to imperatively `invalidateQueries(keyOrPrefix)` (e.g. after a mutation). */
+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). */
+    readonly isPending: boolean;
+    /** Force a refetch (ignores `staleTime`). */
+    readonly refetch: () => Promise<T>;
+}
+/**
+ * Subscribe to the keyed query for `key`, fetched via `fn`. Returns `{ status, data, error, isFetching,
+ * updatedAt, isPending, refetch }`. Concurrent `useQuery`s with the same key share one cache entry +
+ * one in-flight fetch (dedup). Refetches on mount and when the key changes; SSR-idle.
+ */
+export declare function useQuery<T>(key: unknown, fn: () => Promise<T>): UseQueryResult<T>;
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAEhB,KAAK,UAAU,EAChB,MAAM,cAAc,CAAA;AAqBrB,wGAAwG;AACxG,wBAAgB,cAAc,IAAI,IAAI,CAAC,WAAW,EAAE,mBAAmB,CAAC,CAEvE;AAgBD,0EAA0E;AAC1E,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;IACtD,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAA;CACnC;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAejF"}