@rangojs/router 0.0.0-experimental.002d056c

package/src/browser/prefetch/cache.ts

@@ -0,0 +1,206 @@
+/**
+ * Prefetch Cache
+ *
+ * In-memory cache storing prefetch Response objects for instant cache hits
+ * on subsequent navigation. Cache key is source-dependent (includes the
+ * current page URL) because the server's diff-based response depends on
+ * where the user navigates from.
+ *
+ * Also tracks in-flight prefetch promises so navigation can reuse a
+ * prefetch that is still downloading rather than starting a duplicate
+ * request. See consumeInflightPrefetch().
+ *
+ * Replaces the previous browser HTTP cache approach which was unreliable
+ * due to response draining race conditions and browser inconsistencies.
+ */
+
+import { abortAllPrefetches } from "./queue.js";
+import { invalidateRangoState } from "../rango-state.js";
+
+// Default TTL: 5 minutes. Overridden by initPrefetchCache() with
+// the server-configured prefetchCacheTTL from router options.
+// 0 disables the in-memory cache entirely.
+let cacheTTL = 300_000;
+
+/**
+ * Initialize the prefetch cache with the configured TTL.
+ * Called once at app startup with the value from server metadata.
+ * A TTL of 0 disables the in-memory cache and all prefetching.
+ */
+export function initPrefetchCache(ttlMs: number): void {
+  cacheTTL = ttlMs;
+}
+
+/**
+ * Check if the prefetch cache is disabled (TTL <= 0).
+ * When disabled, no prefetch requests should be issued.
+ */
+export function isPrefetchCacheDisabled(): boolean {
+  return cacheTTL <= 0;
+}
+const MAX_PREFETCH_CACHE_SIZE = 50;
+
+interface PrefetchCacheEntry {
+  response: Response;
+  timestamp: number;
+}
+
+const cache = new Map<string, PrefetchCacheEntry>();
+const inflight = new Set<string>();
+
+/**
+ * In-flight promise map. When a prefetch fetch is in progress, its
+ * Promise<Response | null> is stored here so navigation can await
+ * it instead of starting a duplicate request.
+ */
+const inflightPromises = new Map<string, Promise<Response | null>>();
+
+// Generation counter incremented on each clearPrefetchCache(). Fetches that
+// started before a clear carry a stale generation and must not store their
+// response (the data may be stale due to a server action invalidation).
+let generation = 0;
+
+/**
+ * Build a source-dependent cache key.
+ * Includes the source page href so the same target prefetched from
+ * different pages gets separate entries — the server response varies
+ * based on the source page context (diff-based rendering).
+ */
+export function buildPrefetchKey(sourceHref: string, targetUrl: URL): string {
+  return sourceHref + "\0" + targetUrl.pathname + targetUrl.search;
+}
+
+/**
+ * Check if a prefetch is already cached, in-flight, or queued for the given key.
+ */
+export function hasPrefetch(key: string): boolean {
+  if (inflight.has(key)) return true;
+  if (cacheTTL <= 0) return false;
+  const entry = cache.get(key);
+  if (!entry) return false;
+  if (Date.now() - entry.timestamp > cacheTTL) {
+    cache.delete(key);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Consume a cached prefetch response. Returns null if not found or expired.
+ * One-time consumption: the entry is deleted after retrieval.
+ * Returns null when caching is disabled (TTL <= 0).
+ *
+ * Does NOT check in-flight prefetches — use consumeInflightPrefetch()
+ * for that (returns a Promise instead of a Response).
+ */
+export function consumePrefetch(key: string): Response | null {
+  if (cacheTTL <= 0) return null;
+  const entry = cache.get(key);
+  if (!entry) return null;
+  if (Date.now() - entry.timestamp > cacheTTL) {
+    cache.delete(key);
+    return null;
+  }
+  cache.delete(key);
+  return entry.response;
+}
+
+/**
+ * Consume an in-flight prefetch promise. Returns null if no prefetch is
+ * in-flight for this key. The returned Promise resolves to the buffered
+ * Response (or null if the fetch failed/was aborted).
+ *
+ * One-time consumption: the promise entry is removed so a second call
+ * returns null. The `inflight` set entry is intentionally kept so that
+ * hasPrefetch() continues to return true while the underlying fetch is
+ * still downloading — this prevents prefetchDirect() or other callers
+ * from starting a duplicate request during the handoff window. The
+ * inflight flag is cleaned up naturally by clearPrefetchInflight() in
+ * the fetch's .finally().
+ */
+export function consumeInflightPrefetch(
+  key: string,
+): Promise<Response | null> | null {
+  const promise = inflightPromises.get(key);
+  if (!promise) return null;
+  // Remove the promise (one-time consumption) but keep the inflight flag.
+  inflightPromises.delete(key);
+  return promise;
+}
+
+/**
+ * Store a prefetch response in the in-memory cache.
+ * The response body must be fully buffered (e.g. via arrayBuffer()) before
+ * storing, so the cached Response is self-contained and network-independent.
+ *
+ * Skips storage if the generation has changed since the fetch started
+ * (a server action invalidated the cache mid-flight).
+ */
+export function storePrefetch(
+  key: string,
+  response: Response,
+  fetchGeneration: number,
+): void {
+  if (cacheTTL <= 0) return;
+  if (fetchGeneration !== generation) return;
+
+  // Evict expired entries
+  const now = Date.now();
+  for (const [k, entry] of cache) {
+    if (now - entry.timestamp > cacheTTL) {
+      cache.delete(k);
+    }
+  }
+
+  // FIFO eviction if at capacity
+  if (cache.size >= MAX_PREFETCH_CACHE_SIZE) {
+    const oldest = cache.keys().next().value;
+    if (oldest) cache.delete(oldest);
+  }
+
+  cache.set(key, { response, timestamp: now });
+}
+
+/**
+ * Capture the current generation. The returned value is passed to
+ * storePrefetch so it can detect stale completions.
+ */
+export function currentGeneration(): number {
+  return generation;
+}
+
+export function markPrefetchInflight(key: string): void {
+  inflight.add(key);
+}
+
+/**
+ * Store the in-flight Promise for a prefetch so navigation can reuse it.
+ */
+export function setInflightPromise(
+  key: string,
+  promise: Promise<Response | null>,
+): void {
+  inflightPromises.set(key, promise);
+}
+
+export function clearPrefetchInflight(key: string): void {
+  inflight.delete(key);
+  inflightPromises.delete(key);
+}
+
+/**
+ * Invalidate all prefetch state. Called when server actions mutate data.
+ * Clears the in-memory cache, cancels in-flight prefetches, and rotates
+ * the Rango state key so CDN-cached responses are also invalidated.
+ *
+ * Uses abortAllPrefetches (hard cancel) because in-flight responses
+ * may contain stale data after a mutation.
+ */
+export function clearPrefetchCache(): void {
+  generation++;
+  inflight.clear();
+  inflightPromises.clear();
+  cache.clear();
+  abortAllPrefetches();
+  invalidateRangoState();
+}

package/src/browser/prefetch/fetch.ts

@@ -0,0 +1,145 @@
+/**
+ * Prefetch Fetch
+ *
+ * Fetch-based prefetch logic used by Link (hover/viewport/render strategies)
+ * and useRouter().prefetch(). Sends the same headers and segment IDs as a
+ * real navigation so the server returns a proper diff. The Response is fully
+ * buffered and stored in an in-memory cache for instant consumption on
+ * subsequent navigation.
+ *
+ * In-flight promises are tracked in the cache so that navigation can reuse
+ * a prefetch that is still downloading instead of starting a duplicate request.
+ */
+
+import {
+  buildPrefetchKey,
+  hasPrefetch,
+  markPrefetchInflight,
+  setInflightPromise,
+  storePrefetch,
+  clearPrefetchInflight,
+  currentGeneration,
+} from "./cache.js";
+import { getRangoState } from "../rango-state.js";
+import { enqueuePrefetch } from "./queue.js";
+import { shouldPrefetch } from "./policy.js";
+
+/**
+ * Build an RSC partial URL for prefetching.
+ * Includes _rsc_segments so the server can diff against currently mounted
+ * segments, and _rsc_v for version mismatch detection.
+ * Returns null for malformed or cross-origin URLs.
+ */
+function buildPrefetchUrl(
+  url: string,
+  segmentIds: string[],
+  version?: string,
+): URL | null {
+  let targetUrl: URL;
+  try {
+    targetUrl = new URL(url, window.location.origin);
+  } catch {
+    return null;
+  }
+  if (targetUrl.origin !== window.location.origin) {
+    return null;
+  }
+  targetUrl.searchParams.set("_rsc_partial", "true");
+  if (segmentIds.length > 0) {
+    targetUrl.searchParams.set("_rsc_segments", segmentIds.join(","));
+  }
+  if (version) {
+    targetUrl.searchParams.set("_rsc_v", version);
+  }
+  return targetUrl;
+}
+
+/**
+ * Core prefetch fetch logic. Fetches the response, fully buffers the body,
+ * and stores it in the in-memory cache. The returned Promise resolves to
+ * the buffered Response (or null on failure) so navigation can reuse
+ * in-flight prefetches via consumeInflightPrefetch().
+ */
+function executePrefetchFetch(
+  key: string,
+  fetchUrl: string,
+  signal?: AbortSignal,
+): Promise<Response | null> {
+  const gen = currentGeneration();
+  markPrefetchInflight(key);
+
+  const promise: Promise<Response | null> = fetch(fetchUrl, {
+    priority: "low" as RequestPriority,
+    signal,
+    headers: {
+      "X-Rango-State": getRangoState(),
+      "X-RSC-Router-Client-Path": window.location.href,
+      "X-Rango-Prefetch": "1",
+    },
+  })
+    .then(async (response) => {
+      if (!response.ok) return null;
+      // Fully buffer the response body so the cached Response is
+      // self-contained and doesn't depend on the network connection.
+      // This eliminates the race condition where the user clicks before
+      // the response body has been fully downloaded.
+      const buffer = await response.arrayBuffer();
+      const cachedResponse = new Response(buffer, {
+        headers: response.headers,
+        status: response.status,
+        statusText: response.statusText,
+      });
+      storePrefetch(key, cachedResponse.clone(), gen);
+      return cachedResponse;
+    })
+    .catch(() => null)
+    .finally(() => {
+      clearPrefetchInflight(key);
+    });
+
+  setInflightPromise(key, promise);
+  return promise;
+}
+
+/**
+ * Prefetch (direct): fetch with low priority and store in in-memory cache.
+ * Used by hover strategy -- fires immediately without queueing.
+ */
+export function prefetchDirect(
+  url: string,
+  segmentIds: string[],
+  version?: string,
+): void {
+  if (!shouldPrefetch()) return;
+
+  const targetUrl = buildPrefetchUrl(url, segmentIds, version);
+  if (!targetUrl) return;
+  const key = buildPrefetchKey(window.location.href, targetUrl);
+  if (hasPrefetch(key)) return;
+  executePrefetchFetch(key, targetUrl.toString());
+}
+
+/**
+ * Prefetch (queued): goes through the concurrency-limited queue.
+ * Used by viewport/render strategies to avoid flooding the server.
+ * Returns the cache key for use in cleanup.
+ */
+export function prefetchQueued(
+  url: string,
+  segmentIds: string[],
+  version?: string,
+): string {
+  if (!shouldPrefetch()) return "";
+  const targetUrl = buildPrefetchUrl(url, segmentIds, version);
+  if (!targetUrl) return "";
+  const key = buildPrefetchKey(window.location.href, targetUrl);
+  if (hasPrefetch(key)) return key;
+  const fetchUrlStr = targetUrl.toString();
+  enqueuePrefetch(key, (signal) => {
+    // Re-check at execution time: a hover-triggered prefetchDirect may
+    // have started or completed this key while the item sat in the queue.
+    if (hasPrefetch(key)) return Promise.resolve();
+    return executePrefetchFetch(key, fetchUrlStr, signal).then(() => {});
+  });
+  return key;
+}

package/src/browser/prefetch/observer.ts

@@ -0,0 +1,65 @@
+/**
+ * Prefetch Observer
+ *
+ * Shared singleton IntersectionObserver for viewport-based prefetching.
+ * One observer handles all Link components with prefetch="viewport".
+ *
+ * Lazy-created on first call to avoid issues in SSR or test environments
+ * where IntersectionObserver may not exist.
+ *
+ * Observation is one-shot: once a link enters the viewport and the callback
+ * fires, the element is unobserved. This prevents re-prefetching when a link
+ * scrolls in and out repeatedly.
+ */
+
+type PrefetchCallback = () => void;
+
+const callbacks = new Map<Element, PrefetchCallback>();
+let observer: IntersectionObserver | null = null;
+
+function getObserver(): IntersectionObserver {
+  if (!observer) {
+    observer = new IntersectionObserver(
+      (entries) => {
+        for (const entry of entries) {
+          if (entry.isIntersecting) {
+            const callback = callbacks.get(entry.target);
+            if (callback) {
+              observer!.unobserve(entry.target);
+              callbacks.delete(entry.target);
+              callback();
+            }
+          }
+        }
+      },
+      { rootMargin: "200px" },
+    );
+  }
+  return observer;
+}
+
+/**
+ * Observe an element for viewport intersection.
+ * When the element becomes visible (within 200px margin), the callback fires
+ * and the element is automatically unobserved.
+ * No-op in environments without IntersectionObserver (SSR, some test runners).
+ */
+export function observeForPrefetch(
+  element: Element,
+  onVisible: PrefetchCallback,
+): void {
+  if (typeof IntersectionObserver === "undefined") return;
+  callbacks.set(element, onVisible);
+  getObserver().observe(element);
+}
+
+/**
+ * Stop observing an element. Used for cleanup when a Link unmounts
+ * before entering the viewport.
+ */
+export function unobserveForPrefetch(element: Element): void {
+  callbacks.delete(element);
+  if (observer) {
+    observer.unobserve(element);
+  }
+}

package/src/browser/prefetch/policy.ts

@@ -0,0 +1,48 @@
+/**
+ * Prefetch Policy
+ *
+ * Determines whether speculative prefetching should run for the current user.
+ * Honors browser reduced-data preferences when available.
+ */
+
+import { isPrefetchCacheDisabled } from "./cache.js";
+
+type NavigatorWithConnection = Navigator & {
+  connection?: {
+    saveData?: boolean;
+  };
+};
+
+/**
+ * Evaluate on every call so runtime changes to Save-Data or
+ * prefers-reduced-data are respected immediately.
+ */
+export function shouldPrefetch(): boolean {
+  if (typeof window === "undefined") return false;
+
+  // When prefetchCacheTTL is false/0, prefetching is fully disabled —
+  // no point issuing requests whose responses will be discarded.
+  if (isPrefetchCacheDisabled()) return false;
+
+  const nav =
+    typeof navigator !== "undefined"
+      ? (navigator as NavigatorWithConnection)
+      : undefined;
+
+  if (nav?.connection?.saveData) return false;
+
+  if (typeof window.matchMedia === "function") {
+    try {
+      if (window.matchMedia("(prefers-reduced-data: reduce)").matches) {
+        return false;
+      }
+    } catch {
+      // Ignore unsupported query errors and allow prefetch.
+    }
+  }
+
+  return true;
+}
+
+/** No-op, kept for test compatibility. */
+export function resetPrefetchPolicy(): void {}

package/src/browser/prefetch/queue.ts

@@ -0,0 +1,128 @@
+/**
+ * Prefetch Queue
+ *
+ * Concurrency-limited FIFO queue for speculative prefetches (viewport/render).
+ * Hover prefetches bypass this queue — they fire directly for immediate response
+ * to user intent.
+ *
+ * Draining is deferred to the next animation frame so prefetch network activity
+ * never blocks paint. This applies to both the initial batch and subsequent
+ * batches — every drain cycle yields to the browser first.
+ *
+ * When a navigation starts, queued prefetches are cancelled but executing ones
+ * are left running. Navigation can reuse their in-flight responses via the
+ * prefetch cache's inflight promise map, avoiding duplicate requests.
+ */
+
+const MAX_CONCURRENT = 2;
+
+const deferToNextPaint: (fn: () => void) => void =
+  typeof requestAnimationFrame === "function"
+    ? requestAnimationFrame
+    : (fn) => setTimeout(fn, 0);
+
+let active = 0;
+const queue: Array<{
+  key: string;
+  execute: (signal: AbortSignal) => Promise<void>;
+}> = [];
+const queued = new Set<string>();
+const executing = new Set<string>();
+let abortController: AbortController | null = null;
+let drainScheduled = false;
+
+function startExecution(
+  key: string,
+  execute: (signal: AbortSignal) => Promise<void>,
+): void {
+  active++;
+  executing.add(key);
+  abortController ??= new AbortController();
+  execute(abortController.signal).finally(() => {
+    // Only decrement if this key wasn't already cleared by cancelAllPrefetches.
+    // Without this guard, cancelled tasks' .finally() would underflow active
+    // below zero, breaking the MAX_CONCURRENT guarantee.
+    if (executing.delete(key)) {
+      active--;
+    }
+    scheduleDrain();
+  });
+}
+
+/**
+ * Schedule a drain on the next animation frame.
+ * Coalesces multiple drain requests into a single rAF callback so
+ * batch completion doesn't schedule redundant frames.
+ */
+function scheduleDrain(): void {
+  if (drainScheduled) return;
+  if (active >= MAX_CONCURRENT || queue.length === 0) return;
+  drainScheduled = true;
+  deferToNextPaint(() => {
+    drainScheduled = false;
+    drain();
+  });
+}
+
+function drain(): void {
+  while (active < MAX_CONCURRENT && queue.length > 0) {
+    const item = queue.shift()!;
+    queued.delete(item.key);
+    startExecution(item.key, item.execute);
+  }
+}
+
+/**
+ * Enqueue a prefetch for concurrency-limited execution.
+ * Execution is always deferred to the next animation frame to avoid
+ * blocking paint, even when below the concurrency limit.
+ * Deduplicates by key — items already queued or executing are skipped.
+ *
+ * The executor receives an AbortSignal that is aborted when
+ * cancelAllPrefetches() is called (e.g. on navigation start).
+ */
+export function enqueuePrefetch(
+  key: string,
+  execute: (signal: AbortSignal) => Promise<void>,
+): void {
+  if (queued.has(key) || executing.has(key)) return;
+
+  queued.add(key);
+  queue.push({ key, execute });
+  scheduleDrain();
+}
+
+/**
+ * Cancel queued prefetches. Executing prefetches are left running so
+ * navigation can reuse their in-flight responses (checked via
+ * consumeInflightPrefetch in the prefetch cache). With MAX_CONCURRENT=2
+ * and priority: "low", in-flight prefetches don't meaningfully compete
+ * with navigation fetches under HTTP/2 multiplexing.
+ *
+ * Called when a navigation starts via the NavigationProvider's
+ * event controller subscription.
+ */
+export function cancelAllPrefetches(): void {
+  queue.length = 0;
+  queued.clear();
+  drainScheduled = false;
+}
+
+/**
+ * Hard-cancel everything including in-flight prefetches.
+ * Used by clearPrefetchCache (server action invalidation) where
+ * in-flight responses would be stale.
+ */
+export function abortAllPrefetches(): void {
+  abortController?.abort();
+  abortController = null;
+
+  queue.length = 0;
+  queued.clear();
+  // Clear executing before resetting active. In-flight .finally() callbacks
+  // check executing.delete(key) — if the key is gone, they skip decrementing,
+  // so active settles at 0 without underflow.
+  executing.clear();
+  active = 0;
+  drainScheduled = false;
+}

package/src/browser/rango-state.ts

@@ -0,0 +1,112 @@
+/**
+ * Rango State
+ *
+ * Manages a localStorage-based state key for HTTP cache invalidation.
+ * The key is sent as the `X-Rango-State` header on both prefetch and
+ * navigation requests. The server responds with `Vary: X-Rango-State`,
+ * so the browser HTTP cache keys responses by (URL, X-Rango-State value).
+ *
+ * Format: `{buildVersion}:{invalidationTimestamp}`
+ * - Build version changes on deploy, busting all cached prefetches.
+ * - Timestamp changes on server action invalidation.
+ *
+ * localStorage is cross-tab and survives page refresh, so:
+ * - One tab's prefetch warms the cache for all tabs.
+ * - Invalidation in one tab is picked up by other tabs on next fetch.
+ */
+
+const STORAGE_KEY = "rango-state";
+
+// Module-level cache avoids hitting localStorage on every getRangoState() call.
+// Initialized from localStorage on first access or by initRangoState().
+let cachedState: string | null = null;
+
+// Cross-tab sync: the `storage` event fires in OTHER tabs when one tab writes
+// to localStorage, keeping cachedState fresh without polling.
+let storageListenerAttached = false;
+
+function attachStorageListener(): void {
+  if (storageListenerAttached || typeof window === "undefined") return;
+  window.addEventListener("storage", (e) => {
+    if (e.key !== STORAGE_KEY) return;
+    cachedState = e.newValue;
+  });
+  storageListenerAttached = true;
+}
+
+/**
+ * Initialize the Rango state key in localStorage.
+ * Called once at app startup with the build version from the server.
+ * If localStorage already has a key with matching version prefix, keeps it
+ * (preserves invalidation state across refresh). Otherwise writes a new key.
+ */
+export function initRangoState(version: string): void {
+  if (typeof window === "undefined") return;
+
+  attachStorageListener();
+
+  try {
+    const existing = localStorage.getItem(STORAGE_KEY);
+    if (existing) {
+      const colonIdx = existing.indexOf(":");
+      if (colonIdx > 0) {
+        const existingVersion = existing.slice(0, colonIdx);
+        if (existingVersion === version) {
+          cachedState = existing;
+          return;
+        }
+      }
+    }
+    // New version or first load
+    const newState = `${version}:${Date.now()}`;
+    localStorage.setItem(STORAGE_KEY, newState);
+    cachedState = newState;
+  } catch {
+    // localStorage may be unavailable (private browsing in some browsers)
+    cachedState = `${version}:${Date.now()}`;
+  }
+}
+
+/**
+ * Get the current Rango state key value.
+ * Used as the `X-Rango-State` header value for prefetch and navigation requests.
+ */
+export function getRangoState(): string {
+  if (cachedState) return cachedState;
+
+  if (typeof window === "undefined") return "0:0";
+
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    if (stored) {
+      cachedState = stored;
+      return stored;
+    }
+  } catch {
+    // Fallback for unavailable localStorage
+  }
+
+  return "0:0";
+}
+
+/**
+ * Invalidate the Rango state key. Called when server actions mutate data.
+ * Updates the timestamp portion while keeping the version prefix.
+ * The new value takes effect immediately for all subsequent fetches,
+ * causing Vary mismatches with previously cached responses.
+ */
+export function invalidateRangoState(): void {
+  const current = getRangoState();
+  const colonIdx = current.indexOf(":");
+  const version = colonIdx > 0 ? current.slice(0, colonIdx) : "0";
+  const newState = `${version}:${Date.now()}`;
+  cachedState = newState;
+
+  if (typeof window === "undefined") return;
+
+  try {
+    localStorage.setItem(STORAGE_KEY, newState);
+  } catch {
+    // Silently handle localStorage errors
+  }
+}