@rangojs/router 0.0.0-experimental.f3c21dba → 0.0.0-experimental.f4a8e8de

package/dist/types/vite/plugins/cloudflare-protocol-stub.d.ts

@@ -0,0 +1,64 @@
+import type { Plugin } from "vite";
+/**
+ * `globalThis` key the `cloudflare:workers` stub reads to populate its
+ * `env` export. Router discovery sets this to the resolved `buildEnv`
+ * proxy (from `wrangler.getPlatformProxy()` when `buildEnv: "auto"` is
+ * configured, or a user-supplied object otherwise) before importing the
+ * worker entry, and clears it after discovery disposes the proxy. When
+ * unset, the stub's `env` falls back to `{}`.
+ *
+ * Using `globalThis` is the only cross-module bridge that works here:
+ * the stub's `load` hook returns source text, not a live closure, but
+ * the stub module is evaluated in the same Node process as the
+ * discovery plugin — so reading a global at module-evaluation time
+ * reaches whatever the plugin assigned there. A symbol key would be
+ * cleaner in-process but awkward to name from the stub source.
+ *
+ * @internal
+ */
+export declare const BUILD_ENV_GLOBAL_KEY = "__rango_build_env__";
+/**
+ * Stubs `cloudflare:*` imports for the discovery-time Node Vite server.
+ *
+ * Discovery only evaluates user module top-level code — it never invokes
+ * DurableObject / WorkerEntrypoint / Workflow handlers — so empty base
+ * classes are enough for `class X extends DurableObject {}` declarations
+ * to load in Node, where `cloudflare:*` is otherwise unresolvable.
+ *
+ * Interception point: a transform hook parses source with Rollup's
+ * plugin-context parser (`this.parse`) and rewrites only real import
+ * specifier spans (`import ... from "cloudflare:xxx"`,
+ * `import("cloudflare:xxx")`, `export ... from "cloudflare:xxx"`) to a
+ * plain virtual module name (`virtual:rango-cloudflare-stub-xxx`).
+ * This must be done in transform because Vite's module runner routes
+ * URL-scheme specifiers straight to Node's native ESM loader without
+ * consulting plugin `resolveId` hooks. Using the AST (instead of a
+ * text regex or a permissive lexer) guarantees that strings,
+ * comments, and template literals that merely contain import-like
+ * text are never mutated — the walker only looks at the four import
+ * node types.
+ *
+ * The transform runs on user source AND on compiled node_modules
+ * output: real-world CF packages (e.g. the Cloudflare Agents SDK)
+ * ship compiled JS that contains `import ... from "cloudflare:email"`
+ * and similar, so excluding node_modules would leave those imports
+ * unrewritten. Cost is small because the early exit (`code.includes`)
+ * skips files with no cloudflare: mention.
+ *
+ * The plugin intentionally runs at Vite's default ordering (no
+ * `enforce: "pre"`) so TS/JSX has already been compiled to plain JS
+ * by the time `this.parse` runs — acorn doesn't understand
+ * non-standard syntax.
+ *
+ * `cloudflare:workers`, `cloudflare:email`, `cloudflare:sockets`, and
+ * `cloudflare:workflows` each get curated stubs with the well-known
+ * symbols that appear in top-level `extends` positions. Any other
+ * `cloudflare:*` specifier falls back to an empty default export —
+ * discovery never executes the handlers, so an empty module is safe
+ * for anything the graph pulls in transitively.
+ *
+ * Only registered in the discovery temp server, not the user's runtime
+ * config.
+ * @internal
+ */
+export declare function createCloudflareProtocolStubPlugin(): Plugin;

package/dist/types/vite/plugins/expose-action-id.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "vite";
+/**
+ * Vite plugin that exposes action IDs on server reference functions.
+ *
+ * When React Server Components creates server references via createServerReference(),
+ * the action ID (format: "hash#actionName") is passed as the first argument but not
+ * exposed on the returned function. This plugin transforms the output to attach
+ * the $id property to each server reference function, enabling the router to
+ * identify which action was called during revalidation.
+ *
+ * Server bundles (RSC/SSR) get file paths in $id for filtering (e.g., "src/actions.ts#add").
+ * Client bundles keep hashed IDs for security (e.g., "ec387bc704d4#add").
+ *
+ * Works in:
+ * - Build mode: uses renderChunk to transform bundled chunks
+ * - Dev mode: uses transform with enforce:"post" to transform after RSC plugin
+ */
+export declare function exposeActionId(): Plugin;

package/dist/types/vite/plugins/expose-id-utils.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Normalize path to forward slashes.
+ */
+export declare function normalizePath(p: string): string;
+export declare function hashId(filePath: string, exportName: string): string;
+export declare function makeStubId(filePath: string, exportName: string, isBuild: boolean): string;
+export declare function hashInlineId(filePath: string, fnName: string, index: number): string;
+export interface DetectedImports {
+    loader: boolean;
+    handle: boolean;
+    locationState: boolean;
+    prerenderHandler: boolean;
+    staticHandler: boolean;
+    router: boolean;
+    any: boolean;
+}
+export declare function buildExportMap(program: any): Map<string, string[]>;
+export declare function detectImports(code: string): DetectedImports;
+export declare function skipStringOrComment(code: string, pos: number): number;
+export declare function findMatchingParen(code: string, startPos: number): number;
+export declare function countArgs(code: string, startPos: number, endPos: number): number;
+export declare function findStatementEnd(code: string, pos: number): number;
+export { escapeRegExp } from "../../regex-escape.js";
+/**
+ * Given an index pointing just past a `create*` callee identifier, return the
+ * index of the call's opening `(`, accounting for an optional generic type
+ * argument list `<...>` with arbitrarily nested `<>`. Returns -1 when the next
+ * non-trivia token is neither `<` nor `(` (i.e. not a call site).
+ *
+ * Replaces the single-level `<[^>]*>` regex assumption, which stopped at the
+ * first `>` and so never reached `(` for `createRouter<Config<Env>>(`.
+ *
+ * Whitespace, comments, and strings between the callee and `(` are skipped via
+ * skipStringOrComment. The `<...>` scan only balances angle brackets; it does
+ * not attempt to parse full TS type syntax (sufficient for locating the paren).
+ */
+export declare function findCallParenAfterGenerics(code: string, afterCalleeIndex: number): number;

package/dist/types/vite/plugins/expose-ids/export-analysis.d.ts

@@ -0,0 +1,19 @@
+import type { CreateExportBinding } from "./types.js";
+export declare function isExportOnlyFile(code: string, bindings: CreateExportBinding[]): boolean;
+export declare function countCreateCallsForNames(code: string, fnNames: string[]): number;
+export declare function offsetToLineColumn(code: string, index: number): {
+    line: number;
+    column: number;
+};
+export declare function findUnsupportedCreateCallSites(code: string, fnNames: string[], supportedBindings: CreateExportBinding[]): Array<{
+    line: number;
+    column: number;
+}>;
+export declare function getImportedFnNames(code: string, importedName: string): string[];
+export declare function getCalledIdentifierFromCall(callExpr: any): string | null;
+export declare function collectCreateExportBindingsFallback(code: string, fnNames: string[]): CreateExportBinding[];
+export declare function collectCreateExportBindings(code: string, fnNames: string[], program?: any): CreateExportBinding[];
+export declare function buildUnsupportedShapeWarning(filePath: string, fnName: string, sites?: Array<{
+    line: number;
+    column: number;
+}>): string;

package/dist/types/vite/plugins/expose-ids/handler-transform.d.ts

@@ -0,0 +1,10 @@
+import MagicString from "magic-string";
+import type { HandlerTransformConfig, CreateExportBinding } from "./types.js";
+export declare function transformHandles(bindings: CreateExportBinding[], s: MagicString, filePath: string, isBuild: boolean): boolean;
+export declare function transformLocationState(bindings: CreateExportBinding[], s: MagicString, filePath: string, isBuild: boolean): boolean;
+export declare function generateWholeFileStubs(cfg: HandlerTransformConfig, bindings: CreateExportBinding[], code: string, filePath: string, isBuild: boolean): {
+    code: string;
+    map: null;
+} | null;
+export declare function stubHandlerExprs(cfg: HandlerTransformConfig, bindings: CreateExportBinding[], s: MagicString, filePath: string, isBuild: boolean): boolean;
+export declare function transformHandlerIds(cfg: HandlerTransformConfig, bindings: CreateExportBinding[], s: MagicString, filePath: string, isBuild: boolean): boolean;

package/dist/types/vite/plugins/expose-ids/loader-transform.d.ts

@@ -0,0 +1,8 @@
+import type MagicString from "magic-string";
+import type { CreateExportBinding } from "./types.js";
+export declare function hasCreateLoaderImport(code: string): boolean;
+export declare function generateClientLoaderStubs(bindings: CreateExportBinding[], code: string, filePath: string, isBuild: boolean): {
+    code: string;
+    map?: undefined;
+} | null;
+export declare function transformLoaders(bindings: CreateExportBinding[], s: MagicString, filePath: string, isBuild: boolean): boolean;

package/dist/types/vite/plugins/expose-ids/router-transform.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from "vite";
+import MagicString from "magic-string";
+export declare function transformRouter(code: string, filePath: string, routerFnNames: string[], absolutePath?: string, warn?: (message: string) => void): {
+    code: string;
+    map: ReturnType<MagicString["generateMap"]>;
+} | null;
+/**
+ * Inject stable $$id into createRouter() calls at compile time.
+ * This must be a separate plugin without enforce:"post" because running
+ * at "post" priority changes Vite's dep optimization timing and can cause
+ * ERR_OUTDATED_OPTIMIZED_DEP / React dual-instance issues.
+ */
+export declare function exposeRouterId(): Plugin;

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

@@ -0,0 +1,29 @@
+export interface HandlerTransformConfig {
+    fnName: string;
+    brand: string;
+}
+export interface CreateExportBinding {
+    localName: string;
+    exportNames: string[];
+    callExprStart: number;
+    callOpenParenPos: number;
+    callCloseParenPos: number;
+    argCount: number;
+    statementEnd: number;
+}
+export interface StrictCreateTransformConfig {
+    fnName: "createLoader" | "createHandle" | "createLocationState";
+}
+export declare const PRERENDER_CONFIG: HandlerTransformConfig;
+export declare const STATIC_CONFIG: HandlerTransformConfig;
+export declare const STRICT_CREATE_CONFIGS: StrictCreateTransformConfig[];
+export interface ExposeInternalIdsApi {
+    /** Tracks absolute module IDs that contain prerender handler exports.
+     *  key: absolute module ID (filesystem path)
+     *  value: array of export names (e.g., ["ArticlesIndex", "ArticleDetail"]) */
+    prerenderHandlerModules: Map<string, string[]>;
+    /** Tracks absolute module IDs that contain static handler exports.
+     *  key: absolute module ID (filesystem path)
+     *  value: array of export names (e.g., ["DocsNav", "DocShell"]) */
+    staticHandlerModules: Map<string, string[]>;
+}

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

@@ -0,0 +1,16 @@
+import type { Plugin } from "vite";
+export { exposeRouterId } from "./expose-ids/router-transform.js";
+export type { ExposeInternalIdsApi } from "./expose-ids/types.js";
+/**
+ * Stub export-only loader modules before plugin-rsc reduces scan modules to
+ * imports. The regular post transform remains authoritative outside scan builds.
+ *
+ * Handles and location-state definitions are intentionally excluded: handle
+ * collect functions run in the browser, and location-state definitions are
+ * callable browser objects. Their dependencies must remain visible to non-RSC
+ * validation rather than being hidden behind an opaque scan stub.
+ */
+export declare function createLoaderScanStubPlugin(): Plugin;
+export declare function exposeInternalIds(options?: {
+    forceBuild?: boolean;
+}): Plugin;

package/dist/types/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/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/vite/plugins/server-ref-hashing.d.ts

@@ -0,0 +1,24 @@
+import type { Plugin } from "vite";
+/**
+ * Replace dev-style server-reference ids with their production hashes. The temp
+ * server renders Static/Prerender in a dev/serve Vite server, so plugin-rsc mints
+ * a dev-style id (e.g. "/src/urls/prerender.tsx"); rewriting only the id (group 2)
+ * leaves the hoisted function and its trailing encrypted .bind(...) untouched.
+ * Exported for testing; used by hashServerRefs. Returns null if nothing changed.
+ */
+export declare function transformServerRefs(code: string, projectRoot: string): string | null;
+/**
+ * Server-side analog of hashClientRefs. Runs in the build-discovery temp server
+ * (a dev/serve Vite server, where plugin-rsc mints dev-style ids), rewriting
+ * registerServerReference ids to production hashes AFTER plugin-rsc's
+ * rsc:use-server transform (enforce:"post"), so the Flight serializer bakes the
+ * production hash into the stored prerender/static payloads.
+ *
+ * Without this, a server-created action embedded in a prerendered/static Flight
+ * is stored with a dev-style id that the production hash-keyed server-references
+ * manifest cannot resolve -> "server reference not found" on a build-time-cache
+ * hit. Mirrors hashClientRefs, which already does exactly this for the client
+ * half of the same payload (which is why client refs in stored Flight are
+ * already production hashes while server refs were not).
+ */
+export declare function hashServerRefs(projectRoot: string): Plugin;

package/dist/types/vite/plugins/server-reference-pattern.d.ts

@@ -0,0 +1 @@
+export declare function registerServerReferenceRegex(): RegExp;

package/dist/types/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/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/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/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/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/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/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/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/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/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/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;