@nifrajs/web-solid 0.1.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import type { RenderAdapter } from "@nifrajs/web";
+import type { BunPlugin } from "bun";
+/** 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"`
+ * 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.
+ */
+export declare function solidBunPlugin(generate: "dom" | "ssr"): BunPlugin;
+//# 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":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAGjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAUpC,6EAA6E;AAC7E,eAAO,MAAM,YAAY,EAAE,aAsB1B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CAqBjE"}

package/dist/index.js

@@ -0,0 +1,67 @@
+/**
+ * @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
+import presetTypeScript from "@babel/preset-typescript";
+// @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`. */
+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
+    // 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
+        // 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.
+        const ts = new TransformStream();
+        solidRenderToStream(compose(chain, props)).pipeTo(ts.writable);
+        return ts.readable;
+    },
+    hydrationHead() {
+        return HYDRATION_HEAD;
+    },
+};
+/**
+ * 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.
+ */
+export function solidBunPlugin(generate) {
+    return {
+        name: `nifra-solid-${generate}`,
+        setup(build) {
+            // Match `.tsx`, tolerating a `?query` suffix (dev servers append one to bust Bun's import
+            // cache); strip it before reading the file off disk.
+            build.onLoad({ filter: /\.tsx(\?|$)/ }, async (args) => {
+                const path = args.path.split("?")[0] ?? args.path;
+                const source = await Bun.file(path).text();
+                const result = await transformAsync(source, {
+                    filename: path,
+                    // babel applies presets last→first: strip TS first, then Solid transforms JSX.
+                    presets: [
+                        [presetSolid, { generate, hydratable: true }],
+                        [presetTypeScript, { onlyRemoveTypeImports: true }],
+                    ],
+                });
+                return { contents: result?.code ?? "", loader: "js" };
+            });
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,oDAAoD;AACpD,OAAO,gBAAgB,MAAM,0BAA0B,CAAA;AAEvD,oDAAoD;AACpD,OAAO,WAAW,MAAM,oBAAoB,CAAA;AAE5C,OAAO,EACL,uBAAuB,EACvB,cAAc,IAAI,mBAAmB,EACrC,cAAc,IAAI,mBAAmB,GACtC,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,MAAM,cAAc,GAAG,uBAAuB,EAAE,CAAA;AAEhD,6EAA6E;AAC7E,MAAM,CAAC,MAAM,YAAY,GAAkB;IACzC,gGAAgG;IAChG,mFAAmF;IACnF,4FAA4F;IAC5F,iGAAiG;IACjG,kEAAkE;IAClE,cAAc,CAAC,KAAK,EAAE,KAAK;QACzB,OAAO,mBAAmB,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;IACnD,CAAC;IACD,cAAc,CAAC,KAAK,EAAE,KAAK;QACzB,uFAAuF;QACvF,2FAA2F;QAC3F,6FAA6F;QAC7F,4FAA4F;QAC5F,iCAAiC;QACjC,MAAM,EAAE,GAAG,IAAI,eAAe,EAA0B,CAAA;QACxD,mBAAmB,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAA;QAC9D,OAAO,EAAE,CAAC,QAAQ,CAAA;IACpB,CAAC;IACD,aAAa;QACX,OAAO,cAAc,CAAA;IACvB,CAAC;CACF,CAAA;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,QAAuB;IACpD,OAAO;QACL,IAAI,EAAE,eAAe,QAAQ,EAAE;QAC/B,KAAK,CAAC,KAAK;YACT,0FAA0F;YAC1F,qDAAqD;YACrD,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;gBACrD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAA;gBACjD,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAA;gBAC1C,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,MAAM,EAAE;oBAC1C,QAAQ,EAAE,IAAI;oBACd,+EAA+E;oBAC/E,OAAO,EAAE;wBACP,CAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;wBAC7C,CAAC,gBAAgB,EAAE,EAAE,qBAAqB,EAAE,IAAI,EAAE,CAAC;qBACpD;iBACF,CAAC,CAAA;gBACF,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAA;YACvD,CAAC,CAAC,CAAA;QACJ,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/mdx-runtime.d.ts

@@ -0,0 +1,4 @@
+/** Returns the intrinsic-element → Solid-component map MDX content uses. Merge in your own overrides by
+ * passing `components` to the MDX content component (they take precedence). */
+export declare function useMDXComponents(): Record<string, (props: Record<string, unknown>) => unknown>;
+//# sourceMappingURL=mdx-runtime.d.ts.map

package/dist/mdx-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdx-runtime.d.ts","sourceRoot":"","sources":["../src/mdx-runtime.ts"],"names":[],"mappings":"AAiDA;+EAC+E;AAC/E,wBAAgB,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,CAE9F"}

package/dist/mdx-runtime.js

@@ -0,0 +1,52 @@
+/**
+ * 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
+ * each Markdown-output tag to a Solid component that renders it via `<Dynamic component={tag}>`.
+ */
+import { createComponent } from "solid-js";
+import { Dynamic } from "solid-js/web";
+// The HTML element set CommonMark + GFM produce. An explicit map (not a Proxy): `@mdx-js` *spreads* the
+// provider's result into a plain object, so only own-enumerable keys survive.
+const MARKDOWN_TAGS = [
+    "a",
+    "blockquote",
+    "br",
+    "code",
+    "del",
+    "em",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "img",
+    "input",
+    "li",
+    "ol",
+    "p",
+    "pre",
+    "section",
+    "span",
+    "strong",
+    "sup",
+    "table",
+    "tbody",
+    "td",
+    "th",
+    "thead",
+    "tr",
+    "ul",
+];
+const components = {};
+for (const tag of MARKDOWN_TAGS) {
+    components[tag] = (props) => createComponent(Dynamic, Object.assign({ component: tag }, props));
+}
+/** Returns the intrinsic-element → Solid-component map MDX content uses. Merge in your own overrides by
+ * passing `components` to the MDX content component (they take precedence). */
+export function useMDXComponents() {
+    return components;
+}
+//# sourceMappingURL=mdx-runtime.js.map

package/dist/mdx-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdx-runtime.js","sourceRoot":"","sources":["../src/mdx-runtime.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,wGAAwG;AACxG,8EAA8E;AAC9E,MAAM,aAAa,GAAG;IACpB,GAAG;IACH,YAAY;IACZ,IAAI;IACJ,MAAM;IACN,KAAK;IACL,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,KAAK;IACL,OAAO;IACP,IAAI;IACJ,IAAI;IACJ,GAAG;IACH,KAAK;IACL,SAAS;IACT,MAAM;IACN,QAAQ;IACR,KAAK;IACL,OAAO;IACP,OAAO;IACP,IAAI;IACJ,IAAI;IACJ,OAAO;IACP,IAAI;IACJ,IAAI;CACI,CAAA;AAEV,MAAM,UAAU,GAAgE,EAAE,CAAA;AAClF,KAAK,MAAM,GAAG,IAAI,aAAa,EAAE,CAAC;IAChC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,KAAK,CAAC,CAAC,CAAA;AACjG,CAAC;AAED;+EAC+E;AAC/E,MAAM,UAAU,gBAAgB;IAC9B,OAAO,UAAU,CAAA;AACnB,CAAC"}

package/dist/mdx.d.ts

@@ -0,0 +1,5 @@
+import type { BunPlugin } from "bun";
+/** Build a `Bun.build` plugin that loads `.mdx` files as Solid components. `generate`: `"ssr"` for the
+ * server build, `"dom"` for the client (matches `solidBunPlugin`). */
+export declare function solidMdxBunPlugin(generate: "dom" | "ssr"): BunPlugin;
+//# sourceMappingURL=mdx.d.ts.map

package/dist/mdx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdx.d.ts","sourceRoot":"","sources":["../src/mdx.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AASpC;sEACsE;AACtE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CAmCpE"}

package/dist/mdx.js

@@ -0,0 +1,59 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * `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
+ * `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
+import presetTypeScript from "@babel/preset-typescript";
+// @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";
+/** Build a `Bun.build` plugin that loads `.mdx` files as Solid components. `generate`: `"ssr"` for the
+ * server build, `"dom"` for the client (matches `solidBunPlugin`). */
+export function solidMdxBunPlugin(generate) {
+    return {
+        name: `nifra-solid-mdx-${generate}`,
+        async setup(build) {
+            let compile;
+            try {
+                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`).");
+            }
+            build.onLoad({ filter: /\.mdx(\?|$)/ }, async (args) => {
+                const path = args.path.split("?")[0] ?? args.path;
+                // 1. MDX → JSX, with intrinsics provided by the Solid runtime (rendered via `<Dynamic>`).
+                const jsx = String(await compile(await Bun.file(path).text(), {
+                    jsx: true,
+                    providerImportSource: "@nifrajs/web-solid/mdx-runtime",
+                }));
+                // 2. babel-preset-solid (TS stripped first), exactly like `solidBunPlugin`.
+                const result = await transformAsync(jsx, {
+                    filename: `${path}.tsx`,
+                    presets: [
+                        [presetSolid, { generate, hydratable: true }],
+                        [presetTypeScript, { onlyRemoveTypeImports: true }],
+                    ],
+                    babelrc: false,
+                    configFile: false,
+                });
+                return { contents: result?.code ?? "", loader: "js" };
+            });
+        },
+    };
+}
+//# sourceMappingURL=mdx.js.map

package/dist/mdx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdx.js","sourceRoot":"","sources":["../src/mdx.ts"],"names":[],"mappings":";;;;;;;;AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,oDAAoD;AACpD,OAAO,gBAAgB,MAAM,0BAA0B,CAAA;AACvD,oDAAoD;AACpD,OAAO,WAAW,MAAM,oBAAoB,CAAA;AAG5C,wGAAwG;AACxG,MAAM,UAAU,GAAG,aAAa,CAAA;AAMhC;sEACsE;AACtE,MAAM,UAAU,iBAAiB,CAAC,QAAuB;IACvD,OAAO;QACL,IAAI,EAAE,mBAAmB,QAAQ,EAAE;QACnC,KAAK,CAAC,KAAK,CAAC,KAAK;YACf,IAAI,OAA+B,CAAA;YACnC,IAAI,CAAC;gBACH,OAAO,GAAI,CAAC,MAAM,MAAM,kCAAC,UAAU,EAAC,CAAiB,CAAC,OAAO,CAAA;YAC/D,CAAC;YAAC,MAAM,CAAC;gBACP,MAAM,IAAI,KAAK,CACb,gHAAgH,CACjH,CAAA;YACH,CAAC;YACD,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;gBACrD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAA;gBACjD,0FAA0F;gBAC1F,MAAM,GAAG,GAAG,MAAM,CAChB,MAAM,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;oBACzC,GAAG,EAAE,IAAI;oBACT,oBAAoB,EAAE,gCAAgC;iBACvD,CAAC,CACH,CAAA;gBACD,4EAA4E;gBAC5E,MAAM,MAAM,GAAG,MAAM,cAAc,CAAC,GAAG,EAAE;oBACvC,QAAQ,EAAE,GAAG,IAAI,MAAM;oBACvB,OAAO,EAAE;wBACP,CAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;wBAC7C,CAAC,gBAAgB,EAAE,EAAE,qBAAqB,EAAE,IAAI,EAAE,CAAC;qBACpD;oBACD,OAAO,EAAE,KAAK;oBACd,UAAU,EAAE,KAAK;iBAClB,CAAC,CAAA;gBACF,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAA;YACvD,CAAC,CAAC,CAAA;QACJ,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/query.d.ts

@@ -0,0 +1,28 @@
+import { type QueryClient, type QueryState } from "@nifrajs/web";
+/**
+ * `@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
+ * 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.
+ */
+import { type Accessor } from "solid-js";
+/** Access the query client to imperatively `invalidateQueries(keyOrPrefix)` (e.g. after a mutation). */
+export declare function useQueryClient(): Pick<QueryClient, "invalidateQueries">;
+/** A query's reactive state accessor plus `refetch`. */
+export interface CreateQueryResult<T> {
+    /** Reactive accessor for the {@link QueryState} (`status`/`data`/`error`/`isFetching`/`updatedAt`). */
+    readonly state: Accessor<QueryState<T>>;
+    /** Force a refetch (ignores `staleTime`). */
+    readonly refetch: () => Promise<T>;
+}
+/**
+ * Bind the keyed query for `key`, fetched via `fn`. Returns a reactive `state()` accessor + `refetch`.
+ * Concurrent `createQuery`s with the same key share one cache entry + one in-flight fetch (dedup).
+ * Fetches on mount; SSR-idle. Call inside a component (owns the subscription).
+ */
+export declare function createQuery<T>(key: unknown, fn: () => Promise<T>): CreateQueryResult<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,EAAqB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAA;AACnF;;;;;;;;;GASG;AACH,OAAO,EAAE,KAAK,QAAQ,EAAoC,MAAM,UAAU,CAAA;AAS1E,wGAAwG;AACxG,wBAAgB,cAAc,IAAI,IAAI,CAAC,WAAW,EAAE,mBAAmB,CAAC,CAEvE;AAUD,wDAAwD;AACxD,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC,uGAAuG;IACvG,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;IACvC,6CAA6C;IAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAA;CACnC;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAgBvF"}

package/dist/query.js

@@ -0,0 +1,54 @@
+import { createQueryClient } from "@nifrajs/web";
+/**
+ * `@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
+ * 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.
+ */
+import { createSignal, onCleanup, onMount } from "solid-js";
+let client;
+function getClient() {
+    if (typeof window === "undefined")
+        return undefined; // SSR → no client (queries render idle)
+    if (client === undefined)
+        client = createQueryClient({ now: () => Date.now() });
+    return client;
+}
+/** Access the query client to imperatively `invalidateQueries(keyOrPrefix)` (e.g. after a mutation). */
+export function useQueryClient() {
+    return getClient() ?? { invalidateQueries: () => { } };
+}
+const IDLE = Object.freeze({
+    status: "pending",
+    data: undefined,
+    error: undefined,
+    isFetching: false,
+    updatedAt: Number.NEGATIVE_INFINITY,
+});
+/**
+ * Bind the keyed query for `key`, fetched via `fn`. Returns a reactive `state()` accessor + `refetch`.
+ * Concurrent `createQuery`s with the same key share one cache entry + one in-flight fetch (dedup).
+ * Fetches on mount; SSR-idle. Call inside a component (owns the subscription).
+ */
+export function createQuery(key, fn) {
+    const handle = getClient()?.query(key, fn);
+    const [state, setState] = createSignal(handle ? handle.snapshot() : IDLE);
+    if (handle !== undefined) {
+        onCleanup(handle.subscribe(() => setState(() => handle.snapshot())));
+        onMount(() => {
+            handle.fetch().catch(() => { });
+        });
+        return { state, refetch: handle.refetch };
+    }
+    return {
+        state,
+        refetch: async () => {
+            throw new Error("[nifra/web-solid] createQuery.refetch called with no query client (server?)");
+        },
+    };
+}
+//# sourceMappingURL=query.js.map

package/dist/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAqC,MAAM,cAAc,CAAA;AACnF;;;;;;;;;GASG;AACH,OAAO,EAAiB,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAE1E,IAAI,MAA+B,CAAA;AACnC,SAAS,SAAS;IAChB,IAAI,OAAO,MAAM,KAAK,WAAW;QAAE,OAAO,SAAS,CAAA,CAAC,wCAAwC;IAC5F,IAAI,MAAM,KAAK,SAAS;QAAE,MAAM,GAAG,iBAAiB,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;IAC/E,OAAO,MAAM,CAAA;AACf,CAAC;AAED,wGAAwG;AACxG,MAAM,UAAU,cAAc;IAC5B,OAAO,SAAS,EAAE,IAAI,EAAE,iBAAiB,EAAE,GAAG,EAAE,GAAE,CAAC,EAAE,CAAA;AACvD,CAAC;AAED,MAAM,IAAI,GAAsB,MAAM,CAAC,MAAM,CAAC;IAC5C,MAAM,EAAE,SAAS;IACjB,IAAI,EAAE,SAAS;IACf,KAAK,EAAE,SAAS;IAChB,UAAU,EAAE,KAAK;IACjB,SAAS,EAAE,MAAM,CAAC,iBAAiB;CACpC,CAAC,CAAA;AAUF;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAI,GAAY,EAAE,EAAoB;IAC/D,MAAM,MAAM,GAAG,SAAS,EAAE,EAAE,KAAK,CAAI,GAAG,EAAE,EAAE,CAAC,CAAA;IAC7C,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,YAAY,CAAgB,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;IACxF,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAA;QACpE,OAAO,CAAC,GAAG,EAAE;YACX,MAAM,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAA;QAChC,CAAC,CAAC,CAAA;QACF,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAA;IAC3C,CAAC;IACD,OAAO;QACL,KAAK;QACL,OAAO,EAAE,KAAK,IAAI,EAAE;YAClB,MAAM,IAAI,KAAK,CAAC,6EAA6E,CAAC,CAAA;QAChG,CAAC;KACF,CAAA;AACH,CAAC"}

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@nifrajs/web-solid",
+  "version": "0.1.0-alpha.1",
+  "description": "Solid render adapter for @nifrajs/web — SSR + hydration + the Solid Babel build plugin.",
+  "keywords": [
+    "bun",
+    "typescript",
+    "nifra",
+    "web-framework",
+    "full-stack",
+    "edge",
+    "ssr"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "bun": "./src/client.ts",
+      "types": "./dist/client.d.ts",
+      "default": "./dist/client.js"
+    },
+    "./await": {
+      "bun": "./src/await.ts",
+      "types": "./dist/await.d.ts",
+      "default": "./dist/await.js"
+    },
+    "./fetcher": {
+      "bun": "./src/fetcher.ts",
+      "types": "./dist/fetcher.d.ts",
+      "default": "./dist/fetcher.js"
+    },
+    "./query": {
+      "bun": "./src/query.ts",
+      "types": "./dist/query.d.ts",
+      "default": "./dist/query.js"
+    },
+    "./i18n": {
+      "bun": "./src/i18n.ts",
+      "types": "./dist/i18n.d.ts",
+      "default": "./dist/i18n.js"
+    },
+    "./image": {
+      "bun": "./src/image.ts",
+      "types": "./dist/image.d.ts",
+      "default": "./dist/image.js"
+    },
+    "./content": {
+      "bun": "./src/content.ts",
+      "types": "./dist/content.d.ts",
+      "default": "./dist/content.js"
+    },
+    "./mdx": {
+      "bun": "./src/mdx.ts",
+      "types": "./dist/mdx.d.ts",
+      "default": "./dist/mdx.js"
+    },
+    "./mdx-runtime": {
+      "bun": "./src/mdx-runtime.ts",
+      "types": "./dist/mdx-runtime.d.ts",
+      "default": "./dist/mdx-runtime.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && bun run ../../scripts/fix-dts.ts dist"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@babel/core": "^7.26.0",
+    "@babel/preset-typescript": "^7.26.0",
+    "@nifrajs/i18n": "workspace:*",
+    "@nifrajs/image": "workspace:*",
+    "@nifrajs/web": "workspace:*",
+    "babel-preset-solid": "^1.9.3"
+  },
+  "peerDependencies": {
+    "@mdx-js/mdx": "^3",
+    "solid-js": "^1.9.0"
+  },
+  "peerDependenciesMeta": {
+    "@mdx-js/mdx": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/babel__core": "^7.20.5",
+    "solid-js": "^1.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nifrajs/nifra.git",
+    "directory": "packages/web-solid"
+  },
+  "bugs": {
+    "url": "https://github.com/nifrajs/nifra/issues"
+  },
+  "homepage": "https://github.com/nifrajs/nifra#readme"
+}

package/src/await.ts

@@ -0,0 +1,58 @@
+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 { createComponent, createResource, type JSX, Suspense } 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
+}
+
+function isDeferred<T>(value: Deferred<T> | T): value is Deferred<T> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    (value as { __nifra_deferred?: unknown }).__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<T>(props: AwaitProps<T>): JSX.Element {
+  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)
+    },
+  })
+}

package/src/client.ts

@@ -0,0 +1,89 @@
+import type { MountRouterOptions, RenderProps } 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
+ * 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.ts"
+import { setMountedRouter } from "./fetcher.ts"
+
+// 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.ts"
+
+/** Hydrate a server-rendered Solid layout `chain` (with the loader `props`) inside `container`. */
+export function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown): void {
+  solidHydrate(compose(chain, props), container as Element)
+}
+
+/**
+ * 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: MountRouterOptions): void {
+  const { router, routes, container } = options
+  setMountedRouter(router) // expose it to createFetcher/useFetchers (same page, client-only)
+  const el = container as Element
+
+  let dispose: (() => void) | undefined
+  let mountedRouteId: string | null = null
+  // The setter for the currently-mounted route's reactive props — same-route settles push through it.
+  let update: ((snapshot: ReturnType<typeof router.snapshot>) => void) | null = null
+
+  const mount = (first: boolean): void => {
+    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
+        },
+      } as RenderProps
+      // 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)
+    }
+  })
+}

package/src/compose.ts

@@ -0,0 +1,18 @@
+import type { RenderProps } from "@nifrajs/web"
+import { type Component, createComponent, 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 function compose(chain: readonly unknown[], props: RenderProps): () => JSX.Element {
+  const last = chain.length - 1
+  let node: () => JSX.Element = () => createComponent(chain[last] as Component<RenderProps>, props)
+  for (let i = last - 1; i >= 0; i--) {
+    const Layout = chain[i] as Component<{ children: JSX.Element }>
+    const child = node
+    node = () => createComponent(Layout, { children: child() })
+  }
+  return node
+}

package/src/content.ts

@@ -0,0 +1,30 @@
+/**
+ * `@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, type JSX, mergeProps, splitProps } from "solid-js"
+import { Dynamic } from "solid-js/web"
+
+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 function Content(props: ContentProps): JSX.Element {
+  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 })),
+  )
+}