create-rsc-kit 0.5.0 → 0.6.0

package/dist/index.js

@@ -122,7 +122,6 @@ function write(o) {
         ['package.json', t.packageJson(o)],
         ['tsconfig.json', t.tsconfig(o)],
         ['vite.config.ts', t.viteConfig(o)],
-        [t.serverFile(o.host), t.server(o)],
         ['.gitignore', t.gitignore],
         ['README.md', t.readme(o)],
         ['src/app/layout.tsx', t.layout(o)],
@@ -167,7 +166,8 @@ function report(o) {
         `cd ${relativeish(o.dir)}`,
         ...(o.install ? [] : [o.host === 'node' ? 'npm install' : 'bun install']),
         `${pm} build`,
-        `${pm} start`,
+        // A Worker has no start: wrangler runs it on workerd, or deploys it.
+        ...(o.host === 'worker' ? [`${pm} preview`, `${pm} deploy`] : [`${pm} start`]),
     ];
     stdout.write(`\n${bold('Done.')} ${dim(o.dir)}\n\n`);
     for (const step of steps)

package/dist/init.js

@@ -14,7 +14,9 @@ import { cwd, exit, stdout } from 'node:process';
 import { DEFAULT_COMPILER, parseArgs, publishedCore } from './options.js';
 import { Prompter, bold, cyan, dim } from './prompt.js';
 import * as t from './templates.js';
-const HOST_PACKAGES = { hono: 'hono', elysia: 'elysia' };
+// Nothing here detects a host any more: a host is a Nitro preset, and Nitro
+// is added to whatever project this runs in.
+const HOST_PACKAGES = {};
 /**
  * What is already here.
  *
@@ -233,8 +235,6 @@ function viteConfig(o, found, dir) {
     const shown = [
         `sourceDir: '${p.sourceDir}'`,
         `outDir: '${p.outDir}'`,
-        `assetsDir: '${p.assetsDir}'`,
-        ...(p.assetsUrl ? [`assetsUrl: '${p.assetsUrl}'`] : []),
         ...(p.hotFile ? [`hotFile: '${p.hotFile}'`] : []),
     ].join(', ');
     return [
@@ -242,35 +242,14 @@ function viteConfig(o, found, dir) {
             kind: 'manual',
             what: existing,
             detail: `add the plugin — it must come before any react() layer:\n` +
-                `      import { rscRoutes } from '@rsc-kit/core/vite'\n\n` +
+                `      import { rscKit } from '@rsc-kit/core/vite'\n\n` +
                 `      plugins: [\n` +
-                `        rscRoutes({ ${shown} }),\n` +
+                `        rscKit({ ${shown} }),\n` +
                 `        …whatever you already have\n` +
                 `      ]`,
         },
     ];
 }
-/** The server: written only when there is nothing there to break. */
-function server(o, dir) {
-    const file = t.serverFile(o.host);
-    if (existsSync(join(dir, file))) {
-        return [
-            {
-                kind: 'manual',
-                what: file,
-                detail: 'left alone. Mount the handler in it — anything the route table does not\n' +
-                    '      claim comes back null, so your own routes still win:\n\n' +
-                    t
-                        .server(o)
-                        .split('\n')
-                        .map((line) => '      ' + line)
-                        .join('\n'),
-            },
-        ];
-    }
-    writeFileSync(join(dir, file), t.server(o));
-    return [{ kind: 'wrote', what: file }];
-}
 /** The route tree, only where there is not one already. */
 function routes(o, dir) {
     const appDir = join(dir, o.sourceDir, 'app');
@@ -306,22 +285,22 @@ function routes(o, dir) {
  * everything else.
  */
 function tsconfig(o, found, dir) {
+    const steps = [];
     if (found.hasTypeScript) {
-        return [{ kind: 'skipped', what: 'tsconfig.json', detail: 'already here' }];
+        return [...steps, { kind: 'skipped', what: 'tsconfig.json', detail: 'already here' }];
     }
     writeFileSync(join(dir, 'tsconfig.json'), t.tsconfig(o));
-    return [{ kind: 'wrote', what: 'tsconfig.json' }];
+    return [...steps, { kind: 'wrote', what: 'tsconfig.json' }];
 }
 /** Ignore the files the build rewrites into the source dir on every run. */
 function gitignore(o, dir) {
     const path = join(dir, '.gitignore');
     const generated = ['rsc-env.d.ts', 'rsc-types.d.ts', 'rsc-routes.d.ts', 'rsc-engine.d.ts'].map((f) => `${o.sourceDir}/${f}`);
     const p = t.paths(o);
-    // Everything the build writes. On Laravel that is three separate places —
-    // the bundles, the browser assets under public/, and the hot file — and a
-    // committed hot file is the worst of them: it points every other machine at
-    // a dev server that is not running there.
-    const all = [p.outDir, p.assetsDir, ...(p.hotFile ? [p.hotFile] : [])];
+    // Everything the build writes: the bundles, Nitro's output, and the hot
+    // file. The hot file is the worst of them to commit — it points every other
+    // machine at a dev server that is not running there.
+    const all = ['.output', p.outDir, ...(p.hotFile ? [p.hotFile] : [])];
     const outputs = all.filter((path) => !all.some((other) => other !== path && path.startsWith(other + '/')));
     const current = existsSync(path) ? readFileSync(path, 'utf-8') : '';
     const missing = [...generated, ...outputs].filter((line) => !current.split('\n').some((existing) => existing.trim() === line));
@@ -337,7 +316,6 @@ export function initialise(o, found, dir) {
     const steps = [
         ...routes(o, dir),
         ...viteConfig(o, found, dir),
-        ...server(o, dir),
         ...tsconfig(o, found, dir),
         ...gitignore(o, dir),
         ...mergeDependencies(o, found),
@@ -433,6 +411,6 @@ export async function runInit(args) {
         return;
     }
     stdout.write(options.host === 'laravel'
-        ? `\n  ${cyan('npm install')}, then ${cyan('npm run rsc:dev')} — and open the app at its own domain.\n\n`
+        ? `\n  ${cyan('npm install')}, then ${cyan('npm run dev')} — and open the app at its own domain.\n\n`
         : `\n  ${cyan('bun install')} and you are ready.\n\n`);
 }

package/dist/options.d.ts

@@ -1,4 +1,12 @@
-export type Host = 'bun' | 'hono' | 'elysia' | 'node' | 'laravel';
+/**
+ * Where the app runs, which is now a Nitro preset rather than a server we write.
+ *
+ * hono and elysia are gone. They were never deployment targets — they were
+ * "mount the handler inside my framework", and Nitro owns the server now.
+ * createRscHandler is still exported, so mounting it by hand is still a thing
+ * anyone can do; there is simply no template for it.
+ */
+export type Host = 'bun' | 'node' | 'worker' | 'laravel';
 export type Compiler = 'none' | 'oxc' | 'babel';
 export interface Options {
     dir: string;

package/dist/options.js

@@ -10,10 +10,9 @@ import { fileURLToPath } from 'node:url';
  * question with a wrong answer available.
  */
 export const HOSTS = [
-    { value: 'bun', label: 'Bun.serve', hint: 'no framework, fastest to start' },
-    { value: 'hono', label: 'Hono', hint: 'also what a Worker or Deno would use' },
-    { value: 'elysia', label: 'Elysia', hint: 'Bun-first, typed routes of its own' },
-    { value: 'node', label: 'node:http', hint: 'no Bun, no framework' },
+    { value: 'bun', label: 'Bun', hint: 'and compiles to a single binary' },
+    { value: 'node', label: 'Node', hint: 'the default everywhere else' },
+    { value: 'worker', label: 'Cloudflare Workers', hint: 'no filesystem — assets from a binding' },
 ];
 /**
  * Not asked as a three-way.

package/dist/templates.d.ts

@@ -4,21 +4,22 @@ export interface Paths {
     sourceDir: string;
     /** Where the bundles land. The server imports the rsc one from here. */
     outDir: string;
-    /** Where browser assets are written. */
-    assetsDir: string;
-    /** The url they are served under, when it is not Vite's default. */
-    assetsUrl?: string;
     /** Written while the dev server runs, for a backend that has to find it. */
     hotFile?: string;
 }
 /**
- * Where this host's build writes, and where its server reads.
+ * Where this host's build writes.
  *
- * One function because the two have to agree and nothing checks that they do:
- * an assetsDir the server does not serve 404s every asset while every page
- * still renders, so the page looks right and nothing hydrates. Laravel's
- * differ from the rest because public/ is already the browser's root and
- * bootstrap/ is already where a Laravel app keeps generated code.
+ * There is no assetsDir or assetsUrl any more. Nitro publishes the browser
+ * assets to .output/public and serves them from its own root, so naming a
+ * directory or a prefix here would be read and then ignored — the markup asks
+ * for the app's path, Nitro answers at its own, and every asset 404s while
+ * every page still renders. rscKit() refuses the pair outright rather than
+ * letting that happen quietly.
+ *
+ * Laravel keeps its own outDir, because bootstrap/ is already where a Laravel
+ * application puts generated code, and its own hotFile, because the framework
+ * has to find a running dev server.
  */
 export declare function paths(o: Options): Paths;
 /**
@@ -42,10 +43,19 @@ export declare const configFile: (o: Options) => string;
 export declare function scripts(o: Options): Record<string, string>;
 export declare function packageJson(o: Options): string;
 /** One server per app, so it needs no qualifier. */
+/**
+ * The Nitro preset for a host.
+ *
+ * This is the whole of what a host is now. Nitro carries presets for Vercel,
+ * Netlify, Azure, Deno and the rest, and none of them need anything here — a
+ * preset is a string in a config file, not a server we write and keep working.
+ */
+export declare const preset: (host: Host) => string;
+/** @deprecated Nothing generates a server file. Kept until callers are gone. */
 export declare const serverFile: (_host: Host) => string;
 export declare function viteConfig(o: Options): string;
+export declare const WRANGLER_FILE = "wrangler.toml";
 export declare const tsconfig: (o: Options) => string;
-export declare function server(o: Options): string;
 export declare function layout(o: Options): string;
 export declare function page(o: Options): string;
 export declare function counter(o: Options): string;

package/dist/templates.js

@@ -5,23 +5,26 @@
 // layout — and a template directory would need one copy per combination.
 const PORT = 3000;
 /**
- * Where this host's build writes, and where its server reads.
+ * Where this host's build writes.
  *
- * One function because the two have to agree and nothing checks that they do:
- * an assetsDir the server does not serve 404s every asset while every page
- * still renders, so the page looks right and nothing hydrates. Laravel's
- * differ from the rest because public/ is already the browser's root and
- * bootstrap/ is already where a Laravel app keeps generated code.
+ * There is no assetsDir or assetsUrl any more. Nitro publishes the browser
+ * assets to .output/public and serves them from its own root, so naming a
+ * directory or a prefix here would be read and then ignored — the markup asks
+ * for the app's path, Nitro answers at its own, and every asset 404s while
+ * every page still renders. rscKit() refuses the pair outright rather than
+ * letting that happen quietly.
+ *
+ * Laravel keeps its own outDir, because bootstrap/ is already where a Laravel
+ * application puts generated code, and its own hotFile, because the framework
+ * has to find a running dev server.
  */
 export function paths(o) {
     if (o.host !== 'laravel') {
-        return { sourceDir: o.sourceDir, outDir: 'build', assetsDir: 'build/public' };
+        return { sourceDir: o.sourceDir, outDir: 'build' };
     }
     return {
         sourceDir: o.sourceDir,
         outDir: 'bootstrap/rsc/vite',
-        assetsDir: 'public/build/rsc-vite',
-        assetsUrl: '/build/rsc-vite/',
         hotFile: 'public/rsc-hot',
     };
 }
@@ -44,36 +47,36 @@ export const configFile = (o) => o.host === 'laravel' ? 'vite.rsc.config.ts' : '
  * wrote themselves.
  */
 export function scripts(o) {
-    const run = o.host === 'node' ? 'node' : 'bun run';
-    const p = paths(o);
     if (o.host === 'laravel') {
         const config = `--config ${configFile(o)}`;
-        // The build cannot discover the app's server actions — reflection through
-        // Composer's autoloader is the only thing that sees what a class inherits
-        // from its parents and traits — so PHP writes them out first and the
-        // plugin reads the file. Part of the command rather than a step to
-        // remember: a stale map names a method that has since been renamed, and
-        // nothing fails until the browser calls it.
         const actions = 'php artisan rsc:action-manifest';
         return {
             // The ordinary names. A Laravel application already has `dev` and
             // `build`, and init combines rather than replaces — the stock ones run
             // the asset pipeline, and both pipelines belong to `npm run dev`.
-            // Only a script somebody actually wrote gets left alone, and then the
-            // RSC one takes an `rsc:` name and says so.
             dev: `${actions} && vite ${config}`,
             build: `${actions} && vite build ${config}`,
-            start: `${run} ${serverFile(o.host)}`,
+            // What the build wrote. There is no server file to start any more.
+            start: 'bun .output/server/index.mjs',
         };
     }
     return {
-        // Vite serves it: modules are re-evaluated on edit, and adding a
-        // page restarts to pick up the new route table. Nothing is prebuilt,
-        // so there is no NODE_ENV to keep in step with a build.
         dev: 'vite',
         build: 'vite build',
-        start: `${run} ${serverFile(o.host)}`,
-        prerender: `rsc-kit prerender --out ${p.outDir}`,
+        ...(o.host === 'worker'
+            ? { preview: 'wrangler dev .output/server/index.mjs', deploy: 'nitro deploy --prebuilt' }
+            : {
+                start: `${o.host === 'node' ? 'node' : 'bun'} .output/server/index.mjs`,
+                // Bun only, and only because serveStatic: 'inline' is set in the vite
+                // config. Without that the binary compiles, serves pages, and 404s
+                // every asset — the static path resolves into Bun's virtual
+                // filesystem, where the files on disk are not.
+                ...(o.host === 'bun'
+                    ? { compile: `bun build --compile .output/server/index.mjs --outfile ${o.name}` }
+                    : {}),
+            }),
+        typecheck: 'tsc --noEmit',
+        ...(o.lint ? { lint: 'oxlint src --fix', 'lint:check': 'oxlint src --deny-warnings' } : {}),
     };
 }
 export function packageJson(o) {
@@ -82,15 +85,19 @@ export function packageJson(o) {
         react: '^19.2.5',
         'react-dom': '^19.2.5',
     };
-    if (o.host === 'hono')
-        deps.hono = '^4.13.5';
-    if (o.host === 'elysia')
-        deps.elysia = '^1.4.30';
     const dev = {
         '@types/react': '^19.2.18',
         '@types/react-dom': '^19.2.7',
         typescript: '^7.0.2',
         vite: '^8.1.5',
+        // Pinned, and to a beta on purpose. Nitro's own `latest` tag is a dated
+        // prerelease that sorts ABOVE the plain 3.0.0 on npm, so `^3.0.0` quietly
+        // resolves to the older one — which builds without complaint and then 404s
+        // every route. TanStack Start pins a dated beta for the same reason.
+        nitro: '3.0.260903-beta',
+        ...(o.host === 'worker'
+            ? { wrangler: '^4.0.0', '@cloudflare/workers-types': '^4.0.0' }
+            : {}),
         // Not redundant, though it is also the engine's peer: the generated entry
         // imports '@vitejs/plugin-rsc/rsc' by specifier, so it has to resolve from
         // the app. bun hoists peers and makes that work by accident; npm does not,
@@ -134,6 +141,15 @@ export function packageJson(o) {
 }
 const sorted = (o) => Object.fromEntries(Object.entries(o).sort(([a], [b]) => a.localeCompare(b)));
 /** One server per app, so it needs no qualifier. */
+/**
+ * The Nitro preset for a host.
+ *
+ * This is the whole of what a host is now. Nitro carries presets for Vercel,
+ * Netlify, Azure, Deno and the rest, and none of them need anything here — a
+ * preset is a string in a config file, not a server we write and keep working.
+ */
+export const preset = (host) => host === 'worker' ? 'cloudflare_module' : host === 'node' ? 'node' : 'bun';
+/** @deprecated Nothing generates a server file. Kept until callers are gone. */
 export const serverFile = (_host) => 'server.ts';
 export function viteConfig(o) {
     const imports = ["import { defineConfig } from 'vite'"];
@@ -145,20 +161,23 @@ export function viteConfig(o) {
         imports.push("import babel from '@rolldown/plugin-babel'");
     if (o.tailwind)
         imports.push("import tailwindcss from '@tailwindcss/vite'");
-    imports.push("import { rscRoutes } from '@rsc-kit/core/vite'");
+    imports.push("import { rscKit } from '@rsc-kit/core/vite'");
+    imports.push("import { nitro } from 'nitro/vite'");
     const p = paths(o);
-    // Every path the build writes to, and the two the server has to agree with.
-    // Written out rather than defaulted so they are editable in one place — and
-    // so the pair that has no error case, assetsDir and assetsUrl, is visible
-    // together.
+    // Where the build writes. Assets are not here: Nitro publishes those to
+    // .output/public and serves them itself.
     const options = [
         `sourceDir: '${p.sourceDir}'`,
         `outDir: '${p.outDir}'`,
-        `assetsDir: '${p.assetsDir}'`,
-        ...(p.assetsUrl ? [`assetsUrl: '${p.assetsUrl}'`] : []),
         ...(p.hotFile ? [`hotFile: '${p.hotFile}'`] : []),
     ];
-    plugins.push(`rscRoutes({
+    // Nitro leads: it builds the server around the rsc entry's default export,
+    // and rscKit tells plugin-rsc not to install a handler competing for that
+    // role. serveStatic: 'inline' embeds the built assets, without which a
+    // compiled binary serves pages and 404s every asset.
+    plugins.push(`nitro({ preset: ${JSON.stringify(preset(o.host))}, serveStatic: 'inline' })`);
+    plugins.push(`rscKit({
+      nitro: true,
       ${options.join(',\n      ')},
     })`);
     plugins.push(o.compiler === 'oxc' ? 'react({ compiler: true })' : 'react()');
@@ -175,6 +194,7 @@ export default defineConfig({
 })
 `;
 }
+export const WRANGLER_FILE = 'wrangler.toml';
 export const tsconfig = (o) => JSON.stringify({
     compilerOptions: {
         target: 'ESNext',
@@ -183,218 +203,31 @@ export const tsconfig = (o) => JSON.stringify({
         jsx: 'react-jsx',
         strict: true,
         noEmit: true,
+        // Vite hands each file to esbuild alone, with no view of any other, so
+        // the type system should only allow what a single-file transpiler can
+        // actually carry out — re-exporting a type without `export type`, a
+        // const enum, a file that is a script rather than a module.
+        isolatedModules: true,
+        moduleDetection: 'force',
+        // An import means what it says. Without this, `import { Thing }` where
+        // Thing is only a type is erased silently — and in an RSC app the
+        // difference between an erased import and a real one is the difference
+        // between a type reference and dragging a server module into the client
+        // bundle. Requiring `import type` makes the graph split something you
+        // can see in the source rather than infer from the output.
+        verbatimModuleSyntax: true,
         skipLibCheck: true,
         resolveJsonModule: true,
-        types: o.host === 'node' ? ['node', 'vite/client'] : ['@types/bun', 'vite/client'],
+        types: o.host === 'worker'
+            ? // A Worker has neither node globals nor Bun's. Its own types, and
+                // vite/client for import.meta.env.
+                ['@cloudflare/workers-types', 'vite/client']
+            : o.host === 'node'
+                ? ['node', 'vite/client']
+                : ['@types/bun', 'vite/client'],
     },
-    include: [`${o.sourceDir}/**/*`, serverFile(o.host)],
+    include: [`${o.sourceDir}/**/*`],
 }, null, 2) + '\n';
-const HANDLER = `const rsc = createRscHandler({
-  engine,
-  assets: assetsFrom('./build/public'),
-  // Served from disk when a page was frozen at build time; rendered now when
-  // it was not.
-  prerendered: prerenderedFrom('./build/static'),
-})`;
-const IMPORTS = `import { createRscHandler } from '@rsc-kit/core/host'
-import { assetsFrom, prerenderedFrom } from '@rsc-kit/core/files'
-
-// Statically imported, not \`import(variable)\`: a bundler cannot see through a
-// variable, so \`bun build --compile\` would leave the engine out of the binary.
-//
-// No NODE_ENV to set before it. The build bakes the mode it ran in into the
-// bundle, so this server is production because it was built that way — not
-// because whoever started it remembered to say so.
-import * as engine from './build/dist/rsc/index.js'`;
-/**
- * The renderer for an app whose data lives in PHP.
- *
- * Different in kind from the others, not just in wiring: those servers ARE the
- * application, and this one renders for an application it talks to. Every
- * rpc() a server component makes leaves this process as a POST carrying the
- * visitor's own cookie, so the session, the user and the authorization are
- * Laravel's — this side holds no database connection and no session.
- *
- * Only production runs it. In development `vite` is the renderer, and Laravel
- * finds it through the hot file.
- */
-function backedServer(o) {
-    const p = paths(o);
-    const backend = o.backend ?? 'http://localhost';
-    return `// The renderer for this app.
-//
-// It owns routing, rendering, prerendered pages and assets. Laravel owns the
-// data: every rpc() a server component makes arrives there as a POST, with
-// this visitor's cookie, and comes back as JSON.
-//
-// Run it beside Laravel:
-//   bun server.ts
-//
-// Both processes need the same RSC_HOST_CALL_SECRET. Nothing else is shared.
-
-import { createBackedHandler } from '@rsc-kit/core/serve'
-import * as engine from './${p.outDir}/dist/rsc/index.js'
-
-const secret = process.env.RSC_HOST_CALL_SECRET
-// Where host calls go: the application this is rendering for.
-const backend = process.env.RSC_BACKEND ?? '${backend}'
-const port = Number(process.env.RSC_RENDERER_PORT ?? 5173)
-
-// Refused rather than defaulted. An empty secret is a host-call endpoint that
-// answers to anyone who can reach it, and it would fail nowhere until then.
-if (!secret) {
-  console.error('RSC_HOST_CALL_SECRET must match the one Laravel is configured with.')
-  process.exit(1)
-}
-
-const handle = createBackedHandler({
-  engine,
-  // The browser's root, and the prefix the build serves assets under. Passing
-  // the asset folder itself 404s every asset while every page still renders —
-  // so the page looks right and nothing hydrates.
-  assetsDir: 'public',
-  assetsPrefix: '${p.assetsUrl}',
-  // Where the build's prerender writes.
-  prerenderedDir: '${p.outDir}/static',
-  hostCall: {
-    endpoint: \`\${backend}/__rsc/host-call\`,
-    secret,
-  },
-  // Compared by the client on every navigation, which falls back to a full
-  // load when it changes. Without one a browser keeps talking to a deployment
-  // that no longer exists.
-  version: process.env.RSC_BUILD_VERSION,
-
-  // A page reading \`params\` gets its url params from the engine; the query
-  // string is merged in here, because a page asking for \`params.q\` should get
-  // it whether it arrived in the path or after the ?.
-  //
-  // Read from the url rather than fetched: a page needing more than the
-  // request carries — a loaded record, a tenant — asks for it with a host
-  // call, because this process has no database.
-  props: (match, request) => ({
-    ...match.params,
-    ...Object.fromEntries(new URL(request.url).searchParams),
-  }),
-})
-
-Bun.serve({
-  port,
-  // Named explicitly. The default binds IPv6 only on some machines, so the
-  // renderer answers on localhost and ::1 but not on 127.0.0.1 — which reads
-  // as the process being down.
-  hostname: process.env.RSC_RENDERER_HOST ?? '127.0.0.1',
-  idleTimeout: 60,
-  fetch: async (request) => (await handle(request)) ?? new Response('Not found', { status: 404 }),
-})
-
-console.log(\`renderer on http://127.0.0.1:\${port}, calling \${backend}\`)
-`;
-}
-export function server(o) {
-    const host = o.host;
-    if (host === 'laravel')
-        return backedServer(o);
-    if (host === 'bun') {
-        return `${IMPORTS}
-
-${HANDLER}
-
-Bun.serve({
-  port: ${PORT},
-  // Anything the route manifest does not claim comes back null and is yours.
-  fetch: async (request) => (await rsc(request)) ?? new Response('Not found', { status: 404 }),
-})
-
-console.log('http://localhost:${PORT}')
-`;
-    }
-    if (host === 'hono') {
-        return `import { Hono } from 'hono'
-${IMPORTS}
-
-${HANDLER}
-
-const app = new Hono()
-
-app.get('/health', (c) => c.json({ ok: true }))
-// Last, so the app's own routes win; anything left falls through to the RSC
-// handler, and anything it does not claim is a real 404.
-app.all('*', async (c) => (await rsc(c.req.raw)) ?? c.notFound())
-
-export default { port: ${PORT}, fetch: app.fetch }
-`;
-    }
-    if (host === 'elysia') {
-        return `import { Elysia } from 'elysia'
-${IMPORTS}
-
-${HANDLER}
-
-new Elysia()
-  .get('/health', () => ({ ok: true }))
-  .all('*', async ({ request, status }) => (await rsc(request)) ?? status(404, 'Not found'))
-  .listen(${PORT})
-
-console.log('http://localhost:${PORT}')
-`;
-    }
-    return `import { createServer } from 'node:http'
-import { Readable } from 'node:stream'
-${IMPORTS}
-
-${HANDLER}
-
-// Node exits on an unhandled rejection; Bun logs one and carries on. That
-// difference is reachable from outside: a malformed body posted to
-// /_rsc/action fails inside React's Flight decoder, in a promise nobody
-// awaits, so no try/catch here can see it — and on Node the process dies.
-process.on('unhandledRejection', (reason) => {
-  console.error('[unhandled rejection]', reason)
-})
-
-const server = createServer(async (req, res) => {
-  const url = \`http://\${req.headers.host ?? 'localhost'}\${req.url ?? '/'}\`
-  const hasBody = req.method !== 'GET' && req.method !== 'HEAD'
-
-  const request = new Request(url, {
-    method: req.method,
-    headers: req.headers as Record<string, string>,
-    // A server action posts binary. Streaming rather than buffering keeps an
-    // upload from being held twice; \`duplex\` is required for a stream body.
-    body: hasBody ? (Readable.toWeb(req) as ReadableStream) : undefined,
-    ...(hasBody ? { duplex: 'half' } : {}),
-  } as RequestInit)
-
-  let response: Response
-
-  try {
-    response = (await rsc(request)) ?? new Response('Not found', { status: 404 })
-  } catch (error) {
-    console.error('[rsc]', error)
-    res.writeHead(500, { 'Content-Type': 'text/plain' })
-    res.end('Internal Server Error')
-
-    return
-  }
-
-  res.writeHead(response.status, Object.fromEntries(response.headers))
-
-  if (!response.body) {
-    res.end()
-
-    return
-  }
-
-  // Piped, not buffered: reading it to a string first would hold the whole
-  // page before sending any of it, which is the streaming this exists to do
-  // thrown away in the last three lines.
-  Readable.fromWeb(response.body as never).pipe(res)
-})
-
-server.listen(${PORT}, () => console.log('http://localhost:${PORT}'))
-`;
-}
 export function layout(o) {
     return `${o.tailwind ? "import './styles.css'\n" : ''}import type { ReactNode } from 'react'
 
@@ -550,8 +383,10 @@ ${pm} build       # bundles, then freezes every page it can
 ${pm} start       # serve on http://localhost:${PORT}
 \`\`\`
 
-\`${pm} prerender\` re-runs only the freezing part, for when you turned it off
-in \`vite.config.ts\` or want to redo it without rebuilding.
+Freezing is part of \`build\`. To redo it against fresh data without
+rebuilding — or after turning it off in \`vite.config.ts\` — run
+\`bunx rsc-kit prerender --out ${paths(o).outDir}\`, keeping that package's version in
+step with \`@rsc-kit/core\`.
 
 ## Where things go
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-rsc-kit",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "description": "Scaffold an RSC app on Bun, Hono, Elysia or Node.",
   "bin": {