vinext 0.0.32 → 0.0.34

package/dist/entries/app-ssr-entry.js

@@ -1,3 +1,4 @@
+import { resolveRuntimeEntryModule } from "./runtime-entry-module.js";
 //#region src/entries/app-ssr-entry.ts
 /**
 * Generate the virtual SSR entry module.
@@ -11,468 +12,11 @@
 * metadata (including `getStaticPaths`) via `import("./ssr/index.js")`.
 */
 function generateSsrEntry(hasPagesDir = false) {
+	const entryPath = resolveRuntimeEntryModule("app-ssr-entry");
 	return `
-import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
-import { renderToReadableStream, renderToStaticMarkup } from "react-dom/server.edge";
-import { setNavigationContext, ServerInsertedHTMLContext } from "next/navigation";
-import { runWithNavigationContext as _runWithNavCtx } from "vinext/navigation-state";
-import { safeJsonStringify } from "vinext/html";
-import { createElement as _ssrCE } from "react";
-import * as _clientRefs from "virtual:vite-rsc/client-references";
-
-let _clientRefsPreloaded = false;
-
-/**
- * Collect all chunks from a ReadableStream into an array of text strings.
- * Used to capture the RSC payload for embedding in HTML.
- * The RSC flight protocol is text-based (line-delimited key:value pairs),
- * so we decode to text strings instead of byte arrays — this is dramatically
- * more compact when JSON-serialized into inline <script> tags.
- */
-async function collectStreamChunks(stream) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  const chunks = [];
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    // Decode Uint8Array to text string for compact JSON serialization
-    chunks.push(decoder.decode(value, { stream: true }));
-  }
-  return chunks;
-}
-
-// React 19 dev-mode workaround (see VinextFlightRoot in handleSsr):
-//
-// In dev, Flight error decoding in react-server-dom-webpack/client.edge
-// can hit resolveErrorDev() which (via React's dev error stack capture)
-// expects a non-null hooks dispatcher.
-//
-// Vinext previously called createFromReadableStream() outside of any React render.
-// When an RSC stream contains an error, dev-mode decoding could crash with:
-//   - "Invalid hook call"
-//   - "Cannot read properties of null (reading 'useContext')"
-//
-// Fix: call createFromReadableStream() lazily inside a React component render.
-// This mirrors Next.js behavior and ensures the dispatcher is set.
-
-/**
- * Create a TransformStream that appends RSC chunks as inline <script> tags
- * to the HTML stream. This allows progressive hydration — the browser receives
- * RSC data incrementally as Suspense boundaries resolve, rather than waiting
- * for the entire RSC payload before hydration can begin.
- *
- * Each chunk is written as:
- *   <script>self.__VINEXT_RSC_CHUNKS__=self.__VINEXT_RSC_CHUNKS__||[];self.__VINEXT_RSC_CHUNKS__.push("...")<\/script>
- *
- * Chunks are embedded as text strings (not byte arrays) since the RSC flight
- * protocol is text-based. The browser entry encodes them back to Uint8Array.
- * This is ~3x more compact than the previous byte-array format.
- */
-function createRscEmbedTransform(embedStream) {
-  const reader = embedStream.getReader();
-  const _decoder = new TextDecoder();
-  let done = false;
-  let pendingChunks = [];
-  let reading = false;
-
-  // Start reading RSC chunks in the background, accumulating them as text strings.
-  // The RSC flight protocol is text-based, so decoding to strings and embedding
-  // as JSON strings is ~3x more compact than the byte-array format.
-  //
-  // Note: Flight HL hint "stylesheet" → "style" rewriting is handled upstream
-  // in the renderToReadableStream wrapper (app-rsc-entry.ts), so the stream
-  // arriving here is already clean.
-  async function pumpReader() {
-    if (reading) return;
-    reading = true;
-    try {
-      while (true) {
-        const result = await reader.read();
-        if (result.done) {
-          done = true;
-          break;
-        }
-        const text = _decoder.decode(result.value, { stream: true });
-        pendingChunks.push(text);
-      }
-    } catch (err) {
-      if (process.env.NODE_ENV !== "production") {
-        console.warn("[vinext] RSC embed stream read error:", err);
-      }
-      done = true;
-    }
-    reading = false;
-  }
-
-  // Fire off the background reader immediately
-  const pumpPromise = pumpReader();
-
-  return {
-    /**
-     * Flush any accumulated RSC chunks as <script> tags.
-     * Called after each HTML chunk is enqueued.
-     */
-    flush() {
-      if (pendingChunks.length === 0) return "";
-      const chunks = pendingChunks;
-      pendingChunks = [];
-      let scripts = "";
-      for (const chunk of chunks) {
-        scripts += "<script>self.__VINEXT_RSC_CHUNKS__=self.__VINEXT_RSC_CHUNKS__||[];self.__VINEXT_RSC_CHUNKS__.push(" + safeJsonStringify(chunk) + ")<\/script>";
-      }
-      return scripts;
-    },
-
-    /**
-     * Wait for the RSC stream to fully complete and return any final
-     * script tags plus the closing signal.
-     */
-    async finalize() {
-      await pumpPromise;
-      let scripts = this.flush();
-      // Signal that all RSC chunks have been sent.
-      // Params are already embedded in <head> — no need to include here.
-      scripts += "<script>self.__VINEXT_RSC_DONE__=true<\/script>";
-      return scripts;
-    },
-  };
-}
-
-/**
- * Render the RSC stream to HTML.
- *
- * @param rscStream - The RSC payload stream from the RSC environment
- * @param navContext - Navigation context for client component SSR hooks.
- *   "use client" components like those using usePathname() need the current
- *   request URL during SSR, and they run in this SSR environment (separate
- *   from the RSC environment where the context was originally set).
- * @param fontData - Font links and styles collected from the RSC environment.
- *   Fonts are loaded during RSC rendering (when layout calls Geist() etc.),
- *   and the data needs to be passed to SSR since they're separate module instances.
- */
-export async function handleSsr(rscStream, navContext, fontData) {
-  // Eagerly preload all client reference modules before SSR rendering.
-  // On the first request after server start, client component modules are
-  // loaded lazily via async import(). Without this preload, React's
-  // renderToReadableStream rejects because the shell can't resolve client
-  // components synchronously (there is no Suspense boundary wrapping the
-  // root). The memoized require cache ensures this is only async on the
-  // very first call; subsequent requests resolve from cache immediately.
-  // See: https://github.com/cloudflare/vinext/issues/256
-  // _clientRefs.default is the default export from the virtual:vite-rsc/client-references
-  // namespace import — a map of client component IDs to their async import functions.
-  if (!_clientRefsPreloaded && _clientRefs.default && globalThis.__vite_rsc_client_require__) {
-    await Promise.all(
-      Object.keys(_clientRefs.default).map((id) =>
-        globalThis.__vite_rsc_client_require__(id).catch((err) => {
-          if (process.env.NODE_ENV !== "production") {
-            console.warn("[vinext] failed to preload client ref:", id, err);
-          }
-        })
-      )
-    );
-    _clientRefsPreloaded = true;
-  }
-
-  // Wrap in a navigation ALS scope for per-request isolation in the SSR
-  // environment. The SSR environment has separate module instances from RSC,
-  // so it needs its own ALS scope.
-  return _runWithNavCtx(async () => {
-  // Set navigation context so hooks like usePathname() work during SSR
-  // of "use client" components
-  if (navContext) {
-    setNavigationContext(navContext);
-  }
-
-  // Clear any stale callbacks from previous requests
-  const { clearServerInsertedHTML, flushServerInsertedHTML, useServerInsertedHTML: _addInsertedHTML } = await import("next/navigation");
-  clearServerInsertedHTML();
-
-  try {
-    // Tee the RSC stream - one for SSR rendering, one for embedding in HTML.
-    // This ensures the browser uses the SAME RSC payload for hydration that
-    // was used to generate the HTML, avoiding hydration mismatches (React #418).
-    const [ssrStream, embedStream] = rscStream.tee();
-
-    // Create the progressive RSC embed helper — it reads the embed stream
-    // in the background and provides script tags to inject into the HTML stream.
-    const rscEmbed = createRscEmbedTransform(embedStream);
-
-    // Deserialize RSC stream back to React VDOM.
-    // IMPORTANT: Do NOT await this — createFromReadableStream returns a thenable
-    // that React's renderToReadableStream can consume progressively. By passing
-    // the unresolved thenable, React will render Suspense fallbacks (loading.tsx)
-    // immediately in the HTML shell, then stream in resolved content as RSC
-    // chunks arrive. Awaiting here would block until all async server components
-    // complete, collapsing the streaming behavior.
-    // Lazily create the Flight root inside render so React's hook dispatcher is set
-    // (avoids React 19 dev-mode resolveErrorDev() crash). VinextFlightRoot returns
-    // a thenable (not a ReactNode), which React 19 consumes via its internal
-    // thenable-as-child suspend/resume behavior. This matches Next.js's approach.
-    let flightRoot;
-    function VinextFlightRoot() {
-      if (!flightRoot) {
-        flightRoot = createFromReadableStream(ssrStream);
-      }
-      return flightRoot;
-    }
-    const root = _ssrCE(VinextFlightRoot);
-
-    // Wrap with ServerInsertedHTMLContext.Provider so libraries that use
-    // useContext(ServerInsertedHTMLContext) (Apollo Client, styled-components,
-    // etc.) get a working callback registration function during SSR.
-    // The provider value is useServerInsertedHTML — same function that direct
-    // callers use — so both paths push to the same ALS-backed callback array.
-    const ssrRoot = ServerInsertedHTMLContext
-      ? _ssrCE(ServerInsertedHTMLContext.Provider, { value: _addInsertedHTML }, root)
-      : root;
-
-    // Get the bootstrap script content for the browser entry
-    const bootstrapScriptContent =
-      await import.meta.viteRsc.loadBootstrapScriptContent("index");
-
-    // djb2 hash for digest generation in the SSR environment.
-    // Matches the RSC environment's __errorDigest function.
-    function ssrErrorDigest(str) {
-      let hash = 5381;
-      for (let i = str.length - 1; i >= 0; i--) {
-        hash = (hash * 33) ^ str.charCodeAt(i);
-      }
-      return (hash >>> 0).toString();
-    }
-
-    // Render HTML (streaming SSR)
-    // useServerInsertedHTML callbacks are registered during this render.
-    // The onError callback preserves the digest for Next.js navigation errors
-    // (redirect, notFound, forbidden, unauthorized) thrown inside Suspense
-    // boundaries during RSC streaming. Without this, React's default onError
-    // returns undefined and the digest is lost in the $RX() call, preventing
-    // client-side error boundaries from identifying the error type.
-    // In production, non-navigation errors also get a digest hash so they
-    // can be correlated with server logs without leaking details to clients.
-    const htmlStream = await renderToReadableStream(ssrRoot, {
-      bootstrapScriptContent,
-      onError(error) {
-        if (error && typeof error === "object" && "digest" in error) {
-          return String(error.digest);
-        }
-        // In production, generate a digest hash for non-navigation errors
-        if (process.env.NODE_ENV === "production" && error) {
-          const msg = error instanceof Error ? error.message : String(error);
-          const stack = error instanceof Error ? (error.stack || "") : "";
-          return ssrErrorDigest(msg + stack);
-        }
-        return undefined;
-      },
-    });
-
-    // Flush useServerInsertedHTML callbacks (CSS-in-JS style injection)
-    const insertedElements = flushServerInsertedHTML();
-
-    // Render the inserted elements to HTML strings
-    const { Fragment } = await import("react");
-    let insertedHTML = "";
-    for (const el of insertedElements) {
-      try {
-        insertedHTML += renderToStaticMarkup(_ssrCE(Fragment, null, el));
-      } catch {
-        // Skip elements that can't be rendered
-      }
-    }
-
-    // Escape HTML attribute values (defense-in-depth for font URLs/types).
-    function _escAttr(s) { return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;"); }
-
-    // Build font HTML from data passed from RSC environment
-    // (Fonts are loaded during RSC rendering, and RSC/SSR are separate module instances)
-    let fontHTML = "";
-    if (fontData) {
-      if (fontData.links && fontData.links.length > 0) {
-        for (const url of fontData.links) {
-          fontHTML += '<link rel="stylesheet" href="' + _escAttr(url) + '" />\\n';
-        }
-      }
-      // Emit <link rel="preload"> for local font files
-      if (fontData.preloads && fontData.preloads.length > 0) {
-        for (const preload of fontData.preloads) {
-          fontHTML += '<link rel="preload" href="' + _escAttr(preload.href) + '" as="font" type="' + _escAttr(preload.type) + '" crossorigin />\\n';
-        }
-      }
-      if (fontData.styles && fontData.styles.length > 0) {
-        fontHTML += '<style data-vinext-fonts>' + fontData.styles.join("\\n") + '</style>\\n';
-      }
-    }
-
-    // Extract client entry module URL from bootstrapScriptContent to emit
-    // a <link rel="modulepreload"> hint. The RSC plugin formats bootstrap
-    // content as: import("URL") — we extract the URL so the browser can
-    // speculatively fetch and parse the JS module while still processing
-    // the HTML body, instead of waiting until it reaches the inline script.
-    let modulePreloadHTML = "";
-    if (bootstrapScriptContent) {
-      const m = bootstrapScriptContent.match(/import\\("([^"]+)"\\)/);
-      if (m && m[1]) {
-        modulePreloadHTML = '<link rel="modulepreload" href="' + _escAttr(m[1]) + '" />\\n';
-      }
-    }
-
-    // Head-injected HTML: server-inserted HTML, font HTML, route params,
-    // and modulepreload hints.
-    // RSC payload is now embedded progressively via script tags in the body stream.
-    // Params are embedded eagerly in <head> so they're available before client
-    // hydration starts, avoiding the need for polling on the client.
-    const paramsScript = '<script>self.__VINEXT_RSC_PARAMS__=' + safeJsonStringify(navContext?.params || {}) + '<\/script>';
-    // Embed the initial navigation context (pathname + searchParams) so the
-    // browser useSyncExternalStore getServerSnapshot can return the correct
-    // value during hydration. Without this, getServerSnapshot returns "/" and
-    // React detects a mismatch against the SSR-rendered HTML.
-     // Serialise searchParams as an array of [key, value] pairs to preserve
-     // duplicate keys (e.g. ?tag=a&tag=b). Object.fromEntries() would keep
-     // only the last value, causing a hydration mismatch for multi-value params.
-     const __navPayload = { pathname: navContext?.pathname ?? '/', searchParams: navContext?.searchParams ? [...navContext.searchParams.entries()] : [] };
-    const navScript = '<script>self.__VINEXT_RSC_NAV__=' + safeJsonStringify(__navPayload) + '<\/script>';
-    const injectHTML = paramsScript + navScript + modulePreloadHTML + insertedHTML + fontHTML;
-
-    // Inject the collected HTML before </head> and progressively embed RSC
-    // chunks as script tags throughout the HTML body stream.
-    const decoder = new TextDecoder();
-    const encoder = new TextEncoder();
-    let injected = false;
-
-    // Fix invalid preload "as" values in server-rendered HTML.
-    // React Fizz emits <link rel="preload" as="stylesheet"> for CSS,
-    // but the HTML spec requires as="style" for <link rel="preload">.
-    // Note: Flight HL hints are fixed upstream in the renderToReadableStream
-    // wrapper (app-rsc-entry.ts); this only handles the Fizz HTML stream.
-    // See: https://html.spec.whatwg.org/multipage/links.html#link-type-preload
-    function fixPreloadAs(html) {
-      // Match <link ...rel="preload"... as="stylesheet"...> in any attribute order
-      return html.replace(/<link(?=[^>]*\\srel="preload")[^>]*>/g, function(tag) {
-        return tag.replace(' as="stylesheet"', ' as="style"');
-      });
-    }
-
-    // Tick-buffered RSC script injection.
-    //
-    // React's renderToReadableStream (Fizz) flushes chunks synchronously
-    // within one microtask — all chunks from a single flushCompletedQueues
-    // call arrive in the same macrotask. We buffer HTML chunks as they
-    // arrive, then use setTimeout(0) to defer emitting them plus any
-    // accumulated RSC scripts to the next macrotask. This guarantees we
-    // never inject <script> tags between partial HTML chunks (which would
-    // corrupt split elements like "<linearGradi" + "ent>"), while still
-    // delivering RSC data progressively as Suspense boundaries resolve.
-    //
-    // Reference: rsc-html-stream by Devon Govett (credited by Next.js)
-    // https://github.com/devongovett/rsc-html-stream
-    let buffered = [];
-    let timeoutId = null;
-
-    const transform = new TransformStream({
-      transform(chunk, controller) {
-        const text = decoder.decode(chunk, { stream: true });
-        const fixed = fixPreloadAs(text);
-        buffered.push(fixed);
-
-        if (timeoutId !== null) return;
-
-        timeoutId = setTimeout(() => {
-          // Flush all buffered HTML chunks from this React flush cycle
-          for (const buf of buffered) {
-            if (!injected) {
-              const headEnd = buf.indexOf("</head>");
-              if (headEnd !== -1) {
-                const before = buf.slice(0, headEnd);
-                const after = buf.slice(headEnd);
-                controller.enqueue(encoder.encode(before + injectHTML + after));
-                injected = true;
-                continue;
-              }
-            }
-            controller.enqueue(encoder.encode(buf));
-          }
-          buffered = [];
-
-          // Now safe to inject any accumulated RSC scripts — we're between
-          // React flush cycles, so no partial HTML chunks can follow until
-          // the next macrotask.
-          const rscScripts = rscEmbed.flush();
-          if (rscScripts) {
-            controller.enqueue(encoder.encode(rscScripts));
-          }
-
-          timeoutId = null;
-        }, 0);
-      },
-      async flush(controller) {
-        // Cancel any pending setTimeout callback — flush() drains
-        // everything itself, so the callback would be a no-op but
-        // cancelling makes the code obviously correct.
-        if (timeoutId !== null) {
-          clearTimeout(timeoutId);
-          timeoutId = null;
-        }
-
-        // Flush any remaining buffered HTML chunks
-        for (const buf of buffered) {
-          if (!injected) {
-            const headEnd = buf.indexOf("</head>");
-            if (headEnd !== -1) {
-              const before = buf.slice(0, headEnd);
-              const after = buf.slice(headEnd);
-              controller.enqueue(encoder.encode(before + injectHTML + after));
-              injected = true;
-              continue;
-            }
-          }
-          controller.enqueue(encoder.encode(buf));
-        }
-        buffered = [];
-
-        if (!injected && injectHTML) {
-          controller.enqueue(encoder.encode(injectHTML));
-        }
-        // Finalize: wait for the RSC stream to complete and emit remaining
-        // chunks plus the __VINEXT_RSC_DONE__ signal.
-        const finalScripts = await rscEmbed.finalize();
-        if (finalScripts) {
-          controller.enqueue(encoder.encode(finalScripts));
-        }
-      },
-    });
-
-    return htmlStream.pipeThrough(transform);
-  } finally {
-    // Clean up so we don't leak context between requests
-    setNavigationContext(null);
-    clearServerInsertedHTML();
-  }
-  }); // end _runWithNavCtx
-}
-
-export default {
-  async fetch(request) {
-    const url = new URL(request.url);
-    if (url.pathname.startsWith("//")) {
-      return new Response("404 Not Found", { status: 404 });
-    }
-    const rscModule = await import.meta.viteRsc.loadModule("rsc", "index");
-    const result = await rscModule.default(request);
-    if (result instanceof Response) {
-      return result;
-    }
-    if (result === null || result === undefined) {
-      return new Response("Not Found", { status: 404 });
-    }
-    return new Response(String(result), { status: 200 });
-  },
-};
+export * from ${JSON.stringify(entryPath)};
+export { default } from ${JSON.stringify(entryPath)};
 ${hasPagesDir ? `
-// Re-export pageRoutes and renderPage from the Pages Router server entry so
-// that the Cloudflare Workers RSC bundle can access Pages Router route metadata
-// (including getStaticPaths) via import("./ssr/index.js").pageRoutes, and can
-// delegate unmatched App Router requests to renderPage for hybrid builds.
 export { pageRoutes, renderPage } from "virtual:vinext-server-entry";
 ` : ""}`;
 }

package/dist/entries/app-ssr-entry.js.map

@@ -1 +1 @@
-{"version":3,"file":"app-ssr-entry.js","names":[],"sources":["../../src/entries/app-ssr-entry.ts"],"sourcesContent":["/**\n * Generate the virtual SSR entry module.\n *\n * This runs in the `ssr` Vite environment. It receives an RSC stream,\n * deserializes it to a React tree, and renders to HTML.\n *\n * When `hasPagesDir` is true (hybrid App + Pages Router project), the SSR\n * entry also re-exports `pageRoutes` from `virtual:vinext-server-entry` so\n * that the Cloudflare Workers RSC bundle can access Pages Router route\n * metadata (including `getStaticPaths`) via `import(\"./ssr/index.js\")`.\n */\nexport function generateSsrEntry(hasPagesDir = false): string {\n  return `\nimport { createFromReadableStream } from \"@vitejs/plugin-rsc/ssr\";\nimport { renderToReadableStream, renderToStaticMarkup } from \"react-dom/server.edge\";\nimport { setNavigationContext, ServerInsertedHTMLContext } from \"next/navigation\";\nimport { runWithNavigationContext as _runWithNavCtx } from \"vinext/navigation-state\";\nimport { safeJsonStringify } from \"vinext/html\";\nimport { createElement as _ssrCE } from \"react\";\nimport * as _clientRefs from \"virtual:vite-rsc/client-references\";\n\nlet _clientRefsPreloaded = false;\n\n/**\n * Collect all chunks from a ReadableStream into an array of text strings.\n * Used to capture the RSC payload for embedding in HTML.\n * The RSC flight protocol is text-based (line-delimited key:value pairs),\n * so we decode to text strings instead of byte arrays — this is dramatically\n * more compact when JSON-serialized into inline <script> tags.\n */\nasync function collectStreamChunks(stream) {\n  const reader = stream.getReader();\n  const decoder = new TextDecoder();\n  const chunks = [];\n  while (true) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    // Decode Uint8Array to text string for compact JSON serialization\n    chunks.push(decoder.decode(value, { stream: true }));\n  }\n  return chunks;\n}\n\n// React 19 dev-mode workaround (see VinextFlightRoot in handleSsr):\n//\n// In dev, Flight error decoding in react-server-dom-webpack/client.edge\n// can hit resolveErrorDev() which (via React's dev error stack capture)\n// expects a non-null hooks dispatcher.\n//\n// Vinext previously called createFromReadableStream() outside of any React render.\n// When an RSC stream contains an error, dev-mode decoding could crash with:\n//   - \"Invalid hook call\"\n//   - \"Cannot read properties of null (reading 'useContext')\"\n//\n// Fix: call createFromReadableStream() lazily inside a React component render.\n// This mirrors Next.js behavior and ensures the dispatcher is set.\n\n/**\n * Create a TransformStream that appends RSC chunks as inline <script> tags\n * to the HTML stream. This allows progressive hydration — the browser receives\n * RSC data incrementally as Suspense boundaries resolve, rather than waiting\n * for the entire RSC payload before hydration can begin.\n *\n * Each chunk is written as:\n *   <script>self.__VINEXT_RSC_CHUNKS__=self.__VINEXT_RSC_CHUNKS__||[];self.__VINEXT_RSC_CHUNKS__.push(\"...\")</script>\n *\n * Chunks are embedded as text strings (not byte arrays) since the RSC flight\n * protocol is text-based. The browser entry encodes them back to Uint8Array.\n * This is ~3x more compact than the previous byte-array format.\n */\nfunction createRscEmbedTransform(embedStream) {\n  const reader = embedStream.getReader();\n  const _decoder = new TextDecoder();\n  let done = false;\n  let pendingChunks = [];\n  let reading = false;\n\n  // Start reading RSC chunks in the background, accumulating them as text strings.\n  // The RSC flight protocol is text-based, so decoding to strings and embedding\n  // as JSON strings is ~3x more compact than the byte-array format.\n  //\n  // Note: Flight HL hint \"stylesheet\" → \"style\" rewriting is handled upstream\n  // in the renderToReadableStream wrapper (app-rsc-entry.ts), so the stream\n  // arriving here is already clean.\n  async function pumpReader() {\n    if (reading) return;\n    reading = true;\n    try {\n      while (true) {\n        const result = await reader.read();\n        if (result.done) {\n          done = true;\n          break;\n        }\n        const text = _decoder.decode(result.value, { stream: true });\n        pendingChunks.push(text);\n      }\n    } catch (err) {\n      if (process.env.NODE_ENV !== \"production\") {\n        console.warn(\"[vinext] RSC embed stream read error:\", err);\n      }\n      done = true;\n    }\n    reading = false;\n  }\n\n  // Fire off the background reader immediately\n  const pumpPromise = pumpReader();\n\n  return {\n    /**\n     * Flush any accumulated RSC chunks as <script> tags.\n     * Called after each HTML chunk is enqueued.\n     */\n    flush() {\n      if (pendingChunks.length === 0) return \"\";\n      const chunks = pendingChunks;\n      pendingChunks = [];\n      let scripts = \"\";\n      for (const chunk of chunks) {\n        scripts += \"<script>self.__VINEXT_RSC_CHUNKS__=self.__VINEXT_RSC_CHUNKS__||[];self.__VINEXT_RSC_CHUNKS__.push(\" + safeJsonStringify(chunk) + \")</script>\";\n      }\n      return scripts;\n    },\n\n    /**\n     * Wait for the RSC stream to fully complete and return any final\n     * script tags plus the closing signal.\n     */\n    async finalize() {\n      await pumpPromise;\n      let scripts = this.flush();\n      // Signal that all RSC chunks have been sent.\n      // Params are already embedded in <head> — no need to include here.\n      scripts += \"<script>self.__VINEXT_RSC_DONE__=true</script>\";\n      return scripts;\n    },\n  };\n}\n\n/**\n * Render the RSC stream to HTML.\n *\n * @param rscStream - The RSC payload stream from the RSC environment\n * @param navContext - Navigation context for client component SSR hooks.\n *   \"use client\" components like those using usePathname() need the current\n *   request URL during SSR, and they run in this SSR environment (separate\n *   from the RSC environment where the context was originally set).\n * @param fontData - Font links and styles collected from the RSC environment.\n *   Fonts are loaded during RSC rendering (when layout calls Geist() etc.),\n *   and the data needs to be passed to SSR since they're separate module instances.\n */\nexport async function handleSsr(rscStream, navContext, fontData) {\n  // Eagerly preload all client reference modules before SSR rendering.\n  // On the first request after server start, client component modules are\n  // loaded lazily via async import(). Without this preload, React's\n  // renderToReadableStream rejects because the shell can't resolve client\n  // components synchronously (there is no Suspense boundary wrapping the\n  // root). The memoized require cache ensures this is only async on the\n  // very first call; subsequent requests resolve from cache immediately.\n  // See: https://github.com/cloudflare/vinext/issues/256\n  // _clientRefs.default is the default export from the virtual:vite-rsc/client-references\n  // namespace import — a map of client component IDs to their async import functions.\n  if (!_clientRefsPreloaded && _clientRefs.default && globalThis.__vite_rsc_client_require__) {\n    await Promise.all(\n      Object.keys(_clientRefs.default).map((id) =>\n        globalThis.__vite_rsc_client_require__(id).catch((err) => {\n          if (process.env.NODE_ENV !== \"production\") {\n            console.warn(\"[vinext] failed to preload client ref:\", id, err);\n          }\n        })\n      )\n    );\n    _clientRefsPreloaded = true;\n  }\n\n  // Wrap in a navigation ALS scope for per-request isolation in the SSR\n  // environment. The SSR environment has separate module instances from RSC,\n  // so it needs its own ALS scope.\n  return _runWithNavCtx(async () => {\n  // Set navigation context so hooks like usePathname() work during SSR\n  // of \"use client\" components\n  if (navContext) {\n    setNavigationContext(navContext);\n  }\n\n  // Clear any stale callbacks from previous requests\n  const { clearServerInsertedHTML, flushServerInsertedHTML, useServerInsertedHTML: _addInsertedHTML } = await import(\"next/navigation\");\n  clearServerInsertedHTML();\n\n  try {\n    // Tee the RSC stream - one for SSR rendering, one for embedding in HTML.\n    // This ensures the browser uses the SAME RSC payload for hydration that\n    // was used to generate the HTML, avoiding hydration mismatches (React #418).\n    const [ssrStream, embedStream] = rscStream.tee();\n\n    // Create the progressive RSC embed helper — it reads the embed stream\n    // in the background and provides script tags to inject into the HTML stream.\n    const rscEmbed = createRscEmbedTransform(embedStream);\n\n    // Deserialize RSC stream back to React VDOM.\n    // IMPORTANT: Do NOT await this — createFromReadableStream returns a thenable\n    // that React's renderToReadableStream can consume progressively. By passing\n    // the unresolved thenable, React will render Suspense fallbacks (loading.tsx)\n    // immediately in the HTML shell, then stream in resolved content as RSC\n    // chunks arrive. Awaiting here would block until all async server components\n    // complete, collapsing the streaming behavior.\n    // Lazily create the Flight root inside render so React's hook dispatcher is set\n    // (avoids React 19 dev-mode resolveErrorDev() crash). VinextFlightRoot returns\n    // a thenable (not a ReactNode), which React 19 consumes via its internal\n    // thenable-as-child suspend/resume behavior. This matches Next.js's approach.\n    let flightRoot;\n    function VinextFlightRoot() {\n      if (!flightRoot) {\n        flightRoot = createFromReadableStream(ssrStream);\n      }\n      return flightRoot;\n    }\n    const root = _ssrCE(VinextFlightRoot);\n\n    // Wrap with ServerInsertedHTMLContext.Provider so libraries that use\n    // useContext(ServerInsertedHTMLContext) (Apollo Client, styled-components,\n    // etc.) get a working callback registration function during SSR.\n    // The provider value is useServerInsertedHTML — same function that direct\n    // callers use — so both paths push to the same ALS-backed callback array.\n    const ssrRoot = ServerInsertedHTMLContext\n      ? _ssrCE(ServerInsertedHTMLContext.Provider, { value: _addInsertedHTML }, root)\n      : root;\n\n    // Get the bootstrap script content for the browser entry\n    const bootstrapScriptContent =\n      await import.meta.viteRsc.loadBootstrapScriptContent(\"index\");\n\n    // djb2 hash for digest generation in the SSR environment.\n    // Matches the RSC environment's __errorDigest function.\n    function ssrErrorDigest(str) {\n      let hash = 5381;\n      for (let i = str.length - 1; i >= 0; i--) {\n        hash = (hash * 33) ^ str.charCodeAt(i);\n      }\n      return (hash >>> 0).toString();\n    }\n\n    // Render HTML (streaming SSR)\n    // useServerInsertedHTML callbacks are registered during this render.\n    // The onError callback preserves the digest for Next.js navigation errors\n    // (redirect, notFound, forbidden, unauthorized) thrown inside Suspense\n    // boundaries during RSC streaming. Without this, React's default onError\n    // returns undefined and the digest is lost in the $RX() call, preventing\n    // client-side error boundaries from identifying the error type.\n    // In production, non-navigation errors also get a digest hash so they\n    // can be correlated with server logs without leaking details to clients.\n    const htmlStream = await renderToReadableStream(ssrRoot, {\n      bootstrapScriptContent,\n      onError(error) {\n        if (error && typeof error === \"object\" && \"digest\" in error) {\n          return String(error.digest);\n        }\n        // In production, generate a digest hash for non-navigation errors\n        if (process.env.NODE_ENV === \"production\" && error) {\n          const msg = error instanceof Error ? error.message : String(error);\n          const stack = error instanceof Error ? (error.stack || \"\") : \"\";\n          return ssrErrorDigest(msg + stack);\n        }\n        return undefined;\n      },\n    });\n\n    // Flush useServerInsertedHTML callbacks (CSS-in-JS style injection)\n    const insertedElements = flushServerInsertedHTML();\n\n    // Render the inserted elements to HTML strings\n    const { Fragment } = await import(\"react\");\n    let insertedHTML = \"\";\n    for (const el of insertedElements) {\n      try {\n        insertedHTML += renderToStaticMarkup(_ssrCE(Fragment, null, el));\n      } catch {\n        // Skip elements that can't be rendered\n      }\n    }\n\n    // Escape HTML attribute values (defense-in-depth for font URLs/types).\n    function _escAttr(s) { return s.replace(/&/g, \"&amp;\").replace(/\"/g, \"&quot;\"); }\n\n    // Build font HTML from data passed from RSC environment\n    // (Fonts are loaded during RSC rendering, and RSC/SSR are separate module instances)\n    let fontHTML = \"\";\n    if (fontData) {\n      if (fontData.links && fontData.links.length > 0) {\n        for (const url of fontData.links) {\n          fontHTML += '<link rel=\"stylesheet\" href=\"' + _escAttr(url) + '\" />\\\\n';\n        }\n      }\n      // Emit <link rel=\"preload\"> for local font files\n      if (fontData.preloads && fontData.preloads.length > 0) {\n        for (const preload of fontData.preloads) {\n          fontHTML += '<link rel=\"preload\" href=\"' + _escAttr(preload.href) + '\" as=\"font\" type=\"' + _escAttr(preload.type) + '\" crossorigin />\\\\n';\n        }\n      }\n      if (fontData.styles && fontData.styles.length > 0) {\n        fontHTML += '<style data-vinext-fonts>' + fontData.styles.join(\"\\\\n\") + '</style>\\\\n';\n      }\n    }\n\n    // Extract client entry module URL from bootstrapScriptContent to emit\n    // a <link rel=\"modulepreload\"> hint. The RSC plugin formats bootstrap\n    // content as: import(\"URL\") — we extract the URL so the browser can\n    // speculatively fetch and parse the JS module while still processing\n    // the HTML body, instead of waiting until it reaches the inline script.\n    let modulePreloadHTML = \"\";\n    if (bootstrapScriptContent) {\n      const m = bootstrapScriptContent.match(/import\\\\(\"([^\"]+)\"\\\\)/);\n      if (m && m[1]) {\n        modulePreloadHTML = '<link rel=\"modulepreload\" href=\"' + _escAttr(m[1]) + '\" />\\\\n';\n      }\n    }\n\n    // Head-injected HTML: server-inserted HTML, font HTML, route params,\n    // and modulepreload hints.\n    // RSC payload is now embedded progressively via script tags in the body stream.\n    // Params are embedded eagerly in <head> so they're available before client\n    // hydration starts, avoiding the need for polling on the client.\n    const paramsScript = '<script>self.__VINEXT_RSC_PARAMS__=' + safeJsonStringify(navContext?.params || {}) + '</script>';\n    // Embed the initial navigation context (pathname + searchParams) so the\n    // browser useSyncExternalStore getServerSnapshot can return the correct\n    // value during hydration. Without this, getServerSnapshot returns \"/\" and\n    // React detects a mismatch against the SSR-rendered HTML.\n     // Serialise searchParams as an array of [key, value] pairs to preserve\n     // duplicate keys (e.g. ?tag=a&tag=b). Object.fromEntries() would keep\n     // only the last value, causing a hydration mismatch for multi-value params.\n     const __navPayload = { pathname: navContext?.pathname ?? '/', searchParams: navContext?.searchParams ? [...navContext.searchParams.entries()] : [] };\n    const navScript = '<script>self.__VINEXT_RSC_NAV__=' + safeJsonStringify(__navPayload) + '</script>';\n    const injectHTML = paramsScript + navScript + modulePreloadHTML + insertedHTML + fontHTML;\n\n    // Inject the collected HTML before </head> and progressively embed RSC\n    // chunks as script tags throughout the HTML body stream.\n    const decoder = new TextDecoder();\n    const encoder = new TextEncoder();\n    let injected = false;\n\n    // Fix invalid preload \"as\" values in server-rendered HTML.\n    // React Fizz emits <link rel=\"preload\" as=\"stylesheet\"> for CSS,\n    // but the HTML spec requires as=\"style\" for <link rel=\"preload\">.\n    // Note: Flight HL hints are fixed upstream in the renderToReadableStream\n    // wrapper (app-rsc-entry.ts); this only handles the Fizz HTML stream.\n    // See: https://html.spec.whatwg.org/multipage/links.html#link-type-preload\n    function fixPreloadAs(html) {\n      // Match <link ...rel=\"preload\"... as=\"stylesheet\"...> in any attribute order\n      return html.replace(/<link(?=[^>]*\\\\srel=\"preload\")[^>]*>/g, function(tag) {\n        return tag.replace(' as=\"stylesheet\"', ' as=\"style\"');\n      });\n    }\n\n    // Tick-buffered RSC script injection.\n    //\n    // React's renderToReadableStream (Fizz) flushes chunks synchronously\n    // within one microtask — all chunks from a single flushCompletedQueues\n    // call arrive in the same macrotask. We buffer HTML chunks as they\n    // arrive, then use setTimeout(0) to defer emitting them plus any\n    // accumulated RSC scripts to the next macrotask. This guarantees we\n    // never inject <script> tags between partial HTML chunks (which would\n    // corrupt split elements like \"<linearGradi\" + \"ent>\"), while still\n    // delivering RSC data progressively as Suspense boundaries resolve.\n    //\n    // Reference: rsc-html-stream by Devon Govett (credited by Next.js)\n    // https://github.com/devongovett/rsc-html-stream\n    let buffered = [];\n    let timeoutId = null;\n\n    const transform = new TransformStream({\n      transform(chunk, controller) {\n        const text = decoder.decode(chunk, { stream: true });\n        const fixed = fixPreloadAs(text);\n        buffered.push(fixed);\n\n        if (timeoutId !== null) return;\n\n        timeoutId = setTimeout(() => {\n          // Flush all buffered HTML chunks from this React flush cycle\n          for (const buf of buffered) {\n            if (!injected) {\n              const headEnd = buf.indexOf(\"</head>\");\n              if (headEnd !== -1) {\n                const before = buf.slice(0, headEnd);\n                const after = buf.slice(headEnd);\n                controller.enqueue(encoder.encode(before + injectHTML + after));\n                injected = true;\n                continue;\n              }\n            }\n            controller.enqueue(encoder.encode(buf));\n          }\n          buffered = [];\n\n          // Now safe to inject any accumulated RSC scripts — we're between\n          // React flush cycles, so no partial HTML chunks can follow until\n          // the next macrotask.\n          const rscScripts = rscEmbed.flush();\n          if (rscScripts) {\n            controller.enqueue(encoder.encode(rscScripts));\n          }\n\n          timeoutId = null;\n        }, 0);\n      },\n      async flush(controller) {\n        // Cancel any pending setTimeout callback — flush() drains\n        // everything itself, so the callback would be a no-op but\n        // cancelling makes the code obviously correct.\n        if (timeoutId !== null) {\n          clearTimeout(timeoutId);\n          timeoutId = null;\n        }\n\n        // Flush any remaining buffered HTML chunks\n        for (const buf of buffered) {\n          if (!injected) {\n            const headEnd = buf.indexOf(\"</head>\");\n            if (headEnd !== -1) {\n              const before = buf.slice(0, headEnd);\n              const after = buf.slice(headEnd);\n              controller.enqueue(encoder.encode(before + injectHTML + after));\n              injected = true;\n              continue;\n            }\n          }\n          controller.enqueue(encoder.encode(buf));\n        }\n        buffered = [];\n\n        if (!injected && injectHTML) {\n          controller.enqueue(encoder.encode(injectHTML));\n        }\n        // Finalize: wait for the RSC stream to complete and emit remaining\n        // chunks plus the __VINEXT_RSC_DONE__ signal.\n        const finalScripts = await rscEmbed.finalize();\n        if (finalScripts) {\n          controller.enqueue(encoder.encode(finalScripts));\n        }\n      },\n    });\n\n    return htmlStream.pipeThrough(transform);\n  } finally {\n    // Clean up so we don't leak context between requests\n    setNavigationContext(null);\n    clearServerInsertedHTML();\n  }\n  }); // end _runWithNavCtx\n}\n\nexport default {\n  async fetch(request) {\n    const url = new URL(request.url);\n    if (url.pathname.startsWith(\"//\")) {\n      return new Response(\"404 Not Found\", { status: 404 });\n    }\n    const rscModule = await import.meta.viteRsc.loadModule(\"rsc\", \"index\");\n    const result = await rscModule.default(request);\n    if (result instanceof Response) {\n      return result;\n    }\n    if (result === null || result === undefined) {\n      return new Response(\"Not Found\", { status: 404 });\n    }\n    return new Response(String(result), { status: 200 });\n  },\n};\n${\n  hasPagesDir\n    ? `\n// Re-export pageRoutes and renderPage from the Pages Router server entry so\n// that the Cloudflare Workers RSC bundle can access Pages Router route metadata\n// (including getStaticPaths) via import(\"./ssr/index.js\").pageRoutes, and can\n// delegate unmatched App Router requests to renderPage for hybrid builds.\nexport { pageRoutes, renderPage } from \"virtual:vinext-server-entry\";\n`\n    : \"\"\n}`;\n}\n"],"mappings":";;;;;;;;;;;;AAWA,SAAgB,iBAAiB,cAAc,OAAe;AAC5D,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0cP,cACI;;;;;;IAOA"}
+{"version":3,"file":"app-ssr-entry.js","names":[],"sources":["../../src/entries/app-ssr-entry.ts"],"sourcesContent":["import { resolveRuntimeEntryModule } from \"./runtime-entry-module.js\";\n\n/**\n * Generate the virtual SSR entry module.\n *\n * This runs in the `ssr` Vite environment. It receives an RSC stream,\n * deserializes it to a React tree, and renders to HTML.\n *\n * When `hasPagesDir` is true (hybrid App + Pages Router project), the SSR\n * entry also re-exports `pageRoutes` from `virtual:vinext-server-entry` so\n * that the Cloudflare Workers RSC bundle can access Pages Router route\n * metadata (including `getStaticPaths`) via `import(\"./ssr/index.js\")`.\n */\nexport function generateSsrEntry(hasPagesDir = false): string {\n  const entryPath = resolveRuntimeEntryModule(\"app-ssr-entry\");\n\n  return `\nexport * from ${JSON.stringify(entryPath)};\nexport { default } from ${JSON.stringify(entryPath)};\n${\n  hasPagesDir\n    ? `\nexport { pageRoutes, renderPage } from \"virtual:vinext-server-entry\";\n`\n    : \"\"\n}`;\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,iBAAiB,cAAc,OAAe;CAC5D,MAAM,YAAY,0BAA0B,gBAAgB;AAE5D,QAAO;gBACO,KAAK,UAAU,UAAU,CAAC;0BAChB,KAAK,UAAU,UAAU,CAAC;EAElD,cACI;;IAGA"}

package/dist/entries/pages-server-entry.js

@@ -1038,7 +1038,14 @@ async function _renderPage(request, url, manifest) {
     if (_fontLinkHeader) {
       responseHeaders.set("Link", _fontLinkHeader);
     }
-    return new Response(compositeStream, { status: finalStatus, headers: responseHeaders });
+    const streamedPageResponse = new Response(compositeStream, {
+      status: finalStatus,
+      headers: responseHeaders,
+    });
+    // Mark the normal streamed HTML render so the Node prod server can strip
+    // stale Content-Length only for this path, not for custom gSSP responses.
+    streamedPageResponse.__vinextStreamedHtmlResponse = true;
+    return streamedPageResponse;
     } catch (e) {
     console.error("[vinext] SSR error:", e);
     _reportRequestError(