@rangojs/router 0.4.0 → 0.4.2

package/src/rsc/types.ts

@@ -210,6 +210,23 @@ export interface HandlerCacheConfig {
   store: import("../cache/types.js").SegmentCacheStore;
   /** Enable/disable caching (default: true) */
   enabled?: boolean;
+  /**
+   * Which query params key the cache (default: `"all"`). Affects cache keys
+   * ONLY -- handlers and loaders still see the full query string. Global by
+   * design: the per-route case is already reachable through `cache({ key })`.
+   *
+   * Excluding a param is a promise that rendered output does not depend on
+   * it; if it does, the first variant is cached and served to everyone.
+   *
+   * @example
+   * ```typescript
+   * cache: {
+   *   store: cacheStore,
+   *   searchParams: { exclude: TRACKING_SEARCH_PARAMS },
+   * }
+   * ```
+   */
+  searchParams?: import("../cache/search-params-filter.js").CacheSearchParams;
 }
 
 /**

package/src/segment-fragments.ts

@@ -6,10 +6,11 @@
  * fragment STRINGS ride the outgoing payload verbatim inside these envelopes
  * — the outer Flight render copies a string instead of re-serializing a whole
  * element tree — and the CONSUMER expands each envelope through its own Flight
- * deserializer: the SSR resume pass (ssr/ssr-root.tsx) and browser hydration
- * (browser/rsc-router.tsx). Each fragment is its own row space, decoded
- * independently, exactly like the segment codec's per-record decode — so
- * there is no Flight row-id collision or shared-row dedupe hazard.
+ * deserializer: the SSR resume pass (ssr/ssr-root.tsx), browser hydration, and
+ * capability-gated partial navigation/prefetch decoders. Each fragment is its
+ * own row space, decoded independently, exactly like the segment codec's
+ * per-record decode — so there is no Flight row-id collision or shared-row
+ * dedupe hazard.
  *
  * Envelopes appear ONLY on fields that hold ReactNodes (component / layout /
  * loading). A plain object is never a valid ReactNode, so the marker cannot
@@ -22,6 +23,25 @@
 
 import type { ResolvedSegment } from "./types.js";
 
+/** Partial-request capability gate for browser-side fragment expansion. */
+export const SEGMENT_FRAGMENT_CAPABILITY_HEADER: string =
+  "X-Rango-Fragment-Passthrough";
+
+/** One-shot request marker that forces server-side fragment validation. */
+export const SEGMENT_FRAGMENT_RECOVERY_HEADER: string =
+  "X-Rango-Fragment-Recovery";
+
+/** A stored fragment failed in its consumer-side Flight decoder. */
+export class SegmentFragmentDecodeError extends Error {
+  readonly cause: unknown;
+
+  constructor(cause: unknown) {
+    super("Failed to decode a stored RSC segment fragment");
+    this.name = "SegmentFragmentDecodeError";
+    this.cause = cause;
+  }
+}
+
 /**
  * One RSC-encoded fragment traveling inside an RscPayload segment field.
  * `f` is the stored Flight document (segment-codec output) for that field.
@@ -107,6 +127,27 @@ export async function expandSegmentFragments(
   if (decodes.length > 0) await Promise.all(decodes);
 }
 
+/**
+ * Expand every envelope in an RscPayload-shaped object, in place. Decode
+ * failures use a distinct error so partial navigation can retry once through
+ * the server's decode-and-evict path. The
+ * hasSegmentFragments pre-scan keeps envelope-free payloads — every
+ * non-replay response — to one synchronous field walk; this runs on every
+ * navigation and prefetch decode.
+ */
+export async function expandPayloadFragments(
+  payload: { metadata?: { segments?: ResolvedSegment[] } },
+  decode: FragmentDecoder,
+): Promise<void> {
+  const segments = payload.metadata?.segments;
+  if (!hasSegmentFragments(segments)) return;
+  try {
+    await expandSegmentFragments(segments, decode);
+  } catch (error) {
+    throw new SegmentFragmentDecodeError(error);
+  }
+}
+
 /**
  * True when any segment carries an unexpanded envelope. Cheap scan used by
  * consumers that only need to know whether an expansion pass is required.

package/src/server/request-context.ts

@@ -211,9 +211,27 @@ export interface RequestContext<
   /** @internal PPR transition decisions evaluated before cache lookup/handlers. */
   _pprTransitionDecisions?: Map<string, boolean>;
 
+  /**
+   * @internal Post-match serve-source truth for the PPR replay reporter.
+   * Stamped from the match context as `intercept`, then overwritten as
+   * `prerender-store` if that lookup actually serves. The latter wins because
+   * it identifies the response source. matchPartialWithPprReplay reads this
+   * AFTER matching to reclassify its pre-match guess and suppress pointless
+   * heal captures.
+   */
+  _pprReplayPostMatchReason?: "prerender-store" | "intercept";
+
   /** @internal Cache store for segment caching (optional, used by CacheScope) */
   _cacheStore?: SegmentCacheStore;
 
+  /**
+   * @internal Compiled `cache.searchParams` filter for default cache-key
+   * generation (undefined = "all", the byte-stable unfiltered format). Set
+   * once per request by handler.ts; every URL-keyed tier (segment, document,
+   * response, shell, "use cache") reads it so the tiers cannot drift.
+   */
+  _searchParamsFilter?: import("../cache/search-params-filter.js").SearchParamsFilter;
+
   /**
    * @internal PPR shell-capture ACTIVE marker. True ONLY inside the background
    * capture task's derived request context (built by shell-capture.ts). This is
@@ -265,9 +283,13 @@ export interface RequestContext<
    * (b) a HIT tail's seeded context, and (c) an eligible normal-route partial
    * replay, where `store` is a request-local segment overlay. Handler-live holes
    * and conditional transitions decline replay.
-   * Routes with their own cache() config (including cache(false)) are never
-   * overridden: the marker only applies when the route tree derived NO cache
-   * scope.
+   * Routes with their own cache() config are never overridden — their scope's
+   * store/key/ttl/swr/condition semantics stay authoritative. On the
+   * navigation-replay serve path (`onExplicitHit` set) the marker COMPOSES with
+   * such a scope instead of being ignored: the seeded doc record supplies the match
+   * only when the explicit tier misses (withCacheLookup). cache(false) and a
+   * false condition() stay absolute opt-outs — replay bypasses before any
+   * shell read (`cache-disabled`).
    */
   _shellImplicitCache?: {
     ttl?: number;
@@ -281,18 +303,59 @@ export interface RequestContext<
     keyPrefix?: "doc";
     /** @internal Called only after the implicit cache hit decodes successfully. */
     onHit?: () => void;
+    /**
+     * @internal Called when the seeded document record fails server-side
+     * deserialization. Partial replay uses it to replace the enclosing shell
+     * snapshot after serving the fresh fallback.
+     */
+    onCorrupt?: () => void;
+    /**
+     * @internal The resolved key of the canonical document segment record.
+     * Written during a CAPTURE render by CacheScope.cacheRoute when a
+     * doc-namespaced scope records the matched segments; captureAndStoreShell
+     * stamps it onto the ShellCacheEntry (`docKey`) so replay eligibility can
+     * require the exact consumable record instead of "any segment record".
+     */
+    docKey?: string;
+    /**
+     * @internal Set ONLY by matchPartialWithPprReplay on the navigation-replay
+     * serve path. Its presence arms the explicit-scope composition in
+     * withCacheLookup: a route-derived cache() scope stays authoritative, and
+     * only when its lookup MISSes does the seeded doc record supply the match.
+     * A capture render must never set this (its match must re-run handlers so
+     * SWR recapture stays fresh), which is why the fallback keys off this
+     * field and not off the marker itself. Fired when the route-derived
+     * scope's own lookup supplied the match — the header then reports
+     * `BYPASS; reason=explicit-cache-hit`, never a false replay HIT.
+     */
+    onExplicitHit?: () => void;
+    /**
+     * @internal Companion to onExplicitHit, same lifecycle: fired when the
+     * route-derived scope's lookup REFUSED the read (`bypass` outcome — a
+     * false condition() or no store). The gate only pre-decides the static
+     * cache(false) case; a predicate refusal is known only at lookup time and
+     * reports `BYPASS; reason=cache-disabled` post-match.
+     */
+    onExplicitBypass?: () => void;
   };
 
   /**
-   * @internal Shell-HIT tail marker: cache/prerender-store hits during THIS
-   * render emit stored segment fragments VERBATIM into the payload
+   * @internal Fragment-passthrough marker: cache/prerender-store hits during
+   * THIS render emit stored segment fragments VERBATIM into the payload
    * (segment-codec fragmentSegments) instead of deserialize -> re-serialize
-   * per request; the payload consumers (SSR resume + browser hydration)
-   * expand them (segment-fragments.ts, issue #700). Own property of
-   * serveShellHit's derived tail context ONLY — it must never be visible to a
-   * capture render: the capture SSR-prerenders the payload AND serializes
-   * segments into records (cacheRoute), and an envelope reaching
-   * serializeSegments would store a double-encoded fragment.
+   * per request; the payload consumers (SSR resume, browser hydration, and
+   * the client partial-navigation decode chokepoints) expand them
+   * (segment-fragments.ts, issue #700). Partial requests arm only after the
+   * browser advertises `X-Rango-Fragment-Passthrough: 1`; a decode failure
+   * retries without it so CacheScope can evict the bad record. Two arming sites,
+   * both scoped to a
+   * render/match window: serveShellHit's derived tail context (document
+   * HIT), and matchPartialWithPprReplay's mutate-restore around the partial
+   * match (matchPartialForReplay). It must never be visible to a capture
+   * render: the capture SSR-prerenders the payload AND serializes segments
+   * into records (cacheRoute), and an envelope reaching serializeSegments
+   * would store a double-encoded fragment — deriveShellCaptureContext resets
+   * it as an own property for exactly that reason.
    */
   _shellFragmentPayload?: boolean;
 
@@ -656,7 +719,9 @@ export type PublicRequestContext<
   | "_handleStore"
   | "_transitionWhen"
   | "_pprTransitionDecisions"
+  | "_pprReplayPostMatchReason"
   | "_cacheStore"
+  | "_searchParamsFilter"
   | "_shellCaptureRun"
   | "_shellImplicitCache"
   | "_shellLoaderSeed"
@@ -842,6 +907,11 @@ export interface CreateRequestContextOptions<TEnv> {
   initialResponse?: Response;
   /** Optional cache store for segment caching (used by CacheScope) */
   cacheStore?: SegmentCacheStore;
+  /**
+   * Compiled `cache.searchParams` filter from the resolved handler cache
+   * config (handler.ts). Stored as _searchParamsFilter.
+   */
+  searchParamsFilter?: import("../cache/search-params-filter.js").SearchParamsFilter;
   /**
    * Handler-owned registry of explicit per-scope stores for cross-store tag
    * invalidation. Created once per handler, reused across requests.
@@ -882,6 +952,7 @@ export function createRequestContext<TEnv>(
     variables,
     initialResponse,
     cacheStore,
+    searchParamsFilter,
     explicitTaggedStores,
     cacheProfiles,
     executionContext,
@@ -1176,6 +1247,7 @@ export function createRequestContext<TEnv>(
     _handleStore: handleStore,
     _transitionWhen: [],
     _cacheStore: cacheStore,
+    _searchParamsFilter: searchParamsFilter,
     _explicitTaggedStores: explicitTaggedStores,
     _requestTags: new Set<string>(),
     _cacheProfiles: cacheProfiles,

package/src/testing/dispatch.ts

@@ -116,6 +116,11 @@ import {
   stripInternalParams,
 } from "../router/handler-context.js";
 import { NOCACHE_SYMBOL } from "../cache/taint.js";
+import {
+  compileSearchParamsFilter,
+  type CacheSearchParams,
+  type SearchParamsFilter,
+} from "../cache/search-params-filter.js";
 import type { SegmentCacheStore } from "../cache/types.js";
 import type { CacheProfile } from "../cache/profile-registry.js";
 // cache-scope is loaded LAZILY inside the response-route cache path (below):
@@ -193,11 +198,19 @@ interface DispatchableRouter<TEnv> {
   } | null>;
   basename?: string;
   cache?:
-    | { enabled?: boolean; store?: SegmentCacheStore }
+    | {
+        enabled?: boolean;
+        store?: SegmentCacheStore;
+        searchParams?: CacheSearchParams;
+      }
     | ((
         env: TEnv,
         executionContext: unknown,
-      ) => { enabled?: boolean; store?: SegmentCacheStore });
+      ) => {
+        enabled?: boolean;
+        store?: SegmentCacheStore;
+        searchParams?: CacheSearchParams;
+      });
   cacheProfiles?: Record<string, CacheProfile>;
 }
 
@@ -375,13 +388,17 @@ export async function dispatch<TEnv = any>(
   // "use cache" inside a response-route handler reaches the request-scope
   // (NOCACHE) detection below instead of bypassing on a missing store.
   let cacheStore: SegmentCacheStore | undefined;
+  let searchParamsFilter: SearchParamsFilter | undefined;
   const cacheOption = router.cache;
   if (cacheOption && !url.searchParams.has("__no_cache")) {
     const cacheConfig =
       typeof cacheOption === "function"
         ? cacheOption(env, undefined)
         : cacheOption;
-    if (cacheConfig.enabled !== false) cacheStore = cacheConfig.store;
+    if (cacheConfig.enabled !== false) {
+      cacheStore = cacheConfig.store;
+      searchParamsFilter = compileSearchParamsFilter(cacheConfig.searchParams);
+    }
   }
 
   const requestContext = createRequestContext<TEnv>({
@@ -390,6 +407,7 @@ export async function dispatch<TEnv = any>(
     url,
     variables,
     cacheStore,
+    searchParamsFilter,
     cacheProfiles: router.cacheProfiles,
   });
   // Wire background error reporting so cache degradation (reportCacheError ->

package/src/testing/render-route.tsx

@@ -38,7 +38,7 @@
  * (the segment chain is wrapped in a MountContext exactly as in production).
  */
 
-import type { ReactNode, ComponentType } from "react";
+import { useEffect, type ReactNode, type ComponentType } from "react";
 import type { RenderResult } from "@testing-library/react";
 import { renderSegments } from "../segment-system.js";
 import {
@@ -62,8 +62,14 @@ import type { Handle } from "../handle.js";
 import type { ThemeConfig } from "../theme/types.js";
 import { resolveThemeConfig } from "../theme/constants.js";
 import { isUnderTestRunner } from "../runtime-env.js";
+import { setupNavigationBridgeDelegatedPrefetch } from "../browser/navigation-bridge.js";
+import { resetAdaptiveStrategyForTesting } from "../browser/prefetch/default-strategy.js";
+import { resetPrefetchObserverForTesting } from "../browser/prefetch/observer.js";
+import type { PrefetchStrategy } from "../router/prefetch-default.js";
 
 const TEST_ORIGIN = "http://localhost";
+let activePrefetchRegistrations = 0;
+let pendingPrefetchReset: object | undefined;
 
 /**
  * Seed shape for `options.handle`, matching the handle wire format:
@@ -268,6 +274,14 @@ export interface RenderRouteOptions {
    * expect(getByTestId("nonce").textContent).toBe("test-nonce");
    */
   nonce?: string;
+  /**
+   * Router default prefetch strategy scoped to this rendered tree. This mirrors
+   * `createRouter({ defaultPrefetch })` for Links and eligible plain anchors
+   * inside `basename`. `data-prefetch="false"`/`"none"` opts out; `"true"`
+   * allows an application route with a common static-resource suffix but does
+   * not override a `"none"` default.
+   */
+  defaultPrefetch?: PrefetchStrategy;
 }
 
 /**
@@ -299,6 +313,41 @@ interface ResolvedMatch {
   pathname: string;
 }
 
+function DelegatedPrefetchRegistration({
+  bridge,
+}: {
+  bridge: NavigationBridge;
+}): null {
+  useEffect(() => {
+    const unregister = bridge.registerDelegatedPrefetch();
+    pendingPrefetchReset = undefined;
+    activePrefetchRegistrations++;
+    return () => {
+      try {
+        unregister();
+      } finally {
+        activePrefetchRegistrations--;
+        if (activePrefetchRegistrations === 0) {
+          const reset = {};
+          pendingPrefetchReset = reset;
+          queueMicrotask(() => {
+            if (
+              pendingPrefetchReset !== reset ||
+              activePrefetchRegistrations !== 0
+            ) {
+              return;
+            }
+            pendingPrefetchReset = undefined;
+            resetPrefetchObserverForTesting();
+            resetAdaptiveStrategyForTesting();
+          });
+        }
+      }
+    };
+  }, [bridge]);
+  return null;
+}
+
 function matchLeaf(
   pattern: string,
   pathname: string,
@@ -429,6 +478,7 @@ export async function renderRoute(
 
   const historyKey = generateHistoryKey(url.href);
   const mount = normalizeBasename(options.mount);
+  const basename = normalizeBasename(options.basename);
   // Fail loud on a request that cannot resolve the leaf route (a typo, or the
   // mount-prefixed-vs-relative confusion) instead of silently rendering empty
   // params (matchLeaf -> null -> {}). renderRoute paths are include-RELATIVE and
@@ -520,20 +570,31 @@ export async function renderRoute(
     });
   };
 
+  let prefetchRoot: HTMLElement | undefined;
   const bridge: NavigationBridge = {
     navigate: (target) => navigate(target),
     refresh: () => navigate(url.pathname + url.search),
     handlePopstate: async () => {},
     registerLinkInterception: () => () => {},
+    registerDelegatedPrefetch: () =>
+      setupNavigationBridgeDelegatedPrefetch(
+        store,
+        eventController,
+        () => undefined,
+        {
+          defaultPrefetch: options.defaultPrefetch,
+          root: prefetchRoot,
+          basename,
+        },
+      ),
     getVersion: () => undefined,
     updateVersion: () => {},
   };
 
-  const initialMetadata = makeMetadata(
-    url.pathname,
-    initialSegments,
-    initialMatch.params,
-  );
+  const initialMetadata = {
+    ...makeMetadata(url.pathname, initialSegments, initialMatch.params),
+    defaultPrefetch: options.defaultPrefetch,
+  };
   const initialTree = await renderSegments(initialSegments);
 
   // Wrap render in an awaited async act so a tree that suspends (async loaders,
@@ -542,19 +603,27 @@ export async function renderRoute(
   // suspended inside an act scope, but the act call was not awaited") and the
   // resolved content never reaches the asserted DOM.
   let result!: Awaited<ReturnType<typeof render>>;
+  const container = document.body.appendChild(document.createElement("div"));
+  prefetchRoot = container;
   await act(async () => {
     result = render(
-      <NavigationProvider
-        store={store}
-        eventController={eventController}
-        initialPayload={{ root: initialTree, metadata: initialMetadata }}
-        bridge={bridge}
-        basename={normalizeBasename(options.basename)}
-        themeConfig={
-          options.theme === undefined ? null : resolveThemeConfig(options.theme)
-        }
-        nonce={options.nonce}
-      />,
+      <>
+        <NavigationProvider
+          store={store}
+          eventController={eventController}
+          initialPayload={{ root: initialTree, metadata: initialMetadata }}
+          bridge={bridge}
+          basename={basename}
+          themeConfig={
+            options.theme === undefined
+              ? null
+              : resolveThemeConfig(options.theme)
+          }
+          nonce={options.nonce}
+        />
+        <DelegatedPrefetchRegistration bridge={bridge} />
+      </>,
+      { baseElement: document.body, container },
     );
   });
 

package/src/testing/shell-status.ts

@@ -29,6 +29,10 @@
  */
 
 import { sortedSearchString } from "../cache/cache-key-utils.js";
+import {
+  compileSearchParamsFilter,
+  type CacheSearchParams,
+} from "../cache/search-params-filter.js";
 
 /** Production header name (`rsc/shell-serve.ts` `SHELL_STATUS_HEADER`). */
 export const SHELL_STATUS_HEADER: string = "x-rango-shell";
@@ -45,6 +49,10 @@ const PPR_REPLAY_BYPASS_REASONS = [
   "nonce",
   "store-unavailable",
   "passive-read-unsupported",
+  "no-navigation-context",
+  "prerender-store",
+  "intercept",
+  "cache-disabled",
   "read-error",
   "no-entry",
   "invalid-version",
@@ -53,6 +61,7 @@ const PPR_REPLAY_BYPASS_REASONS = [
   "transition-when",
   "no-segment-snapshot",
   "snapshot-miss",
+  "explicit-cache-hit",
   "stale-build-entry",
 ] as const;
 
@@ -74,12 +83,20 @@ export type ShellStatusTarget = Response | { headers: Headers };
  * module (it pulls React). A parity test pins the two implementations.
  *
  * Accepts a `URL` or an absolute/relative request URL string (relative strings
- * resolve against `http://localhost`).
+ * resolve against `http://localhost`). Pass the router's `cache.searchParams`
+ * config as `searchParams` when the app under test sets one — the production
+ * key applies it, so the expected key must too.
  */
-export function shellCacheKey(url: URL | string): string {
+export function shellCacheKey(
+  url: URL | string,
+  searchParams?: CacheSearchParams,
+): string {
   const resolved =
     typeof url === "string" ? new URL(url, "http://localhost") : url;
-  const sorted = sortedSearchString(resolved.searchParams);
+  const sorted = sortedSearchString(
+    resolved.searchParams,
+    compileSearchParamsFilter(searchParams),
+  );
   const searchSuffix = sorted ? `?${sorted}` : "";
   return `${resolved.host}${resolved.pathname}${searchSuffix}:shell`;
 }

package/src/vite/plugin-types.ts

@@ -267,7 +267,7 @@ export interface RangoCloudflareOptions extends RangoBaseOptions {
  * `.vc-config.json` (and `config.json` for `functionName`).
  */
 export interface VercelPresetOptions {
-  /** Node runtime for the function. @default "nodejs22.x" */
+  /** Node runtime for the function. @default "nodejs24.x" */
   runtime?: string;
   /** Max execution time in seconds. @default 30 */
   maxDuration?: number;

package/src/vite/plugins/vercel-output.ts

@@ -99,7 +99,7 @@ export function assertVercelNodeRuntime(runtime: string | undefined): void {
     throw new Error(
       `[rango] preset "vercel": runtime "${runtime}" is not supported. ` +
         `This preset emits a Node serverless function; use a "nodejs*" runtime ` +
-        `(default "nodejs22.x"). The Edge runtime is not supported.`,
+        `(default "nodejs24.x"). The Edge runtime is not supported.`,
     );
   }
 }
@@ -125,7 +125,7 @@ export function buildVercelVcConfig(
   vercel: VercelPresetOptions,
 ): Record<string, unknown> {
   const vcConfig: Record<string, unknown> = {
-    runtime: vercel.runtime ?? "nodejs22.x",
+    runtime: vercel.runtime ?? "nodejs24.x",
     handler: "index.mjs",
     launcherType: "Nodejs",
     shouldAddHelpers: false,

package/dist/types.backup/__internal.d.ts

@@ -1,127 +0,0 @@
-/**
- * Internal Types - Implementation Details
- *
- * @internal
- * These types are for internal use only and should not be relied upon by consumers.
- * They may change without notice between versions.
- *
- * If you find yourself needing these types, please open an issue to discuss
- * adding them to the public API.
- */
-/**
- * @internal
- * Internal representation of a resolved route segment.
- * Used during route matching and rendering pipeline.
- */
-export type { ResolvedSegment, SegmentMetadata } from "./types.js";
-/**
- * @internal
- * Internal match result from route resolution.
- */
-export type { MatchResult, SlotState } from "./types.js";
-/**
- * @internal
- * Context for intercept route selection.
- */
-export type { InterceptSelectorContext, InterceptSegmentsState, InterceptWhenFn, } from "./server/context.js";
-/**
- * @internal
- * RSC protocol payload structure.
- */
-export type { RscPayload, ReactFormState } from "./rsc/types.js";
-/**
- * @internal
- * Internal navigation store interface.
- */
-export type { NavigationStore, NavigationBridge, RscMetadata, ActionResult, InflightAction, NavigationState, TrackedActionState, ActionStateListener, SegmentCache, SegmentState, NavigationUpdate, } from "./browser/types.js";
-/**
- * @internal
- * Internal handle storage mechanism.
- */
-export type { HandleStore, HandleData } from "./server/handle-store.js";
-/**
- * @internal
- * Segment handle data in cache.
- */
-export type { SegmentHandleData } from "./cache/types.js";
-/**
- * @internal
- * Internal cache entry data structure.
- */
-export type { CachedEntryData, CacheGetResult, SerializedSegmentData, CacheDefaults, } from "./cache/types.js";
-/**
- * @internal
- * Router context for AsyncLocalStorage.
- */
-export type { RouterContext, RevalidationContext, InterceptResult, } from "./router/router-context.js";
-/**
- * @internal
- * Route match context during pipeline processing.
- */
-export type { MatchContext, MatchPipelineState, } from "./router/match-context.js";
-/**
- * @internal
- * Pattern matching result.
- */
-export type { RouteMatchResult } from "./router/pattern-matching.js";
-/**
- * @internal
- * Entry data during route traversal.
- */
-export type { EntryData, InterceptEntry, MetricsStore, PerformanceMetric, EntryCacheConfig, EntryPropCommon, EntryPropDatas, LoaderEntry, EntryPropSegments, } from "./server/context.js";
-/**
- * @internal
- * Internal handler context with additional props for router internals.
- * Includes `_currentSegmentId` and `_responseType`.
- */
-export type { InternalHandlerContext } from "./types.js";
-/**
- * @internal
- * Builds React element trees from route segments.
- */
-export { renderSegments } from "./segment-system.js";
-/**
- * @internal
- * Error sanitization and network error utilities.
- */
-export { sanitizeError, NetworkError, isNetworkError } from "./errors.js";
-/**
- * @internal
- * Scoped view of GeneratedRouteMap for Handler<"localName", ScopedRouteMap<"prefix">>.
- */
-export type { ScopedRouteMap } from "./types.js";
-/**
- * @internal
- * Type-level utilities for reverse URL generation.
- */
-export type { MergeRoutes, SanitizePrefix } from "./reverse.js";
-/**
- * @internal
- * Individual telemetry event types.
- */
-export type { RequestStartEvent, RequestEndEvent, RequestErrorEvent, RequestTimeoutEvent, LoaderStartEvent, LoaderEndEvent, LoaderErrorEvent, HandlerErrorEvent, CacheDecisionEvent, RevalidationDecisionEvent, } from "./router/telemetry.js";
-/**
- * @internal
- * Type guard for prerender handler definitions.
- */
-export { isPrerenderHandler, isPassthroughHandler } from "./prerender.js";
-/**
- * @internal
- * Type guard for static handler definitions.
- */
-export { isStaticHandler } from "./static-handler.js";
-/**
- * @internal
- * Sentinel used to tag response-type route entries.
- */
-export { RESPONSE_TYPE } from "./urls.js";
-/**
- * @internal
- * Debug utilities for route matching performance analysis.
- */
-export { enableMatchDebug, getMatchDebugStats, } from "./router/pattern-matching.js";
-/**
- * @internal
- * Debug utilities for manifest inspection and comparison.
- */
-export { serializeManifest, compareManifests, formatManifestDiff, type SerializedEntry, type SerializedManifest, } from "./debug.js";

package/dist/types.backup/bin/rango.d.ts

@@ -1 +0,0 @@
-export {};