@rangojs/router 0.0.0-experimental.8 → 0.0.0-experimental.80daa23e

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

@@ -0,0 +1,53 @@
+import type { RouterContext } from "./router-context.js";
+import type { ResolveSegmentOptions } from "./segment-resolution.js";
+import type { EntryData } from "../server/context";
+import type { PartialPrerenderProps } from "../urls/pattern-types.js";
+import type { HandlerContext, ResolvedSegment } from "../types";
+import type { SerializedSegmentData } from "../cache/types.js";
+import type { RouteMatchResult } from "./pattern-matching.js";
+export interface PrerenderMatchDeps<TEnv = any> {
+    /** Owning router id; scopes bake-time root-scope/search-schema lookups the
+     *  same way reqCtx._routerId does at runtime (issue #762). */
+    routerId?: string;
+    findMatch: (pathname: string) => RouteMatchResult<TEnv> | null | Promise<RouteMatchResult<TEnv> | null>;
+    buildRouterContext: () => RouterContext<TEnv>;
+    mergedRouteMap: Record<string, string>;
+    resolveAllSegments: (entries: EntryData[], routeKey: string, params: Record<string, string>, context: HandlerContext<any, TEnv>, loaderPromises: Map<string, Promise<any>>, options?: ResolveSegmentOptions) => Promise<ResolvedSegment[]>;
+}
+/**
+ * Build-time pre-render match. Resolves segments with a BuildContext
+ * (no request/env/headers/cookies), skipping middleware and loaders.
+ */
+export declare function matchForPrerender<TEnv = any>(pathname: string, params: Record<string, string>, deps: PrerenderMatchDeps<TEnv>, buildVars?: Record<string, any>, isPassthroughRoute?: boolean, buildEnv?: TEnv, 
+/** Dev-only: check getParams() for passthrough routes to skip unknown params. */
+devMode?: boolean): Promise<{
+    segments: SerializedSegmentData[];
+    /** RSC-encoded handle map ("" when none) — see handle-snapshot.ts. Encoded in
+     *  the producer (where the Flight codec resolves) so the node-side build/dev
+     *  sinks can persist it without touching the codec. */
+    handles: string;
+    routeName: string;
+    params: Record<string, string>;
+    interceptSegments?: SerializedSegmentData[];
+    /** RSC-encoded MERGED (main + intercept) handle map for the intercept artifact;
+     *  the sinks store it as-is (no longer merge raw records). */
+    interceptHandles?: string;
+    passthrough?: true;
+    /**
+     * The matched route entry's `ppr` path option, surfaced so the build
+     * collection can flag Prerender+ppr routes as build-time shell candidates
+     * (issue #699 producer B). Runtime-only today; the build otherwise never
+     * sees the option (it lives on EntryData, not the trie).
+     */
+    ppr?: boolean | PartialPrerenderProps;
+} | null>;
+/**
+ * Render a single Static handler at build time.
+ * Creates a minimal BuildContext, calls the handler, and RSC-serializes
+ * the component. Returns the encoded Flight string (or null on failure).
+ * Used by the Vite plugin to collect static segment data at build time.
+ */
+export declare function renderStaticSegment<TEnv = any>(handler: Function, handlerId: string, mergedRouteMap: Record<string, string>, routeName?: string, buildEnv?: TEnv, devMode?: boolean, routerId?: string, rootScoped?: boolean): Promise<{
+    encoded: string;
+    handles: string;
+} | null>;

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

@@ -0,0 +1,22 @@
+import type { EntryData } from "../server/context";
+import type { RouteMatchResult } from "./pattern-matching.js";
+import type { MiddlewareFn } from "./middleware.js";
+export interface PreviewMatchDeps<TEnv = any> {
+    findMatch: (pathname: string) => RouteMatchResult<TEnv> | null | Promise<RouteMatchResult<TEnv> | null>;
+}
+/**
+ * Preview match - returns route middleware without segment resolution.
+ * Also returns responseType and handler for response routes (non-RSC short-circuit).
+ */
+export declare function previewMatch<TEnv = any>(request: Request, _context: TEnv, deps: PreviewMatchDeps<TEnv>): Promise<{
+    routeMiddleware?: Array<{
+        handler: MiddlewareFn;
+        params: Record<string, string>;
+    }>;
+    responseType?: string;
+    handler?: Function;
+    params?: Record<string, string>;
+    negotiated?: boolean;
+    manifestEntry?: EntryData;
+    routeKey?: string;
+} | null>;

package/dist/types/router/request-classification.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Request Classification
+ *
+ * Replaces the implicit "preview then match again" model with a clean
+ * two-stage architecture:
+ *
+ * 1. Classification — classifyRequest() produces a RequestPlan that answers
+ *    all routing questions once: target route, request mode, route middleware,
+ *    response-route info, negotiation state.
+ *
+ * 2. Execution — executeRequest() dispatches on the plan to the appropriate
+ *    handler (response route, loader fetch, full render, partial render,
+ *    action revalidation, PE render).
+ *
+ * Builds on RouteSnapshot from route-snapshot.ts.
+ */
+import type { EntryData } from "../server/context.js";
+import type { CollectedMiddleware } from "./middleware-types.js";
+import type { RouteMatchResult } from "./pattern-matching.js";
+import { type RouteSnapshot } from "./route-snapshot.js";
+interface RedirectPlan<TEnv = any> {
+    mode: "redirect";
+    route: RouteSnapshot<TEnv>;
+    redirectUrl: string;
+}
+interface VersionMismatchPlan<TEnv = any> {
+    mode: "version-mismatch";
+    /** May be undefined when version mismatch is detected before route resolution */
+    route?: RouteSnapshot<TEnv>;
+    reloadUrl: string;
+}
+interface AppSwitchReloadPlan {
+    mode: "app-switch";
+    /** Clean target URL (internal _rsc_* params stripped) to navigate to. */
+    reloadUrl: string;
+}
+interface ResponseRoutePlan<TEnv = any> {
+    mode: "response";
+    route: RouteSnapshot<TEnv>;
+    handler: Function;
+    responseType: string;
+    negotiated: boolean;
+    manifestEntry: EntryData;
+    routeMiddleware: CollectedMiddleware[];
+}
+interface LoaderFetchPlan<TEnv = any> {
+    mode: "loader";
+    route: RouteSnapshot<TEnv>;
+}
+interface PeRenderPlan<TEnv = any> {
+    mode: "pe-render";
+    route: RouteSnapshot<TEnv>;
+}
+interface ActionPlan<TEnv = any> {
+    mode: "action";
+    route: RouteSnapshot<TEnv>;
+    actionId: string;
+    negotiated: boolean;
+}
+interface FullRenderPlan<TEnv = any> {
+    mode: "full-render";
+    route: RouteSnapshot<TEnv>;
+    negotiated: boolean;
+}
+interface PartialRenderPlan<TEnv = any> {
+    mode: "partial-render";
+    route: RouteSnapshot<TEnv>;
+    negotiated: boolean;
+}
+/**
+ * The output of request classification. A discriminated union where each
+ * variant carries exactly the fields needed for its execution path.
+ */
+export type RequestPlan<TEnv = any> = RedirectPlan<TEnv> | VersionMismatchPlan<TEnv> | AppSwitchReloadPlan | ResponseRoutePlan<TEnv> | LoaderFetchPlan<TEnv> | PeRenderPlan<TEnv> | ActionPlan<TEnv> | FullRenderPlan<TEnv> | PartialRenderPlan<TEnv>;
+/**
+ * Plans that have passed the terminal-check gate (version-mismatch and
+ * app-switch reloads handled) and are ready for execution. Always have a
+ * `route` field.
+ */
+export type ExecutableRequestPlan<TEnv = any> = Exclude<RequestPlan<TEnv>, VersionMismatchPlan<TEnv> | AppSwitchReloadPlan>;
+/**
+ * Re-export individual plan types for consumers that need to narrow.
+ */
+export type { RedirectPlan, VersionMismatchPlan, ResponseRoutePlan, LoaderFetchPlan, PeRenderPlan, ActionPlan, FullRenderPlan, PartialRenderPlan, };
+export interface ClassifyRequestDeps<TEnv = any> {
+    findMatch: (pathname: string) => RouteMatchResult<TEnv> | null | Promise<RouteMatchResult<TEnv> | null>;
+    routerVersion: string;
+    routerId: string;
+}
+/**
+ * Classify an incoming request into a RequestPlan.
+ *
+ * This is the single source of truth for request mode detection. It replaces
+ * the scattered previewMatch + isAction/isLoaderFetch/isPartial checks in
+ * handler.ts.
+ *
+ * Classification order:
+ * 1. Route resolution (findMatch + loadManifest via resolveRoute lite)
+ * 2. Redirect detection
+ * 3. Version mismatch
+ * 4. Response route + content negotiation
+ * 5. Mode detection from headers/params
+ */
+export declare function classifyRequest<TEnv = any>(request: Request, url: URL, deps: ClassifyRequestDeps<TEnv>): Promise<RequestPlan<TEnv>>;

package/dist/types/router/revalidation.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Router Revalidation Logic
+ *
+ * Evaluates whether segments should revalidate based on params, actions, and custom functions.
+ */
+import type { ResolvedSegment, HandlerContext } from "../types";
+import type { ActionContext } from "./types";
+import type { RevalidationTraceEntry } from "./logging.js";
+/**
+ * Options for revalidation evaluation
+ */
+interface EvaluateRevalidationOptions<TEnv> {
+    /** Current segment to evaluate */
+    segment: ResolvedSegment;
+    /** Previous route params (from route match, not segment) */
+    prevParams: Record<string, string>;
+    /** Lazy function to get previous segment if needed */
+    getPrevSegment: (() => Promise<ResolvedSegment | undefined>) | null;
+    /** Current request */
+    request: Request;
+    /** Previous URL */
+    prevUrl: URL;
+    /** Next URL */
+    nextUrl: URL;
+    /** Custom revalidation functions */
+    revalidations: Array<{
+        name: string;
+        fn: any;
+    }>;
+    /** Current route key */
+    routeKey: string;
+    /** Handler context */
+    context: HandlerContext<any, TEnv>;
+    /** Action context if triggered by action */
+    actionContext?: ActionContext;
+    /** If true, this is a stale cache revalidation request */
+    stale?: boolean;
+    /** Trace source hint for the revalidation trace */
+    traceSource?: RevalidationTraceEntry["source"];
+    /**
+     * Override the segment-type-derived default. When set, the value is used as
+     * the seed `defaultShouldRevalidate` passed to user revalidate fns and the
+     * reason flows into the trace. Callers use this when client-knowledge
+     * (e.g. parallel slot not in clientSegmentIds) should dictate the seed
+     * instead of the params/method-based heuristic.
+     *
+     * `floor` makes a `true` seed a guarantee rather than a suggestion: user fns
+     * may raise the decision but never lower it. Set it when the segment has no
+     * client-side content to fall back on, so a `false` would render nothing
+     * instead of keeping a cached copy — see the parallel-slot call site in
+     * segment-resolution/revalidation.ts.
+     */
+    defaultOverride?: {
+        value: boolean;
+        reason: string;
+        floor?: boolean;
+    };
+}
+/**
+ * Evaluate if a segment should revalidate using soft/hard decision pattern
+ * Optimized to use prevParams directly and avoid building previous segments
+ */
+export declare function evaluateRevalidation<TEnv>(options: EvaluateRevalidationOptions<TEnv>): Promise<boolean>;
+export {};

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

@@ -0,0 +1,112 @@
+/**
+ * Route Snapshot
+ *
+ * Pure data type representing the fully-resolved state of a single route match.
+ * Consolidates the duplicated findMatch + loadManifest + collectRouteMiddleware +
+ * cacheScope derivation that previously lived separately in preview-match.ts
+ * and match-api.ts.
+ *
+ * resolveRoute() is the factory: given a pathname and dependencies, it returns
+ * a RouteSnapshot (or redirect/null). Consumers (createMatchContextForFull,
+ * createMatchContextForPartial, previewMatch) read snapshot fields instead of
+ * re-deriving them.
+ */
+import type { CacheScope } from "../cache/cache-scope.js";
+import type { EntryData, MetricsStore } from "../server/context.js";
+import type { CollectedMiddleware } from "./middleware-types.js";
+import type { RouteMatchResult } from "./pattern-matching.js";
+/**
+ * Immutable snapshot of a resolved route match.
+ *
+ * Contains everything derivable from (pathname, findMatch, loadManifest)
+ * without request context, navigation state, or intercept logic.
+ */
+export interface RouteSnapshot<TEnv = any> {
+    /** Raw match result from the trie/pattern matcher */
+    matched: RouteMatchResult<TEnv>;
+    /** Resolved manifest entry (with loaded handler, loader, etc.) */
+    manifestEntry: EntryData;
+    /** All entries in the route chain (from traverseBack) */
+    entries: EntryData[];
+    /** Canonical route key (e.g. "blog.detail") */
+    routeKey: string;
+    /** Last segment of a dotted route key (e.g. "detail" from "blog.detail") */
+    localRouteName: string;
+    /** Extracted route params */
+    params: Record<string, string>;
+    /** Collected route-level middleware from the entry tree */
+    routeMiddleware: CollectedMiddleware[];
+    /** Merged cache scope from the entry chain */
+    cacheScope: CacheScope | null;
+    /** Whether the matched route is a passthrough route */
+    isPassthrough: boolean;
+    /** Response type for non-RSC routes (e.g. "application/json") */
+    responseType?: string;
+    /**
+     * The isSSR flag the manifest was resolved with. Recorded so consumers can
+     * decide whether the snapshot is reusable: a snapshot resolved with isSSR
+     * differs (loading({ ssr: false }) entries) and is cached under a different
+     * manifest partition, so the full (document) path only reuses an isSSR:true
+     * snapshot and the partial path only reuses a non-isSSR one. Undefined on
+     * inline snapshots (redirect / not-found) that are never reused.
+     */
+    isSSR?: boolean;
+}
+export type ResolveRouteResult<TEnv = any> = {
+    type: "match";
+    snapshot: RouteSnapshot<TEnv>;
+} | {
+    type: "redirect";
+    redirectTo: string;
+} | null;
+export interface ResolveRouteDeps<TEnv = any> {
+    findMatch: (pathname: string) => RouteMatchResult<TEnv> | null | Promise<RouteMatchResult<TEnv> | null>;
+    metricsStore?: MetricsStore;
+    isSSR?: boolean;
+    /**
+     * When true, skip entries array and cacheScope chain construction.
+     * Used by previewMatch which only needs matched, manifestEntry,
+     * routeMiddleware, and responseType — avoids an extra traverseBack
+     * allocation and cacheScope composition on the hot classification path.
+     */
+    lite?: boolean;
+    /**
+     * When true, skip pushing the "route-matching" metric internally.
+     * Used by createMatchContextForPartial on the fresh path (no snapshot
+     * reuse) so it can measure current + prev + intercept-source findMatch
+     * calls under one combined "route-matching" metric. On the reuse path,
+     * the partial path emits "route-matching:nav" for the prev +
+     * intercept-source lookups only (current-route resolution was done
+     * during classification without metrics).
+     */
+    skipRouteMatchMetric?: boolean;
+}
+/**
+ * Resolve a pathname into a RouteSnapshot.
+ *
+ * This is the single source of truth for route derivation. It performs:
+ * 1. findMatch(pathname)
+ * 2. Redirect check
+ * 3. loadManifest
+ * 4. Passthrough detection
+ * 5. collectRouteMiddleware
+ * 6. Cache scope chain
+ * 7. responseType + localRouteName extraction
+ *
+ * Metrics timing is preserved identically to the previous inline code.
+ */
+export declare function resolveRoute<TEnv = any>(pathname: string, deps: ResolveRouteDeps<TEnv>): Promise<ResolveRouteResult<TEnv>>;
+/**
+ * Fill in the entries and cacheScope fields on a lite snapshot.
+ *
+ * When classifyRequest produces a lite snapshot (entries=[], cacheScope=null),
+ * this function computes the missing fields from manifestEntry without
+ * re-running findMatch, loadManifest, or collectRouteMiddleware.
+ *
+ * If the snapshot already has entries, returns it as-is.
+ */
+export declare function ensureFullRouteSnapshot<TEnv = any>(snapshot: RouteSnapshot<TEnv>): RouteSnapshot<TEnv>;
+/**
+ * Test helper: create a RouteSnapshot with sensible defaults and overrides.
+ */
+export declare function createRouteSnapshot<TEnv = any>(overrides?: Partial<RouteSnapshot<TEnv>>): RouteSnapshot<TEnv>;

package/dist/types/router/route-trie-builder.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Runtime Route Trie Construction
+ *
+ * Builds a serializable trie from route manifest data for O(path_length)
+ * route matching at runtime.
+ */
+/**
+ * A response-type variant folded into a primary leaf's negotiate list. `pa` is
+ * the variant's own positional param-name array, carried so the runtime can
+ * re-key the matched params under the variant's names when it wins negotiation
+ * (the trie match extracts params under the PRIMARY leaf's pa). Omitted when the
+ * variant has no params; absent/identical pa means no re-key is needed.
+ */
+export interface NegotiateVariant {
+    routeKey: string;
+    responseType: string;
+    pa?: string[];
+}
+export interface TrieLeaf {
+    /** Route name (e.g., "site.l1_500") */
+    n: string;
+    /** Static prefix of the entry (e.g., "/site") */
+    sp: string;
+    /** Constraint validation: paramName -> allowed values */
+    cv?: Record<string, string[]>;
+    /** Ordered param names for this route (positional) */
+    pa?: string[];
+    /** Trailing slash mode */
+    ts?: string;
+    /** Route has pre-rendered data available */
+    pr?: true;
+    /** Passthrough: handler kept in bundle for live fallback on unknown params */
+    pt?: true;
+    /** Response type for non-RSC routes (json, text, image, any) */
+    rt?: string;
+    /** Negotiate variants: response-type routes sharing this path */
+    nv?: NegotiateVariant[];
+    /** RSC-first: RSC route was defined before response-type variants */
+    rf?: true;
+}
+export interface TrieNode {
+    /** Route terminal at this node */
+    r?: TrieLeaf;
+    /** Static segment children */
+    s?: Record<string, TrieNode>;
+    /** Param child: { n: paramName, c: child node } */
+    p?: {
+        n: string;
+        c: TrieNode;
+    };
+    /** Suffix-param children keyed by suffix (e.g., ".html" -> { n: "productId", c: ... }) */
+    xp?: Record<string, {
+        n: string;
+        c: TrieNode;
+    }>;
+    /**
+     * Wildcard terminal: leaf + paramName (`pn`). `pn` is "*" for the bare `/*`
+     * form and the param name for a named catch-all (`:name+`/`:name*`). `w1`
+     * marks a one-or-more catch-all (`:name+`): the runtime walker then rejects
+     * the zero-segment/empty-remainder case. Absent `w1` is zero-or-more.
+     */
+    w?: TrieLeaf & {
+        pn: string;
+        w1?: true;
+    };
+}
+/**
+ * Build a route trie from route manifest data.
+ *
+ * @param routeManifest - Map of route name to full URL pattern
+ * @param routeToStaticPrefix - Map of route name to its entry's staticPrefix
+ * @param routeTrailingSlash - Optional map of route name to trailing slash mode
+ * @param prerenderRouteNames - Optional set of prerendered route names (sets leaf.pr)
+ * @param passthroughRouteNames - Optional set of passthrough route names (sets leaf.pt)
+ * @param responseTypeRoutes - Optional map of route name to response type (sets leaf.rt)
+ */
+export declare function buildRouteTrie(routeManifest: Record<string, string>, routeToStaticPrefix: Record<string, string>, routeTrailingSlash?: Record<string, string>, prerenderRouteNames?: Set<string>, passthroughRouteNames?: Set<string>, responseTypeRoutes?: Record<string, string>): TrieNode;

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

@@ -0,0 +1,137 @@
+import type { CacheScope } from "../cache/cache-scope.js";
+import type { EntryData, InterceptEntry, InterceptSelectorContext, MetricsStore } from "../server/context.js";
+import type { HandlerContext, ResolvedSegment, ShouldRevalidateFn } from "../types.js";
+import type { RouteMatchResult } from "./pattern-matching.js";
+import type { TelemetrySink } from "./telemetry.js";
+import type { ResolveSegmentOptions } from "./segment-resolution.js";
+/**
+ * Revalidation context passed to segment resolution
+ */
+export interface RevalidationContext {
+    clientSegmentIds: Set<string>;
+    prevParams: Record<string, string>;
+    request: Request;
+    prevUrl: URL;
+    nextUrl: URL;
+    routeKey: string;
+    actionContext?: {
+        actionId?: string;
+        actionUrl?: URL;
+        actionResult?: any;
+        formData?: FormData;
+    };
+    stale: boolean;
+}
+/**
+ * Result from intercept lookup
+ */
+export interface InterceptResult {
+    intercept: InterceptEntry;
+    entry: EntryData;
+}
+/**
+ * Router context available via AsyncLocalStorage
+ *
+ * Contains closure functions from createRouter() that middleware needs access to.
+ * Instead of passing 20+ parameters, middleware calls getRouterContext() to access them.
+ */
+export interface RouterContext<TEnv = any> {
+    findMatch: (pathname: string) => RouteMatchResult | null | Promise<RouteMatchResult | null>;
+    loadManifest: (entry: any, routeKey: string, pathname: string, metricsStore?: MetricsStore, isSSR?: boolean) => Promise<EntryData>;
+    traverseBack: (entry: EntryData) => Generator<EntryData>;
+    createHandlerContext: (params: Record<string, string>, request: Request, searchParams: URLSearchParams, pathname: string, url: URL, bindings?: any, routeMap?: Record<string, string>, routeName?: string, responseType?: string, isPassthroughRoute?: boolean) => HandlerContext<any, TEnv>;
+    setupLoaderAccess: (ctx: HandlerContext<any, TEnv>, loaderPromises: Map<string, Promise<any>>) => void;
+    setupLoaderAccessSilent: (ctx: HandlerContext<any, TEnv>, loaderPromises: Map<string, Promise<any>>) => void;
+    getContext: () => {
+        getOrCreateStore: (key: string) => any;
+        runWithStore: <T>(store: any, namespace: string, parent: any, fn: () => T) => T;
+    };
+    getMetricsStore: () => MetricsStore | undefined;
+    createCacheScope: (cacheConfig: any, parent: CacheScope | null) => CacheScope | null;
+    findInterceptForRoute: (routeKey: string, parentEntry: EntryData | null, selectorContext: InterceptSelectorContext, isAction: boolean) => InterceptResult | null;
+    resolveAllSegmentsWithRevalidation: (entries: EntryData[], routeKey: string, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, clientSegmentSet: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, actionContext: any | undefined, interceptResult: InterceptResult | null, localRouteName: string, pathname: string, stale?: boolean) => Promise<{
+        segments: ResolvedSegment[];
+        matchedIds: string[];
+    }>;
+    resolveAllSegmentsWithRevalidationGenerator?: (entries: EntryData[], routeKey: string, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, clientSegmentSet: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, loaderPromises: Map<string, Promise<any>>, actionContext?: any) => AsyncGenerator<ResolvedSegment | {
+        __type: "id";
+        id: string;
+    }>;
+    resolveInterceptEntry: (intercept: InterceptEntry, entry: EntryData, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, belongsToRoute: boolean, revalidationContext?: RevalidationContext, options?: {
+        skipMiddleware?: boolean;
+    }) => Promise<ResolvedSegment[]>;
+    collectWithMarkers?: <T>(gen: AsyncGenerator<T | {
+        __type: "id";
+        id: string;
+    }>) => Promise<{
+        items: T[];
+        matchedIds: string[];
+    }>;
+    evaluateRevalidation: (params: {
+        segment: ResolvedSegment;
+        prevParams: Record<string, string>;
+        getPrevSegment: (() => Promise<ResolvedSegment | undefined>) | null;
+        request: Request;
+        prevUrl: URL;
+        nextUrl: URL;
+        revalidations: Array<{
+            name: string;
+            fn: any;
+        }>;
+        routeKey: string;
+        context: HandlerContext<any, TEnv>;
+        actionContext?: any;
+        stale?: boolean;
+        traceSource?: "segment-resolution" | "cache-hit" | "loader" | "parallel" | "orphan-layout" | "route-handler" | "layout-handler" | "intercept-loader";
+    }) => Promise<boolean>;
+    getRequestContext: () => {
+        waitUntil: (fn: () => Promise<void>) => void;
+        _handleStore?: any;
+    } | undefined;
+    resolveAllSegments: (entries: EntryData[], routeKey: string, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, loaderPromises: Map<string, Promise<any>>, options?: ResolveSegmentOptions) => Promise<ResolvedSegment[]>;
+    resolveAllSegmentsGenerator?: (entries: EntryData[], routeKey: string, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, loaderPromises: Map<string, Promise<any>>) => AsyncGenerator<ResolvedSegment | {
+        __type: "id";
+        id: string;
+    }>;
+    collectSegmentsFromGenerator?: <T>(gen: AsyncGenerator<T | {
+        __type: "id";
+        id: string;
+    }>) => Promise<T[]>;
+    createHandleStore: () => any;
+    resolveLoadersOnly?: (entries: EntryData[], handlerContext: HandlerContext<any, TEnv>) => Promise<ResolvedSegment[]>;
+    resolveLoadersOnlyWithRevalidation?: (entries: EntryData[], handlerContext: HandlerContext<any, TEnv>, clientSegmentSet: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, routeKey: string, actionContext?: any, stale?: boolean) => Promise<{
+        segments: ResolvedSegment[];
+        matchedIds: string[];
+    }>;
+    buildEntryRevalidateMap?: (entries: EntryData[]) => Map<string, {
+        revalidate: ShouldRevalidateFn[];
+    }>;
+    telemetry?: TelemetrySink;
+    requestId?: string;
+    resolveInterceptLoadersOnly?: (intercept: InterceptEntry, entry: EntryData, params: Record<string, string>, handlerContext: HandlerContext<any, TEnv>, belongsToRoute: boolean, revalidationContext: {
+        clientSegmentIds: Set<string>;
+        prevParams: Record<string, string>;
+        request: Request;
+        prevUrl: URL;
+        nextUrl: URL;
+        routeKey: string;
+        actionContext?: any;
+        stale?: boolean;
+    }) => Promise<{
+        loaderDataPromise: Promise<any[]> | any[];
+        loaderIds: string[];
+    } | null>;
+}
+/**
+ * Get router dependencies from AsyncLocalStorage context
+ *
+ * @throws Error if called outside of router context (runWithRouterContext)
+ */
+export declare function getRouterContext<TEnv = any>(): RouterContext<TEnv>;
+/**
+ * Run a function with router dependencies available via getRouterContext()
+ *
+ * All async code within fn() can call getRouterContext() to access router closures.
+ * This works across async boundaries thanks to AsyncLocalStorage.
+ */
+export declare function runWithRouterContext<T, TEnv = any>(deps: RouterContext<TEnv>, fn: () => T): T;