@rangojs/router 0.0.0-experimental.13 → 0.0.0-experimental.131

package/src/cache/types.ts

@@ -12,10 +12,6 @@
 import type { ResolvedSegment } from "../types.js";
 import type { RequestContext } from "../server/request-context.js";
 
-// ============================================================================
-// Segment Cache Store (low-level storage interface)
-// ============================================================================
-
 /**
  * Result from cache get() including data and revalidation status
  */
@@ -75,14 +71,14 @@ export interface SegmentCacheStore<TEnv = unknown> {
    * @example Using cookies for locale
    * ```typescript
    * keyGenerator: (ctx, defaultKey) => {
-   *   const locale = ctx.cookie('locale') || 'en';
+   *   const locale = cookies().get('locale')?.value || 'en';
    *   return `${locale}:${defaultKey}`;
    * }
    * ```
    */
   readonly keyGenerator?: (
     ctx: RequestContext<TEnv>,
-    defaultKey: string
+    defaultKey: string,
   ) => string | Promise<string>;
 
   /**
@@ -98,7 +94,12 @@ export interface SegmentCacheStore<TEnv = unknown> {
    * @param ttl - Time-to-live in seconds
    * @param swr - Optional stale-while-revalidate window in seconds
    */
-  set(key: string, data: CachedEntryData, ttl: number, swr?: number): Promise<void>;
+  set(
+    key: string,
+    data: CachedEntryData,
+    ttl: number,
+    swr?: number,
+  ): Promise<void>;
 
   /**
    * Delete a cached entry
@@ -111,17 +112,13 @@ export interface SegmentCacheStore<TEnv = unknown> {
    */
   clear?(): Promise<void>;
 
-  // ============================================================================
-  // Document Cache Methods (optional)
-  // ============================================================================
-  // These methods are for caching full HTTP responses (document-level caching).
-  // Stores that support response caching should implement these methods.
-
   /**
    * Get a cached Response by key.
    * Returns the response and whether it should be revalidated (SWR).
    */
-  getResponse?(key: string): Promise<{ response: Response; shouldRevalidate: boolean } | null>;
+  getResponse?(
+    key: string,
+  ): Promise<{ response: Response; shouldRevalidate: boolean } | null>;
 
   /**
    * Store a Response with TTL and optional SWR window.
@@ -129,8 +126,78 @@ export interface SegmentCacheStore<TEnv = unknown> {
    * @param response - Response to cache (will be cloned)
    * @param ttl - Time-to-live in seconds
    * @param swr - Optional stale-while-revalidate window in seconds
+   * @param tags - Optional cache tags for invalidation
+   */
+  putResponse?(
+    key: string,
+    response: Response,
+    ttl: number,
+    swr?: number,
+    tags?: string[],
+  ): Promise<void>;
+
+  /**
+   * Get a cached function result by key.
+   * Returns the serialized value, optional handle data, and staleness flag.
    */
-  putResponse?(key: string, response: Response, ttl: number, swr?: number): Promise<void>;
+  getItem?(key: string): Promise<CacheItemResult | null>;
+
+  /**
+   * Store a function result with TTL and optional SWR window.
+   * @param key - Cache key (format: use-cache:{functionId}:{serializedArgs})
+   * @param value - RSC-serialized return value
+   * @param options - TTL, SWR, handle data, and tags
+   */
+  setItem?(
+    key: string,
+    value: string,
+    options?: CacheItemOptions,
+  ): Promise<void>;
+
+  /**
+   * Invalidate every cache entry (segment, response, item) tagged with any of
+   * `tags`. Store-level primitive that the public updateTag()/revalidateTag()
+   * APIs delegate to. Receives ALL of one invalidation call's tags at once so
+   * stores can batch their work (e.g. a single CDN purge request rather than
+   * one per tag). Stores that do not support tags simply omit this method.
+   * @param tags - The cache tags to invalidate
+   */
+  invalidateTags?(tags: string[]): Promise<void>;
+}
+
+/**
+ * Result from getItem() for function-level caching ("use cache").
+ */
+export interface CacheItemResult {
+  /** RSC-serialized return value */
+  value: string;
+  /** RSC-encoded handle data captured during execution (breadcrumbs, metadata,
+   *  etc.). Encoded via the Flight codec so Promise/ReactNode handle values
+   *  survive JSON-serializing stores — see handle-snapshot.ts encodeHandles. */
+  handles?: string;
+  /** Whether the entry is stale and should be revalidated */
+  shouldRevalidate: boolean;
+  /**
+   * The entry's cache tags (including runtime cacheTag() tags), surfaced on read
+   * so a "use cache" HIT can still contribute its tags to the request-scoped tag
+   * set used by document-level caching. On a hit the cached function is not
+   * re-run, so its runtime tags are only available here, not from re-execution.
+   */
+  tags?: string[];
+}
+
+/**
+ * Options for setItem() for function-level caching ("use cache").
+ */
+export interface CacheItemOptions {
+  /** RSC-encoded handle data to store alongside the value (see encodeHandles). */
+  handles?: string;
+  /** Time-to-live in seconds */
+  ttl?: number;
+  /** Stale-while-revalidate window in seconds */
+  swr?: number;
+  /** Cache tags for invalidation */
+  tags?: string[];
 }
 
 /**
@@ -151,7 +218,10 @@ export interface SerializedSegmentData {
   /** RSC-encoded loaderDataPromise (if present) */
   encodedLoaderDataPromise?: string;
   /** Segment metadata (everything except component, layout, loading, and loader data) */
-  metadata: Omit<ResolvedSegment, "component" | "layout" | "loading" | "loaderData" | "loaderDataPromise">;
+  metadata: Omit<
+    ResolvedSegment,
+    "component" | "layout" | "loading" | "loaderData" | "loaderDataPromise"
+  >;
 }
 
 /**
@@ -162,16 +232,18 @@ export interface SerializedSegmentData {
 export interface CachedEntryData {
   /** Serialized segments for this entry */
   segments: SerializedSegmentData[];
-  /** Handle data keyed by segment ID */
-  handles: Record<string, SegmentHandleData>;
+  /** RSC-encoded handle data keyed by segment ID. Encoded via the Flight codec
+   *  (see handle-snapshot.ts encodeHandles) so Promise/ReactNode handle values
+   *  round-trip through JSON-serializing stores instead of being flattened. */
+  handles: string;
   /** Expiration timestamp (ms since epoch) */
   expiresAt: number;
+  /** Cache tags for invalidation */
+  tags?: string[];
+  /** Timestamp (ms since epoch) when tags were attached, for distributed invalidation */
+  taggedAt?: number;
 }
 
-// ============================================================================
-// Cache Configuration
-// ============================================================================
-
 /**
  * Default cache options applied to all cache() boundaries.
  * Individual cache() calls can override any of these values.
@@ -196,197 +268,8 @@ export interface CacheDefaults {
   swr?: number;
 }
 
-/**
- * Cache configuration for RSC handler
- */
-export interface CacheConfig {
-  /** Cache store implementation (includes defaults) */
-  store: SegmentCacheStore;
-  /** Enable/disable caching (default: true) */
-  enabled?: boolean;
-}
-
-/**
- * Cache configuration - can be static or a function receiving env
- */
-export type CacheConfigOrFactory<TEnv> =
-  | CacheConfig
-  | ((env: TEnv) => CacheConfig);
-
-// ============================================================================
-// Segment Cache Provider (request-level interface)
-// ============================================================================
-
 /**
  * Handle data for a single segment
  * Structure: { handleName: [values...] }
  */
 export type SegmentHandleData = Record<string, unknown[]>;
-
-/**
- * Result from cache get() including segments and their handle data
- * Each entry can produce multiple segments (main + parallels)
- */
-export interface CachedEntryResult {
-  /** All segments for this entry (main segment + parallels) */
-  segments: ResolvedSegment[];
-  /** Handle data keyed by segment ID */
-  handles: Record<string, SegmentHandleData>;
-}
-
-
-/**
- * Segment cache provider interface
- *
- * Used by router to check/store segment cache during matching.
- * Accessed via request context - if not present, caching is disabled.
- *
- * @internal Not currently implemented - CacheScope is used directly.
- * Reserved for future extensibility.
- */
-export interface SegmentCacheProvider {
-  /** Whether caching is enabled for this request */
-  readonly enabled: boolean;
-
-  /**
-   * Get cached segments and restore handles/loaders.
-   *
-   * Combines cache get with handle replay and loader data restoration.
-   * Returns tuple of [segments, segmentIds] if cache hit, null if miss or disabled.
-   *
-   * @param cacheKey - Cache key to look up
-   * @param params - Route params for cache key generation
-   * @param loaderPromises - Map to restore loader data into
-   * @returns Tuple of [segments, segmentIds] or null if miss
-   */
-  restore(
-    cacheKey: string,
-    params: Record<string, string>,
-    loaderPromises: Map<string, Promise<any>>
-  ): Promise<[ResolvedSegment[], string[]] | null>;
-
-  /**
-   * Cache entry with automatic handle collection (non-blocking).
-   *
-   * Schedules caching via waitUntil - handles are collected after they settle.
-   * Validates segments have actual components before caching.
-   *
-   * @param cacheKey - The cache key to store under
-   * @param segments - All resolved segments for this entry
-   */
-  cacheEntry(cacheKey: string, segments: ResolvedSegment[]): void;
-}
-
-// ============================================================================
-// Generic Cache Store (for future extensibility)
-// ============================================================================
-// These types support a general-purpose cache interface that can be used
-// for caching arbitrary values (responses, streams, objects). Currently,
-// the segment caching system uses SegmentCacheStore directly, but these
-// types enable future use cases like response caching or data caching.
-
-/**
- * Supported cache value types for the generic CacheStore interface.
- * @internal Reserved for future extensibility
- */
-export type CacheValue =
-  | ReadableStream<Uint8Array>
-  | Response
-  | ArrayBuffer
-  | string
-  | unknown[] // JSON-serializable array
-  | Record<string, unknown>; // JSON-serializable object
-
-/**
- * Cache entry returned by match().
- * @internal Reserved for future extensibility
- */
-export interface CacheEntry<T = CacheValue> {
-  /** The cached value */
-  value: T;
-  /** Optional metadata stored with the entry */
-  metadata?: CacheMetadata;
-}
-
-/**
- * Original value type for reconstruction.
- * @internal Reserved for future extensibility
- */
-export type CacheValueType =
-  | "stream"
-  | "response"
-  | "arraybuffer"
-  | "string"
-  | "object";
-
-/**
- * Metadata associated with a cache entry.
- * @internal Reserved for future extensibility
- */
-export interface CacheMetadata {
-  /** Timestamp when entry expires (ms since epoch) */
-  expiresAt?: number;
-  /** Tags for bulk invalidation */
-  tags?: string[];
-  /** Original value type for reconstruction on read */
-  valueType?: CacheValueType;
-  /** Response headers (preserved when caching Response) */
-  responseHeaders?: Record<string, string>;
-  /** Response status (preserved when caching Response) */
-  responseStatus?: number;
-  /** Custom metadata */
-  [key: string]: unknown;
-}
-
-/**
- * Options for put().
- * @internal Reserved for future extensibility
- */
-export interface CachePutOptions {
-  /** Time-to-live in seconds */
-  ttl?: number;
-  /** Metadata to store with entry */
-  metadata?: Omit<CacheMetadata, "expiresAt">;
-}
-
-/**
- * Generic cache store interface for arbitrary value types.
- *
- * This interface is designed for future extensibility to support caching
- * responses, streams, and other values. Currently, segment caching uses
- * the SegmentCacheStore interface directly.
- *
- * Implementations must handle:
- * - Stream values (clone before storing, streams can only be read once)
- * - Promise values (await before storing)
- * - Expiration/TTL
- *
- * @internal Reserved for future extensibility
- */
-export interface CacheStore {
-  /**
-   * Retrieve a cached entry by key.
-   * @param key - Cache key
-   * @returns The cached entry or undefined if not found/expired
-   */
-  match<T = CacheValue>(key: string): Promise<CacheEntry<T> | undefined>;
-
-  /**
-   * Store a value in the cache.
-   * @param key - Cache key
-   * @param value - Value to cache (stream, response, string, object, etc.)
-   * @param options - TTL, metadata, etc.
-   */
-  put<T extends CacheValue>(
-    key: string,
-    value: T,
-    options?: CachePutOptions
-  ): Promise<void>;
-
-  /**
-   * Delete a cached entry.
-   * @param key - Cache key
-   * @returns true if entry was deleted, false if not found
-   */
-  delete(key: string): Promise<boolean>;
-}

package/src/client.rsc.tsx

@@ -14,70 +14,57 @@
 export {
   Outlet,
   ParallelOutlet,
-  OutletProvider,
   useOutlet,
   useLoader,
-  useLoaderData,
   ErrorBoundary,
   type ErrorBoundaryProps,
 } from "./client.js";
 
-// Re-export the server's createLoader for RSC context
-// This version includes the actual loader function
 export { createLoader } from "./route-definition.js";
 
-// Re-export Link component (can be used in server components)
 export {
   Link,
   type LinkProps,
   type PrefetchStrategy,
 } from "./browser/react/Link.js";
 
-// Re-export ScrollRestoration (can be used in server components)
 export {
   ScrollRestoration,
   type ScrollRestorationProps,
 } from "./browser/react/ScrollRestoration.js";
 
-// Re-export NavigationProvider (needed for setup)
 export {
   NavigationProvider,
   type NavigationProviderProps,
 } from "./browser/react/NavigationProvider.js";
 
-// Re-export href function (can be used in server components)
 export { href } from "./href-client.js";
 
-// Mount context re-exports (useMount is client-only, but MountContext can be referenced)
 export { MountContext } from "./browser/react/mount-context.js";
 
-// Note: useNavigation, useAction, useClientCache are NOT re-exported here
-// because they use client-side state and should only be used in client components
+// useNavigation and useAction are NOT re-exported here because they use client-side state
 
-// Handle API - for accumulating data across route segments
-// Works in both RSC and client contexts
 export { createHandle, isHandle, type Handle } from "./handle.js";
 
-// Built-in handles
-// Meta handle works in RSC context
 export { Meta } from "./handles/meta.js";
-// MetaTags is a "use client" component that can be imported from RSC
 export { MetaTags } from "./handles/MetaTags.js";
 export type { MetaDescriptor, MetaDescriptorBase } from "./router/types.js";
+export { Breadcrumbs, type BreadcrumbItem } from "./handles/breadcrumbs.js";
 
-// Location state - createLocationState works in RSC (just creates definition)
-// useLocationState is NOT exported here as it uses client hooks
 export {
   createLocationState,
   type LocationStateDefinition,
   type LocationStateEntry,
+  type LocationStateOptions,
 } from "./browser/react/location-state-shared.js";
 
-// Re-export useHref - it's a "use client" hook
 export { useHref } from "./browser/react/use-href.js";
 
-// Re-export useHandle - it's a "use client" hook
+export { useReverse } from "./browser/react/use-reverse.js";
+
 export { useHandle } from "./browser/react/use-handle.js";
+// Type a deferred-aware consumer narrows: an accumulated entry may be a Promise
+// (a `ctx.use(Handle).defer()` slot) until it resolves.
+export type { DeferredHandleEntry } from "./defer.js";
 
-// Re-export useLocationState - it's a "use client" hook
 export { useLocationState } from "./browser/react/location-state.js";