@rangojs/router 0.22.1 → 0.24.0

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

@@ -158,6 +158,15 @@ export interface ResolvedSegment {
      */
     awaitBeforeFlush?: true;
     parallelLoading?: ReactNode;
+    /**
+     * A prefetch skipped this segment's work (`prefetch: false`): a loader
+     * carries no `loaderData`, a layout/route/parallel unit carries
+     * `component: null` and its fallback. The browser shows the fallback and
+     * sends a fill request for it (browser/partial-update.ts); until that
+     * lands the segment is a placeholder, never a held copy. Only ever on a
+     * prefetch response: see docs/design/prefetch-false.md.
+     */
+    deferred?: true;
     loaderDataPromise?: Promise<any[]> | any[];
     loaderIds?: string[];
     /**
@@ -228,10 +237,12 @@ export interface MatchResult {
     /**
      * Every segment id whose handler actually ran on the server this request,
      * including ones with `component === null` that get filtered out of
-     * `segments`/`diff` to avoid wasted bytes. Drives the client's handle-
-     * cleanup pass — a slot that re-resolves and pushes nothing must clear
-     * its previous handle bucket, but `diff` doesn't carry it because the
-     * segment payload doesn't either. A superset of `diff`.
+     * `segments`/`diff` to avoid wasted bytes, and every loader segment that
+     * ran. Drives the client's handle merge (handles/pushed-by.ts) — a slot
+     * that re-resolves and pushes nothing must clear its previous handle
+     * bucket, but `diff` doesn't carry it because the segment payload doesn't
+     * either; a loader that ran replaces its pushes, one that did not keeps
+     * them. A superset of `diff`.
      */
     resolvedIds: string[];
     /**
@@ -279,3 +290,9 @@ export interface MatchResult {
         params: Record<string, string>;
     }>;
 }
+/**
+ * A `prefetch: false` placeholder (ResolvedSegment.deferred): a segment whose
+ * work a prefetch skipped, waiting for its fill. Never a held copy of the
+ * segment it stands for.
+ */
+export declare function isPlaceholder(segment: Pick<ResolvedSegment, "deferred">): boolean;

package/dist/types/urls/path-helper-types.d.ts

@@ -1,6 +1,6 @@
 import type { ReactNode } from "react";
 import type { ErrorBoundaryHandler, ExtractParams, Handler, HandlerContext, LoaderDefinition, LoaderOptions, MiddlewareFn, NotFoundBoundaryHandler, PartialCacheOptions, ShouldRevalidateFn, TransitionConfig } from "../types.js";
-import type { AllUseItems, TypedLayoutItem, ParallelItem, InterceptItem, MiddlewareItem, RevalidateItem, LoaderItem, LoadingItem, ErrorBoundaryItem, NotFoundBoundaryItem, LayoutUseItem, RouteUseItem, ResponseRouteUseItem, ParallelUseItem, InterceptUseItem, LoaderUseItem, TypedCacheItem, TransitionItem, TypedTransitionItem, TypedRouteItem, TypedIncludeItem, UseItems } from "../route-types.js";
+import type { AllUseItems, TypedLayoutItem, ParallelItem, InterceptItem, MiddlewareItem, RevalidateItem, LoaderItem, LoadingItem, ErrorBoundaryItem, NotFoundBoundaryItem, LayoutUseItem, RouteUseItem, ResponseRouteUseItem, ParallelUseItem, InterceptUseItem, LoaderUseItem, TypedCacheItem, TypedTransitionItem, TypedRouteItem, TypedIncludeItem, UseItems } from "../route-types.js";
 import type { SearchSchema } from "../search-params.js";
 import type { PrerenderHandlerDefinition, PassthroughHandlerDefinition } from "../prerender.js";
 import type { StaticHandlerDefinition, StaticHandlerRef } from "../static-handler.js";
@@ -158,13 +158,34 @@ export type PathHelpers<TEnv> = {
      * flag BAKES: the loader executes at shell capture and its settled return
      * freezes into the shell (nested promises stay live holes) — the pre-flush
      * promise applied to the prelude.
+     *
+     * Pass `{ prefetch: false }` to keep the loader out of prefetches: a
+     * prefetch skips it and the click that adopts the prefetch fetches it in
+     * one follow-up request (see {@link LoaderOptions}). Only on a segment the
+     * client does not have yet: a loader the client already holds runs in the
+     * prefetch when it revalidates.
      */
     loader: <TData>(loaderDef: LoaderDefinition<TData>, optionsOrUse?: LoaderOptions | (() => LoaderUseItem[]), use?: () => LoaderUseItem[]) => LoaderItem;
     /**
-     * Attach a loading component to the current route/layout
+     * Attach a loading component to the current route/layout.
+     *
+     * `{ ssr: false }` skips the fallback on document requests. `{ prefetch:
+     * false }` keeps what the fallback covers out of prefetches, when this
+     * entry's segment is new to the client: the entry's handler, its loaders,
+     * its orphan layouts and parallel slots and, for a layout, every deeper
+     * entry. The click that adopts the prefetch shows the fallback and fetches
+     * them in one follow-up request, which reads cache() and "use cache" as
+     * any request does (a prefetch reads neither for skipped work). A segment
+     * the client already holds is never deferred: a prefetch renders it as
+     * usual when it revalidates, and what is below it follows its own flags.
+     * To keep a child out of prefetches while moving inside a section, flag
+     * the child's own loading(). An entry whose handler output is stored
+     * (cache(), ppr, Prerender/Static) is served as usual and only its loaders
+     * are skipped.
      */
     loading: (component: ReactNode | (() => ReactNode), options?: {
         ssr?: boolean;
+        prefetch?: boolean;
     }) => LoadingItem;
     /**
      * Attach an error boundary to catch errors in this segment
@@ -199,8 +220,8 @@ export type PathHelpers<TEnv> = {
      * the browser (never on the server); see TransitionWhenFn.
      */
     transition: {
-        (): TransitionItem;
-        (config: TransitionConfig): TransitionItem;
+        (): TypedTransitionItem<{}, {}>;
+        (config: TransitionConfig): TypedTransitionItem<{}, {}>;
         <const TChildren extends readonly (AllUseItems | readonly AllUseItems[])[]>(children: () => TChildren): TypedTransitionItem<ExtractRoutes<TChildren>, ExtractResponses<TChildren>>;
         <const TChildren extends readonly (AllUseItems | readonly AllUseItems[])[]>(config: TransitionConfig, children: () => TChildren): TypedTransitionItem<ExtractRoutes<TChildren>, ExtractResponses<TChildren>>;
     };

package/dist/types/urls/type-extraction.d.ts

@@ -1,6 +1,10 @@
 import type { JsonSerialize } from "../serialize.js";
 import type { TypedRouteItem, TypedIncludeItem, TypedLayoutItem, TypedCacheItem, TypedTransitionItem } from "../route-types.js";
 import type { LocalOnlyInclude, UnnamedRoute } from "./pattern-types.js";
+/** Drops string index signatures, keeping literal and template keys. */
+type StripStringIndex<T> = {
+    [K in keyof T as string extends K ? never : K]: T[K];
+};
 /**
  * Prefix route names with a given prefix (e.g., "blog" + "post" = "blog.post")
  *
@@ -52,7 +56,7 @@ type ExtractRoutesFromItem<T> = T extends TypedRouteItem<infer TName, infer TPat
         readonly path: TPattern;
         readonly search: TSearch;
     };
-} : {} : T extends TypedIncludeItem<infer TRoutes, infer TNamePrefix, infer TUrlPrefix> ? TNamePrefix extends LocalOnlyInclude ? {} : TNamePrefix extends string ? TUrlPrefix extends string ? PrefixRoutes<PrefixPatterns<TRoutes, TUrlPrefix>, TNamePrefix> : PrefixRoutes<TRoutes, TNamePrefix> : TUrlPrefix extends string ? PrefixPatterns<TRoutes, TUrlPrefix> : TRoutes : T extends TypedLayoutItem<infer TChildRoutes> ? TChildRoutes : T extends TypedCacheItem<infer TChildRoutes> ? TChildRoutes : T extends TypedTransitionItem<infer TChildRoutes> ? TChildRoutes : {};
+} : {} : T extends TypedIncludeItem<infer TRoutes, infer TNamePrefix, infer TUrlPrefix> ? TNamePrefix extends LocalOnlyInclude ? {} : TNamePrefix extends string ? TUrlPrefix extends string ? PrefixRoutes<PrefixPatterns<TRoutes, TUrlPrefix>, TNamePrefix> : PrefixRoutes<TRoutes, TNamePrefix> : TUrlPrefix extends string ? PrefixPatterns<TRoutes, TUrlPrefix> : TRoutes : T extends TypedLayoutItem<infer TChildRoutes> ? StripStringIndex<TChildRoutes> : T extends TypedCacheItem<infer TChildRoutes> ? StripStringIndex<TChildRoutes> : T extends TypedTransitionItem<infer TChildRoutes> ? StripStringIndex<TChildRoutes> : {};
 /**
  * Extract routes from an array of items using mapped types.
  * Uses UnionToIntersection to combine routes without recursive tuple processing,
@@ -82,7 +86,7 @@ type PrefixKeys<T extends Record<string, unknown>, TPrefix extends string> = TPr
  */
 type ExtractResponsesFromItem<T> = T extends TypedRouteItem<infer TName, any, infer TData> ? TName extends string ? string extends TName ? {} : TName extends UnnamedRoute ? {} : {
     [K in TName]: TData;
-} : {} : T extends TypedIncludeItem<any, infer TNamePrefix, any, infer TResponses> ? TNamePrefix extends LocalOnlyInclude ? {} : TNamePrefix extends string ? TResponses extends Record<string, unknown> ? PrefixKeys<TResponses, TNamePrefix> : {} : TResponses extends Record<string, unknown> ? TResponses : {} : T extends TypedLayoutItem<any, infer TChildResponses> ? TChildResponses extends Record<string, unknown> ? TChildResponses : {} : T extends TypedCacheItem<any, infer TChildResponses> ? TChildResponses extends Record<string, unknown> ? TChildResponses : {} : T extends TypedTransitionItem<any, infer TChildResponses> ? TChildResponses extends Record<string, unknown> ? TChildResponses : {} : {};
+} : {} : T extends TypedIncludeItem<any, infer TNamePrefix, any, infer TResponses> ? TNamePrefix extends LocalOnlyInclude ? {} : TNamePrefix extends string ? TResponses extends Record<string, unknown> ? PrefixKeys<TResponses, TNamePrefix> : {} : TResponses extends Record<string, unknown> ? TResponses : {} : T extends TypedLayoutItem<any, infer TChildResponses> ? StripStringIndex<TChildResponses> extends infer R extends Record<string, unknown> ? R : {} : T extends TypedCacheItem<any, infer TChildResponses> ? StripStringIndex<TChildResponses> extends infer R extends Record<string, unknown> ? R : {} : T extends TypedTransitionItem<any, infer TChildResponses> ? StripStringIndex<TChildResponses> extends infer R extends Record<string, unknown> ? R : {} : {};
 /**
  * Extract responses from an array of items using mapped types.
  * Parallel to ExtractRoutesFromItems.

package/dist/types/vite/discovery/discover-routers.d.ts

@@ -13,5 +13,14 @@ import type { DiscoveryState } from "./state.js";
  *
  * Returns the imported `@rangojs/router/server` module so the caller
  * can access the RouterRegistry and manifest setters.
+ *
+ * A pass reads the router registry and installs clientUrls projections on ONE
+ * `@rangojs/router/server` instance, and checks that the runner still serves
+ * it. A runner full reload during the pass (a watched-file change at boot)
+ * splits the realm: a router module bound to the old instance registers there
+ * while urls modules re-evaluate against a fresh one, so include() looks its
+ * projection up in the fresh, empty Map ("include() could not resolve the
+ * server projection"). Such a pass is redone, at most
+ * MAX_DISCOVERY_PASSES times; the redo evaluates the entry in one realm.
  */
 export declare function discoverRouters(state: DiscoveryState, rscEnv: any, ssrEnv?: any): Promise<any>;

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

@@ -188,14 +188,24 @@ export interface DiscoveryState {
     /** Cleanup function for build-time env resources (e.g., miniflare). */
     buildEnvDispose?: (() => Promise<void> | void) | null;
     /**
-     * Set when the most recent HMR re-discovery threw. Cleared on the next
-     * successful discovery. Surfaced via debug logs so we can detect "manifest
-     * frozen at last-good after error → user fix in non-route file → no
-     * rediscovery trigger" scenarios.
+     * Set when the most recent dev discovery failed: an HMR re-discovery, or the
+     * cold discovery on the Node RSC runner or the Cloudflare temp runner.
+     * Cleared on the next successful discovery. While set, the route-file
+     * watcher treats any in-scan source change as a rediscovery trigger
+     * (recovery mode).
      */
     lastDiscoveryError?: {
         message: string;
         at: number;
     } | null;
 }
+/** Record a failed dev discovery (lastDiscoveryError): recovery mode. */
+export declare function recordDiscoveryFailure(state: Pick<DiscoveryState, "lastDiscoveryError">, err: unknown): void;
+/**
+ * Whether the route-file watcher can re-run runtime discovery: a committed
+ * manifest, or a recorded failure. A failed cold discovery commits none, and
+ * without its recorded failure the dev server stayed broken until a restart,
+ * on the Node runner and on Cloudflare alike.
+ */
+export declare function canRefreshRuntimeDiscovery(state: Pick<DiscoveryState, "perRouterManifests" | "lastDiscoveryError">): boolean;
 export declare function createDiscoveryState(entryPath: string | undefined, opts: PluginOptions | undefined): DiscoveryState & ClientUrlDiscoveryState;

package/dist/types/vite/plugins/client-urls-revalidate-hoist.d.ts

@@ -0,0 +1,54 @@
+import type { Plugin } from "vite";
+import MagicString from "magic-string";
+/**
+ * The key of the predicate `source` declared in `relativeFile` (relative to
+ * the project root): a hash of the file and the predicate's syntax, so the
+ * same predicate gets one key in every environment and however it is
+ * formatted.
+ */
+export declare function revalidateKey(relativeFile: string, source: string): string;
+interface HoistClientUrlsRevalidateDeps {
+    /** Project root: keys hash the file relative to it. */
+    readonly root: string;
+    /**
+     * Whether a module a predicate imports is a "use client" module beyond its
+     * specifier (the plugin resolves it and reads its directive prologue).
+     */
+    isClientModule?(source: string): Promise<boolean> | boolean;
+}
+interface HoistClientUrlsRevalidateResult {
+    /** The module with each predicate replaced by its marker. */
+    readonly code: string;
+    readonly map: ReturnType<MagicString["generateMap"]>;
+    /** The server module that registers every hoisted predicate. */
+    readonly module: string;
+    /** The keys, in declaration order, duplicates removed. */
+    readonly keys: readonly string[];
+}
+/**
+ * Hoist every clientUrls() `revalidate()` predicate of a "use client"
+ * module. Returns null when there is none. Throws, naming file:line, for a
+ * predicate that is not pure.
+ */
+export declare function hoistClientUrlsRevalidates(code: string, id: string, deps: HoistClientUrlsRevalidateDeps): Promise<HoistClientUrlsRevalidateResult | null>;
+/** The file a `?rango-revalidate` id names, or null. */
+export declare function parseHoistedRevalidateId(id: string): string | null;
+/**
+ * The plugins: a pre transform that hoists in every environment (markers in
+ * the client and SSR copies, the server module recorded from the RSC
+ * transform) and serves `?rango-revalidate`, and a post transform that
+ * appends its import to the RSC client-reference proxy.
+ *
+ * `load` serves the module the RSC transform emitted, which hoisted the
+ * pipeline code; the disk source is re-hoisted only when the transform has
+ * not seen the current file (loadEmittedOrDisk). A file whose edit removed
+ * every predicate serves an empty module to a proxy that still imports it.
+ *
+ * The transform's code filter skips a module that never mentions clientUrls,
+ * so a file that stops doing so would keep its `emitted` entry: watchChange
+ * drops it, together with the cached "use client" answer for an edited
+ * dependency (isClientModule memoizes per resolved file; buildStart resets
+ * it).
+ */
+export declare function clientUrlsRevalidateHoistPlugin(): Plugin[];
+export {};

package/dist/types/vite/plugins/hoist/literal.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Literal-level helpers shared by the build-time predicate hoists
+ * (transition-when-hoist.ts moves a `when` from a server module into a
+ * "use client" one; client-urls-revalidate-hoist.ts moves a `revalidate()`
+ * from a "use client" module into a server one): finding a urls-callback
+ * helper's calls, the lexical-capture check, and the free imports a literal
+ * re-emits in its new module.
+ */
+import { type ImportBinding, type Node, type Reference, type Scope } from "./scope.js";
+/** The offset after the directive prologue (0 when there is none). */
+export declare function directivePrologueEnd(program: Node): number;
+export declare function parseLang(file: string): "ts" | "tsx" | "jsx";
+export declare function unwrapExpression(node: Node): Node;
+export declare function isFunctionLiteral(node: Node): boolean;
+export declare function propertyKeyIs(prop: Node, name: string): boolean;
+/** Which helper calls {@link findHelperCalls} looks for. */
+interface HelperCallSpec {
+    /** Module specifiers the builder (and a direct helper import) come from. */
+    readonly sources: ReadonlySet<string>;
+    /** The builder export whose callback's first parameter hands out `helper`. */
+    readonly builder: string;
+    readonly helper: string;
+    /** A direct import of `helper` from `sources` counts too. */
+    readonly directImport: boolean;
+}
+interface HelperCall {
+    readonly call: Node;
+    readonly scope: Scope;
+}
+/**
+ * Every call of `spec.helper` the builder's callback hands out: destructured,
+ * renamed or as `helpers.<helper>`, at any depth of the callback, plus a
+ * direct import when `spec.directImport`. A builder is recognised by its
+ * import (named, renamed, or through a namespace); any other function of the
+ * same name is left alone.
+ */
+export declare function findHelperCalls(program: Node, scopeOf: Map<Node, Scope>, moduleScope: Scope, imports: Map<string, ImportBinding>, spec: HelperCallSpec): HelperCall[];
+/**
+ * What a lexical-capture error says, per hoist direction. `lexical` explains
+ * each construct (`this`, `arguments`, `super`, `new.target`); `captureHint`
+ * and `loadsHint` follow every capture and module-load message;
+ * `importMetaWhy`, `importMetaMemberWhy` and `dynamicImportWhy` explain the
+ * module-loading expressions.
+ */
+export interface LexicalCaptureMessages {
+    readonly lexical: Readonly<Record<string, string>>;
+    readonly captureHint: string;
+    readonly loadsHint: string;
+    readonly importMetaWhy: string;
+    readonly importMetaMemberWhy: string;
+    readonly dynamicImportWhy: string;
+}
+/**
+ * The first use in a literal of a lexical context it would lose when hoisted
+ * (`this`, `arguments`, `super`, `new.target` of an enclosing function or
+ * object), or of a module-loading expression the build cannot check
+ * (`import()`, `import.meta` other than `import.meta.env`). A nested
+ * non-arrow function (or class body) owns its `this`/`arguments`, so uses
+ * inside one are fine; a method literal owns them too, but its `super`
+ * loses the object it was defined on.
+ */
+export declare function findLexicalCapture(literal: Node, references: readonly Reference[], code: string, messages: LexicalCaptureMessages): {
+    node: Node;
+    detail: string;
+} | null;
+/** The free references of a literal, by what they resolve to. */
+interface FreeReferences {
+    /** Import local name -> whether any use is a value use. */
+    readonly imports: Map<string, boolean>;
+    /** Value references to a binding declared outside the literal that is not an import. */
+    readonly bindings: readonly Reference[];
+    /** References declared nowhere (window, URL, console, ...). */
+    readonly globals: readonly Reference[];
+}
+/** Every reference inside `literal` to something declared outside it. */
+export declare function collectFreeReferences(literal: Node, references: readonly Reference[], moduleScope: Scope, imports: Map<string, ImportBinding>): FreeReferences;
+/**
+ * Re-emit the imports a literal uses, grouped per source, type-only uses as
+ * `import type`. `checkValueImport` runs first for each value use and throws
+ * to reject one.
+ */
+export declare function emitImports(used: Map<string, boolean>, imports: Map<string, ImportBinding>, checkValueImport: (local: string, binding: ImportBinding) => Promise<void> | void): Promise<string[]>;
+export {};

package/dist/types/vite/plugins/hoist/scope.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Scope analysis shared by the build-time predicate hoists
+ * (transition-when-hoist.ts, client-urls-revalidate-hoist.ts): a module's
+ * scope tree, every identifier reference, and its imports. Enough of ES
+ * scoping for the free-variable analysis of one literal.
+ */
+export type Node = any;
+export interface ImportBinding {
+    readonly source: string;
+    /** "default", "*", or the imported name. */
+    readonly imported: string;
+    readonly typeOnly: boolean;
+}
+export declare class Scope {
+    readonly parent: Scope | null;
+    readonly isFunction: boolean;
+    readonly node: Node;
+    readonly declarations: Set<string>;
+    constructor(parent: Scope | null, isFunction: boolean, node: Node);
+    nearestFunction(): Scope;
+    lookup(name: string): Scope | null;
+}
+export interface Reference {
+    readonly node: Node;
+    readonly scope: Scope;
+    readonly typeOnly: boolean;
+}
+export declare const TYPE_KEYS: ReadonlySet<string>;
+/**
+ * Scope tree and every identifier reference of a module, TS type positions
+ * flagged. Enough of ES scoping for free-variable analysis of one literal:
+ * var hoists to the function scope, let/const/class to the block, function
+ * declarations to their block.
+ */
+export declare function analyzeScopes(program: Node): {
+    moduleScope: Scope;
+    references: Reference[];
+    scopeOf: Map<Node, Scope>;
+};
+export declare function collectImports(program: Node): Map<string, ImportBinding>;

package/dist/types/vite/plugins/hoist/source.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Source reading shared by the build-time predicate hoists
+ * (transition-when-hoist.ts, client-urls-revalidate-hoist.ts): which ids are
+ * source files, reading one off disk, resolving an import to the file it
+ * names, and the "emitted or disk" lookup behind their `?rango-*` modules.
+ */
+/** A file path (query already stripped) a hoist transform may rewrite. */
+export declare const SOURCE_FILE_RE: RegExp;
+export declare function readSource(file: string): Promise<string | null>;
+/** The part of a plugin context {@link resolveSourceTarget} needs. */
+export interface SourceResolver {
+    resolve(source: string, importer?: string): Promise<{
+        id: string;
+        external?: boolean | string;
+    } | null>;
+}
+/**
+ * The file `source` names when imported from `importer`, query stripped, or
+ * null when it is external or virtual. `skipNodeModules` also yields null for
+ * a dependency: transition-when-hoist only looks for `import "server-only"`
+ * in project files, while client-urls-revalidate-hoist must see the
+ * "use client" directive of a package's modules too.
+ */
+export declare function resolveSourceTarget(ctx: SourceResolver, source: string, importer: string, options: {
+    readonly skipNodeModules: boolean;
+}): Promise<string | null>;
+/** What a hoist's RSC transform emitted for a file, and the disk source it saw. */
+export interface EmittedEntry<T> {
+    readonly disk: string | null;
+    readonly value: T;
+}
+export declare function recordEmitted<T>(emitted: Map<string, EmittedEntry<T>>, file: string, value: T): Promise<void>;
+/**
+ * What a `?rango-*` load serves for `hoistedFile`: the transform's emission
+ * when it saw the current disk source (or the file is gone), else
+ * `rehoist(disk)`. The transform hoists the pipeline code, which an earlier
+ * plugin may have changed, so re-hoisting the disk source is the fallback only
+ * for an environment loading before the RSC transform ran or for an edit the
+ * RSC environment has not re-transformed yet. Undefined when neither exists.
+ */
+export declare function loadEmittedOrDisk<T>(emitted: ReadonlyMap<string, EmittedEntry<T>>, hoistedFile: string, rehoist: (disk: string) => Promise<T | undefined>): Promise<T | undefined>;

package/dist/types/vite/plugins/transition-when-hoist.d.ts

@@ -2,14 +2,14 @@ import type { Plugin } from "vite";
 import MagicString from "magic-string";
 /** Specifiers that can never load in the browser. */
 export declare function isServerOnlySpecifier(source: string): boolean;
-export interface HoistTransitionWhenDeps {
+interface HoistTransitionWhenDeps {
     /**
      * Whether an import the literal re-emits is server-only beyond its
      * specifier (the plugin resolves it and looks for `import "server-only"`).
      */
     isServerOnlyImport?(source: string): Promise<boolean> | boolean;
 }
-export interface HoistTransitionWhenResult {
+interface HoistTransitionWhenResult {
     readonly code: string;
     readonly map: ReturnType<MagicString["generateMap"]>;
     /** Virtual module source per hoisted literal, by index. */
@@ -32,14 +32,11 @@ export declare function parseHoistedWhenId(id: string): {
  * evaluated) and serves the `?rango-when=N` modules in every environment
  * (RSC, SSR and client all load them).
  *
- * `load` serves the modules the transform emitted, not a re-hoist of the file
- * on disk: the transform hoists the pipeline code, which an earlier plugin
- * may have changed, so re-hoisting the disk source can number the literals
- * differently and serve the wrong one for index N. The disk source is the
- * fallback only when the transform has not seen the current file: an
- * environment loading before the RSC transform ran (the order environments
- * ask in is not fixed), or an edit the RSC environment has not re-transformed
- * yet (serving the last transform would then be stale). The map is per
- * plugin instance, so every environment of one dev server or build shares it.
+ * `load` serves the modules the transform emitted (loadEmittedOrDisk), not a
+ * re-hoist of the file on disk: re-hoisting a disk source an earlier plugin
+ * changed can number the literals differently and serve the wrong one for
+ * index N. The map is per plugin instance, so every environment of one dev
+ * server or build shares it.
  */
 export declare function transitionWhenHoistPlugin(): Plugin;
+export {};

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

@@ -8,6 +8,16 @@
 import type { Plugin, ViteDevServer } from "vite";
 import { VIRTUAL_ROUTES_MANIFEST_ID, type DiscoveryState, 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.
  *