create-nifra 0.1.0-alpha.1

package/template-site/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/routes/_layout.tsx

@@ -0,0 +1,40 @@
+import type { ReactNode } from "react"
+
+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?: ReactNode }) {
+  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/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 + React 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, React. 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/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/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/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/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/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "verbatimModuleSyntax": true,
+    "types": ["react", "react-dom"]
+  },
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "dist-bun",
+    "dist-node",
+    "dist-deno",
+    "dist-vercel",
+    ".nifra",
+    ".wrangler",
+    "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/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-preact/.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-preact/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-preact/README.md

@@ -0,0 +1,43 @@
+# nifra site (Preact)
+
+A nifra + **Preact** 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 Preact function components (JSX, via `jsxImportSource: "preact"`) 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`.
+
+## 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` |
+
+The routes, `backend.ts`, and the client bundle are shared; each `build*` script swaps `buildServer`'s
+target/conditions and the server entry. 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 (preactAdapter) — imported by the server entries (edge-bundlable)
+nifra.config.ts the nifra CLI's dev/build config (adapter + clientModule + Vite plugin) — 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-preact/_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-preact/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-preact/build-bun.ts

@@ -0,0 +1,27 @@
+// 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"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist-bun`
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-preact/client",
+  conditions: ["bun", "browser"],
+  define: { "process.env.NODE_ENV": '"production"' },
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-bun.ts`,
+  outDir: `${dir}/.build-bun`,
+  target: "bun",
+  clientEntry: client.entry,
+})
+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-preact/build-deno.ts

@@ -0,0 +1,25 @@
+// Build for Deno → dist-deno/ (server-deno.js + client assets). `bun run build:deno`.
+import { cpSync, mkdirSync, rmSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist-deno`
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-preact/client",
+  conditions: ["bun", "browser"],
+  define: { "process.env.NODE_ENV": '"production"' },
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-deno.ts`,
+  outDir: `${dir}/.build-deno`,
+  clientEntry: client.entry,
+})
+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-preact/build-node.ts

@@ -0,0 +1,26 @@
+// Build for Node → dist-node/ (server-node.js + client assets). `bun run build:node`.
+import { cpSync, mkdirSync, rmSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist-node`
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-preact/client",
+  conditions: ["bun", "browser"],
+  define: { "process.env.NODE_ENV": '"production"' },
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-node.ts`,
+  outDir: `${dir}/.build-node`,
+  target: "node",
+  clientEntry: client.entry,
+})
+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-preact/build-vercel.ts

@@ -0,0 +1,45 @@
+// Build for Vercel, emitting Vercel's Build Output API v3 at .vercel/output/ so it deploys with no
+// framework preset: `vercel deploy --prebuilt`. Layout:
+//   .vercel/output/config.json                   — serve static files, else SSR via the function
+//   .vercel/output/static/assets/<client bundle>  — Vercel's CDN serves these directly
+//   .vercel/output/functions/index.func/index.js  — the Edge SSR function (+ .vc-config.json)
+import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+
+const dir = import.meta.dir
+const out = `${dir}/.vercel/output`
+const fn = `${out}/functions/index.func`
+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-preact/client",
+  conditions: ["bun", "browser"],
+  define: { "process.env.NODE_ENV": '"production"' },
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-vercel.ts`,
+  outDir: `${dir}/.build-vercel`,
+  clientEntry: client.entry,
+})
+cpSync(worker, `${fn}/index.js`)
+rmSync(`${dir}/.build-vercel`, { recursive: true, force: true })
+
+// Build Output API v3: serve real files first (`handle: filesystem` → /assets/*), then SSR the rest.
+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-preact/build.ts

@@ -0,0 +1,29 @@
+// Build for Cloudflare Pages → dist/ (_worker.js + _routes.json + client assets). `bun run build`.
+import { cpSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist`
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-preact/client",
+  conditions: ["bun", "browser"],
+  define: { "process.env.NODE_ENV": '"production"' },
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/_worker.ts`,
+  outDir: `${dir}/.build`,
+  clientEntry: client.entry,
+})
+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-preact/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-preact/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 { preactAdapter } from "@nifrajs/web-preact"
+
+export const adapter = preactAdapter

package/template-site-preact/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-preact/nifra.config.ts

@@ -0,0 +1,9 @@
+// The nifra CLI's config — read by `nifra dev|build|start`. Separate from `framework.ts` (which the
+// edge/server entries import, so it must stay edge-bundlable): THIS file is imported only by the CLI
+// (which runs on Bun), so it's the place for dev/build tooling like the Vite plugin. Preact JSX is
+// Bun-native, so the only extra is the Vite plugin for dev HMR (`@preact/preset-vite` = prefresh).
+import preact from "@preact/preset-vite"
+
+export { adapter } from "./framework"
+export const clientModule = "@nifrajs/web-preact/client"
+export const vitePlugins = [preact()]

package/template-site-preact/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "nifra-site",
+  "version": "0.0.0",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "nifra dev",
+    "preview": "bunx wrangler pages dev dist",
+    "build": "bun run build.ts",
+    "build:bun": "bun run build-bun.ts",
+    "build:node": "bun run build-node.ts",
+    "build:deno": "bun run build-deno.ts",
+    "build:vercel": "bun run build-vercel.ts",
+    "start": "bun dist-bun/server-bun.js",
+    "start:node": "node dist-node/server-node.js",
+    "deploy:cf": "wrangler pages deploy dist",
+    "deploy:vercel": "vercel deploy --prebuilt"
+  },
+  "dependencies": {
+    "@nifrajs/client": "^0.1.0",
+    "@nifrajs/core": "^0.1.0",
+    "@nifrajs/deno": "^0.1.0",
+    "@nifrajs/node": "^0.1.0",
+    "@nifrajs/web": "^0.1.0",
+    "@nifrajs/web-preact": "^0.1.0",
+    "preact": "^10.25.0"
+  },
+  "devDependencies": {
+    "@preact/preset-vite": "^2.9.0",
+    "@nifrajs/cli": "^0.1.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.0"
+  }
+}