@rangojs/router 0.2.0 → 0.4.0

package/dist/types.backup/vite/plugins/expose-internal-ids.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "vite";
+export { exposeRouterId } from "./expose-ids/router-transform.js";
+export type { ExposeInternalIdsApi } from "./expose-ids/types.js";
+export declare function exposeInternalIds(options?: {
+    forceBuild?: boolean;
+}): Plugin;

package/dist/types.backup/vite/plugins/performance-tracks.d.ts

@@ -0,0 +1,25 @@
+/**
+ * React Performance Tracks — RSDW client patch
+ *
+ * Patches the RSDW client so _debugInfo recovery works for plain-object
+ * payloads (our RscPayload shape). Without this, the Server Components
+ * track in Chrome DevTools stays empty.
+ *
+ * React's flushComponentPerformance uses splice(0) to empty _debugInfo
+ * after resolution, then recovers it from the resolved value — but only
+ * for arrays, async iterables, React elements, and lazy types. Since our
+ * RscPayload is a plain object, _debugInfo is lost. This patch relaxes
+ * the check so _debugInfo is recovered from any object.
+ */
+import type { Plugin } from "vite";
+export declare function patchRsdwClientDebugInfoRecovery(code: string): {
+    code: string;
+    debugInfoVar: string | null;
+};
+export declare function performanceTracksOptimizeDepsPlugin(): {
+    name: string;
+    load(id: string): Promise<{
+        code: string;
+    } | null>;
+};
+export declare function performanceTracksPlugin(): Plugin;

package/dist/types.backup/vite/plugins/refresh-cmd.d.ts

@@ -0,0 +1,20 @@
+import type { Plugin } from "vite";
+/**
+ * Vite plugin that triggers a full browser reload from terminal input.
+ *
+ * This plugin is intentionally passive:
+ * - it never enables raw mode on stdin
+ * - it never restores terminal state
+ * - it reacts to Ctrl+R when that raw byte reaches the process
+ * - it also supports safe line-based fallbacks like "e" + Enter
+ *
+ * Usage:
+ * ```ts
+ * import { poke } from "@rangojs/router/vite";
+ *
+ * export default defineConfig({
+ *   plugins: [rango(), poke()],
+ * });
+ * ```
+ */
+export declare function poke(): Plugin;

package/dist/types.backup/vite/plugins/use-cache-transform.d.ts

@@ -0,0 +1,20 @@
+/**
+ * "use cache" Vite Transform Plugin
+ *
+ * Detects "use cache" directives at file-level and function-level,
+ * then wraps exports with registerCachedFunction() from the cache runtime.
+ *
+ * File-level: "use cache" at top of file wraps all exports (except
+ * layout/template default exports which receive children).
+ *
+ * Function-level: "use cache: profileName" inside a function body
+ * hoists the function and wraps it.
+ *
+ * Uses transform helpers from @vitejs/plugin-rsc/transforms:
+ * - hasDirective() for file-level detection
+ * - transformWrapExport() for file-level wrapping
+ * - transformHoistInlineDirective() for function-level hoisting
+ */
+import type { Plugin } from "vite";
+export declare const USE_CACHE_DIRECTIVE_RE: RegExp;
+export declare function useCacheTransform(): Plugin;

package/dist/types.backup/vite/plugins/vercel-output.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Vercel Build Output (Build Output API v3) emitter for `preset: "vercel"`.
+ *
+ * After the full app build, restructures dist/ into .vercel/output:
+ *
+ *   .vercel/output/
+ *     config.json                       routing: static first, else the function
+ *     static/                           dist/client (browser assets, served at /)
+ *     functions/<name>.func/
+ *       .vc-config.json                 Node serverless, response streaming
+ *       index.mjs                       bundled launcher (srvx + @vercel/functions)
+ *       rsc/                            dist/rsc (self-contained RSC server bundle)
+ *       ssr/                            dist/ssr (rsc imports ../ssr/index.js)
+ *
+ * A prebuilt .vercel/output gets no `npm install`, so everything the function
+ * imports must physically live inside the .func directory. This relies on two
+ * things the vercel preset arranges (each is a failure only a real deploy — or
+ * the isolated smoke test — catches, since a local in-place run is masked by the
+ * app's own package.json + node_modules up the tree):
+ *
+ *   1. The rsc/ssr builds are fully bundled (`resolve.noExternal`, set in
+ *      rango.ts for this preset). The node default externalizes node_modules
+ *      deps, which works under `vite preview` but leaves bare imports
+ *      (@vercel/functions, react-dom/server.edge, ...) that have no node_modules
+ *      to resolve against on Vercel.
+ *   2. A `package.json` with `"type": "module"` is written into the .func dir.
+ *      The rsc/ssr bundles are ESM but use a `.js` extension; without a
+ *      type:module in scope the deployed (isolated) function loads them as
+ *      CommonJS and fails on the first `import`.
+ *
+ * The launcher is bundled with srvx (the Web->Node streaming bridge, a
+ * @rangojs/router dependency) and @vercel/functions (resolved from the app)
+ * inlined, keeping the RSC bundle a runtime-relative external.
+ *
+ * Timing: this runs in the `buildApp` hook (order "post"), which fires once
+ * after every environment has built, so dist/{client,rsc,ssr} all exist.
+ * closeBundle is unusable here — it fires per environment, and twice for ssr
+ * (the server-reference scan and the real build), so it would run before
+ * dist/client exists. rango's own prerender/static emitters hardcode dist/rsc,
+ * so we build to dist/ and restructure here rather than retargeting outDir.
+ */
+import type { Plugin } from "vite";
+import type { RangoVercelOptions, VercelPresetOptions } from "../plugin-types.js";
+/**
+ * Reject a non-Node runtime for the vercel preset. The preset only emits a Node
+ * serverless function (launcherType "Nodejs", bundled Node APIs, response
+ * streaming). Vercel's Edge runtime needs a different Build Output primitive
+ * (EdgeFunction, a Web-handler entry, no node_modules) that this assembler does
+ * not produce, so a non-nodejs runtime would emit a config the platform rejects
+ * or mis-runs. Fail fast at build time instead of shipping a broken function.
+ */
+export declare function assertVercelNodeRuntime(runtime: string | undefined): void;
+/**
+ * The function name becomes a `.func` directory segment and the config.json
+ * route `dest` (`/${functionName}`). An empty or space/slash-containing value
+ * would land raw in both, producing a broken function path, so restrict it to a
+ * safe single path segment and fail loudly rather than emit unroutable output.
+ */
+export declare function assertValidVercelFunctionName(functionName: string): void;
+/** The `.vc-config.json` body: a Node serverless function with streaming. */
+export declare function buildVercelVcConfig(vercel: VercelPresetOptions): Record<string, unknown>;
+/**
+ * The Build Output API v3 `config.json` body. Routes, in order: long-cache the
+ * content-hashed assets under `${assetsDir}/` (safe to serve `immutable`;
+ * without this Vercel serves them `max-age=0, must-revalidate` and browsers
+ * re-request every asset on each visit), then the filesystem handler, then
+ * everything to the function. The header route uses `continue: true` so it falls
+ * through to the filesystem handler that actually serves the file.
+ *
+ * Route `src` values are REGEXES on Vercel, so the prefix is regex-escaped
+ * (an unescaped `assetsDir: "static.v2"` would immutable-stamp any
+ * `/static?v2/...` path, including function-rendered pages). An empty
+ * assetsDir (assets at the outDir root) gets no header route at all: there is
+ * no prefix separating hashed from non-hashed files, so fall back to Vercel's
+ * safe default headers. Two accepted edges, matching what other framework
+ * adapters (Astro, SvelteKit) emit: files a user places in
+ * `public/${assetsDir}/` land under the same prefix and are also stamped
+ * immutable (assemble() warns about the collision), and a request for a
+ * MISSING asset falls through to the function whose 404 carries the header.
+ */
+export declare function buildVercelOutputConfig(functionName: string, assetsDir: string): {
+    version: number;
+    routes: unknown[];
+};
+export declare function createVercelOutputPlugin(options: RangoVercelOptions): Plugin;

package/dist/types.backup/vite/plugins/version-injector.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from "vite";
+/**
+ * Plugin that auto-injects VERSION, routes-manifest, and loader-manifest into
+ * custom entry.rsc files. If a custom entry.rsc file uses createRSCHandler but
+ * doesn't pass version, this transform adds the import and property
+ * automatically. It also ensures the routes-manifest and loader-manifest
+ * virtual modules are always imported.
+ *
+ * The loader-manifest import is what makes fetchable loaders resolvable on a
+ * custom worker entry. The virtual RSC entry (getVirtualEntryRSC) imports the
+ * loader manifest itself, but a hand-written entry (e.g. a Cloudflare
+ * worker.rsc.tsx) does not — so without this injection, setLoaderImports() is
+ * never bundled, lazyLoaderImports stays null at runtime, and a fetchable
+ * loader that is never imported by the server graph (not registered via
+ * loader(), reachable only through a client component) cannot be found by the
+ * _rsc_loader endpoint in production. Dev still works because it resolves
+ * loaders by parsing their id into a file path; only production relied on the
+ * manifest, hence the production-only failure this fixes.
+ * @internal
+ */
+export declare function createVersionInjectorPlugin(rscEntryPath: string | undefined): Plugin;

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

@@ -0,0 +1,19 @@
+import { type Plugin } from "vite";
+/**
+ * Plugin providing rsc-router:version virtual module.
+ * Exports VERSION that changes when RSC modules change (dev) or at build time (production).
+ *
+ * The version is used for:
+ * 1. Cache invalidation - CFCacheStore uses VERSION to invalidate stale cache
+ * 2. Version mismatch detection - client sends version, server reloads on mismatch
+ *
+ * In dev mode, the version updates when:
+ * - Server starts (initial version)
+ * - RSC modules change via HMR (triggers version module invalidation)
+ *
+ * Client-only HMR changes don't update the version since they don't affect
+ * server-rendered content or cached RSC payloads.
+ * @internal
+ */
+export declare function createVersionPlugin(): Plugin;
+export declare function isViteDepCachePath(filePath: string | undefined, cacheDir?: string): boolean;

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

@@ -0,0 +1,36 @@
+import type { HeadScriptsOption } from "../plugin-types.js";
+export declare const VIRTUAL_ENTRY_BROWSER: string;
+/**
+ * Generate the virtual SSR entry. `headScripts` mirrors the rango() plugin
+ * option: "preinit" (default) installs the client-reference preinit hook and
+ * lets the SSR handlers convert the bootstrap to `bootstrapModules`;
+ * "preload" omits the hook and pins the handlers to the hint-only strategy.
+ */
+export declare function getVirtualEntrySSR(headScripts?: HeadScriptsOption): string;
+/**
+ * Virtual modules an RSC entry must import at startup to register the data the
+ * request handler needs before the first request arrives:
+ *
+ * - routes-manifest: the pre-generated route map so href()/matching work on a
+ *   cold start (full map in build, in-memory no-op in dev).
+ * - loader-manifest: setLoaderImports() for fetchable loaders. Critical for
+ *   serverless/multi-process deployments and for fetchable loaders reachable
+ *   only through a client component — without it those loaders are never
+ *   registered for the _rsc_loader endpoint and fail in production.
+ *
+ * Single source of truth: both the generated virtual RSC entry below and the
+ * custom-entry injector (version-injector) consume this list, so a new
+ * bootstrap manifest cannot be added to one path and forgotten on the other.
+ * That exact drift (loader-manifest present here but missing from the injector)
+ * is what left fetchable loaders unresolved on custom worker entries.
+ */
+export declare const RSC_ENTRY_BOOTSTRAP_IMPORTS: readonly string[];
+export declare function getVirtualEntryRSC(routerPath: string): string;
+export declare function getVirtualEntryRSCHost(hostEntryPath: string): string;
+export declare const VIRTUAL_IDS: {
+    readonly browser: "virtual:rsc-router/entry.browser.js";
+    readonly ssr: "virtual:rsc-router/entry.ssr.js";
+    readonly rsc: "virtual:rsc-router/entry.rsc.js";
+    readonly version: "@rangojs/router:version";
+};
+export declare function getVirtualVersionContent(version: string): string;

package/dist/types.backup/vite/plugins/virtual-stub-plugin.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "vite";
+/**
+ * Stub plugin that resolves and provides empty exports for virtual modules
+ * that the RSC entry may import but aren't needed for route discovery.
+ * @internal
+ */
+export declare function createVirtualStubPlugin(): Plugin;

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

@@ -0,0 +1,29 @@
+import { type PluginOption } from "vite";
+import type { RangoOptions } from "./plugin-types.js";
+import { hasUseClientDirective } from "./utils/directive-prologue.js";
+export { hasUseClientDirective };
+/**
+ * Vite plugin for @rangojs/router.
+ *
+ * Includes @vitejs/plugin-rsc and all necessary transforms for the router
+ * to function correctly with React Server Components.
+ *
+ * @example Node.js (default)
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [react(), rango()],
+ * });
+ * ```
+ *
+ * @example Cloudflare Workers
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [
+ *     react(),
+ *     rango({ preset: 'cloudflare' }),
+ *     cloudflare({ viteEnvironment: { name: 'rsc' } }),
+ *   ],
+ * });
+ * ```
+ */
+export declare function rango(options?: RangoOptions): Promise<PluginOption[]>;

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

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+import type { Plugin } from "vite";
+import { VIRTUAL_ROUTES_MANIFEST_ID, type PluginOptions } from "./discovery/state.js";
+export { VIRTUAL_ROUTES_MANIFEST_ID };
+/**
+ * Plugin that discovers router instances at dev/build time via the RSC environment.
+ *
+ * Uses `server.environments.rsc.runner.import()` to load the user's router file
+ * with full TS/TSX compilation. This triggers `createRouter()` which populates
+ * the `RouterRegistry`. The plugin then generates manifests for each router.
+ *
+ * In dev mode, this runs in `configureServer` (post-middleware setup).
+ * In build mode, this will run in `buildStart` (future).
+ *
+ * @internal
+ */
+export declare function createRouterDiscoveryPlugin(entryPath: string | undefined, opts?: PluginOptions): Plugin;

package/dist/types.backup/vite/utils/ast-handler-extract.d.ts

@@ -0,0 +1,64 @@
+import type MagicString from "magic-string";
+/** Minimal ESTree Program node — avoids importing from `rollup` (not a direct dep). */
+interface ProgramNode {
+    type: "Program";
+    body: any[];
+}
+export interface HandlerCallSite {
+    callStart: number;
+    callEnd: number;
+    argCount: number;
+    lineNumber: number;
+    calleeName: string;
+    exportInfo: {
+        exportName: string;
+        statementEnd: number;
+    } | null;
+}
+export interface VirtualHandlerEntry {
+    originalModuleId: string;
+    imports: string[];
+    declarations: string[];
+    handlerCode: string;
+    exportName: string;
+}
+/**
+ * Parse the file with Vite's parseAst and find all calls to `fnName`.
+ * Distinguishes between `export const X = fnName(...)` (exportInfo set)
+ * and inline calls like `layout(fnName(...))` (exportInfo null).
+ */
+export declare function findHandlerCalls(code: string, fnName: string, parseAst: (code: string, options?: any) => ProgramNode): HandlerCallSite[];
+export declare function getImportedLocalNames(code: string, importedName: string, parseAst: (code: string, options?: any) => ProgramNode): Set<string>;
+/**
+ * Extract all import declarations from the source as raw text slices.
+ * Copies ALL imports -- Rollup tree-shakes unused ones from virtual modules.
+ */
+export declare function extractImportDeclarations(code: string, parseAst: (code: string, options?: any) => ProgramNode): string[];
+/**
+ * Extract module-level declarations that are safe for inclusion in virtual
+ * modules. "Safe" means the declaration can be eagerly evaluated without
+ * referencing import bindings, preventing TDZ errors in separate chunks.
+ *
+ * Included: function declarations, arrow/function expression inits, and
+ * variable inits that are inert (pure literals, arrays, objects).
+ * Excluded: declarations that reference identifiers at init time (may
+ * reference imports causing TDZ), handler call declarations (circular),
+ * class declarations (field initializers can reference imports).
+ *
+ * Strips export keywords so declarations work as plain locals.
+ * Rollup tree-shakes unused declarations from virtual modules.
+ */
+export declare function extractModuleLevelDeclarations(code: string, parseAst: (code: string, options?: any) => ProgramNode, handlerNames: Set<string>): string[];
+/**
+ * Transform inline handler calls by extracting them into virtual modules.
+ * Only processes inline calls (exportInfo === null); export const calls are
+ * handled by the existing regex fast path.
+ *
+ * Always extracts (dev and build) to keep server-only imports out of non-RSC
+ * environments. The virtual module goes through the standard transform pipeline
+ * automatically -- the existing export const regex path handles it.
+ *
+ * Returns true if any inline calls were transformed.
+ */
+export declare function transformInlineHandlers(fnName: string, virtualPrefix: string, s: MagicString, code: string, filePath: string, virtualRegistry: Map<string, VirtualHandlerEntry>, moduleId: string, parseAst: (code: string, options?: any) => ProgramNode): boolean;
+export {};

package/dist/types.backup/vite/utils/banner.d.ts

@@ -0,0 +1,2 @@
+export declare const rangoVersion: string;
+export declare function printBanner(mode: "dev" | "build" | "preview", preset: string, version: string): void;

package/dist/types.backup/vite/utils/bundle-analysis.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Find matching close paren in bundled code using depth counting.
+ * Uses skipStringOrComment to correctly handle template literals, comments, and nested strings.
+ * @internal Exported for testing only.
+ */
+export declare function findMatchingParenInBundle(code: string, openParenPos: number): number;
+/**
+ * Scan a bundled chunk for handler exports and extract their names + $$id values.
+ * Optionally detects passthrough flag. @internal Exported for testing only.
+ */
+export declare function extractHandlerExportsFromChunk(chunkCode: string, handlerModules: Map<string, string[]>, fnName: string, detectPassthrough: boolean): Array<{
+    name: string;
+    handlerId: string;
+    passthrough: boolean;
+}>;
+/**
+ * Evict handler code from a bundled chunk, replacing full call expressions with stubs.
+ * Returns the modified code and bytes saved, or null if no changes were made.
+ * @internal Exported for testing only.
+ */
+export declare function evictHandlerCode(code: string, exports: Array<{
+    name: string;
+    handlerId: string;
+    passthrough?: boolean;
+}>, fnName: string, brand: string): {
+    code: string;
+    savedBytes: number;
+} | null;

package/dist/types.backup/vite/utils/client-chunks.d.ts

@@ -0,0 +1,55 @@
+import type { ClientChunkMeta, ClientChunks } from "../plugin-types.js";
+/** The callback shape @vitejs/plugin-rsc's `clientChunks` option accepts. */
+export type RscClientChunksFn = (meta: ClientChunkMeta) => string | undefined;
+/**
+ * Build-time context the discovery pass populates and the built-in strategy
+ * reads. It refines how the catch-all (no route-root marker) modules are grouped
+ * without touching marker splits or the shared runtime:
+ *
+ * - `fallbackRefs`: production hashes of the `"use client"` modules a consumer
+ *   registered as `errorBoundary`/`notFoundBoundary` fallbacks. Pulled into a
+ *   dedicated `app-fallback` chunk so the error UI is not co-bundled with the
+ *   very route code it exists to catch failures for (resilience), and so the
+ *   chunk it would otherwise sit in gets named after a real module rather than
+ *   the boundary. Populated by reading each fallback element's client-reference
+ *   `$$id` during discovery (see discover-routers).
+ */
+export interface ClientChunkContext {
+    fallbackRefs: Set<string>;
+}
+/**
+ * Built-in strategy used when `clientChunks: true` (also the default). Splits app
+ * client components by route/feature identity ONLY where it can recognize a route
+ * structure; everywhere else it inherits the default grouping (returns undefined).
+ * This conservatism is what makes it safe as a default:
+ *
+ * - A recognized route structure (`routes/<id>/…`, `app/<id>/…`, `handlers/<id>/…`
+ *   etc.) splits into a per-route chunk `app-<id>`, at any nesting depth.
+ * - A flat `src/components/Button.tsx`, or host sub-apps already split by a dynamic
+ *   `import()` boundary (each app's `serverChunk` differs), get `undefined` and so
+ *   keep `@vitejs/plugin-rsc`'s default `serverChunk` grouping — i.e. NO change
+ *   versus not enabling the option. Returning a parent-dir name here would instead
+ *   merge unrelated modules (e.g. every host app's `components/Layout.tsx` into one
+ *   `app-components`), re-introducing cross-app leakage.
+ *
+ * Resolution order:
+ * 1. Shared runtime (React / router / node_modules) -> `undefined` (never split).
+ * 2. A registered error/notFound fallback (`ctx.fallbackRefs`) -> `app-fallback`,
+ *    regardless of location, so the error UI is decoupled from the happy path.
+ * 3. A {@link ROUTE_ROOT_DIRS} marker with a directory after it -> key on that
+ *    next segment (the route id), robust to any nesting depth.
+ * 4. Otherwise `undefined` (inherit the default `serverChunk` grouping).
+ */
+export declare function directoryClientChunks(meta: ClientChunkMeta, ctx?: ClientChunkContext): string | undefined;
+/**
+ * Resolve a Rango `clientChunks` option into a @vitejs/plugin-rsc `clientChunks`
+ * callback, or `undefined` to leave plugin-rsc on its default (serverChunk)
+ * grouping.
+ *
+ * - `false` / `undefined` -> `undefined` (no override).
+ * - `true`               -> the built-in {@link directoryClientChunks} strategy,
+ *   bound to the discovery-populated {@link ClientChunkContext} (fallback chunk).
+ * - function             -> the user's function, used verbatim (full control; the
+ *   fallback refinement does not apply — the consumer owns the grouping).
+ */
+export declare function resolveClientChunks(option: ClientChunks | undefined, ctx?: ClientChunkContext): RscClientChunksFn | undefined;

package/dist/types.backup/vite/utils/directive-prologue.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Detect a leading `"use client"` (or `'use client'`) directive in a module's
+ * directive prologue, tolerating leading comments/whitespace before it.
+ *
+ * A bare `source.trimStart().startsWith` check only strips whitespace, so a
+ * license banner / `// @ts-nocheck` before the directive would be missed. This
+ * walks the leading ExpressionStatement string-literal directives via the AST
+ * (a leading comment is not a `program.body` node), the single source of truth
+ * shared by both the rango plugin's HMR client-module sniff and the version
+ * plugin's getClientModuleSignature — so the two can never drift on what counts
+ * as a client module.
+ *
+ * Returns false when the source cannot be parsed (a syntactically broken file is
+ * not treated as a client module).
+ */
+export declare function hasUseClientDirective(source: string): boolean;

package/dist/types.backup/vite/utils/forward-user-plugins.d.ts

@@ -0,0 +1,37 @@
+import type { Plugin, ResolvedConfig, UserConfig } from "vite";
+/**
+ * Pick the user's resolution plugins from the resolved plugin list, denylist
+ * framework-owned plugins, keep only those with resolution hooks, and strip
+ * each to its resolution surface. Returns plugin objects safe to drop into the
+ * discovery temp server's `plugins` array.
+ */
+export declare function selectForwardableResolvePlugins(plugins: readonly Plugin[] | undefined): Plugin[];
+/**
+ * The resolution-relevant slice of the user's resolved config that is plain
+ * data (no plugin re-execution): everything under `resolve` that influences
+ * how specifiers map to files, plus `define` and `oxc` so transforms and
+ * compile-time constants match request time.
+ */
+export interface ForwardedRunnerConfig {
+    resolve: UserConfig["resolve"];
+    define: UserConfig["define"];
+    oxc: UserConfig["oxc"];
+}
+/**
+ * Extract the data-only config slice to mirror into the discovery temp server.
+ * `alias` is included here so callers no longer need to thread it separately.
+ *
+ * `tsconfigPaths` is forwarded so Vite 8's native tsconfig `paths` resolution
+ * (a top-level `resolve` flag, off by default) reaches the temp server. The
+ * server is created with `configFile: false` and an explicit, allowlisted
+ * resolve slice, so a flag that is not copied here is simply absent during
+ * discovery — which would make path-aliased imports fail at prerender/static
+ * time the same way unforwarded resolveId plugins did (issue #500).
+ *
+ * `oxc` keeps the user's options but always pins the RSC-required JSX runtime
+ * (automatic, react), since the temp server compiles the handler graph as
+ * React server components regardless of the user's app-level JSX config. Vite 8
+ * replaced the deprecated `esbuild` transform option with `oxc`, so we read and
+ * forward `oxc` exclusively — no `esbuild` field is touched.
+ */
+export declare function pickForwardedRunnerConfig(config: ResolvedConfig): ForwardedRunnerConfig;

package/dist/types.backup/vite/utils/manifest-utils.d.ts

@@ -0,0 +1,7 @@
+export { flattenLeafEntries, buildRouteToStaticPrefix, } from "../../build/prefix-tree-utils.js";
+/**
+ * Wrap a value as `JSON.parse('...')` instead of a JS object literal.
+ * V8's JSON parser is significantly faster than its full JS parser for large
+ * objects, so this improves startup time for big route manifests.
+ */
+export declare function jsonParseExpression(value: unknown): string;

package/dist/types.backup/vite/utils/package-resolution.d.ts

@@ -0,0 +1,6 @@
+export declare function getPublishedPackageName(): string;
+export declare function isInstalledFromNpm(): boolean;
+export declare function isWorkspaceDevelopment(): boolean;
+export declare function getExcludeDeps(): string[];
+export declare function getPackageAliases(): Record<string, string>;
+export declare function getVendorAliases(): Record<string, string>;

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

@@ -0,0 +1,32 @@
+export declare function encodePathParam(value: unknown): string;
+export declare function substituteRouteParams(pattern: string, params: Record<string, string>, encode?: (value: string) => string): string;
+export declare function runWithConcurrency<T>(items: T[], concurrency: number, fn: (item: T) => Promise<void>): Promise<void>;
+export declare function groupByConcurrency<T extends {
+    concurrency: number;
+}>(entries: T[]): {
+    concurrency: number;
+    entries: T[];
+}[];
+export declare function notifyOnError(registry: Map<string, any>, error: unknown, phase: "prerender" | "static", routeKey?: string, pathname?: string, skipped?: boolean): void;
+/**
+ * Resolve a thrown build-time render error into the prerender build's policy and
+ * log a per-entry line. A `Skip` (or any render error under `prerender.onError:
+ * "warn"`) logs and returns so the caller skips the entry; a render error under
+ * the default "fail" logs FAIL, notifies `onError`, and re-throws to fail the
+ * build. Shared by `expandPrerenderRoutes` (prerender) and `renderStaticHandlers`
+ * (static) so the Skip/warn/fail policy lives in one place. `label` is the padded
+ * 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;
+export declare function resetStagedBuildAssets(projectRoot: string): void;
+/**
+ * Write one content-hashed `export default <value>;` asset module into `dir`
+ * (created if needed) and return its file name. Identical payloads dedupe to
+ * one file (the hash is the content). Shared by the staged prerender/static
+ * flow (stageBuildAssetModule below) and the shell prerender phase, which
+ * writes directly into the final RSC assets dir — it runs after buildApp,
+ * past the staging/copy window.
+ */
+export declare function writeBuildAssetModule(dir: string, prefix: "__pr" | "__st" | "__ps", exportValue: string): string;
+export declare function stageBuildAssetModule(projectRoot: string, prefix: "__pr" | "__st", exportValue: string): string;
+export declare function copyStagedBuildAssets(projectRoot: string, fileNames: Iterable<string>): number;

package/dist/types.backup/vite/utils/shared-utils.d.ts

@@ -0,0 +1,55 @@
+import type { Plugin, ResolvedConfig } from "vite";
+import * as Vite from "vite";
+import type { HeadScriptsOption } from "../plugin-types.js";
+export declare function resolveRscEntryFromConfig(config: ResolvedConfig): string | undefined;
+/**
+ * Shared Rolldown options for dependency optimization (Vite 8).
+ * Includes the version stub plugin and the performance-tracks RSDW patch.
+ */
+export declare const sharedRolldownOptions: {
+    plugins: any[];
+};
+/**
+ * Normalize an explicit `hostRouter` option into the specifier emitted as the
+ * host entry's `import ... from "<path>"`, and — for the forms that resolve
+ * unambiguously against the project root — verify the file exists (failing with
+ * a rango message instead of a downstream bundler "failed to resolve").
+ *
+ * Only a BARE specifier ("src/worker.rsc.tsx") that exists under the root is
+ * rewritten (to "./src/...") so it is not read as a package. A bare specifier
+ * that does NOT exist under the root is passed through VERBATIM: it may be a
+ * Vite alias ("@/worker.rsc.tsx"), an imports-map entry ("#app/worker"), or a
+ * workspace package the bundler resolves — rewriting or rejecting those was a
+ * regression (aliases worked before normalization existed). "./"/"../", a
+ * leading-slash (Vite root-relative), and a filesystem-absolute path are
+ * emitted unchanged — Vite resolves each. A leading-slash path and a
+ * filesystem-absolute path are indistinguishable on POSIX, so both are treated
+ * as "rooted": passed through WITHOUT an existence check (guessing between the
+ * two would wrongly reject a valid file — this was a regression the first time
+ * the check was added). Only the explicitly-relative forms, which resolve
+ * unambiguously against the root, fail fast with a rango message.
+ *
+ * `exists` is injected so the logic is unit-testable without a real filesystem.
+ */
+export declare function normalizeHostRouterEntry(rawInput: string, root: string, exists: (absPath: string) => boolean): string;
+/**
+ * Create a virtual modules plugin for default entry files.
+ * Provides virtual module content when entries use VIRTUAL_IDS (no custom entry configured).
+ */
+export declare function createVirtualEntriesPlugin(entries: {
+    client: string;
+    ssr: string;
+    rsc?: string;
+}, routerPathRef?: {
+    path?: string;
+    kind?: "router" | "host";
+}, options?: {
+    headScripts?: HeadScriptsOption;
+}): Plugin;
+/**
+ * Suppress known harmless warnings: "use client" directives, sourcemap errors,
+ * mixed imports (expected for router internals), empty bundles, and content-hashed
+ * asset collisions from @vitejs/plugin-rsc copying RSC-env assets to the client bundle.
+ */
+export declare function onwarn(warning: Vite.Rollup.RollupLog, defaultHandler: (warning: Vite.Rollup.RollupLog) => void): void;
+export declare function getManualChunks(id: string): string | undefined;

package/dist/vite/index.js

@@ -2530,7 +2530,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.2.0",
+  version: "0.4.0",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -4715,10 +4715,13 @@ var PUSH_CALLBACK_SCOPE_KEY = /* @__PURE__ */ Symbol.for(
 );
 var pushCallbackScopeALS = globalThis[PUSH_CALLBACK_SCOPE_KEY] ??= new AsyncLocalStorage();
 
+// src/rsc/shell-capture-constants.ts
+var SHELL_CAPTURE_MAX_WAIT_MS = 15e3;
+
 // src/rsc/shell-serve.ts
 var DEV_SHELL_PROBE_TIMEOUT_MS = 1e4;
 function normalizeCaptureTimeout(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 1 ? value : void 0;
+  return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.min(value, SHELL_CAPTURE_MAX_WAIT_MS) : void 0;
 }
 
 // src/vite/inject-client-debug.ts