@rangojs/router 0.26.3 → 0.26.5

package/dist/bin/rango.js

@@ -1644,7 +1644,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@rangojs/router",
-      version: "0.26.3",
+      version: "0.26.5",
       description: "Django-inspired RSC router with composable URL patterns",
       keywords: [
         "react",

package/dist/types/browser/document-flight-stream.d.ts

@@ -0,0 +1,15 @@
+type FlightChunk = string | Uint8Array;
+/** Where the document's inline scripts push Flight chunks (`self`). */
+export interface FlightDataHost {
+    __FLIGHT_DATA?: FlightChunk[];
+}
+/**
+ * The document's Flight payload as a stream: the server's inline scripts push
+ * chunks onto `self.__FLIGHT_DATA` (rsc-html-stream/server, or
+ * ssr/inject-rsc-eager.ts), and the browser's own DOMContentLoaded
+ * (`isTrusted`) closes it after the last of them ran. rsc-html-stream/client
+ * closed on any DOMContentLoaded, so a script re-dispatching the event cut a
+ * streaming page short and threw after the load (#1205).
+ */
+export declare function createDocumentFlightStream(doc: Pick<Document, "readyState" | "addEventListener" | "removeEventListener">, host: FlightDataHost): ReadableStream<Uint8Array>;
+export {};

package/dist/types/browser/rsc-router.d.ts

@@ -7,7 +7,8 @@ import type { ResolvedThemeConfig, Theme } from "../theme/types.js";
  */
 export interface InitBrowserAppOptions {
     /**
-     * RSC stream containing the initial payload (from rsc-html-stream/client)
+     * RSC stream containing the initial payload
+     * (`@rangojs/router/internal/deps/html-stream-client`)
      */
     rscStream: ReadableStream<Uint8Array>;
     /**
@@ -133,7 +134,7 @@ export interface RangoProps {
  * @example
  * ```tsx
  * import { initBrowserApp, Rango } from "@rangojs/router/browser";
- * import { rscStream } from "rsc-html-stream/client";
+ * import { rscStream } from "@rangojs/router/internal/deps/html-stream-client";
  * import * as rscBrowser from "@vitejs/plugin-rsc/browser";
  *
  * async function main() {

package/dist/types/deps/html-stream-client.d.ts

@@ -1 +1 @@
-export { rscStream } from "rsc-html-stream/client";
+export declare const rscStream: ReadableStream<Uint8Array>;

package/dist/types/router/dev-reload-handoff.d.ts

@@ -13,6 +13,18 @@ export declare function watchRunnerReloads(events: RunnerReloadEvents | undefine
  * @internal
  */
 export declare function droppedByRunnerReload(): boolean;
+type Serve = () => Promise<Response>;
+/**
+ * Serves a request on this router copy, or on the router a runner full reload
+ * re-created when the reload dropped this copy before the request or while it
+ * ran. What a request imports after the clear is the fresh copy, so one the
+ * reload lands inside fails or answers the wrong route: its outcome is
+ * discarded. Only GET and HEAD re-run, since a re-run repeats side effects and
+ * cannot re-read a body. A reload after the response is returned still splits
+ * its stream.
+ * @internal
+ */
+export declare function serveAcrossRunnerReload(request: Request, serve: Serve, recreated: () => Promise<Serve | undefined>): Promise<Response>;
 /**
  * The router the reload re-created for `routerId`, or undefined when none
  * registered within DEV_RECREATED_ROUTER_WAIT_MS. Importing `sourceFile`

package/dist/types/ssr/index.d.ts

@@ -169,13 +169,15 @@ export interface SSRDependencies<TEnv = unknown> {
      * the `rango({ progressiveChunkSize })` plugin option here (canonical docs
      * on `RangoBaseOptions.progressiveChunkSize` in vite/plugin-types.ts).
      *
-     * When UNSET, createSSRHandler auto-raises to Number.MAX_SAFE_INTEGER for
-     * document renders whose matched chain has a `loader(Def, { ssr: false })`
-     * entry (payload segments carry `awaitBeforeFlush`): the loader was awaited
-     * before first flush precisely so its content ships in-place, and React
-     * 19.2's Fizz would otherwise move any completed boundary over ~500 bytes
-     * to an end-of-stream `<div hidden>` + $RC reveal once the shell saturates
-     * the default 12800 budget. An explicit value disables the auto-raise.
+     * When UNSET, createSSRHandler and createShellCaptureHandler auto-raise to
+     * Number.MAX_SAFE_INTEGER for document renders and shell captures whose
+     * matched chain has a `loader(Def, { ssr: false })` entry (payload segments
+     * carry `awaitBeforeFlush`): the loader was awaited before first flush
+     * precisely so its content ships in-place, and React 19.2's Fizz would
+     * otherwise move any completed boundary over ~500 bytes to an end-of-stream
+     * `<div hidden>` + $RC reveal once the shell saturates the default 12800
+     * budget. A shell HIT inherits the raise (prelude and resumed holes), so it
+     * matches the live render. An explicit value disables the auto-raise.
      */
     progressiveChunkSize?: number;
     /**

package/dist/types/ssr/ssr-root.d.ts

@@ -28,11 +28,11 @@ export interface RscPayload {
 }
 /**
  * Deserialize the Flight stream branch into the payload SsrRoot renders,
- * fragment expansion included. Factored out of SsrRoot so createSSRHandler can
- * create the promise BEFORE fizz starts and read metadata that must influence
- * the fizz call itself (the ssr:false progressiveChunkSize auto-raise) —
- * awaiting it there is latency-neutral because fizz cannot emit even <html>
- * until this same promise settles.
+ * fragment expansion included. Factored out of SsrRoot so createSSRHandler and
+ * createShellCaptureHandler can create the promise BEFORE fizz starts and read
+ * metadata that must influence the fizz call itself (the ssr:false
+ * progressiveChunkSize auto-raise) — awaiting it there is latency-neutral
+ * because fizz cannot emit even <html> until this same promise settles.
  */
 export declare function deserializeSsrPayload(createFromReadableStream: CreateFromReadableStream, rscStream: ReadableStream<Uint8Array>): Promise<RscPayload>;
 /**

package/dist/types/vite/discovery/state.d.ts

@@ -126,9 +126,10 @@ export interface DiscoveryState {
      */
     userRunnerConfig: import("../utils/forward-user-plugins.js").ForwardedRunnerConfig | undefined;
     /**
-     * User resolution plugins (resolveId/load), stripped to their resolution
-     * surface, forwarded into the discovery temp server. Lets third-party
-     * resolvers such as vite-tsconfig-paths participate in discovery.
+     * User resolution plugins (resolveId/load, plus import rewriters' transform),
+     * stripped to their resolution surface, forwarded into the discovery temp
+     * server. Lets third-party resolvers such as vite-tsconfig-paths participate
+     * in discovery.
      */
     userResolvePlugins: import("vite").Plugin[];
     scanFilter: ScanFilter | undefined;

package/dist/types/vite/plugin-types.d.ts

@@ -165,12 +165,12 @@ interface RangoBaseOptions {
      * the CSS. Trade-off: inline content delays later shell bytes behind it,
      * which is why React outlines by default.
      *
-     * When UNSET, document renders whose matched chain has a
-     * `loader(Def, { ssr: false })` entry auto-raise to MAX_SAFE_INTEGER — the
-     * loader was awaited before first flush precisely so its content ships
-     * in-place, and outlining the boundary it feeds would defeat that. Setting
-     * an explicit value disables the auto-raise. The auto-raise is live-SSR
-     * only; captured shells use the explicit value or React's default.
+     * When UNSET, document renders and PPR shell captures whose matched chain
+     * has a `loader(Def, { ssr: false })` entry auto-raise to MAX_SAFE_INTEGER —
+     * the loader was awaited before first flush precisely so its content ships
+     * in-place, and outlining the boundary it feeds would defeat that. A shell
+     * HIT inherits the captured value, so it matches the live render. Setting
+     * an explicit value disables the auto-raise.
      *
      * Apps with a custom SSR entry set this per-handler via
      * `SSRDependencies.progressiveChunkSize`.

package/dist/vite/index.js

@@ -7078,7 +7078,7 @@ function resolveVersionsFrom(table, routerId2) {
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.26.3",
+  version: "0.26.5",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -12227,7 +12227,8 @@ async function runShellPrerenderPhase(s, builder, versionsTable) {
       prerender: reactDomStatic.prerender ?? reactDomStatic.default?.prerender,
       injectRSCPayload: htmlStream.injectRSCPayload,
       headScripts: "preinit",
-      // Build-captured shells must honor the explicit outlining budget: the
+      // Build-captured shells honor the explicit outlining budget, or the
+      // ssr:false auto-raise without one (createShellCaptureHandler): the
       // capture value rides the postponed state into every runtime resume().
       ...s.opts?.progressiveChunkSize !== void 0 && {
         progressiveChunkSize: s.opts.progressiveChunkSize
@@ -12942,8 +12943,13 @@ function createDiscoveryGate(s, debug14) {
 function isDenied(name) {
   return name.startsWith("vite:") || name === "rsc" || name.startsWith("rsc:") || name.startsWith("@rangojs/router") || name.startsWith("@cloudflare/vite-plugin") || name.startsWith("vite-plugin-cloudflare");
 }
-function hasResolutionHooks(p) {
-  return Boolean(p.resolveId || p.load);
+var IMPORT_REWRITE_PLUGINS = /* @__PURE__ */ new Set([
+  "rolldown-plugin-transform-imports"
+]);
+function isForwardable(p) {
+  return Boolean(
+    p.resolveId || p.load || IMPORT_REWRITE_PLUGINS.has(p.name)
+  );
 }
 function stripToResolutionHooks(p) {
   const stripped = { name: p.name };
@@ -12952,6 +12958,8 @@ function stripToResolutionHooks(p) {
     stripped.applyToEnvironment = p.applyToEnvironment;
   if (p.resolveId) stripped.resolveId = p.resolveId;
   if (p.load) stripped.load = p.load;
+  if (IMPORT_REWRITE_PLUGINS.has(p.name))
+    stripped.transform = p.transform;
   return stripped;
 }
 function selectForwardableResolvePlugins(plugins) {
@@ -12960,7 +12968,7 @@ function selectForwardableResolvePlugins(plugins) {
   for (const p of plugins) {
     const name = p?.name;
     if (!name || isDenied(name)) continue;
-    if (!hasResolutionHooks(p)) continue;
+    if (!isForwardable(p)) continue;
     forwarded.push(stripToResolutionHooks(p));
   }
   return forwarded;
@@ -13110,7 +13118,8 @@ async function createTempRscServer(state, options = {}) {
         }
       },
       // Forwarded user resolution plugins (e.g. vite-tsconfig-paths). Stripped
-      // to resolveId/load and placed last so framework resolution runs first;
+      // to resolveId/load (plus transform for import rewriters, see
+      // IMPORT_REWRITE_PLUGINS) and placed last so framework resolution runs first;
       // Vite re-sorts by `enforce`, so `enforce: "pre"` resolvers still lead.
       ...state.userResolvePlugins
     ]
@@ -14755,7 +14764,6 @@ async function rango(options) {
                 }
               },
               optimizeDeps: {
-                include: [nested("rsc-html-stream/client")],
                 exclude: excludeDeps,
                 rolldownOptions: sharedRolldownOptions
               }
@@ -14923,8 +14931,7 @@ If this is a multi-app host router, export a createHostRouter() instance and set
                   "react",
                   "react-dom",
                   "react/jsx-runtime",
-                  "react/jsx-dev-runtime",
-                  nested("rsc-html-stream/client")
+                  "react/jsx-dev-runtime"
                 ],
                 exclude: excludeDeps,
                 rolldownOptions: sharedRolldownOptions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rangojs/router",
-  "version": "0.26.3",
+  "version": "0.26.5",
   "description": "Django-inspired RSC router with composable URL patterns",
   "keywords": [
     "react",

package/skills/loader/SKILL.md

@@ -1136,8 +1136,9 @@ COMPLETED Suspense boundary over ~500 bytes to an end-of-stream
 `progressiveChunkSize` budget — the bytes are in the HTML, but not at their
 document position, and a consumer that doesn't execute scripts never sees
 them revealed. When the matched chain has a flagged loader, the document
-render raises the budget to `MAX_SAFE_INTEGER` automatically, so the awaited
-content renders where it belongs. Pin the budget yourself (in either
+render and the `ppr` shell capture raise the budget to `MAX_SAFE_INTEGER`
+automatically, so the awaited content renders where it belongs, on a shell
+HIT too. Pin the budget yourself (in either
 direction) with `rango({ progressiveChunkSize })` in the Vite config — an
 explicit value disables the auto-raise. Boundaries hoisting stylesheets
 still outline; their reveal must wait for the CSS.
@@ -1160,9 +1161,7 @@ The costs and constraints:
   served from the shell and does not run (unless the capture marked it to run:
   see `/ppr` → On a shell HIT); one whose return carries promises
   runs on every HIT, with its baked parts overlaid. A `cookies()`, `headers()`,
-  `ctx.request.headers` or `{ cache: false }` read in it refuses the capture. The
-  `progressiveChunkSize` auto-raise is live-document only; captured shells
-  outline per the explicit option or React's default.
+  `ctx.request.headers` or `{ cache: false }` read in it refuses the capture.
 
 Also available in `clientUrls()` route groups (`/client-urls`), where the
 loader-heavy shape makes it most useful.

package/skills/react-compiler/SKILL.md

@@ -122,9 +122,10 @@ options (`logger`, function-valued `sources`) do not exist on the native path;
 
 Nothing to configure. Rango's discovery/prerender step runs a throwaway temp Vite
 server (`createTempRscServer`) that forwards only your **resolution** plugins
-(`resolveId` / `load`) and denies every `vite:*` plugin, so `vite:react-compiler`
-never runs there. That is correct: the temp runner only produces **data**
-(serialized Flight payloads + the route manifest), not shipped code, and React
+(`resolveId` / `load`, plus the import rewrite of
+`@rolldown/plugin-transform-imports`) and denies every `vite:*` plugin, so
+`vite:react-compiler` never runs there. That is correct: the temp runner only
+produces **data** (serialized Flight payloads + the route manifest), not shipped code, and React
 Compiler is a memoization-only transform that does not change rendered output.
 Your shipped client bundle is compiled by the `react({ compiler: true })` in your
 app's own plugin array.

package/src/browser/document-flight-stream.ts

@@ -0,0 +1,53 @@
+type FlightChunk = string | Uint8Array;
+
+/** Where the document's inline scripts push Flight chunks (`self`). */
+export interface FlightDataHost {
+  __FLIGHT_DATA?: FlightChunk[];
+}
+
+/**
+ * The document's Flight payload as a stream: the server's inline scripts push
+ * chunks onto `self.__FLIGHT_DATA` (rsc-html-stream/server, or
+ * ssr/inject-rsc-eager.ts), and the browser's own DOMContentLoaded
+ * (`isTrusted`) closes it after the last of them ran. rsc-html-stream/client
+ * closed on any DOMContentLoaded, so a script re-dispatching the event cut a
+ * streaming page short and threw after the load (#1205).
+ */
+export function createDocumentFlightStream(
+  doc: Pick<
+    Document,
+    "readyState" | "addEventListener" | "removeEventListener"
+  >,
+  host: FlightDataHost,
+): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder();
+  let controller!: ReadableStreamDefaultController<Uint8Array>;
+  const stream = new ReadableStream<Uint8Array>({
+    start(c) {
+      controller = c;
+    },
+  });
+  const enqueue = (chunk: FlightChunk): void => {
+    controller.enqueue(
+      typeof chunk === "string" ? encoder.encode(chunk) : chunk,
+    );
+  };
+  const data = (host.__FLIGHT_DATA ||= []);
+  data.forEach(enqueue);
+  data.push = (...chunks: FlightChunk[]): number => {
+    chunks.forEach(enqueue);
+    return data.length;
+  };
+
+  if (doc.readyState !== "loading") {
+    controller.close();
+  } else {
+    const onLoaded = (event: Event): void => {
+      if (!event.isTrusted) return;
+      doc.removeEventListener("DOMContentLoaded", onLoaded);
+      controller.close();
+    };
+    doc.addEventListener("DOMContentLoaded", onLoaded);
+  }
+  return stream;
+}

package/src/browser/rsc-router.tsx

@@ -59,7 +59,8 @@ import { setActiveInterceptTargets } from "../client-urls/navigation.js";
  */
 export interface InitBrowserAppOptions {
   /**
-   * RSC stream containing the initial payload (from rsc-html-stream/client)
+   * RSC stream containing the initial payload
+   * (`@rangojs/router/internal/deps/html-stream-client`)
    */
   rscStream: ReadableStream<Uint8Array>;
 
@@ -697,7 +698,7 @@ export interface RangoProps {}
  * @example
  * ```tsx
  * import { initBrowserApp, Rango } from "@rangojs/router/browser";
- * import { rscStream } from "rsc-html-stream/client";
+ * import { rscStream } from "@rangojs/router/internal/deps/html-stream-client";
  * import * as rscBrowser from "@vitejs/plugin-rsc/browser";
  *
  * async function main() {

package/src/deps/html-stream-client.ts

@@ -1,2 +1,11 @@
-// Re-export rsc-html-stream/client for internal use by virtual entries
-export { rscStream } from "rsc-html-stream/client";
+// The document's Flight stream for the generated browser entry. Outside a
+// browser it stays empty and open, as rsc-html-stream/client's did.
+import {
+  createDocumentFlightStream,
+  type FlightDataHost,
+} from "../browser/document-flight-stream.js";
+
+export const rscStream: ReadableStream<Uint8Array> =
+  typeof document === "undefined"
+    ? new ReadableStream<Uint8Array>()
+    : createDocumentFlightStream(document, self as FlightDataHost);

package/src/router/dev-reload-handoff.ts

@@ -45,6 +45,43 @@ export function droppedByRunnerReload(): boolean {
   return runnerReloaded;
 }
 
+type Serve = () => Promise<Response>;
+
+/**
+ * Serves a request on this router copy, or on the router a runner full reload
+ * re-created when the reload dropped this copy before the request or while it
+ * ran. What a request imports after the clear is the fresh copy, so one the
+ * reload lands inside fails or answers the wrong route: its outcome is
+ * discarded. Only GET and HEAD re-run, since a re-run repeats side effects and
+ * cannot re-read a body. A reload after the response is returned still splits
+ * its stream.
+ * @internal
+ */
+export async function serveAcrossRunnerReload(
+  request: Request,
+  serve: Serve,
+  recreated: () => Promise<Serve | undefined>,
+): Promise<Response> {
+  if (runnerReloaded) {
+    const rerun = await recreated();
+    return (rerun ?? serve)();
+  }
+  if (request.method !== "GET" && request.method !== "HEAD") return serve();
+  const settled = await serve().then(
+    (response) => ({ response }),
+    (error: unknown) => ({ error }),
+  );
+  const rerun = runnerReloaded ? await recreated() : undefined;
+  if (rerun) {
+    if ("response" in settled) {
+      void settled.response.body?.cancel().catch(() => {});
+    }
+    return rerun();
+  }
+  if ("error" in settled) throw settled.error;
+  return settled.response;
+}
+
 /**
  * The router the reload re-created for `routerId`, or undefined when none
  * registered within DEV_RECREATED_ROUTER_WAIT_MS. Importing `sourceFile`

package/src/router.ts

@@ -134,8 +134,8 @@ import {
   resolvePrefetchConcurrency,
 } from "./router/prefetch-limits.js";
 import {
-  droppedByRunnerReload,
   routerAfterRunnerReload,
+  serveAcrossRunnerReload,
 } from "./router/dev-reload-handoff.js";
 
 // Re-export public types and values from extracted modules
@@ -1293,18 +1293,30 @@ export function createRouter<TEnv = any>(
           });
         }
 
-        // Dev: a runner full reload dropped this router's module copy
-        // (router/dev-reload-handoff.ts, #1186).
-        if (process.env.NODE_ENV !== "production" && droppedByRunnerReload()) {
-          const reloaded = await routerAfterRunnerReload(
-            routerId,
-            __sourceFile,
+        // Dev: a runner full reload can drop this router's module copy before
+        // or during the request (router/dev-reload-handoff.ts, #1186).
+        if (process.env.NODE_ENV !== "production") {
+          return serveAcrossRunnerReload(
+            request,
+            () => serve(request, input),
+            async () => {
+              const reloaded = await routerAfterRunnerReload(
+                routerId,
+                __sourceFile,
+              );
+              return reloaded && reloaded !== router
+                ? () => reloaded.fetch(request, input)
+                : undefined;
+            },
           );
-          if (reloaded && reloaded !== router) {
-            return reloaded.fetch(request, input);
-          }
         }
+        return serve(request, input);
+      };
 
+      async function serve(
+        request: Request,
+        input: RouterRequestInput<TEnv>,
+      ): Promise<Response> {
         // Trigger lazy import of per-router manifest data before route matching.
         // No-op if data is already loaded or no loader is registered.
         await ensureRouterManifest(routerId);
@@ -1325,7 +1337,7 @@ export function createRouter<TEnv = any>(
           ) => Promise<Response>;
         }
         return handler!(request, input);
-      };
+      }
     })(),
 
     // Low-level route matching for request classification

package/src/ssr/index.tsx

@@ -230,13 +230,15 @@ export interface SSRDependencies<TEnv = unknown> {
    * the `rango({ progressiveChunkSize })` plugin option here (canonical docs
    * on `RangoBaseOptions.progressiveChunkSize` in vite/plugin-types.ts).
    *
-   * When UNSET, createSSRHandler auto-raises to Number.MAX_SAFE_INTEGER for
-   * document renders whose matched chain has a `loader(Def, { ssr: false })`
-   * entry (payload segments carry `awaitBeforeFlush`): the loader was awaited
-   * before first flush precisely so its content ships in-place, and React
-   * 19.2's Fizz would otherwise move any completed boundary over ~500 bytes
-   * to an end-of-stream `<div hidden>` + $RC reveal once the shell saturates
-   * the default 12800 budget. An explicit value disables the auto-raise.
+   * When UNSET, createSSRHandler and createShellCaptureHandler auto-raise to
+   * Number.MAX_SAFE_INTEGER for document renders and shell captures whose
+   * matched chain has a `loader(Def, { ssr: false })` entry (payload segments
+   * carry `awaitBeforeFlush`): the loader was awaited before first flush
+   * precisely so its content ships in-place, and React 19.2's Fizz would
+   * otherwise move any completed boundary over ~500 bytes to an end-of-stream
+   * `<div hidden>` + $RC reveal once the shell saturates the default 12800
+   * budget. A shell HIT inherits the raise (prelude and resumed holes), so it
+   * matches the live render. An explicit value disables the auto-raise.
    */
   progressiveChunkSize?: number;
 
@@ -448,6 +450,18 @@ function hasAwaitBeforeFlush(payload: {
   return payload.metadata?.segments?.some((s) => s.awaitBeforeFlush) === true;
 }
 
+/**
+ * The progressiveChunkSize renderHTML and captureShellHTML pass to Fizz (see
+ * SSRDependencies.progressiveChunkSize): the explicit option, else the
+ * ssr:false auto-raise.
+ */
+function documentChunkSize(
+  explicit: number | undefined,
+  awaitsBeforeFlush: boolean,
+): number | undefined {
+  return explicit ?? (awaitsBeforeFlush ? Number.MAX_SAFE_INTEGER : undefined);
+}
+
 /**
  * ssr: false documents only: before the first flush, give Fizz the turns a
  * task waiting on an already-settling thenable needs, so a boundary that
@@ -955,9 +969,10 @@ export function createSSRHandler<TEnv = unknown>(deps: SSRDependencies<TEnv>) {
         themeConfig: decoded.metadata?.themeConfig ?? null,
       };
       const awaitsBeforeFlush = hasAwaitBeforeFlush(decoded);
-      const progressiveChunkSize =
-        deps.progressiveChunkSize ??
-        (awaitsBeforeFlush ? Number.MAX_SAFE_INTEGER : undefined);
+      const progressiveChunkSize = documentChunkSize(
+        deps.progressiveChunkSize,
+        awaitsBeforeFlush,
+      );
 
       // Render React tree to HTML stream
       // Pass formState for useActionState progressive enhancement if provided
@@ -1110,9 +1125,23 @@ export function createShellCaptureHandler<TEnv = unknown>(
       const payloadSettled = new Promise<void>((resolve) => {
         settlePayload = resolve;
       });
+      // Bootstrap resolution raced against the deadline (see resolveBootstrap):
+      // null means the deadline won — the bounded no-shell degrade.
+      const bootstrap = await resolveBootstrap(deps, deadline.promise);
+      if (bootstrap === null) {
+        return null;
+      }
+
+      // Decoded after the bootstrap, as SsrRoot's first render used to, so
+      // the capture gate's quiet clock starts only once fizz is about to.
+      const payload = deserializeSsrPayload(
+        createFromReadableStream,
+        rscStream,
+      );
       const SsrRoot = createSsrRootComponent({
         createFromReadableStream,
         rscStream,
+        payload,
         onPayloadSettled: settlePayload,
         // The shell key's own search: static-part search reads render what
         // the key names, and the resume pass seeds the identical string.
@@ -1120,12 +1149,17 @@ export function createShellCaptureHandler<TEnv = unknown>(
         origin: opts.origin,
       });
 
-      // Bootstrap resolution raced against the deadline (see resolveBootstrap):
-      // null means the deadline won — the bounded no-shell degrade.
-      const bootstrap = await resolveBootstrap(deps, deadline.promise);
-      if (bootstrap === null) {
-        return null;
-      }
+      // ssr:false auto-raise (SSRDependencies.progressiveChunkSize); resume()
+      // inherits it from the postponed state. A rejected or late payload
+      // skips it and fails or degrades below as before.
+      const awaitsBeforeFlush = await Promise.race([
+        payload.then(hasAwaitBeforeFlush, () => false),
+        deadline.promise.then(() => false),
+      ]);
+      const progressiveChunkSize = documentChunkSize(
+        deps.progressiveChunkSize,
+        awaitsBeforeFlush,
+      );
 
       // Start prerender first, then run the abort schedule concurrently. When
       // holes are pending, prerender's promise settles only after abort(); when
@@ -1140,14 +1174,7 @@ export function createShellCaptureHandler<TEnv = unknown>(
       const prerenderPromise = prerender(<SsrRoot />, {
         signal: controller.signal,
         ...bootstrap,
-        // Explicit option only — the ssr:false auto-raise is live-SSR scoped
-        // (RangoBaseOptions.progressiveChunkSize documents the contract); the
-        // capture handler starts prerender without deserializing the payload,
-        // so segment metadata is not read here. The captured value rides the
-        // postponed state into every later resume().
-        ...(deps.progressiveChunkSize !== undefined && {
-          progressiveChunkSize: deps.progressiveChunkSize,
-        }),
+        ...(progressiveChunkSize !== undefined && { progressiveChunkSize }),
         // Abort is how capture WORKS: once the shell is quiet we abort() to
         // freeze the prelude and let the still-pending holes postpone. React
         // reports the abort reason for each pending boundary through onError.

package/src/ssr/ssr-root.tsx

@@ -147,11 +147,11 @@ function createSsrEventController(opts: {
 
 /**
  * Deserialize the Flight stream branch into the payload SsrRoot renders,
- * fragment expansion included. Factored out of SsrRoot so createSSRHandler can
- * create the promise BEFORE fizz starts and read metadata that must influence
- * the fizz call itself (the ssr:false progressiveChunkSize auto-raise) —
- * awaiting it there is latency-neutral because fizz cannot emit even <html>
- * until this same promise settles.
+ * fragment expansion included. Factored out of SsrRoot so createSSRHandler and
+ * createShellCaptureHandler can create the promise BEFORE fizz starts and read
+ * metadata that must influence the fizz call itself (the ssr:false
+ * progressiveChunkSize auto-raise) — awaiting it there is latency-neutral
+ * because fizz cannot emit even <html> until this same promise settles.
  */
 export function deserializeSsrPayload(
   createFromReadableStream: CreateFromReadableStream,

package/src/vite/discovery/shell-prerender-phase.ts

@@ -187,7 +187,8 @@ export async function runShellPrerenderPhase(
       prerender: reactDomStatic.prerender ?? reactDomStatic.default?.prerender,
       injectRSCPayload: htmlStream.injectRSCPayload,
       headScripts: "preinit",
-      // Build-captured shells must honor the explicit outlining budget: the
+      // Build-captured shells honor the explicit outlining budget, or the
+      // ssr:false auto-raise without one (createShellCaptureHandler): the
       // capture value rides the postponed state into every runtime resume().
       ...(s.opts?.progressiveChunkSize !== undefined && {
         progressiveChunkSize: s.opts.progressiveChunkSize,

package/src/vite/discovery/state.ts

@@ -135,9 +135,10 @@ export interface DiscoveryState {
     | import("../utils/forward-user-plugins.js").ForwardedRunnerConfig
     | undefined;
   /**
-   * User resolution plugins (resolveId/load), stripped to their resolution
-   * surface, forwarded into the discovery temp server. Lets third-party
-   * resolvers such as vite-tsconfig-paths participate in discovery.
+   * User resolution plugins (resolveId/load, plus import rewriters' transform),
+   * stripped to their resolution surface, forwarded into the discovery temp
+   * server. Lets third-party resolvers such as vite-tsconfig-paths participate
+   * in discovery.
    */
   userResolvePlugins: import("vite").Plugin[];
   scanFilter: ScanFilter | undefined;

package/src/vite/plugin-types.ts

@@ -189,12 +189,12 @@ interface RangoBaseOptions {
    * the CSS. Trade-off: inline content delays later shell bytes behind it,
    * which is why React outlines by default.
    *
-   * When UNSET, document renders whose matched chain has a
-   * `loader(Def, { ssr: false })` entry auto-raise to MAX_SAFE_INTEGER — the
-   * loader was awaited before first flush precisely so its content ships
-   * in-place, and outlining the boundary it feeds would defeat that. Setting
-   * an explicit value disables the auto-raise. The auto-raise is live-SSR
-   * only; captured shells use the explicit value or React's default.
+   * When UNSET, document renders and PPR shell captures whose matched chain
+   * has a `loader(Def, { ssr: false })` entry auto-raise to MAX_SAFE_INTEGER —
+   * the loader was awaited before first flush precisely so its content ships
+   * in-place, and outlining the boundary it feeds would defeat that. A shell
+   * HIT inherits the captured value, so it matches the live render. Setting
+   * an explicit value disables the auto-raise.
    *
    * Apps with a custom SSR entry set this per-handler via
    * `SSRDependencies.progressiveChunkSize`.

package/src/vite/rango.ts

@@ -234,7 +234,6 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
                 },
               },
               optimizeDeps: {
-                include: [nested("rsc-html-stream/client")],
                 exclude: excludeDeps,
                 rolldownOptions: sharedRolldownOptions,
               },
@@ -457,7 +456,6 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
                   "react-dom",
                   "react/jsx-runtime",
                   "react/jsx-dev-runtime",
-                  nested("rsc-html-stream/client"),
                 ],
                 exclude: excludeDeps,
                 rolldownOptions: sharedRolldownOptions,

package/src/vite/router-discovery.ts

@@ -350,7 +350,8 @@ export async function createTempRscServer(
         },
       },
       // Forwarded user resolution plugins (e.g. vite-tsconfig-paths). Stripped
-      // to resolveId/load and placed last so framework resolution runs first;
+      // to resolveId/load (plus transform for import rewriters, see
+      // IMPORT_REWRITE_PLUGINS) and placed last so framework resolution runs first;
       // Vite re-sorts by `enforce`, so `enforce: "pre"` resolvers still lead.
       ...state.userResolvePlugins,
     ],
@@ -592,8 +593,9 @@ export function createRouterDiscoveryPlugin(
       // Capture user's resolve aliases for the temp server
       s.userResolveAlias = config.resolve.alias;
       // Capture the data-only resolution config (resolve.*, define, oxc) and
-      // the user's resolution plugins (resolveId/load) so the discovery temp
-      // server resolves modules the same way the real environment does.
+      // the user's resolution plugins (resolveId/load, plus import rewriters'
+      // transform) so the discovery temp server resolves modules the same way
+      // the real environment does.
       // Without this, both flavors of user resolution are absent during
       // discovery/prerender/static rendering even though they apply at request
       // time: third-party resolvers (e.g. vite-tsconfig-paths, forwarded as

package/src/vite/utils/forward-user-plugins.ts

@@ -37,18 +37,39 @@ function isDenied(name: string): boolean {
 }
 
 /**
- * A plugin participates in resolution if it exposes `resolveId` or `load`.
- * Plugins that only transform, configure the server, or hook into the build
- * lifecycle do not affect how bare specifiers resolve, so we skip them to keep
+ * Transform-only plugins forwarded with their `transform` hook. A plugin
+ * belongs here only if its transform changes the code or imports discovery
+ * evaluates, and reads only state built at construction or in
+ * `config`/`configResolved`. Neither shows in a hook's shape, so the list is
+ * by name: forwarding every transform would let e.g. @tailwindcss/vite cache
+ * per-environment state built from the temp server's config.
+ *
+ * `rolldown-plugin-transform-imports` (@rolldown/plugin-transform-imports)
+ * rewrites barrel imports to subpaths (vitejs/vite-plugin-react#1519). Dropped,
+ * discovery loads the whole barrel and fails on a leaf importing `client-only`.
+ */
+const IMPORT_REWRITE_PLUGINS: ReadonlySet<string> = new Set([
+  "rolldown-plugin-transform-imports",
+]);
+
+/**
+ * A plugin participates in resolution if it exposes `resolveId` or `load`, or
+ * rewrites imports (IMPORT_REWRITE_PLUGINS). Other plugins that only transform,
+ * configure the server, or hook into the build lifecycle are skipped to keep
  * the forwarded surface minimal.
  */
-function hasResolutionHooks(p: Plugin): boolean {
-  return Boolean((p as any).resolveId || (p as any).load);
+function isForwardable(p: Plugin): boolean {
+  return Boolean(
+    (p as any).resolveId ||
+    (p as any).load ||
+    IMPORT_REWRITE_PLUGINS.has(p.name),
+  );
 }
 
 /**
- * Strip a resolved plugin instance down to its resolution hooks plus the
- * gating fields that decide whether/where it runs.
+ * Strip a resolved plugin instance down to its resolution hooks (and an import
+ * rewriter's `transform`) plus the gating fields that decide whether/where it
+ * runs.
  *
  * We reuse the SAME instance objects captured from `config.plugins`. By the
  * time `configResolved` fires on the discovery plugin, every plugin's own
@@ -78,6 +99,8 @@ function stripToResolutionHooks(p: Plugin): Plugin {
     (stripped as any).applyToEnvironment = (p as any).applyToEnvironment;
   if ((p as any).resolveId) (stripped as any).resolveId = (p as any).resolveId;
   if ((p as any).load) (stripped as any).load = (p as any).load;
+  if (IMPORT_REWRITE_PLUGINS.has(p.name))
+    (stripped as any).transform = (p as any).transform;
   return stripped;
 }
 
@@ -95,7 +118,7 @@ export function selectForwardableResolvePlugins(
   for (const p of plugins) {
     const name = p?.name;
     if (!name || isDenied(name)) continue;
-    if (!hasResolutionHooks(p)) continue;
+    if (!isForwardable(p)) continue;
     forwarded.push(stripToResolutionHooks(p));
   }
   return forwarded;