@rangojs/router 0.28.0 → 0.30.0

package/src/browser/event-controller.ts

@@ -92,6 +92,11 @@ export interface ActionEntry {
   startedAt: number;
   /** Whether action processing is complete (may still be streaming) */
   completed?: boolean;
+  /**
+   * Set when a later call started (see startAction): "id" hides this call
+   * from every reader, "name" from readers that match by export name.
+   */
+  supersededBy?: "id" | "name";
 }
 
 /**
@@ -104,7 +109,7 @@ export interface DerivedNavigationState {
   isStreaming: boolean;
   /** Whether a navigation is active (fetching or streaming, before commit) */
   isNavigating: boolean;
-  /** Current committed location */
+  /** The location of the last page flushed to React (useNavigation keeps the page on screen) */
   location: NavigationLocation;
   /** URL being navigated to (null if idle) */
   pendingUrl: string | null;
@@ -537,6 +542,28 @@ export function createEventController(
   let unsettledNavigation: NavigationEntry | null = null;
 
   const inflightActions = new Map<string, ActionEntry>();
+  // Each action id's last settled call, which useAction reports until the
+  // action's next call starts (startAction deletes it). A call moves here
+  // when doSettle's cleanup takes it out of inflightActions. A trimmed
+  // snapshot, so no abort controller outlives the call. abortAllActions leaves
+  // settled calls: they persist through navigations until the action's next
+  // call.
+  type TrackedCall = Pick<
+    ActionEntry,
+    | "actionId"
+    | "phase"
+    | "payload"
+    | "result"
+    | "error"
+    | "revalidationError"
+    | "supersededBy"
+  >;
+  const settledActions = new Map<string, TrackedCall>();
+
+  function* trackedCalls(): Generator<TrackedCall> {
+    yield* inflightActions.values();
+    yield* settledActions.values();
+  }
 
   let location: NavigationLocation =
     config?.initialLocation ??
@@ -708,19 +735,24 @@ export function createEventController(
   }
 
   function getActionState(actionId: string): TrackedActionState {
-    // Nothing inflight — skip building/scanning the list and return the shared
-    // idle snapshot (the same reference use-action falls back to).
-    if (inflightActions.size === 0) return DEFAULT_ACTION_STATE;
-
-    const entry = [...inflightActions.values()]
-      .filter((a) => matchesActionId(actionId, a.actionId))
-      .reduce<ActionEntry | undefined>((best, a) => {
-        if (!best) return a;
-        const aActive = a.phase !== "settling";
-        const bActive = best.phase !== "settling";
-        if (aActive !== bActive) return aActive ? a : best;
-        return a.startedAt > best.startedAt ? a : best;
-      }, undefined);
+    // No call tracked: the shared idle snapshot (the same reference use-action
+    // falls back to).
+    if (inflightActions.size === 0 && settledActions.size === 0) {
+      return DEFAULT_ACTION_STATE;
+    }
+
+    // The latest call this reader matches, in flight or settled, or none once
+    // a later call was aborted: an earlier call is never reported again.
+    const byName = !actionId.includes("#");
+    let entry: TrackedCall | undefined;
+    for (const a of trackedCalls()) {
+      if (
+        matchesActionId(actionId, a.actionId) &&
+        (byName ? !a.supersededBy : a.supersededBy !== "id")
+      ) {
+        entry = a;
+      }
+    }
 
     if (!entry) {
       return { ...DEFAULT_ACTION_STATE };
@@ -899,9 +931,9 @@ export function createEventController(
     // after that point is strictly ordered behind the prior action's server
     // execution, and there is no skipped render or order uncertainty for
     // consolidation to repair. Completed entries still linger in the map for
-    // the 100ms doSettle window (useAction reads) and, on a slow connection,
-    // while the Flight stream drains its EOF after complete(). Counting them
-    // latched hadAnyConcurrentActions for back-to-back sequential actions,
+    // the 100ms doSettle window and, on a slow connection, while the Flight
+    // stream drains its EOF after complete(). Counting them latched
+    // hadAnyConcurrentActions for back-to-back sequential actions,
     // which made the LAST action classify as consolidation-needed; the
     // consolidation refetch omits every concurrently-revalidated segment id
     // from _rsc_segments, so the server re-ran gated loaders as "new-segment"
@@ -913,6 +945,22 @@ export function createEventController(
       hadAnyConcurrentActions = true;
     }
 
+    // useAction reports the latest call. Every earlier call that a reader of
+    // this one also matches, in flight or settled, is hidden from that reader
+    // for good, so it never shows again, also once this call is aborted: a
+    // call of the same action from every reader, a call of another action
+    // with the same export name from readers that match by name
+    // (matchesActionId). So at most one call matches a reader (getActionState).
+    const hash = actionId.lastIndexOf("#");
+    const name = hash === -1 ? null : actionId.slice(hash + 1);
+    settledActions.delete(actionId);
+    for (const a of trackedCalls()) {
+      if (a.actionId === actionId) a.supersededBy = "id";
+      else if (name !== null && matchesActionId(name, a.actionId)) {
+        a.supersededBy ??= "name";
+      }
+    }
+
     const entry: ActionEntry = {
       id,
       actionId,
@@ -956,9 +1004,20 @@ export function createEventController(
       if (settled) return;
       settled = true;
 
-      // Cleanup after brief delay (allow useAction to read result)
       setTimeout(() => {
-        inflightActions.delete(id);
+        // The action's last settled call until its next call starts, unless
+        // that call already started.
+        if (inflightActions.delete(id) && entry.supersededBy !== "id") {
+          settledActions.set(actionId, {
+            actionId: entry.actionId,
+            phase: entry.phase,
+            payload: entry.payload,
+            result: entry.result,
+            error: entry.error,
+            revalidationError: entry.revalidationError,
+            supersededBy: entry.supersededBy,
+          });
+        }
         // Free this cohort's arbitration once its last action has settled, so
         // a long-running action elsewhere cannot pin keys from a drained entry.
         releaseCohort();

package/src/browser/navigation-bridge.ts

@@ -45,6 +45,7 @@ import {
 } from "./navigation-store.js";
 import type { EventController } from "./event-controller.js";
 import { isInterceptOnlyCache } from "./intercept-utils.js";
+import { actionBoundaryAt, idsAboveBoundary } from "./segment-reconciler.js";
 import {
   toNetworkError,
   emitNetworkError,
@@ -206,7 +207,10 @@ export function createNavigationBridge(
     error: ServerRedirect,
     url: string,
     hops: number,
-    options: { replace?: boolean; transition?: boolean },
+    options: Pick<
+      NavigateOptionsInternal,
+      "replace" | "transition" | "_redirectFrom"
+    >,
   ): Promise<void> {
     const redirectUrl = validateRedirectOrigin(
       error.url,
@@ -228,6 +232,7 @@ export function createNavigationBridge(
       ...options,
       _skipCache: true,
       _redirectHops: hops + 1,
+      _redirectFrom: options._redirectFrom ?? url,
     });
   }
 
@@ -414,8 +419,11 @@ export function createNavigationBridge(
       // 3. when leaving intercept - we need fresh non-intercept segments from server
       // 4. redirect-with-state - force re-render so hooks read fresh state
       // 5. stale cache - server action invalidated it, need fresh data with loading state
+      // 6. an error boundary in the list - a link renders the page again; its
+      //    ids would tell the server the client holds what the error replaced
       const hasUsableCache =
         isRestorable(cachedSegments) &&
+        !cachedSegments.some((s) => s.type === "error") &&
         !isInterceptOnlyCache(cachedSegments) &&
         !isLeavingIntercept &&
         !cached?.stale &&
@@ -538,7 +546,11 @@ export function createNavigationBridge(
             error,
             url,
             options?._redirectHops ?? 0,
-            { replace: options?.replace, transition: options?.transition },
+            {
+              replace: options?.replace,
+              transition: options?.transition,
+              _redirectFrom: options?._redirectFrom,
+            },
           );
         }
 
@@ -569,9 +581,19 @@ export function createNavigationBridge(
     },
 
     /**
-     * Refresh current route
+     * Refresh current route. A cross-tab refresh holds the action error
+     * boundary the page shows (actionBoundaryAt), as the follow-up does: it
+     * is this tab's own outcome, not a read another tab's write changed. A
+     * refresh the app asks for renders it again.
      */
-    async refresh(): Promise<void> {
+    async refresh(crossTab?: boolean): Promise<void> {
+      const shown =
+        (crossTab &&
+          !store.getInterceptSourceUrl() &&
+          store.getCachedSegments(store.getHistoryKey())?.segments) ||
+        [];
+      const at = actionBoundaryAt(shown);
+      if (at === 0) return;
       eventController.abortNavigation();
 
       const tx = createNavigationTransaction(
@@ -589,7 +611,7 @@ export function createNavigationBridge(
           false,
           tx.handle.signal,
           tx.with({ url: window.location.href, replace: true, scroll: false }),
-          { type: "navigate", refresh: true },
+          { type: "navigate", refresh: true, boundary: shown[at]?.id },
         );
       } catch (error) {
         // Aborted or superseded: bail without rendering a boundary (see navigate()).
@@ -717,9 +739,20 @@ export function createNavigationBridge(
             }),
           });
 
+        // An action error boundary the entry shows (actionBoundaryAt) is
+        // held: the page holds the ids above it, so a link renders it again,
+        // and the revalidation below renders above it. Never under an
+        // intercept, as the follow-up (server-action-bridge.ts).
+        const boundaryAt = isIntercept ? -1 : actionBoundaryAt(cachedSegments);
+        const boundary = cachedSegments[boundaryAt]?.id;
+        const heldIds = idsAboveBoundary(
+          cachedSegments.map((s) => s.id),
+          boundary,
+        );
+
         // Update store to point to this history entry
         store.setHistoryKey(historyKey);
-        store.setSegmentIds(cachedSegments.map((s) => s.id));
+        store.setSegmentIds(heldIds);
         store.setCurrentUrl(url);
         store.setPath(new URL(url).pathname);
 
@@ -798,8 +831,9 @@ export function createNavigationBridge(
                 onUpdate({ ...popstateUpdate, inTransition: true });
               });
             }
-            // SWR: If stale, trigger background revalidation
-            if (isStale) {
+            // SWR: If stale, trigger background revalidation. Nothing is
+            // above a boundary at the page's first segment.
+            if (isStale && boundaryAt !== 0) {
               debugLog("[Browser] Cache is stale, background revalidating...");
               // Background revalidation - don't await, just fire and forget.
               // When the entry's handles are incomplete (a deferred Meta was still
@@ -811,9 +845,7 @@ export function createNavigationBridge(
               // would stay the pre-resolution carry. handlesPending is set only for
               // the deferred-Meta-aborted case, so action/cross-tab SWR keeps the
               // cheap diff path.
-              const segmentIds = cached?.handlesPending
-                ? []
-                : cachedSegments.map((s) => s.id);
+              const segmentIds = cached?.handlesPending ? [] : heldIds;
 
               const tx = createNavigationTransaction(
                 store,
@@ -835,7 +867,7 @@ export function createNavigationBridge(
                   interceptSourceUrl,
                   cacheOnly: true,
                 }),
-                { type: "stale-revalidation", interceptSourceUrl },
+                { type: "stale-revalidation", interceptSourceUrl, boundary },
               )
                 .catch((error) => {
                   if (isBackgroundSuppressible(error)) return;
@@ -990,7 +1022,7 @@ export function createNavigationBridge(
 
       // Register cross-tab refresh callback with the store
       store.setCrossTabRefreshCallback(() => {
-        this.refresh();
+        this.refresh(true);
       });
 
       window.addEventListener("popstate", handlePopstate);

package/src/browser/navigation-client.ts

@@ -82,6 +82,7 @@ export function createNavigationClient(
         rewriteTarget,
         signal,
         staleRevalidation,
+        boundary,
         interceptSourceUrl,
         version,
         routerId,
@@ -114,6 +115,7 @@ export function createNavigationClient(
           segmentIds,
           emptySegments: "send",
           stale: staleRevalidation,
+          boundary,
           version,
           routerId,
           rewriteTarget,

package/src/browser/network-error-handler.ts

@@ -28,6 +28,9 @@ export function toNetworkError(
  * Render an error into the segment tree via the onUpdate subscriber so the
  * nearest error boundary catches it. Wrapped in startTransition; RenderErrorThrower
  * throws during render (async rejections do not reach boundaries on their own).
+ * Flagged inTransition like every tree handed over in a transition, so route
+ * state that arrives after it (the failed navigation's idle) waits for its
+ * commit (NavigationProvider's "anchor").
  */
 function emitErrorToBoundary(
   onUpdate: UpdateSubscriber,
@@ -43,6 +46,7 @@ function emitErrorToBoundary(
         segments: [],
         isError: true,
       },
+      inTransition: true,
     });
   });
 }

package/src/browser/partial-update.ts

@@ -14,7 +14,7 @@ export const addTransitionType: ((type: string) => void) | undefined =
   "addTransitionType" in React ? (React as any).addTransitionType : undefined;
 
 import type { RenderSegmentsOptions } from "../segment-system.js";
-import { reconcileSegments } from "./segment-reconciler.js";
+import { idsAboveBoundary, reconcileSegments } from "./segment-reconciler.js";
 import type { ReconcileActor } from "./segment-reconciler.js";
 import { Defer } from "./defer.js";
 import {
@@ -236,15 +236,28 @@ export type UpdateMode =
        * transition({ when }) sees kind "revalidate", not "replace".
        */
       refresh?: boolean;
+      /** The cross-tab refresh's held boundary (see `action`). */
+      boundary?: string;
+    }
+  | { type: "leave-intercept"; interceptSourceUrl?: string; boundary?: never }
+  | {
+      type: "stale-revalidation";
+      interceptSourceUrl?: string;
+      /** Back/Forward's held boundary (see `action`). */
+      boundary?: string;
     }
-  | { type: "leave-intercept"; interceptSourceUrl?: string }
-  | { type: "stale-revalidation"; interceptSourceUrl?: string }
   | {
       type: "action";
       interceptSourceUrl?: string;
       actionId?: string;
       /** The action's FormData and result, for transition({ when }) `action`. */
       action?: TransitionWhenActionInput;
+      /**
+       * An action's error boundary the page shows (actionBoundaryAt): the
+       * server renders above it, its cached segment stays, and the page
+       * holds only the ids above it.
+       */
+      boundary?: string;
     };
 
 /**
@@ -569,6 +582,7 @@ export function createPartialUpdater(
     const historyKeyAtStart = store.getHistoryKey();
 
     const interceptSourceUrl = mode.interceptSourceUrl;
+    const boundary = mode.boundary;
 
     let segments: string[];
     if (mode.type === "leave-intercept") {
@@ -690,6 +704,7 @@ export function createPartialUpdater(
         : store.getHistoryEntryMemory()?.rewriteTarget,
       staleRevalidation:
         mode.type === "stale-revalidation" || segments.length === 0,
+      boundary,
       version: getVersion(),
       routerId: store.getRouterId?.(),
     });
@@ -874,14 +889,14 @@ export function createPartialUpdater(
       // in place of each missing value, and this navigation fills them from
       // one fill request once it has committed the tree.
       let defers: Holes["defers"] | undefined;
-      let heldIds = matchedIds;
+      let heldIds = idsAboveBoundary(matchedIds, boundary);
       const placeholders = serverSegments.filter(isPlaceholder);
       if (placeholders.length > 0) {
         defers = armHoles(placeholders);
         // A placeholder is not held: every later request from this page
         // leaves its id out, so the server renders it.
         const deferredIds = new Set(placeholders.map((s) => s.id));
-        heldIds = matchedIds.filter((id) => !deferredIds.has(id));
+        heldIds = heldIds.filter((id) => !deferredIds.has(id));
       }
 
       const reconcile = () =>
@@ -895,7 +910,10 @@ export function createPartialUpdater(
         });
       let reconciled = reconcile();
 
-      const missing = missingIds(matchedIds, reconciled.segments);
+      // Not the ids at or below a held boundary: its loaders may never have
+      // reached the client (the route failed on its GET), and nothing renders
+      // them under the error.
+      const missing = missingIds(heldIds, reconciled.segments);
 
       if (missing.length > 0) {
         const missingCount = missing.length;
@@ -1119,6 +1137,15 @@ export function createPartialUpdater(
         }),
         ...(serverLocationState && { serverState: serverLocationState }),
       };
+      // A refetch that held an action's boundary commits only while the page
+      // on screen still shows it: a later commit there (an action's success)
+      // replaced it, and this response would put the error back.
+      if (
+        boundary &&
+        !entryOnScreen()?.includes(cachedSegs.find((s) => s.id === boundary)!)
+      ) {
+        return;
+      }
       const cachedHandleData = readCachedHandleData?.();
       const { scroll: navScroll } = tx.commit(
         heldIds,

package/src/browser/react/use-action.ts

@@ -1,13 +1,6 @@
 "use client";
 
-import {
-  useContext,
-  useState,
-  useEffect,
-  useRef,
-  useOptimistic,
-  startTransition,
-} from "react";
+import { useContext, useState, useEffect, useRef } from "react";
 import { NavigationStoreContext } from "./context.js";
 import { shallowEqual } from "./shallow-equal.js";
 import type { TrackedActionState } from "../types.js";
@@ -78,19 +71,25 @@ export type ServerActionFunction = ((...args: any[]) => Promise<any>) & {
  * tracks the state of individual server action invocations.
  *
  * Uses the event controller for reactive state management.
- * State is derived from the inflight actions tracked by the controller.
+ * State is derived from the calls the controller tracks: those in flight,
+ * and each action's last settled call.
  *
  * Features:
  * - Tracks action lifecycle: idle → loading → streaming → idle
- * - Captures result/error locally (React handles cleanup)
- * - If multiple actions fire, tracks only the last one
+ * - Keeps the settled call's state until the action is called again.
+ * - If the same action fires several times, reports the latest call to
+ *   start. An earlier call that settles later changes nothing it reports;
+ *   a latest call that was aborted reports idle with nothing. One call at a
+ *   time, not one per argument: a reader filtering on `payload` cannot track
+ *   an earlier call once a later one starts.
  * - Supports selector pattern like useNavigation
  *
  * Matching behavior:
  * - **Function reference**: Uses full $$id for exact matching. This is precise
  *   and distinguishes between actions with the same name in different files.
  * - **String**: Matches by suffix (action name after #). This is convenient
- *   but may be ambiguous if multiple files export the same action name.
+ *   but may be ambiguous if multiple files export the same action name: it
+ *   follows the latest call of any action with that export name.
  *
  * @param action - Either a server action function or a string action name.
  *   - **Function**: Must be directly imported in the client component.
@@ -138,8 +137,10 @@ export function useAction<T>(
       ? getActionId(action)
       : "";
 
-  // Base state for useOptimistic
-  const [baseState, setBaseState] = useState<T | TrackedActionState>(() => {
+  // Set urgently from notifyAction's task, also while React holds a page: a
+  // transition of its own would take the held page's transition types (see
+  // useNavigation).
+  const [value, setValue] = useState<T | TrackedActionState>(() => {
     if (!ctx) {
       return selector ? selector(DEFAULT_ACTION_STATE) : DEFAULT_ACTION_STATE;
     }
@@ -149,11 +150,8 @@ export function useAction<T>(
       : ctx.eventController.getActionState(actionId);
     return selector ? selector(state) : state;
   });
-  const prevSelected = useRef(baseState);
-  prevSelected.current = baseState;
-  const [optimisticState, setOptimisticState] = useOptimistic<
-    T | TrackedActionState
-  >(null!);
+  const prevSelected = useRef(value);
+  prevSelected.current = value;
 
   // Ref keeps the latest selector for subscription callbacks without
   // re-subscribing on every render. Selector changes themselves are not
@@ -166,41 +164,20 @@ export function useAction<T>(
   useEffect(() => {
     if (!ctx) return;
 
+    const sync = (state: TrackedActionState) => {
+      const selected = selectorRef.current ? selectorRef.current(state) : state;
+      if (!shallowEqual(selected, prevSelected.current)) {
+        prevSelected.current = selected;
+        setValue(selected);
+      }
+    };
     // Sync current state for the (possibly new) actionId so that switching
     // actions on an idle page doesn't leave stale data from the old action.
-    const currentState = ctx.eventController.getActionState(actionId);
-    const currentSelected = selectorRef.current
-      ? selectorRef.current(currentState)
-      : currentState;
-    if (!shallowEqual(currentSelected, prevSelected.current)) {
-      prevSelected.current = currentSelected;
-      setBaseState(currentSelected);
-    }
-
-    // Subscribe to action-specific updates
-    const unsubscribe = ctx.eventController.subscribeToAction(
-      actionId,
-      (state) => {
-        const selectedState = selectorRef.current
-          ? selectorRef.current(state)
-          : state;
-
-        if (!shallowEqual(selectedState, prevSelected.current)) {
-          prevSelected.current = selectedState;
-          setBaseState(selectedState);
-          startTransition(() => {
-            setOptimisticState(selectedState);
-          });
-        }
-      },
-    );
-
-    return () => {
-      unsubscribe();
-    };
+    sync(ctx.eventController.getActionState(actionId));
+    return ctx.eventController.subscribeToAction(actionId, sync);
   }, [actionId]);
 
-  return (optimisticState ?? baseState) as T | TrackedActionState;
+  return value;
 }
 
 export type { TrackedActionState };

package/src/browser/react/use-handle.ts

@@ -6,6 +6,7 @@ import { collectHandleData } from "../../handle.js";
 import type { HandleData } from "../types.js";
 import { NavigationStoreContext } from "./context.js";
 import { shallowEqual } from "./shallow-equal.js";
+import { useCommitted } from "./use-route-state.js";
 import type { RouteStateSignal } from "../event-controller.js";
 
 /**
@@ -53,7 +54,7 @@ export function useHandle<T, A, S>(
     return selectorRef.current ? selectorRef.current(collected) : collected;
   };
 
-  const [value, setValue] = useCommitAnchoredState(collect);
+  const [value, setValue] = useCommitAnchoredState(collect, true);
 
   useEffect(() => {
     if (!ctx) return;
@@ -68,25 +69,30 @@ export function useHandle<T, A, S>(
 }
 
 /**
- * Route state the controller's handle notifications drive (useHandle,
- * useSegments) commits with the page it belongs to. NavigationProvider
- * flushes the controller inside every payload update, so a value known then
- * is set in the page's lane. A page handed over urgently (signal "release")
- * takes a value that arrives before it commits the same way: set at default
- * priority, it renders in the page's lane, and the page's effects read it.
- * A page in a transition (signal "anchor") does not: until it commits
+ * Route state the controller's handle notifications drive commits with the
+ * page it belongs to. NavigationProvider flushes the controller inside every
+ * payload update, with signal "anchor" for a page in a transition and
+ * "release" for an urgent one, so the page's own change is set in the page's
+ * lane and the page's effects read it. From the anchor until the page commits
  * (releaseRouteState() from the provider's layout effect, signal "release"),
- * a new value waits, and is applied in the commit's task, right after the
- * page's own commit. In the page's lane, a value that suspends in a revealed
- * <Suspense> (a crumb's content) would hold the page; in a lane of its own,
- * it commits over the page being left and takes the page's transition types
- * (#1165); and a transition entangled with the page misses its commit when it
- * is set after React rendered the page, before its view transition's
- * mutation, and starts a view transition of its own. A value shallow-equal to
- * the last one sets nothing, so a reader renders only when its value moves.
+ * a later change waits and is applied in the commit's task, right after the
+ * page's own commit: set in a lane of its own, it would commit over the page
+ * being left (#1165).
+ *
+ * `waitForRelease`, set by useHandle only: the anchor's own change waits too,
+ * so a handle value lands right after its page's commit, never in its lane. A
+ * handle value can carry a promise that suspends, and in the page's lane one
+ * that suspends in a revealed <Suspense> would hold the page. Nothing
+ * useSegments reads can suspend, so it leaves it off and its path and
+ * location commit with their page.
+ *
+ * A value shallow-equal to the last one sets nothing, so a reader renders only
+ * when its value moves. A release is compared with what React committed, as in
+ * useRouteState.
  */
 export function useCommitAnchoredState<T>(
   init: () => T,
+  waitForRelease?: boolean,
 ): [T, (value: T, signal?: RouteStateSignal) => void] {
   // An app that enables the React Compiler compiles the router too; its memo
   // cache gains nothing here and cost 107 B gzip in the router chunk.
@@ -95,15 +101,18 @@ export function useCommitAnchoredState<T>(
   const ref = useRef<{ last: T; held?: boolean; waiting?: boolean }>({
     last: value,
   });
+  const committed = useCommitted(value);
   const [set] = useState(() => (next: T, signal?: RouteStateSignal): void => {
     const r = ref.current;
     if (signal) r.waiting = signal === "anchor";
     if (!shallowEqual(next, r.last)) {
       r.last = next;
       r.held = true;
+    } else if (signal === "release" && r.last !== committed.current) {
+      r.held = true;
     }
-    // The anchor's own change goes in the page's lane, with the page.
-    if (!r.held || (r.waiting && signal !== "anchor")) return;
+    if (!r.held || (r.waiting && (waitForRelease || signal !== "anchor")))
+      return;
     r.held = false;
     setValue(() => r.last);
   });