@rangojs/router 0.23.0 → 0.24.0

package/dist/types/rsc/handler.d.ts

@@ -6,4 +6,37 @@
  */
 import type { CreateRSCHandlerOptions } from "./types.js";
 import type { RouterRequestInput } from "../router/router-interfaces.js";
+/**
+ * Create an RSC request handler.
+ *
+ * **Recommended:** Use `router.createHandler()` instead for simpler setup:
+ * ```tsx
+ * const router = createRouter({ document, urls, nonce: () => true });
+ * export const fetch = router.createHandler();
+ * ```
+ *
+ * This function is still useful for advanced cases like per-request cache
+ * configuration (e.g., Cloudflare Workers with ExecutionContext).
+ *
+ * @example Basic usage (deps and loadSSRModule have sensible defaults)
+ * ```tsx
+ * import { createRSCHandler } from "@rangojs/router/rsc";
+ * import { router } from "./router.js";
+ *
+ * export default createRSCHandler({ router });
+ * ```
+ *
+ * @example With custom deps (advanced)
+ * ```tsx
+ * import { createRSCHandler } from "@rangojs/router/rsc";
+ * import * as rsc from "@vitejs/plugin-rsc/rsc/server";
+ * import { router } from "./router.js";
+ *
+ * export default createRSCHandler({
+ *   router,
+ *   deps: rsc,
+ *   loadSSRModule: () => import.meta.viteRsc.loadModule("ssr", "index"),
+ * });
+ * ```
+ */
 export declare function createRSCHandler<TEnv = unknown, TRoutes extends Record<string, string> = Record<string, string>>(options: CreateRSCHandlerOptions<TEnv, TRoutes>): (incomingRequest: Request, input?: RouterRequestInput<TEnv>) => Promise<Response>;

package/dist/types/rsc/helpers.d.ts

@@ -31,6 +31,14 @@ export declare function hasBodyContent(body: FormData | string): boolean;
  * Also triggers any registered onResponse callbacks.
  */
 export declare function createResponseWithMergedHeaders(body: BodyInit | null, init: ResponseInit): Response;
+/**
+ * An empty 200 carrying X-RSC-Reload: the client turns it into a document
+ * navigation (window.location.href). It points at the visitor's URL: the
+ * first URL of a rewritten request (server/rewrite-trail.ts visitorUrl),
+ * else `url` with the internal `_rsc*` params stripped, or `url` as given
+ * when it is a string the caller resolved (an action's referer).
+ */
+export declare function createReloadResponse(reqCtx: RequestContext<any> | undefined, url: URL | string): Response;
 /**
  * Rebuild a Response returned or thrown by a response-route handler so request
  * effects merge consistently in production and the public dispatch primitive.

package/dist/types/rsc/loader-fetch.d.ts

@@ -11,4 +11,20 @@
  * has already extracted params from it.
  */
 import type { HandlerContext } from "./handler-context.js";
+export interface LoaderErrorMeta<TEnv> {
+    request: Request;
+    url: URL;
+    env: TEnv;
+    loaderId: string;
+}
+/**
+ * A text/x-component Response carrying `{ loaderResult: null, loaderError }`,
+ * the payload `load()` turns into a rejection with `loaderError.message`. A
+ * plain-text body would reject with React's opaque "Connection closed.".
+ * Render failures report through onError("rendering").
+ */
+export declare function renderLoaderError<TEnv>(ctx: HandlerContext<TEnv>, loaderError: {
+    message: string;
+    name: string;
+}, status: number, meta: LoaderErrorMeta<TEnv>): Response;
 export declare function handleLoaderFetch<TEnv>(ctx: HandlerContext<TEnv>, request: Request, env: TEnv, url: URL, variables: Record<string, any>, routeParams?: Record<string, string>): Promise<Response>;

package/dist/types/rsc/rewrite-passes.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The pass loop that honors `throw rewrite()` (route-definition/rewrite.ts):
+ * one catch around the global middleware chain moves the same request
+ * context to the target (server/request-context.ts rebaseRequestContext) and
+ * runs the request again from the top, as a direct visit to the target
+ * would run it. Shared by the request handler (rsc/handler.ts) and the
+ * dispatch testing primitive, so the two cannot drift.
+ */
+import { type Rewrite } from "../route-definition/rewrite.js";
+import { type RequestContext } from "../server/request-context.js";
+/** Response header naming the route path a rewritten request rendered. */
+export declare const REWRITE_HEADER = "x-rango-rewrite";
+/**
+ * Resolve a rewrite's target against the router's route map (global names,
+ * no param auto-fill, as middleware `ctx.reverse`) and the request origin.
+ * A path is basename-prefixed like `redirect()` and must stay under the
+ * basename once normalized (`/../admin` cannot step out of it). The
+ * target's own `_rsc*` params are dropped: only the visitor's transport
+ * params carry over. Throws for an unknown name, a missing param, another
+ * origin or a path outside the basename.
+ */
+export declare function resolveRewriteTarget(rewrite: Rewrite, routeMap: Record<string, string>, base: URL, basename?: string): URL;
+/** The next pass of a rewritten request. */
+export interface RewritePass {
+    request: Request;
+    /** The pass's raw URL, `_rsc*` params included. */
+    url: URL;
+    /** The target's clean URL. */
+    target: URL;
+    hops: number;
+}
+/**
+ * Move the request context to `rewrite`'s target for the next pass: check
+ * that this request can be rewritten, resolve the target, count the hop,
+ * then rebase the context. Throws the site error for a mutation or a loader
+ * fetch, a resolution error, and RewriteLoopError.
+ */
+export declare function applyRewrite(rewrite: Rewrite, passRequest: Request, reqCtx: RequestContext<any>, routeMap: Record<string, string>, basename: string | undefined): RewritePass;
+/** The response to a rewrite loop. */
+export declare function loopDetectedResponse(): Response;
+export interface RewritePassesOptions {
+    reqCtx: RequestContext<any>;
+    /** The visitor's request and raw URL: the first pass. */
+    request: Request;
+    url: URL;
+    routeMap: () => Record<string, string>;
+    basename: string | undefined;
+    /** One pass: the global chain matched on `url`'s path around the core handler. */
+    runPass: (request: Request, url: URL) => Promise<Response>;
+    /** After a hop moved the context to its target. */
+    onHop?: (pass: RewritePass) => void;
+    /** Report a rewrite the request cannot take (onError, phase "routing"). */
+    report: (error: unknown, at: {
+        request: Request;
+        url: URL;
+    }) => void;
+    /**
+     * The response for a refused rewrite other than a loop (a loader fetch's
+     * error response); undefined rethrows the error.
+     */
+    refuse?: (error: unknown, rewrite: Rewrite) => Response | undefined;
+}
+export interface RewritePassesResult {
+    response: Response;
+    /** The pathname the final pass rendered, when a rewrite took the request there. */
+    rewrittenTo?: string;
+}
+/**
+ * Run the request pass by pass until one produces a response. A `Rewrite`
+ * that unwinds a pass moves the context to its target and runs the next;
+ * a loop answers 508; a rewrite the request cannot take is reported and
+ * becomes `refuse`'s response, or is thrown.
+ */
+export declare function runRewritePasses(opts: RewritePassesOptions): Promise<RewritePassesResult>;

package/dist/types/rsc/ssr-setup.d.ts

@@ -23,8 +23,10 @@ export declare const SSR_SETUP_VAR = "__ssrSetup";
  * lazily so stores created after kickoff are still captured). Without a
  * getter the promises run bare — no `.then()` microtasks, no
  * `performance.now()` calls — keeping the non-debug hot path lean.
+ * `ssrModule` reuses a load already started (a rewritten request's earlier
+ * pass).
  */
-export declare function startSSRSetup<TEnv>(ctx: HandlerContext<TEnv>, request: Request, env: TEnv, url: URL, getMetricsStore?: () => MetricsStore | undefined): Promise<SSRSetup>;
+export declare function startSSRSetup<TEnv>(ctx: HandlerContext<TEnv>, request: Request, env: TEnv, url: URL, getMetricsStore?: () => MetricsStore | undefined, ssrModule?: Promise<SSRModule>): Promise<SSRSetup>;
 export interface SsrHtmlStageOptions<TEnv> {
     ctx: HandlerContext<TEnv>;
     request: Request;

package/dist/types/server/request-context.d.ts

@@ -600,6 +600,13 @@ export interface RequestContext<TEnv = DefaultEnv, TParams = Record<string, stri
      * (segment-resolution/prefetch-deferral.ts requestKind).
      */
     _requestKind?: "prefetch" | "fill";
+    /**
+     * @internal Set when a render shows the visitor's URL of a rewritten
+     * request: the payload or SSR seed (renderedLocation, rsc/full-payload.ts)
+     * or a `ctx.rewrittenFrom` read (server/rewrite-trail.ts). The document
+     * cache does not store that response: it is keyed by the target.
+     */
+    _payloadVisitorLocation?: boolean;
     /**
      * Attach location state entries to the current response.
      *
@@ -816,7 +823,7 @@ export interface RouteRecordWindow {
  * This is the type exported to library consumers. Internal code should
  * use the full RequestContext interface directly.
  */
-export type PublicRequestContext<TEnv = DefaultEnv, TParams = Record<string, string>> = Omit<RequestContext<TEnv, TParams>, "cookie" | "cookies" | "_readCookie" | "_readCookies" | "setCookie" | "deleteCookie" | "_handleStore" | "_transitionWhenRefs" | "_pprReplayPostMatchReason" | "_cacheStore" | "_prerender" | "_onDemandProducer" | "_searchParamsFilter" | "_shellCaptureRun" | "_shellImplicitCache" | "_shellLoaderSeed" | "_shellCaptureLoaderRecords" | "_shellCaptureUnrecordedLoaderPush" | "_shellCaptureLoaderLanes" | "_resolvedCacheKeys" | "_shellKey" | "_shellForcedMiss" | "_prerenderWarm" | "_runAtRequestEntry" | "_routeRecordWindow" | "_shellFragmentPayload" | "_shellCaptureGuardTripped" | "_shellCaptureGuardTrippedLoaderId" | "_explicitTaggedStores" | "_requestTags" | "_recordTagOwners" | "_recordLoaderTags" | "_cacheProfiles" | "_onResponseCallbacks" | "_pendingBackgroundTasks" | "_themeConfig" | "_readTheme" | "_documentCacheRender" | "_payloadVisitorTheme" | "_payloadDeferred" | "_requestKind" | "_locationState" | "_routeName" | "_prevRouteKey" | "_inActionRevalidation" | "_reportedErrors" | "_renderErrors" | "_recoveredHandlerErrors" | "_renderBarrier" | "_resolveRenderBarrier" | "_renderBarrierSegmentOrder" | "_treeHasStreaming" | "_renderBarrierWaiters" | "_handlerLoaderDeps" | "_awaitBeforeFlushLoaderIds" | "_renderBarrierHandleSnapshot" | "_renderBarrierGuardClosed" | "_reportBackgroundError" | "_debugPerformance" | "_metricsStore" | "_renderForeground" | "_activeRoutine" | "_renderDiagnosticsEnabled" | "_handlerStart" | "_tracing" | "_basename" | "_routerId" | "_versions" | "_setStatus" | "_rotateStateCookie" | "_setKeepCacheDirective" | "_freshReads" | "_setFreshReadsCookie" | "_requestRoot" | "_requestStart" | "_responseSent" | "_variables" | "_classifiedRoute" | "_requestMode" | "_cacheSignal" | "_dynamic" | "res">;
+export type PublicRequestContext<TEnv = DefaultEnv, TParams = Record<string, string>> = Omit<RequestContext<TEnv, TParams>, "cookie" | "cookies" | "_readCookie" | "_readCookies" | "setCookie" | "deleteCookie" | "_handleStore" | "_transitionWhenRefs" | "_pprReplayPostMatchReason" | "_cacheStore" | "_prerender" | "_onDemandProducer" | "_searchParamsFilter" | "_shellCaptureRun" | "_shellImplicitCache" | "_shellLoaderSeed" | "_shellCaptureLoaderRecords" | "_shellCaptureUnrecordedLoaderPush" | "_shellCaptureLoaderLanes" | "_resolvedCacheKeys" | "_shellKey" | "_shellForcedMiss" | "_prerenderWarm" | "_runAtRequestEntry" | "_routeRecordWindow" | "_shellFragmentPayload" | "_shellCaptureGuardTripped" | "_shellCaptureGuardTrippedLoaderId" | "_explicitTaggedStores" | "_requestTags" | "_recordTagOwners" | "_recordLoaderTags" | "_cacheProfiles" | "_onResponseCallbacks" | "_pendingBackgroundTasks" | "_themeConfig" | "_readTheme" | "_documentCacheRender" | "_payloadVisitorTheme" | "_payloadDeferred" | "_requestKind" | "_payloadVisitorLocation" | "_locationState" | "_routeName" | "_prevRouteKey" | "_inActionRevalidation" | "_reportedErrors" | "_renderErrors" | "_recoveredHandlerErrors" | "_renderBarrier" | "_resolveRenderBarrier" | "_renderBarrierSegmentOrder" | "_treeHasStreaming" | "_renderBarrierWaiters" | "_handlerLoaderDeps" | "_awaitBeforeFlushLoaderIds" | "_renderBarrierHandleSnapshot" | "_renderBarrierGuardClosed" | "_reportBackgroundError" | "_debugPerformance" | "_metricsStore" | "_renderForeground" | "_activeRoutine" | "_renderDiagnosticsEnabled" | "_handlerStart" | "_tracing" | "_basename" | "_routerId" | "_versions" | "_setStatus" | "_rotateStateCookie" | "_setKeepCacheDirective" | "_freshReads" | "_setFreshReadsCookie" | "_requestRoot" | "_requestStart" | "_responseSent" | "_variables" | "_classifiedRoute" | "_requestMode" | "_cacheSignal" | "_dynamic" | "res">;
 /**
  * Marker for a waitUntil-scheduled fn whose task promise must NOT enter
  * _pendingBackgroundTasks. Used by the PPR shell capture for its own task:
@@ -825,6 +832,13 @@ export type PublicRequestContext<TEnv = DefaultEnv, TParams = Record<string, str
  * @internal
  */
 export declare const UNTRACKED_BACKGROUND_TASK: unique symbol;
+/**
+ * Define `ctx.res` as an own accessor that reads `get`. Assigning it throws
+ * the read-only error. A context derived from another (Object.create) gets
+ * its own response this way; copying the descriptor would read the
+ * prototype's slot.
+ */
+export declare function bindRes(ctx: RequestContext<any, any>, get: () => Response): void;
 /**
  * Capture the current async context (RequestContext._runAtRequestEntry), taken
  * on handler entry before any router scope, so a nested dispatch (a
@@ -924,6 +938,26 @@ export interface CreateRequestContextOptions<TEnv> {
  * - Passed to handlers as ctx
  */
 export declare function createRequestContext<TEnv>(options: CreateRequestContextOptions<TEnv>): RequestContext<TEnv>;
+/**
+ * Move a request context to a rewrite target for the next pass of the
+ * request (rsc/rewrite-passes.ts, `throw rewrite()`). The context object
+ * stays the same, so what the visitor's pass set is still there: variables
+ * (the rewrite trail among them), the response stub (status, headers,
+ * cookies), location state, theme, `dynamic()`, metrics, request tags,
+ * onResponse callbacks, the handle store.
+ *
+ * Moved to the target: the request (`rawUrl`, the visitor's `_rsc*` params
+ * included), url, originalUrl, pathname, searchParams and the request kind.
+ * Cleared for the target's match: params, route name, reverse, the
+ * classified route, the request mode, and the document cache's render mark
+ * (its middleware runs again for the target). The loader memo behind
+ * `getRequestContext().use()` is new: a loader that middleware started in
+ * the visitor's pass read the visitor's URL. A pass never renders before it
+ * rewrites: router/middleware.ts refuses a rewrite thrown after a next()
+ * unless that next() rejected with a Rewrite (a downstream middleware
+ * rewrote before its own next()), so there is no render state to reset.
+ */
+export declare function rebaseRequestContext(ctx: RequestContext<any>, request: Request, rawUrl: URL): void;
 /**
  * Wire a fresh render barrier onto `ctx`, closure-bound to THIS ctx and THIS
  * handle store. Called by createRequestContext for every fresh context, and by
@@ -940,8 +974,11 @@ export declare function createRequestContext<TEnv>(options: CreateRequestContext
  * read the foreground's handle snapshot; the capture's fresh `_handleStore`
  * was invisible, so foreground per-request handle data could bake into the
  * shared shell.
+ *
+ * A derived context's `_renderBarrier` is non-enumerable (the default
+ * descriptor); a fresh context's is enumerable like its other fields.
  */
-export declare function wireRenderBarrier(ctx: RequestContext<any, any>, handleStore: HandleStore): void;
+export declare function wireRenderBarrier(ctx: RequestContext<any, any>, handleStore: HandleStore, descriptor?: PropertyDescriptor): void;
 export { parseCookiesFromHeader };
 export declare function serializeCookieValue(name: string, value: string, options?: CookieOptions): string;
 /**

package/dist/types/server/rewrite-trail.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The URLs a rewritten request moved through (`throw rewrite()`), and what
+ * each context sees of them.
+ *
+ * One source: the trail lives in the request's variables under a token no
+ * user code can reach, so a middleware cannot reset the loop count. The
+ * visitor's URL is its first entry (`ctx.rewrittenFrom`); the hops are its
+ * length minus one.
+ */
+import type { RequestContext } from "./request-context.js";
+/** Most rewrites one request may take; the next one is a RewriteLoopError. */
+export declare const MAX_REWRITE_HOPS = 5;
+type TrailContext = Pick<RequestContext<any>, "_variables">;
+/** The trail of a rewritten request; undefined when nothing rewrote. */
+export declare function rewriteTrail(reqCtx: TrailContext | undefined): readonly string[] | undefined;
+/**
+ * Count one hop from `from` to `to` (clean URLs) and return its number.
+ * Throws RewriteLoopError past {@link MAX_REWRITE_HOPS}, or when `to` is the
+ * URL the request is on (pathname and search).
+ */
+export declare function recordRewriteHop(reqCtx: TrailContext, from: URL, to: URL): number;
+type AudienceContext = Pick<RequestContext<any>, "_shellCaptureRun" | "_documentCacheRender" | "res">;
+/**
+ * A render other visitors may be served: a PPR shell capture, or a render
+ * the document cache stores (its response opted in before next()). It shows
+ * what a direct visit to its URL shows: no visitor theme, no visitor URL.
+ */
+export declare function rendersForSharedAudience(reqCtx: AudienceContext): boolean;
+/**
+ * The URL the visitor is on: the first URL of a rewritten request, else
+ * `url` with the internal `_rsc*` params stripped. A reload the router asks
+ * the browser for points here.
+ */
+export declare function visitorUrl(reqCtx: TrailContext | undefined, url: URL): URL;
+/**
+ * Who reads `rewrittenFrom`: "render" for the contexts a render reads
+ * (handler, loader, response route, getRequestContext()), "middleware" for a
+ * middleware ctx, which runs once per request and is never stored.
+ */
+export type RewrittenFromReader = "render" | "middleware";
+/**
+ * Define `ctx.rewrittenFrom` on a handler, loader, response-route or
+ * middleware ctx, read through `source` (the request context it belongs
+ * to). Each ctx gets its own copy of the URL.
+ */
+export declare function defineRewrittenFrom(ctx: object, source: RequestContext<any> | undefined, reader?: RewrittenFromReader): void;
+/** Define `rewrittenFrom` on a request context, read through itself. */
+export declare function defineRequestRewrittenFrom(ctx: RequestContext<any>): void;
+export {};

package/dist/types/server/slot-accessors.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Property definitions for per-request objects that keep V8 fast properties
+ * (#1109): the request context, the middleware ctx, the handle store and a
+ * guarded request.
+ *
+ * V8 puts an object in dictionary mode, where every property read is a hash
+ * lookup for the object's whole lifetime, when an object literal declares a
+ * get/set member, when a data property is redefined as an accessor after
+ * creation, or when an accessor is defined with a function its shape
+ * transition has not recorded: a closure created per request is a new
+ * function every time. So an accessor on a per-request object is a
+ * module-level descriptor, and one that needs per-object state reads a
+ * per-object closure from a non-enumerable symbol slot (slotAccessor +
+ * defineSlot). A derived object (Object.create(obj)) reads the slot through
+ * its prototype; the descriptor copied onto another object reads that
+ * object's slot instead. context-fast-properties.test.ts pins all of it.
+ *
+ * Dependency-free leaf: handle-store.ts is imported by request-context.ts,
+ * so these cannot live in either.
+ */
+/**
+ * An accessor descriptor whose getter calls the receiver's `slot` closure.
+ * Call it once at module level and share the result.
+ */
+export declare function slotAccessor(slot: symbol, enumerable: boolean): PropertyDescriptor;
+/** Define `slot` on `target` as a non-enumerable, read-only data property. */
+export declare function defineSlot(target: object, slot: symbol, value: unknown): void;
+/** Define `key` on `target` as a non-enumerable, writable data property. */
+export declare function defineHidden(target: object, key: PropertyKey, value: unknown): void;

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

@@ -34,7 +34,7 @@
  * - RSC:         see @rangojs/router/testing/flight
  */
 export { runMiddleware } from "./run-middleware.js";
-export type { RunMiddlewareOptions, RunMiddlewareResult, } from "./run-middleware.js";
+export type { RunMiddlewareOptions, RunMiddlewareResult, RunMiddlewareRewrite, } from "./run-middleware.js";
 export { runLoader, runLoaderResult } from "./run-loader.js";
 export type { RunLoaderOptions, RunLoaderResult, UseResolver, TestLoaderContext, } from "./run-loader.js";
 export { runTransitionWhen } from "./run-transition-when.js";

package/dist/types/testing/render-route.d.ts

@@ -300,6 +300,14 @@ export interface RenderRouteOptions {
      * - Needs @testing-library/react >= 16.2.0; throws on older versions.
      */
     hydrate?: boolean;
+    /**
+     * The path middleware rewrote `request` to (`throw rewrite()`): the leaf
+     * route is matched against it for params, while the location stays
+     * `request`, as on a rewritten document. The server pass and hydration
+     * both see `request` (`usePathname()`, `useSearchParams()`), as production
+     * renders a rewritten page with the visitor's URL (`/middleware` skill).
+     */
+    rewrite?: string;
 }
 /**
  * Imperative handle returned alongside the RTL result.

package/dist/types/testing/run-middleware.d.ts

@@ -13,6 +13,10 @@
  *
  * `nextCalled` counts how many times the terminal `next()` (the finalHandler)
  * ran: 0 when the chain short-circuited, 1 when it ran to completion.
+ *
+ * A `throw rewrite(target)` is reported as `result.rewrite` (the resolved
+ * target) instead of failing the run: production re-dispatches the request
+ * there, which this primitive does not do.
  */
 import { type RequestContext } from "../server/request-context.js";
 import type { MiddlewareFn } from "../router/middleware-types.js";
@@ -79,6 +83,12 @@ export interface RunMiddlewareOptions<TEnv = any> {
      */
     stateCookie?: StateCookieSeed;
 }
+/** A rewrite the chain threw (RunMiddlewareResult.rewrite). */
+export interface RunMiddlewareRewrite {
+    pathname: string;
+    search: string;
+    routeName?: string;
+}
 /**
  * Result of runMiddleware.
  */
@@ -94,6 +104,16 @@ export interface RunMiddlewareResult<TEnv = any> {
     ctx: RequestContext<TEnv>;
     /** Number of times the terminal handler ran (0 = short-circuited, 1 = passed through). */
     nextCalled: number;
+    /**
+     * The target of a `throw rewrite(...)` from the chain, resolved as
+     * production resolves it (a path basename-prefixed, a route name through
+     * `routeMap`): `pathname` and `search` of the URL the request would render,
+     * and `routeName` when the rewrite named a route. `undefined` when the chain
+     * did not rewrite. On a rewrite, `response` carries what the chain set
+     * before the throw (status, headers, cookies), which production keeps for
+     * the target's response.
+     */
+    rewrite?: RunMiddlewareRewrite;
     /**
      * Whether the chain called `ctx.dynamic()` (the PPR shell opt-out). The public
      * way to assert the opt-out without reading the `@internal` `ctx._dynamic`.

package/dist/types/testing/serve-shell-request.d.ts

@@ -29,7 +29,8 @@
  *
  * A `Prerender` route serves its handler layer from the artifact
  * `router.matchForPrerender` bakes for the URL (on its first request, kept
- * until resetShellTestState), through the production prerender store. Its
+ * until resetShellTestState), through the production prerender store; an
+ * intercept of it serves from the intercept variant the bake keeps. Its
  * first `ppr` request is a MISS with a runtime capture, as a URL without a
  * build-time shell is in production; build-time shells are e2e-only. An
  * on-demand route (`Prerender(..., { onDemand })`) bakes nothing here: it

package/dist/types/thenable-status.d.ts

@@ -13,3 +13,9 @@ export declare function unwrapsSynchronously(stream: Promise<unknown>): boolean;
  * listing a 0 ms promise on every reader that calls it.
  */
 export declare const SETTLED_THENABLE: Promise<undefined>;
+/**
+ * The value React reads from `value` without suspending: `value` itself when
+ * it is not a promise, a promise's `value` once it carries React's or Flight's
+ * `status: "fulfilled"`. Undefined while it is pending or rejected.
+ */
+export declare function settledValue<T>(value: T | Promise<T>): T | undefined;

package/dist/types/types/request-scope.d.ts

@@ -48,6 +48,13 @@ export interface RequestScope<TEnv = DefaultEnv> {
      * cache keying.
      */
     originalUrl: URL;
+    /**
+     * The visitor's URL (the address bar, search included) when middleware
+     * rewrote this request with `throw rewrite()`; `undefined` otherwise. `url`,
+     * `pathname` and `searchParams` are the rewrite target's. After several
+     * rewrites this is still the first URL. Each context gets its own copy.
+     */
+    rewrittenFrom?: URL;
     /** URL pathname (same as `url.pathname`). */
     pathname: string;
     /**

package/dist/types/vite/discovery/state.d.ts

@@ -188,21 +188,24 @@ export interface DiscoveryState {
     /** Cleanup function for build-time env resources (e.g., miniflare). */
     buildEnvDispose?: (() => Promise<void> | void) | null;
     /**
-     * Set when the most recent discovery threw: an HMR re-discovery, or the
-     * cold dev discovery on a main RSC runner. Cleared on the next successful
-     * discovery. While set, the route-file watcher treats any in-scan source
-     * change as a rediscovery trigger (recovery mode).
+     * Set when the most recent dev discovery failed: an HMR re-discovery, or the
+     * cold discovery on the Node RSC runner or the Cloudflare temp runner.
+     * Cleared on the next successful discovery. While set, the route-file
+     * watcher treats any in-scan source change as a rediscovery trigger
+     * (recovery mode).
      */
     lastDiscoveryError?: {
         message: string;
         at: number;
     } | null;
 }
+/** Record a failed dev discovery (lastDiscoveryError): recovery mode. */
+export declare function recordDiscoveryFailure(state: Pick<DiscoveryState, "lastDiscoveryError">, err: unknown): void;
 /**
- * Whether the route-file watcher can re-run runtime discovery. A committed
- * manifest is the usual precondition. A failed cold discovery commits none,
- * so on a main RSC runner its recorded failure qualifies too; without that
- * the dev server stayed broken until a restart.
+ * Whether the route-file watcher can re-run runtime discovery: a committed
+ * manifest, or a recorded failure. A failed cold discovery commits none, and
+ * without its recorded failure the dev server stayed broken until a restart,
+ * on the Node runner and on Cloudflare alike.
  */
-export declare function canRefreshRuntimeDiscovery(state: Pick<DiscoveryState, "perRouterManifests" | "lastDiscoveryError">, hasMainRunner: boolean): boolean;
+export declare function canRefreshRuntimeDiscovery(state: Pick<DiscoveryState, "perRouterManifests" | "lastDiscoveryError">): boolean;
 export declare function createDiscoveryState(entryPath: string | undefined, opts: PluginOptions | undefined): DiscoveryState & ClientUrlDiscoveryState;