@nifrajs/web-solid 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-solid
+
+Solid render adapter for @nifrajs/web — SSR + hydration + the Solid Babel 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-solid
+```
+
+## 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-solid/await` — the `<Await>` primitive for deferred loader data (`defer()`). Isomorphic
+ * and imports only `solid-js` + a type from `@nifrajs/web` (never `solid-js/web`'s server or the Babel
+ * plugin), so route components can use it without dragging server/build code into the client bundle.
+ * No JSX (the package builds with plain `tsc`).
+ *
+ * Solid streams the boundary natively: on the server `createResource` awaits the deferred promise,
+ * `<Suspense>` flushes the fallback then the resolved content mid-stream, and Solid serializes the
+ * resource value into its hydration data — so the client hydrates the streamed content without a
+ * re-fetch (it reads `_$HY`, not the registry promise).
+ */
+import { type JSX } from "solid-js";
+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?: JSX.Element;
+    /** Rendered if the deferred rejects. Without it the error propagates to the nearest
+     * `<ErrorBoundary>`. */
+    readonly errorFallback?: (error: unknown) => JSX.Element;
+    readonly children: (value: T) => JSX.Element;
+}
+/**
+ * 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>): JSX.Element;
+//# 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,EAAmC,KAAK,GAAG,EAAY,MAAM,UAAU,CAAA;AAE9E,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,GAAG,CAAC,OAAO,CAAA;IAC/B;4BACwB;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,GAAG,CAAC,OAAO,CAAA;IACxD,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,GAAG,CAAC,OAAO,CAAA;CAC7C;AAUD;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,CAoB1D"}

package/dist/await.js

@@ -0,0 +1,46 @@
+/**
+ * `@nifrajs/web-solid/await` — the `<Await>` primitive for deferred loader data (`defer()`). Isomorphic
+ * and imports only `solid-js` + a type from `@nifrajs/web` (never `solid-js/web`'s server or the Babel
+ * plugin), so route components can use it without dragging server/build code into the client bundle.
+ * No JSX (the package builds with plain `tsc`).
+ *
+ * Solid streams the boundary natively: on the server `createResource` awaits the deferred promise,
+ * `<Suspense>` flushes the fallback then the resolved content mid-stream, and Solid serializes the
+ * resource value into its hydration data — so the client hydrates the streamed content without a
+ * re-fetch (it reads `_$HY`, not the registry promise).
+ */
+import { createComponent, createResource, Suspense } from "solid-js";
+function isDeferred(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.__nifra_deferred === true);
+}
+/**
+ * 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 marker = props.resolve;
+    const [data] = createResource(() => marker.promise);
+    return createComponent(Suspense, {
+        get fallback() {
+            return props.fallback;
+        },
+        get children() {
+            // Errored? Render `errorFallback`, else rethrow to an outer <ErrorBoundary>. Check `data.error`
+            // BEFORE `data()` (which would rethrow). Otherwise: `data()` suspends until the resource
+            // settles (on the client Solid reads the serialized value — no re-fetch).
+            if (data.error !== undefined) {
+                if (props.errorFallback)
+                    return props.errorFallback(data.error);
+                throw data.error;
+            }
+            const value = data();
+            return value === undefined ? null : props.children(value);
+        },
+    });
+}
+//# 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,eAAe,EAAE,cAAc,EAAY,QAAQ,EAAE,MAAM,UAAU,CAAA;AAY9E,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;;;;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,MAAM,GAAG,KAAK,CAAC,OAAO,CAAA;IAC5B,MAAM,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IACnD,OAAO,eAAe,CAAC,QAAQ,EAAE;QAC/B,IAAI,QAAQ;YACV,OAAO,KAAK,CAAC,QAAQ,CAAA;QACvB,CAAC;QACD,IAAI,QAAQ;YACV,gGAAgG;YAChG,yFAAyF;YACzF,0EAA0E;YAC1E,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBAC7B,IAAI,KAAK,CAAC,aAAa;oBAAE,OAAO,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;gBAC/D,MAAM,IAAI,CAAC,KAAK,CAAA;YAClB,CAAC;YACD,MAAM,KAAK,GAAG,IAAI,EAAE,CAAA;YACpB,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;QAC3D,CAAC;KACF,CAAC,CAAA;AACJ,CAAC"}

package/dist/client.d.ts

@@ -0,0 +1,18 @@
+import type { MountRouterOptions, RenderProps } from "@nifrajs/web";
+export { errorBoundary } from "./error.js";
+/** Hydrate a server-rendered Solid layout `chain` (with the loader `props`) inside `container`. */
+export declare function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown): void;
+/**
+ * Mount a Solid Router driven by the agnostic store. The first render *hydrates* the SSR'd chain. The
+ * route's props are exposed as **getters over a signal** created inside the render root, so:
+ *
+ * - **Same route** (revalidation, a param change, an optimistic submit) — the snapshot signal is
+ *   updated and only the components reading the changed props re-run; the layout chain stays mounted,
+ *   so **focus and scroll are preserved**. This is the case the old "dispose + re-render on every
+ *   navigation" implementation regressed.
+ * - **Different route** — the matched chain genuinely changed (different page + layouts), so the root
+ *   is disposed and the new chain is rendered. (Getter-props are a transparent reactive boundary, so
+ *   they don't shift Solid's structural hydration keys — unlike a `<Show>`, which would.)
+ */
+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;AAgBnE,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;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAqD7D"}

package/dist/client.js

@@ -0,0 +1,85 @@
+/**
+ * @nifrajs/web-solid/client — Solid client runtime. `hydrate` hydrates a single SSR'd route;
+ * `mountRouter` hydrates the initial route then drives navigation through a Solid signal — so a
+ * same-route update (revalidation, a param change, an optimistic submit) updates **in place** via
+ * fine-grained reactivity, preserving the layout chain + focus + scroll. Runs against Solid's client
+ * build; kept in its own entry so SSR code never ships to the client bundle. No JSX — Solid's package
+ * build is plain `tsc`, so this uses Solid's runtime functions directly, like `compose`.
+ */
+import { createSignal } from "solid-js";
+import { hydrate as solidHydrate, render as solidRender } from "solid-js/web";
+import { compose } from "./compose.js";
+import { setMountedRouter } from "./fetcher.js";
+// The `_error` boundary chain element — defined in its own module, re-exported here so nifra's client
+// codegen resolves it from `@nifrajs/web-solid/client` alongside `mountRouter`.
+export { errorBoundary } from "./error.js";
+/** Hydrate a server-rendered Solid layout `chain` (with the loader `props`) inside `container`. */
+export function hydrate(chain, props, container) {
+    solidHydrate(compose(chain, props), container);
+}
+/**
+ * Mount a Solid Router driven by the agnostic store. The first render *hydrates* the SSR'd chain. The
+ * route's props are exposed as **getters over a signal** created inside the render root, so:
+ *
+ * - **Same route** (revalidation, a param change, an optimistic submit) — the snapshot signal is
+ *   updated and only the components reading the changed props re-run; the layout chain stays mounted,
+ *   so **focus and scroll are preserved**. This is the case the old "dispose + re-render on every
+ *   navigation" implementation regressed.
+ * - **Different route** — the matched chain genuinely changed (different page + layouts), so the root
+ *   is disposed and the new chain is rendered. (Getter-props are a transparent reactive boundary, so
+ *   they don't shift Solid's structural hydration keys — unlike a `<Show>`, which would.)
+ */
+export function mountRouter(options) {
+    const { router, routes, container } = options;
+    setMountedRouter(router); // expose it to createFetcher/useFetchers (same page, client-only)
+    const el = container;
+    let dispose;
+    let mountedRouteId = null;
+    // The setter for the currently-mounted route's reactive props — same-route settles push through it.
+    let update = null;
+    const mount = (first) => {
+        const initial = router.snapshot();
+        mountedRouteId = initial.routeId;
+        const renderer = first ? solidHydrate : solidRender;
+        dispose = renderer(() => {
+            // Signal owned by THIS render root (so it's never ownerless). `props` are getters over it; a
+            // same-route settle calls `update(snapshot)` and the reading components update in place — no
+            // recompose, so the layout chain + focus + scroll survive. Cast bridges
+            // `exactOptionalPropertyTypes` (a getter is always present, returning `undefined` when idle —
+            // the documented "absent on idle" semantics for `submission`).
+            const [snapshot, setSnapshot] = createSignal(initial);
+            update = setSnapshot;
+            const props = {
+                get data() {
+                    return snapshot().data;
+                },
+                get actionData() {
+                    return snapshot().actionData;
+                },
+                get pending() {
+                    return snapshot().pending;
+                },
+                get submission() {
+                    return snapshot().submission;
+                },
+            };
+            // The matched chain is fixed for this mount (routeId is constant here); a route *change* disposes
+            // and re-mounts below, so the root render fn reads no signal and never re-runs on its own.
+            return compose(routes[initial.routeId] ?? [], props)();
+        }, el);
+    };
+    mount(true);
+    router.subscribe(() => {
+        const snapshot = router.snapshot();
+        if (snapshot.pending)
+            return; // skip the in-flight tick; act once settled
+        if (snapshot.routeId === mountedRouteId) {
+            update?.(snapshot); // same route → reactive in-place update (preserves layout/focus/scroll)
+        }
+        else {
+            dispose?.(); // route changed → tear down and render the new chain
+            mount(false);
+        }
+    });
+}
+//# 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;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,cAAc,CAAA;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE/C,sGAAsG;AACtG,gFAAgF;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,mGAAmG;AACnG,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB,EAAE,SAAkB;IACvF,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,SAAoB,CAAC,CAAA;AAC3D,CAAC;AAED;;;;;;;;;;;GAWG;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,kEAAkE;IAC3F,MAAM,EAAE,GAAG,SAAoB,CAAA;IAE/B,IAAI,OAAiC,CAAA;IACrC,IAAI,cAAc,GAAkB,IAAI,CAAA;IACxC,oGAAoG;IACpG,IAAI,MAAM,GAAoE,IAAI,CAAA;IAElF,MAAM,KAAK,GAAG,CAAC,KAAc,EAAQ,EAAE;QACrC,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAA;QACjC,cAAc,GAAG,OAAO,CAAC,OAAO,CAAA;QAChC,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,CAAA;QACnD,OAAO,GAAG,QAAQ,CAAC,GAAG,EAAE;YACtB,6FAA6F;YAC7F,6FAA6F;YAC7F,wEAAwE;YACxE,8FAA8F;YAC9F,+DAA+D;YAC/D,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,CAAA;YACrD,MAAM,GAAG,WAAW,CAAA;YACpB,MAAM,KAAK,GAAG;gBACZ,IAAI,IAAI;oBACN,OAAO,QAAQ,EAAE,CAAC,IAAI,CAAA;gBACxB,CAAC;gBACD,IAAI,UAAU;oBACZ,OAAO,QAAQ,EAAE,CAAC,UAAU,CAAA;gBAC9B,CAAC;gBACD,IAAI,OAAO;oBACT,OAAO,QAAQ,EAAE,CAAC,OAAO,CAAA;gBAC3B,CAAC;gBACD,IAAI,UAAU;oBACZ,OAAO,QAAQ,EAAE,CAAC,UAAU,CAAA;gBAC9B,CAAC;aACa,CAAA;YAChB,kGAAkG;YAClG,2FAA2F;YAC3F,OAAO,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,KAAK,CAAC,EAAE,CAAA;QACxD,CAAC,EAAE,EAAE,CAAC,CAAA;IACR,CAAC,CAAA;IAED,KAAK,CAAC,IAAI,CAAC,CAAA;IACX,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE;QACpB,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAA;QAClC,IAAI,QAAQ,CAAC,OAAO;YAAE,OAAM,CAAC,4CAA4C;QACzE,IAAI,QAAQ,CAAC,OAAO,KAAK,cAAc,EAAE,CAAC;YACxC,MAAM,EAAE,CAAC,QAAQ,CAAC,CAAA,CAAC,wEAAwE;QAC7F,CAAC;aAAM,CAAC;YACN,OAAO,EAAE,EAAE,CAAA,CAAC,qDAAqD;YACjE,KAAK,CAAC,KAAK,CAAC,CAAA;QACd,CAAC;IACH,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/dist/compose.d.ts

@@ -0,0 +1,9 @@
+import type { RenderProps } from "@nifrajs/web";
+import { type JSX } from "solid-js";
+/**
+ * Fold a layout chain (outermost layout → page) into a single Solid 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 (hydrate).
+ */
+export declare function compose(chain: readonly unknown[], props: RenderProps): () => JSX.Element;
+//# 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,EAAmC,KAAK,GAAG,EAAE,MAAM,UAAU,CAAA;AAEpE;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,CAAC,OAAO,CASxF"}

package/dist/compose.js

@@ -0,0 +1,17 @@
+import { createComponent } from "solid-js";
+/**
+ * Fold a layout chain (outermost layout → page) into a single Solid 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 (hydrate).
+ */
+export function compose(chain, props) {
+    const last = chain.length - 1;
+    let node = () => createComponent(chain[last], props);
+    for (let i = last - 1; i >= 0; i--) {
+        const Layout = chain[i];
+        const child = node;
+        node = () => createComponent(Layout, { children: child() });
+    }
+    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,EAAkB,eAAe,EAAY,MAAM,UAAU,CAAA;AAEpE;;;;GAIG;AACH,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB;IACnE,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAA;IAC7B,IAAI,IAAI,GAAsB,GAAG,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAA2B,EAAE,KAAK,CAAC,CAAA;IACjG,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAyC,CAAA;QAC/D,MAAM,KAAK,GAAG,IAAI,CAAA;QAClB,IAAI,GAAG,GAAG,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;IAC7D,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/content.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `@nifrajs/web-solid/content` — render pre-rendered HTML (e.g. a `@nifrajs/content` collection entry's
+ * `.html`) into the DOM. Solid sets `innerHTML` reactively on a `<Dynamic>` element. Pairs with content
+ * collections: `<Content html={entry.html} />`. No JSX (`createComponent`/`Dynamic`), so it builds with
+ * plain `tsc`.
+ *
+ * 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 } from "solid-js";
+export interface ContentProps {
+    /** Trusted, pre-rendered HTML (e.g. `entry.html`). */
+    readonly html: string;
+    /** Wrapper element (default `"div"`). */
+    readonly as?: string;
+    /** DOM passthrough (`class`, `style`, `id`, `data-*`, handlers). */
+    readonly [key: string]: unknown;
+}
+/** Render trusted HTML into a wrapper element. Extra props pass through reactively. */
+export declare function Content(props: ContentProps): JSX.Element;
+//# 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;;;;;;;;GAQG;AACH,OAAO,EAAmB,KAAK,GAAG,EAA0B,MAAM,UAAU,CAAA;AAG5E,MAAM,WAAW,YAAY;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAA;IACpB,oEAAoE;IACpE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAChC;AAED,uFAAuF;AACvF,wBAAgB,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,GAAG,CAAC,OAAO,CAOxD"}

package/dist/content.js

@@ -0,0 +1,18 @@
+/**
+ * `@nifrajs/web-solid/content` — render pre-rendered HTML (e.g. a `@nifrajs/content` collection entry's
+ * `.html`) into the DOM. Solid sets `innerHTML` reactively on a `<Dynamic>` element. Pairs with content
+ * collections: `<Content html={entry.html} />`. No JSX (`createComponent`/`Dynamic`), so it builds with
+ * plain `tsc`.
+ *
+ * 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 { createComponent, mergeProps, splitProps } from "solid-js";
+import { Dynamic } from "solid-js/web";
+/** Render trusted HTML into a wrapper element. Extra props pass through reactively. */
+export function Content(props) {
+    const [, rest] = splitProps(props, ["html", "as"]);
+    // A function source keeps `component`/`innerHTML` reactive (matches the `<Image>` pattern).
+    return createComponent(Dynamic, mergeProps(rest, () => ({ component: props.as ?? "div", innerHTML: props.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;;;;;;;;GAQG;AACH,OAAO,EAAE,eAAe,EAAY,UAAU,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC5E,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAWtC,uFAAuF;AACvF,MAAM,UAAU,OAAO,CAAC,KAAmB;IACzC,MAAM,CAAC,EAAE,IAAI,CAAC,GAAG,UAAU,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAA;IAClD,4FAA4F;IAC5F,OAAO,eAAe,CACpB,OAAO,EACP,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,IAAI,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAClF,CAAA;AACH,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 } }` (via Solid's `<ErrorBoundary>`) instead of crashing.
+ * DOM-transparent (renders its children directly — no wrapper element), so it 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,CAYxD"}

package/dist/error.js

@@ -0,0 +1,25 @@
+/**
+ * `errorBoundary` — the Solid error-boundary chain element for nifra's `_error.tsx`. Its own module
+ * (imports only `solid-js`) so the client codegen can import it from `@nifrajs/web-solid/client` (which
+ * re-exports it). No JSX (`createComponent`), so the package builds with plain `tsc`.
+ */
+import { createComponent, ErrorBoundary } from "solid-js";
+/**
+ * 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 } }` (via Solid's `<ErrorBoundary>`) instead of crashing.
+ * DOM-transparent (renders its children directly — no wrapper element), so it never disturbs hydration.
+ */
+export function errorBoundary(fallback) {
+    const Fallback = fallback;
+    return (props) => createComponent(ErrorBoundary, {
+        fallback: (err) => {
+            const e = err instanceof Error ? err : new Error(String(err));
+            return createComponent(Fallback, { data: { name: e.name, message: e.message } });
+        },
+        get children() {
+            return props.children;
+        },
+    });
+}
+//# 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,eAAe,EAAE,aAAa,EAAY,MAAM,UAAU,CAAA;AAEnE;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,QAAiB;IAC7C,MAAM,QAAQ,GAAG,QAA+E,CAAA;IAChG,OAAO,CAAC,KAAiC,EAAe,EAAE,CACxD,eAAe,CAAC,aAAa,EAAE;QAC7B,QAAQ,EAAE,CAAC,GAAY,EAAE,EAAE;YACzB,MAAM,CAAC,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;YAC7D,OAAO,eAAe,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;QAClF,CAAC;QACD,IAAI,QAAQ;YACV,OAAO,KAAK,CAAC,QAAQ,CAAA;QACvB,CAAC;KACF,CAAC,CAAA;AACN,CAAC"}

package/dist/fetcher.d.ts

@@ -0,0 +1,37 @@
+import type { ClientRouter, Fetcher, FetcherState } from "@nifrajs/web";
+/**
+ * `@nifrajs/web-solid/fetcher` — Solid bindings for concurrent fetchers. `createFetcher(key)` bridges an
+ * independent {@link Fetcher}'s `subscribe`/`snapshot` store into a Solid signal (the pattern the F16
+ * spike confirmed) and returns its reactive state accessor plus `load`/`submit`; `useFetchers()`
+ * bridges the whole live collection. Imports only `solid-js` (never `solid-js/web`), so route
+ * components can use it on the server *and* client without pulling server/build code into the wrong
+ * bundle. No JSX (the package builds with plain `tsc`).
+ *
+ * The router that owns the fetchers registers itself via `setMountedRouter` from `mountRouter`. On the
+ * server (no mount) the accessors return an idle state — fetchers are client-only — so SSR markup is
+ * unchanged and the first client render after `mountRouter` takes over cleanly.
+ */
+import { type Accessor } from "solid-js";
+/** 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 state accessor plus its imperative `load`/`submit`. */
+export interface FetcherHandle {
+    /** Reactive accessor for the fetcher's {@link FetcherState} (`pending`/`data`/`actionData`/...). */
+    readonly state: Accessor<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>;
+}
+/**
+ * Bind the independent fetcher for `key` (created lazily, stable). Returns a reactive `state()`
+ * accessor + `load`/`submit`. Multiple `createFetcher` calls with different keys run concurrently
+ * without disturbing the active route or each other. Call inside a component (owns the subscription).
+ */
+export declare function createFetcher(key: string): FetcherHandle;
+/**
+ * Bind the whole live fetcher collection — for a global busy view. Returns a reactive accessor; read
+ * each entry's `.snapshot()` for its state. Updates whenever any fetcher transitions or one is created.
+ */
+export declare function useFetchers(): Accessor<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;AACvE;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,KAAK,QAAQ,EAA2B,MAAM,UAAU,CAAA;AAKjE,oGAAoG;AACpG,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,CAEvE;AAKD,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B,oGAAoG;IACpG,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAA;IACtC,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,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAQxD;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,QAAQ,CAAC,SAAS,OAAO,EAAE,CAAC,CAO1D"}

package/dist/fetcher.js

@@ -0,0 +1,48 @@
+/**
+ * `@nifrajs/web-solid/fetcher` — Solid bindings for concurrent fetchers. `createFetcher(key)` bridges an
+ * independent {@link Fetcher}'s `subscribe`/`snapshot` store into a Solid signal (the pattern the F16
+ * spike confirmed) and returns its reactive state accessor plus `load`/`submit`; `useFetchers()`
+ * bridges the whole live collection. Imports only `solid-js` (never `solid-js/web`), so route
+ * components can use it on the server *and* client without pulling server/build code into the wrong
+ * bundle. No JSX (the package builds with plain `tsc`).
+ *
+ * The router that owns the fetchers registers itself via `setMountedRouter` from `mountRouter`. On the
+ * server (no mount) the accessors return an idle state — fetchers are client-only — so SSR markup is
+ * unchanged and the first client render after `mountRouter` takes over cleanly.
+ */
+import { createSignal, onCleanup } from "solid-js";
+// The active client router (set by `mountRouter`). Module-scoped: one app per page, client-only.
+let mountedRouter;
+/** Register (or clear) the router that owns fetchers — called by `mountRouter`. Not for app use. */
+export function setMountedRouter(router) {
+    mountedRouter = router;
+}
+const IDLE = { pending: false, data: undefined };
+const noopAsync = async () => { };
+/**
+ * Bind the independent fetcher for `key` (created lazily, stable). Returns a reactive `state()`
+ * accessor + `load`/`submit`. Multiple `createFetcher` calls with different keys run concurrently
+ * without disturbing the active route or each other. Call inside a component (owns the subscription).
+ */
+export function createFetcher(key) {
+    const fetcher = mountedRouter?.fetcher(key);
+    const [state, setState] = createSignal(fetcher ? fetcher.snapshot() : IDLE);
+    if (fetcher !== undefined) {
+        onCleanup(fetcher.subscribe(() => setState(fetcher.snapshot())));
+        return { state, load: fetcher.load, submit: fetcher.submit };
+    }
+    return { state, load: noopAsync, submit: noopAsync };
+}
+/**
+ * Bind the whole live fetcher collection — for a global busy view. Returns a reactive accessor; read
+ * each entry's `.snapshot()` for its state. Updates whenever any fetcher transitions or one is created.
+ */
+export function useFetchers() {
+    const router = mountedRouter;
+    const [list, setList] = createSignal(router ? router.fetchers() : []);
+    if (router !== undefined) {
+        onCleanup(router.subscribeFetchers(() => setList(router.fetchers())));
+    }
+    return list;
+}
+//# 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,EAAiB,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEjE,iGAAiG;AACjG,IAAI,aAAuC,CAAA;AAE3C,oGAAoG;AACpG,MAAM,UAAU,gBAAgB,CAAC,MAAgC;IAC/D,aAAa,GAAG,MAAM,CAAA;AACxB,CAAC;AAED,MAAM,IAAI,GAAiB,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,CAAA;AAC9D,MAAM,SAAS,GAAG,KAAK,IAAmB,EAAE,GAAE,CAAC,CAAA;AAY/C;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,GAAW;IACvC,MAAM,OAAO,GAAG,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;IAC3C,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,YAAY,CAAe,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;IACzF,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAA;QAChE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAA;IAC9D,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,CAAA;AACtD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW;IACzB,MAAM,MAAM,GAAG,aAAa,CAAA;IAC5B,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,YAAY,CAAqB,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAA;IACzF,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,SAAS,CAAC,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAA;IACvE,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/i18n.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `@nifrajs/web-solid/i18n` — Solid bindings for `@nifrajs/i18n`. `<I18nProvider locale messages>` builds a
+ * `Formatter` (a `createMemo`, so switching locale rebuilds it) 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 on hydrate (no
+ * mismatch). Imports only `solid-js` + `@nifrajs/i18n`; no JSX (`createComponent`).
+ */
+import { type Formatter, type Messages } from "@nifrajs/i18n";
+import { type JSX } from "solid-js";
+export interface I18nProviderProps {
+    readonly locale: string;
+    readonly messages: Messages;
+    readonly children?: JSX.Element;
+}
+/** Provide a {@link Formatter} (built from `locale` + `messages`) to the subtree. Memoized on
+ * `locale`/`messages`, so switching locale rebuilds it. */
+export declare function I18nProvider(props: I18nProviderProps): JSX.Element;
+/** Read the current {@link Formatter} (`{ locale, t, n, d }`). Throws if no `<I18nProvider>` is above.
+ * nifra switches locale by re-navigating, which re-runs the consuming component with the new catalog. */
+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,EAKL,KAAK,GAAG,EAET,MAAM,UAAU,CAAA;AAIjB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,OAAO,CAAA;CAChC;AAED;2DAC2D;AAC3D,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,GAAG,CAAC,OAAO,CAQlE;AAED;yGACyG;AACzG,wBAAgB,IAAI,IAAI,SAAS,CAMhC"}

package/dist/i18n.js

@@ -0,0 +1,31 @@
+/**
+ * `@nifrajs/web-solid/i18n` — Solid bindings for `@nifrajs/i18n`. `<I18nProvider locale messages>` builds a
+ * `Formatter` (a `createMemo`, so switching locale rebuilds it) 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 on hydrate (no
+ * mismatch). Imports only `solid-js` + `@nifrajs/i18n`; no JSX (`createComponent`).
+ */
+import { createFormatter } from "@nifrajs/i18n";
+import { createComponent, createContext, createMemo, useContext, } from "solid-js";
+const I18nContext = createContext();
+/** Provide a {@link Formatter} (built from `locale` + `messages`) to the subtree. Memoized on
+ * `locale`/`messages`, so switching locale rebuilds it. */
+export function I18nProvider(props) {
+    const formatter = createMemo(() => createFormatter(props.locale, props.messages));
+    return createComponent(I18nContext.Provider, {
+        value: formatter,
+        get children() {
+            return props.children;
+        },
+    });
+}
+/** Read the current {@link Formatter} (`{ locale, t, n, d }`). Throws if no `<I18nProvider>` is above.
+ * nifra switches locale by re-navigating, which re-runs the consuming component with the new catalog. */
+export function useT() {
+    const formatter = useContext(I18nContext);
+    if (formatter === undefined) {
+        throw new Error("[nifra/web-solid] 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,EAEL,eAAe,EACf,aAAa,EACb,UAAU,EAEV,UAAU,GACX,MAAM,UAAU,CAAA;AAEjB,MAAM,WAAW,GAAG,aAAa,EAAuB,CAAA;AAQxD;2DAC2D;AAC3D,MAAM,UAAU,YAAY,CAAC,KAAwB;IACnD,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAA;IACjF,OAAO,eAAe,CAAC,WAAW,CAAC,QAAQ,EAAE;QAC3C,KAAK,EAAE,SAAS;QAChB,IAAI,QAAQ;YACV,OAAO,KAAK,CAAC,QAAQ,CAAA;QACvB,CAAC;KACF,CAAC,CAAA;AACJ,CAAC;AAED;yGACyG;AACzG,MAAM,UAAU,IAAI;IAClB,MAAM,SAAS,GAAG,UAAU,CAAC,WAAW,CAAC,CAAA;IACzC,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAA;IACnF,CAAC;IACD,OAAO,SAAS,EAAE,CAAA;AACpB,CAAC"}

package/dist/image.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `@nifrajs/web-solid/image` — a CLS-safe responsive Solid `<Image>`. A thin wrapper over `resolveImage`
+ * from `@nifrajs/image`: it computes the responsive `<img>` attributes (`src`/`srcset`/`sizes`/`width`/
+ * `height`/`loading`/`decoding`/`fetchpriority` via `toHtmlAttrs`) and renders an `<img>` through
+ * Solid's `<Dynamic>`. Extra DOM props (`class`, `style`, `id`, `data-*`, handlers) pass through
+ * reactively (`splitProps`/`mergeProps`). Resizing is delegated to the `loader`; nifra bundles no codec.
+ * No JSX (`createComponent`/`Dynamic`), so the package builds with plain `tsc`.
+ */
+import { type ImageLoader, type ImageProps } from "@nifrajs/image";
+import { type JSX } from "solid-js";
+/** 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.ImgHTMLAttributes<HTMLImageElement>, 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): JSX.Element;
+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;;;;;;;GAOG;AACH,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAA6B,MAAM,gBAAgB,CAAA;AAC7F,OAAO,EAAmB,KAAK,GAAG,EAA0B,MAAM,UAAU,CAAA;AAG5E,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,gBAAgB,CAAC,EAAE,aAAa,GAAG,MAAM,UAAU,CAAC;IACjF,+FAA+F;IAC/F,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAC9B;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,mBAAmB,GAAG,GAAG,CAAC,OAAO,CAgC7D"}

package/dist/image.js

@@ -0,0 +1,49 @@
+/**
+ * `@nifrajs/web-solid/image` — a CLS-safe responsive Solid `<Image>`. A thin wrapper over `resolveImage`
+ * from `@nifrajs/image`: it computes the responsive `<img>` attributes (`src`/`srcset`/`sizes`/`width`/
+ * `height`/`loading`/`decoding`/`fetchpriority` via `toHtmlAttrs`) and renders an `<img>` through
+ * Solid's `<Dynamic>`. Extra DOM props (`class`, `style`, `id`, `data-*`, handlers) pass through
+ * reactively (`splitProps`/`mergeProps`). Resizing is delegated to the `loader`; nifra bundles no codec.
+ * No JSX (`createComponent`/`Dynamic`), so the package builds with plain `tsc`.
+ */
+import { resolveImage, toHtmlAttrs } from "@nifrajs/image";
+import { createComponent, mergeProps, splitProps } from "solid-js";
+import { Dynamic } from "solid-js/web";
+/**
+ * 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) {
+    // Separate the nifra-only props (not valid DOM attributes) from the DOM passthrough (`rest`), keeping
+    // both reactive. `rest` carries class/style/id/handlers; the computed attrs are layered over it.
+    const [, rest] = splitProps(props, [
+        "loader",
+        "widths",
+        "quality",
+        "priority",
+        "src",
+        "width",
+        "height",
+        "alt",
+        "sizes",
+        "loading",
+    ]);
+    const attrs = () => {
+        // Build ImageProps via conditional spreads (exactOptionalPropertyTypes: an unset optional is
+        // absent, not `undefined`). resolveImage validates width/height > 0 (CLS contract).
+        const input = {
+            src: props.src,
+            width: props.width,
+            height: props.height,
+            alt: props.alt,
+            ...(props.sizes !== undefined ? { sizes: props.sizes } : {}),
+            ...(props.widths !== undefined ? { widths: props.widths } : {}),
+            ...(props.quality !== undefined ? { quality: props.quality } : {}),
+            ...(props.loading !== undefined ? { loading: props.loading } : {}),
+            ...(props.priority !== undefined ? { priority: props.priority } : {}),
+        };
+        return toHtmlAttrs(resolveImage(input, props.loader));
+    };
+    return createComponent(Dynamic, mergeProps(rest, attrs, { component: "img" }));
+}
+//# 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;;;;;;;GAOG;AACH,OAAO,EAAqC,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC7F,OAAO,EAAE,eAAe,EAAY,UAAU,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC5E,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAqBtC;;;GAGG;AACH,MAAM,UAAU,KAAK,CAAC,KAA0B;IAC9C,sGAAsG;IACtG,iGAAiG;IACjG,MAAM,CAAC,EAAE,IAAI,CAAC,GAAG,UAAU,CAAC,KAAK,EAAE;QACjC,QAAQ;QACR,QAAQ;QACR,SAAS;QACT,UAAU;QACV,KAAK;QACL,OAAO;QACP,QAAQ;QACR,KAAK;QACL,OAAO;QACP,SAAS;KACV,CAAC,CAAA;IACF,MAAM,KAAK,GAAG,GAAmC,EAAE;QACjD,6FAA6F;QAC7F,oFAAoF;QACpF,MAAM,KAAK,GAAe;YACxB,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,GAAG,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC5D,GAAG,CAAC,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/D,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAClE,GAAG,CAAC,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAClE,GAAG,CAAC,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACtE,CAAA;QACD,OAAO,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;IACvD,CAAC,CAAA;IACD,OAAO,eAAe,CAAC,OAAO,EAAE,UAAU,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAAA;AAChF,CAAC"}