vinext 0.0.30 → 0.0.31

package/dist/entries/app-ssr-entry.d.ts

@@ -1,8 +1,16 @@
+//#region src/entries/app-ssr-entry.d.ts
 /**
  * Generate the virtual SSR entry module.
  *
  * This runs in the `ssr` Vite environment. It receives an RSC stream,
  * deserializes it to a React tree, and renders to HTML.
+ *
+ * When `hasPagesDir` is true (hybrid App + Pages Router project), the SSR
+ * entry also re-exports `pageRoutes` from `virtual:vinext-server-entry` so
+ * that the Cloudflare Workers RSC bundle can access Pages Router route
+ * metadata (including `getStaticPaths`) via `import("./ssr/index.js")`.
  */
-export declare function generateSsrEntry(): string;
+declare function generateSsrEntry(hasPagesDir?: boolean): string;
+//#endregion
+export { generateSsrEntry };
 //# sourceMappingURL=app-ssr-entry.d.ts.map

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

@@ -1,17 +1,26 @@
+//#region src/entries/app-ssr-entry.ts
 /**
- * Generate the virtual SSR entry module.
- *
- * This runs in the `ssr` Vite environment. It receives an RSC stream,
- * deserializes it to a React tree, and renders to HTML.
- */
-export function generateSsrEntry() {
-    return `
+* Generate the virtual SSR entry module.
+*
+* This runs in the `ssr` Vite environment. It receives an RSC stream,
+* deserializes it to a React tree, and renders to HTML.
+*
+* When `hasPagesDir` is true (hybrid App + Pages Router project), the SSR
+* entry also re-exports `pageRoutes` from `virtual:vinext-server-entry` so
+* that the Cloudflare Workers RSC bundle can access Pages Router route
+* metadata (including `getStaticPaths`) via `import("./ssr/index.js")`.
+*/
+function generateSsrEntry(hasPagesDir = false) {
+	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.
@@ -54,7 +63,7 @@ async function collectStreamChunks(stream) {
  * 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>
+ *   <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.
@@ -67,20 +76,13 @@ function createRscEmbedTransform(embedStream) {
   let pendingChunks = [];
   let reading = false;
 
-  // Fix invalid preload "as" values in RSC Flight hint lines before
-  // they reach the client. React Flight emits HL hints with
-  // as="stylesheet" for CSS, but the HTML spec requires as="style"
-  // for <link rel="preload">. The fixPreloadAs() below only fixes the
-  // server-rendered HTML stream; this fixes the raw Flight data that
-  // gets embedded as __VINEXT_RSC_CHUNKS__ and processed client-side.
-  function fixFlightHints(text) {
-    // Flight hint format: <id>:HL["url","stylesheet"] or with options
-    return text.replace(/(\\d+:HL\\[.*?),"stylesheet"(\\]|,)/g, '$1,"style"$2');
-  }
-
   // 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;
@@ -92,7 +94,7 @@ function createRscEmbedTransform(embedStream) {
           break;
         }
         const text = _decoder.decode(result.value, { stream: true });
-        pendingChunks.push(fixFlightHints(text));
+        pendingChunks.push(text);
       }
     } catch (err) {
       if (process.env.NODE_ENV !== "production") {
@@ -117,7 +119,7 @@ function createRscEmbedTransform(embedStream) {
       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>";
+        scripts += "<script>self.__VINEXT_RSC_CHUNKS__=self.__VINEXT_RSC_CHUNKS__||[];self.__VINEXT_RSC_CHUNKS__.push(" + safeJsonStringify(chunk) + ")<\/script>";
       }
       return scripts;
     },
@@ -131,7 +133,7 @@ function createRscEmbedTransform(embedStream) {
       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>";
+      scripts += "<script>self.__VINEXT_RSC_DONE__=true<\/script>";
       return scripts;
     },
   };
@@ -150,6 +152,29 @@ function createRscEmbedTransform(embedStream) {
  *   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.
@@ -297,7 +322,7 @@ export async function handleSsr(rscStream, navContext, fontData) {
     // 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>';
+    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
@@ -306,7 +331,7 @@ export async function handleSsr(rscStream, navContext, fontData) {
      // 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 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
@@ -318,9 +343,8 @@ export async function handleSsr(rscStream, navContext, fontData) {
     // 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: fixFlightHints() in createRscEmbedTransform handles the
-    // complementary case — fixing the raw Flight stream data before
-    // it's embedded as __VINEXT_RSC_CHUNKS__ for client-side processing.
+    // 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
@@ -444,6 +468,15 @@ export default {
     return new Response(String(result), { status: 200 });
   },
 };
-`;
+${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";
+` : ""}`;
 }
+//#endregion
+export { generateSsrEntry };
+
 //# sourceMappingURL=app-ssr-entry.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"app-ssr-entry.js","sourceRoot":"","sources":["../../src/entries/app-ssr-entry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAubR,CAAC;AACF,CAAC","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 */\nexport function generateSsrEntry(): 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\";\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  // Fix invalid preload \"as\" values in RSC Flight hint lines before\n  // they reach the client. React Flight emits HL hints with\n  // as=\"stylesheet\" for CSS, but the HTML spec requires as=\"style\"\n  // for <link rel=\"preload\">. The fixPreloadAs() below only fixes the\n  // server-rendered HTML stream; this fixes the raw Flight data that\n  // gets embedded as __VINEXT_RSC_CHUNKS__ and processed client-side.\n  function fixFlightHints(text) {\n    // Flight hint format: <id>:HL[\"url\",\"stylesheet\"] or with options\n    return text.replace(/(\\\\d+:HL\\\\[.*?),\"stylesheet\"(\\\\]|,)/g, '$1,\"style\"$2');\n  }\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  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(fixFlightHints(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  // 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: fixFlightHints() in createRscEmbedTransform handles the\n    // complementary case — fixing the raw Flight stream data before\n    // it's embedded as __VINEXT_RSC_CHUNKS__ for client-side processing.\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}\n"]}
+{"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"}

package/dist/entries/pages-client-entry.d.ts

@@ -1,4 +1,8 @@
 import { createValidFileMatcher } from "../routing/file-matcher.js";
-import { type ResolvedNextConfig } from "../config/next-config.js";
-export declare function generateClientEntry(pagesDir: string, nextConfig: ResolvedNextConfig, fileMatcher: ReturnType<typeof createValidFileMatcher>): Promise<string>;
+import { ResolvedNextConfig } from "../config/next-config.js";
+
+//#region src/entries/pages-client-entry.d.ts
+declare function generateClientEntry(pagesDir: string, nextConfig: ResolvedNextConfig, fileMatcher: ReturnType<typeof createValidFileMatcher>): Promise<string>;
+//#endregion
+export { generateClientEntry };
 //# sourceMappingURL=pages-client-entry.d.ts.map

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

@@ -1,33 +1,29 @@
-/**
- * Pages Router client hydration entry generator.
- *
- * Generates the virtual client entry module (`virtual:vinext-client-entry`).
- * This is the entry point for `vite build` (client bundle). It maps route
- * patterns to dynamic imports of page modules so Vite code-splits each page
- * into its own chunk. At runtime it reads __NEXT_DATA__ to determine which
- * page to hydrate.
- *
- * Extracted from index.ts.
- */
-import { pagesRouter, patternToNextFormat as pagesPatternToNextFormat, } from "../routing/pages-router.js";
+import { patternToNextFormat } from "../routing/route-validation.js";
+import { pagesRouter } from "../routing/pages-router.js";
 import { findFileWithExts } from "./pages-entry-helpers.js";
-export async function generateClientEntry(pagesDir, nextConfig, fileMatcher) {
-    const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
-    const appFilePath = findFileWithExts(pagesDir, "_app", fileMatcher);
-    const hasApp = appFilePath !== null;
-    // Build a map of route pattern -> dynamic import.
-    // Keys must use Next.js bracket format (e.g. "/user/[id]") to match
-    // __NEXT_DATA__.page which is set via patternToNextFormat() during SSR.
-    const loaderEntries = pageRoutes.map((r) => {
-        const absPath = r.filePath.replace(/\\/g, "/");
-        const nextFormatPattern = pagesPatternToNextFormat(r.pattern);
-        // JSON.stringify safely escapes quotes, backslashes, and special chars in
-        // both the route pattern and the absolute file path.
-        // lgtm[js/bad-code-sanitization]
-        return `  ${JSON.stringify(nextFormatPattern)}: () => import(${JSON.stringify(absPath)})`;
-    });
-    const appFileBase = appFilePath?.replace(/\\/g, "/");
-    return `
+//#region src/entries/pages-client-entry.ts
+/**
+* Pages Router client hydration entry generator.
+*
+* Generates the virtual client entry module (`virtual:vinext-client-entry`).
+* This is the entry point for `vite build` (client bundle). It maps route
+* patterns to dynamic imports of page modules so Vite code-splits each page
+* into its own chunk. At runtime it reads __NEXT_DATA__ to determine which
+* page to hydrate.
+*
+* Extracted from index.ts.
+*/
+async function generateClientEntry(pagesDir, nextConfig, fileMatcher) {
+	const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);
+	const appFilePath = findFileWithExts(pagesDir, "_app", fileMatcher);
+	const hasApp = appFilePath !== null;
+	const loaderEntries = pageRoutes.map((r) => {
+		const absPath = r.filePath.replace(/\\/g, "/");
+		const nextFormatPattern = patternToNextFormat(r.pattern);
+		return `  ${JSON.stringify(nextFormatPattern)}: () => import(${JSON.stringify(absPath)})`;
+	});
+	const appFileBase = appFilePath?.replace(/\\/g, "/");
+	return `
 import React from "react";
 import { hydrateRoot } from "react-dom/client";
 // Eagerly import the router shim so its module-level popstate listener is
@@ -61,8 +57,7 @@ async function hydrate() {
   }
 
   let element;
-  ${hasApp
-        ? `
+  ${hasApp ? `
   try {
     const appModule = await import(${JSON.stringify(appFileBase)});
     const AppComponent = appModule.default;
@@ -71,8 +66,7 @@ async function hydrate() {
   } catch {
     element = React.createElement(PageComponent, pageProps);
   }
-  `
-        : `
+  ` : `
   element = React.createElement(PageComponent, pageProps);
   `}
 
@@ -93,4 +87,7 @@ async function hydrate() {
 hydrate();
 `;
 }
+//#endregion
+export { generateClientEntry };
+
 //# sourceMappingURL=pages-client-entry.js.map

package/dist/entries/pages-client-entry.js.map

@@ -1 +1 @@
-{"version":3,"file":"pages-client-entry.js","sourceRoot":"","sources":["../../src/entries/pages-client-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EACL,WAAW,EACX,mBAAmB,IAAI,wBAAwB,GAEhD,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAE5D,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,QAAgB,EAChB,UAA8B,EAC9B,WAAsD;IAEtD,MAAM,UAAU,GAAG,MAAM,WAAW,CAAC,QAAQ,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,CAAC,CAAC;IAExF,MAAM,WAAW,GAAG,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IACpE,MAAM,MAAM,GAAG,WAAW,KAAK,IAAI,CAAC;IAEpC,kDAAkD;IAClD,oEAAoE;IACpE,wEAAwE;IACxE,MAAM,aAAa,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAQ,EAAE,EAAE;QAChD,MAAM,OAAO,GAAG,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC/C,MAAM,iBAAiB,GAAG,wBAAwB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QAC9D,0EAA0E;QAC1E,qDAAqD;QACrD,iCAAiC;QACjC,OAAO,KAAK,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,kBAAkB,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC;IAC5F,CAAC,CAAC,CAAC;IAEH,MAAM,WAAW,GAAG,WAAW,EAAE,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAErD,OAAO;;;;;;;;;EASP,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;IA0BvB,MAAM;QACJ,CAAC,CAAC;;qCAE6B,IAAI,CAAC,SAAS,CAAC,WAAY,CAAC;;;;;;;GAO9D;QACG,CAAC,CAAC;;GAGN;;;;;;;;;;;;;;;;;CAiBD,CAAC;AACF,CAAC","sourcesContent":["/**\n * Pages Router client hydration entry generator.\n *\n * Generates the virtual client entry module (`virtual:vinext-client-entry`).\n * This is the entry point for `vite build` (client bundle). It maps route\n * patterns to dynamic imports of page modules so Vite code-splits each page\n * into its own chunk. At runtime it reads __NEXT_DATA__ to determine which\n * page to hydrate.\n *\n * Extracted from index.ts.\n */\nimport {\n  pagesRouter,\n  patternToNextFormat as pagesPatternToNextFormat,\n  type Route,\n} from \"../routing/pages-router.js\";\nimport { createValidFileMatcher } from \"../routing/file-matcher.js\";\nimport { type ResolvedNextConfig } from \"../config/next-config.js\";\nimport { findFileWithExts } from \"./pages-entry-helpers.js\";\n\nexport async function generateClientEntry(\n  pagesDir: string,\n  nextConfig: ResolvedNextConfig,\n  fileMatcher: ReturnType<typeof createValidFileMatcher>,\n): Promise<string> {\n  const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);\n\n  const appFilePath = findFileWithExts(pagesDir, \"_app\", fileMatcher);\n  const hasApp = appFilePath !== null;\n\n  // Build a map of route pattern -> dynamic import.\n  // Keys must use Next.js bracket format (e.g. \"/user/[id]\") to match\n  // __NEXT_DATA__.page which is set via patternToNextFormat() during SSR.\n  const loaderEntries = pageRoutes.map((r: Route) => {\n    const absPath = r.filePath.replace(/\\\\/g, \"/\");\n    const nextFormatPattern = pagesPatternToNextFormat(r.pattern);\n    // JSON.stringify safely escapes quotes, backslashes, and special chars in\n    // both the route pattern and the absolute file path.\n    // lgtm[js/bad-code-sanitization]\n    return `  ${JSON.stringify(nextFormatPattern)}: () => import(${JSON.stringify(absPath)})`;\n  });\n\n  const appFileBase = appFilePath?.replace(/\\\\/g, \"/\");\n\n  return `\nimport React from \"react\";\nimport { hydrateRoot } from \"react-dom/client\";\n// Eagerly import the router shim so its module-level popstate listener is\n// registered.  Without this, browser back/forward buttons do nothing because\n// navigateClient() is never invoked on history changes.\nimport \"next/router\";\n\nconst pageLoaders = {\n${loaderEntries.join(\",\\n\")}\n};\n\nasync function hydrate() {\n  const nextData = window.__NEXT_DATA__;\n  if (!nextData) {\n    console.error(\"[vinext] No __NEXT_DATA__ found\");\n    return;\n  }\n\n  const { pageProps } = nextData.props;\n  const loader = pageLoaders[nextData.page];\n  if (!loader) {\n    console.error(\"[vinext] No page loader for route:\", nextData.page);\n    return;\n  }\n\n  const pageModule = await loader();\n  const PageComponent = pageModule.default;\n  if (!PageComponent) {\n    console.error(\"[vinext] Page module has no default export\");\n    return;\n  }\n\n  let element;\n  ${\n    hasApp\n      ? `\n  try {\n    const appModule = await import(${JSON.stringify(appFileBase!)});\n    const AppComponent = appModule.default;\n    window.__VINEXT_APP__ = AppComponent;\n    element = React.createElement(AppComponent, { Component: PageComponent, pageProps });\n  } catch {\n    element = React.createElement(PageComponent, pageProps);\n  }\n  `\n      : `\n  element = React.createElement(PageComponent, pageProps);\n  `\n  }\n\n  // Wrap with RouterContext.Provider so next/compat/router works during hydration\n  const { wrapWithRouterContext } = await import(\"next/router\");\n  element = wrapWithRouterContext(element);\n\n  const container = document.getElementById(\"__next\");\n  if (!container) {\n    console.error(\"[vinext] No #__next element found\");\n    return;\n  }\n\n  const root = hydrateRoot(container, element);\n  window.__VINEXT_ROOT__ = root;\n}\n\nhydrate();\n`;\n}\n"]}
+{"version":3,"file":"pages-client-entry.js","names":["pagesPatternToNextFormat"],"sources":["../../src/entries/pages-client-entry.ts"],"sourcesContent":["/**\n * Pages Router client hydration entry generator.\n *\n * Generates the virtual client entry module (`virtual:vinext-client-entry`).\n * This is the entry point for `vite build` (client bundle). It maps route\n * patterns to dynamic imports of page modules so Vite code-splits each page\n * into its own chunk. At runtime it reads __NEXT_DATA__ to determine which\n * page to hydrate.\n *\n * Extracted from index.ts.\n */\nimport {\n  pagesRouter,\n  patternToNextFormat as pagesPatternToNextFormat,\n  type Route,\n} from \"../routing/pages-router.js\";\nimport { createValidFileMatcher } from \"../routing/file-matcher.js\";\nimport { type ResolvedNextConfig } from \"../config/next-config.js\";\nimport { findFileWithExts } from \"./pages-entry-helpers.js\";\n\nexport async function generateClientEntry(\n  pagesDir: string,\n  nextConfig: ResolvedNextConfig,\n  fileMatcher: ReturnType<typeof createValidFileMatcher>,\n): Promise<string> {\n  const pageRoutes = await pagesRouter(pagesDir, nextConfig?.pageExtensions, fileMatcher);\n\n  const appFilePath = findFileWithExts(pagesDir, \"_app\", fileMatcher);\n  const hasApp = appFilePath !== null;\n\n  // Build a map of route pattern -> dynamic import.\n  // Keys must use Next.js bracket format (e.g. \"/user/[id]\") to match\n  // __NEXT_DATA__.page which is set via patternToNextFormat() during SSR.\n  const loaderEntries = pageRoutes.map((r: Route) => {\n    const absPath = r.filePath.replace(/\\\\/g, \"/\");\n    const nextFormatPattern = pagesPatternToNextFormat(r.pattern);\n    // JSON.stringify safely escapes quotes, backslashes, and special chars in\n    // both the route pattern and the absolute file path.\n    // lgtm[js/bad-code-sanitization]\n    return `  ${JSON.stringify(nextFormatPattern)}: () => import(${JSON.stringify(absPath)})`;\n  });\n\n  const appFileBase = appFilePath?.replace(/\\\\/g, \"/\");\n\n  return `\nimport React from \"react\";\nimport { hydrateRoot } from \"react-dom/client\";\n// Eagerly import the router shim so its module-level popstate listener is\n// registered.  Without this, browser back/forward buttons do nothing because\n// navigateClient() is never invoked on history changes.\nimport \"next/router\";\n\nconst pageLoaders = {\n${loaderEntries.join(\",\\n\")}\n};\n\nasync function hydrate() {\n  const nextData = window.__NEXT_DATA__;\n  if (!nextData) {\n    console.error(\"[vinext] No __NEXT_DATA__ found\");\n    return;\n  }\n\n  const { pageProps } = nextData.props;\n  const loader = pageLoaders[nextData.page];\n  if (!loader) {\n    console.error(\"[vinext] No page loader for route:\", nextData.page);\n    return;\n  }\n\n  const pageModule = await loader();\n  const PageComponent = pageModule.default;\n  if (!PageComponent) {\n    console.error(\"[vinext] Page module has no default export\");\n    return;\n  }\n\n  let element;\n  ${\n    hasApp\n      ? `\n  try {\n    const appModule = await import(${JSON.stringify(appFileBase!)});\n    const AppComponent = appModule.default;\n    window.__VINEXT_APP__ = AppComponent;\n    element = React.createElement(AppComponent, { Component: PageComponent, pageProps });\n  } catch {\n    element = React.createElement(PageComponent, pageProps);\n  }\n  `\n      : `\n  element = React.createElement(PageComponent, pageProps);\n  `\n  }\n\n  // Wrap with RouterContext.Provider so next/compat/router works during hydration\n  const { wrapWithRouterContext } = await import(\"next/router\");\n  element = wrapWithRouterContext(element);\n\n  const container = document.getElementById(\"__next\");\n  if (!container) {\n    console.error(\"[vinext] No #__next element found\");\n    return;\n  }\n\n  const root = hydrateRoot(container, element);\n  window.__VINEXT_ROOT__ = root;\n}\n\nhydrate();\n`;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAoBA,eAAsB,oBACpB,UACA,YACA,aACiB;CACjB,MAAM,aAAa,MAAM,YAAY,UAAU,YAAY,gBAAgB,YAAY;CAEvF,MAAM,cAAc,iBAAiB,UAAU,QAAQ,YAAY;CACnE,MAAM,SAAS,gBAAgB;CAK/B,MAAM,gBAAgB,WAAW,KAAK,MAAa;EACjD,MAAM,UAAU,EAAE,SAAS,QAAQ,OAAO,IAAI;EAC9C,MAAM,oBAAoBA,oBAAyB,EAAE,QAAQ;AAI7D,SAAO,KAAK,KAAK,UAAU,kBAAkB,CAAC,iBAAiB,KAAK,UAAU,QAAQ,CAAC;GACvF;CAEF,MAAM,cAAc,aAAa,QAAQ,OAAO,IAAI;AAEpD,QAAO;;;;;;;;;EASP,cAAc,KAAK,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;IA0BxB,SACI;;qCAE6B,KAAK,UAAU,YAAa,CAAC;;;;;;;MAQ1D;;IAGL"}

package/dist/entries/pages-entry-helpers.d.ts

@@ -1,7 +1,11 @@
 import { createValidFileMatcher } from "../routing/file-matcher.js";
+
+//#region src/entries/pages-entry-helpers.d.ts
 /**
  * Find a file with any of the valid extensions in the given directory.
  * Returns the first matching absolute path, or null if not found.
  */
-export declare function findFileWithExts(dir: string, name: string, matcher: ReturnType<typeof createValidFileMatcher>): string | null;
+declare function findFileWithExts(dir: string, name: string, matcher: ReturnType<typeof createValidFileMatcher>): string | null;
+//#endregion
+export { findFileWithExts };
 //# sourceMappingURL=pages-entry-helpers.d.ts.map

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

@@ -1,18 +1,21 @@
-/**
- * Shared helpers used by the Pages Router entry generators.
- */
-import path from "node:path";
 import fs from "node:fs";
+import path from "node:path";
+//#region src/entries/pages-entry-helpers.ts
+/**
+* Shared helpers used by the Pages Router entry generators.
+*/
 /**
- * Find a file with any of the valid extensions in the given directory.
- * Returns the first matching absolute path, or null if not found.
- */
-export function findFileWithExts(dir, name, matcher) {
-    for (const ext of matcher.dottedExtensions) {
-        const filePath = path.join(dir, name + ext);
-        if (fs.existsSync(filePath))
-            return filePath;
-    }
-    return null;
+* Find a file with any of the valid extensions in the given directory.
+* Returns the first matching absolute path, or null if not found.
+*/
+function findFileWithExts(dir, name, matcher) {
+	for (const ext of matcher.dottedExtensions) {
+		const filePath = path.join(dir, name + ext);
+		if (fs.existsSync(filePath)) return filePath;
+	}
+	return null;
 }
+//#endregion
+export { findFileWithExts };
+
 //# sourceMappingURL=pages-entry-helpers.js.map

package/dist/entries/pages-entry-helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"pages-entry-helpers.js","sourceRoot":"","sources":["../../src/entries/pages-entry-helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,MAAM,SAAS,CAAC;AAGzB;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAC9B,GAAW,EACX,IAAY,EACZ,OAAkD;IAElD,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;QAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,GAAG,GAAG,CAAC,CAAC;QAC5C,IAAI,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC;YAAE,OAAO,QAAQ,CAAC;IAC/C,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["/**\n * Shared helpers used by the Pages Router entry generators.\n */\nimport path from \"node:path\";\nimport fs from \"node:fs\";\nimport { createValidFileMatcher } from \"../routing/file-matcher.js\";\n\n/**\n * Find a file with any of the valid extensions in the given directory.\n * Returns the first matching absolute path, or null if not found.\n */\nexport function findFileWithExts(\n  dir: string,\n  name: string,\n  matcher: ReturnType<typeof createValidFileMatcher>,\n): string | null {\n  for (const ext of matcher.dottedExtensions) {\n    const filePath = path.join(dir, name + ext);\n    if (fs.existsSync(filePath)) return filePath;\n  }\n  return null;\n}\n"]}
+{"version":3,"file":"pages-entry-helpers.js","names":[],"sources":["../../src/entries/pages-entry-helpers.ts"],"sourcesContent":["/**\n * Shared helpers used by the Pages Router entry generators.\n */\nimport path from \"node:path\";\nimport fs from \"node:fs\";\nimport { createValidFileMatcher } from \"../routing/file-matcher.js\";\n\n/**\n * Find a file with any of the valid extensions in the given directory.\n * Returns the first matching absolute path, or null if not found.\n */\nexport function findFileWithExts(\n  dir: string,\n  name: string,\n  matcher: ReturnType<typeof createValidFileMatcher>,\n): string | null {\n  for (const ext of matcher.dottedExtensions) {\n    const filePath = path.join(dir, name + ext);\n    if (fs.existsSync(filePath)) return filePath;\n  }\n  return null;\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,iBACd,KACA,MACA,SACe;AACf,MAAK,MAAM,OAAO,QAAQ,kBAAkB;EAC1C,MAAM,WAAW,KAAK,KAAK,KAAK,OAAO,IAAI;AAC3C,MAAI,GAAG,WAAW,SAAS,CAAE,QAAO;;AAEtC,QAAO"}

package/dist/entries/pages-server-entry.d.ts

@@ -1,8 +1,12 @@
 import { createValidFileMatcher } from "../routing/file-matcher.js";
-import { type ResolvedNextConfig } from "../config/next-config.js";
+import { ResolvedNextConfig } from "../config/next-config.js";
+
+//#region src/entries/pages-server-entry.d.ts
 /**
  * Generate the virtual SSR server entry module.
  * This is the entry point for `vite build --ssr`.
  */
-export declare function generateServerEntry(pagesDir: string, nextConfig: ResolvedNextConfig, fileMatcher: ReturnType<typeof createValidFileMatcher>, middlewarePath: string | null, instrumentationPath: string | null): Promise<string>;
+declare function generateServerEntry(pagesDir: string, nextConfig: ResolvedNextConfig, fileMatcher: ReturnType<typeof createValidFileMatcher>, middlewarePath: string | null, instrumentationPath: string | null): Promise<string>;
+//#endregion
+export { generateServerEntry };
 //# sourceMappingURL=pages-server-entry.d.ts.map