@rangojs/router 0.0.0-experimental.debug-cache-2383ca26 → 0.0.0-experimental.df410dd5

package/src/testing/run-loader.ts

@@ -0,0 +1,341 @@
+/**
+ * runLoader — unit-test a loader function in isolation.
+ *
+ * Pass the RAW async loader body `(ctx) => ...`, or a registered `createLoader()`
+ * handle (its fn is recovered from the fetchable registry by `$$id`). The raw
+ * body needs no build step; the handle works because `createLoader` assigns a
+ * runtime-fallback `$$id` and registers its fn even without the Vite plugin (when
+ * imported through the server build — the consumer's `@rangojs/router` under the
+ * `rangoTestConfig()` preset). Either way the function is invoked directly with a
+ * constructed LoaderContext.
+ *
+ * The LoaderContext mirrors the canonical shape the router builds at runtime
+ * (see createUseFunction in server/request-context.ts). The loader runs inside
+ * runWithRequestContext so getRequestContext(), cookie reads, and header
+ * mutations resolve exactly as in production.
+ *
+ * Limitations (v1):
+ * - `ctx.rendered()` is not available — it requires the DSL render barrier,
+ *   which only exists inside a full match. Calling it throws.
+ * - `ctx.reverse()` throws unless `routeMap` is provided (it does NOT fall back
+ *   to the global route map — that would leak whichever routes another test
+ *   registered).
+ * - `ctx.use(handle)` follows the production rule: reading a handle before
+ *   `await ctx.rendered()` throws (pass `rendered` to mock the barrier).
+ * - `use cache` functions only cache (and only fire their taint/profile guards)
+ *   when a `cacheStore` is provided — without one, registerCachedFunction
+ *   bypasses (it checks for a store first). Pass `cacheStore`/`cacheProfiles`
+ *   to exercise cached loaders; otherwise such a call runs uncached, like an
+ *   app with no cache configured.
+ * - `formData` is exposed verbatim; no multipart parsing is performed.
+ * - Scoped dot-local reverse (`.sibling`) uses only the supplied `routeMap`;
+ *   the production root-scoping signal (derived from the global registry) is
+ *   not modeled, so a dotted name resolves against `routeMap` as given.
+ */
+
+import {
+  runWithRequestContext,
+  type RequestContext,
+} from "../server/request-context.js";
+import { createReverseFunction } from "../router/handler-context.js";
+import { getFetchableLoader } from "../server/fetchable-loader-store.js";
+import type { LoaderContext, LoaderDefinition } from "../types.js";
+import type { ContextVar } from "../context-var.js";
+import { isHandle, type Handle } from "../handle.js";
+import type { ThemeConfig } from "../theme/types.js";
+import type { SegmentCacheStore } from "../cache/types.js";
+import type { CacheProfile } from "../cache/profile-registry.js";
+import {
+  createTestRequestContext,
+  type CreateTestContextOptions,
+  type VarsInit,
+} from "./internal/context.js";
+
+/**
+ * The loader context surfaced to a `runLoader` body. It mirrors the runtime
+ * LoaderContext but RELAXES the two members that are otherwise bound to the
+ * app's global route/var augmentation, because in a unit test they are driven by
+ * the `routeMap` / `vars` options instead:
+ * - `reverse` accepts any route name (the names come from `routeMap`, not the
+ *   registered route map), and
+ * - `get` accepts any string key or ContextVar (keys come from `vars`).
+ */
+export type TestLoaderContext<TEnv = any> = Omit<
+  LoaderContext<any, TEnv>,
+  "reverse" | "get"
+> & {
+  reverse: (
+    name: string,
+    params?: Record<string, string>,
+    search?: Record<string, unknown>,
+  ) => string;
+  get: {
+    <T>(contextVar: ContextVar<T>): T | undefined;
+    <T = unknown>(key: string): T | undefined;
+  };
+};
+
+/**
+ * A resolver for `ctx.use(OtherLoader)` composition. Receives the dependency
+ * loader definition and returns its data (or a promise of it). When omitted,
+ * `ctx.use` delegates to the real request-context use(), which executes the
+ * dependency's own `fn` if present.
+ */
+export type UseResolver = <T>(
+  loader: LoaderDefinition<T, any>,
+) => Promise<T> | T;
+
+/**
+ * Options for runLoader.
+ */
+export interface RunLoaderOptions<TEnv = any> {
+  /** Route params surfaced as `ctx.params` and `ctx.routeParams`. */
+  params?: Record<string, string>;
+  /** Search params; merged into the request URL so `ctx.searchParams` reflects them. */
+  search?: Record<string, string>;
+  /**
+   * The TYPED `ctx.search` object a route's search schema would produce. Distinct
+   * from `search` (which sets the raw `ctx.searchParams`): a loader on a typed
+   * search route reads `ctx.search`, which is otherwise `{}` in a test.
+   */
+  searchData?: Record<string, unknown>;
+  /** Router basename surfaced on the context (drives redirect() prefixing). */
+  basename?: string;
+  /**
+   * Theme config in the same shape `createRouter({ theme })` takes (e.g. `true`
+   * or `{ themes: [...] }`). Without it `ctx.theme`/`ctx.setTheme` are inert.
+   */
+  theme?: ThemeConfig | true;
+  /** Environment bindings surfaced as `ctx.env`. */
+  env?: TEnv;
+  /** Override the backing Request (string or Request). Defaults to a localhost GET. */
+  request?: Request | string;
+  /** Variables a prior middleware would have set (object or [key, value] list). */
+  vars?: VarsInit;
+  /** Route name -> pattern map enabling `ctx.reverse()`. */
+  routeMap?: Record<string, string>;
+  /** Matched route name for scoped `.name` reverse resolution. */
+  routeName?: string;
+  /** HTTP method surfaced as `ctx.method`. Defaults to "GET". */
+  method?: string;
+  /** Request body surfaced as `ctx.body`. */
+  body?: unknown;
+  /** Form data surfaced as `ctx.formData`. */
+  formData?: FormData;
+  /** Resolver for `ctx.use(OtherLoader)` composition. */
+  use?: UseResolver;
+  /**
+   * Cache store backing `use cache` functions the loader invokes. Without it,
+   * a cached function bypasses (registerCachedFunction checks for a store
+   * first) and runs uncached — its taint/profile guards never fire. Pass one
+   * (e.g. `new MemorySegmentCacheStore()`) to test a cached loader.
+   */
+  cacheStore?: SegmentCacheStore;
+  /** Cache profiles (the `createRouter({ cacheProfiles })` shape). */
+  cacheProfiles?: Record<string, CacheProfile>;
+  /**
+   * Mock the `ctx.rendered()` render barrier so a loader that does
+   * `await ctx.rendered()` (to read handle data pushed during render) can be
+   * unit-tested. By default `ctx.rendered()` throws, because the real barrier
+   * only exists during a full route match. Pass `true` to resolve it
+   * immediately, or a function to control its timing/side effects.
+   *
+   * This tests the loader's POST-barrier compute logic against the seeded
+   * `handles` below — it does NOT exercise the real push -> accumulate -> barrier
+   * wiring (that stays e2e). Pair with `handles` to feed `ctx.use(SomeHandle)`.
+   */
+  rendered?: boolean | (() => void | Promise<void>);
+  /**
+   * Seed the values `ctx.use(SomeHandle)` returns — the ACCUMULATED handle data a
+   * loader reads after `await ctx.rendered()`. Matched by handle reference, so a
+   * real handle works regardless of its (build-injected) `$$id`.
+   *
+   * @example
+   * await runLoader(livePricesBody, {
+   *   rendered: true,
+   *   handles: [[RenderedProducts, ["widget-a", "widget-b"]]],
+   * });
+   */
+  handles?: ReadonlyArray<readonly [Handle<any, any>, unknown]>;
+}
+
+/**
+ * Merge `search` into a request's URL, returning a value `toRequest` can build.
+ * Keeps the original method/headers/body when a Request was passed.
+ */
+function withSearch(
+  request: Request | string | undefined,
+  search: Record<string, string> | undefined,
+): Request | string | undefined {
+  if (!search) return request;
+  const DEFAULT_ORIGIN = "http://localhost/";
+  if (request instanceof Request) {
+    const url = new URL(request.url);
+    for (const [key, value] of Object.entries(search)) {
+      url.searchParams.set(key, value);
+    }
+    return new Request(url, request);
+  }
+  const url = new URL(request ?? DEFAULT_ORIGIN, DEFAULT_ORIGIN);
+  for (const [key, value] of Object.entries(search)) {
+    url.searchParams.set(key, value);
+  }
+  return url.toString();
+}
+
+/** A raw loader body, or a registered `createLoader()` handle (its fn is recovered). */
+export type RunnableLoader<T> =
+  | ((ctx: TestLoaderContext) => Promise<T> | T)
+  | LoaderDefinition<T, any>;
+
+/**
+ * Resolve the function to run from either a raw body or a `createLoader()` handle.
+ *
+ * A handle carries no inline body (`createLoader` registers it in the fetchable
+ * registry by `$$id`), so recover it from there — `def.fn` first (a hand-built
+ * def), then the registry. This works when the handle resolves through the
+ * SERVER build (the consumer's `@rangojs/router` under `rangoTestConfig`, which
+ * registers the fn); the CLIENT stub drops the body, so a handle imported that
+ * way is unrecoverable and we say so explicitly.
+ */
+function resolveLoaderFn<T>(
+  loader: RunnableLoader<T>,
+): (ctx: TestLoaderContext) => Promise<T> | T {
+  if (typeof loader === "function") {
+    return loader as (ctx: TestLoaderContext) => Promise<T> | T;
+  }
+  const def = loader as LoaderDefinition<T, any>;
+  const fn = def.fn ?? getFetchableLoader(def.$$id)?.fn;
+  if (!fn) {
+    throw new Error(
+      `runLoader() received a createLoader() handle whose function could not be ` +
+        `recovered (id "${def.$$id || "<empty>"}"). The loader was likely imported ` +
+        `through the CLIENT build, which drops the body. Either import it through ` +
+        `@rangojs/router with the rangoTestConfig() preset (resolves to the server ` +
+        `build that registers the fn), or pass the raw loader body directly: ` +
+        `runLoader((ctx) => ...).`,
+    );
+  }
+  return fn as (ctx: TestLoaderContext) => Promise<T> | T;
+}
+
+/**
+ * Run a loader and return its resolved data. Pass the RAW loader body, or a
+ * registered `createLoader()` handle (its fn is recovered from the registry).
+ *
+ * @example
+ * ```ts
+ * // raw body
+ * const a = await runLoader(
+ *   async (ctx) => ({ id: ctx.params.id, user: ctx.get("user") }),
+ *   { params: { id: "42" }, vars: { user: { name: "Ada" } } },
+ * );
+ * // registered createLoader() handle (recovered from the registry)
+ * const b = await runLoader(ProductLoader, { params: { id: "42" } });
+ * ```
+ */
+export async function runLoader<T>(
+  loader: RunnableLoader<T>,
+  opts: RunLoaderOptions = {},
+): Promise<T> {
+  const loaderFn = resolveLoaderFn(loader);
+  const ctxOpts: CreateTestContextOptions<any> = {
+    env: opts.env,
+    // Bake opts.search into the request URL itself so ctx.request.url, ctx.url,
+    // and ctx.searchParams all agree (production carries the query string on the
+    // real request — a loader reading ctx.request.url must see it too).
+    request: withSearch(opts.request, opts.search),
+    requestInit: opts.method ? { method: opts.method } : undefined,
+    vars: opts.vars,
+    routeMap: opts.routeMap,
+    routeName: opts.routeName,
+    params: opts.params,
+    basename: opts.basename,
+    theme: opts.theme,
+    cacheStore: opts.cacheStore,
+    cacheProfiles: opts.cacheProfiles,
+  };
+
+  const { ctx } = createTestRequestContext(ctxOpts);
+
+  const reqCtx = ctx as RequestContext<any>;
+
+  // Seed values for ctx.use(SomeHandle), matched by handle reference (so a real
+  // handle resolves regardless of its build-injected $$id).
+  const handleSeeds = new Map<unknown, unknown>(opts.handles ?? []);
+
+  // Tracks whether the mocked render barrier has settled. ctx.use(handle)
+  // reads are gated on this, matching production (loader-resolution.ts).
+  let renderedResolved = false;
+
+  return runWithRequestContext(reqCtx, () => {
+    const reverse = opts.routeMap
+      ? createReverseFunction(opts.routeMap, opts.routeName, opts.params ?? {})
+      : ((() => {
+          // Documented contract: reverse requires routeMap. Do NOT fall back to
+          // reqCtx.reverse (the global route map) — that leaks whichever routes
+          // another test registered and contradicts the documented behavior.
+          throw new Error(
+            "ctx.reverse() requires the `routeMap` option in runLoader(). " +
+              "Pass { routeMap: { name: pattern, ... } } to enable reverse().",
+          );
+        }) as TestLoaderContext["reverse"]);
+
+    const loaderCtx: TestLoaderContext = {
+      params: opts.params ?? {},
+      routeParams: (opts.params ?? {}) as Record<string, string>,
+      request: reqCtx.request,
+      searchParams: ctx.searchParams,
+      search: opts.searchData ?? {},
+      pathname: reqCtx.pathname,
+      url: reqCtx.url,
+      originalUrl: reqCtx.originalUrl,
+      env: reqCtx.env,
+      waitUntil: reqCtx.waitUntil.bind(reqCtx),
+      executionContext: reqCtx.executionContext,
+      get: reqCtx.get as TestLoaderContext["get"],
+      use: ((dep: LoaderDefinition<any, any> | Handle<any, any>) => {
+        // Match production (loader-resolution.ts): reading a handle in a loader
+        // requires the render barrier to have settled. Gate BEFORE returning a
+        // seed, so a loader that forgets `await ctx.rendered()` fails in the
+        // test exactly as it would at runtime.
+        if (isHandle(dep) && !renderedResolved) {
+          throw new Error(
+            `ctx.use(handle) in a loader requires "await ctx.rendered()" first. ` +
+              `Handle "${(dep as Handle<any, any>).$$id}" cannot be read until ` +
+              `the render tree has settled.`,
+          );
+        }
+        // Handle reads (ctx.use(SomeHandle)) resolve from the seeded map first.
+        if (handleSeeds.has(dep)) return handleSeeds.get(dep);
+        if (opts.use) return opts.use(dep as LoaderDefinition<any, any>);
+        return reqCtx.use(dep as LoaderDefinition<any, any>);
+      }) as LoaderContext<any, any>["use"],
+      method: opts.method ?? "GET",
+      body: opts.body,
+      formData: opts.formData,
+      reverse: reverse as TestLoaderContext["reverse"],
+      rendered:
+        opts.rendered !== undefined && opts.rendered !== false
+          ? async () => {
+              if (typeof opts.rendered === "function") {
+                await opts.rendered();
+              }
+              // Barrier has settled: subsequent ctx.use(handle) reads resolve.
+              renderedResolved = true;
+            }
+          : () => {
+              throw new Error(
+                "ctx.rendered() is not available in runLoader() by default. It " +
+                  "requires the DSL render barrier, which only exists during a " +
+                  "full route match. To unit-test a loader's post-barrier logic, " +
+                  "pass { rendered: true } to mock the barrier and { handles: " +
+                  "[[SomeHandle, accumulatedData]] } to seed ctx.use(SomeHandle). " +
+                  "For the real push/accumulate/barrier wiring, use an e2e test.",
+              );
+            },
+    };
+
+    return Promise.resolve(loaderFn(loaderCtx));
+  });
+}

package/src/testing/run-middleware.ts

@@ -0,0 +1,179 @@
+/**
+ * runMiddleware — unit-test one or more middleware functions in isolation.
+ *
+ * Executes the middleware chain via the SAME executeLoaderMiddleware the router
+ * uses, so ordering, `next()`, short-circuit (return OR throw Response),
+ * double-next guards, and header/cookie merging behave identically to
+ * production. The chain runs inside runWithRequestContext, so cookie/header
+ * mutations and getRequestContext() resolve.
+ *
+ * The returned `ctx` is the underlying RequestContext (not the per-middleware
+ * MiddlewareContext), exposing `ctx.cookies()`, `ctx.get()`, and
+ * `ctx.res.headers` for assertions on what the chain produced.
+ *
+ * `nextCalled` counts how many times the terminal `next()` (the finalHandler)
+ * ran: 0 when the chain short-circuited, 1 when it ran to completion.
+ */
+
+import {
+  runWithRequestContext,
+  type RequestContext,
+} from "../server/request-context.js";
+import { executeLoaderMiddleware } from "../router/middleware.js";
+import { createReverseFunction } from "../router/handler-context.js";
+import type { MiddlewareFn } from "../router/middleware-types.js";
+import {
+  createTestRequestContext,
+  snapshotRunEffects,
+  type CreateTestContextOptions,
+  type VarsInit,
+} from "./internal/context.js";
+import type { ThemeConfig } from "../theme/types.js";
+import type { SegmentCacheStore } from "../cache/types.js";
+import type { CacheProfile } from "../cache/profile-registry.js";
+
+/**
+ * Options for runMiddleware.
+ */
+export interface RunMiddlewareOptions<TEnv = any> {
+  /** Environment bindings surfaced as `ctx.env`. */
+  env?: TEnv;
+  /** Route params surfaced as `ctx.params`. */
+  params?: Record<string, string>;
+  /** Variables a prior middleware would have set (object or [key, value] list). */
+  vars?: VarsInit;
+  /** Route name -> pattern map enabling `ctx.reverse()`. */
+  routeMap?: Record<string, string>;
+  /** Matched route name for scoped `.name` reverse resolution. */
+  routeName?: string;
+  /** Router basename surfaced on the context (drives redirect() prefixing). */
+  basename?: string;
+  /** Theme config in the `createRouter({ theme })` shape (enables ctx.theme). */
+  theme?: ThemeConfig | true;
+  /**
+   * Terminal handler invoked when the chain calls `next()` all the way through.
+   * Defaults to a 200 empty Response. Use this to model the downstream
+   * route/handler response.
+   */
+  next?: () => Promise<Response>;
+  /**
+   * Cache store backing any `use cache` function a middleware invokes. Without
+   * it, registerCachedFunction bypasses (it checks for a store first), so the
+   * cached function runs uncached and its taint/profile guards never fire.
+   */
+  cacheStore?: SegmentCacheStore;
+  /** Cache profiles (the `createRouter({ cacheProfiles })` shape). */
+  cacheProfiles?: Record<string, CacheProfile>;
+}
+
+/**
+ * Result of runMiddleware.
+ */
+export interface RunMiddlewareResult<TEnv = any> {
+  /** The final Response (downstream response, or a middleware short-circuit). */
+  response: Response;
+  /**
+   * The underlying RequestContext. Read `ctx.cookies()`, `ctx.get(...)`, and
+   * `ctx.res.headers` to assert on the chain's effects. (This is always the
+   * RequestContext the chain ran under — not a per-middleware MiddlewareContext —
+   * so `ctx.cookies()` and the other RequestContext accessors are available.)
+   */
+  ctx: RequestContext<TEnv>;
+  /** Number of times the terminal handler ran (0 = short-circuited, 1 = passed through). */
+  nextCalled: number;
+  /**
+   * The effective cookie view after the chain ran: request cookies merged with
+   * anything the chain set or deleted (last-write-wins), as `{ name: value }`.
+   * The public way to assert a cookie a middleware set, without casting through
+   * the `@internal` `ctx.cookies()`. Set-Cookie headers are also on `response`.
+   */
+  cookies: Record<string, string>;
+}
+
+/**
+ * Run a middleware chain and return the response plus observable context.
+ *
+ * @example
+ * ```ts
+ * const { response, ctx, nextCalled } = await runMiddleware(
+ *   async (ctx, next) => {
+ *     if (!ctx.get("user")) return new Response(null, { status: 401 });
+ *     return next();
+ *   },
+ *   "/dashboard",
+ *   { vars: [["user", { id: 1 }]] },
+ * );
+ * // nextCalled === 1, response.status === 200
+ * ```
+ */
+export async function runMiddleware<TEnv = any>(
+  mw: MiddlewareFn<TEnv> | MiddlewareFn<TEnv>[],
+  request: Request | string,
+  opts: RunMiddlewareOptions<TEnv> = {},
+): Promise<RunMiddlewareResult<TEnv>> {
+  const mwArray = Array.isArray(mw) ? mw : [mw];
+
+  const ctxOpts: CreateTestContextOptions<TEnv> = {
+    env: opts.env,
+    request,
+    vars: opts.vars,
+    routeMap: opts.routeMap,
+    routeName: opts.routeName,
+    params: opts.params,
+    basename: opts.basename,
+    theme: opts.theme,
+    cacheStore: opts.cacheStore,
+    cacheProfiles: opts.cacheProfiles,
+  };
+
+  const {
+    ctx,
+    request: builtRequest,
+    variables,
+  } = createTestRequestContext<TEnv>(ctxOpts);
+
+  let nextCalled = 0;
+  const finalHandler = async (): Promise<Response> => {
+    nextCalled++;
+    return opts.next?.() ?? new Response(null, { status: 200 });
+  };
+
+  // Match production: app/response middleware receive ctx.reverse built from the
+  // route map ALONE (no matched route name or current params), so reversing a
+  // parameterized route without explicit params does NOT auto-fill from the
+  // current request. Passing routeName/params here would recreate the
+  // false-confidence class fixed in dispatch.
+  const reverse = opts.routeMap
+    ? (createReverseFunction(opts.routeMap) as (
+        name: string,
+        params?: Record<string, string>,
+        search?: Record<string, unknown>,
+      ) => string)
+    : undefined;
+
+  // Keep the RETURNED ctx.reverse consistent with the map-only reverse the
+  // chain receives. createTestRequestContext installs an auto-fill reverse
+  // (correct for the loader phase) when routeName/params are passed, but
+  // production app/response middleware see a map-only reverse. Without this,
+  // a middleware reading getRequestContext().reverse — or a consumer asserting
+  // on result.ctx.reverse — would observe auto-fill that production never does.
+  if (reverse) {
+    (ctx as RequestContext<TEnv>).reverse =
+      reverse as RequestContext<TEnv>["reverse"];
+  }
+
+  const response = await runWithRequestContext(ctx, () =>
+    executeLoaderMiddleware<TEnv>(
+      mwArray,
+      builtRequest,
+      (opts.env ?? {}) as TEnv,
+      opts.params ?? {},
+      variables,
+      finalHandler,
+      reverse,
+    ),
+  );
+
+  const { cookies } = snapshotRunEffects(ctx);
+  return { response, ctx, nextCalled, cookies };
+}

package/src/testing/vitest-stubs/cloudflare-email.ts

@@ -0,0 +1,9 @@
+// Stub for the `cloudflare:email` runtime virtual, shipped for Cloudflare
+// consumers (enable via `rangoTestAliases({ cloudflare: true })`).
+export class EmailMessage {
+  constructor(
+    public from: string,
+    public to: string,
+    public raw: unknown,
+  ) {}
+}

package/src/testing/vitest-stubs/cloudflare-workers.ts

@@ -0,0 +1,21 @@
+// Stub for the `cloudflare:workers` runtime virtual, shipped for Cloudflare
+// consumers (enable via `rangoTestAliases({ cloudflare: true })`). A CF app's
+// route tree commonly imports `cloudflare:workers` (e.g. `import { env } from
+// "cloudflare:workers"`), which does not resolve in a bare Vitest process.
+export const env: Record<string, unknown> = {};
+
+export class DurableObject<Env = unknown> {
+  constructor(
+    public ctx: unknown,
+    public env: Env,
+  ) {}
+}
+
+export class WorkerEntrypoint<Env = unknown> {
+  constructor(
+    public ctx: unknown,
+    public env: Env,
+  ) {}
+}
+
+export class RpcTarget {}

package/src/testing/vitest-stubs/plugin-rsc.ts

@@ -0,0 +1,16 @@
+// Stub for `@vitejs/plugin-rsc/rsc`, shipped so consumers do not have to write a
+// per-file `vi.mock(...)`. Importing a router internal transitively pulls this
+// module, whose real top-level body imports Vite virtuals that do not resolve in
+// plain node. The unit/integration primitives (dispatch/runLoader/runMiddleware)
+// never render RSC, so empty fns suffice.
+export const createFromReadableStream = (): never => {
+  throw new Error("plugin-rsc stub: createFromReadableStream not available");
+};
+export const renderToReadableStream = (): never => {
+  throw new Error("plugin-rsc stub: renderToReadableStream not available");
+};
+export const loadServerAction = (): undefined => undefined;
+export const decodeReply = (): undefined => undefined;
+export const decodeAction = (): undefined => undefined;
+export const decodeFormState = (): undefined => undefined;
+export const createTemporaryReferenceSet = (): Record<string, never> => ({});

package/src/testing/vitest-stubs/version.ts

@@ -0,0 +1,5 @@
+// Stub for the build-only `@rangojs/router:version` virtual module, shipped so
+// consumers do not have to author it. The rango Vite plugin injects this at
+// build time; in a bare Vitest process it must be aliased to a stub. Empty
+// string keeps generated URLs free of a version path segment.
+export const VERSION = "";