@rangojs/router 0.34.0 → 0.34.1

package/dist/bin/rango.js

@@ -229,7 +229,7 @@ ${formatNestedRouterConflictError(nestedRouterConflict, "[rango]")}
   }
   let discoverAndWriteRouteTypes;
   try {
-    const mod = await import("./runtime-discovery-2ZTYRZ3V.js");
+    const mod = await import("./runtime-discovery-RY6NMQM3.js");
     discoverAndWriteRouteTypes = mod.discoverAndWriteRouteTypes;
   } catch (err) {
     if (err.code === "ERR_MODULE_NOT_FOUND" || err.code === "MODULE_NOT_FOUND") {

package/dist/bin/{runtime-discovery-2ZTYRZ3V.js → runtime-discovery-RY6NMQM3.js}

@@ -163,7 +163,7 @@ async function discoverAndWriteRouteTypes(opts) {
       "Runtime discovery requires '@vitejs/plugin-rsc'. Install it with: pnpm add -D @vitejs/plugin-rsc"
     );
   }
-  const { createTempRscServer } = await import("./temp-rsc-server-EUNKRFJD.js");
+  const { createTempRscServer } = await import("./temp-rsc-server-F7AHOPV4.js");
   const { createDiscoveryState } = await import("./state-ACD2MGKJ.js");
   const { discoverClientUrlProjections } = await import("./client-urls-projection-4Q5EQDAL.js");
   const {

package/dist/bin/{temp-rsc-server-EUNKRFJD.js → temp-rsc-server-F7AHOPV4.js}

@@ -47,7 +47,7 @@ var DEFAULT_ROUTER_VERSIONS_KEY = "*";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.34.0",
+  version: "0.34.1",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",

package/dist/types/loader-store.d.ts

@@ -28,6 +28,10 @@
  *     cancelled on resubscribe so a StrictMode / transition remount does not
  *     reclaim a bucket that is about to be reused, and is held until any
  *     in-flight load settles.
+ *   - Owned buckets (one reader's private refresh-group bucket,
+ *     `useLoader(L, { refreshGroup })` without a key) are sticky while that
+ *     reader is mounted and dropped like an ephemeral bucket once it leaves:
+ *     no other reader names the bucket, and a remount takes a new one.
  *
  * Each router's NavigationStore owns one (navigation-store.ts), and hooks reach
  * it through NavigationStoreContext: the router store is the single source of
@@ -79,6 +83,13 @@ export interface SubscribeOptions {
      * subscriber attaches, and from then on resets via `clearFamily`.
      */
     ephemeral?: boolean;
+    /**
+     * When true, the bucket belongs to this subscriber alone (a private
+     * refresh-group bucket, which no other reader names): it is reset by
+     * `clearFamily` while subscribed, and dropped after the subscriber leaves
+     * even when sticky. Read at unsubscribe, so pass it on every subscribe.
+     */
+    owned?: boolean;
     /**
      * Cross-loader refresh group name(s). Tags this bucket so `refreshGroups(name)`
      * can refresh it alongside buckets of other loaders. A bucket may be tagged
@@ -130,8 +141,8 @@ export declare class LoaderStore {
      * Subscribe to entry changes for `bucketKey`.
      * Returns an unsubscribe function. A sticky bucket's entry is kept around even
      * after the last subscriber leaves so that an in-flight `load()` can still
-     * commit if the consumer remounts. An ephemeral bucket is dropped once its
-     * last subscriber leaves (deferred, see maybeScheduleRefcountClear).
+     * commit if the consumer remounts. An ephemeral or owned bucket is dropped
+     * once its last subscriber leaves (deferred, see maybeScheduleRefcountClear).
      */
     subscribe(bucketKey: string, cb: () => void, options?: SubscribeOptions): () => void;
     private addToGroup;
@@ -149,14 +160,14 @@ export declare class LoaderStore {
      */
     refreshGroups(groups: string | string[]): Promise<void>;
     /**
-     * Schedule a deferred drop for an ad-hoc (never-sticky) bucket whose last
-     * subscriber just left. Deferred to a microtask so a StrictMode / transition
-     * remount that resubscribes in the same tick cancels it.
+     * Schedule a deferred drop for an ad-hoc (never-sticky) or owned bucket
+     * whose last subscriber just left. Deferred to a microtask so a StrictMode /
+     * transition remount that resubscribes in the same tick cancels it.
      */
     private maybeScheduleRefcountClear;
     /** Remove a bucket entry entirely and prune it from its family/group indexes. */
     private dropBucket;
-    /** Drop an ephemeral bucket that settled with no subscribers left. */
+    /** Drop an ephemeral or owned bucket that settled with no subscribers left. */
     private dropIfSettled;
     /**
      * Returns the current snapshot for `bucketKey`. Stable reference between
@@ -205,7 +216,8 @@ export declare class LoaderStore {
      * Reset a single bucket entry. Bumps `latestRequestId` so any in-flight
      * `load()` whose promise is still pending will fail its gate when it resolves
      * and be dropped — prevents pre-navigation loads from clobbering the new
-     * route's context. The entry itself is kept (sticky-bucket semantics).
+     * route's context. The entry itself is kept (sticky-bucket semantics),
+     * unless it was only waiting for that request to be dropped.
      */
     clear(bucketKey: string): void;
     /**

package/dist/types/router/match-context.d.ts

@@ -112,6 +112,7 @@ import type { CacheScope } from "../cache/cache-scope.js";
 import type { EntryData, InterceptSelectorContext, MetricsStore } from "../server/context.js";
 import type { HandlerContext, ResolvedSegment } from "../types.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
+import type { PrevPage } from "./navigation-snapshot.js";
 import type { InterceptResult } from "./router-context.js";
 import type { ResolutionPassInput } from "./segment-resolution/resolution-pass.js";
 import type { ActionContext } from "./types.js";
@@ -130,7 +131,10 @@ export interface MatchContext<TEnv = any> {
     heldBoundary?: string;
     prevUrl: URL;
     prevParams: Record<string, string>;
+    /** The match of the page left: the intercept's URL while one is open. */
     prevMatch: RouteMatchResult | null;
+    /** The page an open intercept's slot was rendered for. */
+    interceptPrev: PrevPage;
     matched: RouteMatchResult;
     manifestEntry: EntryData;
     entries: EntryData[];
@@ -169,6 +173,14 @@ export interface MatchContext<TEnv = any> {
 export declare function rendersLive(ctx: Pick<MatchContext, "isAction" | "stale">): boolean;
 /** This match as the input of a revalidating resolution pass (resolution-pass.ts). */
 export declare function resolutionPassInput<TEnv>(ctx: MatchContext<TEnv>): ResolutionPassInput<TEnv>;
+/**
+ * This match as the input of the pass that resolves its intercept's slot: its
+ * held segments compare with the intercept's own URL (`interceptPrev`), not
+ * with the source page under it. From /item/2 over /list/1, a link to /item/1
+ * compared with the source's params would read as param-equal and keep item
+ * 2's slot.
+ */
+export declare function interceptPassInput<TEnv>(ctx: MatchContext<TEnv>): ResolutionPassInput<TEnv>;
 /**
  * Mutable state that flows through the pipeline
  */

package/dist/types/router/navigation-snapshot.d.ts

@@ -1,10 +1,27 @@
 import type { RouteMatchResult } from "./pattern-matching.js";
+/** A page held segments were rendered for: what their revalidation compares with. */
+export interface PrevPage {
+    url: URL;
+    params: Record<string, string>;
+}
 export interface NavigationSnapshot {
+    /**
+     * `prevUrl` and `prevParams`: the page the held page segments were rendered
+     * for. That is the page left, or the source page while an intercept is open
+     * (`hasInterceptSource`).
+     */
     prevUrl: URL;
     /** The visitor's URL of the page left, when `prevUrl` is its rewrite target. */
     prevVisitorUrl: URL | null;
     prevParams: Record<string, string>;
+    /** The match of the page left: the intercept's URL while one is open. */
     prevMatch: RouteMatchResult | null;
+    /**
+     * The page an open intercept's slot was rendered for: the intercept's own
+     * URL (match-context.ts interceptPassInput). Equals `prevUrl`/`prevParams`
+     * when the request names no intercept source.
+     */
+    interceptPrev: PrevPage;
     interceptContextUrl: URL;
     interceptContextMatch: RouteMatchResult | null;
     clientSegmentIds: string[];

package/dist/vite/index.js

@@ -7344,7 +7344,7 @@ function resolveVersionsFrom(table, routerId2) {
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.34.0",
+  version: "0.34.1",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rangojs/router",
-  "version": "0.34.0",
+  "version": "0.34.1",
   "description": "Django-inspired RSC router with composable URL patterns",
   "keywords": [
     "react",

package/skills/hooks/data.md

@@ -261,7 +261,10 @@ tag (`"account"`) covers everything, while a finer tag (`"orders"`) targets a
 subset. Sharing within a group is opt-in via `key`: members that share a `key`
 share one value (and one fetch); a grouped reader **without** a `key` gets its own
 private bucket, so a group refresh updates only that read and never leaks into
-unrelated unkeyed reads of the same loader. A bucket may belong to several groups
+unrelated unkeyed reads of the same loader. That private bucket lives as long as
+its read is mounted, and a hidden React `<Activity>` counts as unmounted: when it
+shows again, the read is back on the route's data until the next refresh. To keep
+a refreshed value across an `<Activity>` hide, give the read a `key`. A bucket may belong to several groups
 at once (one read tagged with multiple names, or different reads tagging the same
 keyed bucket with different names). Keep parameterized loaders on the single-loader
 `key` — a plain-GET group refresh sends no params.

package/src/loader-store.ts

@@ -28,6 +28,10 @@
  *     cancelled on resubscribe so a StrictMode / transition remount does not
  *     reclaim a bucket that is about to be reused, and is held until any
  *     in-flight load settles.
+ *   - Owned buckets (one reader's private refresh-group bucket,
+ *     `useLoader(L, { refreshGroup })` without a key) are sticky while that
+ *     reader is mounted and dropped like an ephemeral bucket once it leaves:
+ *     no other reader names the bucket, and a remount takes a new one.
  *
  * Each router's NavigationStore owns one (navigation-store.ts), and hooks reach
  * it through NavigationStoreContext: the router store is the single source of
@@ -97,6 +101,13 @@ export interface SubscribeOptions {
    * subscriber attaches, and from then on resets via `clearFamily`.
    */
   ephemeral?: boolean;
+  /**
+   * When true, the bucket belongs to this subscriber alone (a private
+   * refresh-group bucket, which no other reader names): it is reset by
+   * `clearFamily` while subscribed, and dropped after the subscriber leaves
+   * even when sticky. Read at unsubscribe, so pass it on every subscribe.
+   */
+  owned?: boolean;
   /**
    * Cross-loader refresh group name(s). Tags this bucket so `refreshGroups(name)`
    * can refresh it alongside buckets of other loaders. A bucket may be tagged
@@ -130,8 +141,8 @@ interface InternalEntry {
   /** Family id (loader.$$id) this bucket belongs to. */
   loaderId: string;
   /**
-   * True once any non-ephemeral subscriber has attached. Sticky buckets are
-   * never reference-count-dropped; they reset via clearFamily().
+   * True once any non-ephemeral subscriber has attached. Sticky buckets reset
+   * via clearFamily() and are reference-count-dropped only when owned.
    */
   sticky: boolean;
   /** A deferred refcount-drop microtask is scheduled and not yet cancelled. */
@@ -223,8 +234,8 @@ export class LoaderStore {
    * Subscribe to entry changes for `bucketKey`.
    * Returns an unsubscribe function. A sticky bucket's entry is kept around even
    * after the last subscriber leaves so that an in-flight `load()` can still
-   * commit if the consumer remounts. An ephemeral bucket is dropped once its
-   * last subscriber leaves (deferred, see maybeScheduleRefcountClear).
+   * commit if the consumer remounts. An ephemeral or owned bucket is dropped
+   * once its last subscriber leaves (deferred, see maybeScheduleRefcountClear).
    */
   subscribe(
     bucketKey: string,
@@ -261,7 +272,7 @@ export class LoaderStore {
       // different groups stays in each group until ALL of that group's
       // subscribers have left (order-independent).
       for (const group of groups) this.releaseGroup(group, bucketKey, e);
-      this.maybeScheduleRefcountClear(bucketKey, e);
+      this.maybeScheduleRefcountClear(bucketKey, e, options?.owned);
     };
   }
 
@@ -354,17 +365,18 @@ export class LoaderStore {
   }
 
   /**
-   * Schedule a deferred drop for an ad-hoc (never-sticky) bucket whose last
-   * subscriber just left. Deferred to a microtask so a StrictMode / transition
-   * remount that resubscribes in the same tick cancels it.
+   * Schedule a deferred drop for an ad-hoc (never-sticky) or owned bucket
+   * whose last subscriber just left. Deferred to a microtask so a StrictMode /
+   * transition remount that resubscribes in the same tick cancels it.
    */
   private maybeScheduleRefcountClear(
     bucketKey: string,
     e: InternalEntry,
+    owned: boolean | undefined,
   ): void {
     if (e.listeners.size > 0) return;
-    // Sticky buckets persist for remount; they reset via clearFamily().
-    if (e.sticky) return;
+    // Sticky buckets persist for remount unless owned; they reset via clearFamily().
+    if (e.sticky && !owned) return;
     if (e.pendingClear) return;
     e.pendingClear = true;
     queueMicrotask(() => {
@@ -393,7 +405,7 @@ export class LoaderStore {
     }
   }
 
-  /** Drop an ephemeral bucket that settled with no subscribers left. */
+  /** Drop an ephemeral or owned bucket that settled with no subscribers left. */
   private dropIfSettled(bucketKey: string, e: InternalEntry): void {
     if (e.clearWhenSettled && e.listeners.size === 0) {
       e.clearWhenSettled = false;
@@ -523,7 +535,8 @@ export class LoaderStore {
    * Reset a single bucket entry. Bumps `latestRequestId` so any in-flight
    * `load()` whose promise is still pending will fail its gate when it resolves
    * and be dropped — prevents pre-navigation loads from clobbering the new
-   * route's context. The entry itself is kept (sticky-bucket semantics).
+   * route's context. The entry itself is kept (sticky-bucket semantics),
+   * unless it was only waiting for that request to be dropped.
    */
   clear(bucketKey: string): void {
     const e = this.entries.get(bucketKey);
@@ -532,6 +545,9 @@ export class LoaderStore {
     if (e.snapshot === EMPTY_SNAPSHOT) return;
     e.snapshot = EMPTY_SNAPSHOT;
     this.notify(e);
+    // An owned bucket left mid-flight waits for its request to settle, which
+    // the bump above stops from committing.
+    this.dropIfSettled(bucketKey, e);
   }
 
   /**

package/src/router/match-api.ts

@@ -203,6 +203,7 @@ export async function createMatchContextForFull<TEnv>(
     prevUrl: cleanUrl,
     prevParams: {},
     prevMatch: null,
+    interceptPrev: { url: cleanUrl, params: {} },
     matched,
     manifestEntry: snapshot.manifestEntry,
     entries: snapshot.entries,
@@ -520,6 +521,7 @@ export async function createMatchContextForPartial<TEnv>(
     prevUrl: nav.prevUrl,
     prevParams: nav.prevParams,
     prevMatch: nav.prevMatch,
+    interceptPrev: nav.interceptPrev,
     matched,
     manifestEntry: snapshot.manifestEntry,
     entries: snapshot.entries,

package/src/router/match-context.ts

@@ -116,6 +116,7 @@ import type {
 } from "../server/context.js";
 import type { HandlerContext, ResolvedSegment } from "../types.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
+import type { PrevPage } from "./navigation-snapshot.js";
 import type { InterceptResult } from "./router-context.js";
 import type { ResolutionPassInput } from "./segment-resolution/resolution-pass.js";
 import type { ActionContext } from "./types.js";
@@ -139,10 +140,13 @@ export interface MatchContext<TEnv = any> {
   /** NavigationSnapshot.heldBoundary: the walk stops above it. */
   heldBoundary?: string;
 
-  // Previous navigation state
+  // Previous navigation state: see NavigationSnapshot.
   prevUrl: URL;
   prevParams: Record<string, string>;
+  /** The match of the page left: the intercept's URL while one is open. */
   prevMatch: RouteMatchResult | null;
+  /** The page an open intercept's slot was rendered for. */
+  interceptPrev: PrevPage;
 
   // Current route match
   matched: RouteMatchResult;
@@ -225,6 +229,23 @@ export function resolutionPassInput<TEnv>(
   };
 }
 
+/**
+ * This match as the input of the pass that resolves its intercept's slot: its
+ * held segments compare with the intercept's own URL (`interceptPrev`), not
+ * with the source page under it. From /item/2 over /list/1, a link to /item/1
+ * compared with the source's params would read as param-equal and keep item
+ * 2's slot.
+ */
+export function interceptPassInput<TEnv>(
+  ctx: MatchContext<TEnv>,
+): ResolutionPassInput<TEnv> {
+  return {
+    ...resolutionPassInput(ctx),
+    prevUrl: ctx.interceptPrev.url,
+    prevParams: ctx.interceptPrev.params,
+  };
+}
+
 /**
  * Mutable state that flows through the pipeline
  */

package/src/router/match-middleware/cache-lookup.ts

@@ -49,6 +49,7 @@ import {
   type MatchPipelineState,
 } from "../match-context.js";
 import { getRouterContext, type RouterContext } from "../router-context.js";
+import type { PrevPage } from "../navigation-snapshot.js";
 import { freshPassInput } from "../segment-resolution/resolution-pass.js";
 import { observeEvent } from "../instrument.js";
 import { pushRevalidationTraceEntry, isTraceActive } from "../logging.js";
@@ -336,7 +337,12 @@ function storedEntrySends<TEnv>(
   router: RouterContext<TEnv>,
 ): (segment: ResolvedSegment) => boolean | Promise<boolean> {
   if (ctx.isFullMatch) return () => true;
-  const paramsChanged = !paramsEqual(ctx.matched.params, ctx.prevParams);
+  // An intercept variant's slot compares with the intercept's own page, the
+  // page under it with the source (MatchContext.interceptPrev).
+  const pagePrev: PrevPage = { url: ctx.prevUrl, params: ctx.prevParams };
+  const slotPrev = ctx.interceptPrev;
+  const pageParamsChanged = !paramsEqual(ctx.matched.params, pagePrev.params);
+  const slotParamsChanged = !paramsEqual(ctx.matched.params, slotPrev.params);
   const resendRouteSegments = replaceable && (ctx.isAction || ctx.stale);
   const entryRevalidateMap =
     ctx.clientSegmentSet.size > 0
@@ -345,11 +351,11 @@ function storedEntrySends<TEnv>(
   // A keep that hangs on the source's params is right for the pages with
   // the same params only: scope a prefetch of the answer to them, as a
   // predicate that compared every param would (#1331).
-  const heldForSource = (): false => {
+  const heldForSource = (prevParams: Record<string, string>): false => {
     markSourceHeld(
       ctx.handlerContext as InternalHandlerContext<any, TEnv>,
-      readsOfAllParams(ctx.prevParams),
-      { params: ctx.prevParams, routeName: undefined },
+      readsOfAllParams(prevParams),
+      { params: prevParams, routeName: undefined },
     );
     return false;
   };
@@ -362,23 +368,26 @@ function storedEntrySends<TEnv>(
       ctx.clientSegmentSet,
     );
     if (fill !== undefined) return fill;
+    const ofSlot = isInterceptSegment(segment);
+    const prev = ofSlot ? slotPrev : pagePrev;
+    const paramsChanged = ofSlot ? slotParamsChanged : pageParamsChanged;
     if (segment.type === "route" || segment.belongsToRoute === true) {
       if (paramsChanged || resendRouteSegments) return true;
       // Kept on equal params, whatever the search: a source with other
       // params is sent it.
-      return heldForSource();
+      return heldForSource(prev.params);
     }
     const revalidate = entryRevalidateMap?.get(segment.id)?.revalidate;
     if (!revalidate?.length) return false;
     // Kept on equal params: from another source the rules run and may send
     // it.
-    if (!paramsChanged) return heldForSource();
+    if (!paramsChanged) return heldForSource(prev.params);
     return router.evaluateRevalidation({
       segment,
-      prevParams: ctx.prevParams,
+      prevParams: prev.params,
       getPrevSegment: null,
       request: ctx.request,
-      prevUrl: ctx.prevUrl,
+      prevUrl: prev.url,
       nextUrl: ctx.url,
       revalidations: revalidate.map((fn, i) => ({
         name: `revalidate${i}`,

package/src/router/match-middleware/intercept-resolution.ts

@@ -103,7 +103,7 @@
  */
 import type { ResolvedSegment } from "../../types.js";
 import type { MatchContext, MatchPipelineState } from "../match-context.js";
-import { resolutionPassInput } from "../match-context.js";
+import { interceptPassInput } from "../match-context.js";
 import { getRouterContext } from "../router-context.js";
 import type { GeneratorMiddleware } from "./cache-lookup.js";
 import { debugLog } from "../logging.js";
@@ -176,7 +176,7 @@ export function withInterceptResolution<TEnv>(
     const Store = ctx.Store;
     const interceptSegments = await Store.run(() =>
       resolveInterceptEntry(
-        resolutionPassInput(ctx),
+        interceptPassInput(ctx),
         ctx.interceptResult!.intercept,
         ctx.interceptResult!.entry,
         true, // belongsToRoute
@@ -232,7 +232,7 @@ async function handleCacheHitIntercept<TEnv>(
   const loaderSegments = resolveInterceptLoadersOnly
     ? await ctx.Store.run(() =>
         resolveInterceptLoadersOnly(
-          resolutionPassInput(ctx),
+          interceptPassInput(ctx),
           ctx.interceptResult!.intercept,
           ctx.interceptResult!.entry,
           true, // belongsToRoute

package/src/router/navigation-snapshot.ts

@@ -3,12 +3,30 @@ import { requestHeaders } from "../server/request-headers.js";
 import type { RouteMatchResult } from "./pattern-matching.js";
 import { WIRE } from "../wire-params.js";
 
+/** A page held segments were rendered for: what their revalidation compares with. */
+export interface PrevPage {
+  url: URL;
+  params: Record<string, string>;
+}
+
 export interface NavigationSnapshot {
+  /**
+   * `prevUrl` and `prevParams`: the page the held page segments were rendered
+   * for. That is the page left, or the source page while an intercept is open
+   * (`hasInterceptSource`).
+   */
   prevUrl: URL;
   /** The visitor's URL of the page left, when `prevUrl` is its rewrite target. */
   prevVisitorUrl: URL | null;
   prevParams: Record<string, string>;
+  /** The match of the page left: the intercept's URL while one is open. */
   prevMatch: RouteMatchResult | null;
+  /**
+   * The page an open intercept's slot was rendered for: the intercept's own
+   * URL (match-context.ts interceptPassInput). Equals `prevUrl`/`prevParams`
+   * when the request names no intercept source.
+   */
+  interceptPrev: PrevPage;
 
   interceptContextUrl: URL;
   interceptContextMatch: RouteMatchResult | null;
@@ -176,29 +194,40 @@ export async function resolveNavigation(
   }
   // An intercept's request diffs from its source, which _rsc_rt does not name.
   const shown = interceptSourceUrl ? null : getShownRouteUrl(url);
-  const prevUrl = shown ?? visitor;
+  const left = shown ?? visitor;
 
   let interceptContextUrl: URL;
   try {
     interceptContextUrl = interceptSourceUrl
       ? withoutHash(new URL(interceptSourceUrl, url.origin))
-      : prevUrl;
+      : left;
   } catch {
-    interceptContextUrl = prevUrl;
+    interceptContextUrl = left;
   }
 
-  const prevMatch = await deps.findMatch(prevUrl.pathname);
-  const prevParams = prevMatch?.params || {};
+  const prevMatch = await deps.findMatch(left.pathname);
   const interceptContextMatch = interceptSourceUrl
     ? await deps.findMatch(interceptContextUrl.pathname)
     : prevMatch;
+  const interceptPrev: PrevPage = {
+    url: left,
+    params: prevMatch?.params || {},
+  };
+  // The page under an open intercept was rendered for the source, with its
+  // search, not for the intercept's URL.
+  const prev: PrevPage = interceptSourceUrl
+    ? {
+        url: formSearch(new URL(interceptContextUrl)),
+        params: interceptContextMatch?.params || {},
+      }
+    : interceptPrev;
 
   const isSameRouteNavigation = !!(
     interceptContextMatch && interceptContextMatch.routeKey === currentRouteKey
   );
 
   const hasInterceptSource = !!interceptSourceUrl;
-  const effectiveFromUrl = hasInterceptSource ? interceptContextUrl : prevUrl;
+  const effectiveFromUrl = hasInterceptSource ? interceptContextUrl : left;
   const effectiveFromMatch = hasInterceptSource
     ? interceptContextMatch
     : prevMatch;
@@ -212,10 +241,11 @@ export async function resolveNavigation(
   const clientSegmentSet = new Set(clientSegmentIds);
 
   return {
-    prevUrl,
+    prevUrl: prev.url,
     prevVisitorUrl: shown && visitor,
-    prevParams,
+    prevParams: prev.params,
     prevMatch,
+    interceptPrev,
     interceptContextUrl,
     interceptContextMatch,
     clientSegmentIds,
@@ -240,6 +270,7 @@ export function createNavigationSnapshot(
     prevVisitorUrl: null,
     prevParams: {},
     prevMatch: null,
+    interceptPrev: { url: defaultUrl, params: {} },
     interceptContextUrl: defaultUrl,
     interceptContextMatch: null,
     clientSegmentIds: [],

package/src/use-loader.tsx

@@ -256,12 +256,13 @@ function useLoaderInternal<T>(
     [groupKey],
   );
   const hasGroups = groupList.length > 0;
+  // A grouped read without a key refreshes a bucket no other reader names.
+  const usesPrivateBucket = hasGroups && key === undefined;
   const privateBucketIdRef = useRef<string | null>(null);
-  if (hasGroups && key === undefined && privateBucketIdRef.current === null) {
+  if (usesPrivateBucket && privateBucketIdRef.current === null) {
     privateBucketIdRef.current = `__rg${privateGroupBucketSeq++}`;
   }
-  const effectiveKey =
-    key ?? (hasGroups ? privateBucketIdRef.current! : undefined);
+  const effectiveKey = usesPrivateBucket ? privateBucketIdRef.current! : key;
   const bucketKey =
     effectiveKey === undefined ? loaderId : `${loaderId}::${effectiveKey}`;
 
@@ -352,6 +353,7 @@ function useLoaderInternal<T>(
       {
         loaderId,
         ephemeral: !hasContextData,
+        owned: usesPrivateBucket,
         group: hasGroups ? groupList : undefined,
         refetch: hasGroups ? groupRefetch : undefined,
         onStreamPending: hasContextData