@rangojs/router 0.0.0-experimental.15 → 0.0.0-experimental.16

package/dist/vite/index.js

@@ -1778,7 +1778,7 @@ import { resolve as resolve2 } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.15",
+  version: "0.0.0-experimental.16",
   type: "module",
   description: "Django-inspired RSC router with composable URL patterns",
   author: "Ivo Todorov",
@@ -2061,7 +2061,7 @@ function createVirtualEntriesPlugin(entries, routerPath) {
   };
 }
 function onwarn(warning, defaultHandler) {
-  if (warning.code === "MODULE_LEVEL_DIRECTIVE" || warning.code === "SOURCEMAP_ERROR") {
+  if (warning.code === "MODULE_LEVEL_DIRECTIVE" || warning.code === "SOURCEMAP_ERROR" || warning.code === "EMPTY_BUNDLE") {
     return;
   }
   if (warning.message?.includes("Sourcemap is likely to be incorrect")) {
@@ -2586,6 +2586,13 @@ ${err.stack}`
         setTimeout(() => discover().then(resolve4, resolve4), 0);
       });
       let prerenderTempServer = null;
+      server.httpServer?.on("close", () => {
+        if (prerenderTempServer) {
+          prerenderTempServer.close().catch(() => {
+          });
+          prerenderTempServer = null;
+        }
+      });
       let prerenderNodeRegistry = null;
       let mainRegistry = null;
       server.middlewares.use("/__rsc_prerender", async (req, res) => {
@@ -2998,6 +3005,53 @@ globalThis.__PRERENDER_MANIFEST = __pm;
     }
   };
 }
+function stripJsonComments(input) {
+  let result = "";
+  let i = 0;
+  const len = input.length;
+  while (i < len) {
+    const ch = input[i];
+    if (ch === '"') {
+      result += ch;
+      i++;
+      while (i < len) {
+        const sc = input[i];
+        result += sc;
+        i++;
+        if (sc === "\\") {
+          if (i < len) {
+            result += input[i];
+            i++;
+          }
+        } else if (sc === '"') {
+          break;
+        }
+      }
+      continue;
+    }
+    if (ch === "/" && i + 1 < len && input[i + 1] === "/") {
+      i += 2;
+      while (i < len && input[i] !== "\n") {
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && i + 1 < len && input[i + 1] === "*") {
+      i += 2;
+      while (i < len) {
+        if (input[i] === "*" && i + 1 < len && input[i + 1] === "/") {
+          i += 2;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    result += ch;
+    i++;
+  }
+  return result;
+}
 var VIRTUAL_ROUTES_MANIFEST_ID = "virtual:rsc-router/routes-manifest";
 function resolveDiscoveryEntryPath(options, routerPath) {
   if (options.preset === "cloudflare") {
@@ -3006,7 +3060,7 @@ function resolveDiscoveryEntryPath(options, routerPath) {
       if (existsSync3(filename)) {
         try {
           const raw = readFileSync2(filename, "utf-8");
-          const cleaned = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+          const cleaned = stripJsonComments(raw);
           const config = JSON.parse(cleaned);
           if (config.main) {
             return config.main;
@@ -3353,6 +3407,23 @@ ${list}`
       );
     }
   }
+  plugins.push({
+    name: "@rangojs/router:client-component-hmr",
+    hotUpdate(ctx) {
+      const envName = this.environment?.name;
+      if (envName !== "rsc" && envName !== "ssr") return;
+      const file = ctx.file;
+      if (!file.endsWith(".tsx") && !file.endsWith(".ts") && !file.endsWith(".jsx") && !file.endsWith(".js")) return;
+      try {
+        const source = readFileSync2(file, "utf-8");
+        const trimmed = source.trimStart();
+        if (trimmed.startsWith('"use client"') || trimmed.startsWith("'use client'")) {
+          return [];
+        }
+      } catch {
+      }
+    }
+  });
   plugins.push(exposeActionId());
   plugins.push(exposeInternalIds());
   plugins.push(exposeRouterId());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rangojs/router",
-  "version": "0.0.0-experimental.15",
+  "version": "0.0.0-experimental.16",
   "type": "module",
   "description": "Django-inspired RSC router with composable URL patterns",
   "author": "Ivo Todorov",
@@ -127,15 +127,6 @@
   "bin": {
     "rango": "./dist/bin/rango.js"
   },
-  "scripts": {
-    "build": "pnpm dlx esbuild src/vite/index.ts --bundle --format=esm --outfile=dist/vite/index.js --platform=node --packages=external && pnpm dlx esbuild src/bin/rango.ts --bundle --format=esm --outfile=dist/bin/rango.js --platform=node --packages=external --banner:js='#!/usr/bin/env node'",
-    "prepublishOnly": "pnpm build",
-    "typecheck": "tsc --noEmit",
-    "test": "playwright test",
-    "test:ui": "playwright test --ui",
-    "test:unit": "vitest run",
-    "test:unit:watch": "vitest"
-  },
   "peerDependencies": {
     "@cloudflare/vite-plugin": "^1.21.0",
     "@vitejs/plugin-rsc": "^0.5.14",
@@ -159,14 +150,22 @@
   "devDependencies": {
     "@playwright/test": "^1.49.1",
     "@types/node": "^24.10.1",
-    "@types/react": "catalog:",
-    "@types/react-dom": "catalog:",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
     "esbuild": "^0.27.0",
     "jiti": "^2.6.1",
-    "react": "catalog:",
-    "react-dom": "catalog:",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
     "tinyexec": "^0.3.2",
     "typescript": "^5.3.0",
     "vitest": "^4.0.0"
+  },
+  "scripts": {
+    "build": "pnpm dlx esbuild src/vite/index.ts --bundle --format=esm --outfile=dist/vite/index.js --platform=node --packages=external && pnpm dlx esbuild src/bin/rango.ts --bundle --format=esm --outfile=dist/bin/rango.js --platform=node --packages=external --banner:js='#!/usr/bin/env node'",
+    "typecheck": "tsc --noEmit",
+    "test": "playwright test",
+    "test:ui": "playwright test --ui",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest"
   }
-}
+}

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

@@ -0,0 +1,104 @@
+/**
+ * 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" };
+}

package/src/browser/event-controller.ts

@@ -40,7 +40,7 @@ export interface NavigationEntry {
   abort: AbortController;
   phase: NavigationPhase;
   startedAt: number;
-  options?: NavigateOptions;
+  options?: NavigateOptions & { skipLoadingState?: boolean };
 }
 
 /**
@@ -176,7 +176,7 @@ export interface ActionHandle extends Disposable {
  */
 export interface EventController {
   // Navigation operations
-  startNavigation(url: string, options?: NavigateOptions): NavigationHandle;
+  startNavigation(url: string, options?: NavigateOptions & { skipLoadingState?: boolean }): NavigationHandle;
   abortNavigation(): void;
 
   // Action operations
@@ -367,9 +367,13 @@ export function createEventController(
       }));
 
     // State: loading if navigation OR actions are in progress
+    // Background revalidations (skipLoadingState) don't affect visible state
     const hasActiveActions = inflightActionsList.length > 0;
+    const isVisibleNavigation =
+      currentNavigation !== null &&
+      !currentNavigation.options?.skipLoadingState;
     const state =
-      currentNavigation !== null || hasActiveActions ? "loading" : "idle";
+      isVisibleNavigation || hasActiveActions ? "loading" : "idle";
 
     // Streaming: true if any active streams (navigation or action) or loading
     const isStreaming = activeStreamCount > 0 || state === "loading";
@@ -379,7 +383,12 @@ export function createEventController(
       isStreaming,
       location,
       // pendingUrl only during fetching phase - once streaming starts (URL changed), not pending
-      pendingUrl: currentNavigation?.phase === "fetching" ? currentNavigation.url : null,
+      // Background revalidations don't expose a pending URL
+      pendingUrl:
+        currentNavigation?.phase === "fetching" &&
+        !currentNavigation.options?.skipLoadingState
+          ? currentNavigation.url
+          : null,
       inflightActions: inflightActionsList,
     };
   }
@@ -431,7 +440,7 @@ export function createEventController(
 
   function startNavigation(
     url: string,
-    options?: NavigateOptions
+    options?: NavigateOptions & { skipLoadingState?: boolean }
   ): NavigationHandle {
     // Cancel existing navigation (switchMap semantics)
     if (currentNavigation) {

package/src/browser/intercept-utils.ts

@@ -0,0 +1,56 @@
+import type { ResolvedSegment } from "./types.js";
+import type { SlotState } from "../types.js";
+
+/**
+ * Check if a segment is an intercept segment.
+ * Intercept segments have namespace starting with "intercept:" or are parallel
+ * segments with ".@" in their ID (e.g., "L0.@modal").
+ */
+export function isInterceptSegment(s: ResolvedSegment): boolean {
+  return (
+    s.namespace?.startsWith("intercept:") ||
+    (s.type === "parallel" && s.id.includes(".@"))
+  );
+}
+
+/**
+ * Split an array of segments into main and intercept groups.
+ * Intercept segments are separated for explicit injection into the render tree
+ * via the interceptSegments render option.
+ */
+export function splitInterceptSegments(segments: ResolvedSegment[]): {
+  main: ResolvedSegment[];
+  intercept: ResolvedSegment[];
+} {
+  const main: ResolvedSegment[] = [];
+  const intercept: ResolvedSegment[] = [];
+  for (const s of segments) {
+    if (isInterceptSegment(s)) {
+      intercept.push(s);
+    } else {
+      main.push(s);
+    }
+  }
+  return { main, intercept };
+}
+
+/**
+ * Check if any slot is currently active (has content to render).
+ * Active slots indicate an intercept response where a parallel segment
+ * (e.g., @modal) has matched and should be rendered.
+ */
+export function hasActiveIntercept(
+  slots?: Record<string, SlotState>,
+): boolean {
+  if (!slots) return false;
+  return Object.values(slots).some((slot) => slot.active);
+}
+
+/**
+ * Check if cached segments contain any intercept segments.
+ * Intercept caches shouldn't be used for optimistic rendering since
+ * whether interception happens depends on the current page context.
+ */
+export function isInterceptOnlyCache(segments: ResolvedSegment[]): boolean {
+  return segments.some(isInterceptSegment);
+}

package/src/browser/logging.ts

@@ -42,3 +42,14 @@ export function browserDebugLog(
 
   console.log(`${prefix} ${message}`);
 }
+
+/**
+ * Simple gated console.log for browser-side debug output.
+ * Unlike browserDebugLog, this doesn't require a transaction context -
+ * use it for standalone debug messages in partial-update, navigation-bridge, etc.
+ */
+export function debugLog(msg: string, ...args: unknown[]): void {
+  if (INTERNAL_RANGO_DEBUG) {
+    console.log(msg, ...args);
+  }
+}

package/src/browser/lru-cache.ts

@@ -40,15 +40,7 @@ export class LRUCache<K, V> {
   }
 
   has(key: K): boolean {
-    if (!this.cache.has(key)) {
-      return false;
-    }
-
-    // Move to end (most recently used) - same as get()
-    const value = this.cache.get(key)!;
-    this.cache.delete(key);
-    this.cache.set(key, value);
-    return true;
+    return this.cache.has(key);
   }
 
   delete(key: K): boolean {

package/src/browser/merge-segment-loaders.ts

@@ -1,4 +1,5 @@
 import type { ResolvedSegment } from "./types.js";
+import { debugLog } from "./logging.js";
 
 /**
  * Merge partial loader data from server with cached loader data.
@@ -18,8 +19,8 @@ export function mergeSegmentLoaders(
   const serverLoaderIds = fromServer.loaderIds || [];
   const cachedLoaderIds = fromCache.loaderIds || [];
 
-  console.log(
-    `[Browser] Merging partial loaders: server has ${serverLoaderIds.join(", ")}, cache has ${cachedLoaderIds.join(", ")}`
+  debugLog(
+    `[Browser] Merging partial loaders: server has ${serverLoaderIds.join(", ")}, cache has ${cachedLoaderIds.join(", ")}`,
   );
 
   return {
@@ -105,8 +106,8 @@ export function insertMissingDiffSegments(
           if (parentIndex !== -1) {
             // Insert loader segment right after its parent layout
             allSegments.splice(parentIndex + 1, 0, fromServer);
-            console.log(
-              `[Browser] Inserted diff segment ${diffId} after ${parentLayoutId}`
+            debugLog(
+              `[Browser] Inserted diff segment ${diffId} after ${parentLayoutId}`,
             );
           } else {
             // Fallback: append to end if parent not found
@@ -118,7 +119,7 @@ export function insertMissingDiffSegments(
         } else {
           // Non-loader diff segment not in matched - append to end
           allSegments.push(fromServer);
-          console.log(`[Browser] Appended diff segment ${diffId}`);
+          debugLog(`[Browser] Appended diff segment ${diffId}`);
         }
       }
     }