@rangojs/router 0.0.0-experimental.fb6e2f40 → 0.0.0-experimental.fce7fbd1

package/src/vite/utils/shared-utils.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "vite";
+import type { Plugin, ResolvedConfig } from "vite";
 import * as Vite from "vite";
 import { getPublishedPackageName } from "./package-resolution.js";
 import { performanceTracksOptimizeDepsPlugin } from "../plugins/performance-tracks.js";
@@ -6,39 +6,52 @@ import {
   VIRTUAL_ENTRY_BROWSER,
   VIRTUAL_ENTRY_SSR,
   getVirtualEntryRSC,
+  getVirtualVersionContent,
   VIRTUAL_IDS,
 } from "../plugins/virtual-entries.js";
 
+// Cloudflare preset: @cloudflare/vite-plugin sets optimizeDeps.entries (string
+// or array) on the rsc environment. Single source for both the discovery plugin
+// and the version injector so they target the same entry.
+export function resolveRscEntryFromConfig(
+  config: ResolvedConfig,
+): string | undefined {
+  const entries = (config.environments as any)?.["rsc"]?.optimizeDeps?.entries;
+  if (typeof entries === "string") return entries;
+  if (Array.isArray(entries) && entries.length > 0) return entries[0];
+  return undefined;
+}
+
 /**
- * esbuild plugin to provide rsc-router:version virtual module during optimization.
- * This is needed because esbuild runs during Vite's dependency optimization phase,
- * before Vite's plugin system can handle virtual modules.
+ * Rolldown plugin to provide the version virtual module during dependency
+ * optimization. Vite 8 optimizes deps with Rolldown (a Rollup-style plugin
+ * pipeline that is separate from the main plugin set), so this is a
+ * resolveId/load plugin under optimizeDeps.rolldownOptions. Any dep pulled into
+ * optimization that imports the version virtual module gets a "dev" stub here;
+ * the real VERSION is injected into runtime modules by the version plugin.
  */
-const versionEsbuildPlugin = {
+const versionRolldownPlugin = {
   name: "@rangojs/router-version",
-  setup(build: any): void {
-    build.onResolve({ filter: /^rsc-router:version$/ }, (args: any) => ({
-      path: args.path,
-      namespace: "@rangojs/router-virtual",
-    }));
-    build.onLoad(
-      { filter: /.*/, namespace: "@rangojs/router-virtual" },
-      () => ({
-        contents: `export const VERSION = "dev";`,
-        loader: "js",
-      }),
-    );
+  resolveId(id: string): string | undefined {
+    if (id === VIRTUAL_IDS.version) return "\0" + VIRTUAL_IDS.version;
+    return undefined;
+  },
+  load(id: string): string | undefined {
+    if (id === "\0" + VIRTUAL_IDS.version) {
+      return getVirtualVersionContent("dev");
+    }
+    return undefined;
   },
 };
 
 /**
- * Shared esbuild options for dependency optimization.
- * Includes the version stub plugin for all environments.
+ * Shared Rolldown options for dependency optimization (Vite 8).
+ * Includes the version stub plugin and the performance-tracks RSDW patch.
  */
-export const sharedEsbuildOptions: {
+export const sharedRolldownOptions: {
   plugins: any[];
 } = {
-  plugins: [versionEsbuildPlugin, performanceTracksOptimizeDepsPlugin()],
+  plugins: [versionRolldownPlugin, performanceTracksOptimizeDepsPlugin()],
 };
 
 /**
@@ -103,14 +116,68 @@ export function createVirtualEntriesPlugin(
   };
 }
 
+// Matches rollup's FILE_NAME_CONFLICT message and reports whether the colliding
+// file is a content-hashed asset, e.g.
+//   The emitted file "assets/index-DlGNrvnU.css" overwrites a previously ...
+//   The emitted file "assets/inter-latin-Dx4kXJAl.woff2" overwrites a ...
+// The match is UNANCHORED on purpose: by the time the warning reaches this user
+// onwarn handler, Vite's logger has wrapped rollup's raw message with an ANSI
+// color sequence and a "[CODE] " label, e.g.
+//   "[FILE_NAME_CONFLICT] The emitted file \"...\" overwrites ..."
+// A "^The emitted file" anchor sits behind that prefix and never matches; and
+// Vite also strips the JSON.stringify quotes rollup puts around the filename, so
+// the match is UNANCHORED and quote-OPTIONAL ("?...?"?). The non-whitespace
+// capture stops at the space before "overwrites" (Vite's unquoted display form)
+// or the closing quote (raw rollup form); either way it carries no ANSI.
+// A content-hashed name ends with a "-" separator + a Vite content hash. The
+// hash is a FIXED-LENGTH base64url run ([A-Za-z0-9_-], default 8), so it can
+// itself contain "-"/"_": it CANNOT be located by splitting on the last "-"
+// (that lands inside the hash whenever it carries a dash, e.g. "...-Cabi7G8-" ->
+// "" or "...-CkhJZR-_" -> "_", which let those conflicts leak). Instead take the
+// trailing HASH_LEN chars and require the "-" separator right before them. The
+// hash must hold an uppercase letter or digit (a real hash is never an
+// all-lowercase word), so stable names like "assets/manifest.json" or
+// "assets/loading-skeleton.css" still surface as potential genuine overwrites.
+function isContentHashedAssetConflict(message: string | undefined): boolean {
+  if (!message) return false;
+  const match =
+    /The emitted file "?([^"\s]+)"? overwrites a previously emitted file/.exec(
+      message,
+    );
+  if (!match) return false;
+  const fileName = match[1];
+  const base = fileName.slice(fileName.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return false;
+  const stem = base.slice(0, dot);
+  // HASH_LEN tracks Vite's default [hash] width; bump it if an app sets a custom
+  // assetFileNames hash length.
+  const HASH_LEN = 8;
+  if (stem.length < HASH_LEN + 1 || stem[stem.length - HASH_LEN - 1] !== "-") {
+    return false;
+  }
+  const hash = stem.slice(-HASH_LEN);
+  return /^[A-Za-z0-9_-]+$/.test(hash) && /[A-Z0-9]/.test(hash);
+}
+
 /**
  * Rollup onwarn handler that suppresses known harmless warnings:
  * - "use client" directives: handled by the RSC plugin, not relevant to Rollup
  * - sourcemap errors: caused by "use client" directive at line 1:0 confusing sourcemap resolution
  * - sourcemap incomplete: plugins that transform without generating sourcemaps (router + RSC plugin)
- * - dynamic/static mixed imports: expected for router internals (e.g. request-context, cache-scope)
+ * - dynamic/static mixed imports: expected for router internals (e.g. request-context, cache-scope).
+ *   Under Rolldown (Vite 8) this surfaces as the INEFFECTIVE_DYNAMIC_IMPORT code emitted directly
+ *   by the bundler, rather than the vite:reporter message handled below (Rollup/Vite 7 shape).
  * - empty bundle: @vitejs/plugin-rsc scan build (step 1/5) produces an empty "index" chunk
  *   because the RSC entry is fully externalized during client-reference analysis
+ * - file name conflicts on content-hashed assets: @vitejs/plugin-rsc copies the rsc
+ *   environment's imported CSS/assets into the client bundle (its assets-manifest
+ *   generateBundle re-emits each via emitFile with an explicit content-hashed
+ *   fileName). When the client bundle already produced that identical asset,
+ *   rollup raises FILE_NAME_CONFLICT even though the bytes are identical (a
+ *   content hash collision IS a content match). Only these are suppressed; a
+ *   collision on a stable name still surfaces. No upstream fix as of
+ *   @vitejs/plugin-rsc@0.5.27; remove when it skips the redundant emit.
  */
 export function onwarn(
   warning: Vite.Rollup.RollupLog,
@@ -119,7 +186,14 @@ export function onwarn(
   if (
     warning.code === "MODULE_LEVEL_DIRECTIVE" ||
     warning.code === "SOURCEMAP_ERROR" ||
-    warning.code === "EMPTY_BUNDLE"
+    warning.code === "EMPTY_BUNDLE" ||
+    warning.code === "INEFFECTIVE_DYNAMIC_IMPORT"
+  ) {
+    return;
+  }
+  if (
+    warning.code === "FILE_NAME_CONFLICT" &&
+    isContentHashedAssetConflict(warning.message)
   ) {
     return;
   }
@@ -157,12 +231,19 @@ export function getManualChunks(id: string): string | undefined {
     return "react";
   }
   // Use dynamic package name from package.json
-  // Check both npm install path and workspace symlink resolved path
+  // Check both npm install path and workspace symlink resolved path.
+  //
+  // The workspace patterns are anchored to the package's own `src`/`dist` so
+  // they match the router runtime but NOT consumer apps that merely live under a
+  // `packages/rangojs-router/` ancestor (the in-repo e2e apps at
+  // `packages/rangojs-router/e2e/<app>/src/...`). Without the anchor those apps'
+  // own client components were force-merged into the shared "router" chunk,
+  // which both misrepresented real-consumer bundles and blocked `clientChunks`
+  // splitting from relocating them.
   const packageName = getPublishedPackageName();
   if (
     normalized.includes(`node_modules/${packageName}/`) ||
-    normalized.includes("packages/rsc-router/") ||
-    normalized.includes("packages/rangojs-router/")
+    /\/packages\/(rsc-router|rangojs-router)\/(src|dist)\//.test(normalized)
   ) {
     return "router";
   }

package/src/browser/action-response-classifier.ts

@@ -1,99 +0,0 @@
-/**
- * Discriminated union of post-reconciliation action response scenarios.
- *
- * Error and full-update-unsupported are handled inline in the bridge
- * before reconciliation. This classifier only runs for partial responses
- * that have been successfully reconciled.
- */
-export type ActionScenario =
-  | {
-      type: "navigated-away";
-      historyKeyChanged: boolean;
-      onInterceptRoute: boolean;
-    }
-  | { type: "hmr-missing" }
-  | { type: "consolidation-needed"; segmentIds: string[] }
-  | { type: "concurrent-skip"; otherFetchingCount: number }
-  | { type: "normal" };
-
-/**
- * Pure data inputs for classifying a partial action response.
- * All values come from the bridge but no browser APIs or side effects.
- */
-export interface ClassifierInput {
-  /** window.location.pathname captured at action start */
-  actionStartPathname: string;
-  /** window.location.pathname at classification time */
-  currentPathname: string;
-  /** window.history.state?.key captured at action start */
-  actionStartLocationKey: string | undefined;
-  /** window.history.state?.key at classification time */
-  currentLocationKey: string | undefined;
-  /** Number of segments after reconciliation */
-  reconciledSegmentCount: number;
-  /** Number of matched segment IDs from server */
-  matchedCount: number;
-  /** Segment IDs needing consolidation (from concurrent action tracking) */
-  consolidationSegments: string[] | null;
-  /** Number of other actions still in "fetching" phase */
-  otherFetchingActionCount: number;
-  /** Current intercept source URL (null when not on intercept route) */
-  currentInterceptSource: string | null;
-}
-
-/**
- * Classify a partial action response into one of 5 post-reconciliation
- * scenarios.
- *
- * Called after error and full-update cases are handled inline by the bridge.
- * The classification order matches the priority chain:
- * 1. User navigated away during action
- * 2. HMR missing segments (fewer reconciled than matched)
- * 3. Consolidation needed (concurrent actions finished)
- * 4. Concurrent skip (other actions still fetching)
- * 5. Normal (single action, no issues)
- *
- * This is a pure function with no side effects - the bridge handles
- * all UI updates, store mutations, and network requests based on the
- * returned scenario.
- */
-export function classifyActionResponse(input: ClassifierInput): ActionScenario {
-  // Check if user navigated away during the action
-  const userNavigatedAway =
-    input.currentPathname !== input.actionStartPathname ||
-    input.currentLocationKey !== input.actionStartLocationKey;
-
-  if (userNavigatedAway) {
-    const historyKeyChanged =
-      input.currentLocationKey !== input.actionStartLocationKey;
-    return {
-      type: "navigated-away",
-      historyKeyChanged,
-      onInterceptRoute: input.currentInterceptSource !== null,
-    };
-  }
-
-  // HMR resilience: segments missing after reconciliation
-  if (input.reconciledSegmentCount < input.matchedCount) {
-    return { type: "hmr-missing" };
-  }
-
-  // Consolidation needed for concurrent actions
-  if (input.consolidationSegments && input.consolidationSegments.length > 0) {
-    return {
-      type: "consolidation-needed",
-      segmentIds: input.consolidationSegments,
-    };
-  }
-
-  // Other actions still fetching - skip UI update
-  if (input.otherFetchingActionCount > 0) {
-    return {
-      type: "concurrent-skip",
-      otherFetchingCount: input.otherFetchingActionCount,
-    };
-  }
-
-  // Normal single-action completion
-  return { type: "normal" };
-}