@rangojs/router 0.0.0-experimental.11 → 0.0.0-experimental.110

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

@@ -0,0 +1,99 @@
+/**
+ * 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/app-shell.ts

@@ -0,0 +1,52 @@
+import type { ComponentType, ReactNode } from "react";
+
+/**
+ * App-shell metadata: the set of per-router fields that describe the
+ * "envelope" around the current app's segment tree. These fields are set
+ * from the initial RSC payload and must be replaced atomically when the
+ * client navigates into a different router (app switch).
+ *
+ * Intentionally NOT part of the shell (all document-lifetime):
+ * - themeConfig / initialTheme: ThemeProvider is mounted above the segment
+ *   tree and must not remount on smooth transitions.
+ * - warmupEnabled: attached to the NavigationProvider's lifetime effect;
+ *   toggling it mid-session would tear down and restart idle listeners.
+ *   Also not serialized on every full-render path (e.g. the not-found
+ *   fallback), so carrying it here would be unreliable.
+ * - prefetchCacheTTL: the not-found full-render payload does not serialize
+ *   it, so a cross-app nav into a 404 would silently erase the setting.
+ *   Mutable shell fields must be serialized on EVERY full-render path,
+ *   otherwise absent fields are indistinguishable from "new app has no
+ *   value" and the old app's value is dropped.
+ *
+ * A new document navigation (hard reload) applies these fields from the
+ * target app's initial payload.
+ */
+export interface AppShell {
+  /** Router identity. Used to namespace per-app client state (e.g. the
+   *  rango-state localStorage key) so sibling apps on the same origin
+   *  cannot observe each other's cache invalidations. */
+  routerId?: string;
+  rootLayout?: ComponentType<{ children: ReactNode }>;
+  basename?: string;
+  version?: string;
+}
+
+/**
+ * Mutable container for the active app shell. Read-through via `get()` so
+ * closures capture the ref, not the shell, and pick up updates at call time.
+ */
+export interface AppShellRef {
+  get(): AppShell;
+  update(next: AppShell): void;
+}
+
+export function createAppShellRef(initial: AppShell): AppShellRef {
+  let current = initial;
+  return {
+    get: () => current,
+    update: (next) => {
+      current = next;
+    },
+  };
+}

package/src/browser/app-version.ts

@@ -0,0 +1,14 @@
+/**
+ * Mutable app version — updated after HMR revalidation.
+ * Read by prefetch, navigation, and context code.
+ */
+
+let currentVersion: string | undefined;
+
+export function getAppVersion(): string | undefined {
+  return currentVersion;
+}
+
+export function setAppVersion(version: string | undefined): void {
+  currentVersion = version;
+}

package/src/browser/event-controller.ts

@@ -8,7 +8,9 @@ import type {
   ResolvedSegment,
   RscMetadata,
   HandleData,
+  StreamingToken,
 } from "./types.js";
+import { filterSegmentOrder } from "./react/filter-segment-order.js";
 
 // Polyfill Symbol.dispose for Safari and older browsers
 if (typeof Symbol.dispose === "undefined") {
@@ -40,7 +42,7 @@ export interface NavigationEntry {
   abort: AbortController;
   phase: NavigationPhase;
   startedAt: number;
-  options?: NavigateOptions;
+  options?: NavigateOptions & { skipLoadingState?: boolean };
 }
 
 /**
@@ -77,6 +79,8 @@ export interface DerivedNavigationState {
   state: "idle" | "loading";
   /** Whether any operation is streaming */
   isStreaming: boolean;
+  /** Whether a navigation is active (fetching or streaming, before commit) */
+  isNavigating: boolean;
   /** Current committed location */
   location: NavigationLocation;
   /** URL being navigated to (null if idle) */
@@ -109,20 +113,24 @@ export type ActionStateListener = (state: TrackedActionState) => void;
 export type HandleListener = () => void;
 
 /**
- * Internal handle state stored in controller
+ * Internal handle state stored in controller.
+ *
+ * Two segment lists are exposed because they serve different consumers:
+ *
+ * - `segmentOrder` drives handle collection (collectHandleData). Includes
+ *   parallel slot ids and reorders them after their parent so later-wins
+ *   collect functions (e.g. Meta) get the right precedence.
+ * - `routeSegmentIds` is the layouts-and-routes-only list documented by
+ *   `useSegments().segmentIds`. Parallels and loader sub-ids are stripped;
+ *   raw matched order is preserved.
+ *
+ * Both are derived from the same `matched` input on each setHandleData call
+ * so they stay in sync.
  */
 export interface HandleState {
   data: HandleData;
   segmentOrder: string[];
-}
-
-/**
- * Token for tracking an active stream
- * Call end() when the stream completes
- */
-export interface StreamingToken {
-  /** End this streaming operation */
-  end(): void;
+  routeSegmentIds: string[];
 }
 
 /**
@@ -165,8 +173,8 @@ export interface ActionHandle extends Disposable {
   readonly settled: boolean;
   /** Check if any concurrent actions were started */
   hadConcurrentActions: boolean;
-  /** Get segments to consolidate (only valid when this is the last action) */
-  getConsolidationSegments(): string[] | null;
+  /** Get raw set of segments revalidated by concurrent actions */
+  getRevalidatedSegments(): Set<string>;
   /** Clear consolidation tracking */
   clearConsolidation(): void;
 }
@@ -176,7 +184,10 @@ 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
@@ -186,6 +197,7 @@ export interface EventController {
   // State access
   getState(): DerivedNavigationState;
   getActionState(actionId: string): TrackedActionState;
+  getLocation(): NavigationLocation;
 
   // Location updates (for popstate where navigation doesn't go through startNavigation)
   setLocation(location: NavigationLocation): void;
@@ -194,7 +206,7 @@ export interface EventController {
   subscribe(listener: StateListener): () => void;
   subscribeToAction(
     actionId: string,
-    listener: ActionStateListener
+    listener: ActionStateListener,
   ): () => void;
   subscribeToHandles(listener: HandleListener): () => void;
 
@@ -202,13 +214,27 @@ export interface EventController {
   setHandleData(
     data: HandleData,
     matched?: string[],
-    isPartial?: boolean
+    isPartial?: boolean,
+    /**
+     * Segment ids that were re-resolved on the server this request (the
+     * partial response's `diff`). On a partial update, any existing bucket
+     * keyed under one of these ids that has no incoming entry is treated as
+     * stale and cleared. Without this, a parallel slot that revalidates but
+     * pushes nothing leaves its previous bucket in place forever.
+     */
+    resolvedIds?: string[],
   ): void;
   getHandleState(): HandleState;
 
+  // Params operations
+  setParams(params: Record<string, string>): void;
+  getParams(): Record<string, string>;
+
   // Direct state access for advanced use
   getCurrentNavigation(): NavigationEntry | null;
   getInflightActions(): Map<string, ActionEntry>;
+  /** Whether any concurrent actions have occurred (shared across all handles) */
+  hadAnyConcurrentActions(): boolean;
 }
 
 // ============================================================================
@@ -230,7 +256,10 @@ const DEFAULT_ACTION_STATE: TrackedActionState = {
  * When subscriptionId has no '#', it's just an action name and matches by suffix.
  * This allows useAction("addToCart") to match "hash#addToCart" or "src/file.ts#addToCart".
  */
-function matchesActionId(subscriptionId: string, entryActionId: string): boolean {
+function matchesActionId(
+  subscriptionId: string,
+  entryActionId: string,
+): boolean {
   if (subscriptionId.includes("#")) {
     // Full ID: exact match
     return subscriptionId === entryActionId;
@@ -261,7 +290,7 @@ export interface EventControllerConfig {
  * Actions use mergeMap semantics (all run concurrently, consolidate at end).
  */
 export function createEventController(
-  config?: EventControllerConfig
+  config?: EventControllerConfig,
 ): EventController {
   // ========================================================================
   // Source of Truth
@@ -292,6 +321,10 @@ export function createEventController(
   // Handle data from RSC payload
   let handleData: HandleData = {};
   let handleSegmentOrder: string[] = [];
+  let routeSegmentIds: string[] = [];
+
+  // Merged route params from current match
+  let routeParams: Record<string, string> = {};
 
   // ========================================================================
   // Listeners
@@ -334,7 +367,7 @@ export function createEventController(
             listeners.forEach((listener) => listener(state));
           }
         }
-      }, 0)
+      }, 0),
     );
   }
 
@@ -367,9 +400,12 @@ 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 state =
-      currentNavigation !== null || hasActiveActions ? "loading" : "idle";
+    const isVisibleNavigation =
+      currentNavigation !== null &&
+      !currentNavigation.options?.skipLoadingState;
+    const state = isVisibleNavigation || hasActiveActions ? "loading" : "idle";
 
     // Streaming: true if any active streams (navigation or action) or loading
     const isStreaming = activeStreamCount > 0 || state === "loading";
@@ -377,9 +413,17 @@ export function createEventController(
     return {
       state,
       isStreaming,
+      // True when a navigation is active (fetching or streaming, before
+      // commit). Broader than pendingUrl which clears during streaming.
+      isNavigating: currentNavigation !== null,
       location,
-      // pendingUrl only during fetching phase - once streaming starts (URL changed), not pending
-      pendingUrl: currentNavigation?.phase === "fetching" ? currentNavigation.url : null,
+      // pendingUrl only during fetching phase - once streaming starts (URL changed), not pending.
+      // Background revalidations (skipLoadingState) don't expose a pending URL.
+      pendingUrl:
+        currentNavigation?.phase === "fetching" &&
+        !currentNavigation.options?.skipLoadingState
+          ? currentNavigation.url
+          : null,
       inflightActions: inflightActionsList,
     };
   }
@@ -388,12 +432,16 @@ export function createEventController(
     // Find the most recent action with this ID that's not settling
     // Uses suffix matching when actionId is just a name (no #)
     const activeEntry = [...inflightActions.values()]
-      .filter((a) => matchesActionId(actionId, a.actionId) && a.phase !== "settling")
+      .filter(
+        (a) => matchesActionId(actionId, a.actionId) && a.phase !== "settling",
+      )
       .sort((a, b) => b.startedAt - a.startedAt)[0];
 
     // Also check for settling entries to get result/error
     const settlingEntry = [...inflightActions.values()]
-      .filter((a) => matchesActionId(actionId, a.actionId) && a.phase === "settling")
+      .filter(
+        (a) => matchesActionId(actionId, a.actionId) && a.phase === "settling",
+      )
       .sort((a, b) => b.startedAt - a.startedAt)[0];
 
     const entry = activeEntry || settlingEntry;
@@ -431,7 +479,7 @@ export function createEventController(
 
   function startNavigation(
     url: string,
-    options?: NavigateOptions
+    options?: NavigateOptions & { skipLoadingState?: boolean },
   ): NavigationHandle {
     // Cancel existing navigation (switchMap semantics)
     if (currentNavigation) {
@@ -463,6 +511,7 @@ export function createEventController(
 
       startStreaming(): StreamingToken {
         let ended = false;
+        entry.phase = "streaming";
         activeStreamCount++;
         notify();
 
@@ -650,24 +699,8 @@ export function createEventController(
         // If streaming is in progress, tryFinalize() will be called when streaming ends
       },
 
-      getConsolidationSegments(): string[] | null {
-        // Only consolidate if all actions have at least received their response
-        // We don't need to wait for streaming to complete since we're refetching anyway
-        // Count actions that are still fetching (waiting for server response)
-        const stillFetchingCount = [...inflightActions.values()].filter(
-          (a) => a.phase === "fetching"
-        ).length;
-
-        if (stillFetchingCount > 0) {
-          return null; // Some actions still waiting for server response
-        }
-        if (!hadAnyConcurrentActions) {
-          return null; // No concurrent actions occurred
-        }
-        if (concurrentRevalidatedSegments.size === 0) {
-          return null; // No segments to consolidate
-        }
-        return Array.from(concurrentRevalidatedSegments);
+      getRevalidatedSegments(): Set<string> {
+        return concurrentRevalidatedSegments;
       },
 
       clearConsolidation() {
@@ -702,16 +735,26 @@ export function createEventController(
   }
 
   function abortAllActions() {
-    for (const entry of inflightActions.values()) {
+    for (const [id, entry] of inflightActions) {
+      // Preserve settling entries — they have already been handled by
+      // fail()/complete() and will self-cleanup via the settlement timeout.
+      // Clearing them here would prevent debounced notifications from
+      // delivering the error/result state to subscribers.
+      if (entry.phase === "settling") continue;
       entry.abort.abort();
+      inflightActions.delete(id);
     }
-    inflightActions.clear();
     hadAnyConcurrentActions = false;
     concurrentRevalidatedSegments.clear();
     notify();
-    // Notify all action listeners
-    for (const actionId of actionListeners.keys()) {
-      notifyAction(actionId);
+    // Notify all action listeners directly by subscription ID.
+    // actionListeners keys are subscription IDs (possibly short names like
+    // "addToCart"), not full entry actionIds. Passing them to notifyAction
+    // would fail the suffix matcher — instead, notify each subscriber with
+    // its own state.
+    for (const [subscriptionId, listeners] of actionListeners) {
+      const state = getActionState(subscriptionId);
+      listeners.forEach((listener) => listener(state));
     }
   }
 
@@ -719,24 +762,19 @@ export function createEventController(
   // Handle Operations
   // ========================================================================
 
-  /**
-   * Filter segment IDs to only include routes and layouts.
-   * Excludes parallels (contain .@) and loaders (contain D followed by digit).
-   */
-  function filterSegmentOrder(matched: string[]): string[] {
-    return matched.filter((id) => {
-      if (id.includes(".@")) return false;
-      if (/D\d+\./.test(id)) return false;
-      return true;
-    });
-  }
-
   function setHandleData(
     data: HandleData,
     matched?: string[],
-    isPartial?: boolean
+    isPartial?: boolean,
+    resolvedIds?: string[],
   ): void {
-    const newSegmentOrder = filterSegmentOrder(matched ?? []);
+    const rawMatched = matched ?? [];
+    const newSegmentOrder = filterSegmentOrder(rawMatched);
+    // Separate list for useSegments(): "layouts and routes only" — strip
+    // parallels (".@") and loader sub-ids (D digit) without reordering.
+    const newRouteSegmentIds = rawMatched.filter(
+      (id) => !id.includes(".@") && !/D\d+\./.test(id),
+    );
 
     if (isPartial && newSegmentOrder.length > 0) {
       // Partial update: merge new data with existing
@@ -748,10 +786,19 @@ export function createEventController(
           handleData[handleName][segmentId] = data[handleName][segmentId];
         }
       }
-      // Clean up data from segments no longer in the matched list
+      const resolvedIdSet =
+        resolvedIds && resolvedIds.length > 0 ? new Set(resolvedIds) : null;
+      // Cleanup pass:
+      //   a) segment dropped from the match list — delete its bucket.
+      //   b) segment was re-resolved this request but pushed nothing for
+      //      this handle — its previous bucket is stale.
+      // (a) is the existing behavior; (b) requires resolvedIds.
       for (const handleName of Object.keys(handleData)) {
         for (const segmentId of Object.keys(handleData[handleName])) {
-          if (!newSegmentOrder.includes(segmentId)) {
+          const droppedFromMatch = !newSegmentOrder.includes(segmentId);
+          const reresolvedWithoutPush =
+            resolvedIdSet?.has(segmentId) && !data[handleName]?.[segmentId];
+          if (droppedFromMatch || reresolvedWithoutPush) {
             delete handleData[handleName][segmentId];
           }
         }
@@ -761,6 +808,7 @@ export function createEventController(
       handleData = data;
     }
     handleSegmentOrder = newSegmentOrder;
+    routeSegmentIds = newRouteSegmentIds;
 
     notifyHandles();
   }
@@ -769,6 +817,7 @@ export function createEventController(
     return {
       data: handleData,
       segmentOrder: handleSegmentOrder,
+      routeSegmentIds,
     };
   }
 
@@ -783,7 +832,7 @@ export function createEventController(
 
   function subscribeToAction(
     actionId: string,
-    listener: ActionStateListener
+    listener: ActionStateListener,
   ): () => void {
     let listeners = actionListeners.get(actionId);
     if (!listeners) {
@@ -805,6 +854,19 @@ export function createEventController(
     return () => handleListeners.delete(listener);
   }
 
+  // ========================================================================
+  // Params Operations
+  // ========================================================================
+
+  function setParams(params: Record<string, string>): void {
+    routeParams = params;
+    notify();
+  }
+
+  function getParams(): Record<string, string> {
+    return routeParams;
+  }
+
   // ========================================================================
   // Return Controller
   // ========================================================================
@@ -821,12 +883,17 @@ export function createEventController(
     // State
     getState,
     getActionState,
+    getLocation: () => location,
     setLocation,
 
     // Handles
     setHandleData,
     getHandleState,
 
+    // Params
+    setParams,
+    getParams,
+
     // Subscriptions
     subscribe,
     subscribeToAction,
@@ -835,6 +902,7 @@ export function createEventController(
     // Direct access
     getCurrentNavigation: () => currentNavigation,
     getInflightActions: () => inflightActions,
+    hadAnyConcurrentActions: () => hadAnyConcurrentActions,
   };
 }
 
@@ -848,7 +916,7 @@ let controllerInstance: EventController | null = null;
  * Initialize the global event controller
  */
 export function initEventController(
-  config?: EventControllerConfig
+  config?: EventControllerConfig,
 ): EventController {
   if (!controllerInstance) {
     controllerInstance = createEventController(config);
@@ -862,7 +930,7 @@ export function initEventController(
 export function getEventController(): EventController {
   if (!controllerInstance) {
     throw new Error(
-      "Event controller not initialized. Call initEventController first."
+      "Event controller not initialized. Call initEventController first.",
     );
   }
   return controllerInstance;