@rangojs/router 0.32.0 → 0.33.1

package/dist/bin/temp-rsc-server-JALTIWLT.js

@@ -0,0 +1,3190 @@
+import {
+  VIRTUAL_LOADER_MANIFEST_ID
+} from "./chunk-524VACCG.js";
+import {
+  CLIENT_IMPORT_RE,
+  CLIENT_URLS_REVALIDATE_QUERY,
+  HOISTED_REVALIDATE_KEY,
+  NS,
+  TYPE_KEYS,
+  TransitionWhenError,
+  analyzeScopes,
+  collectFreeReferences,
+  collectImports,
+  componentUseSignature,
+  computeProductionHash,
+  createCounter,
+  createRangoDebugger,
+  directivePrologueEnd,
+  emitImports,
+  findHelperCalls,
+  findLexicalCapture,
+  hasUseClientDirective,
+  hashClientRefs,
+  hoistedRevalidateId,
+  isFunctionLiteral,
+  parseLang,
+  propertyKeyIs,
+  recordClientUrlsModule,
+  unwrapExpression
+} from "./chunk-TTXC2U3G.js";
+import "./chunk-3B7CKBRO.js";
+import {
+  codeMatchIndices,
+  isSkippedSourceScanDir
+} from "./chunk-LD7UBHT4.js";
+
+// src/vite/temp-rsc-server.ts
+import { createServer as createViteServer } from "vite";
+import { register } from "node:module";
+
+// src/vite/plugins/version-plugin.ts
+import { parseAst } from "vite";
+
+// src/router-versions.ts
+var DEFAULT_ROUTER_VERSIONS_KEY = "*";
+
+// package.json
+var package_default = {
+  name: "@rangojs/router",
+  version: "0.33.1",
+  description: "Django-inspired RSC router with composable URL patterns",
+  keywords: [
+    "react",
+    "react-server-components",
+    "router",
+    "rsc",
+    "vite"
+  ],
+  homepage: "https://github.com/rangojs/rango#readme",
+  bugs: {
+    url: "https://github.com/rangojs/rango/issues"
+  },
+  license: "MIT",
+  author: "Ivo Todorov",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/rangojs/rango.git",
+    directory: "packages/rangojs-router"
+  },
+  bin: {
+    rango: "./dist/bin/rango.js"
+  },
+  files: [
+    "src",
+    "!src/**/__tests__",
+    "!src/**/__mocks__",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "dist",
+    "skills",
+    "AGENTS.md",
+    "README.md",
+    "LICENSE"
+  ],
+  type: "module",
+  exports: {
+    ".": {
+      types: "./dist/types/index.rsc.d.ts",
+      "react-server": "./src/index.rsc.ts",
+      default: "./src/index.ts"
+    },
+    "./server": {
+      types: "./dist/types/server.d.ts",
+      import: "./src/server.ts"
+    },
+    "./client": {
+      types: "./dist/types/client.d.ts",
+      "react-server": "./src/client.rsc.tsx",
+      default: "./src/client.tsx"
+    },
+    "./browser": {
+      types: "./dist/types/browser/index.d.ts",
+      default: "./src/browser/index.ts"
+    },
+    "./ssr": {
+      types: "./dist/types/ssr/index.d.ts",
+      default: "./src/ssr/index.tsx"
+    },
+    "./rsc": {
+      types: "./dist/types/rsc/index.d.ts",
+      "react-server": "./src/rsc/index.ts",
+      default: "./src/rsc/index.ts"
+    },
+    "./vite": {
+      types: "./dist/types/vite/index.d.ts",
+      import: "./dist/vite/index.js"
+    },
+    "./types": {
+      types: "./src/vite/plugins/version.d.ts"
+    },
+    "./__internal": {
+      types: "./dist/types/__internal.d.ts",
+      default: "./src/__internal.ts"
+    },
+    "./internal/deps/browser": {
+      types: "./dist/types/deps/browser.d.ts",
+      default: "./src/deps/browser.ts"
+    },
+    "./internal/deps/ssr": {
+      types: "./dist/types/deps/ssr.d.ts",
+      default: "./src/deps/ssr.ts"
+    },
+    "./internal/deps/rsc": {
+      types: "./dist/types/deps/rsc.d.ts",
+      "react-server": "./src/deps/rsc.ts",
+      default: "./src/deps/rsc.ts"
+    },
+    "./internal/deps/rsc-client": {
+      types: "./dist/types/deps/rsc-client.d.ts",
+      "react-server": "./src/deps/rsc-client.ts",
+      default: "./src/deps/rsc-client.ts"
+    },
+    "./internal/deps/html-stream-client": {
+      types: "./dist/types/deps/html-stream-client.d.ts",
+      default: "./src/deps/html-stream-client.ts"
+    },
+    "./internal/deps/html-stream-server": {
+      types: "./dist/types/deps/html-stream-server.d.ts",
+      default: "./src/deps/html-stream-server.ts"
+    },
+    "./internal/rsc-handler": {
+      types: "./dist/types/rsc/handler.d.ts",
+      "react-server": "./src/rsc/handler.ts",
+      default: "./src/rsc/handler.ts"
+    },
+    "./internal/browser/dev-discovery": {
+      types: "./dist/types/browser/dev-discovery.d.ts",
+      default: "./src/browser/dev-discovery.ts"
+    },
+    "./cache": {
+      types: "./dist/types/cache/index.d.ts",
+      "react-server": "./src/cache/index.ts",
+      default: "./src/cache/index.ts"
+    },
+    "./cache-runtime": {
+      types: "./dist/types/cache/cache-runtime.d.ts",
+      "react-server": "./src/cache/cache-runtime.ts",
+      default: "./src/cache/cache-runtime.ts"
+    },
+    "./cloudflare": {
+      types: "./dist/types/cloudflare/index.d.ts",
+      "react-server": "./src/cloudflare/index.ts",
+      default: "./src/cloudflare/index.ts"
+    },
+    "./prerender": {
+      types: "./dist/types/prerender/index.d.ts",
+      "react-server": "./src/prerender/index.ts",
+      default: "./src/prerender/index.ts"
+    },
+    "./prerender/cloudflare": {
+      types: "./dist/types/prerender/cloudflare.d.ts",
+      "react-server": "./src/prerender/cloudflare.ts",
+      default: "./src/prerender/cloudflare.ts"
+    },
+    "./vercel": {
+      types: "./dist/types/vercel/index.d.ts",
+      "react-server": "./src/vercel/index.ts",
+      default: "./src/vercel/index.ts"
+    },
+    "./theme": {
+      types: "./dist/types/theme/index.d.ts",
+      default: "./src/theme/index.ts"
+    },
+    "./build": {
+      types: "./dist/types/build/index.d.ts",
+      import: "./src/build/index.ts"
+    },
+    "./build/shell-capture": {
+      types: "./dist/types/prerender/build-shell-capture.d.ts",
+      "react-server": "./src/prerender/build-shell-capture.ts",
+      import: "./src/prerender/build-shell-capture.ts"
+    },
+    "./host": {
+      types: "./dist/types/host/index.d.ts",
+      "react-server": "./src/host/index.ts",
+      default: "./src/host/index.ts"
+    },
+    "./host/testing": {
+      types: "./dist/types/host/testing.d.ts",
+      default: "./src/host/testing.ts"
+    },
+    "./testing": {
+      types: "./dist/types/testing/index.d.ts",
+      default: "./src/testing/index.ts"
+    },
+    "./testing/vitest": {
+      types: "./dist/types/testing/vitest.d.ts",
+      default: "./dist/testing/vitest.js"
+    },
+    "./testing/dom": {
+      types: "./dist/types/testing/dom.entry.d.ts",
+      default: "./src/testing/dom.entry.ts"
+    },
+    "./testing/e2e": {
+      types: "./dist/types/testing/e2e/index.d.ts",
+      default: "./src/testing/e2e/index.ts"
+    },
+    "./testing/flight": {
+      types: "./dist/types/testing/flight.entry.d.ts",
+      "react-server": "./src/testing/flight.entry.ts",
+      default: "./src/testing/flight.entry.ts"
+    },
+    "./testing/flight-matchers": {
+      types: "./dist/types/testing/flight-matchers.d.ts",
+      default: "./src/testing/flight-matchers.ts"
+    }
+  },
+  publishConfig: {
+    access: "public",
+    tag: "latest"
+  },
+  scripts: {
+    build: "pnpm run build:types && pnpm exec esbuild src/vite/index.ts --bundle --format=esm --outfile=dist/vite/index.js --platform=node --packages=external && mkdir -p dist/vite/plugins && cp src/vite/plugins/cloudflare-protocol-loader-hook.mjs dist/vite/plugins/cloudflare-protocol-loader-hook.mjs && pnpm exec esbuild src/testing/vitest.ts --bundle --format=esm --outfile=dist/testing/vitest.js --platform=node --packages=external && rm -rf dist/bin && pnpm exec esbuild src/bin/rango.ts --bundle --format=esm --splitting --outdir=dist/bin --platform=node --packages=external && chmod +x dist/bin/rango.js && mkdir -p dist/bin/plugins && cp src/vite/plugins/cloudflare-protocol-loader-hook.mjs dist/bin/plugins/cloudflare-protocol-loader-hook.mjs",
+    "build:types": "rm -rf dist/types && pnpm exec tsc -p tsconfig.types.json",
+    prepublishOnly: "pnpm build",
+    typecheck: "tsc --noEmit && tsc -p tsconfig.strict-check.json --noEmit && tsc -p tsconfig.augment-check.json --noEmit",
+    test: "playwright test",
+    "test:preload": "playwright test --config=playwright.preload.config.ts",
+    "test:ui": "playwright test --ui",
+    "test:hmr-local": "playwright test --project=dev-warmup --project=hmr-basename --project=hmr-prerender --no-deps --workers=1 && RANGO_E2E_ROUTE_HMR_ONLY=1 playwright test --project=hmr-routes --no-deps --workers=1",
+    "test:hmr-routes-local": "RANGO_E2E_ROUTE_HMR_ONLY=1 playwright test --project=hmr-routes --no-deps --workers=1",
+    "test:unit": "pnpm run build:types && vitest run",
+    "test:unit:watch": "vitest",
+    "test:unit:rsc": "vitest run --config vitest.rsc.config.ts"
+  },
+  dependencies: {
+    "@types/debug": "^4.1.12",
+    "@vitejs/plugin-rsc": "^0.5.38",
+    debug: "^4.4.1",
+    "magic-string": "^0.30.17",
+    picomatch: "^4.0.4",
+    "rsc-html-stream": "^0.0.7",
+    srvx: "^0.11.15",
+    tinyexec: "^0.3.2",
+    typescript: "^5.3.0 || ^6.0.0"
+  },
+  devDependencies: {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/context-async-hooks": "^2.9.0",
+    "@opentelemetry/sdk-trace-base": "^2.9.0",
+    "@playwright/test": "^1.62.0",
+    "@shared/e2e": "workspace:*",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^24.10.1",
+    "@types/react": "catalog:",
+    "@types/react-dom": "catalog:",
+    esbuild: "^0.28.1",
+    "happy-dom": "^20.10.1",
+    jiti: "^2.7.0",
+    react: "catalog:",
+    "react-dom": "catalog:",
+    vitest: "^4.1.11"
+  },
+  peerDependencies: {
+    "@cloudflare/vite-plugin": "^1.42.1",
+    "@opentelemetry/api": "^1.9.0",
+    "@playwright/test": "^1.49.1",
+    "@testing-library/react": ">=16",
+    "@vercel/functions": "^3.0.0",
+    react: ">=19.2.8 <20",
+    "react-dom": ">=19.2.8 <20",
+    vite: "^8.0.16",
+    vitest: ">=3"
+  },
+  peerDependenciesMeta: {
+    "@cloudflare/vite-plugin": {
+      optional: true
+    },
+    "@opentelemetry/api": {
+      optional: true
+    },
+    "@playwright/test": {
+      optional: true
+    },
+    "@testing-library/react": {
+      optional: true
+    },
+    "@vercel/functions": {
+      optional: true
+    },
+    vite: {
+      optional: true
+    },
+    vitest: {
+      optional: true
+    }
+  },
+  engines: {
+    node: ">=24.0.0"
+  }
+};
+
+// src/vite/utils/banner.ts
+var rangoVersion = package_default.version;
+
+// src/vite/plugins/virtual-entries.ts
+var VIRTUAL_ENTRY_BROWSER = `
+import {
+  createFromReadableStream,
+  createFromFetch,
+  setServerCallback,
+  encodeReply,
+  createTemporaryReferenceSet,
+} from "@rangojs/router/internal/deps/browser";
+import { createElement, StrictMode } from "react";
+import { createRoot, hydrateRoot } from "react-dom/client";
+import { rscStream } from "@rangojs/router/internal/deps/html-stream-client";
+import { initBrowserApp, Rango } from "@rangojs/router/browser";
+
+async function initializeApp() {
+  const deps = {
+    createFromFetch,
+    createFromReadableStream,
+    encodeReply,
+    setServerCallback,
+    createTemporaryReferenceSet,
+  };
+
+  // initBrowserApp resolves the initial payload and returns the browser app
+  // context, including strictMode (default true) from createRouter. StrictMode
+  // is the default; createRouter({ strictMode: false }) ships the opt-out in the
+  // payload metadata. StrictMode emits no DOM, so toggling never changes markup.
+  const { strictMode, initialPayload } = await initBrowserApp({ rscStream, deps });
+  // Set only on a document a no-JS useActionState POST rendered: React needs
+  // the server's form state to hydrate the hook without resetting it. A state
+  // Flight could not carry rejects: hydrate without it, as before.
+  const formState = await Promise.resolve(initialPayload.formState).catch(
+    () => undefined
+  );
+
+  if (import.meta.hot) {
+    const { startDevDiscoveryHandshake } = await import(
+      "@rangojs/router/internal/browser/dev-discovery"
+    );
+    startDevDiscoveryHandshake(
+      initialPayload.metadata?.devDiscoveryEpoch,
+      import.meta.hot
+    );
+  }
+
+  const app = createElement(Rango);
+  const root = strictMode === false ? app : createElement(StrictMode, null, app);
+  // The server render failed its shell and answered a recovery document
+  // (ssr/shell-error-document.tsx): nothing to hydrate, so render it, and the
+  // router's error boundaries run as on a client navigation.
+  if (document.documentElement.hasAttribute("data-rango-ssr-error")) {
+    createRoot(document).render(root);
+  } else {
+    hydrateRoot(document, root, formState ? { formState } : undefined);
+  }
+}
+
+initializeApp().catch(console.error);
+`.trim();
+function emitProgressiveChunkSize(value) {
+  if (value === Number.POSITIVE_INFINITY) {
+    return "Number.POSITIVE_INFINITY";
+  }
+  if (!Number.isFinite(value)) {
+    throw new Error(
+      `rango({ progressiveChunkSize }) must be a finite number or Infinity, received ${String(value)}`
+    );
+  }
+  return JSON.stringify(value);
+}
+function getVirtualEntrySSR(headScripts = "preinit", progressiveChunkSize) {
+  if (headScripts !== "preinit" && headScripts !== "preload") {
+    throw new Error(
+      `rango({ headScripts }) must be "preinit" or "preload", received ${JSON.stringify(headScripts)}`
+    );
+  }
+  const preinit = headScripts === "preinit";
+  const depsImportNames = preinit ? "createFromReadableStream,\n  setOnClientReference,\n  getClientEntryUrl," : "createFromReadableStream,";
+  const ssrImportNames = preinit ? "\n  installClientReferencePreinit," : "";
+  const install = preinit ? `
+// Upgrade client-reference modulepreload hints to executing module scripts in
+// the document head, for every render pass (live SSR, shell capture, resume).
+// See src/ssr/preinit-client-references.ts for the full rationale.
+installClientReferencePreinit(setOnClientReference);
+` : "";
+  const bootstrapDep = preinit ? "getClientEntryUrl," : `loadBootstrapScriptContent: () =>
+    import.meta.viteRsc.loadBootstrapScriptContent("index"),`;
+  const hs = JSON.stringify(headScripts);
+  const pcs = progressiveChunkSize !== void 0 ? `
+  progressiveChunkSize: ${emitProgressiveChunkSize(progressiveChunkSize)},` : "";
+  return `
+import {
+  ${depsImportNames}
+} from "@rangojs/router/internal/deps/ssr";
+import { renderToReadableStream, resume } from "react-dom/server.edge";
+import { prerender } from "react-dom/static.edge";
+import { injectRSCPayload } from "@rangojs/router/internal/deps/html-stream-server";
+import {
+  createSSRHandler,
+  createShellCaptureHandler,
+  createShellResumeHandler,${ssrImportNames}
+} from "@rangojs/router/ssr";
+${install}
+export const renderHTML = createSSRHandler({
+  createFromReadableStream,
+  renderToReadableStream,
+  injectRSCPayload,
+  headScripts: ${hs},${pcs}
+  ${bootstrapDep}
+});
+
+export const captureShellHTML = createShellCaptureHandler({
+  createFromReadableStream,
+  renderToReadableStream,
+  injectRSCPayload,
+  prerender,
+  resume,
+  headScripts: ${hs},${pcs}
+  ${bootstrapDep}
+});
+
+export const resumeShellHTML = createShellResumeHandler({
+  createFromReadableStream,
+  renderToReadableStream,
+  injectRSCPayload,
+  prerender,
+  resume,
+  headScripts: ${hs},${pcs}
+  ${bootstrapDep}
+});
+`.trim();
+}
+var VIRTUAL_IDS = {
+  browser: "virtual:rsc-router/entry.browser.js",
+  ssr: "virtual:rsc-router/entry.ssr.js",
+  rsc: "virtual:rsc-router/entry.rsc.js",
+  version: "@rangojs/router:version"
+};
+function getPackageVersionExport() {
+  return `export const PACKAGE_VERSION = ${JSON.stringify(rangoVersion)};`;
+}
+function getVirtualPackageVersionContent() {
+  return getPackageVersionExport();
+}
+function getVirtualVersionContent(version) {
+  return [
+    getPackageVersionExport(),
+    `export const VERSION = ${JSON.stringify(version)};`,
+    `export const ROUTER_VERSIONS = undefined;`
+  ].join("\n");
+}
+var ROUTER_VERSIONS_PLACEHOLDER = "__RANGO_ROUTER_VERSIONS__";
+function getVirtualBuildVersionContent() {
+  return [
+    getPackageVersionExport(),
+    `export const ROUTER_VERSIONS = ${ROUTER_VERSIONS_PLACEHOLDER};`,
+    `export const VERSION = ROUTER_VERSIONS[${JSON.stringify(DEFAULT_ROUTER_VERSIONS_KEY)}][1];`
+  ].join("\n");
+}
+
+// src/vite/plugins/version-plugin.ts
+function isCodeModule(id) {
+  return /\.(tsx?|jsx?)($|\?)/.test(id);
+}
+function normalizeModuleId(id) {
+  return id.split("?", 1)[0];
+}
+function getClientModuleSignature(source) {
+  if (!hasUseClientDirective(source)) return void 0;
+  let program;
+  try {
+    program = parseAst(source, { lang: "tsx" });
+  } catch {
+    return void 0;
+  }
+  const exports = /* @__PURE__ */ new Set();
+  let hasDefault = false;
+  let hasExportAll = false;
+  const collectBindingNames = (pattern) => {
+    if (!pattern) return;
+    if (pattern.type === "Identifier") {
+      exports.add(pattern.name);
+    } else if (pattern.type === "ObjectPattern") {
+      for (const prop of pattern.properties ?? []) {
+        if (prop?.type === "RestElement") {
+          collectBindingNames(prop.argument);
+        } else {
+          collectBindingNames(prop?.value);
+        }
+      }
+    } else if (pattern.type === "ArrayPattern") {
+      for (const el of pattern.elements ?? []) {
+        if (el?.type === "RestElement") {
+          collectBindingNames(el.argument);
+        } else {
+          collectBindingNames(el);
+        }
+      }
+    }
+  };
+  const collectDeclarationNames = (declaration) => {
+    if (!declaration) return;
+    if (declaration.type === "VariableDeclaration") {
+      for (const decl of declaration.declarations ?? []) {
+        collectBindingNames(decl?.id);
+      }
+      return;
+    }
+    collectBindingNames(declaration.id);
+  };
+  for (const node of program.body ?? []) {
+    if (node?.type === "ExportDefaultDeclaration") {
+      hasDefault = true;
+      continue;
+    }
+    if (node?.type === "ExportAllDeclaration") {
+      hasExportAll = true;
+      continue;
+    }
+    if (node?.type !== "ExportNamedDeclaration") continue;
+    collectDeclarationNames(node.declaration);
+    for (const specifier of node.specifiers ?? []) {
+      const exportedName = specifier?.exported?.name ?? specifier?.exported?.value;
+      if (exportedName === "default") {
+        hasDefault = true;
+      } else if (typeof exportedName === "string") {
+        exports.add(exportedName);
+      }
+    }
+  }
+  return {
+    key: JSON.stringify({
+      default: hasDefault,
+      exportAll: hasExportAll,
+      exports: [...exports].sort()
+    })
+  };
+}
+function createVersionPlugin() {
+  let currentVersion = Date.now().toString(16);
+  let isDev = false;
+  let server = null;
+  let resolvedCacheDir;
+  const clientModuleSignatures = /* @__PURE__ */ new Map();
+  let versionCounter = 0;
+  const bumpVersion = (reason) => {
+    currentVersion = Date.now().toString(16) + String(++versionCounter);
+    console.log(`[rango] ${reason}, version updated: ${currentVersion}`);
+    const rscEnv = server?.environments?.rsc;
+    const versionMod = rscEnv?.moduleGraph?.getModuleById(
+      "\0" + VIRTUAL_IDS.version
+    );
+    if (versionMod) {
+      rscEnv.moduleGraph.invalidateModule(versionMod);
+    }
+  };
+  return {
+    name: "@rangojs/router:version",
+    enforce: "pre",
+    configResolved(config) {
+      isDev = config.command === "serve";
+      resolvedCacheDir = config.cacheDir ? String(config.cacheDir).replace(/\\/g, "/") : void 0;
+    },
+    configureServer(devServer) {
+      server = devServer;
+      devServer.watcher.on("unlink", (filePath) => {
+        if (!isDev) return;
+        if (!clientModuleSignatures.has(filePath)) return;
+        clientModuleSignatures.delete(filePath);
+        bumpVersion("Client module removed");
+      });
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_IDS.version) {
+        return "\0" + id;
+      }
+      return null;
+    },
+    load(id) {
+      if (id === "\0" + VIRTUAL_IDS.version) {
+        const environment = this?.environment?.name;
+        if (environment === "client") {
+          return getVirtualPackageVersionContent();
+        }
+        return isDev ? getVirtualVersionContent(currentVersion) : getVirtualBuildVersionContent();
+      }
+      return null;
+    },
+    transform(code, id) {
+      if (!isDev || !isCodeModule(id)) return null;
+      const normalizedId = normalizeModuleId(id);
+      if (!code.includes("use client") && !clientModuleSignatures.has(normalizedId)) {
+        return null;
+      }
+      const signature = getClientModuleSignature(code);
+      if (signature) {
+        clientModuleSignatures.set(normalizedId, signature);
+      } else {
+        clientModuleSignatures.delete(normalizedId);
+      }
+      return null;
+    },
+    async hotUpdate(ctx) {
+      if (!isDev) return;
+      const isRscModule = this.environment?.name === "rsc";
+      if (!isRscModule) return;
+      if (isViteDepCachePath(ctx.file, resolvedCacheDir)) return;
+      if (ctx.modules.length === 1 && ctx.modules[0].id === "\0" + VIRTUAL_IDS.version) {
+        return;
+      }
+      if (isCodeModule(ctx.file)) {
+        const filePath = normalizeModuleId(ctx.file);
+        const previousSignature = clientModuleSignatures.get(filePath);
+        try {
+          const source = await ctx.read();
+          const nextSignature = getClientModuleSignature(source);
+          if (nextSignature) {
+            clientModuleSignatures.set(filePath, nextSignature);
+            if (previousSignature && previousSignature.key === nextSignature.key) {
+              return;
+            }
+          } else {
+            clientModuleSignatures.delete(filePath);
+            if (!previousSignature) {
+              if (ctx.modules.length === 0) return;
+            }
+          }
+        } catch {
+        }
+      } else {
+        if (ctx.modules.length === 0) return;
+      }
+      bumpVersion("RSC module changed");
+    }
+  };
+}
+function isViteDepCachePath(filePath, cacheDir) {
+  if (!filePath) return false;
+  const normalized = filePath.replace(/\\/g, "/");
+  if (cacheDir) {
+    const normalizedCacheDir = cacheDir.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (normalized === normalizedCacheDir || normalized.startsWith(normalizedCacheDir + "/")) {
+      return true;
+    }
+  }
+  return /\/node_modules\/\.vite[^/]*\//.test(normalized) || normalized.includes("/.vite-isolated/");
+}
+
+// src/vite/plugins/virtual-stub-plugin.ts
+function createVirtualStubPlugin() {
+  const STUB_PREFIXES = [
+    "virtual:rsc-router/",
+    "virtual:entry-",
+    "virtual:vite-rsc/"
+  ];
+  return {
+    name: "@rangojs/router:virtual-stubs",
+    resolveId(id) {
+      if (STUB_PREFIXES.some((p) => id.startsWith(p))) {
+        return "\0stub:" + id;
+      }
+      return null;
+    },
+    load(id) {
+      if (id.startsWith("\0stub:")) {
+        return "export default {}";
+      }
+      return null;
+    }
+  };
+}
+
+// src/vite/plugins/cloudflare-protocol-stub.ts
+var VIRTUAL_PREFIX = "virtual:rango-cloudflare-stub-";
+var NULL_PREFIX = "\0" + VIRTUAL_PREFIX;
+var CF_PREFIX = "cloudflare:";
+var BUILD_ENV_GLOBAL_KEY = "__rango_build_env__";
+var SOURCE_EXT_RE = /\.[mc]?[jt]sx?$/;
+var IMPORT_NODE_TYPES = /* @__PURE__ */ new Set([
+  "ImportDeclaration",
+  "ImportExpression",
+  "ExportNamedDeclaration",
+  "ExportAllDeclaration"
+]);
+var STUBS = {
+  "cloudflare:workers": `
+export class DurableObject { constructor(_ctx, _env) {} }
+export class WorkerEntrypoint { constructor(_ctx, _env) {} }
+export class WorkflowEntrypoint { constructor(_ctx, _env) {} }
+export class RpcTarget {}
+export const env = globalThis[${JSON.stringify(BUILD_ENV_GLOBAL_KEY)}] ?? {};
+export default {};
+`,
+  "cloudflare:email": `
+export class EmailMessage { constructor(_from, _to, _raw) {} }
+export default {};
+`,
+  "cloudflare:sockets": `
+export function connect() { return {}; }
+export default {};
+`,
+  "cloudflare:workflows": `
+export class NonRetryableError extends Error {
+  constructor(message, name) { super(message); this.name = name ?? "NonRetryableError"; }
+}
+export default {};
+`
+};
+var FALLBACK_STUB = `export default {};
+`;
+function createCloudflareProtocolStubPlugin() {
+  return {
+    name: "@rangojs/router:cloudflare-protocol-stub",
+    transform(code, id) {
+      const cleanId = id.split("?")[0] ?? id;
+      if (!SOURCE_EXT_RE.test(cleanId)) return null;
+      if (!code.includes(CF_PREFIX)) return null;
+      let ast;
+      try {
+        ast = this.parse(code, { lang: "tsx" });
+      } catch {
+        return null;
+      }
+      const hits = [];
+      walk(ast, (node) => {
+        if (!IMPORT_NODE_TYPES.has(node.type)) return;
+        const source = node.source;
+        if (!source || source.type !== "Literal") return;
+        if (typeof source.value !== "string") return;
+        if (!source.value.startsWith(CF_PREFIX)) return;
+        if (typeof source.start !== "number" || typeof source.end !== "number")
+          return;
+        hits.push({
+          start: source.start,
+          end: source.end,
+          value: source.value
+        });
+      });
+      if (hits.length === 0) return null;
+      hits.sort((a, b) => b.start - a.start);
+      let out = code;
+      for (const hit of hits) {
+        const submodule = hit.value.slice(CF_PREFIX.length);
+        const quote = code[hit.start] === "'" ? "'" : '"';
+        out = out.slice(0, hit.start) + quote + VIRTUAL_PREFIX + submodule + quote + out.slice(hit.end);
+      }
+      return { code: out, map: null };
+    },
+    resolveId(id) {
+      if (id.startsWith(VIRTUAL_PREFIX)) {
+        return "\0" + id;
+      }
+      return null;
+    },
+    load(id) {
+      if (!id.startsWith(NULL_PREFIX)) return null;
+      const submodule = id.slice(NULL_PREFIX.length);
+      const specifier = CF_PREFIX + submodule;
+      return STUBS[specifier] ?? FALLBACK_STUB;
+    }
+  };
+}
+function walk(node, visit) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const child of node) walk(child, visit);
+    return;
+  }
+  const n = node;
+  if (typeof n.type !== "string") return;
+  visit(n);
+  for (const key in n) {
+    if (key === "loc" || key === "start" || key === "end" || key === "range") {
+      continue;
+    }
+    walk(n[key], visit);
+  }
+}
+
+// src/vite/plugins/expose-internal-ids.ts
+import { parseAst as parseAst3 } from "vite";
+import MagicString2 from "magic-string";
+import path3 from "node:path";
+
+// src/vite/plugins/expose-id-utils.ts
+import path from "node:path";
+import crypto from "node:crypto";
+
+// src/regex-escape.ts
+function escapeRegExp(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/vite/plugins/expose-id-utils.ts
+function normalizePath(p) {
+  return p.split(path.sep).join("/");
+}
+function hashId(filePath, exportName) {
+  const input = `${filePath}#${exportName}`;
+  const hash = crypto.createHash("sha256").update(input).digest("hex");
+  return `${hash.slice(0, 8)}#${exportName}`;
+}
+function makeStubId(filePath, exportName, isBuild) {
+  return isBuild ? hashId(filePath, exportName) : `${filePath}#${exportName}`;
+}
+function hashInlineId(filePath, fnName, index) {
+  const input = `${filePath}:${fnName}:${index}`;
+  return crypto.createHash("sha256").update(input).digest("hex").slice(0, 8);
+}
+function buildExportMap(program) {
+  const exportMap = /* @__PURE__ */ new Map();
+  const pushExport = (local, exported) => {
+    const list = exportMap.get(local);
+    if (list) {
+      if (!list.includes(exported)) list.push(exported);
+      return;
+    }
+    exportMap.set(local, [exported]);
+  };
+  for (const node of program.body ?? []) {
+    if (node?.type !== "ExportNamedDeclaration") continue;
+    if (node.declaration?.type === "VariableDeclaration") {
+      for (const decl of node.declaration.declarations ?? []) {
+        if (decl?.id?.type === "Identifier") {
+          pushExport(decl.id.name, decl.id.name);
+        }
+      }
+    }
+    if (!node.source && Array.isArray(node.specifiers)) {
+      for (const spec of node.specifiers) {
+        if (spec?.type === "ExportSpecifier" && spec.local?.type === "Identifier" && spec.exported?.type === "Identifier") {
+          pushExport(spec.local.name, spec.exported.name);
+        }
+      }
+    }
+  }
+  return exportMap;
+}
+function detectImports(code) {
+  const importPattern = /import\s*\{([^}]*)\}\s*from\s*["']@rangojs\/router(?:\/[^"']*)?["']/g;
+  const result = {
+    loader: false,
+    handle: false,
+    locationState: false,
+    prerenderHandler: false,
+    staticHandler: false,
+    router: false,
+    any: false
+  };
+  let match;
+  while ((match = importPattern.exec(code)) !== null) {
+    const imports = match[1];
+    if (/\bcreateLoader\b/.test(imports)) result.loader = true;
+    if (/\bcreateHandle\b/.test(imports)) result.handle = true;
+    if (/\bcreateLocationState\b/.test(imports)) result.locationState = true;
+    if (/\bPrerender\b/.test(imports)) result.prerenderHandler = true;
+    if (/\bStatic\b/.test(imports)) result.staticHandler = true;
+    if (/\bcreateRouter\b/.test(imports)) result.router = true;
+  }
+  if (result.router) {
+    result.router = /import\s*\{[^}]*\bcreateRouter\b[^}]*\}\s*from\s*["']@rangojs\/router["']/.test(
+      code
+    );
+  }
+  result.any = result.loader || result.handle || result.locationState || result.prerenderHandler || result.staticHandler || result.router;
+  return result;
+}
+function skipStringOrComment(code, pos) {
+  const ch = code[pos];
+  if (ch === '"' || ch === "'") {
+    for (let j = pos + 1; j < code.length; j++) {
+      if (code[j] === "\\") {
+        j++;
+        continue;
+      }
+      if (code[j] === ch) return j + 1;
+    }
+    return code.length;
+  }
+  if (ch === "`") {
+    let j = pos + 1;
+    while (j < code.length) {
+      if (code[j] === "\\") {
+        j += 2;
+        continue;
+      }
+      if (code[j] === "`") return j + 1;
+      if (code[j] === "$" && j + 1 < code.length && code[j + 1] === "{") {
+        j += 2;
+        let braceDepth = 1;
+        while (j < code.length && braceDepth > 0) {
+          const inner = skipStringOrComment(code, j);
+          if (inner > j) {
+            j = inner;
+            continue;
+          }
+          if (code[j] === "{") braceDepth++;
+          else if (code[j] === "}") braceDepth--;
+          if (braceDepth > 0) j++;
+        }
+        if (braceDepth === 0) j++;
+        continue;
+      }
+      j++;
+    }
+    return j;
+  }
+  if (ch === "/" && pos + 1 < code.length) {
+    if (code[pos + 1] === "/") {
+      const eol = code.indexOf("\n", pos + 2);
+      return eol === -1 ? code.length : eol + 1;
+    }
+    if (code[pos + 1] === "*") {
+      const end = code.indexOf("*/", pos + 2);
+      return end === -1 ? code.length : end + 2;
+    }
+  }
+  return pos;
+}
+function findMatchingParen(code, startPos) {
+  let depth = 1;
+  let i = startPos;
+  while (i < code.length && depth > 0) {
+    const skipped = skipStringOrComment(code, i);
+    if (skipped > i) {
+      i = skipped;
+      continue;
+    }
+    if (code[i] === "(") depth++;
+    if (code[i] === ")") depth--;
+    i++;
+  }
+  return i;
+}
+function countArgs(code, startPos, endPos) {
+  let depth = 0;
+  let argCount = 0;
+  let hasContent = false;
+  let i = startPos;
+  while (i < endPos) {
+    const skipped = skipStringOrComment(code, i);
+    if (skipped > i) {
+      const ch = code[i];
+      const isComment = ch === "/" && i + 1 < code.length && (code[i + 1] === "/" || code[i + 1] === "*");
+      if (!isComment) hasContent = true;
+      i = skipped;
+      continue;
+    }
+    const char = code[i];
+    if (char === "(" || char === "[" || char === "{") {
+      depth++;
+      hasContent = true;
+    } else if (char === ")" || char === "]" || char === "}") {
+      depth--;
+    } else if (char === "," && depth === 0) {
+      argCount++;
+    } else if (!/\s/.test(char)) {
+      hasContent = true;
+    }
+    i++;
+  }
+  return hasContent ? argCount + 1 : 0;
+}
+function findStatementEnd(code, pos) {
+  let i = pos;
+  while (i < code.length && /\s/.test(code[i])) {
+    i++;
+  }
+  if (i < code.length && code[i] === ";") {
+    i++;
+  }
+  return i;
+}
+function findCallParenAfterGenerics(code, afterCalleeIndex) {
+  let i = afterCalleeIndex;
+  while (i < code.length) {
+    const skipped = skipStringOrComment(code, i);
+    if (skipped > i) {
+      i = skipped;
+      continue;
+    }
+    if (/\s/.test(code[i])) {
+      i++;
+      continue;
+    }
+    break;
+  }
+  if (i >= code.length) return -1;
+  if (code[i] === "(") return i;
+  if (code[i] === "<") {
+    let depth = 0;
+    while (i < code.length) {
+      const skipped = skipStringOrComment(code, i);
+      if (skipped > i) {
+        i = skipped;
+        continue;
+      }
+      const ch = code[i];
+      if (ch === "<") {
+        depth++;
+      } else if (ch === ">") {
+        depth--;
+        if (depth === 0) {
+          i++;
+          break;
+        }
+      }
+      i++;
+    }
+    if (depth !== 0) return -1;
+    while (i < code.length) {
+      const skipped = skipStringOrComment(code, i);
+      if (skipped > i) {
+        i = skipped;
+        continue;
+      }
+      if (/\s/.test(code[i])) {
+        i++;
+        continue;
+      }
+      break;
+    }
+    if (i < code.length && code[i] === "(") return i;
+    return -1;
+  }
+  return -1;
+}
+
+// src/vite/utils/ast-handler-extract.ts
+function isDirectivePrologueStatement(node) {
+  return node?.type === "ExpressionStatement" && typeof node.directive === "string";
+}
+function findImportInsertionPos(code, parseAst6) {
+  let program;
+  try {
+    program = parseAst6(code, { lang: "tsx" });
+  } catch {
+    return 0;
+  }
+  const body = program.body;
+  let i = 0;
+  let insertionPos = 0;
+  while (i < body.length && isDirectivePrologueStatement(body[i])) {
+    insertionPos = body[i].end;
+    i++;
+  }
+  while (i < body.length && body[i]?.type === "ImportDeclaration") {
+    insertionPos = body[i].end;
+    i++;
+  }
+  return insertionPos;
+}
+function walkNode(node, parent, ancestors, enter) {
+  if (!node || typeof node !== "object") return;
+  if (typeof node.type !== "string") return;
+  ancestors.push(node);
+  enter(node, parent, ancestors);
+  for (const key of Object.keys(node)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (item && typeof item === "object" && typeof item.type === "string") {
+          walkNode(item, node, ancestors, enter);
+        }
+      }
+    } else if (child && typeof child === "object" && typeof child.type === "string") {
+      walkNode(child, node, ancestors, enter);
+    }
+  }
+  ancestors.pop();
+}
+function findHandlerCalls(code, fnName, parseAst6) {
+  let program;
+  try {
+    program = parseAst6(code, { lang: "tsx" });
+  } catch {
+    return [];
+  }
+  const sites = [];
+  const localNames = getImportedLocalNamesFromProgram(program, fnName);
+  const exportedNamesByLocal = buildExportMap(program);
+  walkNode(program, null, [], (node, parent, ancestors) => {
+    if (node.type !== "CallExpression" || node.callee?.type !== "Identifier" || !localNames.has(node.callee.name)) {
+      return;
+    }
+    const callStart = node.start;
+    const callEnd = node.end;
+    const argCount = node.arguments?.length ?? 0;
+    const calleeName = node.callee.name;
+    let lineNumber = 1;
+    for (let i = 0; i < callStart && i < code.length; i++) {
+      if (code[i] === "\n") lineNumber++;
+    }
+    let exportInfo = null;
+    if (parent?.type === "VariableDeclarator" && parent.init === node) {
+      const grandParent = ancestors.length >= 3 ? ancestors[ancestors.length - 3] : null;
+      const greatGrandParent = ancestors.length >= 4 ? ancestors[ancestors.length - 4] : null;
+      if (grandParent?.type === "VariableDeclaration" && greatGrandParent?.type === "ExportNamedDeclaration") {
+        const exportName = parent.id?.name;
+        if (exportName) {
+          exportInfo = {
+            exportName,
+            statementEnd: greatGrandParent.end
+          };
+        }
+      } else if (grandParent?.type === "VariableDeclaration" && parent.id?.type === "Identifier") {
+        const exportedNames = exportedNamesByLocal.get(parent.id.name);
+        if (exportedNames && exportedNames.length > 0) {
+          exportInfo = {
+            exportName: exportedNames[0],
+            statementEnd: grandParent.end
+          };
+        }
+      }
+    }
+    sites.push({
+      callStart,
+      callEnd,
+      argCount,
+      lineNumber,
+      calleeName,
+      exportInfo
+    });
+  });
+  return sites;
+}
+function getImportedLocalNamesFromProgram(program, importedName) {
+  const localNames = /* @__PURE__ */ new Set();
+  const body = program.body;
+  for (const node of body) {
+    if (node?.type !== "ImportDeclaration") continue;
+    const source = node.source?.value;
+    if (typeof source !== "string") continue;
+    if (!source.startsWith("@rangojs/router")) continue;
+    const specifiers = Array.isArray(node.specifiers) ? node.specifiers : [];
+    for (const spec of specifiers) {
+      if (spec?.type !== "ImportSpecifier") continue;
+      if (spec.imported?.type !== "Identifier") continue;
+      if (spec.imported.name !== importedName) continue;
+      if (spec.local?.type === "Identifier") {
+        localNames.add(spec.local.name);
+      }
+    }
+  }
+  return localNames;
+}
+function getImportedLocalNames(code, importedName, parseAst6) {
+  try {
+    const program = parseAst6(code, { lang: "tsx" });
+    return getImportedLocalNamesFromProgram(program, importedName);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function extractImportDeclarations(code, parseAst6) {
+  let program;
+  try {
+    program = parseAst6(code, { lang: "tsx" });
+  } catch {
+    return [];
+  }
+  const imports = [];
+  for (const node of program.body) {
+    if (node.type === "ImportDeclaration") {
+      imports.push(code.slice(node.start, node.end));
+    }
+  }
+  return imports;
+}
+function isInertExpression(node) {
+  if (!node) return false;
+  switch (node.type) {
+    case "Literal":
+      return true;
+    case "TemplateLiteral":
+      return (node.expressions ?? []).every((e) => isInertExpression(e));
+    case "ArrayExpression":
+      return (node.elements ?? []).every(
+        (e) => e === null || isInertExpression(e)
+      );
+    case "ObjectExpression":
+      return (node.properties ?? []).every((p) => {
+        if (p.type === "SpreadElement" || p.type === "RestElement") {
+          return isInertExpression(p.argument);
+        }
+        return p.type === "Property" && (!p.computed || isInertExpression(p.key)) && isInertExpression(p.value);
+      });
+    case "UnaryExpression":
+      return isInertExpression(node.argument);
+    case "BinaryExpression":
+      return isInertExpression(node.left) && isInertExpression(node.right);
+    case "LogicalExpression":
+      return isInertExpression(node.left) && isInertExpression(node.right);
+    case "ConditionalExpression":
+      return isInertExpression(node.test) && isInertExpression(node.consequent) && isInertExpression(node.alternate);
+    case "SpreadElement":
+      return isInertExpression(node.argument);
+    default:
+      return false;
+  }
+}
+function isSafeDeclaratorInit(init) {
+  if (!init) return true;
+  if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
+    return true;
+  }
+  return isInertExpression(init);
+}
+function isSafeVariableDeclaration(node, handlerNames) {
+  if (node.type !== "VariableDeclaration") return false;
+  return node.declarations.every(
+    (d) => isSafeDeclaratorInit(d.init) && !(d.init?.type === "CallExpression" && d.init.callee?.type === "Identifier" && handlerNames.has(d.init.callee.name))
+  );
+}
+function extractModuleLevelDeclarations(code, parseAst6, handlerNames) {
+  let program;
+  try {
+    program = parseAst6(code, { lang: "tsx" });
+  } catch {
+    return [];
+  }
+  const declarations = [];
+  for (const node of program.body) {
+    if (node.type === "ImportDeclaration") continue;
+    if (node.type === "VariableDeclaration") {
+      if (isSafeVariableDeclaration(node, handlerNames)) {
+        declarations.push(code.slice(node.start, node.end));
+      }
+      continue;
+    }
+    if (node.type === "FunctionDeclaration") {
+      declarations.push(code.slice(node.start, node.end));
+      continue;
+    }
+    if (node.type === "ExportNamedDeclaration" && node.declaration) {
+      const decl = node.declaration;
+      if (decl.type === "VariableDeclaration") {
+        if (isSafeVariableDeclaration(decl, handlerNames)) {
+          declarations.push(code.slice(decl.start, decl.end));
+        }
+      } else if (decl.type === "FunctionDeclaration") {
+        declarations.push(code.slice(decl.start, decl.end));
+      }
+      continue;
+    }
+  }
+  return declarations;
+}
+function transformInlineHandlers(fnName, virtualPrefix, s, code, filePath, virtualRegistry, moduleId, parseAst6) {
+  const sites = findHandlerCalls(code, fnName, parseAst6);
+  const inlineSites = sites.filter((site) => site.exportInfo === null);
+  if (inlineSites.length === 0) return false;
+  const imports = extractImportDeclarations(code, parseAst6);
+  const staticNames = getImportedLocalNames(code, "Static", parseAst6);
+  const prerenderNames = getImportedLocalNames(code, "Prerender", parseAst6);
+  const handlerNames = /* @__PURE__ */ new Set([...staticNames, ...prerenderNames]);
+  const declarations = extractModuleLevelDeclarations(
+    code,
+    parseAst6,
+    handlerNames
+  );
+  const importStatements = [];
+  for (const [siteIndex, site] of inlineSites.entries()) {
+    const hash = hashInlineId(filePath, fnName, siteIndex);
+    const exportName = `__sh_${hash}`;
+    const idSuffix = `${filePath}:${fnName}:${siteIndex}`;
+    const virtualId = `\0${virtualPrefix}${idSuffix}`;
+    const handlerCode = code.slice(site.callStart, site.callEnd);
+    virtualRegistry.set(virtualId, {
+      originalModuleId: moduleId,
+      imports,
+      declarations,
+      handlerCode,
+      exportName
+    });
+    s.overwrite(site.callStart, site.callEnd, exportName);
+    const importId = `${virtualPrefix}${idSuffix}`;
+    importStatements.push(`import { ${exportName} } from "${importId}";`);
+  }
+  if (importStatements.length > 0) {
+    const importBlock = importStatements.join("\n") + "\n";
+    const insertionPos = findImportInsertionPos(code, parseAst6);
+    if (insertionPos === 0) {
+      s.prepend(importBlock);
+    } else {
+      s.appendLeft(insertionPos, "\n" + importBlock);
+    }
+  }
+  return true;
+}
+
+// src/vite/plugins/expose-ids/types.ts
+var PRERENDER_CONFIG = {
+  fnName: "Prerender",
+  brand: "prerenderHandler"
+};
+var STATIC_CONFIG = {
+  fnName: "Static",
+  brand: "staticHandler"
+};
+var STRICT_CREATE_CONFIGS = [
+  { fnName: "createLoader" },
+  { fnName: "createHandle" },
+  { fnName: "createLocationState" }
+];
+
+// src/vite/plugins/expose-ids/export-analysis.ts
+import { parseAst as parseAst2 } from "vite";
+function isExportOnlyFile(code, bindings) {
+  if (bindings.length === 0) return false;
+  const knownLocals = /* @__PURE__ */ new Set();
+  const knownExports = /* @__PURE__ */ new Set();
+  for (const b of bindings) {
+    knownLocals.add(b.localName);
+    for (const e of b.exportNames) knownExports.add(e);
+  }
+  if (/export\s*\*/.test(code)) return false;
+  const declExportPattern = /export\s+(const|let|var|function|class|default)\s+(\w+)/g;
+  let match;
+  while ((match = declExportPattern.exec(code)) !== null) {
+    if (!knownExports.has(match[2])) return false;
+  }
+  const specExportPattern = /export\s*\{([^}]+)\}/g;
+  while ((match = specExportPattern.exec(code)) !== null) {
+    const specifiers = match[1].split(",").map((s) => s.trim()).filter(Boolean);
+    for (const spec of specifiers) {
+      const m = spec.match(
+        /^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/
+      );
+      if (!m) continue;
+      const local = m[1];
+      if (!knownLocals.has(local)) return false;
+    }
+  }
+  return true;
+}
+function createCallPattern(fnNames) {
+  return new RegExp(`\\b(?:${fnNames.map(escapeRegExp).join("|")})\\b`, "g");
+}
+function createCallStartIndices(code, fnNames) {
+  return codeMatchIndices(code, createCallPattern(fnNames)).filter(
+    (index) => findCallParenAfterGenerics(
+      code,
+      index + matchedNameLength(code, index)
+    ) !== -1
+  );
+}
+function matchedNameLength(code, index) {
+  let i = index;
+  while (i < code.length && /[A-Za-z0-9_$]/.test(code[i])) i++;
+  return i - index;
+}
+function countCreateCallsForNames(code, fnNames) {
+  return createCallStartIndices(code, fnNames).length;
+}
+function offsetToLineColumn(code, index) {
+  let line = 1;
+  let lineStart = 0;
+  const end = Math.min(index, code.length);
+  for (let i = 0; i < end; i++) {
+    if (code[i] === "\n") {
+      line++;
+      lineStart = i + 1;
+    }
+  }
+  return { line, column: index - lineStart + 1 };
+}
+function findUnsupportedCreateCallSites(code, fnNames, supportedBindings) {
+  const supported = new Set(supportedBindings.map((b) => b.callExprStart));
+  return createCallStartIndices(code, fnNames).filter((index) => !supported.has(index)).map((index) => offsetToLineColumn(code, index));
+}
+function getImportedFnNames(code, importedName) {
+  const importPattern = /import\s*\{([^}]*)\}\s*from\s*["']@rangojs\/router(?:\/[^"']*)?["']/g;
+  const localNames = /* @__PURE__ */ new Set();
+  let match;
+  while ((match = importPattern.exec(code)) !== null) {
+    const specList = match[1].split(",").map((s) => s.trim()).filter(Boolean);
+    for (const spec of specList) {
+      const m = spec.match(
+        /^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/
+      );
+      if (!m) continue;
+      const imported = m[1];
+      const local = m[2] || imported;
+      if (imported === importedName) {
+        localNames.add(local);
+      }
+    }
+  }
+  const names = Array.from(localNames);
+  return names.length > 0 ? names : [importedName];
+}
+function getCalledIdentifierFromCall(callExpr) {
+  const callee = callExpr?.callee;
+  if (callee?.type === "Identifier") return callee.name;
+  if (callee?.type === "TSInstantiationExpression" && callee.expression?.type === "Identifier") {
+    return callee.expression.name;
+  }
+  return null;
+}
+function unwrapSignatureWrappedCall(init, fnNameSet) {
+  if (init?.type !== "CallExpression") return init;
+  const directId = getCalledIdentifierFromCall(init);
+  if (directId && fnNameSet.has(directId)) return init;
+  const firstArg = init.arguments?.[0];
+  if (firstArg?.type === "CallExpression") {
+    const innerId = getCalledIdentifierFromCall(firstArg);
+    if (innerId && fnNameSet.has(innerId)) return firstArg;
+  }
+  return init;
+}
+function collectCreateExportBindingsFallback(code, fnNames) {
+  const alternation = fnNames.map(escapeRegExp).join("|");
+  const exportConstPattern = new RegExp(
+    `export\\s+const\\s+(\\w+)\\s*=\\s*(?:${alternation})\\s*(?:<[^>]*>)?\\s*\\(`,
+    "g"
+  );
+  const localDeclPattern = new RegExp(
+    `\\bconst\\s+(\\w+)\\s*=\\s*((?:${alternation})\\s*(?:<[^>]*>)?\\s*\\()`,
+    "g"
+  );
+  const exportSpecPattern = /export\s*\{([^}]+)\}/g;
+  const exportMap = /* @__PURE__ */ new Map();
+  const pushExport = (local, exported) => {
+    const list = exportMap.get(local);
+    if (list) {
+      if (!list.includes(exported)) list.push(exported);
+      return;
+    }
+    exportMap.set(local, [exported]);
+  };
+  let match;
+  while ((match = exportConstPattern.exec(code)) !== null) {
+    pushExport(match[1], match[1]);
+  }
+  while ((match = exportSpecPattern.exec(code)) !== null) {
+    const specifiers = match[1].split(",").map((s) => s.trim()).filter(Boolean);
+    for (const specifier of specifiers) {
+      const specMatch = specifier.match(
+        /^([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/
+      );
+      if (!specMatch) continue;
+      const local = specMatch[1];
+      const exported = specMatch[2] || local;
+      pushExport(local, exported);
+    }
+  }
+  const bindings = [];
+  while ((match = localDeclPattern.exec(code)) !== null) {
+    const localName = match[1];
+    const exportNames = exportMap.get(localName) ?? [];
+    if (exportNames.length === 0) continue;
+    const openParenPos = match.index + match[0].length - 1;
+    const closeParenPos = findMatchingParen(code, openParenPos + 1) - 1;
+    if (closeParenPos <= openParenPos) continue;
+    bindings.push({
+      localName,
+      exportNames,
+      callExprStart: match.index + match[0].length - match[2].length,
+      callOpenParenPos: openParenPos,
+      callCloseParenPos: closeParenPos,
+      argCount: countArgs(code, openParenPos + 1, closeParenPos),
+      statementEnd: findStatementEnd(code, closeParenPos + 1)
+    });
+  }
+  return bindings;
+}
+function collectCreateExportBindings(code, fnNames, program) {
+  if (!program) {
+    try {
+      program = parseAst2(code, { lang: "tsx" });
+    } catch {
+      return collectCreateExportBindingsFallback(code, fnNames);
+    }
+  }
+  const exportMap = buildExportMap(program);
+  const fnNameSet = new Set(fnNames);
+  const bindings = [];
+  const collectFromVarDecl = (varDecl, statementEnd) => {
+    if (varDecl?.type !== "VariableDeclaration" || varDecl.kind !== "const") {
+      return;
+    }
+    for (const decl of varDecl.declarations ?? []) {
+      const callExpr = unwrapSignatureWrappedCall(decl?.init, fnNameSet);
+      const calledIdentifier = getCalledIdentifierFromCall(callExpr);
+      if (decl?.id?.type !== "Identifier" || callExpr?.type !== "CallExpression" || !calledIdentifier || !fnNameSet.has(calledIdentifier)) {
+        continue;
+      }
+      const localName = decl.id.name;
+      const exportNames = exportMap.get(localName) ?? [];
+      if (exportNames.length === 0) continue;
+      const callEnd = callExpr.end;
+      const calleeEnd = callExpr.callee.end;
+      let openParenPos = -1;
+      for (let i = calleeEnd; i < callEnd; i++) {
+        if (code[i] === "(") {
+          openParenPos = i;
+          break;
+        }
+      }
+      if (openParenPos === -1) continue;
+      const closeParenPos = findMatchingParen(code, openParenPos + 1) - 1;
+      if (closeParenPos <= openParenPos) continue;
+      bindings.push({
+        localName,
+        exportNames,
+        callExprStart: callExpr.start,
+        callOpenParenPos: openParenPos,
+        callCloseParenPos: closeParenPos,
+        argCount: callExpr.arguments?.length ?? 0,
+        statementEnd
+      });
+    }
+  };
+  for (const node of program.body ?? []) {
+    if (node?.type === "VariableDeclaration") {
+      collectFromVarDecl(node, node.end);
+      continue;
+    }
+    if (node?.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+      collectFromVarDecl(node.declaration, node.end);
+    }
+  }
+  if (bindings.length === 0) {
+    return collectCreateExportBindingsFallback(code, fnNames);
+  }
+  return bindings;
+}
+function buildUnsupportedShapeWarning(filePath, fnName, sites = []) {
+  const lines = [`[rango] Unsupported ${fnName} shape in "${filePath}".`];
+  if (sites.length === 1) {
+    const s = sites[0];
+    lines.push(
+      `The ${fnName}(...) call at ${filePath}:${s.line}:${s.column} has no stable $$id injected \u2014 it is not in a supported shape.`
+    );
+  } else if (sites.length > 1) {
+    lines.push(
+      `These ${fnName}(...) calls have no stable $$id injected \u2014 they are not in a supported shape:`
+    );
+    for (const s of sites) lines.push(`  - ${filePath}:${s.line}:${s.column}`);
+  }
+  lines.push(
+    `Supported shapes are:`,
+    `  - export const X = ${fnName}(...)`,
+    `  - const X = ${fnName}(...); export { X }`,
+    `  - const X = ${fnName}(...); export { X as Y }`,
+    `Potentially unsupported forms include:`,
+    `  - export let/var X = ${fnName}(...)`,
+    `  - inline ${fnName}(...) calls`
+  );
+  return lines.join("\n");
+}
+
+// src/vite/plugins/expose-ids/loader-transform.ts
+import { hasDirective } from "@vitejs/plugin-rsc/transforms";
+function hasCreateLoaderImport(code) {
+  return /import\s*\{[^}]*\bcreateLoader\b[^}]*\}\s*from\s*["']@rangojs\/router(?:\/server)?["']/.test(
+    code
+  );
+}
+function generateClientLoaderStubs(bindings, code, filePath, isBuild) {
+  if (!isExportOnlyFile(code, bindings)) return null;
+  const lines = [];
+  for (const binding of bindings) {
+    const primaryName = binding.exportNames[0];
+    const loaderId = makeStubId(filePath, primaryName, isBuild);
+    lines.push(
+      `export const ${primaryName} = { __brand: "loader", $$id: "${loaderId}" };`
+    );
+    for (const alias of binding.exportNames.slice(1)) {
+      lines.push(`export const ${alias} = ${primaryName};`);
+    }
+  }
+  return { code: lines.join("\n") + "\n" };
+}
+function transformLoaders(bindings, s, filePath, isBuild) {
+  let hasChanges = false;
+  for (const binding of bindings) {
+    const exportName = binding.exportNames[0];
+    const loaderId = makeStubId(filePath, exportName, isBuild);
+    const paramInjection = binding.argCount === 1 ? `, undefined, "${loaderId}"` : `, "${loaderId}"`;
+    s.appendLeft(binding.callCloseParenPos, paramInjection);
+    const propInjection = `
+${binding.localName}.$$id = "${loaderId}";`;
+    s.appendRight(binding.statementEnd, propInjection);
+    hasChanges = true;
+  }
+  return hasChanges;
+}
+
+// src/vite/plugins/expose-ids/handler-transform.ts
+function transformHandles(bindings, s, filePath, isBuild) {
+  let hasChanges = false;
+  for (const binding of bindings) {
+    const exportName = binding.exportNames[0];
+    const handleId = makeStubId(filePath, exportName, isBuild);
+    let paramInjection;
+    if (binding.argCount === 0) {
+      paramInjection = `undefined, "${handleId}"`;
+    } else {
+      paramInjection = `, "${handleId}"`;
+    }
+    s.appendLeft(binding.callCloseParenPos, paramInjection);
+    const propInjection = `
+${binding.localName}.$$id = "${handleId}";`;
+    s.appendRight(binding.statementEnd, propInjection);
+    hasChanges = true;
+  }
+  return hasChanges;
+}
+function transformLocationState(bindings, s, filePath, isBuild) {
+  let hasChanges = false;
+  for (const binding of bindings) {
+    const exportName = binding.exportNames[0];
+    const stateKey = makeStubId(filePath, exportName, isBuild);
+    const propInjection = `
+${binding.localName}.__rsc_ls_key = "__rsc_ls_${stateKey}";`;
+    s.appendRight(binding.statementEnd, propInjection);
+    hasChanges = true;
+  }
+  return hasChanges;
+}
+function generateWholeFileStubs(cfg, bindings, code, filePath, isBuild) {
+  if (!isExportOnlyFile(code, bindings)) return null;
+  const exportNames = bindings.flatMap((b) => b.exportNames);
+  const stubs = exportNames.map((name) => {
+    const handlerId = makeStubId(filePath, name, isBuild);
+    return `export const ${name} = { __brand: "${cfg.brand}", $$id: "${handlerId}" };`;
+  });
+  return { code: stubs.join("\n") + "\n", map: null };
+}
+function stubHandlerExprs(cfg, bindings, s, filePath, isBuild) {
+  let hasChanges = false;
+  for (const binding of bindings) {
+    const exportName = binding.exportNames[0];
+    const handlerId = makeStubId(filePath, exportName, isBuild);
+    s.overwrite(
+      binding.callExprStart,
+      binding.callCloseParenPos + 1,
+      `{ __brand: "${cfg.brand}", $$id: "${handlerId}" }`
+    );
+    hasChanges = true;
+  }
+  return hasChanges;
+}
+function transformHandlerIds(cfg, bindings, s, filePath, isBuild) {
+  let hasChanges = false;
+  for (const binding of bindings) {
+    const exportName = binding.exportNames[0];
+    const handlerId = makeStubId(filePath, exportName, isBuild);
+    let paramInjection;
+    if (binding.argCount === 0) {
+      paramInjection = `undefined, "${handlerId}"`;
+    } else if (binding.argCount === 1) {
+      paramInjection = `, undefined, "${handlerId}"`;
+    } else {
+      paramInjection = `, "${handlerId}"`;
+    }
+    s.appendLeft(binding.callCloseParenPos, paramInjection);
+    const propInjection = `
+${binding.localName}.$$id = "${handlerId}";`;
+    s.appendRight(binding.statementEnd, propInjection);
+    hasChanges = true;
+  }
+  return hasChanges;
+}
+
+// src/vite/utils/compare-strings.ts
+function compareStrings(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/vite/plugins/expose-ids/router-transform.ts
+import MagicString from "magic-string";
+import path2 from "node:path";
+import { createHash } from "node:crypto";
+var debug = createRangoDebugger(NS.transform);
+function skipLeadingTrivia(code, start, end) {
+  let i = start;
+  while (i < end) {
+    const skipped = skipStringOrComment(code, i);
+    if (skipped > i) {
+      i = skipped;
+      continue;
+    }
+    if (/\s/.test(code[i])) {
+      i++;
+      continue;
+    }
+    break;
+  }
+  return i;
+}
+function routerId(filePath, callIndex) {
+  return createHash("sha256").update(`${filePath}#${callIndex}`).digest("hex").slice(0, 8);
+}
+function transformRouter(code, filePath, routerFnNames, absolutePath, warn) {
+  const pat = createCallPattern(routerFnNames);
+  let match;
+  const s = new MagicString(code);
+  let changed = false;
+  const unsupportedSites = [];
+  let callIndex = -1;
+  const basename = path2.basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
+  const routeNamesImport = `./${basename}.named-routes.gen.js`;
+  const routeNamesVar = `__rsc_rn`;
+  const codeOffsets = new Set(codeMatchIndices(code, pat));
+  pat.lastIndex = 0;
+  while ((match = pat.exec(code)) !== null) {
+    if (!codeOffsets.has(match.index)) continue;
+    const callStart = match.index;
+    const calleeEnd = match.index + match[0].length;
+    const parenPos = findCallParenAfterGenerics(code, calleeEnd);
+    if (parenPos === -1) continue;
+    callIndex++;
+    const closeParen = findMatchingParen(code, parenPos + 1);
+    const callArgs = code.slice(parenPos + 1, closeParen);
+    if (callArgs.includes(`$$routeNames: ${routeNamesVar}`)) continue;
+    const sourceFilePath = absolutePath ?? filePath;
+    const injected = ` $$id: "${routerId(filePath, callIndex)}", $$sourceFile: "${sourceFilePath}", $$routeNames: ${routeNamesVar},`;
+    const argsContentStart = skipLeadingTrivia(code, parenPos + 1, closeParen);
+    const firstArgChar = code[argsContentStart];
+    if (firstArgChar === "{") {
+      changed = true;
+      s.appendRight(argsContentStart + 1, injected);
+    } else if (argsContentStart >= closeParen - 1) {
+      changed = true;
+      s.appendRight(parenPos + 1, `{${injected} }`);
+    } else {
+      unsupportedSites.push(offsetToLineColumn(code, callStart));
+    }
+  }
+  if (unsupportedSites.length > 0 && warn) {
+    warn(
+      buildUnsupportedShapeWarning(filePath, "createRouter", unsupportedSites)
+    );
+  }
+  if (!changed) return null;
+  s.prepend(
+    `import { NamedRoutes as ${routeNamesVar} } from "${routeNamesImport}";
+`
+  );
+  return {
+    code: s.toString(),
+    map: s.generateMap({ hires: true })
+  };
+}
+function exposeRouterId() {
+  let projectRoot = "";
+  let rootRelativeSourceFile = false;
+  const counter = createCounter(debug, "expose-router-id");
+  return {
+    name: "@rangojs/router:expose-router-id",
+    configResolved(config) {
+      projectRoot = config.root;
+      rootRelativeSourceFile = config.command === "build";
+    },
+    buildEnd() {
+      counter?.flush();
+    },
+    transform(code, id) {
+      if (!code.includes("createRouter")) return null;
+      if (!/import\s*\{[^}]*\bcreateRouter\b[^}]*\}\s*from\s*["']@rangojs\/router(?:\/server)?["']/.test(
+        code
+      )) {
+        return null;
+      }
+      if (id.includes("node_modules")) return null;
+      const start = counter ? performance.now() : 0;
+      try {
+        const filePath = normalizePath(path2.relative(projectRoot, id));
+        const routerFnNames = getImportedFnNames(code, "createRouter");
+        const warn = typeof this.warn === "function" ? (message) => this.warn(message) : void 0;
+        return transformRouter(
+          code,
+          filePath,
+          routerFnNames,
+          rootRelativeSourceFile ? void 0 : normalizePath(id),
+          warn
+        );
+      } finally {
+        counter?.record(id, performance.now() - start);
+      }
+    }
+  };
+}
+
+// src/vite/plugins/expose-internal-ids.ts
+var debug2 = createRangoDebugger(NS.transform);
+var VIRTUAL_LOADER_MANIFEST = VIRTUAL_LOADER_MANIFEST_ID;
+var RESOLVED_VIRTUAL_LOADER_MANIFEST = "\0" + VIRTUAL_LOADER_MANIFEST;
+var VIRTUAL_HANDLER_PREFIX = "virtual:handler-extract:";
+function exposeInternalIds(options) {
+  let config;
+  let isBuild = false;
+  let projectRoot = "";
+  const loaderRegistry = /* @__PURE__ */ new Map();
+  const prerenderHandlerModules = /* @__PURE__ */ new Map();
+  const staticHandlerModules = /* @__PURE__ */ new Map();
+  const virtualHandlers = /* @__PURE__ */ new Map();
+  const unsupportedShapeWarnings = /* @__PURE__ */ new Set();
+  const counter = createCounter(debug2, "expose-internal-ids");
+  function loaderManifestCode() {
+    if (!isBuild) {
+      return `import { setLoaderImports } from "@rangojs/router/server";
+
+// Dev mode: empty map, loaders are resolved dynamically via path parsing
+setLoaderImports({});
+`;
+    }
+    const lazyImports = [];
+    const sortedLoaders = [...loaderRegistry].sort(
+      ([a], [b]) => compareStrings(a, b)
+    );
+    for (const [hashedId, { filePath, exportName }] of sortedLoaders) {
+      lazyImports.push(
+        `  "${hashedId}": () => import("/${filePath}").then(m => m.${exportName})`
+      );
+    }
+    if (lazyImports.length === 0) {
+      return `import { setLoaderImports } from "@rangojs/router/server";
+
+// No fetchable loaders discovered during build
+setLoaderImports({});
+`;
+    }
+    return `import { setLoaderImports } from "@rangojs/router/server";
+
+// Lazy import map - loaders are loaded on-demand when first requested
+setLoaderImports({
+${lazyImports.join(",\n")}
+});
+`;
+  }
+  return {
+    name: "@rangojs/router:expose-internal-ids",
+    enforce: "post",
+    buildEnd() {
+      counter?.flush();
+    },
+    api: {
+      prerenderHandlerModules,
+      staticHandlerModules
+    },
+    configResolved(resolved2) {
+      config = resolved2;
+      isBuild = options?.forceBuild || config.command === "build";
+      projectRoot = config.root;
+    },
+    // --------------- Virtual module support ---------------
+    resolveId(id, importer) {
+      if (id === VIRTUAL_LOADER_MANIFEST) {
+        return RESOLVED_VIRTUAL_LOADER_MANIFEST;
+      }
+      if (id.startsWith(VIRTUAL_HANDLER_PREFIX)) {
+        return "\0" + id;
+      }
+      if (importer?.startsWith("\0" + VIRTUAL_HANDLER_PREFIX)) {
+        const entry = virtualHandlers.get(importer);
+        if (entry) {
+          return this.resolve(id, entry.originalModuleId, { skipSelf: true });
+        }
+      }
+    },
+    load(id) {
+      if (id.startsWith("\0" + VIRTUAL_HANDLER_PREFIX)) {
+        const entry = virtualHandlers.get(id);
+        if (!entry) return null;
+        return [
+          ...entry.imports,
+          ...entry.declarations,
+          `export const ${entry.exportName} = ${entry.handlerCode};`
+        ].join("\n") + "\n";
+      }
+      if (id !== RESOLVED_VIRTUAL_LOADER_MANIFEST) return;
+      return { code: loaderManifestCode(), moduleSideEffects: "no-treeshake" };
+    },
+    // --------------- Loader pre-scan (build mode) ---------------
+    async buildStart() {
+      if (!isBuild) return;
+      if (this.environment && this.environment.name !== "rsc") return;
+      const fs = await import("node:fs/promises");
+      async function scanDir(dir) {
+        const results = [];
+        try {
+          const entries = await fs.readdir(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path3.join(dir, entry.name);
+            if (entry.isDirectory()) {
+              if (!isSkippedSourceScanDir(entry.name)) {
+                results.push(...await scanDir(fullPath));
+              }
+            } else if (/\.(ts|tsx|js|jsx)$/.test(entry.name)) {
+              results.push(fullPath);
+            }
+          }
+        } catch {
+        }
+        return results;
+      }
+      try {
+        const files = await scanDir(projectRoot);
+        for (const filePath of files) {
+          const content = await fs.readFile(filePath, "utf-8");
+          if (!content.includes("createLoader")) continue;
+          if (!hasCreateLoaderImport(content)) continue;
+          const fnNames = getImportedFnNames(content, "createLoader");
+          const relativePath = normalizePath(
+            path3.relative(projectRoot, filePath)
+          );
+          const bindings = collectCreateExportBindings(content, fnNames);
+          for (const binding of bindings) {
+            const exportName = binding.exportNames[0];
+            const hashedId = hashId(relativePath, exportName);
+            loaderRegistry.set(hashedId, {
+              filePath: relativePath,
+              exportName
+            });
+          }
+        }
+      } catch (error) {
+        console.warn("[exposeInternalIds] Loader pre-scan failed:", error);
+      }
+    },
+    // --------------- Unified transform ---------------
+    transform(code, id) {
+      if (id.includes("/node_modules/")) return;
+      const __t0 = counter ? performance.now() : 0;
+      try {
+        const filePath = normalizePath(path3.relative(projectRoot, id));
+        const isRscEnv = this.environment?.name === "rsc";
+        if (id.includes(".named-routes.gen.") && !isRscEnv && this.environment?.name === "client") {
+          this.warn(
+            `
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+!!                                                              !!
+!!  WARNING: NamedRoutes imported in a CLIENT component!        !!
+!!                                                              !!
+!!  File: ${filePath.padEnd(53)}!!
+!!                                                              !!
+!!  NamedRoutes contains your entire route structure \u2014 every    !!
+!!  route name and URL pattern in your application. Shipping    !!
+!!  this to the browser exposes your full routing topology to   !!
+!!  the client, which is a security concern (internal/admin     !!
+!!  routes, API endpoints, hidden paths become visible).        !!
+!!                                                              !!
+!!  It also bloats the client bundle \u2014 this map contains all    !!
+!!  named routes in your application.                           !!
+!!                                                              !!
+!!  Fix: remove the import or move it to a server component.    !!
+!!                                                              !!
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+`
+          );
+        }
+        if (!code.includes("@rangojs/router")) return;
+        const has = detectImports(code);
+        const hasLoaderCode = has.loader && code.includes("createLoader");
+        const hasHandleCode = has.handle && code.includes("createHandle");
+        const hasLocationStateCode = has.locationState && code.includes("createLocationState");
+        const hasPrerenderHandlerCode = has.prerenderHandler && code.includes("Prerender");
+        const hasStaticHandlerCode = has.staticHandler && code.includes("Static");
+        if (!hasLoaderCode && !hasHandleCode && !hasLocationStateCode && !hasPrerenderHandlerCode && !hasStaticHandlerCode) {
+          return;
+        }
+        const _fnNamesCache = /* @__PURE__ */ new Map();
+        const _bindingsCache = /* @__PURE__ */ new Map();
+        let _cachedAst;
+        let _astParseFailed = false;
+        let _astCodeRef = code;
+        const getFnNames = (canonicalName) => {
+          let result = _fnNamesCache.get(canonicalName);
+          if (!result) {
+            result = getImportedFnNames(code, canonicalName);
+            _fnNamesCache.set(canonicalName, result);
+          }
+          return result;
+        };
+        const lazyAst = () => {
+          if (code !== _astCodeRef) {
+            _cachedAst = void 0;
+            _astParseFailed = false;
+            _astCodeRef = code;
+          }
+          if (_cachedAst !== void 0 || _astParseFailed) return _cachedAst;
+          try {
+            _cachedAst = parseAst3(code, { lang: "tsx" });
+          } catch {
+            _astParseFailed = true;
+          }
+          return _cachedAst;
+        };
+        const getBindings = (currentCode, fnNames) => {
+          const key = fnNames.join("\0");
+          let result = _bindingsCache.get(key);
+          if (!result) {
+            result = collectCreateExportBindings(
+              currentCode,
+              fnNames,
+              lazyAst()
+            );
+            _bindingsCache.set(key, result);
+          }
+          return result;
+        };
+        for (const cfg of STRICT_CREATE_CONFIGS) {
+          const hasCode = cfg.fnName === "createLoader" ? hasLoaderCode : cfg.fnName === "createHandle" ? hasHandleCode : hasLocationStateCode;
+          if (!hasCode) continue;
+          const fnNames = getFnNames(cfg.fnName);
+          const sites = findUnsupportedCreateCallSites(
+            code,
+            fnNames,
+            getBindings(code, fnNames)
+          );
+          if (sites.length === 0) continue;
+          const warnKey = `${id}::${cfg.fnName}`;
+          if (unsupportedShapeWarnings.has(warnKey)) continue;
+          unsupportedShapeWarnings.add(warnKey);
+          this.warn(buildUnsupportedShapeWarning(filePath, cfg.fnName, sites));
+        }
+        if (hasLoaderCode && isRscEnv) {
+          const fnNames = getFnNames("createLoader");
+          const bindings = getBindings(code, fnNames);
+          for (const binding of bindings) {
+            const exportName = binding.exportNames[0];
+            const hashedId = hashId(filePath, exportName);
+            loaderRegistry.set(hashedId, {
+              filePath,
+              exportName
+            });
+          }
+        }
+        if (hasLoaderCode && !isRscEnv) {
+          const fnNames = getFnNames("createLoader");
+          const bindings = getBindings(code, fnNames);
+          const stubResult = generateClientLoaderStubs(
+            bindings,
+            code,
+            filePath,
+            isBuild
+          );
+          if (stubResult) return stubResult;
+        }
+        if (hasPrerenderHandlerCode && !isRscEnv) {
+          const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
+          const bindings = getBindings(code, fnNames);
+          const wholeFile = generateWholeFileStubs(
+            PRERENDER_CONFIG,
+            bindings,
+            code,
+            filePath,
+            isBuild
+          );
+          if (wholeFile) return wholeFile;
+        }
+        let changed = false;
+        const handlerConfigs = [
+          hasStaticHandlerCode && STATIC_CONFIG,
+          hasPrerenderHandlerCode && PRERENDER_CONFIG
+        ].filter((c) => !!c).map((cfg) => {
+          const fnNames = getFnNames(cfg.fnName);
+          return { cfg, fnNames };
+        });
+        for (const { cfg, fnNames } of handlerConfigs) {
+          const totalCalls = countCreateCallsForNames(code, fnNames);
+          const supportedBindings = getBindings(code, fnNames).length;
+          if (totalCalls > supportedBindings) {
+            const iterS = new MagicString2(code);
+            const result = transformInlineHandlers(
+              cfg.fnName,
+              VIRTUAL_HANDLER_PREFIX,
+              iterS,
+              code,
+              filePath,
+              virtualHandlers,
+              id,
+              parseAst3
+            );
+            if (result) {
+              changed = true;
+              code = iterS.toString();
+              _bindingsCache.clear();
+            }
+          }
+        }
+        if (hasStaticHandlerCode && !isRscEnv) {
+          const fnNames = getFnNames(STATIC_CONFIG.fnName);
+          const bindings = getBindings(code, fnNames);
+          const wholeFile = generateWholeFileStubs(
+            STATIC_CONFIG,
+            bindings,
+            code,
+            filePath,
+            isBuild
+          );
+          if (wholeFile) return wholeFile;
+        }
+        if (!isRscEnv && (hasPrerenderHandlerCode || hasStaticHandlerCode)) {
+          const prerenderFnNames = hasPrerenderHandlerCode ? getFnNames(PRERENDER_CONFIG.fnName) : [];
+          const staticFnNames = hasStaticHandlerCode ? getFnNames(STATIC_CONFIG.fnName) : [];
+          const loaderFnNames = hasLoaderCode ? getFnNames("createLoader") : [];
+          const handleFnNames = hasHandleCode ? getFnNames("createHandle") : [];
+          const lsFnNames = hasLocationStateCode ? getFnNames("createLocationState") : [];
+          const allBindings = [];
+          for (const fnNames of [
+            prerenderFnNames,
+            staticFnNames,
+            loaderFnNames,
+            handleFnNames,
+            lsFnNames
+          ]) {
+            if (fnNames.length > 0) {
+              allBindings.push(...getBindings(code, fnNames));
+            }
+          }
+          let canStubWholeFile = allBindings.length > 0 && isExportOnlyFile(code, allBindings);
+          if (canStubWholeFile && (handleFnNames.length > 0 || lsFnNames.length > 0)) {
+            const exportedLocals = new Set(allBindings.map((b) => b.localName));
+            const strippedBindings = [];
+            const localDeclPattern = /(?:^|;|\n)\s*(?:const|let|var|function)\s+(\w+)/g;
+            let declMatch;
+            while ((declMatch = localDeclPattern.exec(code)) !== null) {
+              const name = declMatch[1];
+              if (!exportedLocals.has(name) && !/^_c\d*$/.test(name)) {
+                strippedBindings.push(name);
+              }
+            }
+            const importPattern = /import\s*\{([^}]*)\}\s*from\s*["'](?!@rangojs\/router)[^"']*["']/g;
+            let importMatch;
+            while ((importMatch = importPattern.exec(code)) !== null) {
+              for (const spec of importMatch[1].split(",")) {
+                const m = spec.trim().match(/^[A-Za-z_$][\w$]*(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+                if (m)
+                  strippedBindings.push(m[1] || m[0].trim().split(/\s/)[0]);
+              }
+            }
+            const defaultImportPattern = /import\s+([A-Za-z_$][\w$]*)\s+from\s*["'](?!@rangojs\/router)[^"']*["']/g;
+            while ((importMatch = defaultImportPattern.exec(code)) !== null) {
+              strippedBindings.push(importMatch[1]);
+            }
+            const nsImportPattern = /import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*["'](?!@rangojs\/router)[^"']*["']/g;
+            while ((importMatch = nsImportPattern.exec(code)) !== null) {
+              strippedBindings.push(importMatch[1]);
+            }
+            if (strippedBindings.length > 0) {
+              const preservedBindings = allBindings.filter((b) => {
+                const fc = code.slice(b.callExprStart, b.callOpenParenPos + 1);
+                return handleFnNames.some((n) => fc.includes(n)) || lsFnNames.some((n) => fc.includes(n));
+              });
+              const strippedRe = new RegExp(
+                `\\b(?:${strippedBindings.join("|")})\\b`
+              );
+              canStubWholeFile = !preservedBindings.some((b) => {
+                const expr = code.slice(
+                  b.callExprStart,
+                  b.callCloseParenPos + 1
+                );
+                return strippedRe.test(expr);
+              });
+            }
+          }
+          if (canStubWholeFile) {
+            const lines = [];
+            const neededImports = [];
+            if (handleFnNames.length > 0) neededImports.push("createHandle");
+            if (lsFnNames.length > 0) neededImports.push("createLocationState");
+            if (neededImports.length > 0) {
+              lines.push(
+                `import { ${neededImports.join(", ")} } from "@rangojs/router";`
+              );
+            }
+            for (const binding of allBindings) {
+              const fnCall = code.slice(
+                binding.callExprStart,
+                binding.callOpenParenPos + 1
+              );
+              const isHandle = handleFnNames.some((n) => fnCall.includes(n));
+              const isLocationState = lsFnNames.some((n) => fnCall.includes(n));
+              const primaryName = binding.exportNames[0];
+              const stubId = makeStubId(filePath, primaryName, isBuild);
+              if (isHandle || isLocationState) {
+                const rawArgs = code.slice(
+                  binding.callOpenParenPos + 1,
+                  binding.callCloseParenPos
+                ).replace(/\b_c\d*\s*=\s*/g, "");
+                const canonicalName = isHandle ? "createHandle" : "createLocationState";
+                const activeFnNames = isHandle ? handleFnNames : lsFnNames;
+                let rawCallee = code.slice(
+                  binding.callExprStart,
+                  binding.callOpenParenPos
+                );
+                for (const alias of activeFnNames) {
+                  if (alias !== canonicalName && rawCallee.startsWith(alias)) {
+                    rawCallee = canonicalName + rawCallee.slice(alias.length);
+                    break;
+                  }
+                }
+                if (isHandle) {
+                  const idParam = binding.argCount === 0 ? `undefined, "${stubId}"` : `, "${stubId}"`;
+                  lines.push(
+                    `export const ${primaryName} = ${rawCallee}(${rawArgs}${idParam});`
+                  );
+                  lines.push(`${primaryName}.$$id = "${stubId}";`);
+                } else {
+                  lines.push(
+                    `export const ${primaryName} = ${rawCallee}(${rawArgs});`
+                  );
+                  lines.push(
+                    `${primaryName}.__rsc_ls_key = "__rsc_ls_${stubId}";`
+                  );
+                }
+                for (const name of binding.exportNames.slice(1)) {
+                  lines.push(`export const ${name} = ${primaryName};`);
+                }
+              } else {
+                let brand = "loader";
+                if (prerenderFnNames.some((n) => fnCall.includes(n))) {
+                  brand = PRERENDER_CONFIG.brand;
+                } else if (staticFnNames.some((n) => fnCall.includes(n))) {
+                  brand = STATIC_CONFIG.brand;
+                }
+                lines.push(
+                  `export const ${primaryName} = { __brand: "${brand}", $$id: "${stubId}" };`
+                );
+                for (const name of binding.exportNames.slice(1)) {
+                  lines.push(`export const ${name} = ${primaryName};`);
+                }
+              }
+            }
+            return { code: lines.join("\n") + "\n", map: null };
+          }
+        }
+        if (isRscEnv && isBuild) {
+          const trackTypes = [
+            [
+              hasPrerenderHandlerCode,
+              PRERENDER_CONFIG,
+              prerenderHandlerModules
+            ],
+            [hasStaticHandlerCode, STATIC_CONFIG, staticHandlerModules]
+          ];
+          for (const [has2, cfg, trackMap] of trackTypes) {
+            if (!has2) continue;
+            const exportNames = getBindings(code, getFnNames(cfg.fnName)).map(
+              (b) => b.exportNames[0]
+            );
+            if (exportNames.length > 0) trackMap.set(id, exportNames);
+          }
+        }
+        const s = new MagicString2(code);
+        if (hasLoaderCode) {
+          const fnNames = getFnNames("createLoader");
+          changed = transformLoaders(
+            getBindings(code, fnNames),
+            s,
+            filePath,
+            isBuild
+          ) || changed;
+        }
+        if (hasHandleCode) {
+          const fnNames = getFnNames("createHandle");
+          changed = transformHandles(
+            getBindings(code, fnNames),
+            s,
+            filePath,
+            isBuild
+          ) || changed;
+        }
+        if (hasLocationStateCode) {
+          const fnNames = getFnNames("createLocationState");
+          changed = transformLocationState(
+            getBindings(code, fnNames),
+            s,
+            filePath,
+            isBuild
+          ) || changed;
+        }
+        const finalHandlerConfigs = [
+          hasPrerenderHandlerCode && PRERENDER_CONFIG,
+          hasStaticHandlerCode && STATIC_CONFIG
+        ].filter((c) => !!c);
+        for (const cfg of finalHandlerConfigs) {
+          const bindings = getBindings(code, getFnNames(cfg.fnName));
+          changed = (isRscEnv ? transformHandlerIds(cfg, bindings, s, filePath, isBuild) : stubHandlerExprs(cfg, bindings, s, filePath, isBuild)) || changed;
+        }
+        if (!changed) return;
+        return {
+          code: s.toString(),
+          map: s.generateMap({ source: id, includeContent: true })
+        };
+      } finally {
+        counter?.record(id, performance.now() - __t0);
+      }
+    }
+  };
+}
+
+// src/vite/plugins/server-reference-pattern.ts
+function registerServerReferenceRegex() {
+  return /registerServerReference\(([^,]+),\s*"([^"]+)",\s*"([^"]+)"\)/g;
+}
+
+// src/vite/plugins/server-ref-hashing.ts
+var debug3 = createRangoDebugger(NS.transform);
+function transformServerRefs(code, projectRoot) {
+  if (!code.includes("registerServerReference")) return null;
+  const hashes = /* @__PURE__ */ new Map();
+  let result = code.replace(
+    registerServerReferenceRegex(),
+    (match, _value, refKey) => {
+      const cleanKey = refKey.split("?")[0];
+      const hash = computeProductionHash(projectRoot, cleanKey);
+      if (hash === cleanKey) return match;
+      hashes.set(refKey, hash);
+      return match.replace(`"${refKey}"`, `"${hash}"`);
+    }
+  );
+  if (hashes.size === 0) return null;
+  for (const [refKey, hash] of hashes) {
+    result = result.replaceAll(`"${refKey}#`, `"${hash}#`);
+  }
+  return result;
+}
+function hashServerRefs(projectRoot) {
+  const counter = createCounter(debug3, "hash-server-refs");
+  return {
+    name: "@rangojs/router:hash-server-refs",
+    enforce: "post",
+    applyToEnvironment(env) {
+      return env.name === "rsc";
+    },
+    buildEnd() {
+      counter?.flush();
+    },
+    transform(code, id) {
+      const start = counter ? performance.now() : 0;
+      try {
+        const result = transformServerRefs(code, projectRoot);
+        if (result === null) return;
+        return { code: result, map: null };
+      } finally {
+        counter?.record(id, performance.now() - start);
+      }
+    }
+  };
+}
+
+// src/vite/encryption-key.ts
+import { randomBytes } from "node:crypto";
+var AES_KEY_BYTES = /* @__PURE__ */ new Set([16, 24, 32]);
+var EXPECTED = "a base64-encoded AES key of 16, 24 or 32 bytes (openssl rand -base64 32)";
+var resolvedKey;
+function assertValidEncryptionKey(value, source) {
+  if (typeof value !== "string") {
+    throw new Error(
+      `[rango] ${source} must be a string, received ${typeof value}. Expected ${EXPECTED}.`
+    );
+  }
+  if (value === "") {
+    throw new Error(
+      `[rango] ${source} is an empty string. Unset it to generate a key per build, or set it to ${EXPECTED}.`
+    );
+  }
+  const bytes = /^[A-Za-z0-9+/]+={0,2}$/.test(value) ? Buffer.from(value, "base64") : void 0;
+  if (!bytes || bytes.toString("base64").replace(/=+$/, "") !== value.replace(/=+$/, "")) {
+    throw new Error(
+      `[rango] ${source} is not valid base64. Expected ${EXPECTED}.`
+    );
+  }
+  if (!AES_KEY_BYTES.has(bytes.length)) {
+    throw new Error(
+      `[rango] ${source} decodes to ${bytes.length} bytes. Expected ${EXPECTED}.`
+    );
+  }
+}
+function configureEncryptionKey(option) {
+  if (option !== void 0) {
+    assertValidEncryptionKey(option, "rango({ encryptionKey })");
+    resolvedKey = { key: option, stable: true };
+    return;
+  }
+  const fromEnv = process.env.RANGO_ENCRYPTION_KEY;
+  if (fromEnv !== void 0) {
+    assertValidEncryptionKey(fromEnv, "RANGO_ENCRYPTION_KEY");
+    resolvedKey = { key: fromEnv, stable: true };
+    return;
+  }
+  if (resolvedKey && !resolvedKey.stable) return;
+  resolvedKey = { key: randomBytes(32).toString("base64"), stable: false };
+}
+function resolved() {
+  if (!resolvedKey) configureEncryptionKey(void 0);
+  return resolvedKey;
+}
+function buildEncryptionKey() {
+  return resolved().key;
+}
+function defineEncryptionKeyExpr() {
+  return JSON.stringify(buildEncryptionKey());
+}
+
+// src/vite/plugins/transition-when-hoist.ts
+import { normalizePath as normalizePath3, parseAst as parseAst4 } from "vite";
+import MagicString3 from "magic-string";
+import { builtinModules } from "node:module";
+import { hasDirective as hasDirective2 } from "@vitejs/plugin-rsc/transforms";
+
+// src/vite/plugins/hoist/source.ts
+import { readFile } from "node:fs/promises";
+import { normalizePath as normalizePath2 } from "vite";
+var SOURCE_FILE_RE = /\.[cm]?[jt]sx?$/;
+async function readSource(file) {
+  try {
+    return await readFile(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function resolveSourceTarget(ctx, source, importer, options) {
+  const resolved2 = await ctx.resolve(source, importer);
+  if (!resolved2 || resolved2.external) return null;
+  const target = resolved2.id.split("?", 1)[0];
+  if (target.startsWith("\0")) return null;
+  if (options.skipNodeModules && target.includes("/node_modules/")) {
+    return null;
+  }
+  return target;
+}
+async function recordEmitted(emitted, file, value) {
+  emitted.set(file, { disk: await readSource(file), value });
+}
+async function loadEmittedOrDisk(emitted, hoistedFile, disk, rehoist) {
+  const entry = emitted.get(normalizePath2(hoistedFile));
+  if (entry && (disk === null || entry.disk === disk)) return entry.value;
+  return disk === null ? void 0 : rehoist(disk);
+}
+
+// src/vite/plugins/transition-when-hoist.ts
+var TRANSITION_WHEN_QUERY = "rango-when";
+var EXPORT_NAME = "__rango_when";
+var LOCAL_PREFIX = "__rango_when_";
+var ROUTER_SOURCES = /* @__PURE__ */ new Set(["@rangojs/router"]);
+function findWhenSites(program, scopeOf, moduleScope, imports) {
+  const sites = [];
+  for (const { call, scope } of findHelperCalls(
+    program,
+    scopeOf,
+    moduleScope,
+    imports,
+    {
+      sources: ROUTER_SOURCES,
+      builder: "urls",
+      helper: "transition",
+      directImport: true
+    }
+  )) {
+    if (call.arguments[0]?.type !== "ObjectExpression") continue;
+    for (const prop of call.arguments[0].properties) {
+      if (propertyKeyIs(prop, "when")) {
+        sites.push({ prop, value: unwrapExpression(prop.value), scope });
+      }
+    }
+  }
+  return sites;
+}
+var WHEN_CAPTURE_MESSAGES = {
+  lexical: {
+    this: "`this` in an arrow is the enclosing server function's `this`.",
+    arguments: "`arguments` in an arrow is the enclosing server function's `arguments`.",
+    super: "`super` refers to the enclosing server object.",
+    "new.target": "`new.target` in an arrow is the enclosing server function's."
+  },
+  captureHint: 'Read what you need from `to.params`/`to.state`, or export the predicate from a "use client" module.',
+  loadsHint: 'Import client-safe modules statically, or export the predicate from a "use client" module.',
+  importMetaWhy: "is the server module's.",
+  importMetaMemberWhy: "is resolved against the server module; only `import.meta.env` is available to an inline predicate.",
+  dynamicImportWhy: "loads a module at run time, which the build cannot check is client-safe."
+};
+var NODE_BUILTINS = new Set(builtinModules);
+function isServerOnlySpecifier(source) {
+  return source === "server-only" || source.startsWith("node:") || source.startsWith("cloudflare:") || NODE_BUILTINS.has(source);
+}
+var ROUTER_IMPORT_RE = /["']@rangojs\/router["']/;
+var WHEN_RE = /\bwhen\b/;
+function whenError(file, code, node, detail) {
+  const { line, column } = offsetToLineColumn(code, node.start);
+  return new TransitionWhenError(
+    `[rango] transition({ when }) at ${file}:${line}:${column}: \`when\` runs in the browser; ${detail}`
+  );
+}
+async function hoistTransitionWhens(code, id, deps = {}) {
+  if (!ROUTER_IMPORT_RE.test(code) || !WHEN_RE.test(code)) return null;
+  const file = normalizePath3(id.split("?", 1)[0]);
+  let program;
+  try {
+    program = parseAst4(code, { lang: parseLang(file) });
+  } catch {
+    return null;
+  }
+  if (hasDirective2(program.body, "use client")) return null;
+  const { moduleScope, references, scopeOf } = analyzeScopes(program);
+  const imports = collectImports(program);
+  const sites = findWhenSites(program, scopeOf, moduleScope, imports);
+  if (sites.length === 0) return null;
+  const s = new MagicString3(code);
+  const modules = [];
+  const header = [];
+  for (const site of sites) {
+    const { prop, value } = site;
+    if (prop.kind === "get" || prop.kind === "set") {
+      throw whenError(
+        file,
+        code,
+        prop,
+        `\`${prop.kind} when()\` is an accessor; \`when\` must be the predicate itself: \`when: (ctx) => ...\` or \`when(ctx) { ... }\`.`
+      );
+    }
+    if (value.type === "Identifier") {
+      const decl = site.scope.lookup(value.name);
+      if (decl && !(decl === moduleScope && imports.has(value.name))) {
+        throw whenError(
+          file,
+          code,
+          value,
+          `\`${value.name}\` is a server-module binding. Export the predicate from a "use client" module and import it, or write it inline.`
+        );
+      }
+      continue;
+    }
+    if (!isFunctionLiteral(value)) continue;
+    const lexical = findLexicalCapture(
+      value,
+      references,
+      code,
+      WHEN_CAPTURE_MESSAGES
+    );
+    if (lexical) throw whenError(file, code, lexical.node, lexical.detail);
+    const free = collectFreeReferences(value, references, moduleScope, imports);
+    const binding = free.bindings[0];
+    if (binding) {
+      throw whenError(
+        file,
+        code,
+        binding.node,
+        `\`${binding.node.name}\` is a server-module binding. Read it from \`to.params\`/\`to.state\`, or export the predicate from a "use client" module.`
+      );
+    }
+    const importLines = await emitImports(
+      free.imports,
+      imports,
+      async (local2, imported) => {
+        if (isServerOnlySpecifier(imported.source) || await deps.isServerOnlyImport?.(imported.source)) {
+          throw whenError(
+            file,
+            code,
+            value,
+            `\`${local2}\` is imported from "${imported.source}", a server-only module. Import only client-safe modules into an inline predicate, or export it from a "use client" module.`
+          );
+        }
+      }
+    );
+    const source = prop.method ? `${value.async ? "async " : ""}function${value.generator ? "*" : ""} ` + code.slice(value.start, value.end) : code.slice(value.start, value.end);
+    const index = modules.length;
+    modules.push(
+      [
+        `"use client";`,
+        ...importLines,
+        `export const ${EXPORT_NAME} = ${source};`,
+        ""
+      ].join("\n")
+    );
+    const local = `${LOCAL_PREFIX}${index}`;
+    s.overwrite(
+      prop.start,
+      prop.end,
+      `${code.slice(prop.key.start, prop.key.end)}: ${local}`
+    );
+    header.push(
+      `import { ${EXPORT_NAME} as ${local} } from ${JSON.stringify(
+        `${file}?${TRANSITION_WHEN_QUERY}=${index}`
+      )};`
+    );
+  }
+  if (modules.length === 0) return null;
+  const insertAt = directivePrologueEnd(program);
+  s.appendLeft(insertAt, `${insertAt ? "\n" : ""}${header.join("\n")}
+`);
+  return {
+    code: s.toString(),
+    map: s.generateMap({ hires: true, source: file }),
+    modules
+  };
+}
+function parseHoistedWhenId(id) {
+  const q = id.indexOf("?");
+  if (q === -1) return null;
+  const params = new URLSearchParams(id.slice(q + 1));
+  const raw = params.get(TRANSITION_WHEN_QUERY);
+  if (raw === null || !/^\d+$/.test(raw)) return null;
+  return { file: id.slice(0, q), index: Number(raw) };
+}
+var SERVER_ONLY_IMPORT_RE = /\bimport\s+["']server-only["']/;
+function transitionWhenHoistPlugin() {
+  const emitted = /* @__PURE__ */ new Map();
+  return {
+    name: "@rangojs/router:transition-when-hoist",
+    enforce: "pre",
+    async load(id) {
+      const hoisted = parseHoistedWhenId(id);
+      if (!hoisted) return;
+      const modules = await loadEmittedOrDisk(
+        emitted,
+        hoisted.file,
+        await readSource(hoisted.file),
+        async (disk) => (await hoistTransitionWhens(disk, hoisted.file))?.modules
+      );
+      const module = modules?.[hoisted.index];
+      if (module === void 0) {
+        throw new TransitionWhenError(
+          `[rango] ${hoisted.file} has no inline transition({ when }) #${hoisted.index}.`
+        );
+      }
+      return module;
+    },
+    async transform(code, id) {
+      if (this.environment?.name !== "rsc") return;
+      if (id.includes("/node_modules/") || parseHoistedWhenId(id)) return;
+      const file = normalizePath3(id.split("?", 1)[0]);
+      if (!SOURCE_FILE_RE.test(file)) return;
+      emitted.delete(file);
+      const result = await hoistTransitionWhens(code, id, {
+        isServerOnlyImport: async (source) => {
+          const target = await resolveSourceTarget(this, source, id, {
+            skipNodeModules: true
+          });
+          if (target === null) return false;
+          const text = await readSource(target);
+          return text !== null && SERVER_ONLY_IMPORT_RE.test(text);
+        }
+      });
+      if (!result) return;
+      await recordEmitted(emitted, file, result.modules);
+      return { code: result.code, map: result.map };
+    }
+  };
+}
+
+// src/vite/plugins/client-urls-revalidate-hoist.ts
+import { normalizePath as normalizePath4, parseAst as parseAst5 } from "vite";
+import MagicString4 from "magic-string";
+import { createHash as createHash2 } from "node:crypto";
+import { relative } from "node:path";
+import { hasDirective as hasDirective3 } from "@vitejs/plugin-rsc/transforms";
+var REGISTER = "__rango_registerClientUrlRevalidators";
+var CLIENT_SOURCES = /* @__PURE__ */ new Set(["@rangojs/router/client"]);
+var BROWSER_GLOBALS = /* @__PURE__ */ new Set([
+  "window",
+  "document",
+  "navigator",
+  "localStorage",
+  "sessionStorage",
+  "location",
+  "history"
+]);
+var NOT_A_FUNCTION = /* @__PURE__ */ new Set([
+  "ObjectExpression",
+  "ArrayExpression",
+  "Literal",
+  "TemplateLiteral",
+  "ClassExpression"
+]);
+var CAPTURE_MESSAGES = {
+  lexical: {
+    this: "`this` in an arrow is the enclosing function's `this`.",
+    arguments: "`arguments` in an arrow is the enclosing function's.",
+    super: "`super` refers to the enclosing object.",
+    "new.target": "`new.target` in an arrow is the enclosing function's."
+  },
+  captureHint: "Read what you need from the predicate's argument.",
+  loadsHint: "Import server-safe modules statically.",
+  importMetaWhy: `is the "use client" module's.`,
+  importMetaMemberWhy: 'is resolved against the "use client" module; only `import.meta.env` is available to a hoisted predicate.',
+  dynamicImportWhy: "loads a module at run time, which the build cannot check is server-safe."
+};
+var CLIENT_URLS_RE = /\bclientUrls\b/;
+var REVALIDATE_RE = /\brevalidate\b/;
+var CANDIDATE_RE = /\b(?:clientUrls|revalidate)\b/;
+function mayHoist(code) {
+  return CLIENT_IMPORT_RE.test(code) && REVALIDATE_RE.test(code);
+}
+function isGroupModule(code) {
+  return code.includes("use client") && CLIENT_URLS_RE.test(code) && CLIENT_IMPORT_RE.test(code) && hasUseClientDirective(code);
+}
+function revalidateError(file, code, node, detail) {
+  const { line, column } = offsetToLineColumn(code, node.start);
+  return new Error(
+    `[rango] clientUrls() revalidate() at ${file}:${line}:${column}: revalidate() runs on the server; ${detail}`
+  );
+}
+var FINGERPRINT_SKIP = /* @__PURE__ */ new Set([
+  "type",
+  "start",
+  "end",
+  "loc",
+  "range",
+  "raw",
+  "extra",
+  "shorthand",
+  // TS-only flags (`let x!: T`), lost with the types.
+  "definite",
+  ...TYPE_KEYS
+]);
+function fingerprint(node) {
+  const out = [];
+  const visit = (value) => {
+    if (value === null || value === void 0) return;
+    if (Array.isArray(value)) {
+      out.push("[");
+      for (const item of value) visit(item);
+      out.push("]");
+      return;
+    }
+    if (typeof value !== "object") {
+      out.push(JSON.stringify(typeof value === "bigint" ? `${value}n` : value));
+      return;
+    }
+    let entry = value;
+    if (typeof entry.type === "string") {
+      entry = unwrapExpression(entry);
+      if (entry.type.startsWith("TS")) {
+        visit(entry.expression);
+        return;
+      }
+      out.push(entry.type, "(");
+      if (entry.type === "TemplateElement") {
+        out.push(JSON.stringify(entry.value.raw));
+      }
+    }
+    for (const key of Object.keys(entry)) {
+      if (FINGERPRINT_SKIP.has(key)) continue;
+      if (key === "optional" && entry.type === "Identifier") continue;
+      out.push(key);
+      visit(entry[key]);
+    }
+    if (typeof entry.type === "string") out.push(")");
+  };
+  visit(node);
+  return out.join(" ");
+}
+function keyOf(relativeFile, predicate) {
+  return createHash2("sha256").update(relativeFile).update("\0").update(fingerprint(predicate)).digest("hex").slice(0, 12);
+}
+async function hoistClientUrlsRevalidates(code, id, deps) {
+  if (!mayHoist(code)) return null;
+  const file = normalizePath4(id.split("?", 1)[0]);
+  const program = parseProgram(code, file);
+  if (!program) return null;
+  const { moduleScope, references, scopeOf } = analyzeScopes(program);
+  const imports = collectImports(program);
+  const calls = findHelperCalls(program, scopeOf, moduleScope, imports, {
+    sources: CLIENT_SOURCES,
+    builder: "clientUrls",
+    helper: "revalidate",
+    directImport: true
+  });
+  if (calls.length === 0) return null;
+  const relativeFile = normalizePath4(relative(deps.root, file));
+  const s = new MagicString4(code);
+  const used = /* @__PURE__ */ new Map();
+  const entries = /* @__PURE__ */ new Map();
+  for (const { call } of calls) {
+    const [arg, extra] = call.arguments;
+    if (!arg || extra || arg.type === "SpreadElement") {
+      throw revalidateError(
+        file,
+        code,
+        call,
+        "`revalidate()` takes exactly one predicate or boolean."
+      );
+    }
+    const value = unwrapExpression(arg);
+    if (value.type === "Literal" && typeof value.value === "boolean") continue;
+    if (NOT_A_FUNCTION.has(value.type)) {
+      throw revalidateError(
+        file,
+        code,
+        value,
+        "`revalidate()` expects a predicate function or a boolean."
+      );
+    }
+    if (isFunctionLiteral(value) && (value.async || value.generator)) {
+      throw revalidateError(
+        file,
+        code,
+        value,
+        `a${value.async ? "n `async`" : " generator"} function returns ${value.async ? "a Promise" : "an iterator"}, which the router ignores: return a boolean, \`{ defaultShouldRevalidate }\`, or nothing.`
+      );
+    }
+    const lexical = findLexicalCapture(
+      value,
+      references,
+      code,
+      CAPTURE_MESSAGES
+    );
+    if (lexical)
+      throw revalidateError(file, code, lexical.node, lexical.detail);
+    const free = collectFreeReferences(value, references, moduleScope, imports);
+    const binding = free.bindings[0];
+    if (binding) {
+      const name = binding.node.name;
+      throw revalidateError(
+        file,
+        code,
+        binding.node,
+        binding.scope.lookup(name) === moduleScope ? `\`${name}\` is declared in this ` + (hasDirective3(program.body, "use client") ? '"use client" module' : "module") + '. Move the predicate to its own module (without "use client") and import it, or write it inline.' : `\`${name}\` is a binding of the enclosing function. Read what you need from the predicate's argument (\`currentParams\`, \`nextUrl\`, \`context\`, \`actionResult\`, ...).`
+      );
+    }
+    const browserGlobal = free.globals.find(
+      (ref) => BROWSER_GLOBALS.has(ref.node.name)
+    );
+    if (browserGlobal) {
+      throw revalidateError(
+        file,
+        code,
+        browserGlobal.node,
+        `\`${browserGlobal.node.name}\` is a browser global. Put the input on the request (a cookie or a search param) and read it from the predicate's argument, or refresh the loader with useRefreshLoaders.`
+      );
+    }
+    const unchecked = [...free.imports].filter(
+      ([local, valueUse]) => valueUse && !used.get(local)
+    );
+    const clientOnly = await Promise.all(
+      unchecked.map(([local]) => isClientOnly(imports.get(local), deps))
+    );
+    const offender = unchecked.find((_, i) => clientOnly[i]);
+    if (offender) {
+      const [local] = offender;
+      throw revalidateError(
+        file,
+        code,
+        value,
+        `\`${local}\` is imported from "${imports.get(local).source}", a client-only module: on the server a "use client" module's exports are client references and cannot be called. Import the predicate's inputs from a module without "use client".`
+      );
+    }
+    for (const [local, valueUse] of free.imports) {
+      used.set(local, (used.get(local) ?? false) || valueUse);
+    }
+    const source = code.slice(value.start, value.end);
+    const key = keyOf(relativeFile, value);
+    entries.set(key, source);
+    s.overwrite(
+      arg.start,
+      arg.end,
+      `{ ${HOISTED_REVALIDATE_KEY}: ${JSON.stringify(key)} }`
+    );
+  }
+  if (entries.size === 0) return null;
+  const importLines = await emitImports(used, imports, () => {
+  });
+  const module = [
+    `import { registerClientUrlRevalidators as ${REGISTER} } from "@rangojs/router/server";`,
+    ...importLines,
+    `${REGISTER}({`,
+    ...[...entries].map(
+      ([key, source]) => `  ${JSON.stringify(key)}: ${source},`
+    ),
+    `});`,
+    ""
+  ].join("\n");
+  return {
+    code: s.toString(),
+    map: s.generateMap({ hires: true, source: file }),
+    module,
+    keys: [...entries.keys()]
+  };
+}
+async function isClientOnly(binding, deps) {
+  return binding.source === "client-only" || Boolean(await deps.isClientModule?.(binding.source));
+}
+function parseProgram(code, file) {
+  try {
+    return parseAst5(code, { lang: parseLang(file) });
+  } catch {
+    return null;
+  }
+}
+function parseHoistedRevalidateId(id) {
+  const q = id.indexOf("?");
+  if (q === -1) return null;
+  const params = new URLSearchParams(id.slice(q + 1));
+  return params.has(CLIENT_URLS_REVALIDATE_QUERY) ? id.slice(0, q) : null;
+}
+var HOISTED_ID_RE = new RegExp(
+  `[?&]${CLIENT_URLS_REVALIDATE_QUERY}(?:[=&]|$)`
+);
+var SOURCE_ID_RE = /\.[cm]?[jt]sx?(?:\?|$)/;
+var NODE_MODULES_RE = /\/node_modules\//;
+var USE_ASSIGNMENT_RE = /\.use\s*=/;
+function clientUrlsRevalidateHoistPlugin(index) {
+  const emitted = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Set();
+  const clientModules = /* @__PURE__ */ new Map();
+  const useSignatures = /* @__PURE__ */ new Map();
+  let root = process.cwd();
+  const isClientFile = (file) => {
+    let known = clientModules.get(file);
+    if (!known) {
+      known = readSource(file).then(
+        (text) => text !== null && text.includes("use client") && hasUseClientDirective(text)
+      );
+      clientModules.set(file, known);
+    }
+    return known;
+  };
+  const clientModuleCheck = (ctx, importer) => async (source) => {
+    const target = await resolveSourceTarget(ctx, source, importer, {
+      skipNodeModules: false
+    });
+    return target !== null && await isClientFile(target);
+  };
+  return [
+    {
+      name: "@rangojs/router:client-urls-revalidate-hoist",
+      enforce: "pre",
+      configResolved(config) {
+        root = normalizePath4(config.root);
+      },
+      buildStart() {
+        clientModules.clear();
+      },
+      watchChange(id) {
+        const file = normalizePath4(id);
+        clientModules.delete(file);
+        emitted.delete(file);
+        groups.delete(file);
+      },
+      load: {
+        filter: { id: HOISTED_ID_RE },
+        async handler(id) {
+          const hoistedFile = parseHoistedRevalidateId(id);
+          if (hoistedFile === null) return;
+          const file = normalizePath4(hoistedFile);
+          const registrations = await loadEmittedOrDisk(
+            emitted,
+            file,
+            await readSource(file),
+            async (source) => (await hoistClientUrlsRevalidates(source, file, {
+              root,
+              isClientModule: clientModuleCheck(this, file)
+            }))?.module
+          );
+          const assigned = index.filesByGroup.get(file) ?? [];
+          const code = registrations === void 0 && assigned.length === 0 ? "export {};\n" : [
+            registrations ?? "",
+            ...assigned.map(
+              (target) => `import ${JSON.stringify(hoistedRevalidateId(target))};
+`
+            )
+          ].join("");
+          return { code, moduleSideEffects: "no-treeshake" };
+        }
+      },
+      transform: {
+        filter: {
+          id: {
+            include: SOURCE_ID_RE,
+            exclude: [NODE_MODULES_RE, HOISTED_ID_RE]
+          },
+          code: CANDIDATE_RE
+        },
+        async handler(code, id) {
+          if (id.includes("/node_modules/") || parseHoistedRevalidateId(id)) {
+            return;
+          }
+          const file = normalizePath4(id.split("?", 1)[0]);
+          if (!SOURCE_FILE_RE.test(file)) return;
+          const rsc = this.environment?.name === "rsc";
+          if (rsc) {
+            emitted.delete(file);
+            if (isGroupModule(code)) groups.add(file);
+            else groups.delete(file);
+          }
+          const result = await hoistClientUrlsRevalidates(code, id, {
+            root,
+            isClientModule: rsc ? clientModuleCheck(this, id) : void 0
+          });
+          if (!result) return;
+          for (const key of result.keys) index.fileByKey.set(key, file);
+          if (rsc) await recordEmitted(emitted, file, result.module);
+          return { code: result.code, map: result.map };
+        }
+      }
+    },
+    {
+      name: "@rangojs/router:client-urls-revalidate-register",
+      enforce: "post",
+      applyToEnvironment: (env) => env.name === "rsc",
+      transform: {
+        filter: { code: "registerClientReference" },
+        handler(code, id) {
+          if (parseHoistedRevalidateId(id)) return;
+          const file = normalizePath4(id.split("?", 1)[0]);
+          if (!groups.has(file)) return;
+          const s = new MagicString4(code);
+          s.append(`
+import ${JSON.stringify(hoistedRevalidateId(file))};
+`);
+          return { code: s.toString(), map: s.generateMap({ hires: true }) };
+        }
+      }
+    },
+    {
+      name: "@rangojs/router:client-urls-component-use-hmr",
+      apply: "serve",
+      applyToEnvironment: (env) => env.name === "client",
+      transform: {
+        filter: {
+          id: { include: SOURCE_ID_RE, exclude: [NODE_MODULES_RE] },
+          code: USE_ASSIGNMENT_RE
+        },
+        async handler(_code, id) {
+          const file = normalizePath4(id.split("?", 1)[0]);
+          const disk = await readSource(file);
+          const signature = disk && componentUseSignature(disk, file);
+          if (signature) useSignatures.set(file, signature);
+        }
+      },
+      async hotUpdate({ file, modules, read }) {
+        if (modules.length === 0 || !SOURCE_FILE_RE.test(file)) return;
+        const next = componentUseSignature(await read(), file);
+        if (next === useSignatures.get(file)) return;
+        if (next === void 0) useSignatures.delete(file);
+        else useSignatures.set(file, next);
+        const updated = new Set(modules);
+        for (const mod of modules) {
+          for (const importer of mod.importers) updated.add(importer);
+        }
+        return [...updated];
+      }
+    }
+  ];
+}
+
+// src/vite/temp-rsc-server.ts
+var loaderHookRegistered = false;
+function ensureCloudflareProtocolLoaderRegistered() {
+  if (loaderHookRegistered) return;
+  loaderHookRegistered = true;
+  try {
+    register(
+      new URL("./plugins/cloudflare-protocol-loader-hook.mjs", import.meta.url)
+    );
+  } catch (err) {
+    console.warn(
+      `[rango] Could not register Node ESM loader hook for cloudflare:* imports (${err?.message ?? err}). Falling back to Vite transform only.`
+    );
+  }
+}
+async function createTempRscServer(state, options = {}) {
+  ensureCloudflareProtocolLoaderRegistered();
+  const { default: rsc } = await import("@vitejs/plugin-rsc");
+  const runnerConfig = state.userRunnerConfig;
+  const resolveConfig = runnerConfig?.resolve ?? {
+    alias: state.userResolveAlias
+  };
+  const oxcConfig = runnerConfig?.oxc ?? {
+    jsx: { runtime: "automatic", importSource: "react" }
+  };
+  return createViteServer({
+    root: state.projectRoot,
+    configFile: false,
+    server: {
+      middlewareMode: true,
+      // Build mode: no file watching. buildStart installs the per-router tries
+      // into this realm and runShellPrerenderPhase reuses it after the bundles
+      // are written. A watched write in between (writeRouteTypesFiles' own
+      // <router>.named-routes.gen.ts, which every router file imports) can
+      // make Vite full-reload the RSC runner; the shell phase then matches in
+      // a fresh realm with no tries and a root path("/*") wins (#947).
+      ...options.forceBuild ? { watch: null } : {}
+    },
+    appType: "custom",
+    logLevel: "silent",
+    resolve: resolveConfig,
+    ...runnerConfig?.define ? { define: runnerConfig.define } : {},
+    oxc: oxcConfig,
+    ...options.cacheDir && { cacheDir: options.cacheDir },
+    plugins: [
+      rsc({
+        entries: {
+          client: "virtual:entry-client",
+          ssr: "virtual:entry-ssr",
+          rsc: state.resolvedEntryPath
+        },
+        // The temp server renders Static/Prerender output and encrypts inline-
+        // action bound args. Give it the SAME key as the main build/dev runtime
+        // (defineEncryptionKeyExpr is process-cached) so those args decrypt at
+        // invocation. Unconditional, NOT build-only: under Cloudflare/workerd dev
+        // the RSC env has no module runner, so prerender is rendered by THIS temp
+        // server (via /__rsc_prerender), and the action decrypts in the main
+        // runtime with the rango.ts key -- gating on forceBuild left dev encrypting
+        // with the temp server's own random key, failing decryptActionBoundArgs.
+        // (hashServerRefs stays build-only: dev keeps dev-style ids the dev runtime
+        // resolves directly.)
+        defineEncryptionKey: defineEncryptionKeyExpr()
+      }),
+      // hashClientRefs/hashServerRefs only in build mode — production bundles
+      // need hashed refs. hashServerRefs is the server-side analog: it rewrites
+      // registerServerReference dev-style ids to production hashes so a
+      // server-created action embedded in prerendered/static Flight resolves
+      // against the production manifest on a build-time-cache hit.
+      ...options.forceBuild ? [hashClientRefs(state.projectRoot), hashServerRefs(state.projectRoot)] : [],
+      createVersionPlugin(),
+      // Before the stub plugin, so "virtual:entry-ssr" resolves to the real
+      // SSR entry when the shell endpoint needs it (see the option doc).
+      ...options.realSsrEntry ? [
+        {
+          name: "@rangojs/router:temp-real-ssr-entry",
+          enforce: "pre",
+          resolveId(id) {
+            return id === "virtual:entry-ssr" ? "\0rango-temp-real-ssr-entry" : null;
+          },
+          load(id) {
+            return id === "\0rango-temp-real-ssr-entry" ? getVirtualEntrySSR(
+              state.opts?.headScripts,
+              state.opts?.progressiveChunkSize
+            ) : null;
+          }
+        }
+      ] : [],
+      createVirtualStubPlugin(),
+      createCloudflareProtocolStubPlugin(),
+      // Inline transition({ when }) literals become client references here
+      // too, or discovery would see (and reject) the plain function.
+      transitionWhenHoistPlugin(),
+      // clientUrls() revalidate() predicates move to the server here too:
+      // discovery serializes the SSR copy's markers and the RSC realm
+      // registers the predicates the materialized stubs call. The index is
+      // the main plugin's, so its group modules import the files assigned here.
+      ...clientUrlsRevalidateHoistPlugin(state.clientUrlRevalidate),
+      // Dev prerender must use dev-mode IDs (path-based) to match the workerd
+      // runtime. forceBuild produces hashed IDs for production bundle consistency.
+      exposeInternalIds(options.forceBuild ? { forceBuild: true } : void 0),
+      exposeRouterId(),
+      {
+        name: "@rangojs/router:client-urls-source-tracking",
+        enforce: "pre",
+        transform(code, id) {
+          recordClientUrlsModule(state, code, id);
+        }
+      },
+      // Forwarded user resolution plugins (e.g. vite-tsconfig-paths). Stripped
+      // to resolveId/load (plus transform for import rewriters, see
+      // IMPORT_REWRITE_PLUGINS) and placed last so framework resolution runs first;
+      // Vite re-sorts by `enforce`, so `enforce: "pre"` resolvers still lead.
+      ...state.userResolvePlugins,
+      ...options.plugins ?? []
+    ]
+  });
+}
+export {
+  createTempRscServer
+};