@rangojs/router 0.32.0 → 0.33.0

package/dist/bin/chunk-TTXC2U3G.js

@@ -0,0 +1,2477 @@
+import {
+  notifyListeners,
+  prefetchDirect,
+  prefetchQueued,
+  schedulePrefetchWhenRouterIdle
+} from "./chunk-3B7CKBRO.js";
+import {
+  findTsFiles,
+  firstCodeMatchIndex,
+  prefixBasename
+} from "./chunk-LD7UBHT4.js";
+
+// src/vite/discovery/client-urls-projection.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, relative as relative2, resolve } from "node:path";
+import { normalizePath, parseAst as parseAst2 } from "vite";
+
+// src/client-urls/server-projection.ts
+import * as React4 from "react";
+
+// src/server/context.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+
+// src/rsc/shell-capture-constants.ts
+var PPR_LANE_HINT = 'Lane rule: only loader(Def, { ssr: false }) executes at capture and bakes its non-promise data; every other loader is live (masked at capture, fresh per request) and needs loading() or an inline <Suspense> above its reader. See the /ppr skill, "The loader lane rule" (node_modules/@rangojs/router/skills/ppr/SKILL.md).';
+
+// src/cache/cache-exec-scope.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// src/cache/taint.ts
+var cacheExecScopeProbe = () => false;
+function _setCacheExecScopeProbe(probe) {
+  cacheExecScopeProbe = probe;
+}
+
+// src/cache/cache-exec-scope.ts
+var cacheExecStorage = new AsyncLocalStorage();
+var IDENTITY_EXEMPT_KEY = /* @__PURE__ */ Symbol.for("rangojs-router:identity-exempt");
+var identityExemptStorage = globalThis[IDENTITY_EXEMPT_KEY] ??= new AsyncLocalStorage();
+function isInsideCacheExecScope() {
+  return cacheExecStorage.getStore() !== void 0;
+}
+_setCacheExecScopeProbe(isInsideCacheExecScope);
+
+// src/server/context.ts
+var RSC_CONTEXT_KEY = /* @__PURE__ */ Symbol.for("rangojs-router:rsc-context");
+var RangoContext = globalThis[RSC_CONTEXT_KEY] ??= new AsyncLocalStorage2();
+var LOADER_SCOPE_KEY = /* @__PURE__ */ Symbol.for("rangojs-router:loader-scope");
+var loaderScopeALS = globalThis[LOADER_SCOPE_KEY] ??= new AsyncLocalStorage2();
+var LOADER_BODY_SCOPE_KEY = /* @__PURE__ */ Symbol.for("rangojs-router:loader-body-scope");
+var loaderBodyScopeALS = globalThis[LOADER_BODY_SCOPE_KEY] ??= new AsyncLocalStorage2();
+function requestReadCaptureFix(what) {
+  return {
+    capture: `The captured shell is served to every user of this URL, so request-scoped data read here would leak one user's ${what} to others. Read it inside a loader without ssr: false and consume it with useLoader, e.g. createLoader(async () => getUser(cookies().get("session")?.value)). ${PPR_LANE_HINT}`,
+    warning: "Read it in a loader without ssr: false and consume it with useLoader under loading() or an inline <Suspense> (a live hole). A promise the handler passes or pushes does not help: the capture waits for it."
+  };
+}
+var NON_CACHEABLE_READ = {
+  verb: "called",
+  fix: {
+    useCache: "The variable was created with { cache: false } or set with { cache: false }, and the cache key does not include its value, so the first caller's value would be served to later callers. Read it before calling the cached function and pass the value in as an argument so it becomes part of the cache key.",
+    cacheScope: "The variable was created with { cache: false } or set with { cache: false }, and its value would be stale on cache hit. Move the read outside the cached scope.",
+    ...requestReadCaptureFix("per-request variables")
+  }
+};
+var loaderRunALS = globalThis[/* @__PURE__ */ Symbol.for("rangojs-router:loader-run-identity")] ??= new AsyncLocalStorage2();
+function getLoaderBodyTags() {
+  return loaderBodyScopeALS.getStore()?.tags;
+}
+function getCurrentLoaderBodyId() {
+  return loaderBodyScopeALS.getStore()?.loaderId;
+}
+var segmentPinALS = globalThis[/* @__PURE__ */ Symbol.for("rangojs-router:segment-pin")] ??= new AsyncLocalStorage2();
+var PUSH_CALLBACK_SCOPE_KEY = /* @__PURE__ */ Symbol.for(
+  "rangojs-router:push-callback-scope"
+);
+var pushCallbackScopeALS = globalThis[PUSH_CALLBACK_SCOPE_KEY] ??= new AsyncLocalStorage2();
+
+// src/transition-when-ref.ts
+var TransitionWhenError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "TransitionWhenError";
+  }
+};
+
+// src/runtime-env.ts
+function isUnderTestRunner() {
+  return !!globalThis.process?.env?.VITEST;
+}
+
+// src/client.tsx
+import {
+  Component as Component3,
+  createElement as createElement4,
+  isValidElement as isValidElement2,
+  useContext as useContext18,
+  useMemo as useMemo9,
+  Suspense as Suspense2
+} from "react";
+
+// src/browser/react/use-handle.ts
+import { useContext as useContext2, useState as useState2, useEffect as useEffect2, useRef as useRef2 } from "react";
+
+// src/missing-id-error.ts
+var SELF_FILES = /* @__PURE__ */ new Set([
+  "missing-id-error",
+  "loader",
+  "loader.rsc",
+  "handle"
+]);
+function findUserCallSite() {
+  try {
+    const stack = new Error().stack;
+    if (!stack) return void 0;
+    for (const frame of stack.split("\n").slice(1)) {
+      const m = frame.match(
+        /(?:\(|@|\s)(?:file:\/\/)?((?:\/|[A-Za-z]:[\\/])[^()\s]+?\.(?:ts|tsx|js|jsx|mts|cts)):(\d+):(\d+)\)?/
+      );
+      if (!m) continue;
+      const path = m[1];
+      if (path.includes("node_modules") || path.includes("@rangojs/router")) {
+        continue;
+      }
+      const base = path.split(/[\\/]/).pop().replace(/\.(?:ts|tsx|js|jsx|mts|cts)$/, "");
+      if (SELF_FILES.has(base)) continue;
+      return `${path}:${m[2]}:${m[3]}`;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function missingInjectedIdError(kind, fnName) {
+  const site = findUserCallSite();
+  const at = site ? ` (created at ${site})` : "";
+  return new Error(
+    `[rango] ${kind} is missing $$id${at}.
+The @rangojs/router:expose-internal-ids Vite transform injects ${fnName}()'s stable $$id from an EXPORTED const declaration only:
+  export const X = ${fnName}(...)
+  const X = ${fnName}(...); export { X }
+A non-exported const, an \`export let/var\`, or an inline ${fnName}(...) call gets no $$id \u2014 export it as \`export const\`. (A matching "Unsupported ${fnName} shape" warning names the exact file:line.)`
+  );
+}
+
+// src/handle.ts
+function defaultCollect(segments) {
+  return segments;
+}
+var collectRegistry = /* @__PURE__ */ new Map();
+var runtimeHandleIdCounter = 0;
+function createHandle(collect, __injectedId) {
+  let handleId = __injectedId ?? "";
+  if (!handleId) {
+    if (isUnderTestRunner()) {
+      handleId = `__rango_runtime_handle_${runtimeHandleIdCounter++}`;
+    } else if (process.env.NODE_ENV !== "production") {
+      throw missingInjectedIdError("Handle", "createHandle");
+    } else {
+      throw new Error(
+        "[rango] Handle is missing $$id \u2014 the build plugin did not inject one. Export it as `export const X = createHandle(...)`."
+      );
+    }
+  }
+  const collectFn = collect ?? defaultCollect;
+  collectRegistry.set(
+    handleId,
+    collectFn
+  );
+  return {
+    __brand: "handle",
+    $$id: handleId
+  };
+}
+
+// src/browser/react/context.ts
+import { createContext } from "react";
+var NavigationStoreContext = createContext(null);
+var LocationStateContext = createContext(void 0);
+var HydrationBarrierContext = createContext(0);
+
+// src/browser/react/use-route-state.ts
+import {
+  useContext,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useState
+} from "react";
+var NO_ROUTE = {
+  location: new URL("/", "http://localhost"),
+  params: Object.freeze({})
+};
+
+// src/handles/meta.ts
+function isUnsetDescriptor(descriptor) {
+  return typeof descriptor === "object" && descriptor !== null && "unset" in descriptor && typeof descriptor.unset === "string";
+}
+function isTitleDescriptor(descriptor) {
+  return typeof descriptor === "object" && descriptor !== null && "title" in descriptor;
+}
+function isTitleTemplate(title) {
+  return typeof title === "object" && title !== null && "template" in title && "default" in title;
+}
+function isAbsoluteTitle(title) {
+  return typeof title === "object" && title !== null && "absolute" in title;
+}
+function getMetaKey(descriptor) {
+  if (isUnsetDescriptor(descriptor)) {
+    return void 0;
+  }
+  if ("charSet" in descriptor) {
+    return "charSet";
+  }
+  if ("title" in descriptor) {
+    return "title";
+  }
+  if ("name" in descriptor && "content" in descriptor) {
+    return `name:${descriptor.name}`;
+  }
+  if ("property" in descriptor && "content" in descriptor) {
+    return `property:${descriptor.property}`;
+  }
+  if ("httpEquiv" in descriptor && "content" in descriptor) {
+    return `httpEquiv:${descriptor.httpEquiv}`;
+  }
+  if ("script:ld+json" in descriptor) {
+    return void 0;
+  }
+  if ("tagName" in descriptor) {
+    if (descriptor.tagName === "link" && "rel" in descriptor) {
+      const uniqueRels = ["canonical", "icon", "apple-touch-icon"];
+      if (uniqueRels.includes(descriptor.rel)) {
+        return `link:${descriptor.rel}`;
+      }
+    }
+    return void 0;
+  }
+  return void 0;
+}
+var defaultMetaDescriptors = [
+  { charSet: "utf-8" },
+  { name: "viewport", content: "width=device-width, initial-scale=1" }
+];
+function addOrReplace(result, keyToIndex, descriptor, key) {
+  if (key !== void 0 && keyToIndex.has(key)) {
+    result[keyToIndex.get(key)] = descriptor;
+  } else {
+    if (key !== void 0) {
+      keyToIndex.set(key, result.length);
+    }
+    result.push(descriptor);
+  }
+}
+function updateIndicesAfterRemoval(keyToIndex, removedIndex) {
+  for (const [key, index] of keyToIndex) {
+    if (index > removedIndex) {
+      keyToIndex.set(key, index - 1);
+    }
+  }
+}
+function collectMeta(segments) {
+  const result = [];
+  const keyToIndex = /* @__PURE__ */ new Map();
+  let titleTemplate;
+  for (const descriptor of defaultMetaDescriptors) {
+    const key = getMetaKey(descriptor);
+    if (key !== void 0) {
+      keyToIndex.set(key, result.length);
+    }
+    result.push(descriptor);
+  }
+  for (const descriptors of segments) {
+    for (const descriptor of descriptors) {
+      if (isUnsetDescriptor(descriptor)) {
+        const keyToRemove = descriptor.unset;
+        if (keyToIndex.has(keyToRemove)) {
+          const idx = keyToIndex.get(keyToRemove);
+          result.splice(idx, 1);
+          keyToIndex.delete(keyToRemove);
+          updateIndicesAfterRemoval(keyToIndex, idx);
+        }
+        continue;
+      }
+      if (isTitleDescriptor(descriptor)) {
+        const titleValue = descriptor.title;
+        if (isTitleTemplate(titleValue)) {
+          titleTemplate = titleValue.template;
+          addOrReplace(
+            result,
+            keyToIndex,
+            { title: titleValue.default },
+            "title"
+          );
+          continue;
+        }
+        if (isAbsoluteTitle(titleValue)) {
+          addOrReplace(
+            result,
+            keyToIndex,
+            { title: titleValue.absolute },
+            "title"
+          );
+          continue;
+        }
+        const finalTitle = titleTemplate ? titleTemplate.split("%s").join(titleValue) : titleValue;
+        addOrReplace(
+          result,
+          keyToIndex,
+          { title: finalTitle },
+          "title"
+        );
+        continue;
+      }
+      const key = getMetaKey(descriptor);
+      addOrReplace(result, keyToIndex, descriptor, key);
+    }
+  }
+  return result;
+}
+var Meta = createHandle(collectMeta, "__rsc_router_meta__");
+
+// src/theme/theme-context.ts
+import { createContext as createContext2, useContext as useContext3 } from "react";
+var ThemeContext = createContext2(null);
+
+// src/browser/react/nonce-context.ts
+import { createContext as createContext3, useContext as useContext4 } from "react";
+var NonceContext = createContext3(void 0);
+
+// src/handles/MetaTags.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+// src/handles/Scripts.tsx
+import { useState as useState3 } from "react";
+
+// src/handles/script.ts
+function validateConfigDev(config) {
+  if (process.env.NODE_ENV === "production") return;
+  const c = config;
+  if (c.src != null && c.children != null) {
+    console.warn(
+      `[Script] A config has both "src" and "children"; they are mutually exclusive \u2014 "src" wins and the inline body is ignored.`
+    );
+  } else if (c.src == null && c.children == null) {
+    console.warn(
+      `[Script] A config has neither "src" nor "children"; it injects nothing.`
+    );
+  } else if (c.src == null && c.id == null) {
+    console.warn(
+      `[Script] An inline script was pushed without an "id" and cannot be deduplicated. Pass an "id" so a layout + child pushing the same script inject it only once.`
+    );
+  }
+  if (c.async && c.defer) {
+    console.warn(
+      `[Script] A config has both "async" and "defer"; they are mutually exclusive.`
+    );
+  }
+}
+function collectScripts(segments) {
+  const result = [];
+  const keyToIndex = /* @__PURE__ */ new Map();
+  for (const configs of segments) {
+    for (const config of configs) {
+      validateConfigDev(config);
+      const isAsyncResource = config.src != null && config.async === true;
+      const key = isAsyncResource ? config.src : config.id ?? config.src;
+      if (key === void 0) {
+        result.push(config);
+        continue;
+      }
+      const existing = keyToIndex.get(key);
+      if (existing !== void 0) {
+        result[existing] = config;
+      } else {
+        keyToIndex.set(key, result.length);
+        result.push(config);
+      }
+    }
+  }
+  return result;
+}
+var Script = createHandle(collectScripts, "__rsc_router_script__");
+
+// src/handles/Scripts.tsx
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+
+// src/browser/react/ScrollRestoration.tsx
+import { useEffect as useEffect3 } from "react";
+
+// src/outlet-context.ts
+import { createContext as createContext4 } from "react";
+var OutletContext = createContext4(null);
+
+// src/route-content-wrapper.tsx
+import { Component, Suspense, use as use2, useMemo as useMemo3 } from "react";
+
+// src/outlet-provider.tsx
+import {
+  useContext as useContext5,
+  useMemo
+} from "react";
+
+// src/suspense-audit-react.tsx
+import { useEffect as useEffect4, useLayoutEffect as useLayoutEffect2, useRef as useRef3 } from "react";
+
+// src/internal-suspense-audit.ts
+var INTERNAL_RANGO_SUSPENSE_AUDIT = typeof process !== "undefined" && Boolean(process.env?.INTERNAL_RANGO_SUSPENSE_AUDIT);
+
+// src/outlet-provider.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+
+// src/decode-loader-results.ts
+import { createElement as createElement2 } from "react";
+
+// src/loader-redirect.tsx
+import { useEffect as useEffect5 } from "react";
+
+// src/browser/react/use-router.ts
+import { useContext as useContext7, useMemo as useMemo2 } from "react";
+
+// src/browser/react/use-mount.ts
+import { useContext as useContext6 } from "react";
+
+// src/browser/react/mount-context.ts
+import {
+  createContext as createContext5,
+  createElement
+} from "react";
+var MountContext = createContext5("/");
+
+// src/browser/app-version.ts
+var currentVersion;
+function getAppVersion() {
+  return currentVersion;
+}
+
+// src/href-client.ts
+function href(path, mount) {
+  if (mount && mount !== "/") {
+    const normalizedMount = mount.endsWith("/") ? mount.slice(0, -1) : mount;
+    return normalizedMount + path;
+  }
+  return path;
+}
+function createResponseHrefTag() {
+  return (path, mount) => ({
+    to: href(path, mount),
+    "data-external": ""
+  });
+}
+((href2) => {
+  href2.json = createResponseHrefTag();
+  href2.text = createResponseHrefTag();
+  href2.html = createResponseHrefTag();
+  href2.xml = createResponseHrefTag();
+  href2.md = createResponseHrefTag();
+  href2.image = createResponseHrefTag();
+  href2.stream = createResponseHrefTag();
+  href2.any = createResponseHrefTag();
+})(href || (href = {}));
+
+// src/browser/defer.ts
+import { use } from "react";
+
+// src/thenable-status.ts
+var SETTLED_THENABLE = Object.assign(
+  Promise.resolve(void 0),
+  { status: "fulfilled", value: void 0, _debugInfo: [] }
+);
+
+// src/route-content-wrapper.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+import { createElement as createElement3 } from "react";
+
+// src/use-loader.tsx
+import {
+  isValidElement,
+  startTransition,
+  use as use3,
+  useCallback,
+  useContext as useContext8,
+  useEffect as useEffect6,
+  useMemo as useMemo4,
+  useOptimistic,
+  useRef as useRef4,
+  useState as useState4
+} from "react";
+
+// src/loader-store.ts
+var EMPTY_SNAPSHOT = Object.freeze({
+  value: void 0,
+  hasValue: false,
+  error: null,
+  isLoading: false,
+  requestId: 0
+});
+
+// src/client-urls/hoisted-revalidate.ts
+var HOISTED_REVALIDATE_KEY = "$$rangoRevalidate";
+function isHoistedRevalidateRef(value) {
+  return typeof value === "object" && value !== null && typeof value[HOISTED_REVALIDATE_KEY] === "string";
+}
+
+// src/browser/react/use-navigation.ts
+import { useContext as useContext9, useEffect as useEffect7, useRef as useRef5 } from "react";
+
+// src/browser/react/use-pathname.ts
+import { useContext as useContext10 } from "react";
+
+// src/client-urls/optimistic-location.ts
+import { createContext as createContext6 } from "react";
+var OptimisticLocationContext = createContext6(null);
+
+// src/browser/react/use-search-params.ts
+import { useCallback as useCallback2, useContext as useContext11, useMemo as useMemo5 } from "react";
+
+// src/browser/react/use-params.ts
+import { useContext as useContext12 } from "react";
+
+// src/browser/react/use-action.ts
+import { useContext as useContext13, useState as useState5, useEffect as useEffect8, useRef as useRef6 } from "react";
+
+// src/browser/react/location-state-shared.ts
+function isLocationStateDefinition(value) {
+  return typeof value === "function" && "__rsc_ls_flash" in value;
+}
+
+// src/browser/event-controller.ts
+if (typeof Symbol.dispose === "undefined") {
+  Symbol.dispose = /* @__PURE__ */ Symbol("Symbol.dispose");
+}
+if (typeof Symbol.asyncDispose === "undefined") {
+  Symbol.asyncDispose = /* @__PURE__ */ Symbol("Symbol.asyncDispose");
+}
+var locationChangeSubscriptions = /* @__PURE__ */ new WeakMap();
+function subscribeToLocationChange(eventController, listener) {
+  let subscription = locationChangeSubscriptions.get(eventController);
+  if (!subscription) {
+    subscription = {
+      registrations: /* @__PURE__ */ new Map(),
+      notificationVersion: 0,
+      unsubscribe: () => {
+      }
+    };
+    locationChangeSubscriptions.set(eventController, subscription);
+    const currentSubscription = subscription;
+    subscription.unsubscribe = eventController.subscribe(() => {
+      const notificationVersion = ++currentSubscription.notificationVersion;
+      const nextHref = eventController.getState().location.href;
+      notifyListeners(
+        [...currentSubscription.registrations],
+        ([, registration]) => {
+          if (registration.href === nextHref) return;
+          registration.href = nextHref;
+          registration.listener(nextHref);
+        },
+        ([token2, registration]) => currentSubscription.registrations.get(token2) === registration,
+        () => notificationVersion === currentSubscription.notificationVersion
+      );
+    });
+  }
+  const token = /* @__PURE__ */ Symbol();
+  subscription.registrations.set(token, {
+    href: eventController.getState().location.href,
+    listener
+  });
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    subscription.registrations.delete(token);
+    if (subscription.registrations.size > 0) return;
+    if (locationChangeSubscriptions.get(eventController) === subscription) {
+      locationChangeSubscriptions.delete(eventController);
+    }
+    subscription.unsubscribe();
+  };
+}
+
+// src/browser/react/use-segments.ts
+import { useContext as useContext14, useEffect as useEffect9, useRef as useRef7 } from "react";
+
+// src/browser/react/NavigationProvider.tsx
+import {
+  useState as useState8,
+  useEffect as useEffect11,
+  useLayoutEffect as useLayoutEffect4,
+  useCallback as useCallback4,
+  useMemo as useMemo7,
+  useRef as useRef9,
+  use as use4,
+  startTransition as startTransition2
+} from "react";
+
+// src/root-error-boundary.tsx
+import { Component as Component2, useState as useState6 } from "react";
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+
+// src/theme/ThemeProvider.tsx
+import {
+  useCallback as useCallback3,
+  useEffect as useEffect10,
+  useLayoutEffect as useLayoutEffect3,
+  useMemo as useMemo6,
+  useState as useState7
+} from "react";
+
+// src/theme/constants.ts
+var THEME_COOKIE = {
+  maxAge: 60 * 60 * 24 * 365,
+  // 1 year
+  path: "/",
+  sameSite: "lax"
+};
+
+// src/theme/ThemeProvider.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+
+// src/browser/react/NavigationProvider.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+
+// src/browser/react/Link.tsx
+import {
+  forwardRef,
+  useCallback as useCallback5,
+  useContext as useContext16,
+  useEffect as useEffect13,
+  useMemo as useMemo8,
+  useRef as useRef10
+} from "react";
+
+// src/browser/react/use-link-status.ts
+import {
+  createContext as createContext7,
+  useContext as useContext15,
+  useState as useState9,
+  useEffect as useEffect12
+} from "react";
+var LinkContext = createContext7(
+  null
+);
+
+// src/browser/prefetch/default-strategy.ts
+var ENVIRONMENT_DEFAULT_PREFETCH = process.env.NODE_ENV === "production" ? "viewport" : "none";
+function hoverNoneQuery() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function")
+    return null;
+  return window.matchMedia("(hover: none)");
+}
+function resolveAdaptiveStrategy(strategy) {
+  if (strategy !== "adaptive") return strategy;
+  return hoverNoneQuery()?.matches ? "viewport" : "hover";
+}
+function subscribeToAdaptiveStrategyChange(listener) {
+  const query = hoverNoneQuery();
+  if (!query) return () => {
+  };
+  if (typeof query.addEventListener === "function") {
+    query.addEventListener("change", listener);
+    return () => query.removeEventListener("change", listener);
+  }
+  query.addListener(listener);
+  return () => query.removeListener(listener);
+}
+
+// src/browser/prefetch/observer.ts
+var callbacks = /* @__PURE__ */ new Map();
+var observer = null;
+function getObserver() {
+  if (!observer) {
+    observer = new IntersectionObserver(
+      (entries, currentObserver) => {
+        function* intersectingCallbacks() {
+          for (const entry of entries) {
+            if (entry.isIntersecting) {
+              const subscriptions = callbacks.get(entry.target);
+              if (subscriptions) {
+                currentObserver.unobserve(entry.target);
+                callbacks.delete(entry.target);
+                for (const [subscription, callback] of subscriptions) {
+                  yield [subscriptions, subscription, callback];
+                }
+              }
+            }
+          }
+        }
+        notifyListeners(
+          intersectingCallbacks(),
+          ([, , callback]) => callback(),
+          ([subscriptions, subscription]) => subscriptions.has(subscription)
+        );
+      },
+      { rootMargin: "200px" }
+    );
+    for (const element of callbacks.keys()) observer.observe(element);
+  }
+  return observer;
+}
+function observeForPrefetch(element, onVisible) {
+  if (typeof IntersectionObserver === "undefined") return () => {
+  };
+  const currentObserver = getObserver();
+  let subscriptions = callbacks.get(element);
+  if (!subscriptions) {
+    subscriptions = /* @__PURE__ */ new Map();
+    callbacks.set(element, subscriptions);
+  }
+  const subscription = /* @__PURE__ */ Symbol();
+  subscriptions.set(subscription, onVisible);
+  if (subscriptions.size === 1) currentObserver.observe(element);
+  return () => {
+    const current = callbacks.get(element);
+    subscriptions.delete(subscription);
+    if (current !== subscriptions) return;
+    if (current.size > 0) return;
+    callbacks.delete(element);
+    observer?.unobserve(element);
+  };
+}
+
+// src/browser/link-interceptor.ts
+var ELIGIBILITY_ATTRIBUTES = {
+  href: "href",
+  target: "target",
+  download: "download",
+  noIntercept: "data-no-intercept",
+  linkComponent: "data-link-component",
+  external: "data-external",
+  prefetch: "data-prefetch",
+  prefetchScope: "data-prefetch-scope"
+};
+var ELIGIBILITY_ATTRIBUTE_FILTER = Object.values(ELIGIBILITY_ATTRIBUTES);
+var ELIGIBLE_ANCHOR_SELECTOR = `a[${ELIGIBILITY_ATTRIBUTES.href}]`;
+var LINK_COMPONENT_SELECTOR = `a[${ELIGIBILITY_ATTRIBUTES.linkComponent}]`;
+var PREFETCH_SCOPE_OPT_OUT_SELECTOR = `[${ELIGIBILITY_ATTRIBUTES.prefetchScope}="false"],[${ELIGIBILITY_ATTRIBUTES.prefetchScope}="none"]`;
+function isElementNode(value) {
+  return typeof value === "object" && value !== null && value.nodeType === 1 && typeof value.matches === "function";
+}
+var prefetchScopeObservers = /* @__PURE__ */ new WeakMap();
+function createPrefetchScopeObserverState(ownerDocument) {
+  if (typeof MutationObserver === "undefined" || !ownerDocument.documentElement) {
+    return void 0;
+  }
+  const subscriptions = /* @__PURE__ */ new Map();
+  const observer2 = new MutationObserver((mutations) => {
+    const affected = /* @__PURE__ */ new Set();
+    const collect = (element) => {
+      subscriptions.get(element)?.forEach((listener) => affected.add(listener));
+    };
+    for (const mutation of mutations) {
+      if (!isElementNode(mutation.target)) continue;
+      collect(mutation.target);
+      mutation.target.querySelectorAll(LINK_COMPONENT_SELECTOR).forEach(collect);
+    }
+    notifyListeners(affected, (listener) => listener());
+  });
+  observer2.observe(ownerDocument.documentElement, {
+    subtree: true,
+    attributes: true,
+    attributeFilter: [ELIGIBILITY_ATTRIBUTES.prefetchScope]
+  });
+  return { observer: observer2, subscriptions };
+}
+function subscribeToPrefetchScopeChange(element, listener) {
+  const ownerDocument = element.ownerDocument;
+  let state = prefetchScopeObservers.get(ownerDocument);
+  if (!state) {
+    state = createPrefetchScopeObserverState(ownerDocument);
+    if (!state) return () => {
+    };
+    prefetchScopeObservers.set(ownerDocument, state);
+  }
+  let listeners = state.subscriptions.get(element);
+  if (!listeners) {
+    listeners = /* @__PURE__ */ new Set();
+    state.subscriptions.set(element, listeners);
+  }
+  listeners.add(listener);
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    listeners.delete(listener);
+    if (listeners.size === 0 && state.subscriptions.get(element) === listeners) {
+      state.subscriptions.delete(element);
+    }
+    if (state.subscriptions.size === 0 && prefetchScopeObservers.get(ownerDocument) === state) {
+      state.observer.disconnect();
+      prefetchScopeObservers.delete(ownerDocument);
+    }
+  };
+}
+function isHashOnlyNavigationToPath(anchor, pathname) {
+  return pathname === window.location.pathname && anchor.search === window.location.search && !!anchor.hash;
+}
+function isHashOnlyNavigation(anchor) {
+  return isHashOnlyNavigationToPath(anchor, anchor.pathname);
+}
+function isPrefetchScopeDisabled(element) {
+  return typeof element.closest === "function" && element.closest(PREFETCH_SCOPE_OPT_OUT_SELECTOR) !== null;
+}
+
+// src/browser/react/Link.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+function isExternalUrl(href2, origin) {
+  if (href2.startsWith("//")) return true;
+  if (href2.startsWith("http://") || href2.startsWith("https://")) {
+    if (!origin) return false;
+    try {
+      return new URL(href2).origin !== origin;
+    } catch {
+      return false;
+    }
+  }
+  if (/^[a-z][a-z0-9+.-]*:/i.test(href2)) {
+    return true;
+  }
+  return false;
+}
+var Link = forwardRef(function Link2({
+  to,
+  replace = false,
+  scroll = true,
+  reloadDocument = false,
+  revalidate: revalidate3,
+  transition: transition3,
+  prefetch,
+  prefetchKey,
+  state,
+  children,
+  onClick,
+  ...props
+}, ref) {
+  const ctx = useContext16(NavigationStoreContext);
+  const isExternal = isExternalUrl(to, ctx?.origin);
+  const resolvedTo = useMemo8(
+    () => isExternal ? to : prefixBasename(to, ctx?.basename),
+    [to, isExternal, ctx?.basename]
+  );
+  const configuredStrategy = prefetch ?? ctx?.defaultPrefetch ?? ENVIRONMENT_DEFAULT_PREFETCH;
+  const internalRef = useRef10(null);
+  const setRef = useCallback5(
+    (node) => {
+      internalRef.current = node;
+      if (typeof ref === "function") {
+        ref(node);
+      } else if (ref) {
+        ref.current = node;
+      }
+    },
+    [ref]
+  );
+  const stateRef = useRef10(state);
+  stateRef.current = state;
+  const handleClick = useCallback5(
+    (e) => {
+      onClick?.(e);
+      if (e.defaultPrevented) return;
+      if (isExternal) return;
+      if (reloadDocument) return;
+      if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+      if (e.currentTarget.hasAttribute("download"))
+        return;
+      const target = e.currentTarget.target;
+      if (target && target !== "_self") return;
+      if (isHashOnlyNavigation(e.currentTarget)) {
+        return;
+      }
+      if (!ctx?.navigate) {
+        return;
+      }
+      e.preventDefault();
+      e.stopPropagation();
+      const currentState = stateRef.current;
+      const state2 = typeof currentState === "function" && !(process.env.NODE_ENV !== "production" && isLocationStateDefinition(currentState)) ? currentState() : currentState ?? void 0;
+      ctx.navigate(resolvedTo, {
+        replace,
+        scroll,
+        state: state2,
+        revalidate: revalidate3,
+        transition: transition3
+      });
+    },
+    [
+      resolvedTo,
+      isExternal,
+      reloadDocument,
+      replace,
+      scroll,
+      revalidate3,
+      transition3,
+      ctx,
+      onClick
+    ]
+  );
+  const handleMouseEnter = useCallback5(() => {
+    const element = internalRef.current;
+    const strategy = resolveAdaptiveStrategy(configuredStrategy);
+    if ((strategy === "hover" || strategy === "viewport") && !isExternal && ctx?.store && (!element || !isHashOnlyNavigation(element) && !isPrefetchScopeDisabled(element))) {
+      const segmentState = ctx.store.getSegmentState();
+      prefetchDirect(
+        resolvedTo,
+        segmentState.currentSegmentIds,
+        getAppVersion(),
+        ctx.store.getRouterId?.(),
+        prefetchKey
+      );
+    }
+  }, [configuredStrategy, resolvedTo, isExternal, ctx, prefetchKey]);
+  useEffect13(() => {
+    if (isExternal || !ctx?.store) return;
+    if (configuredStrategy !== "viewport" && configuredStrategy !== "render" && configuredStrategy !== "adaptive") {
+      return;
+    }
+    const armPrefetch = () => {
+      const strategy = resolveAdaptiveStrategy(configuredStrategy);
+      const isViewport = strategy === "viewport";
+      const isRender = strategy === "render";
+      if (!isViewport && !isRender) return () => {
+      };
+      const element2 = internalRef.current;
+      if (element2 && (isHashOnlyNavigation(element2) || isPrefetchScopeDisabled(element2))) {
+        return () => {
+        };
+      }
+      let cancelled = false;
+      let unsubIdle;
+      let stopObserving;
+      const triggerPrefetch = () => {
+        if (cancelled) return;
+        const currentElement = internalRef.current;
+        if (currentElement && isPrefetchScopeDisabled(currentElement)) return;
+        const segmentState = ctx.store.getSegmentState();
+        prefetchQueued(
+          resolvedTo,
+          segmentState.currentSegmentIds,
+          getAppVersion(),
+          ctx.store.getRouterId?.(),
+          prefetchKey
+        );
+      };
+      if (isRender) {
+        unsubIdle = schedulePrefetchWhenRouterIdle(
+          ctx.eventController,
+          triggerPrefetch
+        );
+      } else {
+        const viewportElement = internalRef.current;
+        if (viewportElement) {
+          stopObserving = observeForPrefetch(viewportElement, () => {
+            unsubIdle = schedulePrefetchWhenRouterIdle(
+              ctx.eventController,
+              triggerPrefetch
+            );
+          });
+        }
+      }
+      return () => {
+        cancelled = true;
+        unsubIdle?.();
+        stopObserving?.();
+      };
+    };
+    let disarmPrefetch = armPrefetch();
+    const rearm = () => {
+      disarmPrefetch();
+      disarmPrefetch = armPrefetch();
+    };
+    const element = internalRef.current;
+    const unsubscribeScope = element ? subscribeToPrefetchScopeChange(element, rearm) : void 0;
+    const unsubscribeLocation = subscribeToLocationChange(
+      ctx.eventController,
+      rearm
+    );
+    const unsubscribeAdaptive = configuredStrategy === "adaptive" ? subscribeToAdaptiveStrategyChange(rearm) : void 0;
+    return () => {
+      unsubscribeScope?.();
+      unsubscribeLocation();
+      unsubscribeAdaptive?.();
+      disarmPrefetch();
+    };
+  }, [configuredStrategy, resolvedTo, isExternal, ctx, prefetchKey]);
+  return /* @__PURE__ */ jsx8(
+    "a",
+    {
+      ref: setRef,
+      href: resolvedTo,
+      onClick: handleClick,
+      onMouseEnter: handleMouseEnter,
+      "data-link-component": true,
+      "data-external": isExternal ? "" : void 0,
+      "data-scroll": scroll === false ? "false" : void 0,
+      "data-replace": replace ? "true" : void 0,
+      "data-revalidate": revalidate3 === false ? "false" : void 0,
+      "data-transition": transition3 === false ? "false" : void 0,
+      ...props,
+      children: /* @__PURE__ */ jsx8(LinkContext.Provider, { value: resolvedTo, children })
+    }
+  );
+});
+
+// src/handles/breadcrumbs.ts
+function collectBreadcrumbs(segments) {
+  const all = segments.flat();
+  const hasHref = (item) => item != null && typeof item === "object" && typeof item.href === "string";
+  const valueByHref = /* @__PURE__ */ new Map();
+  for (const item of all) {
+    if (hasHref(item)) valueByHref.set(item.href, item);
+  }
+  const result = [];
+  const emitted = /* @__PURE__ */ new Set();
+  for (const item of all) {
+    if (!hasHref(item)) {
+      result.push(item);
+      continue;
+    }
+    if (!emitted.has(item.href)) {
+      emitted.add(item.href);
+      result.push(valueByHref.get(item.href));
+    }
+  }
+  return result;
+}
+var Breadcrumbs = createHandle(
+  collectBreadcrumbs,
+  "__rsc_router_breadcrumbs__"
+);
+
+// src/browser/react/location-state.ts
+import { useContext as useContext17, useEffect as useEffect14 } from "react";
+
+// src/browser/react/use-href.tsx
+import { useCallback as useCallback6 } from "react";
+
+// src/browser/react/use-reverse.ts
+import { useCallback as useCallback7 } from "react";
+
+// src/client.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+
+// src/server/root-layout.tsx
+import { Fragment as Fragment3, jsx as jsx10 } from "react/jsx-runtime";
+
+// src/prerender.ts
+var PRERENDER_PASSTHROUGH = Object.freeze({
+  __brand: "prerenderPassthrough"
+});
+
+// src/route-definition/use-item-types.ts
+var USE_ITEM_TYPES = {
+  layout: true,
+  route: true,
+  middleware: true,
+  revalidate: true,
+  parallel: true,
+  intercept: true,
+  loader: true,
+  loading: true,
+  errorBoundary: true,
+  notFoundBoundary: true,
+  cache: true,
+  transition: true,
+  include: true
+};
+var ALL_USE_ITEM_TYPES = new Set(
+  Object.keys(USE_ITEM_TYPES)
+);
+
+// src/server/slot-accessors.ts
+function slotAccessor(slot, enumerable) {
+  return {
+    get() {
+      return this[slot]();
+    },
+    enumerable,
+    configurable: true
+  };
+}
+
+// src/router/logging.ts
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+var routerLogContext = new AsyncLocalStorage3();
+
+// src/server/request-context.ts
+import { AsyncLocalStorage as AsyncLocalStorage6 } from "node:async_hooks";
+
+// src/context-var.ts
+function createVar(options) {
+  return {
+    __brand: "context-var",
+    key: /* @__PURE__ */ Symbol(),
+    cache: options?.cache !== false
+  };
+}
+
+// src/router/segment-resolution/mask-nested.ts
+import { cloneElement, isValidElement as isValidElement3 } from "react";
+
+// src/server/handle-store.ts
+var LOADER_SLOT = Object.freeze({ loader: true });
+var RECORD_SLOT = Object.freeze({ record: true });
+
+// src/cache/cache-tag.ts
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
+var cacheTagStorage = new AsyncLocalStorage4();
+var segmentOwnerStorage = new AsyncLocalStorage4();
+var recordedTagCapture = globalThis[/* @__PURE__ */ Symbol.for("rangojs-router:recorded-tag-capture")] ??= new AsyncLocalStorage4();
+var identityReads = globalThis[/* @__PURE__ */ Symbol.for("rangojs-router:identity-reads")] ??= /* @__PURE__ */ new WeakMap();
+function activeTagSet() {
+  const capture = recordedTagCapture.getStore();
+  const body = getLoaderBodyTags();
+  if (capture && capture.outer === body) return capture.into;
+  return body ?? capture?.into;
+}
+globalThis[/* @__PURE__ */ Symbol.for("rangojs-router:identity-read-recorder")] = (surface, verb) => {
+  const set = activeTagSet();
+  if (set === void 0 || identityReads.has(set)) return;
+  identityReads.set(set, { surface, verb, bodyId: getCurrentLoaderBodyId() });
+};
+var loaderRuns = globalThis[/* @__PURE__ */ Symbol.for("rangojs-router:loader-runs")] ??= /* @__PURE__ */ new WeakMap();
+
+// src/router/router-context.ts
+import { AsyncLocalStorage as AsyncLocalStorage5 } from "async_hooks";
+var routerContext = new AsyncLocalStorage5();
+
+// src/server/cookie-store.ts
+var REQUEST_READ_CACHE_FIX = {
+  useCache: 'Request-scoped data (cookies, headers) varies per request but is not reflected in the cache key, so cached results would be served to the wrong users. Extract the value before the cached function and pass it as an argument:\n\n  const locale = cookies().get("locale")?.value ?? "en";\n  const data = await getCachedData(locale); // locale is now in the cache key',
+  cacheScope: 'A cache() scope caches everything except loaders, so request-scoped data (cookies, headers) read here would be frozen into the shared cached shell and served to other users. Read it inside a loader instead \u2014 loaders always run fresh on every request, even on a cache hit:\n\n  loader("user", () => getUser(cookies().get("session")?.value));'
+};
+function requestReadWording(what) {
+  return {
+    verb: "called",
+    fix: { ...REQUEST_READ_CACHE_FIX, ...requestReadCaptureFix(what) },
+    record: false
+  };
+}
+var COOKIES_READ = requestReadWording("cookies");
+var HEADERS_READ = requestReadWording("headers");
+var REQUEST_HEADERS_READ = {
+  verb: "read",
+  fix: HEADERS_READ.fix
+};
+var RAW_COOKIES_READ = {
+  verb: "called",
+  fix: COOKIES_READ.fix
+};
+var THEME_READ_FIX = "On ppr and cache() routes, read the theme with useTheme() in a client component, or in a live loader (no ssr: false) with cookies().get(<storageKey>). The <html> theme class needs neither: the theme script sets it before paint. See the /theme skill (node_modules/@rangojs/router/skills/theme/SKILL.md).";
+var THEME_READ = {
+  verb: "read",
+  fix: {
+    useCache: "The theme comes from the visitor's cookie and is not in the cache key, so the first caller's theme would be served to later callers. Read it before the cached function and pass it in as an argument.",
+    cacheScope: "The theme comes from the visitor's cookie, so the first visitor's theme would be stored in the shared entry and served to everyone. " + THEME_READ_FIX,
+    capture: `The captured shell is served to every visitor of this URL, so the capturing visitor's theme would reach everyone. ${THEME_READ_FIX}`,
+    warning: THEME_READ_FIX
+  }
+};
+
+// src/server/rewrite-trail.ts
+var REWRITE_TRAIL = createVar();
+var REWRITE_SHELL = createVar();
+
+// src/cache/invalidation-order.ts
+var order = globalThis[/* @__PURE__ */ Symbol.for("rangojs-router:tag-invalidation-order")] ??= { seq: 0, tags: /* @__PURE__ */ new Map(), forgotten: 0 };
+var responseStarts = globalThis[/* @__PURE__ */ Symbol.for("rangojs-router:response-execution-start")] ??= /* @__PURE__ */ new WeakMap();
+
+// src/server/request-context.ts
+var requestContextStorage = new AsyncLocalStorage6();
+var RES_SLOT = /* @__PURE__ */ Symbol("rango.requestContext.res");
+var RENDER_BARRIER_SLOT = /* @__PURE__ */ Symbol(
+  "rango.requestContext.renderBarrier"
+);
+var RES_DESCRIPTOR = {
+  ...slotAccessor(RES_SLOT, true),
+  set(_) {
+    throw new Error(
+      "ctx.res is read-only. Use ctx.header() to set response headers, or cookies() for cookie mutations."
+    );
+  }
+};
+var RENDER_BARRIER_DESCRIPTOR = slotAccessor(
+  RENDER_BARRIER_SLOT,
+  true
+);
+var DERIVED_RENDER_BARRIER_DESCRIPTOR = {
+  ...RENDER_BARRIER_DESCRIPTOR,
+  enumerable: false
+};
+var backgroundWork = new AsyncLocalStorage6();
+
+// src/client-urls/client-root.tsx
+import {
+  createElement as createElement5,
+  Fragment as Fragment4,
+  Suspense as Suspense3,
+  useDeferredValue,
+  useLayoutEffect as useLayoutEffect5,
+  useMemo as useMemo10,
+  useState as useState10
+} from "react";
+
+// src/client-urls/navigation.ts
+import { startTransition as startTransition3 } from "react";
+
+// src/client-urls/client-root.tsx
+import { jsx as jsx11, jsxs as jsxs4 } from "react/jsx-runtime";
+var PENDING_FOREVER = new Promise(() => {
+});
+
+// src/client-urls/server-projection.ts
+var SEARCH_SCHEMA_VALUES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "string?",
+  "number?",
+  "boolean?"
+]);
+var PROJECTION_OPTIONS = /* @__PURE__ */ new Set([
+  "name",
+  "search",
+  "trailingSlash",
+  "ppr"
+]);
+var PPR_NUMBER_KEYS = /* @__PURE__ */ new Set([
+  "ttl",
+  "swr",
+  "captureTimeout",
+  "maxSnapshotBytes"
+]);
+function routeDescription(route2) {
+  return `route "${route2.pattern}" (${route2.id})`;
+}
+function projectionError(route2, message) {
+  return new Error(
+    `clientUrls() cannot create a server projection for ${routeDescription(route2)}: ${message}`
+  );
+}
+function serializeSearchSchema(route2, value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw projectionError(route2, 'path option "search" must be an object');
+  }
+  const entries = [];
+  for (const key of Object.keys(value)) {
+    const schemaValue = value[key];
+    if (typeof schemaValue !== "string" || !SEARCH_SCHEMA_VALUES.has(schemaValue)) {
+      throw projectionError(
+        route2,
+        `path option "search.${key}" has unsupported value ${JSON.stringify(schemaValue)}`
+      );
+    }
+    entries.push([key, schemaValue]);
+  }
+  return Object.freeze(Object.fromEntries(entries));
+}
+function serializeOptions(route2) {
+  const source = route2.options;
+  if (!source) return Object.freeze({});
+  for (const key of Reflect.ownKeys(source)) {
+    if (!PROJECTION_OPTIONS.has(key)) {
+      throw projectionError(
+        route2,
+        `path option ${JSON.stringify(String(key))} is not supported`
+      );
+    }
+  }
+  const options = {};
+  if (source.search !== void 0) {
+    options.search = serializeSearchSchema(route2, source.search);
+  }
+  if (source.trailingSlash !== void 0) {
+    options.trailingSlash = source.trailingSlash;
+  }
+  if (source.ppr !== void 0) {
+    options.ppr = serializePpr(route2, source.ppr);
+  }
+  return Object.freeze(options);
+}
+function serializePpr(route2, source) {
+  if (source === true) return true;
+  if (typeof source !== "object" || source === null || Array.isArray(source)) {
+    throw projectionError(
+      route2,
+      'path option "ppr" must be true or a PartialPrerenderProps object'
+    );
+  }
+  const out = {};
+  for (const key of Reflect.ownKeys(source)) {
+    if (PPR_NUMBER_KEYS.has(key)) {
+      const value = source[key];
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw projectionError(
+          route2,
+          `path option "ppr.${String(key)}" must be a finite number`
+        );
+      }
+      out[key] = value;
+      continue;
+    }
+    if (key === "tags") {
+      const tags = source.tags;
+      if (!Array.isArray(tags) || tags.some((tag) => typeof tag !== "string" || tag === "")) {
+        throw projectionError(
+          route2,
+          'path option "ppr.tags" must be an array of non-empty strings'
+        );
+      }
+      out.tags = Object.freeze([...tags]);
+      continue;
+    }
+    throw projectionError(
+      route2,
+      `path option "ppr.${String(key)}" is not supported`
+    );
+  }
+  return Object.freeze(out);
+}
+function serializeTransition(route2) {
+  const source = route2.transition;
+  if (!source) return void 0;
+  const config = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value === void 0 || key === "when") continue;
+    config[key] = typeof value === "object" && value !== null ? Object.freeze({ ...value }) : value;
+  }
+  return Object.freeze(config);
+}
+function indicesWhere(items, pred) {
+  return items.flatMap((item, index) => pred(item) ? [index] : []);
+}
+function serializeRoute(route2, options, ordinals) {
+  const layoutLoaders = route2.layoutLoaders.map((record) => {
+    if (!ordinals.has(record)) ordinals.set(record, ordinals.size);
+    return ordinals.get(record);
+  });
+  const loaderIds = route2.loaders.map(({ loader: loader3 }, index) => {
+    if (typeof loader3.$$id !== "string" || loader3.$$id.length === 0) {
+      throw projectionError(
+        route2,
+        `loader at index ${index} is missing a non-empty $$id`
+      );
+    }
+    return loader3.$$id;
+  });
+  const awaitedLoaderIndices = indicesWhere(
+    route2.loaders,
+    ({ ssr }) => ssr === false
+  );
+  const transition3 = serializeTransition(route2);
+  return Object.freeze({
+    id: route2.id,
+    pattern: route2.pattern,
+    name: route2.name ?? null,
+    options: serializeOptions(route2),
+    loaderIds: Object.freeze(loaderIds),
+    hasLoading: route2.loading !== void 0,
+    ...awaitedLoaderIndices.length > 0 ? { awaitedLoaderIndices: Object.freeze(awaitedLoaderIndices) } : {},
+    ...serializeLoaderOptions(
+      route2.loaders,
+      `route "${route2.pattern}"`,
+      options
+    ),
+    ...layoutLoaders.length > 0 ? { layoutLoaders: Object.freeze(layoutLoaders) } : {},
+    ...transition3 ? { transition: transition3 } : {},
+    ...typeof route2.transition?.when === "function" ? { transitionWhen: true } : {}
+  });
+}
+function serializeLoaderOptions(loaders, owner, options) {
+  const loaderRevalidate = loaders.map(
+    ({ loader: loader3, revalidate: revalidate3 }) => revalidate3.flatMap((entry) => {
+      if (isHoistedRevalidateRef(entry)) return [entry.$$rangoRevalidate];
+      if (typeof entry === "boolean") return [entry];
+      if (options.hoisted) {
+        throw new Error(
+          `clientUrls() revalidate() on loader "${loader3.$$id}" of ${owner} was not hoisted to the server: call revalidate() (the builder's helper, or the one "@rangojs/router/client" exports for a component's .use) with an inline function, an imported predicate or a boolean.`
+        );
+      }
+      return [];
+    })
+  );
+  const deferrableLoaderIndices = indicesWhere(
+    loaders,
+    ({ prefetch }) => prefetch === false
+  );
+  return {
+    ...deferrableLoaderIndices.length > 0 ? { deferrableLoaderIndices: Object.freeze(deferrableLoaderIndices) } : {},
+    ...loaderRevalidate.some((keys) => keys.length > 0) ? {
+      loaderRevalidate: Object.freeze(
+        loaderRevalidate.map((keys) => Object.freeze(keys))
+      )
+    } : {}
+  };
+}
+function serializeIntercept(record, index, options) {
+  const loaderIds = record.loaders.map(({ loader: loader3 }, loaderIndex) => {
+    if (typeof loader3.$$id !== "string" || loader3.$$id.length === 0) {
+      throw new Error(
+        `clientUrls() cannot create a server projection for intercept ".${record.targetName}" (index ${index}): loader at index ${loaderIndex} is missing a non-empty $$id`
+      );
+    }
+    return loader3.$$id;
+  });
+  return Object.freeze({
+    slotName: record.slotName,
+    targetName: record.targetName,
+    loaderIds: Object.freeze(loaderIds),
+    hasLoading: record.loading !== void 0,
+    ...serializeLoaderOptions(
+      record.loaders,
+      `intercept ".${record.targetName}"`,
+      options
+    )
+  });
+}
+function serializeClientUrlPatterns(patterns, options = {}) {
+  const ordinals = /* @__PURE__ */ new Map();
+  return Object.freeze({
+    version: 1,
+    routes: Object.freeze(
+      patterns.routes.map((route2) => serializeRoute(route2, options, ordinals))
+    ),
+    intercepts: Object.freeze(
+      (patterns.intercepts ?? []).map(
+        (record, index) => serializeIntercept(record, index, options)
+      )
+    )
+  });
+}
+function projectClientUrlsModule(namespace, options = {}) {
+  const definition = namespace.default;
+  if (typeof definition !== "object" && typeof definition !== "function" || definition === null || definition.__brand !== "client-urls") {
+    return void 0;
+  }
+  return serializeClientUrlPatterns(definition, options);
+}
+
+// src/vite/plugins/client-ref-hashing.ts
+import { relative } from "node:path";
+import { createHash } from "node:crypto";
+
+// src/vite/debug.ts
+import debugFactory from "debug";
+var NS = {
+  config: "rango:config",
+  discovery: "rango:discovery",
+  routes: "rango:routes",
+  prerender: "rango:prerender",
+  build: "rango:build",
+  dev: "rango:dev",
+  transform: "rango:transform",
+  chunks: "rango:chunks"
+};
+if (process.env.INTERNAL_RANGO_DEBUG) {
+  const existing = debugFactory.disable();
+  debugFactory.enable(existing ? `${existing},rango:*` : "rango:*");
+}
+function createRangoDebugger(namespace) {
+  const primary = debugFactory(namespace);
+  const shadow = debugFactory(`vite:${namespace}`);
+  if (primary.enabled) return primary;
+  if (shadow.enabled) return shadow;
+  return void 0;
+}
+function createCounter(debug3, label) {
+  if (!debug3) return void 0;
+  let n = 0;
+  let totalMs = 0;
+  let slowestMs = 0;
+  let slowestFile = "";
+  const record = (file, ms) => {
+    n++;
+    totalMs += ms;
+    if (ms > slowestMs) {
+      slowestMs = ms;
+      slowestFile = file;
+    }
+  };
+  return {
+    record,
+    time(file, fn) {
+      const start = performance.now();
+      let out;
+      try {
+        out = fn();
+      } catch (err) {
+        record(file, performance.now() - start);
+        throw err;
+      }
+      if (out && typeof out.then === "function") {
+        return out.finally(
+          () => record(file, performance.now() - start)
+        );
+      }
+      record(file, performance.now() - start);
+      return out;
+    },
+    flush() {
+      if (n === 0) return;
+      debug3(
+        "%s: %d files, %sms total, slowest %sms %s",
+        label,
+        n,
+        totalMs.toFixed(1),
+        slowestMs.toFixed(1),
+        slowestFile
+      );
+      n = 0;
+      totalMs = 0;
+      slowestMs = 0;
+      slowestFile = "";
+    }
+  };
+}
+
+// src/vite/plugins/client-ref-hashing.ts
+var debug = createRangoDebugger(NS.transform);
+var CLIENT_PKG_PROXY_PREFIX = "/@id/__x00__virtual:vite-rsc/client-package-proxy/";
+var CLIENT_IN_SERVER_PKG_PROXY_PREFIX = "/@id/__x00__virtual:vite-rsc/client-in-server-package-proxy/";
+var FS_PREFIX = "/@fs/";
+function hashRefKey(relativeId) {
+  return createHash("sha256").update(relativeId).digest("hex").slice(0, 12);
+}
+function computeProductionHash(projectRoot, refKey) {
+  let toHash;
+  if (refKey.startsWith(CLIENT_PKG_PROXY_PREFIX)) {
+    toHash = refKey.slice(CLIENT_PKG_PROXY_PREFIX.length);
+  } else if (refKey.startsWith(CLIENT_IN_SERVER_PKG_PROXY_PREFIX)) {
+    const absPath = decodeURIComponent(
+      refKey.slice(CLIENT_IN_SERVER_PKG_PROXY_PREFIX.length)
+    );
+    toHash = relative(projectRoot, absPath).replaceAll("\\", "/");
+  } else if (refKey.startsWith(FS_PREFIX)) {
+    const absPath = refKey.slice(FS_PREFIX.length - 1);
+    toHash = relative(projectRoot, absPath).replaceAll("\\", "/");
+  } else if (refKey.startsWith("/")) {
+    toHash = refKey.slice(1);
+  } else {
+    return refKey;
+  }
+  return hashRefKey(toHash);
+}
+var REGISTER_CLIENT_REF_RE = /registerClientReference\(\s*(?:(?:\([^)]*\))|(?:\(\)[\s\S]*?\}))\s*,\s*"([^"]+)"\s*,\s*"[^"]+"\s*\)/g;
+function transformClientRefs(code, projectRoot) {
+  if (!code.includes("registerClientReference")) return null;
+  let hasReplacement = false;
+  const result = code.replace(
+    REGISTER_CLIENT_REF_RE,
+    (match, refKey) => {
+      const hash = computeProductionHash(projectRoot, refKey);
+      if (hash === refKey) return match;
+      hasReplacement = true;
+      return match.replace(`"${refKey}"`, `"${hash}"`);
+    }
+  );
+  return hasReplacement ? result : null;
+}
+function hashClientRefs(projectRoot) {
+  const counter = createCounter(debug, "hash-client-refs");
+  return {
+    name: "@rangojs/router:hash-client-refs",
+    enforce: "post",
+    applyToEnvironment(env) {
+      return env.name === "rsc";
+    },
+    buildEnd() {
+      counter?.flush();
+    },
+    transform(code, id) {
+      const start = counter ? performance.now() : 0;
+      try {
+        const result = transformClientRefs(code, projectRoot);
+        if (result === null) return;
+        return { code: result, map: null };
+      } finally {
+        counter?.record(id, performance.now() - start);
+      }
+    }
+  };
+}
+
+// src/vite/utils/directive-prologue.ts
+import { parseAst } from "vite";
+function hasUseClientDirective(source) {
+  let program;
+  try {
+    program = parseAst(source, { lang: "tsx" });
+  } catch {
+    return false;
+  }
+  for (const node of program.body ?? []) {
+    if (node?.type === "ExpressionStatement" && node.expression?.type === "Literal" && typeof node.expression.value === "string") {
+      if (node.expression.value === "use client") return true;
+      continue;
+    }
+    break;
+  }
+  return false;
+}
+
+// src/vite/plugins/hoist/scope.ts
+var Scope = class {
+  constructor(parent, isFunction, node) {
+    this.parent = parent;
+    this.isFunction = isFunction;
+    this.node = node;
+    this.declarations = /* @__PURE__ */ new Set();
+  }
+  nearestFunction() {
+    return this.isFunction || !this.parent ? this : this.parent.nearestFunction();
+  }
+  lookup(name) {
+    if (this.declarations.has(name)) return this;
+    return this.parent ? this.parent.lookup(name) : null;
+  }
+};
+var TYPE_KEYS = /* @__PURE__ */ new Set([
+  "typeAnnotation",
+  "returnType",
+  "typeParameters",
+  "typeArguments",
+  "superTypeArguments",
+  "implements"
+]);
+function jsxNameReference(name) {
+  if (name?.type === "JSXIdentifier") {
+    return /^[a-z]/.test(name.name) || name.name.includes("-") ? null : name;
+  }
+  let root = name;
+  while (root?.type === "JSXMemberExpression") root = root.object;
+  return root?.type === "JSXIdentifier" && root.name !== "this" ? root : null;
+}
+function patternNames(pattern, names = []) {
+  if (!pattern) return names;
+  switch (pattern.type) {
+    case "Identifier":
+      names.push(pattern.name);
+      break;
+    case "ObjectPattern":
+      for (const prop of pattern.properties) {
+        patternNames(prop.type === "RestElement" ? prop : prop.value, names);
+      }
+      break;
+    case "ArrayPattern":
+      for (const element of pattern.elements) patternNames(element, names);
+      break;
+    case "RestElement":
+      patternNames(pattern.argument, names);
+      break;
+    case "AssignmentPattern":
+      patternNames(pattern.left, names);
+      break;
+    case "TSParameterProperty":
+      patternNames(pattern.parameter, names);
+      break;
+  }
+  return names;
+}
+function analyzeScopes(program) {
+  const moduleScope = new Scope(null, true, program);
+  const scopeOf = /* @__PURE__ */ new Map([[program, moduleScope]]);
+  const references = [];
+  const declarePattern = (pattern, scope) => {
+    for (const name of patternNames(pattern)) scope.declarations.add(name);
+  };
+  const walkPattern = (pattern, scope, typeOnly) => {
+    if (!pattern) return;
+    switch (pattern.type) {
+      case "Identifier":
+        if (pattern.typeAnnotation) walk(pattern.typeAnnotation, scope, true);
+        return;
+      case "ObjectPattern":
+        for (const prop of pattern.properties) {
+          if (prop.type === "RestElement") {
+            walkPattern(prop.argument, scope, typeOnly);
+          } else {
+            if (prop.computed) walk(prop.key, scope, typeOnly);
+            walkPattern(prop.value, scope, typeOnly);
+          }
+        }
+        if (pattern.typeAnnotation) walk(pattern.typeAnnotation, scope, true);
+        return;
+      case "ArrayPattern":
+        for (const element of pattern.elements) {
+          walkPattern(element, scope, typeOnly);
+        }
+        if (pattern.typeAnnotation) walk(pattern.typeAnnotation, scope, true);
+        return;
+      case "RestElement":
+        walkPattern(pattern.argument, scope, typeOnly);
+        return;
+      case "AssignmentPattern":
+        walkPattern(pattern.left, scope, typeOnly);
+        walk(pattern.right, scope, typeOnly);
+        return;
+      case "TSParameterProperty":
+        walkPattern(pattern.parameter, scope, typeOnly);
+        return;
+      default:
+        walk(pattern, scope, typeOnly);
+    }
+  };
+  const hoistDeclarations = (statements, scope) => {
+    for (const statement of statements) {
+      const node = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+      if (!node) continue;
+      switch (node.type) {
+        case "ImportDeclaration":
+          for (const spec of node.specifiers) {
+            scope.declarations.add(spec.local.name);
+          }
+          break;
+        case "FunctionDeclaration":
+        case "ClassDeclaration":
+        case "TSEnumDeclaration":
+        case "TSTypeAliasDeclaration":
+        case "TSInterfaceDeclaration":
+        case "TSModuleDeclaration":
+          if (node.id?.type === "Identifier") {
+            scope.declarations.add(node.id.name);
+          }
+          break;
+        case "VariableDeclaration":
+          for (const declarator of node.declarations) {
+            declarePattern(
+              declarator.id,
+              node.kind === "var" ? scope.nearestFunction() : scope
+            );
+          }
+          break;
+      }
+    }
+  };
+  const walk = (node, scope, typeOnly) => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item, scope, typeOnly);
+      return;
+    }
+    if (typeof node.type !== "string") return;
+    switch (node.type) {
+      case "Identifier":
+        references.push({ node, scope, typeOnly });
+        if (node.typeAnnotation) walk(node.typeAnnotation, scope, true);
+        return;
+      case "ImportDeclaration":
+      case "ExportAllDeclaration":
+        return;
+      case "ExportNamedDeclaration":
+        if (node.declaration) walk(node.declaration, scope, typeOnly);
+        else if (!node.source) {
+          for (const spec of node.specifiers) {
+            walk(spec.local, scope, typeOnly || node.exportKind === "type");
+          }
+        }
+        return;
+      case "MemberExpression":
+        walk(node.object, scope, typeOnly);
+        if (node.computed) walk(node.property, scope, typeOnly);
+        return;
+      case "Property":
+      case "MethodDefinition":
+      case "PropertyDefinition":
+      case "TSPropertySignature":
+      case "TSMethodSignature":
+        if (node.computed) walk(node.key, scope, typeOnly);
+        walk(node.value, scope, typeOnly);
+        if (node.typeAnnotation) walk(node.typeAnnotation, scope, true);
+        return;
+      case "LabeledStatement":
+        walk(node.body, scope, typeOnly);
+        return;
+      case "BreakStatement":
+      case "ContinueStatement":
+      case "MetaProperty":
+        return;
+      case "JSXOpeningElement":
+      case "JSXClosingElement": {
+        const ref = jsxNameReference(node.name);
+        if (ref) references.push({ node: ref, scope, typeOnly });
+        walk(node.typeArguments, scope, true);
+        walk(node.attributes, scope, typeOnly);
+        return;
+      }
+      case "TSQualifiedName":
+        walk(node.left, scope, typeOnly);
+        return;
+      case "TSEnumMember":
+        walk(node.initializer, scope, typeOnly);
+        return;
+      case "TSTypeAliasDeclaration":
+      case "TSInterfaceDeclaration":
+        walk(node.typeParameters, scope, true);
+        walk(node.typeAnnotation ?? node.body, scope, true);
+        walk(node.extends, scope, true);
+        return;
+      case "VariableDeclarator":
+        walkPattern(node.id, scope, typeOnly);
+        walk(node.init, scope, typeOnly);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression": {
+        const fnScope = new Scope(scope, true, node);
+        scopeOf.set(node, fnScope);
+        if (node.type === "FunctionExpression" && node.id) {
+          fnScope.declarations.add(node.id.name);
+        }
+        for (const param of node.params) declarePattern(param, fnScope);
+        walk(node.typeParameters, fnScope, true);
+        for (const param of node.params) walkPattern(param, fnScope, typeOnly);
+        walk(node.returnType, fnScope, true);
+        if (node.body?.type === "BlockStatement") {
+          hoistDeclarations(node.body.body, fnScope);
+          walk(node.body.body, fnScope, typeOnly);
+        } else {
+          walk(node.body, fnScope, typeOnly);
+        }
+        return;
+      }
+      case "ClassDeclaration":
+      case "ClassExpression": {
+        let classScope = scope;
+        if (node.type === "ClassExpression" && node.id) {
+          classScope = new Scope(scope, false, node);
+          classScope.declarations.add(node.id.name);
+          scopeOf.set(node, classScope);
+        }
+        walk(node.superClass, classScope, typeOnly);
+        walk(node.superTypeArguments, classScope, true);
+        walk(node.typeParameters, classScope, true);
+        walk(node.implements, classScope, true);
+        walk(node.body, classScope, typeOnly);
+        return;
+      }
+      case "BlockStatement":
+      case "StaticBlock": {
+        const blockScope = new Scope(scope, false, node);
+        scopeOf.set(node, blockScope);
+        hoistDeclarations(node.body, blockScope);
+        walk(node.body, blockScope, typeOnly);
+        return;
+      }
+      case "ForStatement":
+      case "ForInStatement":
+      case "ForOfStatement": {
+        const loopScope = new Scope(scope, false, node);
+        scopeOf.set(node, loopScope);
+        const head = node.type === "ForStatement" ? node.init : node.left;
+        if (head?.type === "VariableDeclaration") {
+          hoistDeclarations([head], loopScope);
+        }
+        for (const key of ["init", "left", "right", "test", "update", "body"]) {
+          walk(node[key], loopScope, typeOnly);
+        }
+        return;
+      }
+      case "SwitchStatement": {
+        walk(node.discriminant, scope, typeOnly);
+        const switchScope = new Scope(scope, false, node);
+        scopeOf.set(node, switchScope);
+        hoistDeclarations(
+          node.cases.flatMap((c) => c.consequent),
+          switchScope
+        );
+        for (const c of node.cases) {
+          walk(c.test, switchScope, typeOnly);
+          walk(c.consequent, switchScope, typeOnly);
+        }
+        return;
+      }
+      case "CatchClause": {
+        const catchScope = new Scope(scope, false, node);
+        scopeOf.set(node, catchScope);
+        if (node.param) {
+          declarePattern(node.param, catchScope);
+          walkPattern(node.param, catchScope, typeOnly);
+        }
+        walk(node.body, catchScope, typeOnly);
+        return;
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      walk(node[key], scope, typeOnly || TYPE_KEYS.has(key));
+    }
+  };
+  hoistDeclarations(program.body, moduleScope);
+  walk(program.body, moduleScope, false);
+  return { moduleScope, references, scopeOf };
+}
+function collectImports(program) {
+  const imports = /* @__PURE__ */ new Map();
+  for (const statement of program.body) {
+    if (statement.type !== "ImportDeclaration") continue;
+    const declTypeOnly = statement.importKind === "type";
+    for (const spec of statement.specifiers) {
+      imports.set(spec.local.name, {
+        source: statement.source.value,
+        imported: spec.type === "ImportDefaultSpecifier" ? "default" : spec.type === "ImportNamespaceSpecifier" ? "*" : spec.imported.type === "Identifier" ? spec.imported.name : String(spec.imported.value),
+        typeOnly: declTypeOnly || spec.importKind === "type"
+      });
+    }
+  }
+  return imports;
+}
+
+// src/vite/plugins/hoist/literal.ts
+function directivePrologueEnd(program) {
+  let end = 0;
+  for (const statement of program.body) {
+    if (statement.type !== "ExpressionStatement" || typeof statement.directive !== "string") {
+      break;
+    }
+    end = statement.end;
+  }
+  return end;
+}
+function parseLang(file) {
+  if (/\.[cm]?ts$/.test(file)) return "ts";
+  if (/\.[cm]?jsx?$/.test(file)) return "jsx";
+  return "tsx";
+}
+var EXPRESSION_WRAPPERS = /* @__PURE__ */ new Set([
+  "TSAsExpression",
+  "TSSatisfiesExpression",
+  "TSNonNullExpression",
+  "TSTypeAssertion",
+  "ParenthesizedExpression"
+]);
+function unwrapExpression(node) {
+  while (node && EXPRESSION_WRAPPERS.has(node.type)) node = node.expression;
+  return node;
+}
+function isFunctionLiteral(node) {
+  return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+}
+function propertyKeyIs(prop, name) {
+  return prop?.type === "Property" && !prop.computed && (prop.key.type === "Identifier" && prop.key.name === name || prop.key.type === "Literal" && prop.key.value === name);
+}
+function findHelperCalls(program, scopeOf, moduleScope, imports, spec) {
+  const calls = [];
+  const helpers = /* @__PURE__ */ new Map();
+  const sourceExport = (callee, scope) => {
+    const sourceImport = (id) => {
+      if (id?.type !== "Identifier") return null;
+      if (scope.lookup(id.name) !== moduleScope) return null;
+      const binding = imports.get(id.name);
+      return binding && spec.sources.has(binding.source) && !binding.typeOnly ? binding : null;
+    };
+    if (callee.type === "Identifier") {
+      const imported = sourceImport(callee)?.imported;
+      return imported && imported !== "*" && imported !== "default" ? imported : null;
+    }
+    if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && sourceImport(callee.object)?.imported === "*") {
+      return callee.property.name;
+    }
+    return null;
+  };
+  const registerBuilderCallback = (callback) => {
+    const fnScope = scopeOf.get(callback);
+    let param = callback.params[0];
+    if (param?.type === "AssignmentPattern") param = param.left;
+    if (!fnScope || !param) return;
+    const bindings = { names: /* @__PURE__ */ new Set(), objects: /* @__PURE__ */ new Set() };
+    if (param.type === "Identifier") bindings.objects.add(param.name);
+    if (param.type === "ObjectPattern") {
+      for (const prop of param.properties) {
+        if (!propertyKeyIs(prop, spec.helper)) continue;
+        const target = prop.value.type === "AssignmentPattern" ? prop.value.left : prop.value;
+        if (target.type === "Identifier") bindings.names.add(target.name);
+      }
+    }
+    helpers.set(fnScope, bindings);
+  };
+  const isHelper = (callee, scope) => {
+    if (spec.directImport && sourceExport(callee, scope) === spec.helper) {
+      return true;
+    }
+    if (callee.type === "Identifier") {
+      const decl = scope.lookup(callee.name);
+      return !!decl && !!helpers.get(decl)?.names.has(callee.name);
+    }
+    if (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier" && callee.property.name === spec.helper && callee.object.type === "Identifier") {
+      const decl = scope.lookup(callee.object.name);
+      return !!decl && !!helpers.get(decl)?.objects.has(callee.object.name);
+    }
+    return false;
+  };
+  const visit = (node, scope) => {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item, scope);
+      return;
+    }
+    if (typeof node.type !== "string") return;
+    const own = scopeOf.get(node) ?? scope;
+    if (node.type === "CallExpression") {
+      const callback = node.arguments[0];
+      if (isFunctionLiteral(callback) && sourceExport(node.callee, own) === spec.builder) {
+        registerBuilderCallback(callback);
+      }
+      if (isHelper(node.callee, own)) calls.push({ call: node, scope: own });
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      visit(node[key], own);
+    }
+  };
+  visit(program.body, moduleScope);
+  return calls;
+}
+function findLexicalCapture(literal, references, code, messages) {
+  const ownArguments = [];
+  let found = null;
+  const capture = (node, what) => {
+    found = {
+      node,
+      detail: `${messages.lexical[what]} ${messages.captureHint}`
+    };
+  };
+  const loads = (node, expression, why) => {
+    found = {
+      node,
+      detail: `\`${expression}\` ${why} ${messages.loadsHint}`
+    };
+  };
+  const visit = (node, boundary) => {
+    if (found || !node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item, boundary);
+      return;
+    }
+    if (typeof node.type !== "string") return;
+    switch (node.type) {
+      case "FunctionExpression":
+      case "FunctionDeclaration":
+        ownArguments.push(node);
+        boundary = node;
+        break;
+      case "ClassBody":
+        boundary = node;
+        break;
+      case "ThisExpression":
+        if (!boundary) capture(node, "this");
+        return;
+      case "Super":
+        if (!boundary || boundary === literal) capture(node, "super");
+        return;
+      case "JSXMemberExpression": {
+        let root = node;
+        while (root.type === "JSXMemberExpression") root = root.object;
+        if (root.name === "this" && !boundary) capture(root, "this");
+        return;
+      }
+      case "MetaProperty":
+        if (node.meta.name === "import") {
+          loads(node, "import.meta", messages.importMetaWhy);
+        } else if (!boundary) {
+          capture(node, "new.target");
+        }
+        return;
+      case "MemberExpression":
+        if (node.object?.type === "MetaProperty") {
+          if (node.object.meta.name !== "import") break;
+          if (!node.computed && node.property.name === "env") return;
+          loads(
+            node,
+            node.computed ? "import.meta[...]" : `import.meta.${node.property.name}`,
+            messages.importMetaMemberWhy
+          );
+          return;
+        }
+        break;
+      case "ImportExpression":
+        loads(
+          node,
+          `import(${code.slice(node.source.start, node.source.end)})`,
+          messages.dynamicImportWhy
+        );
+        return;
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      if (TYPE_KEYS.has(key)) continue;
+      visit(node[key], boundary);
+    }
+  };
+  visit(literal, null);
+  if (found) return found;
+  for (const ref of references) {
+    if (ref.typeOnly || ref.node.name !== "arguments") continue;
+    if (ref.node.start < literal.start || ref.node.end > literal.end) continue;
+    const owned = ownArguments.some(
+      (fn) => fn.start <= ref.node.start && ref.node.end <= fn.end
+    );
+    if (!owned) {
+      capture(ref.node, "arguments");
+      return found;
+    }
+  }
+  return null;
+}
+function collectFreeReferences(literal, references, moduleScope, imports) {
+  const used = /* @__PURE__ */ new Map();
+  const bindings = [];
+  const globals = [];
+  for (const ref of references) {
+    if (ref.node.start < literal.start || ref.node.end > literal.end) continue;
+    const decl = ref.scope.lookup(ref.node.name);
+    if (!decl) {
+      if (!ref.typeOnly) globals.push(ref);
+      continue;
+    }
+    if (decl.node.start >= literal.start && decl.node.end <= literal.end && decl !== moduleScope) {
+      continue;
+    }
+    if (decl === moduleScope && imports.has(ref.node.name)) {
+      const valueUse = !ref.typeOnly && !imports.get(ref.node.name).typeOnly;
+      used.set(ref.node.name, (used.get(ref.node.name) ?? false) || valueUse);
+      continue;
+    }
+    if (ref.typeOnly) continue;
+    bindings.push(ref);
+  }
+  return { imports: used, bindings, globals };
+}
+async function emitImports(used, imports, checkValueImport) {
+  const bySource = /* @__PURE__ */ new Map();
+  for (const [local, valueUse] of used) {
+    const binding = imports.get(local);
+    if (valueUse) await checkValueImport(local, binding);
+    const lines = bySource.get(binding.source) ?? [];
+    const typePrefix = valueUse ? "" : "type ";
+    if (binding.imported === "*") {
+      lines.push(
+        `import ${typePrefix}* as ${local} from ${JSON.stringify(binding.source)};`
+      );
+    } else if (binding.imported === "default") {
+      lines.push(
+        `import ${typePrefix}${local} from ${JSON.stringify(binding.source)};`
+      );
+    } else {
+      const spec = binding.imported === local ? local : `${JSON.stringify(binding.imported)} as ${local}`;
+      lines.push(
+        `import ${typePrefix}{ ${spec} } from ${JSON.stringify(binding.source)};`
+      );
+    }
+    bySource.set(binding.source, lines);
+  }
+  return [...bySource.values()].flat();
+}
+
+// src/vite/discovery/client-urls-projection.ts
+var debug2 = createRangoDebugger(NS.discovery);
+var CLIENT_URLS_REVALIDATE_QUERY = "rango-revalidate";
+function hoistedRevalidateId(file) {
+  return `${file}?${CLIENT_URLS_REVALIDATE_QUERY}`;
+}
+function hasDefaultExport(code) {
+  let program;
+  try {
+    program = parseAst2(code, { lang: "tsx" });
+  } catch {
+    return false;
+  }
+  for (const node of program.body ?? []) {
+    if (node?.type === "ExportDefaultDeclaration") return true;
+    if (node?.type !== "ExportNamedDeclaration") continue;
+    for (const specifier of node.specifiers ?? []) {
+      const exportedName = specifier?.exported?.name ?? specifier?.exported?.value;
+      if (exportedName === "default") return true;
+    }
+  }
+  return false;
+}
+function normalizeSource(state, id) {
+  const cleanId = id.split("?", 1)[0];
+  const absoluteId = isAbsolute(cleanId) ? cleanId : resolve(state.projectRoot, cleanId);
+  return normalizePath(absoluteId);
+}
+function referenceId(referenceKey) {
+  return `${referenceKey}#default`;
+}
+function withoutReferenceQuery(reference) {
+  const exportIndex = reference.lastIndexOf("#");
+  const moduleId = exportIndex === -1 ? reference : reference.slice(0, exportIndex);
+  const exportName = exportIndex === -1 ? "" : reference.slice(exportIndex);
+  const queryIndex = moduleId.indexOf("?");
+  return `${queryIndex === -1 ? moduleId : moduleId.slice(0, queryIndex)}${exportName}`;
+}
+function recordClientUrlsModule(state, code, id) {
+  if (!code.includes("clientUrls(") || !hasUseClientDirective(code) || !hasDefaultExport(code)) {
+    return;
+  }
+  const source = normalizeSource(state, id);
+  const projectRoot = normalizePath(resolve(state.projectRoot));
+  const relativeId = normalizePath(relative2(projectRoot, source));
+  const outsideProject = relativeId === ".." || relativeId.startsWith("../") || isAbsolute(relativeId);
+  const devReferenceKey = outsideProject ? `/@fs${source}` : `/${relativeId}`;
+  const sourceByReferenceId = state.clientUrlSourceByReferenceId ??= /* @__PURE__ */ new Map();
+  sourceByReferenceId.set(referenceId(devReferenceKey), source);
+  const productionReferenceKeys = /* @__PURE__ */ new Set([
+    hashRefKey(relativeId),
+    computeProductionHash(projectRoot, devReferenceKey)
+  ]);
+  for (const productionReferenceKey of productionReferenceKeys) {
+    sourceByReferenceId.set(referenceId(productionReferenceKey), source);
+  }
+}
+var CLIENT_IMPORT_RE = /["']@rangojs\/router\/client["']/;
+function isClientUrlsComponentUseSource(source) {
+  return source.includes(".use") && CLIENT_IMPORT_RE.test(source) && firstCodeMatchIndex(source, /\.use\s*=(?!=)/g) >= 0;
+}
+function componentUseSignature(source, file) {
+  if (!isClientUrlsComponentUseSource(source)) return void 0;
+  const hash = createHash2("sha256");
+  let program;
+  try {
+    program = parseAst2(source, { lang: parseLang(file) });
+  } catch {
+    return hash.update(source).digest("base64");
+  }
+  const visit = (node) => {
+    if (typeof node !== "object" || node === null) return;
+    if (Array.isArray(node)) {
+      for (const child of node) visit(child);
+      return;
+    }
+    const { type, left } = node;
+    if (type === "AssignmentExpression" && left.type === "MemberExpression" && !left.computed && left.property.type === "Identifier" && left.property.name === "use") {
+      const { start, end } = node;
+      hash.update(source.slice(start, end)).update("\0");
+      return;
+    }
+    for (const value of Object.values(node)) visit(value);
+  };
+  visit(program.body);
+  return hash.digest("base64");
+}
+function resolveClientUrlsSource(state, referenceId2) {
+  return state.clientUrlSourceByReferenceId?.get(
+    withoutReferenceQuery(referenceId2)
+  );
+}
+function scanForClientUrlModules(state) {
+  if (!state.projectRoot) return;
+  for (const filePath of findTsFiles(state.projectRoot, state.scanFilter)) {
+    let code;
+    try {
+      code = readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    recordClientUrlsModule(state, code, filePath);
+  }
+}
+function projectionError2(referenceId2, source, message, cause) {
+  const sourceDescription = source ? ` from source "${source}"` : "";
+  const errorMessage = `Cannot discover client URL projection for reference "${referenceId2}"${sourceDescription}: ${message}`;
+  return cause === void 0 ? new Error(errorMessage) : new Error(errorMessage, { cause });
+}
+async function refreshRecordedClientUrlProjections(state, ssrEnv, serverMod, rscEnv) {
+  const sourceByReferenceId = state.clientUrlSourceByReferenceId;
+  if (!sourceByReferenceId?.size || typeof ssrEnv?.runner?.import !== "function") {
+    return;
+  }
+  const referenceIdsBySource = /* @__PURE__ */ new Map();
+  for (const [refId, source] of sourceByReferenceId) {
+    const ids = referenceIdsBySource.get(source);
+    if (ids) {
+      ids.push(refId);
+    } else {
+      referenceIdsBySource.set(source, [refId]);
+    }
+  }
+  const refreshed = /* @__PURE__ */ new Map();
+  for (const [source, referenceIds] of referenceIdsBySource) {
+    let module;
+    try {
+      module = await ssrEnv.runner.import(source);
+    } catch {
+      continue;
+    }
+    let projection;
+    try {
+      projection = projectClientUrlsModule(module, { hoisted: true });
+    } catch {
+      continue;
+    }
+    if (!projection) continue;
+    debug2?.(
+      "pre-entry refresh %s -> [%s]",
+      source,
+      projection.routes.map((route2) => route2.pattern).join(", ")
+    );
+    for (const referenceId2 of referenceIds) {
+      refreshed.set(referenceId2, projection);
+    }
+  }
+  if (refreshed.size === 0) return;
+  try {
+    await installClientUrlProjections(
+      state,
+      rscEnv,
+      serverMod,
+      refreshed,
+      false
+    );
+  } catch (error) {
+    debug2?.(
+      "pre-entry refresh: predicate registrations failed to load: %s",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function discoverClientUrlProjections(state, ssrEnv, serverMod, rscEnv) {
+  scanForClientUrlModules(state);
+  const sourceByReferenceId = state.clientUrlSourceByReferenceId;
+  if (!sourceByReferenceId?.size) {
+    await installClientUrlProjections(
+      state,
+      rscEnv,
+      serverMod,
+      /* @__PURE__ */ new Map(),
+      true
+    );
+    return;
+  }
+  const referenceIdsBySource = /* @__PURE__ */ new Map();
+  for (const [referenceId2, source] of sourceByReferenceId) {
+    const ids = referenceIdsBySource.get(source);
+    if (ids) {
+      ids.push(referenceId2);
+    } else {
+      referenceIdsBySource.set(source, [referenceId2]);
+    }
+  }
+  if (typeof ssrEnv?.runner?.import !== "function") {
+    const [source, ids] = referenceIdsBySource.entries().next().value;
+    throw projectionError2(
+      ids[0],
+      source,
+      "the SSR module runner is unavailable"
+    );
+  }
+  const nextProjections = /* @__PURE__ */ new Map();
+  const removedSources = [];
+  for (const [source, referenceIds] of referenceIdsBySource) {
+    let module;
+    try {
+      module = await ssrEnv.runner.import(source);
+    } catch (cause) {
+      if (!existsSync(source)) {
+        removedSources.push(source);
+        continue;
+      }
+      throw projectionError2(
+        referenceIds[0],
+        source,
+        "failed to import the source module",
+        cause
+      );
+    }
+    let projection;
+    try {
+      projection = projectClientUrlsModule(module, { hoisted: true });
+    } catch (cause) {
+      throw projectionError2(
+        referenceIds[0],
+        source,
+        cause instanceof Error ? cause.message : String(cause),
+        cause
+      );
+    }
+    if (!projection) {
+      throw projectionError2(
+        referenceIds[0],
+        source,
+        'the module default export must be created by clientUrls() and have __brand === "client-urls"'
+      );
+    }
+    for (const referenceId2 of referenceIds) {
+      nextProjections.set(referenceId2, projection);
+    }
+  }
+  for (const source of removedSources) {
+    for (const [referenceId2, recorded] of sourceByReferenceId) {
+      if (recorded === source) sourceByReferenceId.delete(referenceId2);
+    }
+  }
+  await installClientUrlProjections(
+    state,
+    rscEnv,
+    serverMod,
+    nextProjections,
+    true
+  );
+}
+async function installClientUrlProjections(state, rscEnv, serverMod, projections, replace) {
+  const next = new Map(replace ? void 0 : state.clientUrlProjectionMap);
+  for (const [id, projection] of projections) next.set(id, projection);
+  await assignClientUrlRevalidateFiles(state, rscEnv, next);
+  if (replace) serverMod.clearClientUrlProjections();
+  for (const [id, projection] of projections) {
+    serverMod.setClientUrlProjection(id, projection);
+  }
+  state.clientUrlProjectionMap = next;
+}
+async function assignClientUrlRevalidateFiles(state, rscEnv, projections) {
+  const { fileByKey, filesByGroup } = state.clientUrlRevalidate;
+  const next = /* @__PURE__ */ new Map();
+  for (const [referenceId2, projection] of projections) {
+    const group = state.clientUrlSourceByReferenceId?.get(referenceId2);
+    if (group === void 0 || next.has(group)) continue;
+    const files = /* @__PURE__ */ new Set();
+    for (const owner of [
+      ...projection.routes,
+      ...projection.intercepts ?? []
+    ]) {
+      for (const key of owner.loaderRevalidate?.flat() ?? []) {
+        const file = typeof key === "string" ? fileByKey.get(key) : void 0;
+        if (file !== void 0 && file !== group) files.add(file);
+      }
+    }
+    next.set(group, [...files].sort());
+  }
+  await Promise.all(
+    [...new Set([...next.values()].flat())].map(
+      (file) => rscEnv.runner.import(hoistedRevalidateId(file))
+    )
+  );
+  const graph = rscEnv.moduleGraph;
+  for (const [group, files] of next) {
+    if ((filesByGroup.get(group) ?? []).join("\0") === files.join("\0")) {
+      continue;
+    }
+    const mod = graph?.getModuleById(hoistedRevalidateId(group));
+    if (graph && mod) graph.invalidateModule(mod);
+  }
+  filesByGroup.clear();
+  for (const [group, files] of next) filesByGroup.set(group, files);
+}
+
+export {
+  hasUseClientDirective,
+  NS,
+  createRangoDebugger,
+  createCounter,
+  computeProductionHash,
+  hashClientRefs,
+  TransitionWhenError,
+  HOISTED_REVALIDATE_KEY,
+  TYPE_KEYS,
+  analyzeScopes,
+  collectImports,
+  directivePrologueEnd,
+  parseLang,
+  unwrapExpression,
+  isFunctionLiteral,
+  propertyKeyIs,
+  findHelperCalls,
+  findLexicalCapture,
+  collectFreeReferences,
+  emitImports,
+  CLIENT_URLS_REVALIDATE_QUERY,
+  hoistedRevalidateId,
+  recordClientUrlsModule,
+  CLIENT_IMPORT_RE,
+  isClientUrlsComponentUseSource,
+  componentUseSignature,
+  resolveClientUrlsSource,
+  scanForClientUrlModules,
+  refreshRecordedClientUrlProjections,
+  discoverClientUrlProjections,
+  assignClientUrlRevalidateFiles
+};