@rsc-kit/core 0.20.6 → 0.20.8

package/dist/shellHead.js

@@ -0,0 +1,43 @@
+/**
+ * The head of a stored shell, corrected for the url it is served for.
+ *
+ * A shell for a route that listed no urls is one file for every url the
+ * route matches, so its <title> is whatever the build could know without a
+ * url: the layouts' metadata, once the page's own generateMetadata was seen
+ * to read the params and left out. The host serving it does know the url,
+ * and the page's metadata is a function of it - so the title and the
+ * description are written into the head here, as a string edit on the way
+ * out, before React resumes the holes below. The client's DocumentTitle
+ * sets the title again after hydration; this is for the tab before that,
+ * and for whoever reads the document without running it.
+ */
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+const TITLE = /<title(?:\s[^>]*)?>[\s\S]*?<\/title>/i;
+const DESCRIPTION = /<meta\s+name=(?:"description"|'description'|description)\s+content=(?:"[^"]*"|'[^']*'|[^\s>]*)\s*\/?>/i;
+const HEAD_END = /<\/head>/i;
+/**
+ * `shell` with the given title and description in its head. Only the two
+ * that every share preview and every tab reads; the rest of a page's
+ * metadata rides with the payload.
+ */
+export function withHead(shell, metadata) {
+    if (!metadata)
+        return shell;
+    let out = shell;
+    if (metadata.title != null) {
+        const tag = `<title>${escapeHtml(String(metadata.title))}</title>`;
+        out = TITLE.test(out) ? out.replace(TITLE, tag) : out.replace(HEAD_END, `${tag}</head>`);
+    }
+    if (metadata.description != null) {
+        const tag = `<meta name="description" content="${escapeHtml(String(metadata.description))}"/>`;
+        out = DESCRIPTION.test(out) ? out.replace(DESCRIPTION, tag) : out.replace(HEAD_END, `${tag}</head>`);
+    }
+    return out;
+}
+//# sourceMappingURL=shellHead.js.map

package/dist/shellHead.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shellHead.js","sourceRoot":"","sources":["../src/shellHead.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,SAAS,UAAU,CAAC,IAAY;IAC9B,OAAO,IAAI;SACR,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;SACtB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;SACrB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;SACrB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AAC7B,CAAC;AAED,MAAM,KAAK,GAAG,uCAAuC,CAAC;AACtD,MAAM,WAAW,GAAG,wGAAwG,CAAC;AAC7H,MAAM,QAAQ,GAAG,WAAW,CAAC;AAE7B;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CACtB,KAAa,EACb,QAA2D;IAE3D,IAAI,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC;IAE5B,IAAI,GAAG,GAAG,KAAK,CAAC;IAEhB,IAAI,QAAQ,CAAC,KAAK,IAAI,IAAI,EAAE,CAAC;QAC3B,MAAM,GAAG,GAAG,UAAU,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC;QAEnE,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC;IAC3F,CAAC;IAED,IAAI,QAAQ,CAAC,WAAW,IAAI,IAAI,EAAE,CAAC;QACjC,MAAM,GAAG,GAAG,qCAAqC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC;QAE/F,GAAG,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC;IACvG,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["/**\n * The head of a stored shell, corrected for the url it is served for.\n *\n * A shell for a route that listed no urls is one file for every url the\n * route matches, so its <title> is whatever the build could know without a\n * url: the layouts' metadata, once the page's own generateMetadata was seen\n * to read the params and left out. The host serving it does know the url,\n * and the page's metadata is a function of it - so the title and the\n * description are written into the head here, as a string edit on the way\n * out, before React resumes the holes below. The client's DocumentTitle\n * sets the title again after hydration; this is for the tab before that,\n * and for whoever reads the document without running it.\n */\n\nfunction escapeHtml(text: string): string {\n  return text\n    .replace(/&/g, \"&amp;\")\n    .replace(/</g, \"&lt;\")\n    .replace(/>/g, \"&gt;\")\n    .replace(/\"/g, \"&quot;\");\n}\n\nconst TITLE = /<title(?:\\s[^>]*)?>[\\s\\S]*?<\\/title>/i;\nconst DESCRIPTION = /<meta\\s+name=(?:\"description\"|'description'|description)\\s+content=(?:\"[^\"]*\"|'[^']*'|[^\\s>]*)\\s*\\/?>/i;\nconst HEAD_END = /<\\/head>/i;\n\n/**\n * `shell` with the given title and description in its head. Only the two\n * that every share preview and every tab reads; the rest of a page's\n * metadata rides with the payload.\n */\nexport function withHead(\n  shell: string,\n  metadata: { title?: unknown; description?: unknown } | null,\n): string {\n  if (!metadata) return shell;\n\n  let out = shell;\n\n  if (metadata.title != null) {\n    const tag = `<title>${escapeHtml(String(metadata.title))}</title>`;\n\n    out = TITLE.test(out) ? out.replace(TITLE, tag) : out.replace(HEAD_END, `${tag}</head>`);\n  }\n\n  if (metadata.description != null) {\n    const tag = `<meta name=\"description\" content=\"${escapeHtml(String(metadata.description))}\"/>`;\n\n    out = DESCRIPTION.test(out) ? out.replace(DESCRIPTION, tag) : out.replace(HEAD_END, `${tag}</head>`);\n  }\n\n  return out;\n}\n"]}

package/dist/vite.js

@@ -42,8 +42,23 @@ let inlineStylesheets = "auto";
 let resolvedConfig = null;
 /** Server files importing a client library, read off the rsc graph when it is built. */
 let clientLibraryImports = [];
-/** Modules a runtime provides and no bundle should try to carry. */
-const RUNTIME_BUILTINS = ["bun", /^bun:/];
+/**
+ * The Nitro preset this build targets, from the module's setup, for the
+ * decisions buildApp makes about where stored pages can live.
+ */
+let nitroPreset = null;
+/**
+ * Modules a runtime provides and no bundle should try to carry.
+ *
+ * Bun's, and the Workers runtime's: `cloudflare:workers` is where a Worker
+ * reads its bindings - `import { env } from 'cloudflare:workers'` for the
+ * D1 database or the R2 bucket wrangler.jsonc names - and a bundle that
+ * tried to resolve it at build time found nothing to resolve. Import it
+ * where the code runs on Workers; a `vite dev` under Bun or Node has no such
+ * module, so an app that also runs there imports it lazily, behind the
+ * check for the runtime.
+ */
+const RUNTIME_BUILTINS = ["bun", /^bun:/, /^cloudflare:/];
 /**
  * Packages the server bundles import rather than inline, by default.
  *
@@ -394,7 +409,9 @@ function log(...args) {
  * pattern is the host's dialect: Laravel writes {slug}, Hono writes :slug, and
  * neither is the plugin's business.
  */
-/** `[...path]` → catchAll, `[id]` → param, `(group)` → nothing at all. */
+/** The names a top-level parameter directory can have to bind the host rather than a path segment. */
+const HOST_SEGMENTS = new Set(["domain", "host"]);
+/** `[...path]` → catchAll, `[id]` → param, `[domain]` at the top → host, `(group)` → nothing at all. */
 function urlSegments(componentName) {
     const parts = componentName.split("/").slice(1, -1);
     const segments = [];
@@ -410,11 +427,15 @@ function urlSegments(componentName) {
             continue;
         }
         if (part.startsWith("[") && part.endsWith("]")) {
-            // At the top of app/ - the first segment the url has - a parameter is
-            // the host's: bound from acme.example.com, never from example.com/acme.
+            const value = part.slice(1, -1);
+            // At the top of app/ - the first segment the url has - a [domain] or a
+            // [host] is the host's: bound from acme.example.com, never from
+            // example.com/acme. Any other name there is a path parameter, as it is
+            // in Next: a port's app/[collection]/page.tsx was read as a tenant tree
+            // and every collection url answered 404.
             segments.push({
-                type: segments.length === 0 ? "host" : "param",
-                value: part.slice(1, -1),
+                type: segments.length === 0 && HOST_SEGMENTS.has(value) ? "host" : "param",
+                value,
             });
             continue;
         }
@@ -2453,6 +2474,7 @@ import { prerenderedBeside } from ${JSON.stringify(join(packageDir, "files"))}
 import { renderToReadableStream, decodeReply, decodeAction, decodeFormState, 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 { forgetCached } from ${JSON.stringify(join(packageDir, "cache"))}
 import { noteFallback as noteCaughtRead } from ${JSON.stringify(join(packageDir, "request"))}
 import { isOutdatedOptimizedDep, outdatedDepResponse } from ${JSON.stringify(join(packageDir, "devReload"))}
 import { sharedDepth } from ${JSON.stringify(join(packageDir, "routing"))}
@@ -3076,10 +3098,27 @@ function buildElement(
   // it reads, everything above it still paints, and that is a shell one file
   // can serve for every url the route matches.
   params: Promise<Record<string, unknown>> = Promise.resolve(props),
+  // The url the client hooks answer with during a server render, when it is
+  // not the page key. Undefined: the page key, or unknown when that is
+  // empty. Null: unknown, whatever the key - the payload a pattern shell's
+  // document boots from is keyed by its url and still must not know it.
+  pathname: string | null | undefined = undefined,
 ) {
   const Component = components[component]
   if (!Component) throw new Error('Unknown RSC component: ' + component)
 
+  // Rendered at the top and again inside every boundary, and always with
+  // the runtime - so a segment has the same shape whichever way it arrived.
+  // A page reached by a partial navigation had the provider at the root of
+  // its segment, a page reached by a document load had it outside every
+  // boundary, and a revalidation rendered with no page key had none: React
+  // saw a different component at the root of the segment and remounted
+  // everything under it. A port lost the one-time secret in a modal that
+  // way. With the provider at every level the three trees agree.
+  const rendered = pathname === undefined ? pageKey || null : pathname
+  const withPathname = (node: unknown): unknown =>
+    bootstrap ? createElement(PathnameProvider, { value: rendered }, node) : node
+
   // Awaitable rather than spread. Spread, a page reads its slug synchronously
   // and renders to completion during the probe — producing a page about an
   // invented value, right for nothing — which is why such a route could only
@@ -3198,7 +3237,7 @@ function buildElement(
     // one — otherwise every page would drag React in for a seam nothing can
     // use, and no page could ever be JS-free.
     if (bootstrap) {
-      element = createElement(SegmentBoundary, { depth: i + 1, pageKey }, element)
+      element = createElement(SegmentBoundary, { depth: i + 1, pageKey }, withPathname(element))
     }
 
     element = createElement(Layout, {
@@ -3208,14 +3247,8 @@ function buildElement(
     })
   }
 
-  // The url the client hooks answer with during a server render. Outside the
-  // boundaries, so a page keeps it across a partial navigation; omitted with
-  // the runtime, since a route shipping none has nothing to read it.
-  if (bootstrap && pageKey) {
-    element = createElement(PathnameProvider, { value: pageKey }, element)
-  }
-
-  return element
+  // And outside the boundaries, for the root layout, which is above them all.
+  return withPathname(element)
 }
 
 // Resolve route metadata into React elements. React 19 hoists <title>/<meta>
@@ -3232,11 +3265,21 @@ async function renderTree(
   pageKey = '',
   bootstrap = true,
   params?: Promise<Record<string, unknown>>,
+  pathname: string | null | undefined = undefined,
+  // What generateMetadata is given, when it is not what the page is given.
+  // A resume of a pattern shell renders the page for its real params and
+  // the metadata as the shell did - left out where it read them - because
+  // a tree with a <title> the shell had not got is a tree that does not
+  // match, and React then fills nothing.
+  metadataParams: Promise<Record<string, unknown>> | undefined = params,
 ) {
   // The FULL chain, always: a title template lives on an outer layout, and a
   // partial render still has to produce the same <title> the whole document
   // would have.
-  const md = await resolveMetadata(component, props, layouts)
+  // The params promise travels too: during the pattern probe it never
+  // settles, and a generateMetadata that reads it is then left out of the
+  // shell rather than run against the placeholder - see resolveMetadata.
+  const md = await resolveMetadata(component, props, layouts, metadataParams)
   const head: unknown[] = []
 
   // Rendered into the tree rather than written into the app's layout: React
@@ -3483,7 +3526,7 @@ async function renderTree(
 
   // Metadata elements are rendered INSIDE the document tree so React 19 hoists
   // <title>/<meta> into <head> (hoisting only works from within the tree).
-  return buildElement(component, props, layouts, loadings, parallelSlots, slotOverrides, head, from, pageKey, bootstrap, params)
+  return buildElement(component, props, layouts, loadings, parallelSlots, slotOverrides, head, from, pageKey, bootstrap, params, pathname)
 }
 
 /**
@@ -3655,6 +3698,10 @@ export async function handleRscStream(
   slotOverrides: Record<string, SlotOverride> = {},
   from = 0,
   pageKey = '',
+  // The url the client hooks answer with. Null for the payload a document
+  // served from a pattern shell boots from: the shell did not know its url,
+  // and hydration has to agree with the shell. See PathnameProvider.
+  pathname: string | null | undefined = undefined,
 ): Promise<{ stream: ReadableStream; clientChunks: unknown; segmentDepth: number }> {
   await instrumented()
   applyHost()
@@ -3668,7 +3715,7 @@ export async function handleRscStream(
 
   return {
     stream: renderToReadableStream(
-      await renderTree(component, props, layouts, loadings, parallelSlots, slotOverrides, start, pageKey),
+      await renderTree(component, props, layouts, loadings, parallelSlots, slotOverrides, start, pageKey, true, undefined, pathname ?? null),
       { onError: flightOnError },
     ),
     clientChunks: {},
@@ -3795,6 +3842,11 @@ export async function handleRscResume(
   postponed: unknown = null,
   nonce?: string,
   pageKey = '',
+  // The request's url, for the hooks: a pattern shell is keyed with none,
+  // and the holes it leaves are still rendered for a real url. A breadcrumb
+  // in one streamed empty and the client, knowing the url, disagreed on
+  // every document load.
+  pathname: string | null | undefined = undefined,
 ): Promise<{ htmlStream: ReadableStream }> {
   await instrumented()
   applyHost()
@@ -3811,7 +3863,28 @@ export async function handleRscResume(
   // all, so the shell's remains the only one. What this flag actually decides
   // is whether the tree carries its SegmentBoundary, and the shell's did.
   const flight = renderToReadableStream(
-    await renderTree(component, props, layouts, loadings, parallelSlots, slotOverrides, 0, pageKey, true),
+    await renderTree(
+      component,
+      props,
+      layouts,
+      loadings,
+      parallelSlots,
+      slotOverrides,
+      0,
+      pageKey,
+      true,
+      undefined,
+      // A pattern shell was rendered for no url, and the holes that resume
+      // it render the same way: a breadcrumb in one would otherwise be
+      // rendered here for the url and hydrated against a payload that, like
+      // the shell, does not know it. The browser fills it in.
+      pageKey === '' ? null : pathname,
+      // And with params that never settled, its metadata left out where it
+      // read them; the same here, or the tree has a <title> the shell had
+      // not and the slots stop matching. The host writes the real title into
+      // the head as it serves the shell.
+      pageKey === '' ? new Promise<Record<string, unknown>>(() => {}) : undefined,
+    ),
     { onError: flightOnError },
   )
 
@@ -3826,6 +3899,8 @@ export async function handleRscResume(
 interface PageContext {
   component: string
   props: Record<string, unknown>
+  /** The page's url, as the host matched it: the key a navigation to it renders under. */
+  url?: string
   layouts: LayoutEntry[]
   loadings: string[]
   parallelSlots: Record<string, string>
@@ -3856,6 +3931,9 @@ async function renderRevalidated(target: string, page: PageContext): Promise<unk
   await runMiddleware(page.component, page.props)
 
   if (target === 'all' || target === 'page') {
+    // Keyed by the page's url, as a navigation to it is: the tree replaces
+    // the one on screen in place only if it has the same shape, and the
+    // key decides the shape.
     return renderTree(
       page.component,
       page.props,
@@ -3864,7 +3942,7 @@ async function renderRevalidated(target: string, page: PageContext): Promise<unk
       page.parallelSlots,
       {},
       target === 'all' ? 0 : page.layouts.length,
-      '',
+      page.url ?? '',
     )
   }
 
@@ -4073,6 +4151,12 @@ export async function handleAction(
     return { stream: renderToReadableStream(result) }
   }
 
+  // The render is of the world after the write. Everything cache() answered
+  // before it - the agent the middleware loaded, the settings the action
+  // read to compare - was true before the write, and the sidebar rendered
+  // from those memos still showed the old name after a rename.
+  forgetCached()
+
   const revalidated: Record<string, unknown> = {}
 
   for (const target of targets) {
@@ -4084,25 +4168,68 @@ export async function handleAction(
   return { stream: renderToReadableStream({ __rscRevalidated: revalidated, result }) }
 }
 
+/**
+ * How long a generateMetadata gets to answer during the pattern probe before
+ * it is taken to have awaited the params, which never settle there.
+ *
+ * Not zero: a function that awaits nothing of the request still crosses a
+ * microtask or two. Anything still pending after this has read the params or
+ * reached for the host - both are the page's data, and neither is in a shell.
+ */
+const METADATA_PROBE_GRACE_MS = 20
+
+const METADATA_POSTPONED = Symbol('metadata postponed')
+
 export async function resolveMetadata(
   component: string,
   props: Record<string, unknown> = {},
   layouts: LayoutEntry[] = [],
+  // The page's own params promise, when the caller has one. During the
+  // pattern probe it never settles - see handleRscPprShell.
+  params?: Promise<Record<string, unknown>>,
 ): Promise<Record<string, unknown> | null> {
   await instrumented()
 
   const pageEntry = metadataMap[component]
-  const page: Record<string, unknown> = pageEntry
-    ? (pageEntry.generate
-        // The same awaitables the page receives. Resolved rather than
-        // suspending, even during the probe: a title has to be produced for
-        // the shell, and there is no fallback for a <title>.
-        ? ((await pageEntry.generate({
-            params: Promise.resolve(props),
-            searchParams: pageSearchParams(),
-          })) ?? {})
-        : { ...(pageEntry.static ?? {}) })
-    : {}
+
+  // What a route file declares, static or generated. A generateMetadata is
+  // given the same awaitables the page receives - and, during the pattern
+  // probe, params that never settle and a moment: one that answers did not
+  // need them and is the shell's; one still pending did, and is left out.
+  // A shell for a route that listed no urls is rendered for the pattern, and
+  // a title read from the params would be read from the placeholder the
+  // build invented: a port's training-sessions/[id] shell said "Training
+  // Session" over a payload for /new that said "New Training Session". Next
+  // treats params as dynamic under PPR and postpones the metadata. The host
+  // puts the real title in when it serves the shell for a url, and the
+  // client's DocumentTitle sets it again after hydration.
+  const declared = async (entry: (typeof metadataMap)[string] | undefined): Promise<Record<string, unknown>> => {
+    if (!entry) return {}
+
+    if (!entry.generate) return entry.static ? { ...entry.static } : {}
+
+    const generated = entry.generate({
+      params: params ?? Promise.resolve(props),
+      searchParams: pageSearchParams(),
+    })
+
+    const settled = params
+      ? await Promise.race([
+          Promise.resolve(generated),
+          new Promise<typeof METADATA_POSTPONED>((resolve) =>
+            setTimeout(() => resolve(METADATA_POSTPONED), METADATA_PROBE_GRACE_MS),
+          ),
+        ])
+      : await generated
+
+    return settled === METADATA_POSTPONED ? {} : ((settled as Record<string, unknown> | undefined) ?? {})
+  }
+
+  // Layouts too, outer to inner: Next runs a layout's generateMetadata, and
+  // a port had the category's title in its layout - which rendered as the
+  // site's name on every category page until this read it.
+  const layoutMeta = await Promise.all(layouts.map((l) => declared(metadataMap[l.component])))
+  const page = await declared(pageEntry)
 
   // Non-title metadata: layout defaults (outer→inner), page overrides.
   //
@@ -4121,26 +4248,30 @@ export async function resolveMetadata(
     }
   }
 
-  for (const l of layouts) {
-    const s = metadataMap[l.component]?.static
-
-    if (s) take(s as Record<string, unknown>)
-  }
+  for (const m of layoutMeta) take(m)
 
   take(page)
 
   if (Object.keys(other).length > 0) merged.other = other
 
-  // Title: the page title with the NEAREST layout title.template applied; if the
-  // page has no title, the nearest layout default/string title.
+  // Title: the page's, or the nearest layout's own string or default - and
+  // then the nearest template ABOVE whichever supplied it, as Next applies a
+  // layout's template to the titles of the segments below it. A layout's
+  // title used to stop the walk before any template: a category named in
+  // its layout lost the site's suffix every page had.
   let title: string | undefined = typeof page.title === 'string' ? page.title : undefined
   for (let i = layouts.length - 1; i >= 0; i--) {
-    const lt = metadataMap[layouts[i].component]?.static?.title as
+    const lt = layoutMeta[i]?.title as
       | string | { template?: string; default?: string } | undefined
-    if (lt && typeof lt === 'object') {
-      if (title != null && lt.template) { title = lt.template.replace('%s', title); break }
-      if (title == null && lt.default) { title = lt.default; break }
-    } else if (title == null && typeof lt === 'string') { title = lt; break }
+
+    if (title == null) {
+      if (lt && typeof lt === 'object' && lt.default) title = lt.default
+      else if (typeof lt === 'string') title = lt
+
+      continue
+    }
+
+    if (lt && typeof lt === 'object' && lt.template) { title = lt.template.replace('%s', title); break }
   }
   if (title != null) merged.title = title
 
@@ -4389,6 +4520,17 @@ export async function handleRscPprShell(
   // page, stored, with the build reporting success.
   let renderFailure: string | undefined
 
+  // A read the server could not answer, caught at a boundary: the query,
+  // which a server never has, or the pathname, which a shell for a pattern
+  // does not. Each hook throws with its own digest; the build names the hook.
+  const caughtReadOf = (error: unknown): { hook: string; digest: string } | null => {
+    const digest = (error as { digest?: string } | null)?.digest
+
+    if (digest === 'rsc-kit:search-params-fallback') return { hook: 'useSearchParams()', digest }
+
+    return null
+  }
+
   const noteFailure = (e: unknown, info?: { componentStack?: string }): string | undefined => {
     const digest = redirectDigest(e)
 
@@ -4399,10 +4541,12 @@ export async function handleRscPprShell(
     // there is what gets stored. Noted with its component so the build can
     // say so on the route's line; the digest goes into the document for the
     // browser to recognise.
-    if ((e as { digest?: string } | null)?.digest === 'rsc-kit:search-params-fallback') {
+    const caught = caughtReadOf(e)
+
+    if (caught) {
       const where = /at ([A-Z_$][\\w$]*)/.exec(info?.componentStack ?? '')?.[1]
-      noteCaughtRead('useSearchParams()' + (where ? ' in ' + where : ''))
-      return 'rsc-kit:search-params-fallback'
+      noteCaughtRead(caught.hook + (where ? ' in ' + where : ''))
+      return caught.digest
     }
 
     // Every probe ends by aborting, so React reports that abort. Asked of the
@@ -4729,10 +4873,11 @@ export async function handleSsrPrerender(
     // Aborting is how this ends, so React's report of it is not news. A read
     // caught at a boundary is: the build attaches it to the route.
     onError: (error: unknown, info?: { componentStack?: string }) => {
-      if ((error as { digest?: string } | null)?.digest !== 'rsc-kit:search-params-fallback') return
+      const caught = caughtReadOf(error)
+      if (!caught) return
       const where = /at ([A-Z_$][\\w$]*)/.exec(info?.componentStack ?? '')?.[1]
-      noteFallback('useSearchParams()' + (where ? ' in ' + where : ''))
-      return 'rsc-kit:search-params-fallback'
+      noteFallback(caught.hook + (where ? ' in ' + where : ''))
+      return caught.digest
     },
   })
 
@@ -4750,6 +4895,19 @@ export async function handleSsrPrerender(
  * so React writes it into the document. Under a boundary the developer wrote
  * there is nothing to say; with nothing closer than a loading.tsx, one line.
  */
+/**
+ * A read the server could not answer, caught at a boundary: the query, which
+ * a server never has, or the pathname, which a shell for a pattern does not.
+ * Each hook throws with its own digest; the build names the hook.
+ */
+function caughtReadOf(error: unknown): { hook: string; digest: string } | null {
+  const digest = (error as { digest?: string } | null)?.digest
+
+  if (digest === 'rsc-kit:search-params-fallback') return { hook: 'useSearchParams()', digest }
+
+  return null
+}
+
 function reportRenderError(phase: 'ssr' | 'resume') {
   return (error: unknown, info?: { componentStack?: string }) => {
     // The consumer cancelled - a browser that left mid-stream, a prefetch
@@ -4765,19 +4923,21 @@ function reportRenderError(phase: 'ssr' | 'resume') {
     // times or once.
     if (parseRedirectDigest(digest) || isNotFoundDigest(digest)) return digest
 
-    if (digest === 'rsc-kit:search-params-fallback') {
+    const caught = caughtReadOf(error)
+
+    if (caught) {
       // The component is the first frame of React's stack. Noted on the
       // request so the build attaches it to the route; printed as one line,
       // not a stack, so the server says which boundary it wants.
       const where = /at ([A-Z_$][\\w$]*)/.exec(info?.componentStack ?? '')?.[1]
 
-      noteFallback('useSearchParams()' + (where ? ' in ' + where : ''))
+      noteFallback(caught.hook + (where ? ' in ' + where : ''))
 
       if (caughtByLoading(info?.componentStack)) {
         console.error(
           '[rsc-kit] ' + (where ? where + ': ' : '') +
-          'useSearchParams() was read on the server with nothing closer than a loading.tsx, so the whole ' +
-          'segment shows that fallback until the query arrives. A <Suspense> around the component that reads ' +
+          caught.hook + ' was read on the server with nothing closer than a loading.tsx, so the whole ' +
+          'segment shows that fallback until the value arrives. A <Suspense> around the component that reads ' +
           'keeps the rest of the page painted.',
         )
       }
@@ -5511,6 +5671,24 @@ export function rscKit(options = {}) {
             setup(nitro) {
                 if (nitro.options.dev)
                     return;
+                nitroPreset = nitro.options.preset ?? null;
+                // On Workers the stored pages ride the static assets, not the bundle.
+                // Copied once Nitro has listed its public files, so the copies are
+                // not in that list: a path in it is served as an asset before the
+                // Worker runs, and a stored page of a guarded route would then be
+                // public. Off the list and behind run_worker_first, a request for
+                // one reaches the app, which has no such route, and the pages are
+                // read only through the binding. See ASSETS_PREFIX in files.ts.
+                if (nitro.options.preset?.startsWith("cloudflare")) {
+                    nitro.hooks.hook("compiled", async () => {
+                        const { storedPagesToAssets } = await import("./files.js");
+                        const serverDir = nitro.options.output.serverDir;
+                        const publicDir = nitro.options.output.publicDir ?? join(dirname(serverDir), "public");
+                        const copied = await storedPagesToAssets(join(serverDir, NITRO_STATIC_DIR), publicDir, join(serverDir, "wrangler.json"));
+                        if (copied > 0)
+                            log(`stored pages: ${copied} files uploaded as assets, read through the ASSETS binding`);
+                    });
+                }
                 // Said at the end of a bun build, only when true: which module keeps
                 // `bun build --compile --bytecode` from applying, and where. Bun
                 // itself names no file and exits 0. See bytecodeCheck.ts.
@@ -5816,6 +5994,17 @@ export function rscKit(options = {}) {
                             rollupOptions: {
                                 input: { index: join(genDir, "entry.rsc.tsx") },
                                 external: serverExternals,
+                                // The server-references map is `id: () => import(file)` for
+                                // every "use server" file, and the page that passes an action
+                                // to <Form> imports the same file statically. Rolldown says
+                                // so for each one: "dynamically imported by
+                                // virtual:vite-rsc/server-references but also statically
+                                // imported by page.tsx, dynamic import will not move module
+                                // into another chunk". Nothing was meant to move: a server
+                                // bundle has no chunk to lazy-load from a browser, and the
+                                // map is a lookup table, not a split point. One line per
+                                // action in every build was a paragraph nobody could act on.
+                                checks: { ineffectiveDynamicImport: false },
                             },
                         },
                         resolve: { noExternal: bundledClientPackages },
@@ -5826,6 +6015,8 @@ export function rscKit(options = {}) {
                             rollupOptions: {
                                 input: { index: join(genDir, "entry.ssr.tsx") },
                                 external: serverExternals,
+                                // Same table, same reason.
+                                checks: { ineffectiveDynamicImport: false },
                             },
                         },
                         resolve: { noExternal: bundledClientPackages },
@@ -6067,7 +6258,11 @@ export function rscKit(options = {}) {
             // module is uploaded as a sibling of the bundle and imported at runtime
             // when the directory is not there. Only under Nitro, whose presets are
             // the ones without a disk; on its own the plugin serves from outDir.
-            if (clientOut && existsSync(staticDir)) {
+            // Not on Workers, where the pages ride the static assets instead - an
+            // inline module counts against the script's size limit, and a port's
+            // 571 stored pages were 69 MB of one. See the Nitro module's compiled
+            // hook.
+            if (clientOut && existsSync(staticDir) && !nitroPreset?.startsWith("cloudflare")) {
                 const { inlineModuleName, inlineModuleSource, compileEntrySource } = await import("./files.js");
                 writeFileSync(join(dirname(staticDir), inlineModuleName(NITRO_STATIC_DIR)), await inlineModuleSource(staticDir));
                 // And the entry a binary is compiled from, so the pages above end up