@rsc-kit/core 0.29.1 → 0.29.3

package/dist/vite.js

@@ -2932,7 +2932,7 @@ import { isSharedSection, sectionComponent } from ${JSON.stringify(join(packageD
 import { shareRender } from ${JSON.stringify(join(packageDir, "sharedRenders"))}
 import { PathnameProvider } from ${JSON.stringify(join(packageDir, "js/PathnameProvider"))}
 import { DefaultRouteError } from ${JSON.stringify(join(packageDir, "js/DefaultRouteError"))}
-import { searchParams as requestSearchParams, withUrl } from ${JSON.stringify(join(packageDir, "request"))}
+import { requestSearch, searchParams as requestSearchParams, withUrl } from ${JSON.stringify(join(packageDir, "request"))}
 import { parseParams, parseSearchParams, parseBody, isSearchParamsError, isBodyError } from ${JSON.stringify(join(packageDir, "routeSchema"))}
 import { notFoundDigest, isNotFoundSignal } from ${JSON.stringify(join(packageDir, "notFound"))}
 import { noteRequestRead, notePageProps, urlOf } from ${JSON.stringify(join(packageDir, "request"))}
@@ -4378,7 +4378,7 @@ export async function handleRscHtmlStream(
   const [forHtml, forPayload] = flight.tee()
   const rscPayloadPromise = new Response(forPayload).text()
   const ssr = await (import.meta as any).viteRsc.loadModule('ssr', 'index')
-  const htmlStream = await ssr.handleSsr(forHtml, nonce, undefined, bootstrap)
+  const htmlStream = await ssr.handleSsr(forHtml, nonce, undefined, bootstrap, undefined, requestSearch())
   return { htmlStream, rscPayloadPromise, clientChunks: {} }
 }
 
@@ -4425,7 +4425,7 @@ export async function handleRscFormPost(
     { onError: flightOnError },
   )
   const ssr = await (import.meta as any).viteRsc.loadModule('ssr', 'index')
-  const htmlStream = await ssr.handleSsr(flight, nonce, undefined, bootstrap, formState)
+  const htmlStream = await ssr.handleSsr(flight, nonce, undefined, bootstrap, formState, requestSearch())
 
   return { htmlStream }
 }
@@ -4514,9 +4514,15 @@ export async function handleRscResume(
   // client-rendered. Set before the stream ends, because that is when
   // React reports it.
   let replayFailed = false
-  const htmlStream = await ssr.handleSsrResume(flight, postponed, nonce, () => {
-    replayFailed = true
-  })
+  const htmlStream = await ssr.handleSsrResume(
+    flight,
+    postponed,
+    nonce,
+    () => {
+      replayFailed = true
+    },
+    requestSearch(),
+  )
 
   return { htmlStream, replayed: () => !replayFailed }
 }
@@ -4796,8 +4802,14 @@ export async function handleAction(
   // to ask is the whole point — the answer carries what went stale with it.
   const targets = takeRevalidated?.() ?? []
 
+  // flightOnError on both, as on every other render: it is what turns a
+  // redirect() or notFound() into the digest the client's boundaries read.
+  // Without it a re-render that reached a redirect inside a Suspense
+  // boundary - the old address of a page the action just renamed - sent an
+  // anonymous error, and the boundary showed the error page instead of
+  // following it.
   if (targets.length === 0 || !page) {
-    return { stream: renderToReadableStream(result) }
+    return { stream: renderToReadableStream(result, { onError: flightOnError }) }
   }
 
   // The render is of the world after the write. Everything cache() answered
@@ -4822,7 +4834,7 @@ export async function handleAction(
 
     // Marked, so an action whose own result happens to be an object with a
     // 'result' key is not mistaken for this envelope.
-    return { stream: renderToReadableStream({ __rscRevalidated: revalidated, result }) }
+    return { stream: renderToReadableStream({ __rscRevalidated: revalidated, result }, { onError: flightOnError }) }
   }
 
   return page.href ? await withUrl(page.href, render) : await render()
@@ -5076,13 +5088,16 @@ export async function handleRscRevalidate(
     await runMiddleware(page.component, page.props)
 
     const rscPayload = await shareRender(page.component + ' ' + target + ' ' + share, async () =>
-      new Response(renderToReadableStream(await renderRevalidated(target, page, false, true))).text(),
+      new Response(renderToReadableStream(await renderRevalidated(target, page, false, true), { onError: flightOnError })).text(),
     )
 
     return { rscPayload }
   }
 
-  const flight = renderToReadableStream(await renderRevalidated(target, page))
+  // A redirect the refreshed region reaches has to arrive as one - a region
+  // refreshed because refreshOn heard its data change, on a page that now
+  // redirects, showed the error page without the digest.
+  const flight = renderToReadableStream(await renderRevalidated(target, page), { onError: flightOnError })
 
   return { rscPayload: await new Response(flight).text() }
 }
@@ -5521,6 +5536,8 @@ import { cancelledByConsumer, caughtByLoading } from ${JSON.stringify(fallbackRe
 import { parseRedirectDigest } from ${JSON.stringify(redirectDigestModule)}
 import { isNotFoundDigest } from ${JSON.stringify(notFoundModule)}
 import { EARLY_CLICKS } from ${JSON.stringify(earlyClicks)}
+import { searchSnapshotContext } from ${JSON.stringify(join(packageDir, "js/useSearchParams"))}
+import { createElement as h } from 'react'
 ${webManifestOptions ? `import { INSTALL_CAPTURE } from ${JSON.stringify(installCapture)}` : ""}
 
 // What runs ahead of the runtime: held taps, and - in an app that can be
@@ -5532,14 +5549,27 @@ const EARLY = EARLY_CLICKS${webManifestOptions ? " + INSTALL_CAPTURE" : ""}
 // modules only Vite can answer — see devUrls.ts.
 const DEV_ORIGIN = ${JSON.stringify(devOrigin)}
 
+/**
+ * The tree with the query it is rendered for: the request's, so a client
+ * component reading useSearchParams renders on the server like any other -
+ * or null where the HTML may be stored, so it refuses and the browser
+ * renders it. Always wrapped, null or not: a shell prerendered at build and
+ * its holes resumed per request must be the same tree, or React cannot line
+ * them up.
+ */
+function withSearch(root: unknown, search: string | null | undefined): unknown {
+  return h(searchSnapshotContext().Provider, { value: search ?? null }, root as any)
+}
+
 export async function handleSsr(
   rscStream: ReadableStream,
   nonce?: string,
   onError?: (error: unknown) => void,
   bootstrap = true,
   formState?: unknown,
+  search?: string | null,
 ): Promise<ReadableStream> {
-  const root = await createFromReadableStream(rscStream)
+  const root = withSearch(await createFromReadableStream(rscStream), search)
 
   // Without the bootstrap the page ships no client runtime at all: no React,
   // no Flight client, no router. HTML only. A page with nothing interactive on
@@ -5585,7 +5615,8 @@ export async function handleSsrPrerender(
   rscStream: ReadableStream,
   options: { nonce?: string; bootstrap?: boolean; signal?: AbortSignal } = {},
 ): Promise<{ prelude: ReadableStream; postponed: unknown }> {
-  const root = await createFromReadableStream(rscStream)
+  // Null: a prerender is stored.
+  const root = withSearch(await createFromReadableStream(rscStream), null)
 
   const bootstrapScriptContent =
     options.bootstrap === false
@@ -5694,8 +5725,11 @@ export async function handleSsrResume(
   // is client-rendered instead of filled here. The caller decides what to
   // do about it; see the host.
   onReplayMismatch?: () => void,
+  search?: string | null,
 ): Promise<ReadableStream> {
-  const root = await createFromReadableStream(rscStream)
+  // The same tree the shell was prerendered with, now holding this
+  // request's query: the holes are filled per request.
+  const root = withSearch(await createFromReadableStream(rscStream), search)
 
   const html = await resume(root as any, postponed as any, {
     nonce,