@rangojs/router 0.0.0-experimental.92 → 0.0.0-experimental.95

package/dist/vite/index.js

@@ -2040,7 +2040,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.92",
+  version: "0.0.0-experimental.95",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -3376,11 +3376,10 @@ function createVersionInjectorPlugin(rscEntryPath) {
       if (normalizedId !== normalizedEntry) {
         return null;
       }
-      const prepend = [];
+      const prepend = [
+        `import "virtual:rsc-router/routes-manifest";`
+      ];
       let newCode = code;
-      if (!code.includes("virtual:rsc-router/routes-manifest")) {
-        prepend.push(`import "virtual:rsc-router/routes-manifest";`);
-      }
       const needsVersion = code.includes("createRSCHandler") && !code.includes("@rangojs/router:version") && /createRSCHandler\s*\(\s*\{/.test(code);
       if (needsVersion) {
         prepend.push(`import { VERSION } from "@rangojs/router:version";`);
@@ -3389,8 +3388,21 @@ function createVersionInjectorPlugin(rscEntryPath) {
           "createRSCHandler({\n  version: VERSION,"
         );
       }
-      if (prepend.length === 0 && newCode === code) return null;
-      newCode = prepend.join("\n") + (prepend.length > 0 ? "\n" : "") + newCode;
+      const lines = newCode.split("\n");
+      let insertAt = 0;
+      while (insertAt < lines.length) {
+        const trimmed = lines[insertAt].trim();
+        if (trimmed === "" || /^\/\/\/\s*<reference\b/.test(trimmed)) {
+          insertAt++;
+        } else {
+          break;
+        }
+      }
+      newCode = [
+        ...lines.slice(0, insertAt),
+        ...prepend,
+        ...lines.slice(insertAt)
+      ].join("\n");
       return {
         code: newCode,
         map: null
@@ -3784,6 +3796,12 @@ function markSelfGenWrite(state, filePath, content) {
   state.selfWrittenGenFiles.set(filePath, { at: Date.now(), hash });
 }
 function consumeSelfGenWrite(state, filePath) {
+  return checkSelfGenWrite(state, filePath, true);
+}
+function peekSelfGenWrite(state, filePath) {
+  return checkSelfGenWrite(state, filePath, false);
+}
+function checkSelfGenWrite(state, filePath, consume) {
   const info = state.selfWrittenGenFiles.get(filePath);
   if (!info) return false;
   if (Date.now() - info.at > state.SELF_WRITE_WINDOW_MS) {
@@ -3794,7 +3812,7 @@ function consumeSelfGenWrite(state, filePath) {
     const current = readFileSync3(filePath, "utf-8");
     const currentHash = createHash3("sha256").update(current).digest("hex");
     if (currentHash === info.hash) {
-      state.selfWrittenGenFiles.delete(filePath);
+      if (consume) state.selfWrittenGenFiles.delete(filePath);
       return true;
     }
     return false;
@@ -5067,6 +5085,80 @@ function postprocessBundle(state) {
   }
 }
 
+// src/vite/discovery/gate-state.ts
+function createDiscoveryGate(s, debug11) {
+  let gatePending = false;
+  let gateResolver = () => {
+  };
+  let inProgress = false;
+  let queued = false;
+  let pendingEvents = false;
+  const beginGate = () => {
+    if (gatePending) return;
+    s.discoveryDone = new Promise((resolve10) => {
+      gateResolver = resolve10;
+    });
+    gatePending = true;
+  };
+  const resolveGate = () => {
+    if (!gatePending) return;
+    if (inProgress || queued || pendingEvents) {
+      debug11?.(
+        "hmr: resolveGate deferred \u2014 work in flight (inProgress=%s queued=%s pendingEvents=%s)",
+        inProgress,
+        queued,
+        pendingEvents
+      );
+      return;
+    }
+    gatePending = false;
+    debug11?.("hmr: discoveryDone resolved");
+    gateResolver();
+  };
+  const noteRouteEvent = () => {
+    pendingEvents = true;
+    beginGate();
+  };
+  const runRefreshCycle = async (work) => {
+    if (inProgress) {
+      queued = true;
+      debug11?.("hmr: rediscovery in flight \u2014 queued for a follow-up cycle");
+      return;
+    }
+    pendingEvents = false;
+    inProgress = true;
+    try {
+      await work();
+    } finally {
+      inProgress = false;
+      if (queued) {
+        queued = false;
+        debug11?.("hmr: consuming queued rediscovery");
+        runRefreshCycle(work).catch((err) => {
+          debug11?.(
+            "hmr: queued cycle rejected \u2014 releasing gate (%s)",
+            err instanceof Error ? err.message : String(err)
+          );
+          resolveGate();
+        });
+      } else if (pendingEvents) {
+        debug11?.(
+          "hmr: holding gate for pending events (debounce not yet fired)"
+        );
+      } else {
+        resolveGate();
+      }
+    }
+  };
+  return {
+    beginGate,
+    resolveGate,
+    noteRouteEvent,
+    runRefreshCycle,
+    state: () => ({ gatePending, inProgress, queued, pendingEvents })
+  };
+}
+
 // src/vite/router-discovery.ts
 var debugDiscovery = createRangoDebugger(NS.discovery);
 var debugRoutes = createRangoDebugger(NS.routes);
@@ -5231,6 +5323,9 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
       const discoveryPromise = new Promise((resolve10) => {
         resolveDiscovery = resolve10;
       });
+      const gate = createDiscoveryGate(s, debugDiscovery);
+      const beginDiscoveryGate = gate.beginGate;
+      const resolveDiscoveryGate = gate.resolveGate;
       const getDevServerOrigin = () => server.resolvedUrls?.local?.[0]?.replace(/\/$/, "") || `http://localhost:${server.config.server.port || 5173}`;
       let prerenderTempServer = null;
       let prerenderNodeRegistry = null;
@@ -5243,35 +5338,157 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
         releaseBuildEnv(s).catch(() => {
         });
       });
+      async function importEntryAndRegistry(tempRscEnv) {
+        const flagAlreadySet = !!globalThis.__rscRouterDiscoveryActive;
+        if (!flagAlreadySet) {
+          globalThis.__rscRouterDiscoveryActive = true;
+        }
+        try {
+          debugDiscovery?.(
+            "importEntryAndRegistry: importing entry (flag=%s)",
+            globalThis.__rscRouterDiscoveryActive ?? false
+          );
+          await tempRscEnv.runner.import(s.resolvedEntryPath);
+          debugDiscovery?.(
+            "importEntryAndRegistry: entry import OK, fetching RouterRegistry"
+          );
+          const serverMod = await tempRscEnv.runner.import(
+            "@rangojs/router/server"
+          );
+          prerenderNodeRegistry = serverMod.RouterRegistry;
+          debugDiscovery?.(
+            "importEntryAndRegistry: registry size=%d",
+            prerenderNodeRegistry?.size ?? 0
+          );
+        } finally {
+          if (!flagAlreadySet) {
+            delete globalThis.__rscRouterDiscoveryActive;
+            debugDiscovery?.(
+              "importEntryAndRegistry: cleared __rscRouterDiscoveryActive"
+            );
+          }
+        }
+      }
       async function getOrCreateTempServer() {
-        if (prerenderNodeRegistry) {
-          return prerenderTempServer.environments?.rsc ?? null;
+        if (prerenderTempServer) {
+          const existingEnv = prerenderTempServer.environments?.rsc;
+          if (existingEnv?.runner) {
+            if (prerenderNodeRegistry) {
+              debugDiscovery?.(
+                "getOrCreateTempServer: cached temp runner reused"
+              );
+              return existingEnv;
+            }
+            debugDiscovery?.(
+              "getOrCreateTempServer: server alive but registry missing \u2014 re-importing"
+            );
+            try {
+              await importEntryAndRegistry(existingEnv);
+              return existingEnv;
+            } catch (err) {
+              debugDiscovery?.(
+                "getOrCreateTempServer: reuse import failed (%s) \u2014 closing orphan and creating fresh",
+                err?.message ?? String(err)
+              );
+              await prerenderTempServer.close().catch(() => {
+              });
+              prerenderTempServer = null;
+              prerenderNodeRegistry = null;
+            }
+          } else {
+            debugDiscovery?.(
+              "getOrCreateTempServer: existing server has no rsc.runner \u2014 closing and recreating"
+            );
+            await prerenderTempServer.close().catch(() => {
+            });
+            prerenderTempServer = null;
+            prerenderNodeRegistry = null;
+          }
         }
+        debugDiscovery?.(
+          "getOrCreateTempServer: creating new temp server, entry=%s",
+          s.resolvedEntryPath ?? "(unset)"
+        );
         try {
           prerenderTempServer = await createTempRscServer(s, {
             cacheDir: "node_modules/.vite_prerender"
           });
           const tempRscEnv = prerenderTempServer.environments?.rsc;
           if (tempRscEnv?.runner) {
-            await tempRscEnv.runner.import(s.resolvedEntryPath);
-            const serverMod = await tempRscEnv.runner.import(
-              "@rangojs/router/server"
-            );
-            prerenderNodeRegistry = serverMod.RouterRegistry;
+            await importEntryAndRegistry(tempRscEnv);
             return tempRscEnv;
           }
+          debugDiscovery?.(
+            "getOrCreateTempServer: tempRscEnv.runner unavailable"
+          );
         } catch (err) {
+          debugDiscovery?.(
+            "getOrCreateTempServer: FAILED message=%s",
+            err.message
+          );
           console.warn(
             `[rsc-router] Failed to create temp runner: ${err.message}`
           );
         }
         return null;
       }
+      async function clearTempRegistries(tempRscEnv) {
+        try {
+          const serverMod = await tempRscEnv.runner.import(
+            "@rangojs/router/server"
+          );
+          if (typeof serverMod?.RouterRegistry?.clear === "function") {
+            serverMod.RouterRegistry.clear();
+          }
+          if (typeof serverMod?.HostRouterRegistry?.clear === "function") {
+            serverMod.HostRouterRegistry.clear();
+          }
+          debugDiscovery?.(
+            "clearTempRegistries: cleared RouterRegistry + HostRouterRegistry"
+          );
+        } catch (err) {
+          debugDiscovery?.(
+            "clearTempRegistries: import @rangojs/router/server failed (%s)",
+            err?.message ?? String(err)
+          );
+        }
+      }
+      async function refreshTempRscEnv() {
+        let tempRscEnv = await getOrCreateTempServer();
+        if (!tempRscEnv) return null;
+        const envGraph = tempRscEnv.moduleGraph;
+        const serverGraph = prerenderTempServer?.moduleGraph;
+        const target = envGraph?.invalidateAll ? envGraph : serverGraph?.invalidateAll ? serverGraph : null;
+        if (!target) {
+          debugDiscovery?.(
+            "refreshTempRscEnv: invalidateAll unavailable on env+server graphs, falling back to close+recreate"
+          );
+          if (prerenderTempServer) {
+            await prerenderTempServer.close().catch(() => {
+            });
+            prerenderTempServer = null;
+            prerenderNodeRegistry = null;
+          }
+          return await getOrCreateTempServer();
+        }
+        debugDiscovery?.(
+          "refreshTempRscEnv: invalidating module graph (%s)",
+          envGraph?.invalidateAll ? "env" : "server"
+        );
+        target.invalidateAll();
+        prerenderNodeRegistry = null;
+        await clearTempRegistries(tempRscEnv);
+        await importEntryAndRegistry(tempRscEnv);
+        return tempRscEnv;
+      }
       const discover = async () => {
         const discoverStart = performance.now();
         const rscEnv = server.environments?.rsc;
         if (!rscEnv?.runner) {
-          debugDiscovery?.("dev: no rsc runner (cloudflare path)");
+          debugDiscovery?.(
+            "dev: cloudflare path start, __rscRouterDiscoveryActive=%s",
+            globalThis.__rscRouterDiscoveryActive ?? false
+          );
           s.devServerOrigin = getDevServerOrigin();
           try {
             await timed(
@@ -5353,9 +5570,11 @@ ${err.stack}`
           resolveDiscovery();
         }
       };
-      s.discoveryDone = new Promise((resolve10) => {
-        setTimeout(() => discover().then(resolve10, resolve10), 0);
-      });
+      beginDiscoveryGate();
+      setTimeout(
+        () => discover().then(resolveDiscoveryGate, resolveDiscoveryGate),
+        0
+      );
       let mainRegistry = null;
       const propagateDiscoveryState = async (rscEnv) => {
         const serverMod = await rscEnv.runner.import("@rangojs/router/server");
@@ -5504,49 +5723,80 @@ ${err.stack}`
           return true;
         };
         let routeChangeTimer;
-        let runtimeRediscoveryInProgress = false;
         const refreshRuntimeDiscovery = async () => {
           const rscEnv = server.environments?.rsc;
-          if (!rscEnv?.runner || runtimeRediscoveryInProgress) return;
-          runtimeRediscoveryInProgress = true;
-          const hmrStart = performance.now();
-          try {
-            await timed(
-              debugDiscovery,
-              "hmr discoverRouters",
-              () => discoverRouters(s, rscEnv)
-            );
-            timedSync(
-              debugDiscovery,
-              "hmr writeRouteTypesFiles",
-              () => writeRouteTypesFiles(s)
-            );
-            await timed(
-              debugDiscovery,
-              "hmr propagateDiscoveryState",
-              () => propagateDiscoveryState(rscEnv)
-            );
-          } catch (err) {
-            console.warn(
-              `[rsc-router] Runtime re-discovery failed: ${err.message}`
-            );
-          } finally {
-            debugDiscovery?.(
-              "hmr re-discovery done (%sms)",
-              (performance.now() - hmrStart).toFixed(1)
-            );
-            runtimeRediscoveryInProgress = false;
-          }
+          const hasMainRunner = !!rscEnv?.runner;
+          if (!hasMainRunner && s.perRouterManifests.length === 0) return;
+          await gate.runRefreshCycle(async () => {
+            const hmrStart = performance.now();
+            try {
+              if (hasMainRunner) {
+                await timed(
+                  debugDiscovery,
+                  "hmr discoverRouters",
+                  () => discoverRouters(s, rscEnv)
+                );
+                timedSync(
+                  debugDiscovery,
+                  "hmr writeRouteTypesFiles",
+                  () => writeRouteTypesFiles(s)
+                );
+                await timed(
+                  debugDiscovery,
+                  "hmr propagateDiscoveryState",
+                  () => propagateDiscoveryState(rscEnv)
+                );
+              } else {
+                const tempRscEnv = await timed(
+                  debugDiscovery,
+                  "hmr refreshTempRscEnv (cloudflare)",
+                  () => refreshTempRscEnv()
+                );
+                if (!tempRscEnv) {
+                  throw new Error(
+                    "temp runner unavailable for cloudflare HMR rediscovery"
+                  );
+                }
+                await timed(
+                  debugDiscovery,
+                  "hmr discoverRouters (cloudflare)",
+                  () => discoverRouters(s, tempRscEnv)
+                );
+                timedSync(
+                  debugDiscovery,
+                  "hmr writeRouteTypesFiles",
+                  () => writeRouteTypesFiles(s)
+                );
+              }
+            } catch (err) {
+              console.warn(
+                `[rsc-router] Runtime re-discovery failed: ${err.message}`
+              );
+            } finally {
+              debugDiscovery?.(
+                "hmr re-discovery done (%sms)",
+                (performance.now() - hmrStart).toFixed(1)
+              );
+            }
+          });
         };
         const scheduleRouteRegeneration = () => {
           clearTimeout(routeChangeTimer);
           routeChangeTimer = setTimeout(() => {
             routeChangeTimer = void 0;
             const regenStart = debugDiscovery ? performance.now() : 0;
+            const rscEnv = server.environments?.rsc;
+            const skipStaticWrite = !rscEnv?.runner && s.perRouterManifests.length > 0;
             try {
-              writeCombinedRouteTypesWithTracking(s);
-              if (s.perRouterManifests.length > 0) {
-                supplementGenFilesWithRuntimeRoutes(s);
+              if (skipStaticWrite) {
+                debugDiscovery?.(
+                  "watcher: skipping static write (cloudflare HMR \u2014 runtime rediscovery owns gen file)"
+                );
+              } else {
+                writeCombinedRouteTypesWithTracking(s);
+                if (s.perRouterManifests.length > 0) {
+                  supplementGenFilesWithRuntimeRoutes(s);
+                }
               }
             } catch (err) {
               console.error(
@@ -5562,6 +5812,7 @@ ${err.stack}`
                 console.warn(
                   `[rsc-router] Runtime re-discovery error: ${err.message}`
                 );
+                resolveDiscoveryGate();
               });
             }
           }, 100);
@@ -5598,6 +5849,9 @@ ${err.stack}`
               }
               s.cachedRouterFiles = void 0;
             }
+            if (s.perRouterManifests.length > 0) {
+              gate.noteRouteEvent();
+            }
             scheduleRouteRegeneration();
           } catch {
           }
@@ -5696,6 +5950,34 @@ ${details}`
         );
       }
     },
+    // Suppress vite's HMR cascade for our own gen-file writes.
+    //
+    // After every cf HMR cycle, refreshTempRscEnv → writeRouteTypesFiles
+    // writes the configured gen files (default `router.named-routes.gen.ts`,
+    // but the source filenames and gen suffix are user-configurable). The
+    // chokidar watcher then fires twice independently: our
+    // `handleRouteFileChange` (already short-circuited by
+    // `consumeSelfGenWrite` inside `maybeHandleGeneratedRouteFileMutation`),
+    // AND vite's own HMR pipeline (which invalidates the gen file's
+    // importers and triggers a second workerd full reload — visible to the
+    // user as a duplicate "[RSCRouter] HMR: version changed" on the client).
+    //
+    // `peekSelfGenWrite` is the authoritative filter: its map only contains
+    // paths that `markSelfGenWrite` has registered, so it natively works
+    // for any configured gen-file name. It is non-consuming so the chokidar
+    // handler that fires later can still consume the same entry. Returning
+    // [] tells vite "no modules invalidated by this change" — safe because
+    // `s.perRouterManifests` is already up-to-date (the write that just
+    // happened is the consequence of our just-completed rediscovery).
+    handleHotUpdate(ctx) {
+      if (peekSelfGenWrite(s, ctx.file)) {
+        debugDiscovery?.(
+          "handleHotUpdate: suppressing self-write HMR cascade for %s",
+          ctx.file
+        );
+        return [];
+      }
+    },
     // Virtual module: provides the pre-generated route manifest as a JS module
     // that calls setCachedManifest() at import time.
     resolveId(id) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rangojs/router",
-  "version": "0.0.0-experimental.92",
+  "version": "0.0.0-experimental.95",
   "description": "Django-inspired RSC router with composable URL patterns",
   "keywords": [
     "react",

package/src/browser/event-controller.ts

@@ -113,11 +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[];
+  routeSegmentIds: string[];
 }
 
 /**
@@ -202,6 +215,14 @@ export interface EventController {
     data: HandleData,
     matched?: string[],
     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;
 
@@ -300,6 +321,7 @@ 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> = {};
@@ -744,8 +766,15 @@ export function createEventController(
     data: HandleData,
     matched?: string[],
     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
@@ -757,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];
           }
         }
@@ -770,6 +808,7 @@ export function createEventController(
       handleData = data;
     }
     handleSegmentOrder = newSegmentOrder;
+    routeSegmentIds = newRouteSegmentIds;
 
     notifyHandles();
   }
@@ -778,6 +817,7 @@ export function createEventController(
     return {
       data: handleData,
       segmentOrder: handleSegmentOrder,
+      routeSegmentIds,
     };
   }
 

package/src/browser/react/NavigationProvider.tsx

@@ -47,10 +47,22 @@ async function processHandles(
     store: NavigationStore;
     matched?: string[];
     isPartial?: boolean;
+    /** Server's `resolvedIds`: every segment re-resolved this request,
+     *  including null-component ones excluded from `diff`/`segments`.
+     *  Drives cleanup of stale handle buckets when a re-resolved segment
+     *  pushed nothing. */
+    resolvedIds?: string[];
     historyKey: string;
   },
 ): Promise<void> {
-  const { eventController, store, matched, isPartial, historyKey } = opts;
+  const {
+    eventController,
+    store,
+    matched,
+    isPartial,
+    resolvedIds,
+    historyKey,
+  } = opts;
 
   let yieldCount = 0;
   for await (const handleData of handlesGenerator) {
@@ -65,7 +77,7 @@ async function processHandles(
     }
 
     yieldCount++;
-    eventController.setHandleData(handleData, matched, isPartial);
+    eventController.setHandleData(handleData, matched, isPartial, resolvedIds);
   }
 
   // Check again before final updates
@@ -73,12 +85,11 @@ async function processHandles(
     return;
   }
 
-  // For partial updates where the generator yielded nothing (cached handlers),
-  // we still need to update the segment order to clean up stale handle data.
-  // This happens when navigating away from a route - the handlers for the new
-  // route might not push any breadcrumbs, but we still need to remove the old ones.
+  // For partial updates where the generator yielded nothing (every
+  // re-resolved handler pushed nothing), still call setHandleData so the
+  // cleanup pass can clear out stale buckets for those segments.
   if (yieldCount === 0 && matched) {
-    eventController.setHandleData({}, matched, true);
+    eventController.setHandleData({}, matched, true, resolvedIds);
   }
 
   // After handles processing completes, update the cache's handleData.
@@ -394,6 +405,7 @@ export function NavigationProvider({
           store,
           matched: update.metadata.matched,
           isPartial: update.metadata.isPartial,
+          resolvedIds: update.metadata.resolvedIds,
           historyKey,
         }).catch((err) =>
           console.error("[NavigationProvider] Error consuming handles:", err),
@@ -412,6 +424,7 @@ export function NavigationProvider({
           {}, // Empty data - all existing data not in matched will be cleaned up
           update.metadata.matched,
           true, // partial update - will clean up segments not in matched
+          update.metadata.resolvedIds,
         );
       }
     });