@nifrajs/web-solid 2.1.0 → 2.3.0

package/README.md

@@ -1,8 +1,8 @@
 # @nifrajs/web-solid
 
-Solid render adapter for @nifrajs/web — SSR + hydration + the Solid Babel build plugin.
+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`.
+Part of the **[nifra](https://nifra.dev)** full-stack TypeScript framework - one core, five UI libraries, every runtime. Scaffold a new app with `bun create nifra`.
 
 ## Install
 
@@ -19,7 +19,7 @@ MIT
 
 ## For AI agents
 
-Start with [`LLM.md`](./LLM.md) — this package's contract card (the exports you call + its footguns),
+Start with [`LLM.md`](./LLM.md) - this package's contract card (the exports you call + its footguns),
 one cheap read instead of the whole corpus. For the wider framework: the repo's
 [`AGENTS.md`](../../AGENTS.md) is the copy-paste quick reference, and
 [`llms-full.txt`](../../llms-full.txt) is the full machine-readable corpus. Run `nifra check` as the

package/dist/await.d.ts

@@ -1,13 +1,13 @@
 import type { Deferred } from "@nifrajs/web";
 /**
- * `@nifrajs/web-solid/await` — the `<Await>` primitive for deferred loader data (`defer()`). Isomorphic
+ * `@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
+ * 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";

package/dist/await.js

@@ -1,12 +1,12 @@
 /**
- * `@nifrajs/web-solid/await` — the `<Await>` primitive for deferred loader data (`defer()`). Isomorphic
+ * `@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
+ * 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";
@@ -32,7 +32,7 @@ export function Await(props) {
         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).
+            // settles (on the client Solid reads the serialized value - no re-fetch).
             if (data.error !== undefined) {
                 if (props.errorFallback)
                     return props.errorFallback(data.error);

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { MountRouterOptions, RenderProps } from "@nifrajs/web";
+import { type MountRouterOptions, type 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;
@@ -6,13 +6,13 @@ export declare function hydrate(chain: readonly unknown[], props: RenderProps, c
  * 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
+ * - **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
+ * - **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.)
+ *   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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;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"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAiB,MAAM,cAAc,CAAA;AAgBvF,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,CA+D7D"}

package/dist/client.js

@@ -1,16 +1,17 @@
+import { searchOfChain } from "@nifrajs/web";
 /**
- * @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
+ * @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; 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
+// 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`. */
@@ -21,21 +22,21 @@ export function hydrate(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
+ * - **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
+ * - **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.)
+ *   they don't shift Solid's structural hydration keys - unlike a `<Show>`, which would.)
  */
 export function mountRouter(options) {
-    const { router, routes, container } = options;
+    const { router, routes, searchSchemas, 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.
+    // 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();
@@ -43,9 +44,9 @@ export function mountRouter(options) {
         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
+            // 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 —
+            // `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;
@@ -59,6 +60,13 @@ export function mountRouter(options) {
                 get pending() {
                     return snapshot().pending;
                 },
+                get search() {
+                    // The SAME searchOfChain the server ran, over this snapshot's URL - a same-route search change
+                    // updates in place (fine-grained), matching the SSR value on hydration.
+                    const s = snapshot();
+                    const idx = s.path.indexOf("?");
+                    return searchOfChain(searchSchemas?.[s.routeId] ?? [], idx === -1 ? "" : s.path.slice(idx));
+                },
                 get submission() {
                     return snapshot().submission;
                 },

package/dist/client.js.map

@@ -1 +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"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/compose.d.ts

@@ -3,7 +3,10 @@ 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).
+ * `children`. The whole tree is wrapped in a {@link SearchContext} provider carrying an accessor of the
+ * validated `search` (threaded through `RenderProps` identically on SSR + client), so `useSearch` reads
+ * the same value on both sides - no hydration mismatch. Shared by the server adapter (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

@@ -1 +1 @@
-{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,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"}
+{"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;AAMpE;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,CAAC,OAAO,CAsBxF"}

package/dist/compose.js

@@ -1,8 +1,14 @@
 import { createComponent } from "solid-js";
+import { SearchContext } from "./router.js";
+// Frozen empty search so a render with no search context has a stable provider value.
+const EMPTY_SEARCH = Object.freeze({});
 /**
  * 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).
+ * `children`. The whole tree is wrapped in a {@link SearchContext} provider carrying an accessor of the
+ * validated `search` (threaded through `RenderProps` identically on SSR + client), so `useSearch` reads
+ * the same value on both sides - no hydration mismatch. Shared by the server adapter (renderToString) and
+ * the client (hydrate).
  */
 export function compose(chain, props) {
     const last = chain.length - 1;
@@ -10,8 +16,20 @@ export function compose(chain, props) {
     for (let i = last - 1; i >= 0; i--) {
         const Layout = chain[i];
         const child = node;
-        node = () => createComponent(Layout, { children: child() });
+        // Each layout receives its own loader data at its own index. Layouts are the chain's leading
+        // prefix, so `layoutData[i]` belongs to `chain[i]`; anything past that end (a client-only `_error`
+        // boundary marker, the page) reads `undefined` and is unaffected.
+        const layoutData = props.layoutData?.[i] ?? null;
+        node = () => createComponent(Layout, { data: layoutData, children: child() });
     }
-    return node;
+    const inner = node;
+    // The provider `value` is an ACCESSOR reading `props.search` - a getter over the mount's snapshot on
+    // the client (so a same-route search change updates in place), a static value on SSR.
+    return () => createComponent(SearchContext.Provider, {
+        value: () => (props.search ?? EMPTY_SEARCH),
+        get children() {
+            return inner();
+        },
+    });
 }
 //# sourceMappingURL=compose.js.map

package/dist/compose.js.map

@@ -1 +1 @@
-{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,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"}
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,eAAe,EAAY,MAAM,UAAU,CAAA;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,sFAAsF;AACtF,MAAM,YAAY,GAAsC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AAEzE;;;;;;;GAOG;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,6FAA6F;QAC7F,mGAAmG;QACnG,kEAAkE;QAClE,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;QAChD,IAAI,GAAG,GAAG,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;IAC/E,CAAC;IACD,MAAM,KAAK,GAAG,IAAI,CAAA;IAClB,qGAAqG;IACrG,sFAAsF;IACtF,OAAO,GAAG,EAAE,CACV,eAAe,CAAC,aAAa,CAAC,QAAQ,EAAE;QACtC,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,YAAY,CAA4B;QACtE,IAAI,QAAQ;YACV,OAAO,KAAK,EAAE,CAAA;QAChB,CAAC;KACF,CAAC,CAAA;AACN,CAAC"}

package/dist/content.d.ts

@@ -1,11 +1,11 @@
 /**
- * `@nifrajs/web-solid/content` — render pre-rendered HTML (e.g. a `@nifrajs/content` collection entry's
+ * `@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.
+ * build/server time) - never pass user-supplied HTML without sanitizing it first.
  */
 import { type JSX } from "solid-js";
 export interface ContentProps {

package/dist/content.js

@@ -1,11 +1,11 @@
 /**
- * `@nifrajs/web-solid/content` — render pre-rendered HTML (e.g. a `@nifrajs/content` collection entry's
+ * `@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.
+ * 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";

package/dist/error.d.ts

@@ -2,7 +2,7 @@
  * Build an error-boundary chain element bound to `fallback` (a route's `_error` component). nifra's
  * client codegen inserts it before the page in the matched chain; a render error in the subtree renders
  * `fallback` with `{ data: { name, message } }` (via Solid's `<ErrorBoundary>`) instead of crashing.
- * DOM-transparent (renders its children directly — no wrapper element), so it never disturbs hydration.
+ * 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.js

@@ -1,5 +1,5 @@
 /**
- * `errorBoundary` — the Solid error-boundary chain element for nifra's `_error.tsx`. Its own module
+ * `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`.
  */
@@ -8,7 +8,7 @@ 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.
+ * DOM-transparent (renders its children directly - no wrapper element), so it never disturbs hydration.
  */
 export function errorBoundary(fallback) {
     const Fallback = fallback;

package/dist/fetcher.d.ts

@@ -1,6 +1,6 @@
 import type { ClientRouter, Fetcher, FetcherState } from "@nifrajs/web";
 /**
- * `@nifrajs/web-solid/fetcher` — Solid bindings for concurrent fetchers. `createFetcher(key)` bridges an
+ * `@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
@@ -8,11 +8,11 @@ import type { ClientRouter, Fetcher, FetcherState } from "@nifrajs/web";
  * 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
+ * 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. */
+/** 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 {
@@ -30,7 +30,7 @@ export interface FetcherHandle {
  */
 export declare function createFetcher(key: string): FetcherHandle;
 /**
- * Bind the whole live fetcher collection — for a global busy view. Returns a reactive accessor; read
+ * 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[]>;

package/dist/fetcher.js

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-solid/fetcher` — Solid bindings for concurrent fetchers. `createFetcher(key)` bridges an
+ * `@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
@@ -7,13 +7,13 @@
  * 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
+ * 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. */
+/** Register (or clear) the router that owns fetchers - called by `mountRouter`. Not for app use. */
 export function setMountedRouter(router) {
     mountedRouter = router;
 }
@@ -34,7 +34,7 @@ export function createFetcher(key) {
     return { state, load: noopAsync, submit: noopAsync };
 }
 /**
- * Bind the whole live fetcher collection — for a global busy view. Returns a reactive accessor; read
+ * 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() {

package/dist/fn.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `@nifrajs/web-solid/fn` - Solid binding for a server function's pending/error state.
+ *
+ * Calling a server function needs no hook: the client stub is `(input) => Promise<Output>`. This adds
+ * the part a component usually wants around it - in flight, last result, last error - and nothing more.
+ *
+ * The state machine is `@nifrajs/web`'s `createServerFnStore`, shared with every other adapter, so
+ * "is it pending" has one answer rather than five that drift. This file contributes only a signal fed by the store.
+ */
+import type { ServerFnReference } from "@nifrajs/web/fn";
+import { type ServerFnState } from "@nifrajs/web/fn-state";
+import { type Accessor } from "solid-js";
+/** A server function's state accessor plus the call itself. */
+export interface ServerFnHandle<Input, Output> {
+    /** Reactive state - read it inside JSX so Solid tracks it. */
+    readonly state: Accessor<ServerFnState<Output>>;
+    /** Invoke it. Records state, and rejects on failure - attach `.catch` if you only render state. */
+    readonly call: (input: Input) => Promise<Output>;
+    /** Back to idle. */
+    readonly reset: () => void;
+}
+/**
+ * Track one server function's call state.
+ *
+ *     const addTodo = useServerFn(fns.addTodo)
+ *     <button disabled={addTodo.state().pending} onClick={() => addTodo.call({ text }).catch(() => {})}>
+ */
+export declare function useServerFn<Input, Output>(fn: ServerFnReference<Input, Output>): ServerFnHandle<Input, Output>;
+//# sourceMappingURL=fn.d.ts.map

package/dist/fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.d.ts","sourceRoot":"","sources":["../src/fn.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxE,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC/E,OAAO,EAAE,KAAK,QAAQ,EAA2B,MAAM,UAAU,CAAA;AAEjE,+DAA+D;AAC/D,MAAM,WAAW,cAAc,CAAC,KAAK,EAAE,MAAM;IAC3C,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAA;IAC/C,mGAAmG;IACnG,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAChD,oBAAoB;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EACvC,EAAE,EAAE,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,GACnC,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAS/B"}

package/dist/fn.js

@@ -0,0 +1,28 @@
+/**
+ * `@nifrajs/web-solid/fn` - Solid binding for a server function's pending/error state.
+ *
+ * Calling a server function needs no hook: the client stub is `(input) => Promise<Output>`. This adds
+ * the part a component usually wants around it - in flight, last result, last error - and nothing more.
+ *
+ * The state machine is `@nifrajs/web`'s `createServerFnStore`, shared with every other adapter, so
+ * "is it pending" has one answer rather than five that drift. This file contributes only a signal fed by the store.
+ */
+import { createServerFnStore } from "@nifrajs/web/fn-state";
+import { createSignal, onCleanup } from "solid-js";
+/**
+ * Track one server function's call state.
+ *
+ *     const addTodo = useServerFn(fns.addTodo)
+ *     <button disabled={addTodo.state().pending} onClick={() => addTodo.call({ text }).catch(() => {})}>
+ */
+export function useServerFn(fn) {
+    const store = createServerFnStore(fn);
+    // Seeded from the store, not from the idle constant. They are the same value here - the store is
+    // created one line up and cannot have moved - so this is correctness that does not depend on that
+    // staying true. Svelte had exactly this line reading the constant, and when its subscription turned
+    // out to be lazy the first render showed idle for a call that had already finished.
+    const [state, setState] = createSignal(store.snapshot());
+    onCleanup(store.subscribe(() => setState(() => store.snapshot())));
+    return { state, call: store.call, reset: store.reset };
+}
+//# sourceMappingURL=fn.js.map

package/dist/fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.js","sourceRoot":"","sources":["../src/fn.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,mBAAmB,EAAsB,MAAM,uBAAuB,CAAA;AAC/E,OAAO,EAAiB,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAYjE;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CACzB,EAAoC;IAEpC,MAAM,KAAK,GAAG,mBAAmB,CAAC,EAAmC,CAAC,CAAA;IACtE,iGAAiG;IACjG,kGAAkG;IAClG,oGAAoG;IACpG,oFAAoF;IACpF,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,YAAY,CAAwB,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAA;IAC/E,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAA;IAClE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAA;AACxD,CAAC"}

package/dist/i18n.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-solid/i18n` — Solid bindings for `@nifrajs/i18n`. `<I18nProvider locale messages>` builds a
+ * `@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

package/dist/i18n.js

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-solid/i18n` — Solid bindings for `@nifrajs/i18n`. `<I18nProvider locale messages>` builds a
+ * `@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

package/dist/image.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-solid/image` — a CLS-safe responsive Solid `<Image>`. A thin wrapper over `resolveImage`
+ * `@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
@@ -8,10 +8,10 @@
  */
 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. */
+/** 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). */
+    /** CDN URL builder. Defaults to the identity loader (no transform - still CLS-safe + lazy). */
     readonly loader?: ImageLoader;
 }
 /**

package/dist/image.js

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-solid/image` — a CLS-safe responsive Solid `<Image>`. A thin wrapper over `resolveImage`
+ * `@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

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import type { RenderAdapter } from "@nifrajs/web";
 import type { BunPlugin } from "bun";
-/** The Solid server render adapter — pass to @nifrajs/web's `renderPage`. */
+/** The Solid server render adapter - pass to @nifrajs/web's `renderPage`. */
 export declare const solidAdapter: RenderAdapter;
 /**
- * Bun build/runtime plugin that compiles Solid components with Babel — `generate: "ssr"`
+ * Bun build/runtime plugin that compiles Solid components with Babel - `generate: "ssr"`
  * for the server, `"dom"` for the client, `hydratable` so SSR and hydrate align. Solid's
  * reactive-JSX compiler ships only as a Babel plugin (no swc/native port); this runs at
  * build time, on `.tsx` files only.

package/dist/index.js

@@ -1,30 +1,30 @@
 /**
- * @nifrajs/web-solid — the Solid render adapter for @nifrajs/web (server side) + the Solid Babel
+ * @nifrajs/web-solid - the Solid render adapter for @nifrajs/web (server side) + the Solid Babel
  * Bun-plugin. Streaming SSR via `renderToStream` + `generateHydrationScript`; the layout-chain
  * fold is in `./compose`. Client hydration lives in `@nifrajs/web-solid/client` (Solid's browser
  * build).
  */
 import { transformAsync } from "@babel/core";
-// @ts-expect-error — no type declarations published
+// @ts-expect-error - no type declarations published
 import presetTypeScript from "@babel/preset-typescript";
-// @ts-expect-error — no type declarations published
+// @ts-expect-error - no type declarations published
 import presetSolid from "babel-preset-solid";
 import { generateHydrationScript, renderToStream as solidRenderToStream, renderToString as solidRenderToString, } from "solid-js/web";
 import { compose } from "./compose.js";
 const HYDRATION_HEAD = generateHydrationScript();
-/** The Solid server render adapter — pass to @nifrajs/web's `renderPage`. */
+/** The Solid server render adapter - pass to @nifrajs/web's `renderPage`. */
 export const solidAdapter = {
     // Synchronous one-pass render for non-deferred pages (renderPage's buffered fast path). Solid's
     // `renderToString` emits the same hydratable markup (same `data-hk` keys seeded by
     // `generateHydrationScript()`) as `renderToStream`, but skips the TransformStream + Solid's
-    // streaming machinery — the heaviest of the five renderers on Bun. A page that defer()s/Suspends
+    // streaming machinery - the heaviest of the five renderers on Bun. A page that defer()s/Suspends
     // takes `renderToStream` below (progressive resolution needs it).
     renderToString(chain, props) {
         return solidRenderToString(compose(chain, props));
     },
     renderToStream(chain, props) {
         // Solid's `renderToStream` streams `Uint8Array` chunks into a Web `WritableStream` via
-        // `pipeTo` (fire-and-forget — returns void); pipe into a TransformStream and hand back the
+        // `pipeTo` (fire-and-forget - returns void); pipe into a TransformStream and hand back the
         // readable side. Suspense boundaries stream as they resolve; `generateHydrationScript()` (in
         // <head>) seeds client hydration. A render failure errors `ts.readable`, which `renderPage`
         // surfaces on the response body.
@@ -37,7 +37,7 @@ export const solidAdapter = {
     },
 };
 /**
- * Bun build/runtime plugin that compiles Solid components with Babel — `generate: "ssr"`
+ * Bun build/runtime plugin that compiles Solid components with Babel - `generate: "ssr"`
  * for the server, `"dom"` for the client, `hydratable` so SSR and hydrate align. Solid's
  * reactive-JSX compiler ships only as a Babel plugin (no swc/native port); this runs at
  * build time, on `.tsx` files only.

package/dist/mdx-runtime.js

@@ -1,7 +1,7 @@
 /**
- * Solid MDX runtime — the `useMDXComponents` provider that `@nifrajs/web-solid/mdx`'s compiled MDX imports
+ * Solid MDX runtime - the `useMDXComponents` provider that `@nifrajs/web-solid/mdx`'s compiled MDX imports
  * (via `@mdx-js`'s `providerImportSource`). MDX emits intrinsic elements (`h1`, `p`, …) as *string*
- * component references, but Solid can't `createComponent("h1")` — its JSX is compile-time. So we map
+ * component references, but Solid can't `createComponent("h1")` - its JSX is compile-time. So we map
  * each Markdown-output tag to a Solid component that renders it via `<Dynamic component={tag}>`.
  */
 import { createComponent } from "solid-js";

package/dist/mdx.js

@@ -7,17 +7,17 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 /**
- * `solidMdxBunPlugin` — compile `.mdx` routes/files to **Solid** components. MDX is JSX-oriented but
+ * `solidMdxBunPlugin` - compile `.mdx` routes/files to **Solid** components. MDX is JSX-oriented but
  * Solid's JSX is compile-time, so this: (1) compiles MDX → JSX with `@mdx-js` (keeping JSX), pointing
  * intrinsic elements at `@nifrajs/web-solid/mdx-runtime` (which renders them via Solid's `<Dynamic>`), then
- * (2) runs `babel-preset-solid` — the same transform `solidBunPlugin` applies to `.tsx`. Pass it to
+ * (2) runs `babel-preset-solid` - the same transform `solidBunPlugin` applies to `.tsx`. Pass it to
  * `buildClient`/`buildServer`'s `plugins` (`"dom"` for the client, `"ssr"` for the server), like
  * `solidBunPlugin`. `@mdx-js/mdx` is an optional peer (lazy-loaded at build time).
  */
 import { transformAsync } from "@babel/core";
-// @ts-expect-error — no type declarations published
+// @ts-expect-error - no type declarations published
 import presetTypeScript from "@babel/preset-typescript";
-// @ts-expect-error — no type declarations published
+// @ts-expect-error - no type declarations published
 import presetSolid from "babel-preset-solid";
 // Non-literal so tsc/consumers don't need `@mdx-js/mdx`'s types to typecheck this file (optional peer).
 const MDX_MODULE = "@mdx-js/mdx";
@@ -32,7 +32,7 @@ export function solidMdxBunPlugin(generate) {
                 compile = (await import(__rewriteRelativeImportExtension(MDX_MODULE))).compile;
             }
             catch {
-                throw new Error("@nifrajs/web-solid/mdx: compiling `.mdx` needs the `@mdx-js/mdx` package — install it (`bun add @mdx-js/mdx`).");
+                throw new Error("@nifrajs/web-solid/mdx: compiling `.mdx` needs the `@mdx-js/mdx` package - install it (`bun add @mdx-js/mdx`).");
             }
             build.onLoad({ filter: /\.mdx(\?|$)/ }, async (args) => {
                 const path = args.path.split("?")[0] ?? args.path;

package/dist/query.d.ts

@@ -1,11 +1,11 @@
 import { type QueryClient, type QueryState } from "@nifrajs/web";
 /**
- * `@nifrajs/web-solid/query` — Solid bindings for the keyed query-cache. `createQuery(key, fn)` bridges a
+ * `@nifrajs/web-solid/query` - Solid bindings for the keyed query-cache. `createQuery(key, fn)` bridges a
  * query's `subscribe`/`snapshot` store into a Solid signal and fetches on mount; `useQueryClient`
  * exposes `invalidateQueries` for after a mutation. Imports only `solid-js` + `@nifrajs/web` (never
  * `solid-js/web`), so route components use it on the server *and* client. No JSX.
  *
- * The query client is created lazily **client-side only** (`typeof window`) — on the server the
+ * The query client is created lazily **client-side only** (`typeof window`) - on the server the
  * accessor returns the idle/pending state (queries are client-first; loaders are the SSR data source).
  * The `key` is captured once (Solid setup runs once); a reactive key is a documented future enhancement.
  */