create-nifra 0.1.0-alpha.1

package/template-isr/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). This demo
+// counts server renders so the ISR cache is observable: a cache HIT serves stored bytes (the loader
+// doesn't run, so the number holds), while a MISS or background REGENERATION runs it (it bumps).
+// Replace it with real data (KV/D1/Postgres/…); on the edge, reach bindings via `c.env`.
+let renders = 0
+
+export const backend = server().get("/page", () => {
+  renders += 1
+  return { renders }
+})

package/template-isr/build.ts

@@ -0,0 +1,23 @@
+// Build for Cloudflare Workers: (1) buildClient → public/assets (served by Workers Assets at
+// /assets/*), and (2) buildServer → dist-server/worker.js (the ISR worker). `bun run build`.
+import { buildClient, buildServer } from "@nifrajs/web/build"
+
+const dir = import.meta.dir
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dir}/public/assets`,
+  clientModule: "@nifrajs/web-react/client",
+  conditions: ["bun", "browser"],
+  define: { "process.env.NODE_ENV": '"production"' },
+})
+
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/worker.ts`,
+  outDir: `${dir}/dist-server`,
+  clientEntry: client.entry,
+})
+
+console.log("client entry:", client.entry)
+console.log("worker bundle:", worker, "→ run: bunx wrangler dev")

package/template-isr/gitignore

@@ -0,0 +1,7 @@
+node_modules
+public
+dist-server
+.build
+.wrangler
+# generated by buildServer next to the entry
+server-manifest.ts

package/template-isr/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "nifra-isr",
+  "version": "0.0.0",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "build": "bun run build.ts",
+    "dev": "bunx wrangler dev",
+    "dev:bun": "bun run server.ts"
+  },
+  "dependencies": {
+    "@nifrajs/client": "^0.1.0",
+    "@nifrajs/core": "^0.1.0",
+    "@nifrajs/web": "^0.1.0",
+    "@nifrajs/web-react": "^0.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "typescript": "^6.0.3"
+  }
+}

package/template-isr/routes/_404.tsx

@@ -0,0 +1,10 @@
+export default function NotFound() {
+  return (
+    <section>
+      <h2>404 — not found</h2>
+      <p>
+        <a href="/">← home</a>
+      </p>
+    </section>
+  )
+}

package/template-isr/routes/_layout.tsx

@@ -0,0 +1,18 @@
+import type { ReactNode } from "react"
+
+/** Root layout — rendered inside the document shell `renderPage` emits. */
+export default function Layout(props: { children?: ReactNode }) {
+  return (
+    <main
+      style={{
+        fontFamily: "system-ui, sans-serif",
+        maxWidth: 640,
+        margin: "3rem auto",
+        padding: "0 1rem",
+      }}
+    >
+      <h1>nifra + ISR</h1>
+      {props.children}
+    </main>
+  )
+}

package/template-isr/routes/index.tsx

@@ -0,0 +1,34 @@
+import type { LoaderArgs, LoaderData } from "@nifrajs/client"
+import type { backend } from "../backend"
+
+export const meta = {
+  title: "nifra + ISR",
+  meta: [{ name: "description", content: "Incremental Static Regeneration on nifra." }],
+}
+
+// ISR: the `withISR` wrapper (worker.ts / server.ts) caches this page and serves it
+// stale-while-revalidate. `revalidate` is the freshness window in SECONDS — nifra emits it as the
+// `x-nifra-isr-revalidate` header, which the wrapper reads to set this page's TTL. Loader/meta are
+// pure annotated exports, so they tree-shake out of the client bundle.
+export const revalidate = 10
+
+export async function loader({ api }: LoaderArgs<typeof backend>) {
+  const res = await api.page.get()
+  return { renders: res.data?.renders ?? 0 }
+}
+
+export default function Home(props: { data: LoaderData<typeof loader> }) {
+  return (
+    <section>
+      <p>
+        server renders: <b>{props.data.renders}</b>
+      </p>
+      <p>
+        Reload within {revalidate}s and this holds — you're served the cached page (response header{" "}
+        <code>x-nifra-isr: hit</code>). After the window, the next request gets the stale page
+        instantly (<code>stale</code>) while a fresh copy regenerates behind it. Edit{" "}
+        <code>routes/index.tsx</code> to begin.
+      </p>
+    </section>
+  )
+}

package/template-isr/server.ts

@@ -0,0 +1,56 @@
+/**
+ * Local Bun dev server (no wrangler) — the same app with an in-memory ISR store. `bun run dev:bun`
+ * after `bun run build`. Production uses Workers KV (worker.ts); the only line that changes is the
+ * store. Watch the `x-nifra-isr` response header: miss → hit → stale.
+ */
+import { inProcessClient } from "@nifrajs/client"
+import { createWebApp, MemoryCacheStore, revalidateEndpoint, withISR } from "@nifrajs/web"
+import type { BuildManifest } from "@nifrajs/web/build"
+import { discoverRoutes } from "@nifrajs/web/fs"
+import { reactAdapter } from "@nifrajs/web-react"
+import { backend } from "./backend"
+
+const publicDir = `${import.meta.dir}/public`
+const assets = JSON.parse(
+  await Bun.file(`${publicDir}/assets/manifest.json`)
+    .text()
+    .catch(() => '{"entry":"/assets/missing.js","assets":[],"routes":{}}'),
+) as BuildManifest
+
+const app = createWebApp({
+  adapter: reactAdapter,
+  manifest: discoverRoutes(`${import.meta.dir}/routes`),
+  clientEntry: assets.entry,
+  routePreload: assets.routes,
+  api: inProcessClient(backend),
+  title: "nifra + ISR",
+})
+
+app.get("/assets/*", async (c) => {
+  const file = Bun.file(`${publicDir}${new URL(c.req.url).pathname}`)
+  if (!(await file.exists())) return new Response("Not Found", { status: 404 })
+  return new Response(file, {
+    headers: {
+      "content-type": "text/javascript; charset=utf-8",
+      "cache-control": "public, max-age=31536000, immutable",
+    },
+  })
+})
+
+const store = new MemoryCacheStore()
+const secret = Bun.env.REVALIDATE_SECRET ?? "dev-secret"
+const purge = revalidateEndpoint({ store, secret })
+app.post("/__nifra/revalidate", (c) => purge(c.req))
+
+const isr = withISR(app, {
+  store,
+  revalidate: 60,
+  now: () => Date.now(),
+  key: (req) => {
+    const url = new URL(req.url)
+    return url.pathname.startsWith("/assets/") ? null : url.origin + url.pathname + url.search
+  },
+})
+
+const running = Bun.serve({ port: Number(Bun.env.PORT ?? 3000), fetch: (req) => isr(req) })
+console.log(`http://localhost:${running.port}`)

package/template-isr/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "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",
+    "public",
+    "dist-server",
+    ".build",
+    ".nifra",
+    ".wrangler",
+    "server-manifest.ts",
+    "server.ts",
+    "worker.ts",
+    "build.ts"
+  ]
+}

package/template-isr/worker.ts

@@ -0,0 +1,52 @@
+/**
+ * Cloudflare Workers entry — the app, cached in Workers KV so cached pages and on-demand purges hold
+ * ACROSS instances. `ctx.waitUntil` keeps the worker alive while a stale page regenerates behind the
+ * response. `bun run build` then `bunx wrangler dev` (a local KV is provided automatically).
+ */
+import { inProcessClient } from "@nifrajs/client"
+import {
+  createWebApp,
+  KVCacheStore,
+  type KVNamespaceLike,
+  revalidateEndpoint,
+  withISR,
+} from "@nifrajs/web"
+import { reactAdapter } from "@nifrajs/web-react"
+import { backend } from "./backend"
+// Generated by build.ts (buildServer): the static-import route manifest + the baked client entry URL.
+import { clientEntry, manifest } from "./server-manifest"
+
+const app = createWebApp({
+  adapter: reactAdapter,
+  manifest,
+  clientEntry,
+  api: inProcessClient(backend),
+  title: "nifra + ISR",
+})
+
+/** Workers bindings (wrangler.toml → [[kv_namespaces]] + [vars]). */
+interface Env {
+  readonly ISR_CACHE: KVNamespaceLike
+  readonly REVALIDATE_SECRET?: string
+}
+
+/** Minimal shape of the Workers execution context — just `waitUntil`. */
+interface ExecutionContext {
+  waitUntil(promise: Promise<unknown>): void
+}
+
+export default {
+  async fetch(req: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    const store = new KVCacheStore(env.ISR_CACHE, { expirationTtl: 86_400 }) // 1-day GC backstop
+
+    // On-demand purge: POST /__nifra/revalidate?path=/ with the secret in x-nifra-revalidate-token.
+    if (new URL(req.url).pathname === "/__nifra/revalidate") {
+      return revalidateEndpoint({ store, secret: env.REVALIDATE_SECRET ?? "" })(req)
+    }
+
+    // Cache GET documents stale-while-revalidate. Default 60s; a route's `export const revalidate`
+    // overrides it per-page.
+    const isr = withISR(app, { store, revalidate: 60, now: () => Date.now() })
+    return isr(req, { env, waitUntil: (p) => ctx.waitUntil(p) })
+  },
+}

package/template-isr/wrangler.toml

@@ -0,0 +1,20 @@
+name = "nifra-isr"
+main = "dist-server/worker.js"
+compatibility_date = "2025-01-01"
+compatibility_flags = ["nodejs_compat"]
+
+# Workers Assets: the content-hashed client bundle (buildClient → ./public/assets) is served at
+# /assets/*. Non-asset paths fall through to the worker (SSR + ISR).
+assets = { directory = "./public" }
+
+# The ISR page cache. `wrangler dev` provides a LOCAL (miniflare) KV automatically — no Cloudflare
+# account needed. For `wrangler deploy`, create a namespace and paste its id:
+#   bunx wrangler kv namespace create ISR_CACHE
+[[kv_namespaces]]
+binding = "ISR_CACHE"
+id = "REPLACE_WITH_YOUR_KV_NAMESPACE_ID"
+
+# On-demand revalidation secret. DEV placeholder — set a real one for production with
+# `bunx wrangler secret put REVALIDATE_SECRET`.
+[vars]
+REVALIDATE_SECRET = "dev-secret"

package/template-site/.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/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/README.md

@@ -0,0 +1,44 @@
+# nifra site
+
+A nifra + React 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)
+```
+
+Edit `routes/index.tsx` (the landing + a live loader/action counter), add files under `routes/`
+(`about.tsx` → `/about`, `[id].tsx` → `:id`, nested `_layout.tsx` for sections), and put your data
+behind `backend.ts`.
+
+## Deploy — pick a target
+
+| target | build | deploy |
+| --- | --- | --- |
+| **Bun** (flagship) | `bun run build:bun` | `bun run start` (`bun dist-bun/server-bun.js`) — 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` (or `deno task start`) |
+| **Cloudflare Pages** | `bun run build` | `bun run deploy:cf` (`wrangler pages deploy dist`) |
+| **Vercel Edge** | `bun run build:vercel` | `bun run deploy:vercel` (`vercel deploy --prebuilt`) |
+
+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 — the
+configs (`Dockerfile`, `deno.json`, `wrangler.toml`, Vercel Build Output API) are scaffolded; you run
+the vendor CLI.
+
+## Structure
+
+```
+routes/        index.tsx (landing), _layout.tsx (chrome), _404.tsx
+framework.ts   the render adapter (imported by the server entries — kept 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/_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/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/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-react/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/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-react/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/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-react/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/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-react/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/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-react/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/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/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 { reactAdapter } from "@nifrajs/web-react"
+
+export const adapter = reactAdapter

package/template-site/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/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. React JSX is
+// Bun-native, so the only extra is the Vite plugin for dev HMR (Fast Refresh).
+import react from "@vitejs/plugin-react"
+
+export { adapter } from "./framework"
+export const clientModule = "@nifrajs/web-react/client"
+export const vitePlugins = [react()]

package/template-site/package.json

@@ -0,0 +1,37 @@
+{
+  "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-react": "^0.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@nifrajs/cli": "^0.1.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.0"
+  }
+}