@rangojs/router 0.20.0 → 0.22.0

package/src/vite/plugins/expose-ids/router-transform.ts

@@ -8,10 +8,11 @@ import {
   findCallParenAfterGenerics,
   skipStringOrComment,
 } from "../expose-id-utils.js";
-import { escapeRegExp } from "../../../regex-escape.js";
 import {
   getImportedFnNames,
   buildUnsupportedShapeWarning,
+  createCallPattern,
+  offsetToLineColumn,
 } from "./export-analysis.js";
 import { codeMatchIndices } from "../../../build/route-types/source-scan.js";
 import { createRangoDebugger, createCounter, NS } from "../../debug.js";
@@ -42,6 +43,26 @@ function skipLeadingTrivia(code: string, start: number, end: number): number {
   return i;
 }
 
+/**
+ * A router's `$$id`: a hash of its root-relative file and of its position
+ * among the file's createRouter() calls.
+ *
+ * Not of the call's line. `code` is TS-transformed, and a dev server keeps
+ * comments there that a build drops, so a line of `code` gave build-time
+ * discovery and the bundle different ids for any router with a comment above
+ * it (e2e/test-app, tests/cloudflare-basic): the build registered the lazy
+ * route manifest under an id no running router had. And a line of the file as
+ * written changes with every blank line or comment added above the call,
+ * which renamed the state cookie, the route manifest chunk and the router's
+ * cache versions for an edit that changed nothing.
+ */
+export function routerId(filePath: string, callIndex: number): string {
+  return createHash("sha256")
+    .update(`${filePath}#${callIndex}`)
+    .digest("hex")
+    .slice(0, 8);
+}
+
 export function transformRouter(
   code: string,
   filePath: string,
@@ -53,14 +74,12 @@ export function transformRouter(
   // e.g. createRouter<Config<Env>>(...)) and the opening paren are located
   // separately via findCallParenAfterGenerics so a nested `>` does not defeat
   // the scan (a `<[^>]*>` regex stopped at the first `>`).
-  const pat = new RegExp(
-    `\\b(?:${routerFnNames.map(escapeRegExp).join("|")})\\b`,
-    "g",
-  );
+  const pat = createCallPattern(routerFnNames);
   let match: RegExpExecArray | null;
   const s = new MagicString(code);
   let changed = false;
   const unsupportedSites: Array<{ line: number; column: number }> = [];
+  let callIndex = -1;
 
   // Compute the import path for the generated route names file.
   // filePath is relative to project root (e.g., "src/router.tsx")
@@ -86,6 +105,7 @@ export function transformRouter(
     // type position) yields -1 and is skipped.
     const parenPos = findCallParenAfterGenerics(code, calleeEnd);
     if (parenPos === -1) continue;
+    callIndex++;
 
     const closeParen = findMatchingParen(code, parenPos + 1);
     const callArgs = code.slice(parenPos + 1, closeParen);
@@ -98,12 +118,7 @@ export function transformRouter(
     if (callArgs.includes(`$$routeNames: ${routeNamesVar}`)) continue;
 
     const sourceFilePath = absolutePath ?? filePath;
-    const lineNumber = code.slice(0, callStart).split("\n").length;
-    const hash = createHash("sha256")
-      .update(`${filePath}:${lineNumber}`)
-      .digest("hex")
-      .slice(0, 8);
-    const injected = ` $$id: "${hash}", $$sourceFile: "${sourceFilePath}", $$routeNames: ${routeNamesVar},`;
+    const injected = ` $$id: "${routerId(filePath, callIndex)}", $$sourceFile: "${sourceFilePath}", $$routeNames: ${routeNamesVar},`;
 
     // Skip a leading comment/whitespace run so `createRouter(/* c *\/ {...})`
     // and a newline-then-comment prefix still resolve to the object literal.
@@ -124,9 +139,7 @@ export function transformRouter(
       // stable $$id can be injected here. Record it so the plugin can warn —
       // and crucially do NOT mark changed, so a dead named-routes.gen import is
       // not prepended for a call we never touched.
-      const lastNl = code.lastIndexOf("\n", callStart - 1);
-      const column = callStart - (lastNl + 1) + 1;
-      unsupportedSites.push({ line: lineNumber, column });
+      unsupportedSites.push(offsetToLineColumn(code, callStart));
     }
   }
 
@@ -156,11 +169,19 @@ export function transformRouter(
  */
 export function exposeRouterId(): Plugin {
   let projectRoot = "";
+  // $$sourceFile is read by route discovery and the CLI, which run on a dev
+  // server (the build's discovery temp server included) and need the absolute
+  // path. Nothing reads it when serving, so a production build ships the
+  // root-relative path: an absolute one would put the build machine's checkout
+  // directory in every router's chunk and give the same source a different
+  // cache version per directory (discovery/build-versions.ts hashes the chunk).
+  let rootRelativeSourceFile = false;
   const counter = createCounter(debug, "expose-router-id");
   return {
     name: "@rangojs/router:expose-router-id",
     configResolved(config) {
       projectRoot = config.root;
+      rootRelativeSourceFile = config.command === "build";
     },
     buildEnd() {
       counter?.flush();
@@ -188,7 +209,7 @@ export function exposeRouterId(): Plugin {
           code,
           filePath,
           routerFnNames,
-          normalizePath(id),
+          rootRelativeSourceFile ? undefined : normalizePath(id),
           warn,
         );
       } finally {

package/src/vite/plugins/expose-internal-ids.ts

@@ -45,6 +45,8 @@ import {
   transformHandlerIds,
 } from "./expose-ids/handler-transform.js";
 import { createRangoDebugger, createCounter, NS } from "../debug.js";
+import { compareStrings } from "../utils/compare-strings.js";
+import { VIRTUAL_LOADER_MANIFEST_ID } from "../discovery/state.js";
 
 const debug = createRangoDebugger(NS.transform);
 
@@ -56,7 +58,7 @@ export type { ExposeInternalIdsApi } from "./expose-ids/types.js";
 // Virtual module for loader manifest
 // ---------------------------------------------------------------------------
 
-const VIRTUAL_LOADER_MANIFEST = "virtual:rsc-router/loader-manifest";
+const VIRTUAL_LOADER_MANIFEST = VIRTUAL_LOADER_MANIFEST_ID;
 const RESOLVED_VIRTUAL_LOADER_MANIFEST = "\0" + VIRTUAL_LOADER_MANIFEST;
 
 // ---------------------------------------------------------------------------
@@ -245,10 +247,17 @@ setLoaderImports({});
 `;
       }
 
-      // Build mode: generate lazy import map
+      // Build mode: generate lazy import map. Sorted by id: the registry fills
+      // in directory-scan order (the pre-scan below) and transform order, both
+      // of which vary between machines and runs, and this module's bytes feed
+      // the cache version of every router bundled with it
+      // (discovery/build-versions.ts).
       const lazyImports: string[] = [];
+      const sortedLoaders = [...loaderRegistry].sort(([a], [b]) =>
+        compareStrings(a, b),
+      );
 
-      for (const [hashedId, { filePath, exportName }] of loaderRegistry) {
+      for (const [hashedId, { filePath, exportName }] of sortedLoaders) {
         lazyImports.push(
           `  "${hashedId}": () => import("/${filePath}").then(m => m.${exportName})`,
         );

package/src/vite/plugins/stable-rsc-output.ts

@@ -0,0 +1,147 @@
+import { parseAst, type Plugin } from "vite";
+import { escapeRegExp } from "../../regex-escape.js";
+import { compareStrings } from "../utils/compare-strings.js";
+import { SERVER_REFERENCES_MODULE_ID } from "../discovery/build-versions.js";
+
+/** One property of an object literal, by its position in the source. */
+export interface LiteralProperty {
+  readonly key: string;
+  /** Range of the whole property, key included. */
+  readonly start: number;
+  readonly end: number;
+  /** The value's AST node. */
+  readonly value: any;
+}
+
+/**
+ * The properties of an object-literal AST node, or undefined when it is not an
+ * object literal of plain keys (a spread, a computed key).
+ */
+export function literalProperties(object: any): LiteralProperty[] | undefined {
+  if (object?.type !== "ObjectExpression") return undefined;
+  const properties: LiteralProperty[] = [];
+  for (const property of object.properties ?? []) {
+    const key =
+      property?.type === "Property" && !property.computed
+        ? (property.key?.value ?? property.key?.name)
+        : undefined;
+    if (typeof key !== "string") return undefined;
+    properties.push({
+      key,
+      start: property.start,
+      end: property.end,
+      value: property.value,
+    });
+  }
+  return properties;
+}
+
+/**
+ * The properties of a module's `export default { ... }`, or undefined when
+ * the module does not parse or is not that shape. plugin-rsc generates its
+ * registries (the server-reference map, the assets manifest) in this form.
+ */
+export function defaultExportProperties(
+  code: string,
+): LiteralProperty[] | undefined {
+  let program: any;
+  try {
+    program = parseAst(code);
+  } catch {
+    return undefined;
+  }
+  return literalProperties(
+    (program.body ?? []).find(
+      (node: any) => node?.type === "ExportDefaultDeclaration",
+    )?.declaration,
+  );
+}
+
+/**
+ * Return `code` with the properties of its default-exported object literal
+ * sorted by key, or undefined when there is nothing to reorder (or the module
+ * is not that shape).
+ */
+export function sortDefaultExportProperties(code: string): string | undefined {
+  const properties = defaultExportProperties(code);
+  if (!properties || properties.length < 2) return undefined;
+  const sorted = [...properties].sort((a, b) => compareStrings(a.key, b.key));
+  if (sorted.every((property, index) => property === properties[index])) {
+    return undefined;
+  }
+  return (
+    code.slice(0, properties[0]!.start) +
+    sorted
+      .map((property) => code.slice(property.start, property.end))
+      .join(",\n") +
+    code.slice(properties[properties.length - 1]!.end)
+  );
+}
+
+const ASSETS_MANIFEST_ID = "virtual:vite-rsc/assets-manifest";
+const ASSETS_MANIFEST_IMPORT =
+  /import\s+([A-Za-z_$][\w$]*)\s+from\s*["']virtual:vite-rsc\/assets-manifest["']/;
+/** The local name plugin-rsc's own runtime modules import the manifest under. */
+const ASSETS_MANIFEST_BINDING = "assetsManifest";
+/**
+ * The names plugin-rsc's GENERATED code imports it under. Only these are
+ * renamed: the rename is textual, and a name an app author picked
+ * (`import manifest from ...`) can also be a word in that module's strings.
+ */
+const GENERATED_BINDINGS: ReadonlySet<string> = new Set([
+  "__vite_rsc_assets_manifest__",
+  "__vite_rsc_assets_manifest",
+]);
+
+function identifier(name: string): RegExp {
+  return new RegExp(`(?<![\\w$.])${escapeRegExp(name)}(?![\\w$])`, "g");
+}
+
+/**
+ * Return `code` with its default import of plugin-rsc's assets manifest
+ * renamed to {@link ASSETS_MANIFEST_BINDING}, or undefined when there is
+ * nothing to rename (no such import under a generated name, or the module
+ * uses the canonical name for something else).
+ */
+export function canonicalAssetsManifestBinding(
+  code: string,
+): string | undefined {
+  const local = code.match(ASSETS_MANIFEST_IMPORT)?.[1];
+  if (local === undefined || !GENERATED_BINDINGS.has(local)) return undefined;
+  if (identifier(ASSETS_MANIFEST_BINDING).test(code)) return undefined;
+  return code.replace(identifier(local), ASSETS_MANIFEST_BINDING);
+}
+
+/**
+ * Removes two run-to-run differences from plugin-rsc 0.5.35's build output.
+ * The cache versions hash these bytes (discovery/build-versions.ts).
+ *
+ * 1. Property order of the server-reference map. plugin-rsc writes it in the
+ *    order its transforms first saw each `"use server"` module
+ *    (`ServerReferencesManager.claimMap`), which varies with the concurrent
+ *    scan builds (e2e/test-app: 2 of 2 consecutive builds differed). Sorted
+ *    here so a minified server build, where stripServerReferenceMap finds no
+ *    region comments, still hashes the same bytes.
+ * 2. Local name of the assets-manifest import. plugin-rsc imports the manifest
+ *    under three names; the bundler merges them into one import per chunk and
+ *    keeps a different one from build to build (the cache-versions fixture:
+ *    1 of 10 concurrent builds). One name in, one name out.
+ * @internal
+ */
+export function stableRscOutput(): Plugin {
+  return {
+    name: "@rangojs/router:stable-rsc-output",
+    apply: "build",
+    // After plugin-rsc's transforms, which add the manifest import.
+    enforce: "post",
+    transform(code, id) {
+      const stable =
+        id === SERVER_REFERENCES_MODULE_ID
+          ? sortDefaultExportProperties(code)
+          : code.includes(ASSETS_MANIFEST_ID)
+            ? canonicalAssetsManifestBinding(code)
+            : undefined;
+      return stable === undefined ? null : { code: stable, map: null };
+    },
+  };
+}

package/src/vite/plugins/version-plugin.ts

@@ -1,5 +1,9 @@
 import { parseAst, type Plugin } from "vite";
-import { VIRTUAL_IDS, getVirtualVersionContent } from "./virtual-entries.js";
+import {
+  VIRTUAL_IDS,
+  getVirtualBuildVersionContent,
+  getVirtualVersionContent,
+} from "./virtual-entries.js";
 import { hasUseClientDirective } from "../utils/directive-prologue.js";
 
 interface ClientModuleSignature {
@@ -100,25 +104,22 @@ function getClientModuleSignature(
 }
 
 /**
- * Plugin providing rsc-router:version virtual module.
- * Exports VERSION that changes when RSC modules change (dev) or at build time (production).
+ * Plugin providing the `@rangojs/router:version` virtual module.
  *
- * The version is used for:
- * 1. Cache invalidation - CFCacheStore uses VERSION to invalidate stale cache
- * 2. Version mismatch detection - client sends version, server reloads on mismatch
+ * Dev: exports a VERSION stamp used for both versions of every router. It
+ * updates when the server starts and when an RSC module changes via HMR (the
+ * version module is invalidated). Client-only HMR changes do not update it:
+ * they do not affect server-rendered content or cached RSC payloads.
  *
- * In dev mode, the version updates when:
- * - Server starts (initial version)
- * - RSC modules change via HMR (triggers version module invalidation)
- *
- * Client-only HMR changes don't update the version since they don't affect
- * server-rendered content or cached RSC payloads.
+ * Build: exports a placeholder for the per-router versions table. The module
+ * holds nothing that varies between builds; the table is written into the
+ * built chunk after the server output is hashed (the buildApp post hook in
+ * router-discovery.ts). See docs/design/per-app-cache-version.md.
  * @internal
  */
 export function createVersionPlugin(): Plugin {
-  // Generate version at plugin creation time (build/server start)
-  const buildVersion = Date.now().toString(16);
-  let currentVersion = buildVersion;
+  // Dev stamp, generated at plugin creation (server start).
+  let currentVersion = Date.now().toString(16);
   let isDev = false;
   let server: any = null;
   let resolvedCacheDir: string | undefined;
@@ -142,14 +143,6 @@ export function createVersionPlugin(): Plugin {
     name: "@rangojs/router:version",
     enforce: "pre",
 
-    // The build-time shell capture phase (producer B, #699) stamps entries
-    // with THIS instance's version — the value folded into the shipped worker
-    // — never the discovery temp server's own version-plugin value (a
-    // different Date.now() stamp that would fail the serve-side gate).
-    api: {
-      getBuildVersion: (): string => currentVersion,
-    },
-
     configResolved(config) {
       isDev = config.command === "serve";
       resolvedCacheDir = config.cacheDir
@@ -177,7 +170,9 @@ export function createVersionPlugin(): Plugin {
 
     load(id) {
       if (id === "\0" + VIRTUAL_IDS.version) {
-        return getVirtualVersionContent(currentVersion);
+        return isDev
+          ? getVirtualVersionContent(currentVersion)
+          : getVirtualBuildVersionContent();
       }
       return null;
     },

package/src/vite/plugins/version.d.ts

@@ -5,8 +5,23 @@
 
 declare module "@rangojs/router:version" {
   /**
-   * Auto-generated version string for cache invalidation.
-   * Changes on server restart (dev) or build (prod).
+   * The build's version string.
+   *
+   * - Dev: a stamp that changes on server start and on every RSC module edit.
+   * - Production: the whole-build document version, a hash of the server
+   *   output and the client asset names. The same source builds to the same
+   *   value; any change to any router changes it.
+   *
+   * A router serves with its own versions (`ROUTER_VERSIONS`), not this one.
    */
   export const VERSION: string;
+
+  /**
+   * Per-router cache versions computed at build time: router id to
+   * `[data, document]`, with `"*"` holding the whole-build pair.
+   * `undefined` in dev, where `VERSION` is used for both.
+   */
+  export const ROUTER_VERSIONS:
+    | Readonly<Record<string, readonly [data: string, document: string]>>
+    | undefined;
 }

package/src/vite/plugins/virtual-entries.ts

@@ -1,4 +1,5 @@
 import type { HeadScriptsOption } from "../plugin-types.js";
+import { DEFAULT_ROUTER_VERSIONS_KEY } from "../../router-versions.js";
 
 export const VIRTUAL_ENTRY_BROWSER: string = `
 import {
@@ -27,6 +28,12 @@ async function initializeApp() {
   // is the default; createRouter({ strictMode: false }) ships the opt-out in the
   // payload metadata. StrictMode emits no DOM, so toggling never changes markup.
   const { strictMode, initialPayload } = await initBrowserApp({ rscStream, deps });
+  // Set only on a document a no-JS useActionState POST rendered: React needs
+  // the server's form state to hydrate the hook without resetting it. A state
+  // Flight could not carry rejects: hydrate without it, as before.
+  const formState = await Promise.resolve(initialPayload.formState).catch(
+    () => undefined
+  );
 
   if (import.meta.hot) {
     const { startDevDiscoveryHandshake } = await import(
@@ -41,7 +48,8 @@ async function initializeApp() {
   const app = createElement(Rango);
   hydrateRoot(
     document,
-    strictMode === false ? app : createElement(StrictMode, null, app)
+    strictMode === false ? app : createElement(StrictMode, null, app),
+    formState ? { formState } : undefined
   );
 }
 
@@ -164,7 +172,7 @@ export const resumeShellHTML = createShellResumeHandler({
  *   registered for the _rsc_loader endpoint and fail in production.
  *
  * Single source of truth: both the generated virtual RSC entry below and the
- * custom-entry injector (version-injector) consume this list, so a new
+ * custom-entry injector (entry-bootstrap-injector) consume this list, so a new
  * bootstrap manifest cannot be added to one path and forgotten on the other.
  * That exact drift (loader-manifest present here but missing from the injector)
  * is what left fetchable loaders unresolved on custom worker entries.
@@ -197,12 +205,11 @@ import {
 // consults them at router-module evaluation. Router-first would silently push
 // every clientUrls() app onto the deferred-subscription path and change mount
 // registration order with no error. The custom-entry injector keeps the same
-// guarantee by PREPENDING this list at file top (version-injector.ts).
+// guarantee by PREPENDING this list at file top (entry-bootstrap-injector.ts).
 ${bootstrapImports}
 
 import { router } from "${routerPath}";
 import { createRSCHandler } from "@rangojs/router/internal/rsc-handler";
-import { VERSION } from "@rangojs/router:version";
 
 // Lazily create the handler on first request so that ESM live bindings
 // have resolved by the time we read \`router\`. During HMR the module may
@@ -212,7 +219,6 @@ export default function handler(request, env) {
   if (!_handler) {
     _handler = createRSCHandler({
       router,
-      version: VERSION,
       // Forward the router's CSP nonce provider. createRSCHandler reads the
       // provider only from options.nonce; without this, createRouter({ nonce })
       // is silently dropped on the Node preset (the Cloudflare path wires it via
@@ -314,6 +320,33 @@ export const VIRTUAL_IDS = {
   version: "@rangojs/router:version",
 } as const;
 
+/** Dev: one stamp for both versions of every router, bumped on RSC edits. */
 export function getVirtualVersionContent(version: string): string {
-  return `export const VERSION = ${JSON.stringify(version)};`;
+  return [
+    `export const VERSION = ${JSON.stringify(version)};`,
+    `export const ROUTER_VERSIONS = undefined;`,
+  ].join("\n");
+}
+
+/**
+ * Free identifier the production version module ships in place of the table.
+ * The versions are hashes of the built server code, so they cannot be part of
+ * it: the buildApp post hook (router-discovery.ts) replaces this token in the
+ * written chunk once the hashes are final (runRouterVersionsPhase,
+ * discovery/router-versions-phase.ts). An unreplaced token throws a ReferenceError
+ * when the module evaluates, so a build that skipped the step cannot serve
+ * with a constant version.
+ */
+export const ROUTER_VERSIONS_PLACEHOLDER = "__RANGO_ROUTER_VERSIONS__";
+
+/**
+ * Production: byte-identical in every build, so it never moves the hashes it
+ * is later filled with. VERSION is the whole-build document version (the
+ * table's "*" entry).
+ */
+export function getVirtualBuildVersionContent(): string {
+  return [
+    `export const ROUTER_VERSIONS = ${ROUTER_VERSIONS_PLACEHOLDER};`,
+    `export const VERSION = ROUTER_VERSIONS[${JSON.stringify(DEFAULT_ROUTER_VERSIONS_KEY)}][1];`,
+  ].join("\n");
 }

package/src/vite/rango.ts

@@ -2,7 +2,10 @@ import { type PluginOption } from "vite";
 import { readFileSync, existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { exposeActionId } from "./plugins/expose-action-id.js";
-import { defineEncryptionKeyExpr } from "./encryption-key.js";
+import {
+  configureEncryptionKey,
+  defineEncryptionKeyExpr,
+} from "./encryption-key.js";
 import {
   createLoaderDirectiveGuardPlugin,
   createLoaderScanStubPlugin,
@@ -12,6 +15,7 @@ import {
 import { useCacheTransform } from "./plugins/use-cache-transform.js";
 import { transitionWhenHoistPlugin } from "./plugins/transition-when-hoist.js";
 import { clientRefDedup } from "./plugins/client-ref-dedup.js";
+import { stableRscOutput } from "./plugins/stable-rsc-output.js";
 import { VIRTUAL_IDS } from "./plugins/virtual-entries.js";
 import {
   getExcludeDeps,
@@ -43,7 +47,7 @@ import type {
 } from "./plugin-types.js";
 import { createVercelOutputPlugin } from "./plugins/vercel-output.js";
 import { printBanner, rangoVersion } from "./utils/banner.js";
-import { createVersionInjectorPlugin } from "./plugins/version-injector.js";
+import { createEntryBootstrapInjectorPlugin } from "./plugins/entry-bootstrap-injector.js";
 import { createCjsToEsmPlugin } from "./plugins/cjs-to-esm.js";
 import { createRouterDiscoveryPlugin } from "./router-discovery.js";
 import { performanceTracksPlugin } from "./plugins/performance-tracks.js";
@@ -76,6 +80,20 @@ const debugConfig = createRangoDebugger(NS.config);
  */
 const SERVER_BUILD_TARGET = "esnext";
 
+/**
+ * Entry-signature mode for the node/vercel RSC build, the one
+ * `@cloudflare/vite-plugin` forces on its worker entry.
+ *
+ * Vite's default for a server build, "allow-extension", lets the bundler park
+ * modules shared with lazy chunks in the entry chunk. Under a host router that
+ * put the router runtime (80 modules, measured on e2e/test-app/.host-fixture
+ * and examples/vercel-multi-router) and every sub-app's route names into
+ * `index.js`, which every sub-app chunk imported back and which names each
+ * sub-app chunk by its content hash: no router's cache version was independent
+ * of the others (discovery/build-versions.ts hashes a router's chunks).
+ */
+const RSC_ENTRY_SIGNATURES = "strict";
+
 // The leading-directive 'use client' sniff is shared with version-plugin's
 // getClientModuleSignature so the two cannot drift. Imported for local use by the
 // HMR transform below and re-exported because the E8 sniff test imports it from
@@ -111,6 +129,9 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
   const rangoStart = performance.now();
   const resolvedOptions: RangoOptions = options ?? { preset: "node" };
   const preset = resolvedOptions.preset ?? "node";
+  // Before any plugin-rsc instance (this build's, the discovery temp server's)
+  // reads the key, and so an invalid key fails the config load.
+  configureEncryptionKey(resolvedOptions.encryptionKey);
   const showBanner = resolvedOptions.banner ?? true;
   const clientChunksOption = resolvedOptions.clientChunks ?? true;
   const useBuiltInClientChunks = clientChunksOption === true;
@@ -467,6 +488,9 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
               ...(vercelServerEnv ?? {}),
               build: {
                 target: SERVER_BUILD_TARGET,
+                rollupOptions: {
+                  preserveEntrySignatures: RSC_ENTRY_SIGNATURES,
+                },
               },
               optimizeDeps: {
                 entries: [VIRTUAL_IDS.rsc],
@@ -539,6 +563,7 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
     plugins.push(clientRefDedup());
   }
   plugins.push(clientChunksReport());
+  plugins.push(stableRscOutput());
 
   plugins.push({
     name: "@rangojs/router:client-component-hmr",
@@ -583,7 +608,7 @@ export async function rango(options?: RangoOptions): Promise<PluginOption[]> {
   const discoveryRouterRef = preset !== "cloudflare" ? routerRef : undefined;
 
   if (preset === "cloudflare") {
-    plugins.push(createVersionInjectorPlugin(undefined));
+    plugins.push(createEntryBootstrapInjectorPlugin(undefined));
   }
 
   plugins.push(createCjsToEsmPlugin());