@rangojs/router 0.21.0 → 0.22.1

package/dist/types/cache/shell-snapshot.d.ts

@@ -22,7 +22,7 @@
  * a loader whose pin the entry lost runs fresh, and the record's copies of
  * its pushes give way to that run's (restoreHandles).
  */
-import type { SegmentCacheStore, CacheGetResult, CacheItemResult, CacheItemOptions, CachedEntryData, ShellCacheEntry, ShellSnapshotRecord, CacheReadError } from "./types.js";
+import type { SegmentCacheStore, CacheGetResult, CacheItemResult, CacheItemOptions, CachedEntryData, ShellCacheEntry, ShellSnapshotRecord, ShellSnapshotHandlesValue, CacheReadError } from "./types.js";
 /**
  * A store wrapper the CAPTURE render reads through. Every call passes through
  * to the underlying store unchanged; the one thing it records is the doc
@@ -204,6 +204,15 @@ export interface ShellLoaderSeedEntry {
  * touching the Flight codec (kept lazy for cold paths and non-RSC configs).
  */
 export declare function buildShellLoaderSeed(snapshot: ShellSnapshotRecord[]): Promise<Map<string, ShellLoaderSeedEntry> | undefined>;
+/** The key of a snapshot's one `handles` record (ShellSnapshotHandlesValue). */
+export declare const SHELL_HANDLES_RECORD_KEY = "handles";
+/**
+ * The `handles` record of a prerender-served entry, which a HIT tail restores
+ * after the prerender store's handles (cache-lookup.ts yieldFromStore), or
+ * undefined: an entry with a doc record, or one written before the record
+ * existed (v0.21), which serves as it did.
+ */
+export declare function shellPrerenderHandles(snapshot: readonly ShellSnapshotRecord[]): ShellSnapshotHandlesValue | undefined;
 /**
  * The implicit doc scope's store on a HIT tail and on a partial replay: it
  * serves the snapshot's segment records, the doc record among them, and

package/dist/types/cache/store-scope.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The store scope `router.prerender()` gates a warm on
+ * (prerender/create-prerender-trigger.ts). See
+ * docs/design/prerender-every-route.md, "The store declaration".
+ */
+import type { CacheStoreScope, SegmentCacheStore } from "./types.js";
+/**
+ * True under the Vite dev server: only its routes-manifest virtual module sets
+ * the dev origin (vite/discovery/virtual-module-codegen.ts). A build, a preview
+ * server and a test runner answer false.
+ */
+export declare function isViteDevServer(): boolean;
+/**
+ * The scope a warm treats `store` as having: its own declaration, with none
+ * or an unknown value being `"local"`.
+ *
+ * One exception: under the Vite dev server a MemorySegmentCacheStore answers
+ * `"global"`, because that one process serves every request. Production reads
+ * the class's own `scope` (`"local"`): changing that declaration is what
+ * would admit it there.
+ */
+export declare function resolveWarmStoreScope(store: SegmentCacheStore<any>, devServer?: boolean): CacheStoreScope;

package/dist/types/cache/tag-invalidation.d.ts

@@ -37,16 +37,17 @@
  */
 import type { SegmentCacheStore } from "./types.js";
 import { type ExecutionStart } from "./invalidation-order.js";
-export { executionStart, invalidatedSince, type ExecutionStart, } from "./invalidation-order.js";
+export { executionStart, invalidatedSince, markResponseStart, type ExecutionStart, } from "./invalidation-order.js";
 /**
  * The write gate of every cache execution (#977): whether one of `tags` was
  * invalidated after the execution that produced the value started.
  *
- * Every built-in store stamps an entry when it is written (CFCacheStore's
- * `taggedAt`, VercelCacheStore's `ta`) or checks nothing on write
- * (MemorySegmentCacheStore), so a value read before an invalidation and
- * written after it would be served as newer than the invalidation until it
- * expires. Two answers, either one skips the write:
+ * A store stamps an entry with the execution's start (CFCacheStore's
+ * `taggedAt`, VercelCacheStore's `ta`, #1068), but only CFCacheStore with KV
+ * markers rejects it on a later request's read, and MemorySegmentCacheStore
+ * refuses the write. The gate saves the write everywhere and is the only
+ * guard where a read compares nothing. Two answers, either one skips the
+ * write:
  *
  * - this isolate's order (invalidatedSince), which sees every request's
  *   updateTag()/revalidateTag() here, the calling one included;

package/dist/types/cache/types.d.ts

@@ -36,6 +36,17 @@ export interface CacheGetResult {
      */
     shouldRevalidate: boolean;
 }
+/**
+ * Where an entry a store writes during one request can be read by a later
+ * request. `router.prerender()` warms a route only when the app store answers
+ * `"global"` or `"regional"`: a warm fills the store where it runs, which
+ * serves other traffic only when the store is shared beyond that place.
+ * - `"global"`: every location reads the same entries.
+ * - `"regional"`: each region has its own copy; a warm fills the region it
+ *   runs in.
+ * - `"local"`: only the process, isolate or edge location that wrote it.
+ */
+export type CacheStoreScope = "global" | "regional" | "local";
 /**
  * Low-level segment cache store interface.
  *
@@ -53,6 +64,11 @@ export interface CacheGetResult {
  * @typeParam TEnv - Platform bindings type (e.g., Cloudflare env)
  */
 export interface SegmentCacheStore<TEnv = unknown> {
+    /**
+     * Where an entry this store writes can be read ({@link CacheStoreScope}).
+     * Absent: unknown to the router, treated as `"local"`.
+     */
+    readonly scope?: CacheStoreScope;
     /**
      * The store honors getShell(..., { claimRevalidation: false }) without
      * claiming an SWR lock. Navigation replay requires this opt-in because it
@@ -147,6 +163,11 @@ export interface SegmentCacheStore<TEnv = unknown> {
      * @param ttl - Time-to-live in seconds
      * @param swr - Optional stale-while-revalidate window in seconds
      * @param tags - Optional cache tags for invalidation
+     *
+     * The built-in stores read the start of the render from the `Response`
+     * object itself (#1068). A custom store, or a wrapper that rebuilds the
+     * `Response` before delegating, stamps write time. The write gate
+     * (`predatesInvalidation`) runs before this call either way.
      */
     putResponse?(key: string, response: Response, ttl: number, swr?: number, tags?: string[]): Promise<void>;
     /**
@@ -397,9 +418,10 @@ export interface ShellCacheEntry {
      * bake-lane loader pins (pruned to what a HIT reads, issue #941). Replaying
      * them on a HIT keeps the freshly rendered hydration payload equal to the
      * frozen prelude after the underlying cache entries have drifted; every
-     * other read on a HIT, a hole's included, reads the store. Empty when the capture
-     * recorded nothing (a prerender-served capture without bake-lane loaders,
-     * a tombstone). A custom store returns it as putShell received it. See
+     * other read on a HIT, a hole's included, reads the store. A
+     * prerender-served capture holds a `handles` record instead of a doc record
+     * (ShellSnapshotHandlesValue). Empty for a tombstone. A custom store
+     * returns it as putShell received it. See
      * docs/design/ppr-shell-resume.md ("the capture data snapshot").
      */
     snapshot: ShellSnapshotRecord[];
@@ -560,12 +582,22 @@ export interface ShellReadStats {
 }
 /**
  * The families a shell snapshot pins: the doc segment record (recorded by
- * RecordingShellStore) and the settled CONTAINER of each bake-lane loader
- * (lane rule: see resolveLoaderData, loader-cache.ts). No cache read is
- * pinned: a HIT's holes, and a bake-lane loader body that runs on the HIT,
- * read the store.
+ * RecordingShellStore), the settled CONTAINER of each bake-lane loader
+ * (lane rule: see resolveLoaderData, loader-cache.ts), and a prerender-served
+ * entry's `handles` record. No cache read is pinned: a HIT's holes, and a bake-lane
+ * loader body that runs on the HIT, read the store.
  */
-export type ShellSnapshotFamily = "segment" | "loader";
+export type ShellSnapshotFamily = "segment" | "loader" | "handles";
+/**
+ * The stored form of the `handles` family: the handle arrays of a
+ * prerender-served capture that hold a loader-owned push, in the doc record's
+ * format (CachedEntryData `handles` + `handleOwners`). A Prerender + ppr
+ * route's handler layer comes from the prerender store, whose build-time
+ * entry has no loader push, so the entry keeps these for the HIT to restore
+ * as a doc record's (issue #1057, yieldFromStore in cache-lookup.ts). An
+ * entry written before it (v0.21) has none and serves as it did.
+ */
+export type ShellSnapshotHandlesValue = Pick<CachedEntryData, "handles" | "handleOwners">;
 /**
  * The stored form of a loader-family snapshot value: the bake-lane loader's
  * settled container, Flight-serialized AFTER eliding every still-pending nested
@@ -598,17 +630,18 @@ export interface ShellSnapshotLoaderValue {
     runs: 0 | 1;
 }
 /**
- * One snapshot record: the doc segment record or a bake-lane loader pin.
- * `value` carries it in its stored/serialized shape so it round-trips
- * through a JSON-serializing store (KV, CF, Vercel) with the rest of the
- * ShellCacheEntry:
+ * One snapshot record: the doc segment record, a bake-lane loader pin, or a
+ * prerender-served entry's handle record. `value` carries it in its
+ * stored/serialized shape so it round-trips through a JSON-serializing store
+ * (KV, CF, Vercel) with the rest of the ShellCacheEntry:
  * - `segment` -> {@link CachedEntryData} (already JSON-able)
  * - `loader`  -> {@link ShellSnapshotLoaderValue}
+ * - `handles` -> {@link ShellSnapshotHandlesValue}
  */
 export interface ShellSnapshotRecord {
     family: ShellSnapshotFamily;
     key: string;
-    value: CachedEntryData | ShellSnapshotLoaderValue;
+    value: CachedEntryData | ShellSnapshotLoaderValue | ShellSnapshotHandlesValue;
 }
 /**
  * Options for setItem() for function-level caching ("use cache").
@@ -622,6 +655,17 @@ export interface CacheItemOptions {
     swr?: number;
     /** Cache tags for invalidation */
     tags?: string[];
+    /**
+     * Ms since epoch when the execution that produced the value started (#1068).
+     * A store stamps a tagged entry with it instead of its write time. Later
+     * requests then reject an entry an invalidation landed under in
+     * CFCacheStore with KV markers; MemorySegmentCacheStore refuses the write.
+     * Not rejected: VercelCacheStore (a read compares the stamp with the
+     * invalidating request's mask only) and CFCacheStore L1 hits in purge mode
+     * or without KV. Absent or not positive: write time. A custom store may
+     * ignore it.
+     */
+    startedAt?: number;
 }
 /**
  * Serialized segment data stored in cache
@@ -664,7 +708,12 @@ export interface CachedEntryData {
     expiresAt: number;
     /** Cache tags for invalidation */
     tags?: string[];
-    /** Timestamp (ms since epoch) when tags were attached, for distributed invalidation */
+    /**
+     * Timestamp (ms since epoch) the entry's tags are valid as of, for
+     * distributed invalidation. The writer sets it to the start of the render
+     * that produced the record; a store stamps write time when it is absent
+     * (#1068). Which reads reject on it: see `CacheItemOptions.startedAt`.
+     */
     taggedAt?: number;
 }
 /**

package/dist/types/cache/vercel/vercel-cache-store.d.ts

@@ -33,7 +33,7 @@
  * `getCache(...)` result, which satisfies the shape structurally. That keeps the
  * router free of a hard Vercel dependency.
  */
-import type { SegmentCacheStore, CachedEntryData, CacheDefaults, CacheGetResult, CacheItemResult, CacheItemOptions, ShellCacheEntry, ShellDocumentRead, ShellDocumentReadOptions, CacheReadError } from "../types.js";
+import type { CacheStoreScope, SegmentCacheStore, CachedEntryData, CacheDefaults, CacheGetResult, CacheItemResult, CacheItemOptions, ShellCacheEntry, ShellDocumentRead, ShellDocumentReadOptions, CacheReadError } from "../types.js";
 import { type RequestContext } from "../../server/request-context.js";
 import { type StoreMemoOptions } from "../shell-memo.js";
 /**
@@ -227,6 +227,12 @@ export interface VercelCacheStoreOptions<TEnv = unknown> {
  * ```
  */
 export declare class VercelCacheStore<TEnv = unknown> implements SegmentCacheStore<TEnv> {
+    /**
+     * SegmentCacheStore.scope: the Runtime Cache is per region. A
+     * router.prerender() warm fills the region it runs in, which is all traffic
+     * only when the project's functions run in one region.
+     */
+    readonly scope: CacheStoreScope;
     readonly supportsPassiveShellReads: true;
     readonly defaults?: CacheDefaults;
     readonly keyGenerator?: (ctx: RequestContext<TEnv>, defaultKey: string) => string | Promise<string>;

package/dist/types/errors.d.ts

@@ -223,5 +223,11 @@ export declare function invariant(condition: any, message: string): asserts cond
  * @param error - Error to sanitize
  * @returns Response suitable for sending to client
  */
+/**
+ * Vite replaces import.meta.env.DEV at compile time. The fallback covers
+ * non-Vite environments (plain Node, test runners without Vite transforms).
+ * SECURITY: fail closed — default to production when the environment is ambiguous.
+ */
+export declare function isDevEnvironment(): boolean;
 export declare function sanitizeError(error: unknown): Response;
 export {};

package/dist/types/handles/deferred-resolution.d.ts

@@ -51,6 +51,13 @@ export declare function resolveDeferredHandleValues(data: HandleData): Promise<H
  * one holding a masked promise), not this function's.
  */
 export declare function resolvedHandleStream(handleStore: HandleStore, recordedOnly?: boolean): AsyncGenerator<HandleData, void, unknown>;
+/**
+ * `snapshot` without the pushes a record leaves out. A shell capture renders
+ * (resolvedHandleStream) and waits (settleCaptureRecord) on this cut only: a
+ * promise the record drops has no slot in the prelude, and waiting for it
+ * could refuse a capture for a value the shell does not hold.
+ */
+export declare function recordedHandleData(handleStore: HandleStore, snapshot: HandleData): HandleData;
 /**
  * Resolve the deferred (Promise) values in ONE segment's handle bucket
  * (`handleName -> entries[]`). Same shallow + drop-rejections rule as

package/dist/types/internal-suspense-audit.d.ts

@@ -0,0 +1 @@
+export declare const INTERNAL_RANGO_SUSPENSE_AUDIT: boolean;

package/dist/types/loader-store.d.ts

@@ -29,9 +29,10 @@
  *     reclaim a bucket that is about to be reused, and is held until any
  *     in-flight load settles.
  *
- * The store is intentionally module-level: each browser tab is its own JS
- * realm, so there is no cross-request pollution. Server renders never mutate
- * the store — the hook falls back to `OutletContext.loaderData`.
+ * Each router's NavigationStore owns one (navigation-store.ts), and hooks reach
+ * it through NavigationStoreContext: the router store is the single source of
+ * truth. Server renders have no store — the hook falls back to
+ * `OutletContext.loaderData`.
  */
 /** The loader-segment shape announcePendingStreams reads (ResolvedSegment). */
 export interface PendingStreamSource {
@@ -237,9 +238,4 @@ export declare class LoaderStore {
      */
     reset(): void;
 }
-/**
- * Module-level singleton. Each browser tab gets its own; SSR never mutates it.
- * The hook falls through to `OutletContext.loaderData` during the server render.
- */
-export declare const loaderStore: LoaderStore;
 export declare const EMPTY_LOADER_SNAPSHOT: LoaderEntry;

package/dist/types/outlet-provider.d.ts

@@ -1,4 +1,4 @@
-import { type ReactNode } from "react";
+import { type ComponentProps, type ReactNode } from "react";
 import type { ResolvedSegment } from "./types.js";
 /**
  * Outlet content provider — stores parent context for useLoader chain walking.
@@ -13,3 +13,4 @@ export declare function OutletProvider({ content, parallel, segment, loaderData,
     pending?: boolean;
     children: ReactNode;
 }): ReactNode;
+export declare function AuditedOutletProvider({ children, ...props }: ComponentProps<typeof OutletProvider>): ReactNode;

package/dist/types/prerender/cloudflare.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Cloudflare KV writable prerender store (`@rangojs/router/prerender/cloudflare`).
+ *
+ * Backs the durable overlay for on-demand prerender on Cloudflare. Self-contained
+ * (no CFCacheStore construction constraints): entries are stored under the
+ * versioned key `prerender:{routerId}:{version}:{routeName}:{paramHash}`, and
+ * tag invalidation uses the same timestamp-marker technique as the runtime cache
+ * — a per-tag KV marker holding the ms epoch of the last invalidation; a read
+ * treats the entry as stale (never deleted) when any of its tags' markers is at
+ * or after the entry's storedAt.
+ *
+ * Key design constraints (see docs/design/ondemand-prerender.md, Store Model):
+ * - staleAt is SOFT metadata; entries are written with NO KV expirationTtl. Hard
+ *   expiry would delete the entry SWR needs and re-expose older bundled-manifest
+ *   content below the overlay.
+ * - Prerender keys are route + params + variant only — never host-namespaced, so
+ *   a refresh from a different host than the serve request still hits.
+ * - Invalidation is mark-stale, not delete (deleting would re-expose the manifest
+ *   entry as the result of an "invalidation").
+ * - Tag markers use a prerender-specific prefix, separate from the runtime cache's
+ *   `updateTag()`/`revalidateTag()` namespace, and are scoped by router id
+ *   (`{prefix}{encodeURIComponent(routerId)}/{tag}`): routers sharing one KV
+ *   namespace (an app behind a host router) must not mark each other's entries.
+ * - Markers carry no expiry: an entry without a `ttl` never goes stale by
+ *   itself, so an expired marker would silently drop an invalidation.
+ */
+import type { KVNamespace } from "../cache/cf/cf-cache-types.js";
+import { type WritablePrerenderStore } from "./writable-store.js";
+export interface KVPrerenderStoreOptions {
+    /** Injectable clock for `markStale` markers in deterministic tests. Defaults to Date.now. */
+    now?: () => number;
+}
+/**
+ * Create a {@link WritablePrerenderStore} backed by a Cloudflare KV namespace.
+ *
+ * @example
+ * ```ts
+ * import { createKVPrerenderStore } from "@rangojs/router/prerender/cloudflare";
+ *
+ * createRouter<Env>({
+ *   prerender: (env) => ({
+ *     store: createKVPrerenderStore(env.PRERENDER_KV),
+ *     ttl: 3600,
+ *     onRevalidate: (target, e) => e.PRERENDER_QUEUE.send({ target }),
+ *   }),
+ * });
+ * ```
+ */
+export declare function createKVPrerenderStore(kv: KVNamespace, options?: KVPrerenderStoreOptions): WritablePrerenderStore;

package/dist/types/prerender/create-prerender-trigger.d.ts

@@ -0,0 +1,121 @@
+/**
+ * `router.prerender()` trigger factory.
+ *
+ * Builds the `router.prerender` binder: `(runtime) => runner`, the runner being
+ * the per-target callable (plus `.many` / `.remove` / `.markStale`) from router-supplied
+ * deps. Pure and testable: all router internals (reverse, match, the producer,
+ * the request handler) arrive as injected functions, so this module has no RSC
+ * imports and can be unit-tested with fakes.
+ *
+ * One verb, dispatched by route after the match:
+ * - A `Prerender(..., { onDemand })` route takes the requestless render into
+ *   the prerender store (docs/design/ondemand-prerender.md), then, when the
+ *   app cache store is shared and an origin resolves, a warm request that
+ *   rebuilds the runtime caches on top of the new entry.
+ * - Every other route is warmed: a cookie-free GET through the router's own
+ *   handler in which every runtime cache read misses and every write replaces
+ *   the entry (docs/design/prerender-every-route.md).
+ *
+ * Contract highlights:
+ * - Requestless: the producer render never inherits the caller's request state.
+ * - A refresh always renders and replaces; `onlyIfStale` is the cron-sweep
+ *   opt-in and the only path that returns `already-fresh`.
+ * - A failed render/store keeps the previous entry (replace-on-success).
+ * - A `notFound()` in the render is not a failure: it stores a "removed"
+ *   marker in place of the page, stamped with the route's ttl and tags so it
+ *   is rechecked like a page. `prerender.remove()` stores one without
+ *   rendering, which never goes stale. A Passthrough build handler that
+ *   declines (`ctx.passthrough()`) stores one too, so its live handler answers.
+ * - A page and a render's marker (a `notFound()` or a decline) carry the
+ *   render's start as `storedAt`, so a `markStale()` that lands during the
+ *   render marks the result; `staleAt` counts the ttl from the write. A
+ *   `remove()` marker renders nothing and carries its write time.
+ * - An on-demand target is path-only (its key carries no search); a warm
+ *   target keeps its search params, which cache keys carry.
+ * - A warm writes only to a store shared beyond the place the call runs.
+ */
+import type { SerializedSegmentData } from "../cache/types.js";
+import type { HandlerCacheConfig } from "../rsc/types.js";
+import type { ExecutionContext } from "../types/request-scope.js";
+import type { OnDemandRouteConfig, PrerenderConfig, PrerenderFn, PrerenderResult } from "./on-demand.js";
+/** Route metadata the trigger needs, resolved from a pathname by the router. */
+export interface PrerenderMatchInfo {
+    routeName: string;
+    params: Record<string, string>;
+    /** True when the route opted into on-demand (Prerender(..., { onDemand })). */
+    isOnDemand: boolean;
+    /** True when the route is wrapped in Passthrough(). */
+    isPassthrough: boolean;
+}
+/**
+ * Raw producer output (matchForPrerender's main-variant shape). `onDemandConfig`
+ * is the route's `onDemand: { ttl, tags }` object (the `tags` callback can't
+ * ride the serialized trie), read from the loaded route entry during production.
+ */
+export interface ProducerOutput {
+    segments: SerializedSegmentData[];
+    handles: string;
+    routeName: string;
+    params: Record<string, string>;
+    passthrough?: true;
+    /** The render hit `notFound()` and nothing else failed: no page to store. */
+    notFound?: true;
+    onDemandConfig?: OnDemandRouteConfig;
+}
+export interface PrerenderTriggerDeps<TEnv = any> {
+    routerId: string;
+    /**
+     * The key version: the router's data version (resolvePrerenderVersion),
+     * resolved per refresh (once per `.many()` batch), as the request handler
+     * resolves it per request.
+     */
+    resolveVersion: () => string;
+    /** True when running under Vite dev (drives the producer context's `dev`). */
+    isDev: () => boolean;
+    /**
+     * True under the Vite dev server (isViteDevServer): the one place the
+     * memory store counts as shared, and so where the not-shared warning fires.
+     */
+    isViteDevServer: () => boolean;
+    /** Load the per-router manifest/trie before matching, as router.fetch does. */
+    ensureManifest: () => Promise<void>;
+    /** Resolve the env-scoped prerender config (factory or object); undefined when unconfigured. */
+    resolveConfig: (env: TEnv, ctx: ExecutionContext | undefined) => PrerenderConfig<TEnv> | undefined;
+    /** Reverse an object target to a pathname; undefined when the route name is unknown. */
+    reverse: (route: string, params: Record<string, string>) => string | undefined;
+    /** Match a pathname to route metadata; null when nothing matches. */
+    matchRoute: (pathname: string) => PrerenderMatchInfo | null | Promise<PrerenderMatchInfo | null>;
+    /** Run the requestless producer (matchForPrerender with onDemand). May throw. */
+    runProducer: (input: {
+        pathname: string;
+        isPassthrough: boolean;
+        env: TEnv;
+        dev: boolean;
+    }) => Promise<ProducerOutput | null>;
+    /**
+     * Resolve `createRouter({ cache })` (factory or object) for a warm;
+     * undefined when the router has none. May throw, like the prerender factory.
+     */
+    resolveCacheConfig: (env: TEnv, ctx: ExecutionContext) => HandlerCacheConfig | undefined;
+    /** The router's own request handler (`router.fetch`): where a warm is dispatched. */
+    fetch: (request: Request, input: {
+        env: TEnv;
+        ctx: ExecutionContext;
+    }) => Promise<Response>;
+    /** The origin of the request the runner is called from, when there is one. */
+    ambientOrigin: () => string | undefined;
+}
+/** Thrown by the trigger when `throwOnError: true` and the operation did not succeed. */
+export declare class PrerenderError extends Error {
+    readonly result: Extract<PrerenderResult, {
+        ok: false;
+    }>;
+    /** `operation` is the runner call that failed; the message names it. */
+    constructor(result: Extract<PrerenderResult, {
+        ok: false;
+    }>, operation?: "prerender" | "remove");
+}
+/**
+ * Create the `router.prerender` callable. See {@link PrerenderTriggerDeps}.
+ */
+export declare function createPrerenderTrigger<TEnv = any, TRoutes = {}>(deps: PrerenderTriggerDeps<TEnv>): PrerenderFn<TEnv, TRoutes>;

package/dist/types/prerender/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Public on-demand prerender surface (`@rangojs/router/prerender`).
+ *
+ * Store contracts, config/result/target types, and the in-memory store (usable
+ * as a durable overlay in single-process node/Vercel functions, and as a test
+ * fake). The Cloudflare KV adapter lives in `@rangojs/router/prerender/cloudflare`.
+ */
+export { PrerenderError } from "./create-prerender-trigger.js";
+export { createMemoryPrerenderStore, type MemoryPrerenderStore, type MemoryPrerenderStoreOptions, } from "./memory-prerender-store.js";
+export { serializePrerenderKey, type PrerenderKey, type PrerenderStoredEntry, type WritablePrerenderStore, } from "./writable-store.js";
+export type { OnDemandOption, OnDemandRouteConfig, PrerenderConfig, PrerenderFn, PrerenderResult, PrerenderWarmCaches, PrerenderManyOptions, PrerenderRunner, PrerenderRunOptions, PrerenderRuntime, PrerenderTarget, PrerenderTargetObject, } from "./on-demand.js";
+export type { PrerenderEntry } from "./store.js";

package/dist/types/prerender/memory-prerender-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * In-memory writable prerender store.
+ *
+ * Backs the zero-config dev overlay and the `@rangojs/router/testing` fake.
+ * A plain Map — no per-isolate null memoization (a later set() must be visible
+ * after an earlier miss), no React/RSC deps.
+ */
+import { type PrerenderKey, type PrerenderStoredEntry, type WritablePrerenderStore } from "./writable-store.js";
+export interface MemoryPrerenderStore extends WritablePrerenderStore {
+    delete(key: PrerenderKey): Promise<void>;
+    markStale(routerId: string, tags: string[]): Promise<void>;
+    /** Synchronous read by structured key (tests). */
+    peek(key: PrerenderKey): PrerenderStoredEntry | null;
+    /** All stored [serializedKey, entry] pairs (tests). */
+    entries(): [string, PrerenderStoredEntry][];
+    /** Drop every entry. */
+    clear(): void;
+    readonly size: number;
+}
+export interface MemoryPrerenderStoreOptions {
+    /** Injectable clock for `markStale` in deterministic tests. Defaults to Date.now. */
+    now?: () => number;
+}
+/**
+ * Create an in-memory {@link WritablePrerenderStore} with test-inspection
+ * helpers. Invalidation is mark-stale (sets `staleAt`), never delete — matching
+ * the durable v1 contract so the entry keeps serving until refreshed.
+ */
+export declare function createMemoryPrerenderStore(options?: MemoryPrerenderStoreOptions): MemoryPrerenderStore;