vinext 0.0.25 → 0.0.26

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

@@ -0,0 +1,340 @@
+/**
+ * Generate the virtual browser entry module.
+ *
+ * This runs in the client (browser). It hydrates the page from the
+ * embedded RSC payload and handles client-side navigation by re-fetching
+ * RSC streams.
+ */
+export function generateBrowserEntry() {
+    return `
+import {
+  createFromReadableStream,
+  createFromFetch,
+  setServerCallback,
+  encodeReply,
+  createTemporaryReferenceSet,
+} from "@vitejs/plugin-rsc/browser";
+import { hydrateRoot } from "react-dom/client";
+import { flushSync } from "react-dom";
+import { setClientParams, setNavigationContext, toRscUrl, getPrefetchCache, getPrefetchedUrls, PREFETCH_CACHE_TTL } from "next/navigation";
+
+let reactRoot;
+
+/**
+ * Convert the embedded RSC chunks back to a ReadableStream.
+ * Each chunk is a text string that needs to be encoded back to Uint8Array.
+ */
+function chunksToReadableStream(chunks) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(encoder.encode(chunk));
+      }
+      controller.close();
+    }
+  });
+}
+
+/**
+ * Create a ReadableStream from progressively-embedded RSC chunks.
+ * The server injects RSC data as <script> tags that push to
+ * self.__VINEXT_RSC_CHUNKS__ throughout the HTML stream, and sets
+ * self.__VINEXT_RSC_DONE__ = true when complete.
+ *
+ * Instead of polling with setTimeout, we monkey-patch the array's
+ * push() method so new chunks are delivered immediately when the
+ * server's <script> tags execute. This eliminates unnecessary
+ * wakeups and reduces latency — same pattern Next.js uses with
+ * __next_f. The stream closes on DOMContentLoaded (when all
+ * server-injected scripts have executed) or when __VINEXT_RSC_DONE__
+ * is set, whichever comes first.
+ */
+function createProgressiveRscStream() {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(controller) {
+      const chunks = self.__VINEXT_RSC_CHUNKS__ || [];
+
+      // Deliver any chunks that arrived before this code ran
+      // (from <script> tags that executed before the browser entry loaded)
+      for (const chunk of chunks) {
+        controller.enqueue(encoder.encode(chunk));
+      }
+
+      // If the stream is already complete, close immediately
+      if (self.__VINEXT_RSC_DONE__) {
+        controller.close();
+        return;
+      }
+
+      // Monkey-patch push() so future chunks stream in immediately
+      // when the server's <script> tags execute
+      let closed = false;
+      function closeOnce() {
+        if (!closed) {
+          closed = true;
+          controller.close();
+        }
+      }
+
+      const arr = self.__VINEXT_RSC_CHUNKS__ = self.__VINEXT_RSC_CHUNKS__ || [];
+      arr.push = function(chunk) {
+        Array.prototype.push.call(this, chunk);
+        if (!closed) {
+          controller.enqueue(encoder.encode(chunk));
+          if (self.__VINEXT_RSC_DONE__) {
+            closeOnce();
+          }
+        }
+        return this.length;
+      };
+
+      // Safety net: if the server crashes mid-stream and __VINEXT_RSC_DONE__
+      // never arrives, close the stream when all server-injected scripts
+      // have executed (DOMContentLoaded). Without this, a truncated response
+      // leaves the ReadableStream open forever, hanging hydration.
+      if (typeof document !== "undefined") {
+        if (document.readyState === "loading") {
+          document.addEventListener("DOMContentLoaded", closeOnce);
+        } else {
+          // Document already loaded — close immediately if not already done
+          closeOnce();
+        }
+      }
+    }
+  });
+}
+
+// Register the server action callback — React calls this internally
+// when a "use server" function is invoked from client code.
+setServerCallback(async (id, args) => {
+  const temporaryReferences = createTemporaryReferenceSet();
+  const body = await encodeReply(args, { temporaryReferences });
+
+  const fetchResponse = await fetch(toRscUrl(window.location.pathname + window.location.search), {
+    method: "POST",
+    headers: { "x-rsc-action": id },
+    body,
+  });
+
+  // Check for redirect signal from server action that called redirect()
+  const actionRedirect = fetchResponse.headers.get("x-action-redirect");
+  if (actionRedirect) {
+    // External URLs (different origin) need a hard redirect — client-side
+    // RSC navigation only works for same-origin paths.
+    try {
+      const redirectUrl = new URL(actionRedirect, window.location.origin);
+      if (redirectUrl.origin !== window.location.origin) {
+        window.location.href = actionRedirect;
+        return undefined;
+      }
+    } catch {
+      // If URL parsing fails, fall through to client-side navigation
+    }
+
+    // Navigate to the redirect target using client-side navigation
+    const redirectType = fetchResponse.headers.get("x-action-redirect-type") || "replace";
+    if (redirectType === "push") {
+      window.history.pushState(null, "", actionRedirect);
+    } else {
+      window.history.replaceState(null, "", actionRedirect);
+    }
+    // Trigger RSC navigation to the redirect target
+    if (typeof window.__VINEXT_RSC_NAVIGATE__ === "function") {
+      window.__VINEXT_RSC_NAVIGATE__(actionRedirect);
+    }
+    return undefined;
+  }
+
+  const result = await createFromFetch(Promise.resolve(fetchResponse), { temporaryReferences });
+
+  // The RSC response for actions contains { root, returnValue }.
+  // Re-render the page with the updated tree.
+  if (result && typeof result === "object" && "root" in result) {
+    reactRoot.render(result.root);
+    // Return the action's return value to the caller
+    if (result.returnValue) {
+      if (!result.returnValue.ok) throw result.returnValue.data;
+      return result.returnValue.data;
+    }
+    return undefined;
+  }
+
+  // Fallback: render the entire result as the tree
+  reactRoot.render(result);
+  return result;
+});
+
+async function main() {
+  let rscStream;
+
+  // Use embedded RSC data for initial hydration if available.
+  // This ensures we use the SAME RSC payload that generated the HTML,
+  // avoiding hydration mismatches (React error #418).
+  //
+  // The server embeds RSC chunks progressively as <script> tags that push
+  // to self.__VINEXT_RSC_CHUNKS__. When complete, self.__VINEXT_RSC_DONE__
+  // is set and self.__VINEXT_RSC_PARAMS__ contains route params.
+  // For backwards compat, also check the legacy self.__VINEXT_RSC__ format.
+  if (self.__VINEXT_RSC_CHUNKS__ || self.__VINEXT_RSC_DONE__ || self.__VINEXT_RSC__) {
+    if (self.__VINEXT_RSC__) {
+      // Legacy format: single object with all chunks
+      const embedData = self.__VINEXT_RSC__;
+      delete self.__VINEXT_RSC__;
+      if (embedData.params) {
+        setClientParams(embedData.params);
+      }
+      // Legacy format may include nav context for hydration snapshot consistency.
+      if (embedData.nav) {
+        setNavigationContext({ pathname: embedData.nav.pathname, searchParams: new URLSearchParams(embedData.nav.searchParams || {}), params: embedData.params || {} });
+      }
+      rscStream = chunksToReadableStream(embedData.rsc);
+    } else {
+      // Progressive format: chunks arrive incrementally via script tags.
+      // Params are embedded in <head> so they're always available by this point.
+      if (self.__VINEXT_RSC_PARAMS__) {
+        setClientParams(self.__VINEXT_RSC_PARAMS__);
+      }
+      // Restore the server navigation context so useSyncExternalStore getServerSnapshot
+      // matches what was rendered on the server, preventing hydration mismatches.
+      if (self.__VINEXT_RSC_NAV__) {
+        const __nav = self.__VINEXT_RSC_NAV__;
+        setNavigationContext({ pathname: __nav.pathname, searchParams: new URLSearchParams(__nav.searchParams), params: self.__VINEXT_RSC_PARAMS__ || {} });
+      }
+      rscStream = createProgressiveRscStream();
+    }
+  } else {
+    // Fallback: fetch fresh RSC (shouldn't happen on initial page load)
+    const rscResponse = await fetch(toRscUrl(window.location.pathname + window.location.search));
+
+    // Hydrate useParams() with route params from the server before React hydration
+    const paramsHeader = rscResponse.headers.get("X-Vinext-Params");
+    if (paramsHeader) {
+      try { setClientParams(JSON.parse(paramsHeader)); } catch (_e) { /* ignore */ }
+    }
+    // Set nav context from current URL for hydration snapshot consistency.
+    setNavigationContext({ pathname: window.location.pathname, searchParams: new URLSearchParams(window.location.search), params: self.__VINEXT_RSC_PARAMS__ || {} });
+
+    rscStream = rscResponse.body;
+  }
+
+  const root = await createFromReadableStream(rscStream);
+
+  // Hydrate the document
+  // In development, suppress Vite's error overlay for errors caught by React error
+  // boundaries. Without this, React re-throws caught errors to the global handler,
+  // which triggers Vite's overlay even though the error was handled by an error.tsx.
+  // In production, preserve React's default onCaughtError (console.error) so
+  // boundary-caught errors remain visible to error monitoring.
+  reactRoot = hydrateRoot(document, root, import.meta.env.DEV ? {
+    onCaughtError: function() {},
+  } : undefined);
+
+  // Store for client-side navigation
+  window.__VINEXT_RSC_ROOT__ = reactRoot;
+
+  // Client-side navigation handler
+  // Checks the prefetch cache (populated by <Link> IntersectionObserver and
+  // router.prefetch()) before making a network request. This makes navigation
+  // near-instant for prefetched routes.
+  window.__VINEXT_RSC_NAVIGATE__ = async function navigateRsc(href, __redirectDepth) {
+    if ((__redirectDepth || 0) > 10) {
+      console.error("[vinext] Too many RSC redirects — aborting navigation to prevent infinite loop.");
+      window.location.href = href;
+      return;
+    }
+    try {
+      const url = new URL(href, window.location.origin);
+      const rscUrl = toRscUrl(url.pathname + url.search);
+
+      // Check the in-memory prefetch cache first
+      let navResponse;
+      const prefetchCache = getPrefetchCache();
+      const cached = prefetchCache.get(rscUrl);
+      if (cached && (Date.now() - cached.timestamp) < PREFETCH_CACHE_TTL) {
+        navResponse = cached.response;
+        prefetchCache.delete(rscUrl); // Consume the cached entry (one-time use)
+        getPrefetchedUrls().delete(rscUrl); // Allow re-prefetch when link is visible again
+      } else if (cached) {
+        prefetchCache.delete(rscUrl); // Expired, clean up
+        getPrefetchedUrls().delete(rscUrl);
+      }
+
+      // Fallback to network fetch if not in cache
+      if (!navResponse) {
+        navResponse = await fetch(rscUrl, {
+          headers: { Accept: "text/x-component" },
+          credentials: "include",
+        });
+      }
+
+      // Detect if fetch followed a redirect: compare the final response URL to
+      // what we requested. If they differ, the server issued a 3xx — push the
+      // canonical destination URL into history before rendering.
+      const __finalUrl = new URL(navResponse.url);
+      const __requestedUrl = new URL(rscUrl, window.location.origin);
+      if (__finalUrl.pathname !== __requestedUrl.pathname) {
+        // Strip .rsc suffix from the final URL to get the page path for history.
+        // Use replaceState instead of pushState: the caller (navigateImpl) already
+        // pushed the pre-redirect URL; replacing it avoids a stale history entry.
+        const __destPath = __finalUrl.pathname.replace(/\\.rsc$/, "") + __finalUrl.search;
+        window.history.replaceState(null, "", __destPath);
+        return window.__VINEXT_RSC_NAVIGATE__(__destPath, (__redirectDepth || 0) + 1);
+      }
+
+      // Update useParams() with route params from the server before re-rendering
+      const navParamsHeader = navResponse.headers.get("X-Vinext-Params");
+      if (navParamsHeader) {
+        try { setClientParams(JSON.parse(navParamsHeader)); } catch (_e) { /* ignore */ }
+      } else {
+        setClientParams({});
+      }
+
+      const rscPayload = await createFromFetch(Promise.resolve(navResponse));
+      // Use flushSync to guarantee React commits the new tree to the DOM
+      // synchronously before this function returns. Callers scroll to top
+      // after awaiting, so the new content must be painted first.
+      flushSync(function () { reactRoot.render(rscPayload); });
+    } catch (err) {
+      console.error("[vinext] RSC navigation error:", err);
+      // Fallback to full page load
+      window.location.href = href;
+    }
+  };
+
+  // Handle popstate (browser back/forward)
+  // Store the navigation promise on a well-known property so that
+  // restoreScrollPosition (in navigation.ts) can await it before scrolling.
+  // This prevents a flash where the old content is visible at the restored
+  // scroll position before the new RSC payload has rendered.
+  window.addEventListener("popstate", () => {
+    const p = window.__VINEXT_RSC_NAVIGATE__(window.location.href);
+    window.__VINEXT_RSC_PENDING__ = p;
+    p.finally(() => {
+      // Clear once settled so stale promises aren't awaited later
+      if (window.__VINEXT_RSC_PENDING__ === p) {
+        window.__VINEXT_RSC_PENDING__ = null;
+      }
+    });
+  });
+
+  // HMR: re-render on server module updates
+  if (import.meta.hot) {
+    import.meta.hot.on("rsc:update", async () => {
+      try {
+        const rscPayload = await createFromFetch(
+          fetch(toRscUrl(window.location.pathname + window.location.search))
+        );
+        reactRoot.render(rscPayload);
+      } catch (err) {
+        console.error("[vinext] RSC HMR error:", err);
+      }
+    });
+  }
+}
+
+main();
+`;
+}
+//# sourceMappingURL=app-browser-entry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"app-browser-entry.js","sourceRoot":"","sources":["../../src/entries/app-browser-entry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyUR,CAAC;AACF,CAAC","sourcesContent":["/**\n * Generate the virtual browser entry module.\n *\n * This runs in the client (browser). It hydrates the page from the\n * embedded RSC payload and handles client-side navigation by re-fetching\n * RSC streams.\n */\nexport function generateBrowserEntry(): string {\n  return `\nimport {\n  createFromReadableStream,\n  createFromFetch,\n  setServerCallback,\n  encodeReply,\n  createTemporaryReferenceSet,\n} from \"@vitejs/plugin-rsc/browser\";\nimport { hydrateRoot } from \"react-dom/client\";\nimport { flushSync } from \"react-dom\";\nimport { setClientParams, setNavigationContext, toRscUrl, getPrefetchCache, getPrefetchedUrls, PREFETCH_CACHE_TTL } from \"next/navigation\";\n\nlet reactRoot;\n\n/**\n * Convert the embedded RSC chunks back to a ReadableStream.\n * Each chunk is a text string that needs to be encoded back to Uint8Array.\n */\nfunction chunksToReadableStream(chunks) {\n  const encoder = new TextEncoder();\n  return new ReadableStream({\n    start(controller) {\n      for (const chunk of chunks) {\n        controller.enqueue(encoder.encode(chunk));\n      }\n      controller.close();\n    }\n  });\n}\n\n/**\n * Create a ReadableStream from progressively-embedded RSC chunks.\n * The server injects RSC data as <script> tags that push to\n * self.__VINEXT_RSC_CHUNKS__ throughout the HTML stream, and sets\n * self.__VINEXT_RSC_DONE__ = true when complete.\n *\n * Instead of polling with setTimeout, we monkey-patch the array's\n * push() method so new chunks are delivered immediately when the\n * server's <script> tags execute. This eliminates unnecessary\n * wakeups and reduces latency — same pattern Next.js uses with\n * __next_f. The stream closes on DOMContentLoaded (when all\n * server-injected scripts have executed) or when __VINEXT_RSC_DONE__\n * is set, whichever comes first.\n */\nfunction createProgressiveRscStream() {\n  const encoder = new TextEncoder();\n  return new ReadableStream({\n    start(controller) {\n      const chunks = self.__VINEXT_RSC_CHUNKS__ || [];\n\n      // Deliver any chunks that arrived before this code ran\n      // (from <script> tags that executed before the browser entry loaded)\n      for (const chunk of chunks) {\n        controller.enqueue(encoder.encode(chunk));\n      }\n\n      // If the stream is already complete, close immediately\n      if (self.__VINEXT_RSC_DONE__) {\n        controller.close();\n        return;\n      }\n\n      // Monkey-patch push() so future chunks stream in immediately\n      // when the server's <script> tags execute\n      let closed = false;\n      function closeOnce() {\n        if (!closed) {\n          closed = true;\n          controller.close();\n        }\n      }\n\n      const arr = self.__VINEXT_RSC_CHUNKS__ = self.__VINEXT_RSC_CHUNKS__ || [];\n      arr.push = function(chunk) {\n        Array.prototype.push.call(this, chunk);\n        if (!closed) {\n          controller.enqueue(encoder.encode(chunk));\n          if (self.__VINEXT_RSC_DONE__) {\n            closeOnce();\n          }\n        }\n        return this.length;\n      };\n\n      // Safety net: if the server crashes mid-stream and __VINEXT_RSC_DONE__\n      // never arrives, close the stream when all server-injected scripts\n      // have executed (DOMContentLoaded). Without this, a truncated response\n      // leaves the ReadableStream open forever, hanging hydration.\n      if (typeof document !== \"undefined\") {\n        if (document.readyState === \"loading\") {\n          document.addEventListener(\"DOMContentLoaded\", closeOnce);\n        } else {\n          // Document already loaded — close immediately if not already done\n          closeOnce();\n        }\n      }\n    }\n  });\n}\n\n// Register the server action callback — React calls this internally\n// when a \"use server\" function is invoked from client code.\nsetServerCallback(async (id, args) => {\n  const temporaryReferences = createTemporaryReferenceSet();\n  const body = await encodeReply(args, { temporaryReferences });\n\n  const fetchResponse = await fetch(toRscUrl(window.location.pathname + window.location.search), {\n    method: \"POST\",\n    headers: { \"x-rsc-action\": id },\n    body,\n  });\n\n  // Check for redirect signal from server action that called redirect()\n  const actionRedirect = fetchResponse.headers.get(\"x-action-redirect\");\n  if (actionRedirect) {\n    // External URLs (different origin) need a hard redirect — client-side\n    // RSC navigation only works for same-origin paths.\n    try {\n      const redirectUrl = new URL(actionRedirect, window.location.origin);\n      if (redirectUrl.origin !== window.location.origin) {\n        window.location.href = actionRedirect;\n        return undefined;\n      }\n    } catch {\n      // If URL parsing fails, fall through to client-side navigation\n    }\n\n    // Navigate to the redirect target using client-side navigation\n    const redirectType = fetchResponse.headers.get(\"x-action-redirect-type\") || \"replace\";\n    if (redirectType === \"push\") {\n      window.history.pushState(null, \"\", actionRedirect);\n    } else {\n      window.history.replaceState(null, \"\", actionRedirect);\n    }\n    // Trigger RSC navigation to the redirect target\n    if (typeof window.__VINEXT_RSC_NAVIGATE__ === \"function\") {\n      window.__VINEXT_RSC_NAVIGATE__(actionRedirect);\n    }\n    return undefined;\n  }\n\n  const result = await createFromFetch(Promise.resolve(fetchResponse), { temporaryReferences });\n\n  // The RSC response for actions contains { root, returnValue }.\n  // Re-render the page with the updated tree.\n  if (result && typeof result === \"object\" && \"root\" in result) {\n    reactRoot.render(result.root);\n    // Return the action's return value to the caller\n    if (result.returnValue) {\n      if (!result.returnValue.ok) throw result.returnValue.data;\n      return result.returnValue.data;\n    }\n    return undefined;\n  }\n\n  // Fallback: render the entire result as the tree\n  reactRoot.render(result);\n  return result;\n});\n\nasync function main() {\n  let rscStream;\n\n  // Use embedded RSC data for initial hydration if available.\n  // This ensures we use the SAME RSC payload that generated the HTML,\n  // avoiding hydration mismatches (React error #418).\n  //\n  // The server embeds RSC chunks progressively as <script> tags that push\n  // to self.__VINEXT_RSC_CHUNKS__. When complete, self.__VINEXT_RSC_DONE__\n  // is set and self.__VINEXT_RSC_PARAMS__ contains route params.\n  // For backwards compat, also check the legacy self.__VINEXT_RSC__ format.\n  if (self.__VINEXT_RSC_CHUNKS__ || self.__VINEXT_RSC_DONE__ || self.__VINEXT_RSC__) {\n    if (self.__VINEXT_RSC__) {\n      // Legacy format: single object with all chunks\n      const embedData = self.__VINEXT_RSC__;\n      delete self.__VINEXT_RSC__;\n      if (embedData.params) {\n        setClientParams(embedData.params);\n      }\n      // Legacy format may include nav context for hydration snapshot consistency.\n      if (embedData.nav) {\n        setNavigationContext({ pathname: embedData.nav.pathname, searchParams: new URLSearchParams(embedData.nav.searchParams || {}), params: embedData.params || {} });\n      }\n      rscStream = chunksToReadableStream(embedData.rsc);\n    } else {\n      // Progressive format: chunks arrive incrementally via script tags.\n      // Params are embedded in <head> so they're always available by this point.\n      if (self.__VINEXT_RSC_PARAMS__) {\n        setClientParams(self.__VINEXT_RSC_PARAMS__);\n      }\n      // Restore the server navigation context so useSyncExternalStore getServerSnapshot\n      // matches what was rendered on the server, preventing hydration mismatches.\n      if (self.__VINEXT_RSC_NAV__) {\n        const __nav = self.__VINEXT_RSC_NAV__;\n        setNavigationContext({ pathname: __nav.pathname, searchParams: new URLSearchParams(__nav.searchParams), params: self.__VINEXT_RSC_PARAMS__ || {} });\n      }\n      rscStream = createProgressiveRscStream();\n    }\n  } else {\n    // Fallback: fetch fresh RSC (shouldn't happen on initial page load)\n    const rscResponse = await fetch(toRscUrl(window.location.pathname + window.location.search));\n\n    // Hydrate useParams() with route params from the server before React hydration\n    const paramsHeader = rscResponse.headers.get(\"X-Vinext-Params\");\n    if (paramsHeader) {\n      try { setClientParams(JSON.parse(paramsHeader)); } catch (_e) { /* ignore */ }\n    }\n    // Set nav context from current URL for hydration snapshot consistency.\n    setNavigationContext({ pathname: window.location.pathname, searchParams: new URLSearchParams(window.location.search), params: self.__VINEXT_RSC_PARAMS__ || {} });\n\n    rscStream = rscResponse.body;\n  }\n\n  const root = await createFromReadableStream(rscStream);\n\n  // Hydrate the document\n  // In development, suppress Vite's error overlay for errors caught by React error\n  // boundaries. Without this, React re-throws caught errors to the global handler,\n  // which triggers Vite's overlay even though the error was handled by an error.tsx.\n  // In production, preserve React's default onCaughtError (console.error) so\n  // boundary-caught errors remain visible to error monitoring.\n  reactRoot = hydrateRoot(document, root, import.meta.env.DEV ? {\n    onCaughtError: function() {},\n  } : undefined);\n\n  // Store for client-side navigation\n  window.__VINEXT_RSC_ROOT__ = reactRoot;\n\n  // Client-side navigation handler\n  // Checks the prefetch cache (populated by <Link> IntersectionObserver and\n  // router.prefetch()) before making a network request. This makes navigation\n  // near-instant for prefetched routes.\n  window.__VINEXT_RSC_NAVIGATE__ = async function navigateRsc(href, __redirectDepth) {\n    if ((__redirectDepth || 0) > 10) {\n      console.error(\"[vinext] Too many RSC redirects — aborting navigation to prevent infinite loop.\");\n      window.location.href = href;\n      return;\n    }\n    try {\n      const url = new URL(href, window.location.origin);\n      const rscUrl = toRscUrl(url.pathname + url.search);\n\n      // Check the in-memory prefetch cache first\n      let navResponse;\n      const prefetchCache = getPrefetchCache();\n      const cached = prefetchCache.get(rscUrl);\n      if (cached && (Date.now() - cached.timestamp) < PREFETCH_CACHE_TTL) {\n        navResponse = cached.response;\n        prefetchCache.delete(rscUrl); // Consume the cached entry (one-time use)\n        getPrefetchedUrls().delete(rscUrl); // Allow re-prefetch when link is visible again\n      } else if (cached) {\n        prefetchCache.delete(rscUrl); // Expired, clean up\n        getPrefetchedUrls().delete(rscUrl);\n      }\n\n      // Fallback to network fetch if not in cache\n      if (!navResponse) {\n        navResponse = await fetch(rscUrl, {\n          headers: { Accept: \"text/x-component\" },\n          credentials: \"include\",\n        });\n      }\n\n      // Detect if fetch followed a redirect: compare the final response URL to\n      // what we requested. If they differ, the server issued a 3xx — push the\n      // canonical destination URL into history before rendering.\n      const __finalUrl = new URL(navResponse.url);\n      const __requestedUrl = new URL(rscUrl, window.location.origin);\n      if (__finalUrl.pathname !== __requestedUrl.pathname) {\n        // Strip .rsc suffix from the final URL to get the page path for history.\n        // Use replaceState instead of pushState: the caller (navigateImpl) already\n        // pushed the pre-redirect URL; replacing it avoids a stale history entry.\n        const __destPath = __finalUrl.pathname.replace(/\\\\.rsc$/, \"\") + __finalUrl.search;\n        window.history.replaceState(null, \"\", __destPath);\n        return window.__VINEXT_RSC_NAVIGATE__(__destPath, (__redirectDepth || 0) + 1);\n      }\n\n      // Update useParams() with route params from the server before re-rendering\n      const navParamsHeader = navResponse.headers.get(\"X-Vinext-Params\");\n      if (navParamsHeader) {\n        try { setClientParams(JSON.parse(navParamsHeader)); } catch (_e) { /* ignore */ }\n      } else {\n        setClientParams({});\n      }\n\n      const rscPayload = await createFromFetch(Promise.resolve(navResponse));\n      // Use flushSync to guarantee React commits the new tree to the DOM\n      // synchronously before this function returns. Callers scroll to top\n      // after awaiting, so the new content must be painted first.\n      flushSync(function () { reactRoot.render(rscPayload); });\n    } catch (err) {\n      console.error(\"[vinext] RSC navigation error:\", err);\n      // Fallback to full page load\n      window.location.href = href;\n    }\n  };\n\n  // Handle popstate (browser back/forward)\n  // Store the navigation promise on a well-known property so that\n  // restoreScrollPosition (in navigation.ts) can await it before scrolling.\n  // This prevents a flash where the old content is visible at the restored\n  // scroll position before the new RSC payload has rendered.\n  window.addEventListener(\"popstate\", () => {\n    const p = window.__VINEXT_RSC_NAVIGATE__(window.location.href);\n    window.__VINEXT_RSC_PENDING__ = p;\n    p.finally(() => {\n      // Clear once settled so stale promises aren't awaited later\n      if (window.__VINEXT_RSC_PENDING__ === p) {\n        window.__VINEXT_RSC_PENDING__ = null;\n      }\n    });\n  });\n\n  // HMR: re-render on server module updates\n  if (import.meta.hot) {\n    import.meta.hot.on(\"rsc:update\", async () => {\n      try {\n        const rscPayload = await createFromFetch(\n          fetch(toRscUrl(window.location.pathname + window.location.search))\n        );\n        reactRoot.render(rscPayload);\n      } catch (err) {\n        console.error(\"[vinext] RSC HMR error:\", err);\n      }\n    });\n  }\n}\n\nmain();\n`;\n}\n"]}

package/dist/{server/app-dev-server.d.ts → entries/app-rsc-entry.d.ts}

@@ -1,5 +1,5 @@
 import type { AppRoute } from "../routing/app-router.js";
-import type { MetadataFileRoute } from "./metadata-routes.js";
+import type { MetadataFileRoute } from "../server/metadata-routes.js";
 import type { NextRedirect, NextRewrite, NextHeader } from "../config/next-config.js";
 /**
  * Resolved config options relevant to App Router request handling.
@@ -17,6 +17,8 @@ export interface AppRouterConfig {
     allowedOrigins?: string[];
     /** Extra origins allowed for dev server access (from allowedDevOrigins). */
     allowedDevOrigins?: string[];
+    /** Body size limit for server actions in bytes (from experimental.serverActions.bodySizeLimit). */
+    bodySizeLimit?: number;
 }
 /**
  * Generate the virtual RSC entry module.
@@ -26,19 +28,4 @@ export interface AppRouterConfig {
  * nested layout + page tree, and renders it to an RSC stream.
  */
 export declare function generateRscEntry(appDir: string, routes: AppRoute[], middlewarePath?: string | null, metadataRoutes?: MetadataFileRoute[], globalErrorPath?: string | null, basePath?: string, trailingSlash?: boolean, config?: AppRouterConfig, instrumentationPath?: string | null): string;
-/**
- * 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 declare function generateSsrEntry(): string;
-/**
- * Generate the virtual browser entry module.
- *
- * This runs in the client (browser). It hydrates the page from the
- * embedded RSC payload and handles client-side navigation by re-fetching
- * RSC streams.
- */
-export declare function generateBrowserEntry(): string;
-//# sourceMappingURL=app-dev-server.d.ts.map
+//# sourceMappingURL=app-rsc-entry.d.ts.map

package/dist/entries/app-rsc-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-rsc-entry.d.ts","sourceRoot":"","sources":["../../src/entries/app-rsc-entry.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAWtF;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,YAAY,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE;QACT,WAAW,EAAE,WAAW,EAAE,CAAC;QAC3B,UAAU,EAAE,WAAW,EAAE,CAAC;QAC1B,QAAQ,EAAE,WAAW,EAAE,CAAC;KACzB,CAAC;IACF,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB,4GAA4G;IAC5G,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,4EAA4E;IAC5E,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,mGAAmG;IACnG,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,QAAQ,EAAE,EAClB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,EAC9B,cAAc,CAAC,EAAE,iBAAiB,EAAE,EACpC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,EAC/B,QAAQ,CAAC,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,OAAO,EACvB,MAAM,CAAC,EAAE,eAAe,EACxB,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,GAClC,MAAM,CA6zER"}