@rangojs/router 0.4.0 → 0.4.1

package/dist/types.backup/route-types.d.ts

@@ -1,172 +0,0 @@
-/**
- * Type definitions for route system items
- * These are extracted separately to avoid circular dependencies
- * and to prevent bundling server-only code in client bundles
- */
-/**
- * Brand for UrlPatterns nominal typing (see pattern-types.ts). The route-item
- * types below are discriminated by their `type` literal, so they carry no brand.
- */
-export declare const UrlPatternsBrand: unique symbol;
-export type LayoutItem = {
-    name: string;
-    type: "layout";
-    uses?: AllUseItems[];
-};
-/**
- * Phantom inference fields attached to wrapper items (layout/cache/transition)
- * so the urls() type extractor can read their child routes/responses. The fields
- * never exist at runtime.
- */
-type WithChildren<TBase, TChildRoutes extends Record<string, any> = Record<string, string>, TChildResponses extends Record<string, unknown> = Record<string, unknown>> = TBase & {
-    readonly __childRoutes?: TChildRoutes;
-    readonly __childResponses?: TChildResponses;
-};
-/**
- * Typed layout item that carries child routes as phantom type
- * Used for type inference in urls() API
- */
-export type TypedLayoutItem<TChildRoutes extends Record<string, any> = Record<string, string>, TChildResponses extends Record<string, unknown> = Record<string, unknown>> = WithChildren<LayoutItem, TChildRoutes, TChildResponses>;
-export type RouteItem = {
-    name: string;
-    type: "route";
-    uses?: AllUseItems[];
-};
-/**
- * Typed route item that carries route name and pattern as phantom types
- * Used for type inference in urls() API
- */
-export type TypedRouteItem<TName extends string = string, TPattern extends string = string, TData = unknown, TSearch = {}> = RouteItem & {
-    readonly __name?: TName;
-    readonly __pattern?: TPattern;
-    readonly __data?: TData;
-    readonly __search?: TSearch;
-};
-export type ParallelItem = {
-    name: string;
-    type: "parallel";
-    uses?: ParallelUseItem[];
-};
-export type InterceptItem = {
-    name: string;
-    type: "intercept";
-    uses?: InterceptUseItem[];
-};
-export type LoaderItem = {
-    name: string;
-    type: "loader";
-    uses?: LoaderUseItem[];
-};
-export type MiddlewareItem = {
-    name: string;
-    type: "middleware";
-    uses?: AllUseItems[];
-};
-export type RevalidateItem = {
-    name: string;
-    type: "revalidate";
-    uses?: AllUseItems[];
-};
-export type LoadingItem = {
-    name: string;
-    type: "loading";
-};
-export type ErrorBoundaryItem = {
-    name: string;
-    type: "errorBoundary";
-    uses?: AllUseItems[];
-};
-export type NotFoundBoundaryItem = {
-    name: string;
-    type: "notFoundBoundary";
-    uses?: AllUseItems[];
-};
-export type CacheItem = {
-    name: string;
-    type: "cache";
-    uses?: AllUseItems[];
-};
-export type TransitionItem = {
-    name: string;
-    type: "transition";
-};
-/**
- * Typed transition item that carries child routes as phantom type
- * Used for type inference when transition() wraps child routes
- */
-export type TypedTransitionItem<TChildRoutes extends Record<string, any> = Record<string, string>, TChildResponses extends Record<string, unknown> = Record<string, unknown>> = WithChildren<TransitionItem, TChildRoutes, TChildResponses>;
-/**
- * Typed cache item that carries child routes as phantom type
- * Used for type inference in urls() API
- */
-export type TypedCacheItem<TChildRoutes extends Record<string, any> = Record<string, string>, TChildResponses extends Record<string, unknown> = Record<string, unknown>> = WithChildren<CacheItem, TChildRoutes, TChildResponses>;
-/**
- * Include item for URL pattern composition (used by urls() API)
- */
-export type IncludeItem = {
-    type: "include";
-    name: string;
-    prefix: string;
-    patterns: unknown;
-    options?: {
-        name?: string;
-        lazy?: boolean;
-    };
-    /** Whether this include should be lazily evaluated on first request */
-    lazy?: boolean;
-    /** Captured context for deferred lazy evaluation */
-    _lazyContext?: {
-        urlPrefix: string;
-        namePrefix: string | undefined;
-        parent: unknown;
-        /** Counter snapshot from pattern extraction for consistent shortCode indices */
-        counters?: Record<string, number>;
-        /** Cache profiles for DSL-time cache("profileName") resolution */
-        cacheProfiles?: Record<string, import("./cache/profile-registry.js").CacheProfile>;
-        /** Root scope flag for dot-local reverse resolution */
-        rootScoped?: boolean;
-        /**
-         * Positional include scope token composed from the parent scope plus this
-         * include's sibling index (`${parentScope}I${idx}`). Applied to direct-
-         * descendant shortCodes during lazy evaluation so routes inside the
-         * include cannot collide with siblings declared outside it.
-         */
-        includeScope?: string;
-    };
-};
-/**
- * Typed include item that carries nested routes as phantom type
- * Used for type inference in urls() API
- */
-export type TypedIncludeItem<TRoutes extends Record<string, any> = Record<string, string>, TNamePrefix extends string = string, TUrlPrefix extends string = string, TResponses extends Record<string, unknown> = Record<string, unknown>> = IncludeItem & {
-    readonly __routes?: TRoutes;
-    readonly __namePrefix?: TNamePrefix;
-    readonly __urlPrefix?: TUrlPrefix;
-    readonly __responses?: TResponses;
-};
-/**
- * Union types for use() callbacks
- */
-export type AllUseItems = LayoutItem | RouteItem | MiddlewareItem | RevalidateItem | ParallelItem | InterceptItem | LoaderItem | LoadingItem | ErrorBoundaryItem | NotFoundBoundaryItem | CacheItem | TransitionItem | IncludeItem;
-/** Items that can be used inside a layout callback */
-export type LayoutUseItem = AllUseItems;
-export type RouteUseItem = LayoutItem | ParallelItem | InterceptItem | MiddlewareItem | RevalidateItem | LoaderItem | LoadingItem | ErrorBoundaryItem | NotFoundBoundaryItem | CacheItem | TransitionItem;
-/** Items that can be used inside a response route (path.json(), etc.) */
-export type ResponseRouteUseItem = MiddlewareItem | CacheItem;
-export type ParallelUseItem = RevalidateItem | LoaderItem | LoadingItem | ErrorBoundaryItem | NotFoundBoundaryItem | TransitionItem;
-export type InterceptUseItem = MiddlewareItem | RevalidateItem | LoaderItem | LoadingItem | ErrorBoundaryItem | NotFoundBoundaryItem | LayoutItem | RouteItem | TransitionItem;
-export type LoaderUseItem = RevalidateItem | CacheItem;
-/**
- * Allow composition factories in use() callbacks.
- * Factories return T[], which placed inside a use() callback array
- * creates nested arrays like (T | T[])[]. These are flattened at
- * runtime via .flat(3).
- */
-export type UseItems<T> = (T | readonly T[])[];
-/**
- * Union of all items that handler.use() may return.
- * A handler doesn't know its mount site at definition time, so the type
- * is intentionally broad — validation happens per-mount-site at runtime.
- */
-export type HandlerUseItem = RouteUseItem | LayoutUseItem | ParallelUseItem | InterceptUseItem;
-export {};

package/dist/types.backup/router/basename.d.ts

@@ -1,10 +0,0 @@
-/**
- * Normalize a router basename to its canonical form: a single leading slash,
- * no trailing slash, and `undefined` for an empty or bare-"/" value.
- *
- * This is the single source of truth used by both createRouter() (so the RSC
- * handler stores a canonical basename on the request context) and the testing
- * primitives (so a consumer can pass the same un-normalized string their
- * createRouter() accepts and observe the same redirect() prefixing).
- */
-export declare function normalizeBasename(basename?: string): string | undefined;

package/dist/types.backup/router/content-negotiation.d.ts

@@ -1,91 +0,0 @@
-/**
- * Content Negotiation Utilities
- *
- * Pure functions for HTTP Accept header parsing and response type matching.
- * Used by previewMatch and classifyRequest for content negotiation between
- * RSC routes and response routes (JSON, text, image, stream, etc.).
- */
-import type { EntryData } from "../server/context.js";
-import type { CollectedMiddleware } from "./middleware-types.js";
-import type { RouteSnapshot } from "./route-snapshot.js";
-export declare const RESPONSE_TYPE_MIME: Record<string, string>;
-export declare const MIME_RESPONSE_TYPE: Record<string, string>;
-export type NamedRouteEntry = string | {
-    path: string;
-    search?: Record<string, string>;
-};
-export declare function flattenNamedRoutes(routeNames?: Record<string, NamedRouteEntry>): Record<string, string>;
-export interface AcceptEntry {
-    mime: string;
-    q: number;
-    order: number;
-}
-/**
- * Parse an Accept header into a sorted array of MIME entries.
- * Respects q-values (default 1.0) and uses client order as tiebreaker
- * when q-values are equal (matching Express/Hono behavior).
- */
-export declare function parseAcceptTypes(accept: string): AcceptEntry[];
-export declare const RSC_RESPONSE_TYPE = "__rsc__";
-/** RSC wire-format MIME type; explicit-opt-in flight transport. */
-export declare const RSC_WIRE_MIME = "text/x-component";
-/**
- * Rank the RSC route's two representations against a parsed Accept list:
- * true when the flight wire format outranks the HTML document. Wildcard
- * entries count for the HTML side — they express "anything", and the
- * canonical representation of anything is the document. Co-located with
- * RSC_MIMES so the candidate registration and the representation choice
- * cannot drift.
- */
-export declare function prefersFlightRepresentation(acceptEntries: AcceptEntry[]): boolean;
-/**
- * Pick the best negotiate variant by walking the client's sorted Accept list.
- * For each accepted MIME type (in q-value/order priority), check if any
- * candidate serves that type. Wildcards match the first candidate.
- * Falls back to the first candidate if nothing matches.
- */
-export declare function pickNegotiateVariant<T extends {
-    routeKey: string;
-    responseType: string;
-}>(acceptEntries: AcceptEntry[], candidates: T[]): T;
-/**
- * Re-key params from the primary leaf's names to a winning variant's names.
- *
- * The trie match builds `params` positionally under the primary leaf's pa, so
- * `/widgets/:id` matched as the primary yields `{ id }` even when the winning
- * `/widgets/:file` response variant expects `{ file }`. Both share the same trie
- * terminal, so they bind the same number of positional named params; we zip the
- * variant's pa against the named values in insertion order (which is the
- * primary's pa order). The wildcard key (`*`) is positional-independent and left
- * untouched.
- *
- * Mutates `params` in place. No-op when `variantPa` is absent, when names already
- * match (the common case), or when the positional count diverges (defensive:
- * never corrupt params by zipping mismatched lengths).
- */
-export declare function rekeyParamsForVariant(params: Record<string, string>, variantPa: string[] | undefined): void;
-/**
- * Result of content negotiation for a route with negotiate variants.
- */
-export interface NegotiationResult {
-    /** The winning response type */
-    responseType: string;
-    /** Handler function for the winning variant */
-    handler: Function;
-    /** Manifest entry for the winning variant (may differ from primary) */
-    manifestEntry: EntryData;
-    /** Route middleware for the winning variant */
-    routeMiddleware: CollectedMiddleware[];
-    /** True when negotiation selected a variant; false for a plain response route. */
-    negotiated: boolean;
-}
-/**
- * Perform content negotiation for a route with negotiate variants.
- *
- * Returns a NegotiationResult when a response route wins negotiation.
- * Returns null when RSC wins or no negotiation is needed.
- *
- * Shared by previewMatch and classifyRequest to avoid duplicating
- * the candidate-building and variant-loading logic.
- */
-export declare function negotiateRoute(request: Request, pathname: string, snapshot: RouteSnapshot): Promise<NegotiationResult | null>;

package/dist/types.backup/router/debug-manifest.d.ts

@@ -1,7 +0,0 @@
-import { type SerializedManifest } from "../debug.js";
-import type { RouteEntry } from "../types";
-/**
- * Build a serialized manifest from all route entries for debug inspection.
- * Used by the `debugManifest()` method on the router instance.
- */
-export declare function buildDebugManifest<TEnv = any>(routesEntries: RouteEntry<TEnv>[]): Promise<SerializedManifest>;

package/dist/types.backup/router/error-handling.d.ts

@@ -1,76 +0,0 @@
-/**
- * Router Error Handling Utilities
- *
- * Error boundary and not-found boundary handling for Rango.
- * Also includes the shared invokeOnError utility for error callback invocation.
- */
-import type { ReactNode } from "react";
-import type { EntryData } from "../server/context";
-import type { ResolvedSegment, ErrorInfo, ErrorBoundaryHandler, NotFoundInfo, NotFoundBoundaryHandler, ErrorPhase, OnErrorCallback } from "../types";
-/**
- * Context required to invoke the onError callback.
- * This is a subset of OnErrorContext that callers must provide.
- */
-export interface InvokeOnErrorContext<TEnv = any> {
-    request: Request;
-    url: URL;
-    routeKey?: string;
-    params?: Record<string, string>;
-    segmentId?: string;
-    segmentType?: "layout" | "route" | "parallel" | "loader" | "middleware";
-    loaderName?: string;
-    middlewareId?: string;
-    actionId?: string;
-    env?: TEnv;
-    isPartial?: boolean;
-    handledByBoundary?: boolean;
-    metadata?: Record<string, unknown>;
-    /** Request start time from performance.now() for duration calculation */
-    requestStartTime?: number;
-}
-/**
- * Invoke the onError callback with comprehensive context.
- * Catches any errors in the callback itself to prevent masking the original error.
- *
- * This is a shared utility used by both the router and RSC handler to ensure
- * consistent error callback behavior across the codebase.
- *
- * @param onError - The onError callback to invoke (may be undefined)
- * @param error - The error that occurred
- * @param phase - The phase where the error occurred
- * @param context - Additional context about the error
- * @param logPrefix - Prefix for console.error messages (e.g., "Router" or "RSC")
- */
-export declare function invokeOnError<TEnv = any>(onError: OnErrorCallback<TEnv> | undefined, error: unknown, phase: ErrorPhase, context: InvokeOnErrorContext<TEnv>, logPrefix?: string): void;
-/**
- * Find the nearest error boundary by walking up the entry chain
- * Also checks sibling layouts (orphan layouts) for error boundaries
- * Returns the first fallback found, or the default error boundary if configured
- */
-export declare function findNearestErrorBoundary(entry: EntryData | null, defaultErrorBoundary?: ReactNode | ErrorBoundaryHandler): ReactNode | ErrorBoundaryHandler | null;
-/**
- * Find the nearest notFound boundary by walking up the entry chain
- * Returns the first fallback found, or the default notFound boundary if configured
- */
-export declare function findNearestNotFoundBoundary(entry: EntryData | null, defaultNotFoundBoundary?: ReactNode | NotFoundBoundaryHandler): ReactNode | NotFoundBoundaryHandler | null;
-/**
- * Create ErrorInfo from an error object
- * Sanitizes error details in production
- */
-export declare function createErrorInfo(error: unknown, segmentId: string, segmentType: ErrorInfo["segmentType"]): ErrorInfo;
-/**
- * Create an error segment with the fallback component
- * Renders the fallback with error info and reset function
- */
-export declare function createErrorSegment(errorInfo: ErrorInfo, fallback: ReactNode | ErrorBoundaryHandler, entry: EntryData, params: Record<string, string>): ResolvedSegment;
-/**
- * Create NotFoundInfo from a DataNotFoundError
- */
-export declare function createNotFoundInfo(error: {
-    message: string;
-}, segmentId: string, segmentType: NotFoundInfo["segmentType"], pathname?: string): NotFoundInfo;
-/**
- * Create a notFound segment with the fallback component
- * Renders the fallback with not found info
- */
-export declare function createNotFoundSegment(notFoundInfo: NotFoundInfo, fallback: ReactNode | NotFoundBoundaryHandler, entry: EntryData, params: Record<string, string>): ResolvedSegment;

package/dist/types.backup/router/find-match.d.ts

@@ -1,19 +0,0 @@
-import { type RouteMatchResult } from "./pattern-matching.js";
-import type { MetricsStore } from "../server/context";
-import type { RouteEntry } from "../types";
-export interface FindMatchDeps<TEnv = any> {
-    routesEntries: RouteEntry<TEnv>[];
-    evaluateLazyEntry: (entry: RouteEntry<TEnv>) => void | Promise<void>;
-    routerId: string;
-}
-/**
- * Create a findMatch function bound to router state.
- * Includes single-entry cache to avoid redundant matching within the same request.
- *
- * Async because a lazy include may be backed by an async provider
- * (`() => import("./routes")`) that must be resolved before its routes can be
- * matched. The hot path is unaffected: `await` only suspends on the first
- * request to a not-yet-loaded dynamic include; eager routes resolve in the same
- * microtask. Every caller already runs inside an async match pipeline.
- */
-export declare function createFindMatch<TEnv = any>(deps: FindMatchDeps<TEnv>): (pathname: string, ms?: MetricsStore) => Promise<RouteMatchResult<TEnv> | null>;

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

@@ -1,41 +0,0 @@
-/**
- * Router Handler Context
- *
- * Creates the handler context object passed to route handlers, middleware, and loaders.
- */
-import type { InternalHandlerContext } from "../types";
-/**
- * Strip internal _rsc* query params from a URL.
- * Returns a new URL with only user-facing params.
- */
-export declare function stripInternalParams(url: URL): URL;
-/**
- * Create a reverse function for URL generation from route names.
- * Used by both HandlerContext and MiddlewareContext.
- *
- * When currentParams is provided, those params are used as defaults for URL
- * generation. This enables auto-filling mount params from include() prefixes:
- * inner handlers can call ctx.reverse(".sibling") without explicitly passing
- * params that are already known from the current URL match.
- * Explicitly passed hrefParams take priority over currentParams.
- */
-export declare function createReverseFunction(routeMap: Record<string, string>, currentRoutePrefix?: string, currentParams?: Record<string, string>, rootScoped?: boolean): (name: string, hrefParams?: Record<string, string>, search?: Record<string, unknown>) => string;
-/**
- * Create HandlerContext with typed env/var/get/set
- */
-export declare function createHandlerContext<TEnv>(params: Record<string, string>, request: Request, searchParams: URLSearchParams, pathname: string, url: URL, bindings?: TEnv, routeMap?: Record<string, string>, routeName?: string, responseType?: string, isPassthroughRoute?: boolean): InternalHandlerContext<any, TEnv>;
-/**
- * Create a PrerenderContext for Prerender() handlers at build time.
- *
- * Returns an InternalHandlerContext where params, pathname, url, searchParams,
- * search, reverse, and use(handle) work. Request-time properties
- * (request, env, headers, cookies, get, set, res) throw with a clear error.
- */
-export declare function createPrerenderContext<TEnv>(params: Record<string, string>, pathname: string, routeMap: Record<string, string>, routeName?: string, buildVars?: Record<string, any>, isPassthroughRoute?: boolean, buildEnv?: TEnv, devMode?: boolean): InternalHandlerContext<any, TEnv>;
-/**
- * Create a StaticContext for Static() handlers at build time.
- *
- * Returns an InternalHandlerContext where only reverse and use(handle) work.
- * Static handlers have no URL, no params, no pathname — everything else throws.
- */
-export declare function createStaticContext<TEnv>(routeMap: Record<string, string>, routeName?: string, buildEnv?: TEnv, devMode?: boolean): InternalHandlerContext<any, TEnv>;

package/dist/types.backup/router/instrument.d.ts

@@ -1,161 +0,0 @@
-/**
- * Phase + event instrumentation — the single internal API for observing router
- * work.
- *
- * The router exposes the same work on three surfaces, and the rule is: each
- * surface has exactly one owner here, so they cannot drift.
- *
- *   - observePhase(): a span of work. Co-emits the `debugPerformance` perf
- *     metric (metrics store -> [RSC Perf] timeline + Server-Timing) AND the
- *     platform span (tracing runner -> Cloudflare custom spans / OTel). From one
- *     wrap site, so the span set is always a subset of the perf phases and the
- *     two can't disagree. Phases that meter their own perf metric with a finer
- *     decomposition (request, middleware) pass `metric: false` and get the span
- *     only — still co-located, still one owner per surface.
- *   - observeEvent(): a discrete fact (TelemetrySink): cache decisions,
- *     revalidation decisions, handler errors, timeouts, origin rejections.
- *     Event-shaped, not phase-shaped — derived from the same call sites but a
- *     separate surface from spans.
- *
- * Why phases, not events, are the parent abstraction: Cloudflare's span API is
- * callback-bound (enterSpan wraps the actual work), so the callback boundary is
- * the source of truth — async-context nesting (a loader's KV/D1/fetch spans
- * landing under rango.loader) cannot be faithfully reconstructed from
- * after-the-fact start/end events. Spans drive; events are emitted alongside.
- *
- * Phase identity lives in the PHASES registry below, so the raw `rango.*` span
- * names, perf-metric labels, and span attributes have a single definition each.
- *
- * When neither perf surface nor tracing is active on the request, observePhase
- * is a direct call — no wrapper, no timestamp, no allocation.
- */
-import { type TelemetryEvent } from "./telemetry.js";
-import { type TracePhase, type TraceSpan } from "./tracing.js";
-/**
- * Perf-metric boundary for a phase, or `false` for span-only. `false` means the
- * caller records its own perf metric with a finer decomposition than a single
- * wrap (request: a grand total incl. pre-context bootstrap; middleware: pre/post
- * own-time), so observePhase opens the span but records no metric of its own.
- */
-export type PhaseMetric = {
-    label: string | (() => string);
-    depth?: number;
-} | false;
-/** Describes one observable phase across the perf and span surfaces. */
-export interface PhaseSpec {
-    /** Perf timeline label + Server-Timing name, or false for span-only. */
-    metric: PhaseMetric;
-    /** Span phase gate (per-phase toggle in the tracing config). */
-    tracePhase: TracePhase;
-    /** Span name (rango.*). */
-    spanName: string;
-    /** Span attributes set automatically when the span opens. */
-    attributes?: Record<string, string | number | boolean>;
-    /**
-     * Span attributes resolved AFTER the wrapped work runs (so they can read state
-     * that only exists once the work is underway, e.g. the matched route name).
-     * Applied for streaming phases once fn has constructed its value. Return
-     * undefined to add nothing.
-     */
-    lazyAttributes?: () => Record<string, string | number | boolean> | undefined;
-}
-/**
- * The router's observable phases. One definition per phase keeps the `rango.*`
- * span names, perf-metric labels, and identifying attributes from spreading
- * across call sites.
- */
-export declare const PHASES: {
-    /** Whole request pipeline. Span only — handler:total is metered directly. */
-    readonly request: PhaseSpec;
-    /** One middleware (incl. its downstream onion). Span only — the perf metric
-     * is the middleware's exclusive pre/post own-time, recorded directly.
-     * `metricLabel` is that metric's label (e.g. "middleware:auth@*"); it doubles
-     * as the rango.middleware_name span attribute. */
-    readonly middleware: (metricLabel: string) => PhaseSpec;
-    /** The server-action execution (decode args + run the action body), before
-     * the revalidation render. The metric label carries the action id (the
-     * _rsc_action / action $$id) so the perf timeline shows WHICH action ran, not
-     * just "an action"; the span also gets it as rango.action_id. */
-    readonly action: (id: string) => PhaseSpec;
-    /**
-     * One loader execution. `depth` is the perf-timeline indentation: 2 (default)
-     * for render-time loaders that nest under the render phase; 1 for a standalone
-     * fetchable `_rsc_loader` request, which has no render parent.
-     */
-    readonly loader: (id: string, depth?: number) => PhaseSpec;
-    /** One segment route/layout handler execution (the component/handler that
-     * produces a segment). Span only — the perf metric (handler:<id>) is owned by
-     * the legacy track() at the same call site, so observePhase here adds the
-     * rango.handler span without double-recording. `id` is the HANDLER id (the
-     * entry.id used in the handler:<id> perf row), carried as rango.handler_id —
-     * NOT the emitted segment's id (shortCode), which differs; the *_id naming
-     * mirrors rango.loader_id / rango.action_id. */
-    readonly handler: (id: string) => PhaseSpec;
-    /** Whole render phase: match + serialize + SSR. The metric label is resolved
-     * lazily at record time (after match has set the route name) so the perf
-     * timeline shows WHICH route rendered: `render:total:<routeName>`, falling back
-     * to `render:total` when there is no named route (unmatched / auto-generated). */
-    readonly render: PhaseSpec;
-    /** SSR HTML render from the RSC stream. Colon-delimited like the other ssr:*
-     * setup metrics (ssr:module-load / ssr:stream-mode). */
-    readonly ssr: PhaseSpec;
-};
-/**
- * Instrument one unit of work: open its span AND (unless `metric: false`) record
- * its perf metric, from a single wrap site. fn is invoked exactly once with the
- * span (a no-op span when tracing is off); its return value is returned
- * unchanged and thrown errors / rejected promises propagate unchanged. When fn
- * returns a promise both the metric duration and the span end when it settles.
- *
- * This is the ONLY phase primitive: every phase (request/middleware/action/
- * loader/handler/render/ssr) is construction-bound — the span and metric settle
- * when fn's own work completes (for the streaming phases, when the RSC/HTML
- * stream is constructed, NOT when the body drains). Instrumentation is strictly
- * best-effort: it never wraps or buffers the response and adds no work on the
- * streaming path, so it cannot regress response latency or streaming. A loader
- * that resolves while the body streams therefore keeps a rango.loader span that
- * may extend past its render parent — overlapping spans are valid; the loader
- * really did take that long.
- *
- * Reads the metrics store + tracing off the RequestContext ALS, which is active
- * for the WHOLE request — contrast observeEvent, which reads the RouterContext
- * ALS (entered later, during match).
- */
-export declare function observePhase<T>(spec: PhaseSpec, fn: (span: TraceSpan) => T): T;
-/**
- * Open a rango.handler span around one segment route/layout handler call. The
- * segment-resolution hot path runs this PER SEGMENT, so it gates on the SPAN
- * surface alone and calls the handler directly otherwise — building neither the
- * PhaseSpec (PHASES.handler allocates) nor the wrapper closure on the off path.
- * The handler:<id> perf metric is owned by the track() at the call site, so the
- * span is the only surface this adds (metric:false); a debugPerformance-only
- * request (no tracing) or a disabled handler phase (spans:{handler:false}) has
- * nothing to record here and short-circuits.
- */
-export declare function observeHandler<C, R>(id: string, handler: (ctx: C) => R, ctx: C): R;
-/**
- * Emit one discrete telemetry event (the event-shaped counterpart to
- * observePhase). Resolves the sink from the active router context and stamps the
- * request id when the event omits it. No-op (and total — never throws) when no
- * sink is configured.
- *
- * This is the canonical emitter for SYNCHRONOUS facts that fire inside the
- * request's ALS scope (revalidation decisions, cache-lookup decisions). A few
- * emitters deliberately stay on the lower-level resolveSink + safeEmit because
- * observeEvent's lazy, per-call getRouterContext() read does not fit them — keep
- * this the complete list:
- *   - router.ts wrapLoaderPromise (loader.start/end/error) and
- *     segment-resolution/streamed-handler-telemetry.ts (streamed handler.error)
- *     capture the sink + request id EAGERLY and emit from a fire-and-forget
- *     continuation that runs after the ALS scope may have unwound.
- *   - router/match-handlers.ts resolves the sink ONCE for the hot match-pipeline
- *     loop (request.start/end/error, cache.decision, ...).
- *   - segment-resolution/helpers.ts emits via a caller-provided report.telemetry
- *     sink rather than the ALS router context.
- *   - rsc/handler.ts handleTimeoutResponse (request.timeout), the origin guard
- *     (request.origin-rejected), and handleStore.onError (late-handle
- *     handler.error) emit via router.telemetry directly — they run outside the
- *     RouterContext ALS (only match()/matchPartial() enter it), so a
- *     getRouterContext() read there throws and the event would vanish.
- */
-export declare function observeEvent(event: TelemetryEvent): void;

package/dist/types.backup/router/intercept-resolution.d.ts

@@ -1,79 +0,0 @@
-/**
- * Intercept Resolution
- *
- * Extracted from createRouter closure. Contains intercept detection and resolution
- * functions for soft navigation (modals).
- */
-import type { EntryData, InterceptEntry, InterceptSelectorContext } from "../server/context";
-import type { HandlerContext, ResolvedSegment } from "../types";
-import type { SegmentResolutionDeps } from "./types.js";
-/**
- * Check if an intercept's when conditions are satisfied.
- * All when() functions must return true for the intercept to activate.
- * If no when() conditions are defined, the intercept always activates.
- *
- * During action revalidation, when() is NOT evaluated.
- */
-export declare function evaluateInterceptWhen(intercept: InterceptEntry, selectorContext: InterceptSelectorContext | null, isAction: boolean): boolean;
-/**
- * Find an intercept for the target route by walking up the entry chain.
- * Returns the first (innermost) matching intercept along with the entry that defines it.
- */
-export declare function findInterceptForRoute(targetRouteKey: string, fromEntry: EntryData | null, selectorContext?: InterceptSelectorContext | null, isAction?: boolean): {
-    intercept: InterceptEntry;
-    entry: EntryData;
-} | null;
-/**
- * Resolve an intercept entry and emit segment with the slot name.
- */
-export declare function resolveInterceptEntry<TEnv>(interceptEntry: InterceptEntry, parentEntry: EntryData, params: Record<string, string>, context: HandlerContext<any, TEnv>, belongsToRoute: boolean, deps: SegmentResolutionDeps<TEnv>, 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;
-}, options?: {
-    /**
-     * Skip the intercept's middleware execution. Set ONLY by the post-response
-     * background re-render paths (proactive caching, stale background
-     * revalidation), whose sole purpose is to re-render the segment tree to
-     * populate the cache. The foreground request already ran the intercept
-     * middleware before the response was sent — it validated auth, set cookies,
-     * and wrote context vars into the request context's shared `_variables`,
-     * which the background render reuses. Re-running middleware here would fire
-     * its side effects a SECOND time, and a middleware that short-circuits with
-     * a Response would `throw` and silently abort the cache write. Never set on
-     * the foreground path.
-     */
-    skipMiddleware?: boolean;
-}): Promise<ResolvedSegment[]>;
-/**
- * Resolve only the loaders for a cached intercept segment.
- * Used on intercept cache hit to get fresh loader data while keeping cached component/layout.
- */
-export declare function resolveInterceptLoadersOnly<TEnv>(interceptEntry: InterceptEntry, parentEntry: EntryData, params: Record<string, string>, context: HandlerContext<any, TEnv>, belongsToRoute: boolean, deps: SegmentResolutionDeps<TEnv>, 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;
-}): Promise<{
-    loaderDataPromise: Promise<any[]> | any[];
-    loaderIds: string[];
-} | null>;