create-nifra 0.1.0-alpha.1

package/template-site-preact/routes/_404.tsx

@@ -0,0 +1,20 @@
+import Layout from "./_layout"
+
+export const meta = { title: "Not found" }
+
+// nifra's catch-all renders _404 without the layout chain, so it wraps itself in the root Layout.
+export default function NotFound() {
+  return (
+    <Layout>
+      <section className="hero">
+        <h1>
+          <span className="grad">404</span>
+        </h1>
+        <p>That page doesn't exist.</p>
+        <a className="btn" href="/">
+          ← Back home
+        </a>
+      </section>
+    </Layout>
+  )
+}

package/template-site-preact/routes/_layout.tsx

@@ -0,0 +1,40 @@
+import type { ComponentChildren } from "preact"
+
+const css = `
+  :root { --bg:#0a0a0f; --panel:#14141c; --border:#26263a; --fg:#e8e8f0; --muted:#9a9ab0; --accent:#7c5cff; --accent2:#00d4ff; }
+  * { box-sizing: border-box; } html { color-scheme: dark; }
+  body { margin:0; background:var(--bg); color:var(--fg); font:16px/1.6 ui-sans-serif,system-ui,-apple-system,"Segoe UI",Roboto,sans-serif; -webkit-font-smoothing:antialiased; }
+  a { color:var(--accent2); text-decoration:none; } a:hover { text-decoration:underline; }
+  .wrap { max-width:840px; margin:0 auto; padding:0 24px; }
+  header.site { border-bottom:1px solid var(--border); } header.site .wrap { display:flex; align-items:center; justify-content:space-between; height:62px; }
+  .logo, .logo b { font-weight:800; font-size:20px; } .logo b { background:linear-gradient(90deg,var(--accent),var(--accent2)); -webkit-background-clip:text; background-clip:text; color:transparent; }
+  .hero { text-align:center; padding:80px 0 56px; }
+  .hero h1 { font-size:clamp(36px,6vw,56px); line-height:1.05; margin:0 0 16px; letter-spacing:-0.03em; }
+  .hero h1 .grad { background:linear-gradient(90deg,var(--accent),var(--accent2)); -webkit-background-clip:text; background-clip:text; color:transparent; }
+  .hero p { font-size:19px; color:var(--muted); max-width:560px; margin:0 auto 28px; }
+  .card { background:var(--panel); border:1px solid var(--border); border-radius:14px; padding:24px 28px; display:flex; align-items:center; justify-content:space-between; gap:24px; flex-wrap:wrap; }
+  .card h3 { margin:0 0 4px; } .card p { margin:0; color:var(--muted); font-size:14px; }
+  .count { font-size:34px; font-weight:800; font-variant-numeric:tabular-nums; min-width:44px; text-align:center; background:linear-gradient(90deg,var(--accent),var(--accent2)); -webkit-background-clip:text; background-clip:text; color:transparent; }
+  .btn { background:linear-gradient(90deg,var(--accent),var(--accent2)); color:#0a0a0f; font:inherit; font-weight:700; border:none; cursor:pointer; padding:11px 20px; border-radius:10px; }
+  footer.site { border-top:1px solid var(--border); color:var(--muted); font-size:14px; } footer.site .wrap { padding:24px; }
+`.trim()
+
+export default function Layout(props: { children?: ComponentChildren }) {
+  return (
+    <div id="app">
+      <style>{css}</style>
+      <header className="site">
+        <div className="wrap">
+          <a href="/" className="logo">
+            <b>nifra</b>
+          </a>
+          <a href="https://github.com">GitHub</a>
+        </div>
+      </header>
+      <main className="wrap">{props.children}</main>
+      <footer className="site">
+        <div className="wrap">Built with nifra</div>
+      </footer>
+    </div>
+  )
+}

package/template-site-preact/routes/index.tsx

@@ -0,0 +1,53 @@
+import type { ActionArgs, LoaderArgs, LoaderData } from "@nifrajs/client"
+import type { backend } from "../backend"
+
+export const meta = {
+  title: "nifra site",
+  meta: [{ name: "description", content: "A nifra + Preact SSR site, deployable to every runtime." }],
+}
+
+// Loader runs on the server (in-process during SSR). The action handles the form POST; after a
+// client submit the loader revalidates with no full reload (progressive enhancement).
+export async function loader({ api }: LoaderArgs<typeof backend>) {
+  const res = await api.count.get()
+  return { count: res.data?.count ?? 0 }
+}
+
+export async function action({ api }: ActionArgs<typeof backend>) {
+  await api.count.post()
+  return { ok: true }
+}
+
+export default function Home(props: { data: LoaderData<typeof loader> }) {
+  return (
+    <>
+      <section className="hero">
+        <h1>
+          Your nifra app,
+          <br />
+          <span className="grad">everywhere.</span>
+        </h1>
+        <p>
+          SSR + hydration, end-to-end types, Preact. One source — deploy to Cloudflare Pages, Node,
+          Deno, or Vercel Edge. Edit <code>routes/index.tsx</code> to begin.
+        </p>
+      </section>
+
+      <div className="card">
+        <div>
+          <h3>Live full-stack loop</h3>
+          <p>
+            Count is rendered by a typed <code>loader</code>, incremented by an <code>action</code>,
+            revalidated with no full reload.
+          </p>
+        </div>
+        <form method="post" style={{ display: "flex", alignItems: "center", gap: 16 }}>
+          <span className="count">{props.data.count}</span>
+          <button className="btn" type="submit">
+            increment →
+          </button>
+        </form>
+      </div>
+    </>
+  )
+}

package/template-site-preact/server-bun.ts

@@ -0,0 +1,35 @@
+import { inProcessClient } from "@nifrajs/client"
+import { createWebApp } from "@nifrajs/web"
+import { backend } from "./backend"
+import { adapter } from "./framework"
+import { clientEntry, manifest } from "./server-manifest"
+
+const app = createWebApp({
+  adapter,
+  manifest,
+  clientEntry,
+  api: inProcessClient(backend),
+  title: "nifra site",
+})
+
+// Bun (nifra's flagship runtime): Bun.serve handles app.fetch; serve the client bundle (/assets/*)
+// from disk with Bun.file. Assets live next to this file in the built dist-bun/ output.
+const ASSETS = new URL("./assets/", import.meta.url)
+const TYPES: Readonly<Record<string, string>> = { js: "text/javascript", css: "text/css" }
+
+const server = Bun.serve({
+  port: Number(Bun.env.PORT ?? 3000),
+  async fetch(req) {
+    const { pathname } = new URL(req.url)
+    if (pathname.startsWith("/assets/")) {
+      const name = pathname.slice("/assets/".length)
+      if (!/^[A-Za-z0-9._-]+$/.test(name)) return new Response("bad request", { status: 400 })
+      const file = Bun.file(new URL(name, ASSETS))
+      if (!(await file.exists())) return new Response("not found", { status: 404 })
+      const ext = name.slice(name.lastIndexOf(".") + 1)
+      return new Response(file, { headers: { "content-type": TYPES[ext] ?? "application/octet-stream" } })
+    }
+    return app.fetch(req)
+  },
+})
+console.log(`nifra (Bun) → http://localhost:${server.port}`)

package/template-site-preact/server-deno.ts

@@ -0,0 +1,38 @@
+import { inProcessClient } from "@nifrajs/client"
+import { serve } from "@nifrajs/deno"
+import { createWebApp } from "@nifrajs/web"
+import { backend } from "./backend"
+import { adapter } from "./framework"
+import { clientEntry, manifest } from "./server-manifest"
+
+const app = createWebApp({
+  adapter,
+  manifest,
+  clientEntry,
+  api: inProcessClient(backend),
+  title: "nifra site",
+})
+
+const ASSETS = new URL("./assets/", import.meta.url)
+const TYPES: Readonly<Record<string, string>> = { js: "text/javascript", css: "text/css" }
+
+await serve(
+  {
+    async fetch(req) {
+      const { pathname } = new URL(req.url)
+      if (pathname.startsWith("/assets/")) {
+        const name = pathname.slice("/assets/".length)
+        if (!/^[A-Za-z0-9._-]+$/.test(name)) return new Response("bad request", { status: 400 })
+        try {
+          const body = await Deno.readFile(new URL(name, ASSETS))
+          const ext = name.slice(name.lastIndexOf(".") + 1)
+          return new Response(body, { headers: { "content-type": TYPES[ext] ?? "application/octet-stream" } })
+        } catch {
+          return new Response("not found", { status: 404 })
+        }
+      }
+      return app.fetch(req)
+    },
+  },
+  { port: Number(Deno.env.get("PORT") ?? "3000") },
+)

package/template-site-preact/server-node.ts

@@ -0,0 +1,40 @@
+import { readFile } from "node:fs/promises"
+import { inProcessClient } from "@nifrajs/client"
+import { serve } from "@nifrajs/node"
+import { createWebApp } from "@nifrajs/web"
+import { backend } from "./backend"
+import { adapter } from "./framework"
+import { clientEntry, manifest } from "./server-manifest"
+
+const app = createWebApp({
+  adapter,
+  manifest,
+  clientEntry,
+  api: inProcessClient(backend),
+  title: "nifra site",
+})
+
+// @nifrajs/node serves app.fetch only — so serve /assets/* (the client bundle) from disk here.
+const ASSETS = new URL("./assets/", import.meta.url)
+const TYPES: Readonly<Record<string, string>> = { js: "text/javascript", css: "text/css" }
+
+await serve(
+  {
+    async fetch(req) {
+      const { pathname } = new URL(req.url)
+      if (pathname.startsWith("/assets/")) {
+        const name = pathname.slice("/assets/".length)
+        if (!/^[A-Za-z0-9._-]+$/.test(name)) return new Response("bad request", { status: 400 })
+        try {
+          const body = await readFile(new URL(name, ASSETS))
+          const ext = name.slice(name.lastIndexOf(".") + 1)
+          return new Response(body, { headers: { "content-type": TYPES[ext] ?? "application/octet-stream" } })
+        } catch {
+          return new Response("not found", { status: 404 })
+        }
+      }
+      return app.fetch(req)
+    },
+  },
+  { port: Number(process.env.PORT ?? 3000) },
+)

package/template-site-preact/server-vercel.ts

@@ -0,0 +1,17 @@
+import { inProcessClient } from "@nifrajs/client"
+import { createWebApp } from "@nifrajs/web"
+import { backend } from "./backend"
+import { adapter } from "./framework"
+import { clientEntry, manifest } from "./server-manifest"
+
+const app = createWebApp({
+  adapter,
+  manifest,
+  clientEntry,
+  api: inProcessClient(backend),
+  title: "nifra site",
+})
+
+// Vercel Edge Function — Vercel serves /assets/* from its CDN, so this only SSRs page routes.
+export const config = { runtime: "edge" }
+export default (req: Request): Response | Promise<Response> => app.fetch(req)

package/template-site-preact/tsconfig.json

@@ -0,0 +1,38 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "verbatimModuleSyntax": true
+  },
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "dist-bun",
+    "dist-node",
+    "dist-deno",
+    "dist-vercel",
+    ".nifra",
+    ".wrangler",
+    ".vercel",
+    "server-manifest.ts",
+    "server-bun.ts",
+    "server-node.ts",
+    "server-deno.ts",
+    "server-vercel.ts",
+    "_worker.ts",
+    "build.ts",
+    "build-bun.ts",
+    "build-node.ts",
+    "build-deno.ts",
+    "build-vercel.ts"
+  ]
+}

package/template-site-preact/wrangler.toml

@@ -0,0 +1,4 @@
+name = "nifra-site"
+pages_build_output_dir = "dist"
+compatibility_date = "2025-01-01"
+compatibility_flags = ["nodejs_compat"]

package/template-site-solid/.dockerignore

@@ -0,0 +1,14 @@
+node_modules
+dist
+dist-node
+dist-bun
+dist-deno
+.vercel
+.build
+.build-node
+.build-bun
+.build-deno
+.build-vercel
+.wrangler
+.git
+*.log

package/template-site-solid/Dockerfile

@@ -0,0 +1,20 @@
+# nifra on Node, containerized. Build with Bun (nifra's build toolchain), then run the self-contained
+# bundle on a slim Node image — the final image carries no build tools or node_modules.
+#   docker build -t my-nifra-app .
+#   docker run -p 3000:3000 my-nifra-app
+FROM oven/bun:1 AS build
+WORKDIR /app
+# Copy manifests first so the install layer caches across source-only changes.
+COPY package.json bun.lock* ./
+RUN bun install
+COPY . .
+RUN bun run build:node
+
+FROM node:22-slim AS run
+WORKDIR /app
+ENV NODE_ENV=production
+ENV PORT=3000
+# build:node emits a self-contained server-bundle + the client assets it serves from disk.
+COPY --from=build /app/dist-node ./dist-node
+EXPOSE 3000
+CMD ["node", "dist-node/server-node.js"]

package/template-site-solid/README.md

@@ -0,0 +1,43 @@
+# nifra site (Solid)
+
+A nifra + **Solid** SSR site — file-based routes, typed loaders/actions, hydration — that deploys to
+**Bun, Node (Docker), Deno Deploy, Cloudflare Pages, and Vercel Edge from one source**. `app.fetch`
+is Web-standard, so only the server entry + build target differ per platform.
+
+```sh
+bun install
+bun run dev        # nifra dev → true-HMR dev server (Vite + nifra SSR) at http://localhost:3000
+bun run preview    # wrangler pages dev dist → preview the built Cloudflare bundle (run `bun run build` first)
+```
+
+Routes are Solid function components (JSX, compiled by `solidBunPlugin`) under `routes/` — `index.tsx`
+(landing + a live loader/action counter), `_layout.tsx` (chrome), `_404.tsx`. The frontend adapter is
+one line in `framework.ts`; data lives behind `backend.ts`. Each `build*` script wires
+`solidBunPlugin("dom")` for the client and `("ssr")` + the `solid` export condition for the server.
+
+## Deploy — pick a target
+
+| target | build | deploy |
+| --- | --- | --- |
+| **Bun** (flagship) | `bun run build:bun` | `bun run start` — any host |
+| **Node** | `bun run build:node` | `docker build -t app . && docker run -p 3000:3000 app` (or `bun run start:node`) |
+| **Deno Deploy** | `bun run build:deno` | `deployctl deploy --prod --entrypoint=dist-deno/server-deno.js` |
+| **Cloudflare Pages** | `bun run build` | `bun run deploy:cf` |
+| **Vercel Edge** | `bun run build:vercel` | `bun run deploy:vercel` |
+
+nifra never enters your cloud credentials — it scaffolds the configs (`Dockerfile`, `deno.json`,
+`wrangler.toml`, Vercel Build Output API); you run the vendor CLI.
+
+## Structure
+
+```
+routes/        index.tsx (landing), _layout.tsx (chrome), _404.tsx
+framework.ts   the adapter (solidAdapter) — imported by the server entries (edge-bundlable)
+nifra.config.ts the nifra CLI's dev/build config (adapter + clientModule + Solid plugins) — read by `nifra dev`
+backend.ts     your contract (loaders/actions call it in-process)
+server-bun.ts  Bun entry (Bun.serve)         build-bun.ts    → dist-bun/
+_worker.ts     Cloudflare Pages entry        build.ts        → dist/
+server-node.ts Node entry (@nifrajs/node)       build-node.ts   → dist-node/   (Dockerfile)
+server-deno.ts Deno entry (@nifrajs/deno)       build-deno.ts   → dist-deno/    (deno.json)
+server-vercel.ts Vercel Edge function        build-vercel.ts → .vercel/output/
+```

package/template-site-solid/_worker.ts

@@ -0,0 +1,17 @@
+import { inProcessClient } from "@nifrajs/client"
+import { toFetchHandler } from "@nifrajs/core"
+import { createWebApp } from "@nifrajs/web"
+import { backend } from "./backend"
+import { adapter } from "./framework"
+import { clientEntry, manifest } from "./server-manifest"
+
+const app = createWebApp({
+  adapter,
+  manifest,
+  clientEntry,
+  api: inProcessClient(backend),
+  title: "nifra site",
+})
+
+// Cloudflare Pages: _routes.json serves /assets/* statically; everything else hits this (SSR).
+export default toFetchHandler(app)

package/template-site-solid/backend.ts

@@ -0,0 +1,12 @@
+import { server } from "@nifrajs/core"
+
+// Your backend contract — page loaders/actions call it in-process during SSR (no network). Replace
+// the demo counter with real data (KV/D1/Postgres/…); on the edge, reach bindings via `c.env`.
+let count = 0
+
+export const backend = server()
+  .get("/count", () => ({ count }))
+  .post("/count", () => {
+    count += 1
+    return { count }
+  })

package/template-site-solid/build-bun.ts

@@ -0,0 +1,33 @@
+// Build for Bun (nifra's flagship runtime) → dist-bun/ (server-bun.js + client assets).
+// `bun run build:bun`. Run: `bun dist-bun/server-bun.js`.
+import { cpSync, mkdirSync, rmSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+import { solidBunPlugin } from "@nifrajs/web-solid"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist-bun`
+const define = { "process.env.NODE_ENV": '"production"' }
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-solid/client",
+  plugins: [solidBunPlugin("dom")],
+  conditions: ["bun", "solid", "browser"],
+  define,
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-bun.ts`,
+  outDir: `${dir}/.build-bun`,
+  target: "bun",
+  clientEntry: client.entry,
+  plugins: [solidBunPlugin("ssr")],
+  conditions: ["bun", "solid"],
+  define,
+})
+cpSync(worker, `${dist}/server-bun.js`)
+rmSync(`${dir}/.build-bun`, { recursive: true, force: true })
+console.log("Bun output → dist-bun (run: bun dist-bun/server-bun.js)")

package/template-site-solid/build-deno.ts

@@ -0,0 +1,32 @@
+// Build for Deno → dist-deno/ (server-deno.js + client assets). `bun run build:deno`.
+// Run: `deno task start` (or deployctl). Deno runs the edge bundle (workerd/edge-light + solid).
+import { cpSync, mkdirSync, rmSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+import { solidBunPlugin } from "@nifrajs/web-solid"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist-deno`
+const define = { "process.env.NODE_ENV": '"production"' }
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-solid/client",
+  plugins: [solidBunPlugin("dom")],
+  conditions: ["bun", "solid", "browser"],
+  define,
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-deno.ts`,
+  outDir: `${dir}/.build-deno`,
+  clientEntry: client.entry,
+  plugins: [solidBunPlugin("ssr")],
+  conditions: ["workerd", "edge-light", "solid", "browser"],
+  define,
+})
+cpSync(worker, `${dist}/server-deno.js`)
+rmSync(`${dir}/.build-deno`, { recursive: true, force: true })
+console.log("Deno output → dist-deno (run: deno run -A dist-deno/server-deno.js)")

package/template-site-solid/build-node.ts

@@ -0,0 +1,33 @@
+// Build for Node → dist-node/ (server-node.js + client assets). `bun run build:node`.
+// Run: `node dist-node/server-node.js` (or the Dockerfile). `node`+`solid` → solid-js/web's server build.
+import { cpSync, mkdirSync, rmSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+import { solidBunPlugin } from "@nifrajs/web-solid"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist-node`
+const define = { "process.env.NODE_ENV": '"production"' }
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-solid/client",
+  plugins: [solidBunPlugin("dom")],
+  conditions: ["bun", "solid", "browser"],
+  define,
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-node.ts`,
+  outDir: `${dir}/.build-node`,
+  target: "node",
+  clientEntry: client.entry,
+  plugins: [solidBunPlugin("ssr")],
+  conditions: ["node", "solid"],
+  define,
+})
+cpSync(worker, `${dist}/server-node.js`)
+rmSync(`${dir}/.build-node`, { recursive: true, force: true })
+console.log("Node output → dist-node (run: node dist-node/server-node.js)")

package/template-site-solid/build-vercel.ts

@@ -0,0 +1,47 @@
+// Build for Vercel, emitting Vercel's Build Output API v3 at .vercel/output/ so it deploys with no
+// framework preset: `vercel deploy --prebuilt`.
+import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+import { solidBunPlugin } from "@nifrajs/web-solid"
+
+const dir = import.meta.dir
+const out = `${dir}/.vercel/output`
+const fn = `${out}/functions/index.func`
+const define = { "process.env.NODE_ENV": '"production"' }
+rmSync(`${dir}/.vercel`, { recursive: true, force: true })
+mkdirSync(`${out}/static/assets`, { recursive: true })
+mkdirSync(fn, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${out}/static/assets`,
+  clientModule: "@nifrajs/web-solid/client",
+  plugins: [solidBunPlugin("dom")],
+  conditions: ["bun", "solid", "browser"],
+  define,
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-vercel.ts`,
+  outDir: `${dir}/.build-vercel`,
+  clientEntry: client.entry,
+  plugins: [solidBunPlugin("ssr")],
+  conditions: ["workerd", "edge-light", "solid", "browser"],
+  define,
+})
+cpSync(worker, `${fn}/index.js`)
+rmSync(`${dir}/.build-vercel`, { recursive: true, force: true })
+
+writeFileSync(
+  `${fn}/.vc-config.json`,
+  `${JSON.stringify({ runtime: "edge", entrypoint: "index.js" }, null, 2)}\n`,
+)
+writeFileSync(
+  `${out}/config.json`,
+  `${JSON.stringify(
+    { version: 3, routes: [{ handle: "filesystem" }, { src: "/(.*)", dest: "/index" }] },
+    null,
+    2,
+  )}\n`,
+)
+console.log("Vercel output → .vercel/output (deploy: vercel deploy --prebuilt)")

package/template-site-solid/build.ts

@@ -0,0 +1,36 @@
+// Build for Cloudflare Pages → dist/ (_worker.js + _routes.json + client assets). `bun run build`.
+// Solid: solidBunPlugin("dom") for the client, ("ssr") for the server + the `solid` export condition.
+import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+import { solidBunPlugin } from "@nifrajs/web-solid"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist`
+const define = { "process.env.NODE_ENV": '"production"' }
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-solid/client",
+  plugins: [solidBunPlugin("dom")],
+  conditions: ["bun", "solid", "browser"],
+  define,
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/_worker.ts`,
+  outDir: `${dir}/.build`,
+  clientEntry: client.entry,
+  plugins: [solidBunPlugin("ssr")],
+  conditions: ["workerd", "edge-light", "solid", "browser"],
+  define,
+})
+cpSync(worker, `${dist}/_worker.js`)
+rmSync(`${dir}/.build`, { recursive: true, force: true })
+writeFileSync(
+  `${dist}/_routes.json`,
+  `${JSON.stringify({ version: 1, include: ["/*"], exclude: ["/assets/*"] }, null, 2)}\n`,
+)
+console.log("Cloudflare Pages output → dist (deploy: wrangler pages deploy dist)")

package/template-site-solid/deno.json

@@ -0,0 +1,7 @@
+{
+  "tasks": {
+    "build": "bun run build-deno.ts",
+    "start": "deno run --allow-net --allow-read --allow-env dist-deno/server-deno.js"
+  },
+  "//": "Build with Bun (nifra's toolchain), run/deploy the self-contained bundle on Deno. Deploy to Deno Deploy: deployctl deploy --prod --entrypoint=dist-deno/server-deno.js"
+}

package/template-site-solid/framework.ts

@@ -0,0 +1,6 @@
+// The frontend adapter for this app. `create-nifra --framework <react|preact|vue|solid|svelte>` swaps
+// this one line (and the routes + build config); every server entry imports the adapter from here, so
+// they stay framework-agnostic.
+import { solidAdapter } from "@nifrajs/web-solid"
+
+export const adapter = solidAdapter

package/template-site-solid/gitignore

@@ -0,0 +1,16 @@
+node_modules
+dist
+dist-bun
+dist-node
+dist-deno
+.vercel
+.build
+.build-bun
+.build-node
+.build-deno
+.build-vercel
+.wrangler
+# generated by buildServer next to the entry
+server-manifest.ts
+# generated by `nifra dev` (the Vite dev client entry) at the project root
+.nifra-vite-entry.tsx

package/template-site-solid/nifra.config.ts

@@ -0,0 +1,14 @@
+// The nifra CLI's config — read by `nifra dev|build|start`. It's imported ONLY by the CLI (which runs on
+// Bun), so it can eagerly import the Vite plugin + the Solid compile plugin — keeping them OUT of the
+// edge worker bundle that `framework.ts` (the render-adapter source the entries import) must stay free
+// of. Solid needs the `"solid"` resolve condition (routes solid-js to its source / JSX-dev build).
+import { solidBunPlugin } from "@nifrajs/web-solid"
+import solid from "vite-plugin-solid"
+
+export { adapter } from "./framework"
+export const clientModule = "@nifrajs/web-solid/client"
+// `ssr: true` makes vite-plugin-solid emit hydratable client output, matching nifra's Bun SSR.
+export const vitePlugins = [solid({ ssr: true })]
+export const clientPlugins = [solidBunPlugin("dom")]
+export const serverPlugins = [solidBunPlugin("ssr")]
+export const conditions = ["solid"]