@rangojs/router 0.21.0 → 0.22.0

package/src/prerender/warm-request.ts

@@ -0,0 +1,154 @@
+/**
+ * The mark and record of a `router.prerender()` warm request
+ * (docs/design/prerender-every-route.md, "The synthetic request"). The
+ * trigger marks the `Request` it dispatches, the handler puts the record on
+ * the request context (`RequestContext._prerenderWarm`), and each cache layer
+ * reads the context where it reads its store. No runtime imports: the cache
+ * layers import this without pulling the trigger.
+ */
+
+import type { HandlerCacheConfig } from "../rsc/types.js";
+import type { ShellCaptureDebugEvent } from "../rsc/shell-capture.js";
+import type { PrerenderWarmCaches } from "./on-demand.js";
+
+/** What one warm request did: written by the layers, read by the trigger. */
+export interface PrerenderWarmRecord extends PrerenderWarmCaches {
+  /**
+   * `replace`: every runtime cache read misses and the writes replace the
+   * entries. `fill` (`onlyIfStale`): reads are normal; the record only reports.
+   */
+  mode: "replace" | "fill";
+  /**
+   * The `createRouter({ cache })` config the trigger gated on its scope. The
+   * handler uses it instead of resolving the option again, so the store that
+   * was checked is the store that is written.
+   */
+  cacheConfig: HandlerCacheConfig;
+  /** The surface an identity guard refused (server/context.ts guardIdentityRead). */
+  identity?: string;
+  /**
+   * The request's render errors: the handler adopts this list as
+   * `RequestContext._renderErrors`, so what the layers push lands here.
+   */
+  renderErrors: unknown[];
+}
+
+/** What the helpers read; a derived capture context inherits the record. */
+export interface WarmContext {
+  _prerenderWarm?: PrerenderWarmRecord;
+  _shellCaptureRun?: boolean;
+}
+
+/**
+ * In process on purpose: "miss every cache and overwrite it" reachable from a
+ * URL parameter, header or cookie would be a cache-busting amplifier. A client
+ * controls the bytes of a request, never this map's keys.
+ */
+const warmRequests = new WeakMap<Request, PrerenderWarmRecord>();
+
+export function createWarmRecord(
+  mode: PrerenderWarmRecord["mode"],
+  cacheConfig: HandlerCacheConfig,
+): PrerenderWarmRecord {
+  return {
+    mode,
+    cacheConfig,
+    renderErrors: [],
+    writes: { record: 0, item: 0, response: 0, shell: 0 },
+  };
+}
+
+/** The mark is the object: a clone or a rebuilt request carries none. */
+export function markWarmRequest(
+  request: Request,
+  record: PrerenderWarmRecord,
+): void {
+  warmRequests.set(request, record);
+}
+
+export function readWarmMark(
+  request: Request,
+): PrerenderWarmRecord | undefined {
+  return warmRequests.get(request);
+}
+
+/**
+ * True when this request must read every runtime cache as a miss. A flag read
+ * at each read point, not a store wrapper: a route's or loader's own
+ * `cache({ store })` bypasses the app store (CacheScope.getStore), and the
+ * "use cache" in-flight dedup lives outside the store, so a wrapper would
+ * miss both.
+ *
+ * False in the warm's own shell capture (`_shellCaptureRun`): it runs after
+ * the warm's writes settled and must replay them, or it would render every
+ * handler a second time and could bake another generation than the one just
+ * written.
+ */
+export function isWarmReplace(ctx: WarmContext | null | undefined): boolean {
+  return (
+    ctx?._prerenderWarm?.mode === "replace" && ctx._shellCaptureRun !== true
+  );
+}
+
+/** Count a store write that landed. No-op outside a warm. */
+export function noteWarmWrite(
+  ctx: WarmContext | null | undefined,
+  family: keyof PrerenderWarmCaches["writes"],
+): void {
+  const record = ctx?._prerenderWarm;
+  if (record) record.writes[family] += 1;
+}
+
+/** Record the document cache's outcome; its store write counts through noteWarmWrite. */
+export function noteWarmDocument(
+  ctx: WarmContext | null | undefined,
+  outcome: NonNullable<PrerenderWarmCaches["document"]>,
+): void {
+  const record = ctx?._prerenderWarm;
+  if (!record) return;
+  record.document = outcome;
+}
+
+/** Record the surface an identity guard (guardIdentityRead) is about to refuse. */
+export function noteWarmIdentityRead(
+  ctx: WarmContext | null | undefined,
+  surface: string,
+): void {
+  const record = ctx?._prerenderWarm;
+  if (record) record.identity ??= surface;
+}
+
+const SHELL_EVENT_OUTCOMES: Partial<
+  Record<
+    ShellCaptureDebugEvent["outcome"],
+    NonNullable<PrerenderWarmCaches["shell"]>
+  >
+> = {
+  stored: "stored",
+  refused: "refused",
+  "no-shell": "no-shell",
+  expired: "no-shell",
+  redirect: "no-shell",
+  error: "error",
+  "skip-capacity": "skipped-capacity",
+  "skip-queue-timeout": "skipped-queue-timeout",
+  "skip-inert-store": "not-eligible",
+};
+
+/**
+ * Fold one capture event into the record: the last attempt's outcome stands.
+ * The skips a forced capture never takes and the `backoff` notice leave it.
+ */
+export function noteWarmShellEvent(
+  record: PrerenderWarmRecord,
+  event: ShellCaptureDebugEvent,
+): void {
+  let shell = SHELL_EVENT_OUTCOMES[event.outcome];
+  if (shell === undefined) return;
+  // A putShell that threw still ends the attempt `stored` (the capture
+  // worked; shell-capture.ts reports the I/O error), but counted no write.
+  if (shell === "stored" && record.writes.shell === 0) shell = "error";
+  record.shell = shell;
+  if (shell === "stored") delete record.refusal;
+  else if (event.refusal !== undefined) record.refusal = event.refusal;
+}

package/src/prerender/warm.ts

@@ -0,0 +1,193 @@
+/**
+ * One `router.prerender()` warm request: build the synthetic visitor request,
+ * dispatch it through the router's own handler, wait for everything it
+ * scheduled, and read back what it wrote
+ * (docs/design/prerender-every-route.md, "The synthetic request"). The handler
+ * is an injected `fetch`, so unit tests drive this with a fake.
+ */
+
+import {
+  awaitLaterMillisecond,
+  raceDeadline,
+  settleGrowing,
+  type CollectingExecutionContext,
+} from "../cache/background-task.js";
+import { CAPTURE_QUEUE_WAIT_BUDGET_MS } from "../rsc/capture-queue.js";
+import { SHELL_CAPTURE_TASK_HARD_CAP_MS } from "../rsc/shell-capture-constants.js";
+import type { HandlerCacheConfig } from "../rsc/types.js";
+import type { ExecutionContext } from "../types/request-scope.js";
+import type { PrerenderResult, PrerenderWarmCaches } from "./on-demand.js";
+import {
+  createWarmRecord,
+  markWarmRequest,
+  type PrerenderWarmRecord,
+} from "./warm-request.js";
+
+/**
+ * How long a warm waits for its response body and background work: a capture
+ * that waited out the queue budget, then ran to its hard cap.
+ */
+export const WARM_SETTLE_BUDGET_MS: number =
+  SHELL_CAPTURE_TASK_HARD_CAP_MS + CAPTURE_QUEUE_WAIT_BUDGET_MS;
+
+export interface WarmRequestInput<TEnv> {
+  /** The absolute URL a visitor requests. */
+  url: URL;
+  mode: PrerenderWarmRecord["mode"];
+  /** The gated `createRouter({ cache })` config; the handler writes to its store. */
+  cacheConfig: HandlerCacheConfig;
+  env: TEnv;
+  /** The context `cacheConfig` was resolved with. */
+  ctx: CollectingExecutionContext;
+  /** `router.fetch`. */
+  fetch: (
+    request: Request,
+    input: { env: TEnv; ctx: ExecutionContext },
+  ) => Promise<Response>;
+  /** Tests shorten the wait. */
+  settleBudgetMs?: number;
+}
+
+export interface WarmRequestOutcome {
+  record: PrerenderWarmRecord;
+  /** Absent when the handler threw before answering. */
+  responseStatus?: number;
+  /** The handler's throw, a body that failed mid-stream, or a wait that ran out. */
+  error?: unknown;
+}
+
+/**
+ * Dispatch one warm: a GET with `accept: text/html` and nothing else, so it
+ * lands in the partition a header-less visitor lands in. The response is
+ * drained and dropped: what it rendered reaches a visitor only through a
+ * store.
+ */
+export async function runWarmRequest<TEnv>(
+  input: WarmRequestInput<TEnv>,
+): Promise<WarmRequestOutcome> {
+  // `await updateTag(tag)` then a warm is the content-refresh pattern, and a
+  // store refuses a shell whose capture started in the millisecond of an
+  // invalidation of one of its tags (putShell's gate compares whole
+  // milliseconds). Start in a later one, within the helper's bound.
+  await awaitLaterMillisecond(Date.now());
+  const record = createWarmRecord(input.mode, input.cacheConfig);
+  const request = new Request(input.url, { headers: { accept: "text/html" } });
+  markWarmRequest(request, record);
+  const deadline = Date.now() + (input.settleBudgetMs ?? WARM_SETTLE_BUDGET_MS);
+
+  let responseStatus: number | undefined;
+  let error: unknown;
+  try {
+    const response = await input.fetch(request, {
+      env: input.env,
+      ctx: input.ctx,
+    });
+    responseStatus = response.status;
+    // The render, and the tags and writes it records, finish with the body.
+    const drained = await raceDeadline(drainBody(response), deadline);
+    if (!drained.done) {
+      error = new Error(
+        `router.prerender(): the response for ${input.url.href} did not finish within the warm's wait`,
+      );
+    }
+  } catch (err) {
+    error = err ?? new Error("router.prerender(): the warm request failed");
+  }
+  await settleGrowing(input.ctx.tasks, deadline);
+  return { record, responseStatus, error };
+}
+
+/**
+ * Read the body to its end without keeping it. A non-200 is a failed warm
+ * whatever its body says, so it is cancelled instead.
+ */
+async function drainBody(response: Response): Promise<void> {
+  const { body } = response;
+  if (!body) return;
+  if (response.status !== 200) {
+    await body.cancel().catch(() => {});
+    return;
+  }
+  const reader = body.getReader();
+  while (!(await reader.read()).done);
+}
+
+/** The per-cache detail a result carries. */
+export function warmCaches(record: PrerenderWarmRecord): PrerenderWarmCaches {
+  return {
+    writes: { ...record.writes },
+    ...(record.shell !== undefined ? { shell: record.shell } : {}),
+    ...(record.refusal !== undefined ? { refusal: record.refusal } : {}),
+    ...(record.document !== undefined ? { document: record.document } : {}),
+  };
+}
+
+/**
+ * A warm's status from what it recorded, first match wins. An identity
+ * refusal comes ahead of the render failure it usually also causes (the guard
+ * throws). `record.shell` is set only for a `ppr` route (shellServePlan).
+ */
+export function warmStatus(outcome: WarmRequestOutcome): WarmStatus {
+  const { record, responseStatus, error } = outcome;
+  if (record.identity !== undefined) return "skipped-personalized";
+  if (
+    error !== undefined ||
+    responseStatus !== 200 ||
+    record.renderErrors.length > 0
+  ) {
+    return "render-failed";
+  }
+  if (
+    record.shell !== undefined &&
+    record.shell !== "stored" &&
+    record.shell !== "fresh"
+  ) {
+    return "shell-not-stored";
+  }
+  const { writes } = record;
+  if (writes.record + writes.item + writes.response + writes.shell === 0) {
+    return record.mode === "fill" ? "already-fresh" : "skipped-uncached";
+  }
+  return "warmed";
+}
+
+type WarmStatus =
+  | Extract<PrerenderResult, { ok: true; path: "warm" }>["status"]
+  | Extract<PrerenderResult, { ok: false }>["status"];
+
+/** The `PrerenderResult` of a finished warm. */
+export function composeWarmResult(
+  outcome: WarmRequestOutcome,
+  target: string,
+  routeName: string,
+): PrerenderResult {
+  const status = warmStatus(outcome);
+  const caches = warmCaches(outcome.record);
+  if (status === "warmed" || status === "already-fresh") {
+    // Both are answered only for a 200 (warmStatus).
+    return {
+      ok: true,
+      path: "warm",
+      status,
+      target,
+      routeName,
+      responseStatus: outcome.responseStatus!,
+      caches,
+    };
+  }
+  const error =
+    outcome.error ??
+    (status === "render-failed" ? outcome.record.renderErrors[0] : undefined);
+  return {
+    ok: false,
+    path: "warm",
+    status,
+    target,
+    routeName,
+    ...(outcome.responseStatus !== undefined
+      ? { responseStatus: outcome.responseStatus }
+      : {}),
+    caches,
+    ...(error !== undefined ? { error } : {}),
+  };
+}

package/src/prerender/writable-store.ts

@@ -0,0 +1,278 @@
+/**
+ * Writable prerender store contract for on-demand (ISR-style) prerender refresh.
+ *
+ * The bundled build manifest (store.ts) is immutable and read-only. On-demand
+ * prerender adds a writable durable overlay in front of it: `router.prerender()`
+ * renders a route and writes a versioned envelope here; the serve path reads the
+ * overlay before the bundled manifest.
+ *
+ * This module is types + pure helpers only — no React/RSC/plugin-rsc imports —
+ * so it can be imported by the testing barrel and platform adapters alike.
+ */
+
+import type { PrerenderEntry } from "./store.js";
+import { paramsEqual } from "../router/params-util.js";
+
+/**
+ * Structured durable-overlay key. Includes the router's cache version so a
+ * deploy that changed the router's server code never reads Flight payloads
+ * that reference its previous build, and so Cloudflare gradual deployments
+ * stay correct (old and new worker versions each read their own namespace).
+ */
+export interface PrerenderKey {
+  routerId: string;
+  /**
+   * The owning router's cache version (its data version, or
+   * `createRouter({ version })`). Opaque: never set or read by app code; a
+   * store keys off it as given.
+   */
+  version: string;
+  routeName: string;
+  /** DJB2 8-hex hash of the canonical params (see param-hash.ts). */
+  paramHash: string;
+}
+
+/**
+ * @internal What the trigger stamps on a write. TTL is soft staleness metadata
+ * (`staleAt`), never a hard store expiry: hard expiry would delete the entry
+ * a stale-while-revalidate serve needs, and an expired overlay would fall back
+ * to older bundled-manifest content.
+ */
+export interface StoredEntryOptions {
+  /** Seconds until the entry is considered stale. Absent = never stale. */
+  ttl?: number;
+  tags: string[];
+  /** Canonical params, stored for verify-on-read. */
+  params: Record<string, string>;
+}
+
+/** What a page and a "removed" marker both carry: a store reads either alike. */
+interface StoredEnvelope {
+  v: 1;
+  meta: {
+    /**
+     * When the render started, not when the entry was written: a `markStale()`
+     * at or after it (strictly after in an in-process store) covers the entry.
+     * A `remove()` marker renders nothing and carries its write time.
+     */
+    storedAt: number;
+    /**
+     * Absent = never stale. Soft metadata only; controls `onRevalidate`
+     * scheduling, not serving. Counts the ttl from the write. A store may
+     * lower it (tag markers do).
+     */
+    staleAt?: number;
+    /** The configured ttl in seconds, as a result reports it. Absent = none. */
+    ttl?: number;
+    tags: string[];
+    /** The key's `version` at write time; verified on read. */
+    version: string;
+    /** Verified against the request's params on read (DJB2 collision guard). */
+    params: Record<string, string>;
+  };
+}
+
+type StoredPage = StoredEnvelope & { entry: PrerenderEntry; removed?: never };
+
+/**
+ * The "removed" marker (tombstone) stored in place of a page, by
+ * `prerender.remove()` or by a refresh whose render hit `notFound()` (or
+ * declined with `ctx.passthrough()`). A request that finds it is not served
+ * the build-time entry below the overlay. No `entry`: a router from before the
+ * marker rejects it as malformed (a miss) instead of serving an empty page.
+ * `meta` is stamped like a page's for a render outcome, so that marker goes
+ * stale and is rechecked; a `remove()` marker has no `staleAt` and no tags.
+ */
+type StoredTombstone = StoredEnvelope & { removed: true; entry?: never };
+
+/**
+ * Versioned envelope the router composes on a refresh or a removal and
+ * verifies on every read: a page, or the marker that the page was removed. A
+ * store persists either as given and returns it as stored.
+ */
+export type PrerenderStoredEntry = StoredPage | StoredTombstone;
+
+/**
+ * The writable durable overlay: plain get/set. Backed in production by a
+ * platform adapter (Cloudflare KV, …) and in dev/tests by an in-memory store.
+ * The router composes the envelope before `set()` and verifies whatever `get()`
+ * returns (shape, `version`, params collision guard), so a store holds no
+ * policy of its own.
+ *
+ * Key everything off the `key` argument (`serializePrerenderKey(key)` carries
+ * `key.version`). Never call `getCacheVersions()` here: the trigger's `set()`
+ * runs outside the producer's request context, where it returns the
+ * whole-build fallback instead of the owning router's version.
+ */
+export interface WritablePrerenderStore {
+  /**
+   * The envelope stored under `key`, or null. Never memoize a miss: a refresh
+   * can write the key after a request missed it. May lower `meta.staleAt` (a
+   * tag marked stale after the entry was written).
+   */
+  get(key: PrerenderKey): Promise<PrerenderStoredEntry | null>;
+
+  /**
+   * Persist `stored` (a page, or the marker that the page was removed) under
+   * `key`, replacing any previous entry. No expiry.
+   */
+  set(key: PrerenderKey, stored: PrerenderStoredEntry): Promise<void>;
+
+  delete?(key: PrerenderKey): Promise<void>;
+
+  /**
+   * Mark the entries of router `routerId` (`PrerenderKey.routerId`) carrying
+   * any of `tags` stale (they keep serving). A mark covers an entry whose
+   * `meta.storedAt` it is at or after (strictly after for an in-process
+   * store), including one `set()` after the mark: a store that marks held
+   * entries in place has to remember its marks. Scope it to that router: routers
+   * behind a host router share one store, and a tag is only meaningful inside
+   * the router whose routes declared it. Optional: without it,
+   * `router.prerender().markStale()` is a no-op for this store.
+   */
+  markStale?(routerId: string, tags: string[]): Promise<void>;
+}
+
+/**
+ * Serialize a {@link PrerenderKey} to the design's string form:
+ *   `prerender:{routerId}:{version}:{routeName}:{paramHash}`
+ */
+export function serializePrerenderKey(key: PrerenderKey): string {
+  return `prerender:${key.routerId}:${key.version}:${key.routeName}:${key.paramHash}`;
+}
+
+/**
+ * @internal Compose the versioned envelope the trigger hands to `store.set()`.
+ * `now` is `meta.storedAt`; `staleFrom` (default `now`) is where the ttl
+ * starts counting. Both are passed explicitly so tests stay deterministic.
+ */
+export function composeStoredEntry(
+  key: PrerenderKey,
+  entry: PrerenderEntry,
+  options: StoredEntryOptions,
+  now: number,
+  staleFrom: number = now,
+): StoredPage {
+  // Only a finite, non-negative ttl produces a staleAt: NaN would never go
+  // stale and a negative ttl would be stale on every request.
+  const hasTtl =
+    options.ttl != null &&
+    Number.isFinite(options.ttl) &&
+    (options.ttl as number) >= 0;
+  return {
+    v: 1,
+    entry,
+    meta: {
+      storedAt: now,
+      ...(hasTtl
+        ? {
+            staleAt: staleFrom + (options.ttl as number) * 1000,
+            ttl: options.ttl as number,
+          }
+        : {}),
+      tags: options.tags,
+      version: key.version,
+      params: options.params,
+    },
+  };
+}
+
+/**
+ * @internal Compose the "removed" marker stored in place of a page. Its meta
+ * is a page's (composeStoredEntry), so `ttl` and `tags` mean the same: the
+ * marker of a render outcome is given the route's and is rechecked like a
+ * page; `prerender.remove()` gives neither, and its marker never goes stale.
+ */
+export function composeStoredTombstone(
+  key: PrerenderKey,
+  options: StoredEntryOptions,
+  now: number,
+  staleFrom: number = now,
+): StoredTombstone {
+  const { v, meta } = composeStoredEntry(
+    key,
+    { segments: [], handles: "" },
+    options,
+    now,
+    staleFrom,
+  );
+  return { v, removed: true, meta };
+}
+
+/**
+ * @internal Verify a store's answer is safe to serve for this key: the
+ * envelope shape and version tag, the key version, and the stored params
+ * against the request's (the 8-hex DJB2 collision guard, param-hash.ts: a
+ * runtime write keyed off webhook-supplied params must not serve one page's
+ * content under another's URL, nor remove another's page). False means treat
+ * it as a miss. Run by the router on every read, so a third-party store
+ * cannot skip it.
+ */
+export function isStoredEntryValidFor(
+  stored: unknown,
+  key: PrerenderKey,
+  params: Record<string, string>,
+): stored is PrerenderStoredEntry {
+  // A durable store can hold a parseable-but-malformed value (`"null"`,
+  // `{"v":1}`): a miss, never a TypeError on the serve path.
+  if (stored == null || typeof stored !== "object") return false;
+  const candidate = stored as Partial<PrerenderStoredEntry>;
+  const entry = candidate.entry;
+  const meta = candidate.meta;
+  if (
+    candidate.v !== 1 ||
+    // The "removed" marker has no entry; a page must have a whole one.
+    (candidate.removed !== true &&
+      (entry == null ||
+        typeof entry !== "object" ||
+        !Array.isArray(entry.segments) ||
+        typeof entry.handles !== "string")) ||
+    meta == null ||
+    typeof meta !== "object" ||
+    !Array.isArray(meta.tags) ||
+    typeof meta.storedAt !== "number"
+  ) {
+    return false;
+  }
+  if (meta.version !== key.version) return false;
+  return paramsEqual(meta.params ?? {}, params);
+}
+
+/** True once `now` has passed the entry's soft `staleAt`. Never-stale entries never go stale. */
+export function isStoredEntryStale(
+  stored: PrerenderStoredEntry,
+  now: number,
+): boolean {
+  return stored.meta.staleAt != null && now >= stored.meta.staleAt;
+}
+
+/**
+ * @internal Lower `meta.staleAt` to `at` when it is unset or later. Shared by
+ * the stores' tag marking so the rule cannot drift between them.
+ */
+export function lowerStoredEntryStaleAt(
+  stored: PrerenderStoredEntry,
+  at: number,
+): void {
+  if (stored.meta.staleAt == null || stored.meta.staleAt > at) {
+    stored.meta.staleAt = at;
+  }
+}
+
+/**
+ * @internal `store.get(key)` verified for serving (isStoredEntryValidFor). A
+ * store error (e.g. a KV outage) reads as a miss: the serve path falls back to
+ * the bundled manifest or live handler, and the trigger's stale check renders.
+ */
+export async function readVerifiedStoredEntry(
+  store: WritablePrerenderStore,
+  key: PrerenderKey,
+  params: Record<string, string>,
+): Promise<PrerenderStoredEntry | null> {
+  try {
+    const read = await store.get(key);
+    return isStoredEntryValidFor(read, key, params) ? read : null;
+  } catch {
+    return null;
+  }
+}

package/src/prerender.ts

@@ -123,6 +123,27 @@ export interface PrerenderOptions {
    * ```
    */
   concurrency?: number;
+
+  /**
+   * Opt this route into on-demand (ISR-style) prerender refresh via
+   * `router.prerender()`. `true` uses the router-level `prerender` defaults; an
+   * object overrides them per route.
+   *
+   * Any truthy value opts in — a literal, a spread, or an imported const:
+   * producer retention in the production bundle is driven by the evaluated
+   * route manifest (the same source that sets the runtime od flag), not a
+   * textual scan of the call.
+   *
+   * @example
+   * ```typescript
+   * export const ProductPage = Prerender(
+   *   async () => [{ id: "featured" }],
+   *   async (ctx) => <Product data={await ctx.env.PRODUCTS.get(ctx.params.id)} />,
+   *   { onDemand: { ttl: 3600, tags: ({ params }) => [`product:${params.id}`] } },
+   * );
+   * ```
+   */
+  onDemand?: import("./prerender/on-demand.js").OnDemandOption;
 }
 
 /**
@@ -144,6 +165,14 @@ export interface BuildContext<TParams> {
    */
   dev: boolean;
 
+  /**
+   * True when this render is a requestless on-demand refresh driven by
+   * `router.prerender()` (rather than a build-time or dev prerender). The
+   * producer is still requestless — cookies/headers are unavailable — but
+   * `ctx.env` is the live trigger binding, not the shared build env.
+   */
+  onDemand: boolean;
+
   /**
    * Build-time environment bindings (KV, D1, etc.) supplied by the Vite plugin.
    * Only available when `buildEnv` is configured in rango() options.

package/src/reverse.ts

@@ -47,7 +47,7 @@ export type ParamsFor<TRoutes, TName extends keyof TRoutes> = ExtractParams<
 /**
  * Check if an object type has any keys
  */
-type IsEmptyObject<T> = keyof T extends never ? true : false;
+export type IsEmptyObject<T> = keyof T extends never ? true : false;
 
 /**
  * Extract search schema from a route entry.