@timber-js/app 0.2.0-alpha.196 → 0.2.0-alpha.198

package/src/client/router.ts

@@ -219,6 +219,7 @@ export function createRouter(deps: RouterDeps): RouterInstance {
               params,
               segmentInfo: result.segmentInfo,
               status: result.status,
+              skippedSegments: result.skippedSegments,
             });
             return { ...result, payload, params, navState, commit };
           });
@@ -294,18 +295,20 @@ export function createRouter(deps: RouterDeps): RouterInstance {
           // metadata (e.g., initial SSR page) clears the cache so the next
           // forward navigation gets a full render.
           //
-          // Committed immediately: the replay is synchronous and its render
-          // goes out through `transitionRender`, so there is no in-flight
-          // window for a successor to supersede. `runNavigation` has already
-          // superseded whatever was in flight before it (TIM-1022).
+          // No fetch to be superseded — `runNavigation` has already superseded
+          // whatever was in flight before it (TIM-1022) — but the render still
+          // goes out through a transition React may hold (a replayed tree can
+          // suspend), so the publish rides that commit rather than running
+          // here. Publishing first would advertise the replayed route's slot
+          // keys while the slot content cache still describes the departing
+          // one (TIM-1423, codex on #1108).
           const { navState, commit } = prepareNavigation(url, {
             payload: entry.payload,
             params: entry.params,
             segmentInfo: entry.segmentInfo,
             clearSegmentCacheOnEmpty: true,
           });
-          commit();
-          renderPayload(entry.payload, navState, entry.params);
+          renderPayload(entry.payload, navState, entry.params, commit);
           restoreScrollAfterPaint(scrollY);
         },
         externalSignal
@@ -326,6 +329,9 @@ export function createRouter(deps: RouterDeps): RouterInstance {
   /**
    * Prefetch an RSC payload for a URL and store it in the prefetch cache.
    * Called on hover of <Link prefetch> elements.
+   *
+   * Concurrent hovers and a click during the round-trip coalesce via the
+   * singleflight inside PrefetchCache (TIM-1438).
    */
   function prefetch(url: string): void {
     // A stale client hard-navigates on every navigation, so a prefetched RSC
@@ -348,35 +354,41 @@ export function createRouter(deps: RouterDeps): RouterInstance {
     const cacheKey = prefetchKeyFor(fetchUrl, deps.getCurrentUrl(), stateTree);
     const from = cacheKey.from;
 
-    // Don't prefetch if already cached
-    if (prefetchCache.get(cacheKey) !== undefined) return;
+    // Don't prefetch if already cached (ready or negative)
+    if (prefetchCache.has(cacheKey)) return;
     if (historyStack.has(fetchUrl)) return;
 
-    // Fire-and-forget fetch
-    void fetchRscPayload(fetchUrl, deps, stateTree, from).then(
-      (result) => {
-        // The decode rejects separately from the fetch, so the stale shapes
-        // reach us here rather than in the rejection handler below — swallowing
-        // it wholesale threw away the same evidence (TIM-1275).
-        result.decodePromise?.catch((error: unknown) => void recordSkew(error));
-        prefetchCache.set(cacheKey, result);
-      },
-      (error) => {
-        if (error instanceof NonRscResponse) {
-          prefetchCache.setNegative(cacheKey);
-          return;
+    // Fire-and-forget. Concurrent hovers coalesce in the singleflight;
+    // a click during the round-trip joins the same flight via
+    // fetchOrCoalesce in performNavigationFetch (TIM-1438).
+    void prefetchCache
+      .fetchOrCoalesce(
+        cacheKey,
+        (signal) => fetchRscPayload(fetchUrl, deps, stateTree, from, signal),
+        (err) => err instanceof NonRscResponse
+      )
+      .then(
+        (outcome) => {
+          if (outcome.kind === 'ready') {
+            // The decode rejects separately from the fetch, so the stale
+            // shapes reach us here rather than in the rejection handler
+            // below — swallowing it wholesale threw away the same evidence
+            // (TIM-1275).
+            outcome.result.decodePromise?.catch((error: unknown) => void recordSkew(error));
+          }
+        },
+        (error) => {
+          // A prefetch can be the first thing to learn we are stale —
+          // during a rollout it may reach the new deployment while the
+          // click that follows reaches the old one and completes as an
+          // ordinary SPA navigation, throwing the evidence away. Record
+          // it, but never recover from here: nobody navigated, and a page
+          // load triggered by a hover is exactly the unasked-for reload
+          // this design removed. The next click takes the document-load
+          // path (TIM-1275).
+          recordSkew(error);
         }
-        // A prefetch can be the first thing to learn we are stale — during a
-        // rollout it may reach the new deployment while the click that
-        // follows reaches the old one and completes as an ordinary SPA
-        // navigation, throwing the evidence away. Record it, but never
-        // recover from here: nobody navigated, and a page load triggered by
-        // a hover is exactly the unasked-for reload this design removed. The
-        // next click takes the document-load path (TIM-1275).
-        recordSkew(error);
-        // Any other prefetch failure is non-fatal — navigation fetches fresh.
-      }
-    );
+      );
   }
 
   return {
@@ -404,15 +416,15 @@ export function createRouter(deps: RouterDeps): RouterInstance {
       // Preserve existing segmentInfo so away-and-back navigation replays
       // with a correct segment cache (TIM-1037).
       const existingEntry = historyStack.get(currentUrl);
-      // Synchronous, like the popstate replay: there is no fetch to be
-      // superseded, and the payload is already decoded.
+      // Like the popstate replay: there is no fetch to be superseded and the
+      // payload is already decoded, but the publish still rides React's
+      // commit of the tree, not this call (TIM-1423).
       const { navState, commit } = prepareNavigation(currentUrl, {
         payload: tree,
         params,
         segmentInfo: existingEntry?.segmentInfo,
       });
-      commit();
-      renderPayload(tree, navState, params);
+      renderPayload(tree, navState, params, commit);
     },
     initSegmentCache: (segments: SegmentInfo[]) => updateSegmentCache(segments),
     segmentCache,

package/src/client/segment-cache.ts

@@ -3,6 +3,7 @@
 
 import type { PublishedParams } from '../shared/payload-root.ts';
 import type { SegmentInfo, StateTree } from '../shared/segment-info.ts';
+import { createSingleflight } from '../cache/singleflight.ts';
 
 // ─── Types ───────────────────────────────────────────────────────
 
@@ -273,7 +274,7 @@ export function buildSegmentTree(segments: SegmentInfo[]): SegmentNode | undefin
 
 // ─── Prefetch Cache ──────────────────────────────────────────────
 
-interface PrefetchEntry {
+interface ReadyEntry {
   result: PrefetchResult;
   expiresAt: number;
 }
@@ -281,6 +282,13 @@ interface PrefetchEntry {
 /** Sentinel value for negative cache entries (URL is not a route). */
 const NEGATIVE_ENTRY: PrefetchResult = Object.freeze({ payload: null });
 
+/**
+ * Timeout for the in-flight singleflight (TIM-1438). Per CLAUDE.md's
+ * singleflight rule: "Never write a coalescing Map without a timeout."
+ * A hung prefetch cannot block clicks or suppress hovers forever.
+ */
+const PREFETCH_SINGLEFLIGHT_TIMEOUT_MS = 5_000;
+
 /**
  * Identifies a prefetched payload. A payload is addressed by *every* input that
  * changes the server's answer, not by the destination alone.
@@ -333,17 +341,28 @@ export function prefetchScopeOf(stateTree: StateTree | undefined): string {
   return stateTree?.treePaths?.join('\u0000') ?? '';
 }
 
+/** Outcome of a prefetch flight — discriminated so NonRscResponse is a
+ *  success (stores a negative entry) rather than a rejection. */
+export type FlightOutcome = { kind: 'ready'; result: PrefetchResult } | { kind: 'non-route' };
+
 /**
  * Short-lived cache for hover-triggered prefetches. Entries expire after
  * 30 seconds. When a link is clicked, the prefetched payload is consumed
  * (moved to the history stack) and removed from this cache.
  *
+ * In-flight dedup (TIM-1438): concurrent fetches for the same key are
+ * coalesced by a `createSingleflight` instance. A hover starts a flight;
+ * a click for the same key joins it instead of issuing a duplicate. The
+ * singleflight enforces a 5-second timeout and cleans up automatically
+ * on settlement.
+ *
  * timber.js does NOT prefetch on viewport intersection — only explicit
  * hover on <Link prefetch> triggers a prefetch.
  */
 export class PrefetchCache {
   private static readonly TTL_MS = 30_000;
-  private entries = new Map<string, PrefetchEntry>();
+  private entries = new Map<string, ReadyEntry>();
+  private flights = createSingleflight({ timeoutMs: PREFETCH_SINGLEFLIGHT_TIMEOUT_MS });
 
   set(key: PrefetchKey, result: PrefetchResult): void {
     this.entries.set(prefetchMapKey(key), {
@@ -363,6 +382,11 @@ export class PrefetchCache {
     return entry.result;
   }
 
+  /** True if a ready or negative entry exists for this key. */
+  has(key: PrefetchKey): boolean {
+    return this.get(key) !== undefined;
+  }
+
   /** Get and remove the entry (used when navigation consumes a prefetch) */
   consume(key: PrefetchKey): PrefetchResult | undefined {
     const result = this.get(key);
@@ -372,6 +396,50 @@ export class PrefetchCache {
     return result;
   }
 
+  /**
+   * Fetch or coalesce with an in-flight fetch for this key (TIM-1438).
+   *
+   * Concurrent callers (hover + click, repeated hovers) get the same
+   * promise. On success the result is stored as a ready entry. On
+   * NonRscResponse a negative entry is stored and the outcome is
+   * `{ kind: 'non-route' }`. Other errors (network, version skew)
+   * reject — the singleflight cleans up the key and subsequent callers
+   * retry.
+   *
+   * The singleflight signal is passed to `doFetch` so a timed-out flight
+   * aborts the underlying fetch rather than leaving it running.
+   */
+  fetchOrCoalesce(
+    key: PrefetchKey,
+    doFetch: (signal: AbortSignal) => Promise<PrefetchResult>,
+    isNonRoute: (error: unknown) => boolean
+  ): Promise<FlightOutcome> {
+    return this.flights.do(prefetchMapKey(key), async (signal) => {
+      try {
+        const result = await doFetch(signal);
+        if (!signal.aborted) this.set(key, result);
+        return { kind: 'ready' as const, result };
+      } catch (err) {
+        if (isNonRoute(err)) {
+          if (!signal.aborted) this.setNegative(key);
+          return { kind: 'non-route' as const };
+        }
+        throw err;
+      }
+    });
+  }
+
+  /**
+   * Join an in-flight singleflight fetch if one exists for this key.
+   * Returns the in-flight promise or undefined. Used by the click path to
+   * coalesce with a hover prefetch without starting a new flight — when no
+   * flight exists, the click issues its own fetch with the navigation's
+   * abort signal so superseded navigations abort immediately (TIM-1438).
+   */
+  joinInflight(key: PrefetchKey): Promise<FlightOutcome> | undefined {
+    return this.flights.get(prefetchMapKey(key)) as Promise<FlightOutcome> | undefined;
+  }
+
   /**
    * Store a negative entry — the URL is not a route (non-RSC Content-Type).
    *

package/src/client/segment-context.ts

@@ -60,10 +60,13 @@ export function SegmentProvider({
 }: SegmentProviderProps) {
   const value = useMemo(
     () => ({ segments, parallelRouteKeys }),
-    // segments and parallelRouteKeys are static per layout — they don't change
-    // across navigations. The layout's position in the tree is fixed.
-    // Intentionally using derived keys — segments/parallelRouteKeys are static per layout
-    [segments.join('/'), parallelRouteKeys.join(',')]
+    // segments and parallelRouteKeys are static per layout — the layout's
+    // position in the tree is fixed. The arrays are used directly as deps
+    // (React Compiler requires simple expressions here). Referential stability
+    // of the context value doesn't matter: every consumer
+    // (useSelectedLayoutSegment/useSelectedLayoutSegments) also calls
+    // usePathname(), so it re-renders on every navigation regardless.
+    [segments, parallelRouteKeys]
   );
   return createElement(SegmentContext.Provider, { value }, children);
 }

package/src/client/segment-outlet.tsx

@@ -4,19 +4,29 @@
  * Each layout in the segment tree is wrapped with a SegmentOutlet that:
  * 1. Knows its segment path (prop from the server)
  * 2. Reads from SegmentUpdateContext for partial navigation updates
- * 3. Caches its rendered content in a ref across navigations
+ * 3. Reads from — and, at commit, writes to — the router's slot content
+ *    cache, so a skipped parallel slot keeps showing what it last committed
  *
- * On full navigation: receives new children via props, caches and renders them.
+ * On full navigation: receives new children via props and renders them.
  * On partial navigation (this segment skipped): the context map has no entry
- * for this path, so the outlet returns cached content — preserving layout state.
+ * for this path, so the outlet renders its children — which, because the
+ * router re-wraps the *retained* tree, are the same elements as before,
+ * preserving layout state.
  * On partial navigation (this segment updated): the context map has content
  * for this path, so the outlet renders the update.
+ * On a skipped parallel slot (`skip=true`, children null): the outlet renders
+ * the content it last committed for this path.
  *
  * Uses React context instead of useSyncExternalStore to stay compatible
  * with concurrent rendering (transitions). All outlets re-render when the
  * context value changes, but each bails out quickly if its segment has
  * no update — same approach as Next.js LayoutRouter.
  *
+ * Render is a pure read. The only write — recording committed slot content —
+ * happens in a layout effect, so a render React throws away (a superseded
+ * transition, a Suspense retry) cannot poison what a later `skip=true`
+ * resolves to (TIM-1423). See client/slot-content-cache-context.ts.
+ *
  * Security: performance optimization only. The server always runs all
  * access.ts files regardless of segment skipping.
  * See design/13-security.md §"State tree manipulation".
@@ -24,8 +34,9 @@
 
 'use client';
 
-import { useContext, useRef, type ReactNode } from 'react';
+import { useContext, useLayoutEffect, type ReactNode } from 'react';
 import { SegmentUpdateContext } from './segment-update-context.ts';
+import { SlotContentCacheContext } from './slot-content-cache-context.ts';
 
 export interface SegmentOutletProps {
   /**
@@ -41,101 +52,45 @@ export interface SegmentOutletProps {
   children: ReactNode;
 
   /**
-   * When true, the outlet returns cached content instead of rendering
-   * new children. Used for skipped parallel route slots — the server
-   * sends an empty SegmentOutlet with skip=true, and the client keeps
-   * the previously cached slot content.
+   * When true, the outlet renders the content it last committed for this
+   * path instead of `children`. Used for skipped parallel route slots — the
+   * server sends an empty SegmentOutlet with skip=true, and the client keeps
+   * the previously committed slot content.
    */
   skip?: boolean;
 }
 
-// ─── Slot Content Cache ──────────────────────────────────────────
-// Persists slot content across SegmentOutlet fiber lifecycles.
-// When React creates new fibers during full navigation (e.g., the
-// server sends a complete new tree and React remounts the subtree),
-// useRef starts fresh with null. Skipped slots (skip=true, children=null)
-// would lose their cached content because contentRef.current is null.
-//
-// This globalThis-backed Map provides a fallback: SegmentOutlet stores
-// rendered content here whenever it renders non-null slot content, and
-// reads from it when skip=true but contentRef.current is null.
-//
-// Uses globalThis + Symbol.for for singleton guarantee across chunks —
-// same pattern as NavigationContext and SegmentUpdateContext.
-//
-// SSR safety: SegmentOutlet is 'use client' — during RSC rendering it's
-// serialized as a client reference and never executed. During SSR
-// (renderToReadableStream), the component IS executed but skip=true is
-// never sent (the server always renders full content). The cache may
-// accumulate entries during SSR but they're harmless — the skip=true
-// fallback path only activates on the client during SPA navigation.
-
-const SLOT_CACHE_KEY = Symbol.for('__timber_slot_content_cache');
-
-function getSlotContentCache(): Map<string, ReactNode> {
-  const g = globalThis as Record<symbol, unknown>;
-  if (!g[SLOT_CACHE_KEY]) {
-    g[SLOT_CACHE_KEY] = new Map<string, ReactNode>();
-  }
-  return g[SLOT_CACHE_KEY] as Map<string, ReactNode>;
-}
-
 /**
  * Client component boundary at each layout segment in the element tree.
  *
- * On full navigation (context map is empty): renders children, caches in ref.
- * On partial navigation: checks the context map for an update at segmentPath.
- *   - Update found → renders update, caches in ref.
- *   - No update → returns cached content (layout state preserved).
+ * Resolution order, all reads:
+ *   1. An update in SegmentUpdateContext for this path → render it.
+ *   2. `skip` → render the committed content for this path (null if none —
+ *      a fresh outlet with nothing committed yet renders empty and is fully
+ *      rendered on the next navigation).
+ *   3. Otherwise → render `children`.
  *
- * React preserves component instances across reactRoot.render() calls
- * when the same type appears at the same tree position. The ref persists
- * across navigations because SegmentOutlet is reconciled, not remounted.
+ * Whatever a non-skip render resolves to is recorded once React commits it.
+ * A skip render records nothing: it displayed the cache, it did not add to it.
  */
 export function SegmentOutlet({ segmentPath, children, skip }: SegmentOutletProps) {
   const updates = useContext(SegmentUpdateContext);
-  const contentRef = useRef<ReactNode>(null);
-  const slotCache = getSlotContentCache();
+  const cache = useContext(SlotContentCacheContext);
 
   const update = updates.get(segmentPath);
+  const hasUpdate = update !== undefined;
+  const content: ReactNode = hasUpdate
+    ? update
+    : skip
+      ? (cache?.get(segmentPath) ?? null)
+      : children;
 
-  if (update !== undefined) {
-    contentRef.current = update;
-    slotCache.set(segmentPath, update);
-    return update;
-  }
-
-  // Skipped slot: keep cached content. The server sends skip=true for
-  // parallel route slots whose matched content hasn't changed. React
-  // reconciles this SegmentOutlet with the previous one at the same
-  // tree position, so the ref (cached content) is preserved.
-  if (skip) {
-    if (contentRef.current !== null) {
-      return contentRef.current;
-    }
-    // Fiber was remounted (contentRef is fresh null). Fall back to the
-    // globalThis-backed cache which persists across fiber lifecycles.
-    if (slotCache.has(segmentPath)) {
-      const cached = slotCache.get(segmentPath)!;
-      contentRef.current = cached;
-      return cached;
-    }
-    // No cached content anywhere — the SegmentOutlet instance is fresh
-    // and no prior render has populated the cache. Fall through to render
-    // children (null). The slot will be fully rendered next navigation.
-  }
-
-  if (contentRef.current === null) {
-    contentRef.current = children;
-    slotCache.set(segmentPath, children);
-    return children;
-  }
-
-  if (children !== contentRef.current) {
-    contentRef.current = children;
-    slotCache.set(segmentPath, children);
-    return children;
-  }
+  // Commit-time write. `hasUpdate || !skip` is "this render brought its own
+  // content" — the one case where the cache learns something new.
+  const record = hasUpdate || !skip;
+  useLayoutEffect(() => {
+    if (record && cache !== null) cache.set(segmentPath, content);
+  }, [record, cache, segmentPath, content]);
 
-  return contentRef.current;
+  return content;
 }

package/src/client/segment-update-context.ts

@@ -6,37 +6,18 @@
  * as the context value. Mounted SegmentOutlet components read from this
  * context to decide whether to render the update or their cached content.
  *
- * SINGLETON GUARANTEE: Uses globalThis + Symbol.for — same pattern as
- * NavigationContext. The RSC client bundler can duplicate this module
- * across chunks (browser-entry graph + client-reference graph). With
- * ESM output, each chunk gets its own module scope — a bare createContext
- * at module level would create separate instances per chunk. globalThis
- * guarantees a single instance regardless of duplication.
- *
+ * Singleton across bundler-duplicated chunks via `createGlobalContext`.
  * See design/19-client-navigation.md §"Singleton Guarantee via globalThis"
  */
 
 'use client';
 
-import React, { type ReactNode } from 'react';
+import type { ReactNode } from 'react';
+import { createGlobalContext } from './global-context.ts';
 
 export const EMPTY_SEGMENT_UPDATES = new Map<string, ReactNode>();
 
-const CTX_KEY = Symbol.for('__timber_segment_update_ctx');
-
-function getOrCreateContext(): React.Context<Map<string, ReactNode>> {
-  const existing = (globalThis as Record<symbol, unknown>)[CTX_KEY] as
-    | React.Context<Map<string, ReactNode>>
-    | undefined;
-  if (existing !== undefined) return existing;
-  if (typeof React.createContext === 'function') {
-    const ctx = React.createContext<Map<string, ReactNode>>(EMPTY_SEGMENT_UPDATES);
-    (globalThis as Record<symbol, unknown>)[CTX_KEY] = ctx;
-    return ctx;
-  }
-  // RSC environment — createContext not available. Return a dummy that
-  // won't be used (outlets only render on the client).
-  return undefined as unknown as React.Context<Map<string, ReactNode>>;
-}
-
-export const SegmentUpdateContext = getOrCreateContext();
+export const SegmentUpdateContext = createGlobalContext<Map<string, ReactNode>>(
+  '__timber_segment_update_ctx',
+  EMPTY_SEGMENT_UPDATES
+);

package/src/client/slot-content-cache-context.ts

@@ -0,0 +1,43 @@
+/**
+ * SlotContentCacheContext — the router-owned record of slot content the
+ * client has *committed*.
+ *
+ * The server omits a parallel slot's content when the client advertised a
+ * matching content key (`skip=true`, TIM-1370), and the outlet at that
+ * position must render what it displayed before. This Map, keyed by
+ * segmentPath, is where that content lives.
+ *
+ * Ownership and write discipline (TIM-1423):
+ *
+ * - **One instance per router.** `createTimberRouter` creates the Map and
+ *   provides it above every tree it hands to React — hydration included,
+ *   which builds its chain through the same `renderTree`. It is not a
+ *   module or `globalThis` singleton: a process-wide Map executed during
+ *   SSR would be shared by concurrent requests.
+ * - **Written only at commit.** `SegmentOutlet` writes from a layout effect,
+ *   never during render. A render React discards — a transition superseded
+ *   before it commits, a Suspense retry — leaves the Map untouched, so a
+ *   later `skip=true` can only ever resolve to content the user actually saw.
+ *   The content-key record the client advertises (`SegmentCache`, published
+ *   by `NavigationRoot`'s layout effect on the same commit) and this Map
+ *   are therefore written by the same React commit and cannot describe
+ *   different trees.
+ * - **`null` outside a router.** SSR renders no provider and the outlet then
+ *   neither reads nor writes: the server never emits `skip` during SSR, and
+ *   layout effects do not run there. The default is `null` rather than a
+ *   shared Map so that "no provider" cannot silently become "shared cache".
+ *
+ * Singleton across bundler-duplicated chunks via `createGlobalContext`.
+ */
+
+'use client';
+
+import type { ReactNode } from 'react';
+import { createGlobalContext } from './global-context.ts';
+
+export type SlotContentCache = Map<string, ReactNode>;
+
+export const SlotContentCacheContext = createGlobalContext<SlotContentCache | null>(
+  '__timber_slot_content_cache_ctx',
+  null
+);

package/src/client/ssr-data.ts

@@ -36,8 +36,14 @@ import type { SlotParamsRecord } from '../shared/slot-params.ts';
 export interface SsrData {
   /** The request's URL pathname (e.g. '/dashboard/settings') */
   pathname: string;
-  /** The request's search params as a plain record */
-  searchParams: Record<string, string>;
+  /**
+   * The request's raw app-visible query string (`''` or `?…`), matching what
+   * `window.location.search` will hold after hydration. The raw string is
+   * the only representation carried here: it preserves repeated keys
+   * (`?tag=a&tag=b`), which a collapsed `Record<string, string>` cannot
+   * (TIM-1428). Parse with `new URLSearchParams(search)` where needed.
+   */
+  search: string;
   /** The request's cookies as name→value pairs */
   cookies: Map<string, string>;
   /** The request's route params (e.g. { id: '123' }) */

package/src/client/state.ts

@@ -19,8 +19,6 @@
  * §"Singleton State Registry".
  */
 
-import type { CoercedParams } from '../shared/param-value.ts';
-import type { SlotParamsRecord } from '../shared/slot-params.ts';
 import type { RouterInstance } from './router-types.ts';
 import type { SsrData } from './ssr-data.ts';
 
@@ -52,30 +50,6 @@ export function _setCurrentSsrData(data: SsrData | undefined): void {
   currentSsrData = data;
 }
 
-// ─── Route Params (from use-segment-params.ts) ──────────────────────────────────────
-
-/** Current route params snapshot — replaced (not mutated) on each navigation. */
-export let currentParams: CoercedParams = {};
-
-export function _setCurrentParams(params: CoercedParams): void {
-  currentParams = params;
-}
-
-/**
- * Per-slot params snapshot, keyed by slot tree path — the module-level
- * fallback behind `useSegmentParams(slotPath)` when no NavigationContext is
- * mounted (tests, calls outside a component). Replaced, never mutated, on
- * each navigation. See TIM-1285.
- */
-export let currentSlotParams: SlotParamsRecord | null = null;
-
-export function _setCurrentSlotParams(slotParams: SlotParamsRecord | null): void {
-  currentSlotParams = slotParams;
-}
-
-/** Listeners notified when currentParams changes. */
-export const paramsListeners = new Set<() => void>();
-
 // ─── Search Params Cache (from use-search-params.ts) ────────────────────────
 
 /** Cached search string — avoids reparsing when URL hasn't changed. */