create-rsc-kit 0.7.2 → 0.9.0

package/dist/templates.js

@@ -63,16 +63,34 @@ export function scripts(o) {
     return {
         dev: 'vite',
         build: 'vite build',
+        // The two that produce something you ship build first, rather than reading
+        // whatever .output happens to hold. Run on a project that has never been
+        // built, they failed with `ENOENT opening root directory ".output/server"`
+        // — a path the app did not write and has no reason to recognise. Run on one
+        // built a while ago, which is worse, they silently packaged the old code.
+        //
+        // start and preview are left alone: they are the inner loop, they follow a
+        // build in every set of instructions, and re-running one on each restart
+        // costs more than it saves.
         ...(o.host === 'worker'
-            ? { preview: 'wrangler dev .output/server/index.mjs', deploy: 'nitro deploy --prebuilt' }
+            ? {
+                preview: 'wrangler dev .output/server/index.mjs',
+                deploy: 'vite build && 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.
+                //
+                // Into dist/, which is already ignored. Named after the project it
+                // landed a 63MB binary in the root of, next to the source, with
+                // nothing in .gitignore covering it.
                 ...(o.host === 'bun'
-                    ? { compile: `bun build --compile .output/server/index.mjs --outfile ${o.name}` }
+                    ? {
+                        compile: 'vite build && bun build --compile .output/server/index.mjs --outfile dist/app',
+                    }
                     : {}),
             }),
         typecheck: 'tsc --noEmit',
@@ -178,7 +196,11 @@ export function viteConfig(o) {
     //
     // Not optional, and not a flag on rscKit() either — the plugin builds for
     // Nitro and nothing else, so a config without this line has no server.
-    plugins.push(`nitro({ preset: ${JSON.stringify(preset(o.host))}, serveStatic: 'inline' })`);
+    // serverDir is what makes server/api and server/routes exist at all: Nitro's
+    // scanDirs is empty without it, so a handler written there is never scanned,
+    // the request falls through to the rsc entry, and the 404 it answers with
+    // reads as a routing bug in this package rather than a missing option.
+    plugins.push(`nitro({ preset: ${JSON.stringify(preset(o.host))}, serveStatic: 'inline', serverDir: 'server' })`);
     plugins.push(`rscKit({
       ${options.join(',\n      ')},
     })`);
@@ -187,12 +209,22 @@ export function viteConfig(o) {
         plugins.push('babel({ presets: [reactCompilerPreset()] })');
     if (o.tailwind)
         plugins.push('tailwindcss()');
+    // `@/` for the source directory. Vite does not read tsconfig `paths`, so the
+    // alias has to exist here as well or the import type-checks and then fails to
+    // resolve — and the tsconfig half is what tools like shadcn look for when
+    // they ask whether this project has an import alias at all.
     return `${imports.join('\n')}
+import { fileURLToPath } from 'node:url'
 
 export default defineConfig({
   plugins: [
     ${plugins.join(',\n    ')},
   ],
+  resolve: {
+    alias: {
+      '@': fileURLToPath(new URL('./${o.sourceDir}', import.meta.url)),
+    },
+  },
 })
 `;
 }
@@ -202,6 +234,16 @@ export const tsconfig = (o) => JSON.stringify({
         target: 'ESNext',
         module: 'ESNext',
         moduleResolution: 'bundler',
+        // `@/thing` for `<sourceDir>/thing`. Matched by resolve.alias in the
+        // vite config, which is what actually resolves it — this half is for
+        // the type system, and for the tools that read a tsconfig to find out
+        // whether the project has an import alias. shadcn refuses to init
+        // without one.
+        //
+        // No `baseUrl`: TypeScript removed it, and emitting it now is an
+        // outright TS5102 on a freshly scaffolded app. Paths resolve relative
+        // to this file without it.
+        paths: { '@/*': [`./${o.sourceDir}/*`] },
         jsx: 'react-jsx',
         strict: true,
         noEmit: true,
@@ -231,12 +273,17 @@ export const tsconfig = (o) => JSON.stringify({
     // .rsc-kit holds the generated ambient declarations. Ambient means
     // inside the project, and `include` is what decides that — leave it out
     // and typed routes silently fall back to string.
-    include: [`${o.sourceDir}/**/*`, '.rsc-kit/**/*'],
+    //
+    // server/ is the same mistake one directory over: an api handler outside
+    // the program is not type-checked at all, so one returning the wrong
+    // shape builds, deploys and fails at runtime with nothing having said so.
+    include: [`${o.sourceDir}/**/*`, 'server/**/*', '.rsc-kit/**/*'],
 }, null, 2) + '\n';
 export function layout(o) {
     return `${o.tailwind ? "import './styles.css'\n" : ''}import type { ReactNode } from 'react'
+import type { Metadata } from '@rsc-kit/core/metadata'
 
-export const metadata = {
+export const metadata: Metadata = {
   title: { template: '%s · ${o.name}', default: '${o.name}' },
 }
 
@@ -260,23 +307,40 @@ export default function RootLayout({ children }: { children: ReactNode }) {
 export function page(o) {
     const h1 = o.tailwind ? ' className="text-3xl font-bold"' : '';
     const p = o.tailwind ? ' className="mt-4 text-slate-600"' : '';
+    const code = o.tailwind ? ' className="rounded bg-slate-100 px-1"' : '';
+    // Deliberately nothing that changes between renders.
+    //
+    // This page said "Rendered on the server at {new Date()}" — and every route
+    // it can is frozen at build time, so that timestamp was the build's and
+    // never moved again. Reload and the same instant is still there, under a
+    // sentence claiming it was rendered just now. The first thing the starter
+    // did was look broken, and the fix someone reaches for is to stop
+    // prerendering the page that is teaching them about prerendering.
     return `import { Counter } from '../components/Counter'
+import type { Metadata } from '@rsc-kit/core/metadata'
 
-export const metadata = { title: 'Home' }
-
-// A server component: async, runs only on the server, ships no JavaScript.
-export default async function HomePage() {
-  const now = new Date().toISOString()
+export const metadata: Metadata = { title: 'Home' }
 
+// A server component. It runs on the server and ships no JavaScript of its
+// own — this file is not in the browser bundle. It can be \`async\` and await
+// whatever it needs; nothing here does yet.
+export default function HomePage() {
   return (
     <>
       <h1${h1}>${o.name}</h1>
       <p${p}>
-        Rendered on the server at {now}. The only JavaScript on this page is the
-        counter below.
+        The only JavaScript on this page is the counter below, because
+        <code${code}>Counter.tsx</code> is the only file that opts into the
+        client. Everything else rendered on the server and stayed there.
       </p>
 
       <Counter />
+
+      <p${p}>
+        Edit <code${code}>src/app/page.tsx</code> and the change arrives without
+        a reload. Add <code${code}>src/app/about/page.tsx</code> and{' '}
+        <code${code}>/about</code> exists — there is no route table to update.
+      </p>
     </>
   )
 }
@@ -384,9 +448,17 @@ export function readme(o) {
         ? `${pm} preview     # wrangler dev, on workerd\n${pm} deploy      # nitro deploy --prebuilt`
         : `${pm} start       # serve on http://localhost:${PORT}`;
     const compile = o.host === 'bun'
-        ? `\n\n\`${pm} compile\` puts the whole application in one file — engine, pages and
-assets — with Bun's runtime inside it. Frozen pages stay outside: a binary
-has no filesystem to read them from, so it renders those live.`
+        ? `\n\n\`${pm} compile\` builds and then puts the whole application into
+\`dist/app\` — engine, pages and assets, with Bun's runtime inside it. Run it
+directly:
+
+\`\`\`sh
+./dist/app
+\`\`\`
+
+It builds first, so the binary is never a version behind your source. Frozen
+pages stay outside it: a binary has no filesystem to read them from, so it
+renders those live.`
         : '';
     return `# ${o.name}
 

package/package.json

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