create-nifra 0.1.0-alpha.1

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

@@ -0,0 +1,13 @@
+// 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 Svelte compiler — keeping them OUT of the edge
+// worker bundle that `framework.ts` (the render-adapter source the entries import) must stay free of.
+import { svelte } from "@sveltejs/vite-plugin-svelte"
+import { svelteBunPlugin } from "@nifrajs/web-svelte/plugin"
+
+export { adapter } from "./framework"
+export const clientModule = "@nifrajs/web-svelte/client"
+// `nifra dev` HMR: Vite + the official Svelte plugin compile/HMR the .svelte client modules.
+export const vitePlugins = [svelte()]
+// `nifra build` (client) + `nifra start`/`nifra dev` (Bun-side SSR) compile .svelte via these.
+export const clientPlugins = [svelteBunPlugin("dom")]
+export const serverPlugins = [svelteBunPlugin("ssr")]

package/template-site-svelte/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-svelte": "^0.1.0",
+    "svelte": "^5.3.0"
+  },
+  "devDependencies": {
+    "@sveltejs/vite-plugin-svelte": "^5.0.0",
+    "@nifrajs/cli": "^0.1.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.0"
+  }
+}

package/template-site-svelte/routes/_404.svelte

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

package/template-site-svelte/routes/_layout.svelte

@@ -0,0 +1,35 @@
+<!-- Root layout — wraps every page via the `children` snippet (the Chain fold passes the page there). -->
+<script lang="ts">
+  let { children } = $props()
+  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()
+</script>
+
+<div id="app">
+  <!-- Inject the global stylesheet verbatim (Svelte's component <style> is scoped). -->
+  {@html `<style>${css}</style>`}
+  <header class="site">
+    <div class="wrap">
+      <a href="/" class="logo"><b>nifra</b></a>
+      <a href="https://github.com">GitHub</a>
+    </div>
+  </header>
+  <main class="wrap">{@render children()}</main>
+  <footer class="site"><div class="wrap">Built with nifra</div></footer>
+</div>

package/template-site-svelte/routes/index.svelte

@@ -0,0 +1,47 @@
+<script module lang="ts">
+import type { ActionArgs, LoaderArgs } from "@nifrajs/client"
+import type { backend } from "../backend"
+
+export const meta = {
+  title: "nifra site",
+  meta: [{ name: "description", content: "A nifra + Svelte 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 }
+}
+</script>
+
+<script lang="ts">
+  let { data } = $props()
+</script>
+
+<section class="hero">
+  <h1>Your nifra app,<br /><span class="grad">everywhere.</span></h1>
+  <p>
+    SSR + hydration, end-to-end types, Svelte. One source — deploy to Cloudflare Pages, Node, Deno,
+    or Vercel Edge. Edit <code>routes/index.svelte</code> to begin.
+  </p>
+</section>
+
+<div class="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;align-items:center;gap:16px">
+    <span class="count">{data.count}</span>
+    <button class="btn" type="submit">increment →</button>
+  </form>
+</div>

package/template-site-svelte/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-svelte/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-svelte/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-svelte/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-svelte/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "verbatimModuleSyntax": true,
+    "types": ["svelte"]
+  },
+  "include": ["**/*.ts"],
+  "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-svelte/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-vue/.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-vue/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-vue/README.md

@@ -0,0 +1,45 @@
+# nifra site (Vue)
+
+A nifra + **Vue** 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 **Vue SFCs** (`.vue`) under `routes/` — `index.vue` (landing + a live loader/action
+counter), `_layout.vue` (chrome via the default slot), `_404.vue`. A route SFC's plain `<script>`
+carries nifra's `loader`/`action`/`meta`; `<script setup>` + `<template>` are the component. The
+build compiles them with `vueBunPlugin` (`@nifrajs/web-vue/plugin`). 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.vue (landing), _layout.vue (chrome), _404.vue  (Vue SFCs)
+framework.ts   the adapter (vueAdapter) — imported by the server entries (edge-bundlable)
+nifra.config.ts the nifra CLI's dev/build config (adapter + clientModule + Vue 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-vue/_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-vue/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-vue/build-bun.ts

@@ -0,0 +1,37 @@
+// 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 { vueBunPlugin } from "@nifrajs/web-vue/plugin"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist-bun`
+const define = {
+  "process.env.NODE_ENV": '"production"',
+  __VUE_OPTIONS_API__: "true",
+  __VUE_PROD_DEVTOOLS__: "false",
+  __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: "false",
+}
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-vue/client",
+  plugins: [vueBunPlugin("dom")], // compile .vue SFCs → client bundle
+  conditions: ["bun", "browser"],
+  define,
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-bun.ts`,
+  outDir: `${dir}/.build-bun`,
+  target: "bun",
+  clientEntry: client.entry,
+  plugins: [vueBunPlugin("ssr")], // compile .vue SFCs → SSR
+  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-vue/build-deno.ts

@@ -0,0 +1,36 @@
+// Build for Deno → dist-deno/ (server-deno.js + client assets). `bun run build:deno`.
+// Run: `deno task start` (or deployctl for Deno Deploy).
+import { cpSync, mkdirSync, rmSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+import { vueBunPlugin } from "@nifrajs/web-vue/plugin"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist-deno`
+const define = {
+  "process.env.NODE_ENV": '"production"',
+  __VUE_OPTIONS_API__: "true",
+  __VUE_PROD_DEVTOOLS__: "false",
+  __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: "false",
+}
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-vue/client",
+  plugins: [vueBunPlugin("dom")], // compile .vue SFCs → client bundle
+  conditions: ["bun", "browser"],
+  define,
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-deno.ts`,
+  outDir: `${dir}/.build-deno`,
+  clientEntry: client.entry,
+  plugins: [vueBunPlugin("ssr")], // compile .vue SFCs → SSR
+  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-vue/build-node.ts

@@ -0,0 +1,37 @@
+// Build for Node → dist-node/ (server-node.js + client assets). `bun run build:node`.
+// Run: `node dist-node/server-node.js` (or the Dockerfile).
+import { cpSync, mkdirSync, rmSync } from "node:fs"
+import { buildClient, buildServer } from "@nifrajs/web/build"
+import { vueBunPlugin } from "@nifrajs/web-vue/plugin"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist-node`
+const define = {
+  "process.env.NODE_ENV": '"production"',
+  __VUE_OPTIONS_API__: "true",
+  __VUE_PROD_DEVTOOLS__: "false",
+  __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: "false",
+}
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-vue/client",
+  plugins: [vueBunPlugin("dom")], // compile .vue SFCs → client bundle
+  conditions: ["bun", "browser"],
+  define,
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-node.ts`,
+  outDir: `${dir}/.build-node`,
+  target: "node",
+  clientEntry: client.entry,
+  plugins: [vueBunPlugin("ssr")], // compile .vue SFCs → SSR
+  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-vue/build-vercel.ts

@@ -0,0 +1,54 @@
+// 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"
+import { vueBunPlugin } from "@nifrajs/web-vue/plugin"
+
+const dir = import.meta.dir
+const out = `${dir}/.vercel/output`
+const fn = `${out}/functions/index.func`
+const define = {
+  "process.env.NODE_ENV": '"production"',
+  __VUE_OPTIONS_API__: "true",
+  __VUE_PROD_DEVTOOLS__: "false",
+  __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: "false",
+}
+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-vue/client",
+  plugins: [vueBunPlugin("dom")], // compile .vue SFCs → client bundle
+  conditions: ["bun", "browser"],
+  define,
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/server-vercel.ts`,
+  outDir: `${dir}/.build-vercel`,
+  clientEntry: client.entry,
+  plugins: [vueBunPlugin("ssr")], // compile .vue SFCs → SSR
+  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-vue/build.ts

@@ -0,0 +1,40 @@
+// 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"
+import { vueBunPlugin } from "@nifrajs/web-vue/plugin"
+
+const dir = import.meta.dir
+const dist = `${dir}/dist`
+// Vue feature flags: silence "feature flag not explicitly defined" warnings + trim dev-only code.
+const define = {
+  "process.env.NODE_ENV": '"production"',
+  __VUE_OPTIONS_API__: "true",
+  __VUE_PROD_DEVTOOLS__: "false",
+  __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: "false",
+}
+rmSync(dist, { recursive: true, force: true })
+mkdirSync(`${dist}/assets`, { recursive: true })
+
+const client = await buildClient({
+  routesDir: `${dir}/routes`,
+  outDir: `${dist}/assets`,
+  clientModule: "@nifrajs/web-vue/client",
+  plugins: [vueBunPlugin("dom")], // compile .vue SFCs → client bundle
+  conditions: ["bun", "browser"],
+  define,
+})
+const { worker } = await buildServer({
+  routesDir: `${dir}/routes`,
+  serverEntry: `${dir}/_worker.ts`,
+  outDir: `${dir}/.build`,
+  clientEntry: client.entry,
+  plugins: [vueBunPlugin("ssr")], // compile .vue SFCs → SSR
+  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)")