@rangojs/router 0.27.0 → 0.28.0

package/dist/types/server/rewrite-trail.d.ts

@@ -25,12 +25,12 @@ export declare function recordRewriteHop(reqCtx: TrailContext, from: URL, to: UR
 export declare function recordRewriteShell(reqCtx: TrailContext, audience: RewriteShell | undefined): void;
 /** The last hop's `rewrite(...).shell()` choice; undefined: none. */
 export declare function rewriteShellAudience(reqCtx: TrailContext | undefined): RewriteShell | undefined;
-type AudienceContext = Pick<RequestContext<any>, "_shellCaptureRun" | "_documentCacheRender" | "res">;
+type AudienceContext = Pick<RequestContext<any>, "_shellCaptureState" | "_documentCacheRender" | "res">;
 /**
  * A render other visitors may be served: a PPR shell capture, or a render
  * the document cache stores (its response opted in before next()). It shows
  * no visitor theme, and no visitor URL unless it is a visitor-keyed shell
- * capture (`_shellCaptureForVisitor`).
+ * capture (`_shellCaptureState.forVisitor`).
  */
 export declare function rendersForSharedAudience(reqCtx: AudienceContext): boolean;
 /**

package/dist/types/testing/dispatch.d.ts

@@ -2,9 +2,12 @@
  * dispatch — in-process request -> Response for unit/integration tests,
  * WITHOUT the Flight RSC runtime.
  *
- * dispatch runs the router's real matching and middleware execution so that
- * redirects, 404s, response routes (path.json / path.text / path.html / ...),
- * and middleware short-circuits behave exactly as in production. It deliberately
+ * dispatch runs the production handler's request stages
+ * (rsc/request-stages.ts: classify, the terminal plans, the global middleware
+ * passes, the response route and the response's finalization) so that
+ * redirects, 404s, reloads, response routes (path.json / path.text /
+ * path.html / ...), and middleware short-circuits behave exactly as in
+ * production. It deliberately
  * does NOT render React Server Components: there is no Flight stream, no SSR,
  * and no DOM. Hit an RSC (component) route and dispatch throws a clear error
  * directing you to renderToFlightString/renderServerTree/renderHandler or an e2e test.
@@ -17,19 +20,20 @@
  *   so a global auth middleware can 401/redirect them and middleware-set
  *   cookies/headers merge onto the 308/404 the way createResponseWithMergedHeaders
  *   merges them in production.
- * - Response routes (non-RSC)                         -> serialized Response
+ * - Response routes (non-RSC), served by production's handleResponseRoute
+ *   (rsc/response-route-handler.ts)                  -> serialized Response
  *   - json:           JSON.stringify(result) (bare value) with application/json
  *   - text/html/xml/md: String(result) with the mapped MIME type
- *   - handler returning or throwing a Response:         re-wrapped like
- *     handleResponseRoute (stub headers/cookies merged, Set-Cookie preserved,
- *     WebSocket upgrade passed through without reconstruction)
+ *   - handler returning or throwing a Response:         re-wrapped (stub
+ *     headers/cookies merged, Set-Cookie preserved, WebSocket upgrade passed
+ *     through without reconstruction)
  *   - handler throwing a non-Response error:            typed 500 / RouterError
- *     status, matching handleResponseRoute (RFC 9457 problem+json body with
- *     application/problem+json for json routes, text/plain message otherwise)
+ *     status (RFC 9457 problem+json body with application/problem+json for
+ *     json routes, text/plain message otherwise)
  *   - content-negotiated route:                         Vary: Accept appended
  *   - cached response route (cache({...})):             getResponse/putResponse
- *     hit/SWR/tag write, resolved from the matched entry tree exactly as
- *     handleResponseRoute does. The write is scheduled via ctx.waitUntil
+ *     hit/SWR/tag write, resolved from the matched entry tree. The write is
+ *     scheduled via ctx.waitUntil
  *     (a microtask without an executionContext), so a HIT-asserting test must
  *     flush microtasks between the seeding dispatch and the asserting one.
  * - Global middleware (router.use(...)) AND route-level middleware, with full
@@ -38,10 +42,17 @@
  *   global middleware runs first (so an auth gate can still 401/redirect),
  *   then — if it passes through — an X-RSC-Reload is returned. Route-level
  *   middleware is skipped on a partial, exactly as production skips it.
- * - A middleware redirect (3xx + Location) on a partial/action request
- *   (?_rsc_partial / ?_rsc_action): converted to a 204 + X-RSC-Redirect via the
- *   real interceptRedirectForPartial, so fetch() does not auto-follow the 3xx —
+ * - A global middleware redirect (3xx + Location) on a partial/action request
+ *   (?_rsc_partial / ?_rsc_action), and a findMatch() redirect on a partial
+ *   request: a 204 + X-RSC-Redirect, so fetch() does not auto-follow the 3xx —
  *   identical to production's no-location-state path.
+ * - The terminal plans production answers inside the global chain
+ *   (terminalPlanResponse): a `_rsc_v` version mismatch and a `_rsc_rid` app
+ *   switch reload (X-RSC-Reload), and an action (?_rsc_action) a rewrite moved
+ *   to a target that is not a page route throws production's error.
+ * - Route params and name are set inside the global chain, after classify, by
+ *   the stage production's executeRequest runs (recordPlanRoute): global
+ *   middleware sees them after next(), not before it.
  * - The open-redirect guard (rsc/redirect-guard.ts) on full (browser-followed)
  *   redirects: a cross-origin Location is rewritten to the basename root unless
  *   redirect(url, { external: true }) opted out, mirroring production's single
@@ -60,7 +71,9 @@
  *   after finalizeResponse (segmentCount 0 / cacheHit false — dispatch renders no
  *   RSC segments and holds no match-cache state), and a thrown non-Response error
  *   emits request.error with phase "routing". All three carry the same requestId
- *   (getRequestId). Emission is gated entirely on a configured sink; with none,
+ *   (getRequestId), as does a response-route timeout on a rewritten pass
+ *   (runRequestPasses carries the id to each pass's request, as in
+ *   production). Emission is gated entirely on a configured sink; with none,
  *   dispatch does zero new work and stays byte-identical for existing callers.
  *   Lets a consumer unit-test their sink wiring in-process instead of only at e2e.
  * - Response-route `renderStartMs` timeouts and `onTimeout`: dispatch races the
@@ -96,9 +109,13 @@
  *   request.start/end/error lifecycle above; cover cache/loader telemetry with an
  *   e2e test driving a real RSC request.
  *
- * dispatch reuses router.previewMatch(), which itself runs content negotiation
- * and resolves route middleware from the matched entry tree, so dispatch's
- * route-middleware collection is exactly the router's, not a re-implementation.
+ * Each pass is classified with the handler's classify stage
+ * (router/request-classification.ts classifyRequest), which runs content
+ * negotiation and resolves route middleware from the matched entry tree, so
+ * dispatch's route-middleware collection is exactly the router's, not a
+ * re-implementation. The origin guard is not run: it gates only the action,
+ * loader and PE-form plans, which classify gives a component route only, and
+ * dispatch throws on those before the pass's middleware.
  */
 import type { Rango } from "../router/router-interfaces.js";
 /**

package/dist/types/types/cache-types.d.ts

@@ -130,9 +130,12 @@ export interface CacheOptions<TEnv = unknown> {
      */
     condition?: (ctx: import("../server/request-context.js").RequestContext<TEnv>) => boolean;
     /**
-     * Custom cache key function - FULL OVERRIDE.
-     * Bypasses default key generation AND store's keyGenerator. The result is
-     * stored namespaced (`key:` plus its URI encoding), so no value it returns
+     * Custom cache key function. Replaces the URL part of the default key
+     * (host, path, params, search) AND bypasses the store's keyGenerator. The
+     * request kind stays: a document request, a navigation and each intercept
+     * navigation keep their own record under one result, so the result decides
+     * which requests of one kind share a record. It is stored namespaced
+     * (`key:` plus its URI encoding, then the kind), so no value it returns
      * names another route's record; a nested cache() keys its records within
      * this partition.
      *

package/dist/types/types/error-types.d.ts

@@ -69,7 +69,15 @@ export interface OnErrorContext<TEnv = any> {
     env?: TEnv;
     /** Duration from request start to error (milliseconds) */
     duration?: number;
-    /** Whether this is a partial/navigation request */
+    /**
+     * Whether this is a partial/navigation request, on an error the segment
+     * walk catches (a handler that throws, a DSL loader that rejects): `true`
+     * for a navigation, unset for a document. An error in the background
+     * re-render of a `cache()` record (a stale HIT's refresh, the write of a
+     * navigation that kept a layout mounted) reports the request that started
+     * it. A streamed (`loading()`) handler's rejection does not carry it, in
+     * either render; the `routing` phase reports `false`.
+     */
     isPartial?: boolean;
     /** Whether an error boundary caught the error */
     handledByBoundary?: boolean;

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

@@ -342,7 +342,7 @@ export type InternalHandlerContext<TParams = {}, TEnv = DefaultEnv, TSearch exte
     _reverseScope?: import("../server/context.js").ReverseScope;
     /**
      * @internal The on-demand overlay holds a "removed" marker for this request
-     * (tryPrerenderLookup, cache-lookup.ts); gateOnDemandProducer reads it. On
+     * (readPrerenderSource, cache-lookup.ts); gateOnDemandProducer reads it. On
      * this context, not the request's: withCacheLookup documents that the
      * request ALS can be lost mid-pipeline on workerd.
      */
@@ -390,6 +390,14 @@ export type InternalHandlerContext<TParams = {}, TEnv = DefaultEnv, TSearch exte
      * request is a fill. See router/segment-resolution/prefetch-deferral.ts.
      */
     _prefetchDeferral?: import("../router/segment-resolution/prefetch-deferral.js").PrefetchDeferral;
+    /**
+     * @internal DSL loaders registered and not started, by `$$id`: a prefetch
+     * deferred them, or a pass that skips loaders (`skipLoaders`) did not run
+     * them. A reader's ctx.use() starts one through its registration
+     * (registerDeferredLoader, startDeferredLoader in
+     * router/segment-resolution/prefetch-deferral.ts).
+     */
+    _deferredLoaders?: Map<string, import("../router/segment-resolution/prefetch-deferral.js").DeferredLoader>;
     /**
      * @internal Whether a loader was started in this request: a run of it (a
      * handler's or another loader's ctx.use()) or its cache() binding. A

package/dist/types/types/segments.d.ts

@@ -151,7 +151,7 @@ export interface ResolvedSegment {
     loaderData?: any;
     /**
      * True when this loader was awaited before first flush
-     * (loader(Def, { ssr: false })). Stamped by resolveLoaders (fresh.ts) on
+     * (loader(Def, { ssr: false })). Stamped by resolveOwnerLoaders on
      * document AND shell-capture renders — capture bakes flagged loaders and
      * awaits the same lane. Feeds segment-system's settled-value delivery and
      * the dev SSR suspension warning (ssr-suspension-warning.ts).

package/dist/types/vite/discovery/build-discovery-phase.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Build discovery phase: the discovery plugin's buildStart, buildApp (post)
+ * and buildEnd hooks.
+ *
+ * buildStart discovers routers through a temp RSC server and writes the
+ * generated route types. When PPR shell candidates exist, it defers closing
+ * that server, and releasing the buildEnv, as a PAIR: the buildApp post hook
+ * releases them after the shell capture (success), buildEnd after an
+ * environment build failure (abort).
+ */
+import type { Rolldown, ViteBuilder } from "vite";
+import type { DiscoveryState } from "./state.js";
+/**
+ * buildStart. Build mode: create a temporary Vite dev server to access the
+ * RSC environment's module runner, then discover routers and generate
+ * manifests. The manifest data is stored for the virtual module's load hook.
+ */
+export declare function buildDiscoveryPhase(s: DiscoveryState, context: Rolldown.PluginContext): Promise<void>;
+/**
+ * buildApp (post). Post-build phases, after EVERY environment bundle is
+ * written.
+ *
+ * 1. Cache versions (router-versions-phase.ts): hashes the server output as
+ *    postprocessBundle left it and writes the per-router table into the
+ *    built version module. First, because phase 2 stamps its entries with
+ *    these versions and reads the same RSC out dir.
+ * 2. PPR shell capture (producer B, #699): the shell prelude embeds built
+ *    client asset URLs (bootstrap entry), which do not exist at buildStart.
+ *    The kept temp server and the buildEnv were deferred AS A PAIR in
+ *    buildStart's finally; this finally is the pair's success-path owner
+ *    (buildEndPhase owns the aborted-build path) — the phase itself is a pure
+ *    producer and tears down only the globals it installs.
+ */
+export declare function postBuildPhase(s: DiscoveryState, builder: ViteBuilder): Promise<void>;
+/**
+ * buildEnd. An environment build failure aborts the builder before the
+ * buildApp post hook — never leak the kept temp server (open handles hang
+ * the CLI) or the deferred buildEnv (a live miniflare proxy).
+ */
+export declare function buildEndPhase(s: DiscoveryState, error: Error | undefined): Promise<void>;

package/dist/types/vite/discovery/build-env.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Build-time env (rango({ buildEnv })): resolution of the option and the
+ * lifetime of the resolved bindings on DiscoveryState. Acquired by dev
+ * discovery (dev-server-phase.ts) and build discovery
+ * (build-discovery-phase.ts).
+ */
+import type { BuildEnvOption, BuildEnvFactoryContext, BuildEnvResult } from "../plugin-types.js";
+import type { DiscoveryState } from "./state.js";
+/**
+ * Resolve the buildEnv option into a concrete { env, dispose? } result.
+ * Handles all four input shapes: false, "auto", factory, plain object.
+ */
+export declare function resolveBuildEnv(option: BuildEnvOption | undefined, factoryCtx: BuildEnvFactoryContext): Promise<BuildEnvResult | null>;
+/**
+ * Acquire build-time env bindings and store on discovery state.
+ * Returns true if env was acquired, false if buildEnv is disabled.
+ */
+export declare function acquireBuildEnv(s: DiscoveryState, command: "serve" | "build", mode: string): Promise<boolean>;
+/**
+ * Release build-time env resources and clear state.
+ */
+export declare function releaseBuildEnv(s: DiscoveryState): Promise<void>;

package/dist/types/vite/discovery/bundle-scan-phase.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Bundle scan phase: the discovery plugin's generateBundle hook.
+ *
+ * Records the inputs of the per-router cache versions (build-versions.ts) for
+ * every environment and, during the RSC build, the RSC entry filename and the
+ * chunks holding Prerender/Static handler exports. closeBundle
+ * (bundle-postprocess.ts) uses them for handler code eviction and prerender
+ * data injection.
+ */
+import type { Rolldown } from "vite";
+import type { DiscoveryState } from "./state.js";
+export declare function bundleScanPhase(s: DiscoveryState, context: Rolldown.PluginContext, bundle: any): void;

package/dist/types/vite/discovery/dev-prerender-cache.d.ts

@@ -34,8 +34,9 @@ export interface DevPrerenderPayloadBodies {
     /** `intercept != 1` response: the route's own segments + handles. */
     main: string;
     /**
-     * `intercept=1` response: main + intercept segments with the MERGED handle
-     * string. Falls back to `main` byte-for-byte when the route has no
+     * `intercept=1` response: the build's intercept variant
+     * (interceptVariantSegments, prerender/store.ts) with the producer's handle
+     * string for it. Falls back to `main` byte-for-byte when the route has no
      * intercept segments — mirroring the endpoint's historical behavior.
      */
     intercept: string;

package/dist/types/vite/discovery/dev-server-phase.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Dev server phase: the discovery plugin's configureServer hook.
+ *
+ * Runs dev discovery (the Node RSC runner, or a temp Node server under
+ * Cloudflare, whose RSC env has no runner), serves the dev /__rsc_prerender
+ * and /__rsc_shell endpoints, and watches route files to regenerate the
+ * generated route types and re-run runtime discovery on HMR.
+ */
+import type { ViteDevServer } from "vite";
+import { type DiscoveryState } from "./state.js";
+/** The slice of a Vite environment module graph the route-file watcher reads. */
+interface ModulesByFileGraph {
+    getModulesByFile(file: string): ReadonlySet<unknown> | undefined;
+}
+/**
+ * Whether the dev route-file watcher ignores `file`: it sits in a directory
+ * every discovery scan skips (isInSkippedScanDir) and the RSC graph has not
+ * loaded it. See docs/manifests.md, "A reload no file of the app asked for".
+ */
+export declare function isFileOutsideApp(root: string, file: string, rscGraph: ModulesByFileGraph | undefined): boolean;
+/**
+ * configureServer. Dev mode: discover routers and populate manifest in
+ * memory. Skipped in build mode (buildDiscoveryPhase handles it).
+ */
+export declare function devServerPhase(s: DiscoveryState, server: ViteDevServer): void;
+export {};

package/dist/types/vite/discovery/discovery-errors.d.ts

@@ -95,7 +95,7 @@ export interface DiscoveryFailureReport {
  *   - a transient artifact of a Vite dependency re-optimization racing with boot
  *     discovery (a module read before the entry import resolves to the
  *     pre-optimize copy of the runner graph while createRouter() populated the
- *     post-optimize copy — see router-discovery.ts).
+ *     post-optimize copy — see dev-server-phase.ts).
  *
  * We can only tell them apart when the caller observed the dep optimizer's
  * `browserHash` change across the discovery attempt (`reoptimizeObserved`): a

package/dist/types/vite/discovery/state.d.ts

@@ -117,6 +117,9 @@ export interface DiscoveryState {
     resolvedEntryPath: string | undefined;
     projectRoot: string;
     isBuildMode: boolean;
+    /** Vite's resolved command and mode (configResolved), for resolveBuildEnv. */
+    viteCommand: "serve" | "build";
+    viteMode: string;
     userResolveAlias: any;
     /**
      * Data-only slice of the user's resolved config (resolve.* incl. native
@@ -199,6 +202,15 @@ export interface DiscoveryState {
     devDiscoveryEpoch?: number;
     devServerOrigin: string | null;
     devServer: any;
+    /**
+     * Dev: the pending transition({ when }) definition error, re-sent as the
+     * Vite error overlay until a discovery succeeds (dev-server-phase.ts).
+     */
+    transitionWhenOverlay: {
+        message: string;
+        stack: string;
+        plugin: string;
+    } | null;
     selfWrittenGenFiles: Map<string, {
         at: number;
         hash: string;

package/dist/types/vite/plugins/version-plugin.d.ts

@@ -10,7 +10,7 @@ import { type Plugin } from "vite";
  * Build: exports a placeholder for the per-router versions table. The module
  * holds nothing that varies between builds; the table is written into the
  * built chunk after the server output is hashed (the buildApp post hook in
- * router-discovery.ts). See docs/design/per-app-cache-version.md.
+ * discovery/build-discovery-phase.ts). See docs/design/per-app-cache-version.md.
  * @internal
  */
 export declare function createVersionPlugin(): Plugin;

package/dist/types/vite/plugins/virtual-entries.d.ts

@@ -47,7 +47,7 @@ export declare function getVirtualVersionContent(version: string): string;
 /**
  * Free identifier the production version module ships in place of the table.
  * The versions are hashes of the built server code, so they cannot be part of
- * it: the buildApp post hook (router-discovery.ts) replaces this token in the
+ * it: the buildApp post hook (discovery/build-discovery-phase.ts) replaces this token in the
  * written chunk once the hashes are final (runRouterVersionsPhase,
  * discovery/router-versions-phase.ts). An unreplaced token throws a ReferenceError
  * when the module evaluates, so a build that skipped the step cannot serve

package/dist/types/vite/router-discovery.d.ts

@@ -2,55 +2,16 @@
  * Router Discovery Plugin
  *
  * Vite plugin that discovers router instances at dev/build time via the RSC
- * environment. Delegates to extracted modules for discovery, route types
- * generation, virtual module codegen, and bundle post-processing.
+ * environment. Its hooks call the phase modules over one DiscoveryState:
+ * discovery/dev-server-phase.ts (configureServer),
+ * discovery/build-discovery-phase.ts (buildStart, buildApp post, buildEnd) and
+ * discovery/bundle-scan-phase.ts (generateBundle). Route types generation,
+ * virtual module codegen and bundle post-processing live in their own
+ * discovery/ modules.
  */
-import type { Plugin, ViteDevServer } from "vite";
-import { VIRTUAL_ROUTES_MANIFEST_ID, type DiscoveryState, type PluginOptions } from "./discovery/state.js";
+import type { Plugin } from "vite";
+import { VIRTUAL_ROUTES_MANIFEST_ID, type PluginOptions } from "./discovery/state.js";
 export { VIRTUAL_ROUTES_MANIFEST_ID };
-/** The slice of a Vite environment module graph the route-file watcher reads. */
-interface ModulesByFileGraph {
-    getModulesByFile(file: string): ReadonlySet<unknown> | undefined;
-}
-/**
- * Whether the dev route-file watcher ignores `file`: it sits in a directory
- * every discovery scan skips (isInSkippedScanDir) and the RSC graph has not
- * loaded it. See docs/manifests.md, "A reload no file of the app asked for".
- */
-export declare function isFileOutsideApp(root: string, file: string, rscGraph: ModulesByFileGraph | undefined): boolean;
-/**
- * Create a minimal Vite server for router discovery.
- *
- * Both dev-mode prerender and build-mode discovery need a temp RSC server
- * to import user router files via module runner. This factory centralizes
- * the shared config and the mode-specific differences:
- * - Dev: path-based IDs (no forceBuild), separate cacheDir
- * - Build: hashed IDs (forceBuild), hashClientRefs for production bundles
- *
- * Returns the ViteDevServer instance. Callers access .environments.rsc as needed.
- * @internal Exported for tests.
- */
-export declare function createTempRscServer(state: DiscoveryState, options?: {
-    forceBuild?: boolean;
-    cacheDir?: string;
-    /**
-     * Serve the REAL rango SSR entry (getVirtualEntrySSR) for
-     * "virtual:entry-ssr" instead of the discovery stub, so the dev
-     * /__rsc_shell endpoint can drive captureShellHTML in this server's SSR
-     * realm. Dev-correct by construction: the entry's bootstrap resolves to
-     * plugin-rsc's stable virtual browser-entry URL, which the MAIN dev
-     * server serves to the browser. Loaded lazily — discovery never imports
-     * the SSR entry, so the temp server stays as light as before until a
-     * shell capture actually runs.
-     */
-    realSsrEntry?: boolean;
-}): Promise<ViteDevServer>;
-import type { BuildEnvOption, BuildEnvFactoryContext, BuildEnvResult } from "./plugin-types.js";
-/**
- * Resolve the buildEnv option into a concrete { env, dispose? } result.
- * Handles all four input shapes: false, "auto", factory, plain object.
- */
-export declare function resolveBuildEnv(option: BuildEnvOption | undefined, factoryCtx: BuildEnvFactoryContext): Promise<BuildEnvResult | null>;
 /**
  * Plugin that discovers router instances at dev/build time via the RSC environment.
  *

package/dist/types/vite/temp-rsc-server.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The discovery temp RSC server: a minimal Vite server whose module runner
+ * imports the user's router files. Shared by dev discovery
+ * (discovery/dev-server-phase.ts) and build discovery
+ * (discovery/build-discovery-phase.ts).
+ *
+ * Sits in src/vite/, not src/vite/discovery/: the loader hook URL below
+ * resolves against this module's import.meta.url, and the published bundle
+ * (dist/vite/index.js) ships the hook at the same relative path.
+ */
+import type { ViteDevServer } from "vite";
+import type { DiscoveryState } from "./discovery/state.js";
+/**
+ * Create a minimal Vite server for router discovery.
+ *
+ * Both dev-mode prerender and build-mode discovery need a temp RSC server
+ * to import user router files via module runner. This factory centralizes
+ * the shared config and the mode-specific differences:
+ * - Dev: path-based IDs (no forceBuild), separate cacheDir
+ * - Build: hashed IDs (forceBuild), hashClientRefs for production bundles
+ *
+ * Returns the ViteDevServer instance. Callers access .environments.rsc as needed.
+ * @internal Exported for tests.
+ */
+export declare function createTempRscServer(state: DiscoveryState, options?: {
+    forceBuild?: boolean;
+    cacheDir?: string;
+    /**
+     * Serve the REAL rango SSR entry (getVirtualEntrySSR) for
+     * "virtual:entry-ssr" instead of the discovery stub, so the dev
+     * /__rsc_shell endpoint can drive captureShellHTML in this server's SSR
+     * realm. Dev-correct by construction: the entry's bootstrap resolves to
+     * plugin-rsc's stable virtual browser-entry URL, which the MAIN dev
+     * server serves to the browser. Loaded lazily — discovery never imports
+     * the SSR entry, so the temp server stays as light as before until a
+     * shell capture actually runs.
+     */
+    realSsrEntry?: boolean;
+}): Promise<ViteDevServer>;

package/dist/types/vite/utils/prerender-utils.d.ts

@@ -1,3 +1,4 @@
+import type { LiveIntercept } from "../../router/prerender-match.js";
 export declare function encodePathParam(value: unknown): string;
 /**
  * `ctx.reverse` of a build-time `getParams()`. Substitutes like the dev-mode
@@ -25,6 +26,14 @@ export declare function notifyOnError(registry: Map<string, any>, error: unknown
  * URL / handler name for the log line; `elapsed` is the per-entry duration string.
  */
 export declare function resolvePrerenderError(registry: Map<string, any>, error: any, onError: "fail" | "warn", label: string, elapsed: string, phase: "prerender" | "static", routeKey?: string, pathname?: string): void;
+/**
+ * Warn once per router, route and slot (`warned` holds the keys already
+ * warned) that an intercept over a Prerender() route renders live: the build
+ * did not bake it (matchForPrerender `liveIntercepts`), so its handler runs
+ * per request and one that needs BuildContext fails there. A route in an
+ * unnamed include() has an internal key; the warning names its URL instead.
+ */
+export declare function warnLiveIntercepts(warned: Set<string>, routerId: string, routeName: string, urlPath: string, liveIntercepts: readonly LiveIntercept[] | undefined): void;
 /** Build scratch space, relative to the project root. Never shipped. */
 export declare const RANGO_BUILD_DIR = "node_modules/.rangojs-router-build";
 export declare function resetStagedBuildAssets(projectRoot: string): void;

package/dist/types/wire-params.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The router's `_rsc_*` query parameter names, shared by the browser and the
+ * server graph (dependency free): the one module that spells them
+ * (tools/check-internals.mjs rule rsc-param-literal). The browser writes the
+ * partial-request set through browser/wire-protocol.ts writePartialParams.
+ */
+export declare const WIRE: {
+    /** A navigation or prefetch: `true`. */
+    readonly partial: "_rsc_partial";
+    /** The mounted segment ids, comma-joined. */
+    readonly segments: "_rsc_segments";
+    /** A JS server action's id, in place of `partial`. */
+    readonly action: "_rsc_action";
+    /** The client's build version (version-mismatch reload). */
+    readonly version: "_rsc_v";
+    /** The client's router id (app-switch reload). */
+    readonly routerId: "_rsc_rid";
+    /** The rewrite target of the page on screen (#1144). */
+    readonly rewriteTarget: "_rsc_rt";
+    /** A stale request: `true` (router/navigation-snapshot.ts). */
+    readonly stale: "_rsc_stale";
+    /** A fill request (docs/design/prefetch-false.md): `1`. */
+    readonly fill: "_rsc_fill";
+    /** A loader fetch's loader id (rsc/loader-fetch.ts). */
+    readonly loader: "_rsc_loader";
+    /** A loader fetch's params, JSON: a query param, or a form field on a POST. */
+    readonly loaderParams: "_rsc_loader_params";
+    /** The forced-MISS marker of a degraded PPR shell reload (rsc/shell-serve.ts). */
+    readonly shellMiss: "_rsc_shell";
+    /** A connection warmup HEAD request (browser/connection-warmup.ts). */
+    readonly warmup: "_rsc_warmup";
+};
+/** The prefix every name in WIRE starts with. */
+export declare const WIRE_PREFIX = "_rsc_";