@rsc-kit/core 0.14.0 → 0.16.0

package/dist/vite.js

@@ -18,7 +18,7 @@ import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import rsc from '@vitejs/plugin-rsc';
+import rsc, { getPluginApi } from '@vitejs/plugin-rsc';
 import { loadEnv } from 'vite';
 import { REPORT_FILE, buildReport } from './buildReport.js';
 import { MANIFEST_PATH, manifestWarning, webManifest } from './webManifest.js';
@@ -1009,7 +1009,37 @@ function resolveRscBundle(dir) {
     }
     return null;
 }
-async function prerenderAfterBundles(bundle, staticDir, assetsDir) {
+/**
+ * Every server action the bundle registered, from the plugin's own table.
+ *
+ * Only the app's: the engine registers a few of its own and they are not the
+ * project's to be warned about.
+ */
+function knownActionsOf(config, root) {
+    const api = getPluginApi(config);
+    const metaMap = api?.manager?.serverReferences?.metaMap;
+    if (!metaMap)
+        return [];
+    const out = [];
+    for (const meta of metaMap.values()) {
+        if (meta.importId.includes('/node_modules/'))
+            continue;
+        const file = relative(root, meta.importId.split('?')[0] ?? meta.importId);
+        for (const name of meta.exportNames) {
+            out.push({ id: `${meta.referenceKey}#${name}`, name, file });
+        }
+    }
+    return out;
+}
+async function auditActions(engine, known) {
+    const audit = engine
+        .auditActions;
+    if (!audit || known.length === 0)
+        return [];
+    const byId = new Map(known.map((k) => [k.id, k]));
+    return (await audit(known.map((k) => k.id))).map((a) => ({ ...byId.get(a.id), client: a.client, query: a.query }));
+}
+async function prerenderAfterBundles(bundle, staticDir, assetsDir, knownActions = []) {
     // A missing bundle used to be a silent `return`, and under Nitro it was the
     // normal case: the path was assumed to be <outDir>/dist/rsc/index.js, Nitro
     // builds the rsc environment somewhere else entirely, and so every Nitro app
@@ -1022,7 +1052,7 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir) {
             'Prerendering renders the app, so it needs the bundle the build just wrote. ' +
             'Build with prerender: false to render every page on demand instead.');
     }
-    const [{ prerender, summary, legend, notes, clientJsSize, pathKey: pathKeyOf }, { writeTo }, { prerenderApiRoutes },] = await Promise.all([
+    const [{ prerender, NotPrerenderable, summary, legend, notes, clientJsSize, pathKey: pathKeyOf }, { writeTo }, { prerenderApiRoutes },] = await Promise.all([
         import('./prerender.js'),
         import('./files.js'),
         import('./apiPrerender.js'),
@@ -1032,36 +1062,58 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir) {
     // Nothing warns — the page loads, with content from the previous build.
     rmSync(staticDir, { recursive: true, force: true });
     const engine = (await import(pathToFileURL(bundle).href));
-    const mark = { frozen: '○', shell: '◐', blocked: 'ƒ', error: '✗' };
+    const mark = { frozen: '○', shell: '◐', blocked: '✗', error: '✗' };
     let failed = 0;
     // Weighed from the page the prerenderer just wrote, so the column is what
     // that page actually loads rather than a total every route is charged for.
     const weigh = weighClientJs(assetsDir);
     const sized = new Map();
     const pending = [];
-    const results = await prerender({
-        engine,
-        write: writeTo(staticDir),
-        onResult: (r) => {
-            if (r.type === 'error')
-                failed++;
-            const key = pathKeyOf(r.url);
-            const file = [`${key}.html`, `${key}.ppr.html`]
-                .map((name) => join(staticDir, name))
-                .find((path) => existsSync(path));
-            const bytes = file ? weigh(readFileSync(file, 'utf-8')) : null;
-            if (bytes !== null)
-                sized.set(r.url, bytes);
-            pending.push({
-                line: `  ${mark[r.type] ?? ' '}  ${r.url}`,
-                bytes,
-                extra: [
-                    ...(r.reason ? [`     ${r.reason}`] : []),
-                    ...(r.warning ? [`     ⚠  ${r.warning}`] : []),
-                ],
-            });
-        },
-    });
+    // Every result as it lands, so a refusal still has the whole table.
+    //
+    // prerender() throws NotPrerenderable when a page blocked above every
+    // boundary, and it used to throw past everything below: no table printed,
+    // no report written. The terminal got the advice; the report on disk was
+    // the previous build's, and an agent reading it through the MCP server was
+    // told the routes were fine, as of some minutes ago. A build that refuses
+    // is the build an agent most needs written down.
+    const collected = [];
+    let refusal = null;
+    let results;
+    try {
+        results = await prerender({
+            engine,
+            write: writeTo(staticDir),
+            serviceWorker: offline,
+            onResult: (r) => {
+                collected.push(r);
+                if (r.type === 'error' || r.type === 'blocked')
+                    failed++;
+                const key = pathKeyOf(r.url);
+                const file = [`${key}.html`, `${key}.ppr.html`]
+                    .map((name) => join(staticDir, name))
+                    .find((path) => existsSync(path));
+                const bytes = file ? weigh(readFileSync(file, 'utf-8')) : null;
+                if (bytes !== null)
+                    sized.set(r.url, bytes);
+                pending.push({
+                    line: `  ${mark[r.type] ?? ' '}  ${r.url}`,
+                    bytes,
+                    extra: [
+                        ...(r.reason ? [`     ${r.reason}`] : []),
+                        ...(r.note ? [`     ${r.note}`] : []),
+                        ...(r.warning ? [`     ⚠  ${r.warning}`] : []),
+                    ],
+                });
+            },
+        });
+    }
+    catch (error) {
+        if (!(error instanceof NotPrerenderable))
+            throw error;
+        refusal = error;
+        results = collected;
+    }
     // After the pages, sharing their output. An api route is a url the build
     // either answered or could not, which is the same question the table above
     // is already answering — a second list under its own heading would be two
@@ -1085,6 +1137,21 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir) {
             console.log(line);
     }
     const count = (type) => results.filter((r) => r.type === type).length;
+    // The actions, after the routes. Which ones a client built is a mark on the
+    // loaded function, so the bundle is asked; the answer is the one fact about
+    // an action nothing else in the app states — whether anything checks who
+    // calls it.
+    const audited = await auditActions(engine, knownActions);
+    const bare = audited.filter((a) => !a.client);
+    if (bare.length > 0) {
+        const byFile = new Map();
+        for (const a of bare)
+            byFile.set(a.file, [...(byFile.get(a.file) ?? []), a.name]);
+        console.log(`\n  \u26a0  ${bare.length} ${bare.length === 1 ? 'action runs' : 'actions run'} no middleware: ` +
+            [...byFile].map(([file, names]) => `${names.join(', ')} (${file})`).join('; '));
+        console.log('     Nothing checks who calls them. Fine for a public one; otherwise build it\n' +
+            '     from an action client, so the check cannot be forgotten.');
+    }
     // Written from the rows that were just printed rather than recomputed: the
     // report and the terminal must not be able to disagree about what happened.
     writeFileSync(join(outDir, REPORT_FILE), buildReport(results.map((r) => ({
@@ -1093,14 +1160,18 @@ async function prerenderAfterBundles(bundle, staticDir, assetsDir) {
         type: r.type,
         reason: r.reason,
         warning: r.warning ?? null,
+        note: r.note ?? null,
         clientJs: sized.get(r.url) ?? null,
-    })), apis.map((a) => ({ url: a.url, name: a.name, type: a.type, reason: a.reason }))));
+    })), apis.map((a) => ({ url: a.url, name: a.name, type: a.type, reason: a.reason })), audited));
     const note = notes(results);
     const counted = [...results, ...apis];
     console.log(`
 ${legend(counted)}
 
   ${summary(counted)}${note ? `\n\n${note}` : ''}`);
+    // The table and the report are on disk. Now the refusal, in its own words.
+    if (refusal)
+        throw new Error(refusal.message);
     if (failed > 0) {
         throw new Error(`[rsc-kit] ${failed} route${failed === 1 ? '' : 's'} failed to render.\n` +
             'Prerendering runs your app: whatever those pages need at render time has to be\n' +
@@ -1241,6 +1312,19 @@ function patternOf(segments) {
 function renderRouteTypes(manifest) {
     const patterns = [...new Set(manifest.routes.map((route) => patternOf(route.segments)))].sort();
     const apis = [...new Set((manifest.apis ?? []).map((route) => patternOf(route.segments)))].sort();
+    // Each pattern to the page module that answers it, as a type-only import
+    // from the generated file's own directory. SearchExportOf reads the page's
+    // `searchParams` export, or undefined when there is none, so nothing here
+    // has to look inside the file - the typechecker already has every page
+    // open. One line per route, and a page without a schema costs nothing.
+    const search = new Map();
+    for (const route of manifest.routes) {
+        const pattern = patternOf(route.segments);
+        if (search.has(pattern))
+            continue;
+        const target = relative(typesDir, join(sourceDir, route.component)).replace(/\\/g, '/');
+        search.set(pattern, target.startsWith('.') ? target : './' + target);
+    }
     return [
         '// @generated — do not edit. Written by the RSC build from the route tree.',
         '//',
@@ -1258,6 +1342,11 @@ function renderRouteTypes(manifest) {
         patterns.length > 0
             ? '    routes:\n' + patterns.map((p) => '      | ' + JSON.stringify(p)).join('\n')
             : '    // No routes found under the source directory.\n    routes: never',
+        // The searchParams schema each page exports, read off the module's type.
+        // This is what types Link's `search` prop and href() per route.
+        '    search: {',
+        ...[...search].sort().map(([pattern, target]) => '      ' + JSON.stringify(pattern) + ': SearchExportOf<typeof import(' + JSON.stringify(target) + ')>'),
+        '    }',
         '  }',
         // Api routes are a separate union, so Link refuses an api url and apiUrl()
         // refuses a page. Linking to an api route navigates the browser away to a
@@ -1419,7 +1508,8 @@ function metadataExports(absPath) {
  */
 function shipsClientJs(absPath) {
     const src = readFileSync(absPath, 'utf-8');
-    return !/export\s+const\s+clientJs\s*(:[^=]+)?=\s*false/.test(src);
+    const declared = /export\s+const\s+clientJs\s*(:[^=]+)?=\s*(true|false)/.exec(src);
+    return declared ? declared[2] === 'true' : 'auto';
 }
 /**
  * Which urls exist for a parameterised route.
@@ -1679,6 +1769,7 @@ import { httpHostCalls } from ${JSON.stringify(join(packageDir, 'hostCalls'))}
 import { prerenderedBeside } from ${JSON.stringify(join(packageDir, 'files'))}
 import { renderToReadableStream, decodeReply, loadServerAction } from '@vitejs/plugin-rsc/rsc'
 import { isQuery, queryCacheControl, isQueryValidationError } from ${JSON.stringify(join(packageDir, 'query'))}
+import { isActionValidationError, isClientBuilt } from ${JSON.stringify(join(packageDir, 'action'))}
 import { Suspense, createElement, Fragment } from 'react'
 import { AsyncLocalStorage } from 'node:async_hooks'
 ${imports.join('\n')}
@@ -1872,6 +1963,31 @@ export function manifest(): any {
   return ${JSON.stringify(routeManifest())}
 }
 
+/**
+ * For each server action id, whether a client built it. The build asks after
+ * the bundle exists, because the answer is a mark on the loaded function and
+ * nothing static could tell a wrapped export from a bare one.
+ */
+export async function auditActions(ids: string[]): Promise<{ id: string; client: boolean; query: boolean }[]> {
+  const out: { id: string; client: boolean; query: boolean }[] = []
+
+  for (const id of ids) {
+    let fn: unknown = null
+
+    try {
+      fn = await loadServerAction(id)
+    } catch {
+      continue
+    }
+
+    if (typeof fn !== 'function') continue
+
+    out.push({ id, client: isClientBuilt(fn), query: isQuery(fn) })
+  }
+
+  return out
+}
+
 /**
  * The param sets a route declares, or null when it declares none.
  *
@@ -2914,7 +3030,20 @@ export async function handleAction(
     )
   }
 
-  const result = await (action as (...a: unknown[]) => unknown)(...args)
+  // A plain "use server" function that threw fieldErrors() gets the same
+  // treatment createActionClient gives its handlers: the throw becomes the
+  // returned { validationErrors } that <Form> reads. Left thrown, React
+  // serialises the rejection opaquely — production strips the message — and the
+  // fields it named never reach the browser.
+  let result: unknown
+
+  try {
+    result = await (action as (...a: unknown[]) => unknown)(...args)
+  } catch (error) {
+    if (!isActionValidationError(error)) throw error
+
+    result = { validationErrors: error.errors }
+  }
 
   // Read after the action has run: what it invalidated is only known once its
   // host calls have been made. Rendering here rather than telling the browser
@@ -3009,7 +3138,7 @@ export async function handleRsc(
   pageKey = '',
   bootstrap = true,
   canReachHost = true,
-): Promise<{ body: string; rscPayload: string; clientChunks: unknown; usedDynamicApis: boolean; dynamicBecause: string[]; clientComponents: string[] }> {
+): Promise<{ body: string; rscPayload: string; clientChunks: unknown; usedDynamicApis: boolean; dynamicBecause: string[]; clientComponents: string[]; serverReferences: boolean }> {
   applyHost()
 
   // A build renders this with no host installed, so every rpc() has to suspend
@@ -3064,6 +3193,7 @@ export async function handleRsc(
     // says which components forced the decision, since they are usually in a
     // shared layout rather than the page itself.
     clientComponents: clientReferenceNames(rscPayload),
+    serverReferences: hasServerReference(rscPayload),
   }
 }
 
@@ -3077,14 +3207,35 @@ export async function handleRsc(
 function clientReferenceNames(payload: string): string[] {
   const names = new Set<string>()
 
+  // A string React has already sent is referenced by row - "$1" for the
+  // string in row 1 - rather than repeated. The export name of a client
+  // reference is exactly the kind of string that repeats, so it arrives that
+  // way and has to be looked up, or the refusal names a component "$1".
+  const strings = new Map<string, string>()
+
+  for (const line of payload.split('\\n')) {
+    const match = /^(\\d+):"(.*)"$/.exec(line)
+    if (match) strings.set('$' + match[1], match[2]!)
+  }
+
   for (const row of payload.split(':I[').slice(1)) {
     const name = row.split('"')[3]
-    if (name) names.add(name)
+    if (name) names.add(strings.get(name) ?? name)
   }
 
   return [...names]
 }
 
+/**
+ * Whether the payload carries a server reference - an action handed to a
+ * form or a client component. A row of {"id":"...","bound":...} is one,
+ * however it is pointed at ($F for a function prop, $h for a form action).
+ * A page with one needs the runtime to submit it.
+ */
+export function hasServerReference(payload: string): boolean {
+  return /^\\d+:\\{"id":"[^"]+","bound":/m.test(payload)
+}
+
 // Flight payload only (worker: rsc-payload — build-time).
 //
 // The segment variant of a prerendered route needs the payload and nothing
@@ -4043,7 +4194,7 @@ export function rscKit(options = {}) {
             const staticDir = clientOut
                 ? join(dirname(clientOut), 'server', NITRO_STATIC_DIR)
                 : join(outDir, NITRO_STATIC_DIR);
-            const { frozen, results } = await prerenderAfterBundles(bundle, staticDir, clientOut ?? publicAssetsDir);
+            const { frozen, results } = await prerenderAfterBundles(bundle, staticDir, clientOut ?? publicAssetsDir, builder ? knownActionsOf(builder.config, projectRoot) : []);
             // Manifest first. The service worker precaches whatever it finds in this
             // directory, so writing it afterwards leaves it out of the list — and an
             // installed app whose manifest is the one file that needs the network is