vinext 0.0.25 → 0.0.26

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

@@ -0,0 +1,449 @@
+/**
+ * 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 `
+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";
+
+/**
+ * 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;
+
+  // 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.
+  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(fixFlightHints(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) {
+  // 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: 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.
+    // 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 });
+  },
+};
+`;
+}
+//# sourceMappingURL=app-ssr-entry.js.map

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

@@ -0,0 +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"]}

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

@@ -0,0 +1,4 @@
+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>;
+//# sourceMappingURL=pages-client-entry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pages-client-entry.d.ts","sourceRoot":"","sources":["../../src/entries/pages-client-entry.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,kBAAkB,EAC9B,WAAW,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,GACrD,OAAO,CAAC,MAAM,CAAC,CAmFjB"}

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

@@ -0,0 +1,94 @@
+/**
+ * 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 { 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 `
+import React from "react";
+import { hydrateRoot } from "react-dom/client";
+// Eagerly import the router shim so its module-level popstate listener is
+// registered.  Without this, browser back/forward buttons do nothing because
+// navigateClient() is never invoked on history changes.
+import "next/router";
+
+const pageLoaders = {
+${loaderEntries.join(",\n")}
+};
+
+async function hydrate() {
+  const nextData = window.__NEXT_DATA__;
+  if (!nextData) {
+    console.error("[vinext] No __NEXT_DATA__ found");
+    return;
+  }
+
+  const { pageProps } = nextData.props;
+  const loader = pageLoaders[nextData.page];
+  if (!loader) {
+    console.error("[vinext] No page loader for route:", nextData.page);
+    return;
+  }
+
+  const pageModule = await loader();
+  const PageComponent = pageModule.default;
+  if (!PageComponent) {
+    console.error("[vinext] Page module has no default export");
+    return;
+  }
+
+  let element;
+  ${hasApp ? `
+  try {
+    const appModule = await import(${JSON.stringify(appFileBase)});
+    const AppComponent = appModule.default;
+    window.__VINEXT_APP__ = AppComponent;
+    element = React.createElement(AppComponent, { Component: PageComponent, pageProps });
+  } catch {
+    element = React.createElement(PageComponent, pageProps);
+  }
+  ` : `
+  element = React.createElement(PageComponent, pageProps);
+  `}
+
+  // Wrap with RouterContext.Provider so next/compat/router works during hydration
+  const { wrapWithRouterContext } = await import("next/router");
+  element = wrapWithRouterContext(element);
+
+  const container = document.getElementById("__next");
+  if (!container) {
+    console.error("[vinext] No #__next element found");
+    return;
+  }
+
+  const root = hydrateRoot(container, element);
+  window.__VINEXT_ROOT__ = root;
+}
+
+hydrate();
+`;
+}
+//# sourceMappingURL=pages-client-entry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pages-client-entry.js","sourceRoot":"","sources":["../../src/entries/pages-client-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,WAAW,EAAE,mBAAmB,IAAI,wBAAwB,EAAc,MAAM,4BAA4B,CAAC;AAGtH,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;;;;;;;;;;;;;;;;;;;;;;;;;IAyBvB,MAAM,CAAC,CAAC,CAAC;;qCAEwB,IAAI,CAAC,SAAS,CAAC,WAAY,CAAC;;;;;;;GAO9D,CAAC,CAAC,CAAC;;GAEH;;;;;;;;;;;;;;;;;CAiBF,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 { pagesRouter, patternToNextFormat as pagesPatternToNextFormat, type Route } 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  ${hasApp ? `\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  element = React.createElement(PageComponent, pageProps);\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"]}

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

@@ -0,0 +1,7 @@
+import { createValidFileMatcher } from "../routing/file-matcher.js";
+/**
+ * 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;
+//# sourceMappingURL=pages-entry-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pages-entry-helpers.d.ts","sourceRoot":"","sources":["../../src/entries/pages-entry-helpers.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,UAAU,CAAC,OAAO,sBAAsB,CAAC,GACjD,MAAM,GAAG,IAAI,CAMf"}

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

@@ -0,0 +1,18 @@
+/**
+ * Shared helpers used by the Pages Router entry generators.
+ */
+import path from "node:path";
+import fs from "node:fs";
+/**
+ * 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;
+}
+//# sourceMappingURL=pages-entry-helpers.js.map

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

@@ -0,0 +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"]}