@rangojs/router 0.27.0 → 0.28.0

package/dist/types/router/segment-wrappers.d.ts

@@ -1,51 +1,14 @@
-import type { EntryData, InterceptEntry } from "../server/context";
-import type { HandlerContext, ResolvedSegment, ShouldRevalidateFn } from "../types";
 import type { SegmentResolutionDeps } from "./types.js";
-import type { ResolveSegmentOptions } from "./segment-resolution.js";
-import type { RevalidationContext } from "./router-context.js";
-import type { InterceptSelectorContext } from "../server/context";
-export interface SegmentWrappers<TEnv = any> {
-    resolveAllSegments: (entries: EntryData[], routeKey: string, params: Record<string, string>, context: HandlerContext<any, TEnv>, loaderPromises: Map<string, Promise<any>>, options?: ResolveSegmentOptions) => Promise<ResolvedSegment[]>;
-    resolveLoadersOnly: (entries: EntryData[], context: HandlerContext<any, TEnv>) => Promise<ResolvedSegment[]>;
-    resolveLoadersOnlyWithRevalidation: (entries: EntryData[], context: HandlerContext<any, TEnv>, clientSegmentIds: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, routeKey: string, actionContext?: {
-        actionId?: string;
-        actionUrl?: URL;
-        actionResult?: any;
-        formData?: FormData;
-    }, stale?: boolean) => Promise<{
-        segments: ResolvedSegment[];
-        matchedIds: string[];
-    }>;
-    buildEntryRevalidateMap: (entries: EntryData[]) => Map<string, {
-        entry: EntryData;
-        revalidate: ShouldRevalidateFn<any, any>[];
-    }>;
-    resolveAllSegmentsWithRevalidation: (entries: EntryData[], routeKey: string, params: Record<string, string>, context: HandlerContext<any, TEnv>, clientSegmentSet: Set<string>, prevParams: Record<string, string>, request: Request, prevUrl: URL, nextUrl: URL, actionContext: {
-        actionId?: string;
-        actionUrl?: URL;
-        actionResult?: any;
-        formData?: FormData;
-    } | undefined, interceptResult: {
-        intercept: InterceptEntry;
-        entry: EntryData;
-    } | null, localRouteName: string, pathname: string, stale?: boolean, chain?: readonly EntryData[]) => Promise<{
-        segments: ResolvedSegment[];
-        matchedIds: string[];
-    }>;
-    findInterceptForRoute: (targetRouteKey: string, fromEntry: EntryData | null, selectorContext?: InterceptSelectorContext | null, isAction?: boolean) => {
-        intercept: InterceptEntry;
-        entry: EntryData;
-    } | null;
-    resolveInterceptEntry: (interceptEntry: InterceptEntry, parentEntry: EntryData, params: Record<string, string>, context: HandlerContext<any, TEnv>, belongsToRoute?: boolean, revalidationContext?: any, options?: {
-        background?: boolean;
-    }) => Promise<ResolvedSegment[]>;
-    resolveInterceptLoadersOnly: (interceptEntry: InterceptEntry, parentEntry: EntryData, context: HandlerContext<any, TEnv>, belongsToRoute: boolean, revalidationContext: RevalidationContext) => Promise<ResolvedSegment[]>;
-}
+import type { RouterContext } from "./router-context.js";
+import { findInterceptForRoute as _findInterceptForRoute } from "./intercept-resolution.js";
+/** The resolvers RouterContext exposes, with the router's deps bound. */
+export type SegmentWrappers<TEnv = any> = Pick<RouterContext<TEnv>, "resolveAllSegments" | "resolveInterceptEntry"> & Required<Pick<RouterContext<TEnv>, "resolveLoadersOnly" | "buildEntryRevalidateMap" | "resolveInterceptLoadersOnly">> & {
+    /** Its own signature: a null selector context, isAction defaulting to false. */
+    findInterceptForRoute: typeof _findInterceptForRoute;
+};
 /**
- * Create thin wrapper functions that bind segmentDeps to extracted
- * segment resolution and intercept resolution functions.
- *
- * These maintain the same signatures as the original inline functions
- * so that RouterContext and call sites don't need to change.
+ * Bind the router's segment deps into the extracted segment and intercept
+ * resolvers. Each gets a ResolutionPass: the caller's request-side input with
+ * the deps added here, once per call.
  */
-export declare function createSegmentWrappers<TEnv = any>(segmentDeps: SegmentResolutionDeps<TEnv>): SegmentWrappers<TEnv>;
+export declare function createSegmentWrappers<TEnv = any>(deps: SegmentResolutionDeps<TEnv>): SegmentWrappers<TEnv>;

package/dist/types/router/telemetry.d.ts

@@ -208,6 +208,8 @@ export declare function safeEmit(sink: TelemetrySink, event: TelemetryEvent): vo
  * Generated IDs use format "t-{base36}" to distinguish from header values.
  */
 export declare function getRequestId(request: Request): string;
+/** Make `id` the id getRequestId returns for `request`. */
+export declare function setRequestId(request: Request, id: string): void;
 /**
  * Built-in console sink that logs events in a structured format.
  * Designed as the default sink for development / debugging.

package/dist/types/router/types.d.ts

@@ -15,6 +15,16 @@ export type ActionContext = {
     actionUrl?: URL;
     actionResult?: any;
     formData?: FormData;
+    /**
+     * A thrown action's error segment (matchError), set on the action's
+     * revalidation (rsc/server-action.ts matchBoundaryRevalidation). The walk
+     * (resolveAllSegments) resolves every entry above the segment's outlet as on
+     * a success, emits the segment in the outlet's place and stops, so nothing
+     * at or below the outlet runs. The pass skips the prerender store
+     * (cache-lookup.ts): the evicted handler is under the cut. No revalidate()
+     * predicate sees it.
+     */
+    boundary?: ResolvedSegment;
 };
 export interface SegmentResolutionDeps<TEnv = any> {
     wrapLoaderPromise: <T>(promise: Promise<T>, entry: EntryData, segmentId: string, pathname: string, errorContext?: {

package/dist/types/rsc/full-payload.d.ts

@@ -32,7 +32,7 @@ export declare function buildFullPayload(m: MatchResult, ctx: HandlerContext<any
  * visitor's URL. Any other render that shows the visitor's URL marks
  * `_payloadVisitorLocation`, and the document cache does not store it.
  */
-export declare function renderedLocation(reqCtx: Pick<RequestContext<any>, "_variables" | "_shellCaptureRun" | "_shellCaptureForVisitor" | "_documentCacheRender" | "_payloadVisitorLocation" | "res"> | undefined, url: URL): URL;
+export declare function renderedLocation(reqCtx: Pick<RequestContext<any>, "_variables" | "_shellCaptureState" | "_documentCacheRender" | "_payloadVisitorLocation" | "res"> | undefined, url: URL): URL;
 /**
  * A payload's `pathname` (renderedLocation) and, when middleware rewrote the
  * request, `rewriteTarget`: the path and search the route rendered (the
@@ -63,4 +63,4 @@ export declare function payloadLocation(reqCtx: Parameters<typeof renderedLocati
  * default it marks `_payloadVisitorTheme`, and the document cache does not
  * store the response.
  */
-export declare function payloadInitialTheme(reqCtx: Pick<RequestContext<any>, "_themeConfig" | "_shellCaptureRun" | "_readTheme" | "_documentCacheRender" | "_payloadVisitorTheme" | "res">): Theme | undefined;
+export declare function payloadInitialTheme(reqCtx: Pick<RequestContext<any>, "_themeConfig" | "_shellCaptureState" | "_readTheme" | "_documentCacheRender" | "_payloadVisitorTheme" | "res">): Theme | undefined;

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

@@ -6,11 +6,14 @@
  * RSC rendering) so they can be standalone modules without closure coupling.
  */
 import type { RangoInternal } from "../router/router-interfaces.js";
-import type { ErrorPhase } from "../types.js";
-import type { InvokeOnErrorContext } from "../router/error-handling.js";
 import type { RSCDependencies, LoadSSRModule } from "./types.js";
 import type { SSRStreamMode } from "../router/router-options.js";
-export interface HandlerContext<TEnv = unknown> {
+import type { RequestStageContext } from "./request-stages.js";
+/**
+ * Extends what the request stages (rsc/request-stages.ts) call back into, so
+ * the handler hands this one bundle to them as well.
+ */
+export interface HandlerContext<TEnv = unknown> extends RequestStageContext<TEnv> {
     router: RangoInternal<TEnv, any>;
     /**
      * The router's DOCUMENT version (router-versions.ts): payload metadata, the
@@ -26,9 +29,6 @@ export interface HandlerContext<TEnv = unknown> {
     decodeAction: RSCDependencies["decodeAction"];
     decodeFormState: RSCDependencies["decodeFormState"];
     loadSSRModule: LoadSSRModule;
-    callOnError: (error: unknown, phase: ErrorPhase, context: InvokeOnErrorContext<TEnv>) => void;
-    getRequiredRouteMap: () => Record<string, string>;
-    createRedirectFlightResponse: (redirectUrl: string, locationState?: Record<string, unknown>, external?: boolean) => Response;
     /**
      * Resolve the SSR stream mode for a given request.
      * Returns "stream" when no resolveStreaming callback is configured.

package/dist/types/rsc/json-route-result.d.ts

@@ -1,10 +1,6 @@
 /**
- * Shared serialization for `json()` response-route results.
- *
- * Kept in its own lightweight module (depends only on `errors.js`) so the
- * `dispatch()` testing primitive can import it WITHOUT dragging in
- * `response-route-handler.ts`'s heavy runtime graph, which transitively reaches
- * a Vite virtual module and breaks a plain (non-Vite) vitest import.
+ * Serialization for `json()` response-route results (depends only on
+ * `errors.js`).
  */
 /**
  * Serialize a `json()` response-route result, rejecting a nested unresolved
@@ -13,8 +9,8 @@
  * the RSC pipeline awaits nested promises but this path does not. Throwing
  * `RESPONSE_NOT_SERIALIZABLE` makes the failure loud.
  *
- * Shared by the production response-route handler and the `dispatch()` testing
- * primitive so a `dispatch` json test of a forgotten await fails exactly where
- * production 500s, instead of going green.
+ * The `dispatch()` testing primitive runs the same response-route handler, so
+ * a `dispatch` json test of a forgotten await fails exactly where production
+ * 500s, instead of going green.
  */
 export declare function stringifyJsonRouteResult(result: unknown): string;

package/dist/types/rsc/request-stages.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Request stages
+ *
+ * The stages a request runs through before and after rendering: classify,
+ * guard, the global middleware passes, the response route, and the
+ * response's finalization. The RSC handler (rsc/handler.ts createRSCHandler)
+ * runs them all around its Flight executor. The dispatch testing primitive
+ * (testing/dispatch.ts) runs classify, the terminal plans, the passes, the
+ * response route and the finalization, and throws where a plan would render
+ * a component. Sharing them keeps dispatch's responses identical to
+ * production's; a hand-kept mirror drifted once (#1128).
+ *
+ * No import of @vitejs/plugin-rsc on this graph: dispatch loads it in a
+ * plain Vitest project, where plugin-rsc's entries cannot load (they import
+ * Vite virtuals). testing/__tests__/testing-module-graph.test.ts pins it.
+ */
+import type { MiddlewareEntry } from "../router/middleware-types.js";
+import { type RequestContext } from "../server/request-context.js";
+import { type RewritePassesOptions, type RewritePassesResult } from "./rewrite-passes.js";
+import { type ResponseRouteMatch } from "./response-route-handler.js";
+import type { ErrorPhase } from "../types.js";
+import type { OnErrorCallback } from "../types/error-types.js";
+import { type InvokeOnErrorContext } from "../router/error-handling.js";
+import type { OriginCheckPhase } from "./origin-guard.js";
+import { type OnTimeoutCallback, type ResolvedTimeouts, type TimeoutPhase } from "../router/timeout.js";
+import { type TelemetrySink } from "../router/telemetry.js";
+import { type ClassifyRequestDeps, type ExecutableRequestPlan, type RequestPlan, type ResponseRoutePlan } from "../router/request-classification.js";
+/**
+ * The router members the stages read. The handler's `RangoInternal` carries
+ * them; dispatch reads them off the router a test passes.
+ */
+export interface StageRouter<TEnv = unknown> {
+    readonly basename: string | undefined;
+    readonly middleware: MiddlewareEntry<TEnv>[];
+    readonly onError?: OnErrorCallback<TEnv>;
+    readonly telemetry?: TelemetrySink;
+    readonly timeouts?: ResolvedTimeouts;
+    readonly onTimeout?: OnTimeoutCallback<TEnv>;
+}
+/** Report an error through the router's onError. */
+export type ReportError<TEnv = unknown> = (error: unknown, phase: ErrorPhase, context: InvokeOnErrorContext<TEnv>) => void;
+/**
+ * What the stages call back into. The handler's context bundle
+ * (rsc/handler-context.ts HandlerContext) extends it.
+ */
+export interface RequestStageContext<TEnv = unknown> {
+    router: StageRouter<TEnv>;
+    callOnError: ReportError<TEnv>;
+    getRequiredRouteMap: () => Record<string, string>;
+    /**
+     * The redirect a partial or action request receives: a Flight payload in
+     * the handler (fetch() would follow a raw 3xx to HTML). dispatch has no
+     * Flight runtime and answers 204 + X-RSC-Redirect.
+     */
+    createRedirectFlightResponse: (redirectUrl: string, locationState?: Record<string, unknown>, external?: boolean) => Response;
+    /**
+     * Reports a response-route handler's own throw; absent, it goes to
+     * callOnError with phase "handler". dispatch passes a no-op: it does not
+     * report that throw (its documented boundary, testing/dispatch.ts).
+     */
+    reportResponseRouteError?: (error: unknown, context: InvokeOnErrorContext<TEnv>) => void;
+}
+/** What classify and the terminal plans read beyond the stage context. */
+export interface ClassifyContext<TEnv = unknown> {
+    router: {
+        readonly id: string;
+        readonly findMatch: ClassifyRequestDeps<TEnv>["findMatch"];
+    };
+    /** The router's DOCUMENT version: the `_rsc_v` reload check. */
+    version: string;
+}
+/**
+ * Per-request error reporter that deduplicates via the ALS request context.
+ *
+ * Uses the same _reportedErrors WeakSet as the router layer so errors
+ * that propagate across layers are only reported once per request.
+ */
+export declare function createErrorReporter<TEnv>(router: {
+    readonly onError?: OnErrorCallback<TEnv>;
+}): ReportError<TEnv>;
+/**
+ * Wire background error reporting so "use cache" and other subsystems can
+ * surface non-fatal errors through the router's onError callback.
+ */
+export declare function reportBackgroundErrors<TEnv>(reqCtx: RequestContext<TEnv>, request: Request, url: URL, callOnError: ReportError<TEnv>): void;
+/**
+ * Classify a request into its plan. classifyRequest throws
+ * RouteNotFoundError for an unknown route; that falls through to a
+ * full-render plan with no matched route, so the render path renders the
+ * 404 page (match()/matchPartial() re-throw and the render's catch renders
+ * it).
+ */
+export declare function classify<TEnv>(request: Request, url: URL, ctx: ClassifyContext<TEnv>): Promise<RequestPlan<TEnv>>;
+/** The plan classify answers an unknown route with (the render path's 404). */
+export declare function isUnmatchedPlan(plan: RequestPlan<any>): boolean;
+/**
+ * Record a plan's route on the request context: its params and name, and the
+ * classified snapshot match()/matchPartial() reuse instead of resolving the
+ * route again. Runs inside the global chain, so global middleware sees the
+ * route after next(). A redirect has none.
+ */
+export declare function recordPlanRoute<TEnv>(plan: ExecutableRequestPlan<TEnv>): void;
+/**
+ * The checks between classification and execution that need no await.
+ * Returns the response of a terminal plan (a partial request's redirect, a
+ * version or app-switch reload), null to go on. Throws for a rewritten
+ * action whose target is not a page route.
+ *
+ * Synchronous, and the origin guard is a separate step: the caller awaits
+ * checkRequestOrigin only for the modes ORIGIN_CHECK_PHASE_BY_MODE gates, so
+ * a full, partial or response plan reaches execution without an added
+ * microtask (rsc/__tests__/request-microtasks.rsc-test.tsx).
+ */
+export declare function terminalPlanResponse<TEnv>(plan: RequestPlan<TEnv>, url: URL, ctx: RequestStageContext<TEnv> & ClassifyContext<TEnv>): Response | null;
+/**
+ * The origin guard's rejection: reports it through onError and telemetry,
+ * and returns the response checkRequestOrigin rejected the request with. The
+ * caller awaits checkRequestOrigin itself, for the modes
+ * ORIGIN_CHECK_PHASE_BY_MODE gates (action, loader, PE form), so the guard
+ * adds no microtask over that await.
+ */
+export declare function originRejectedResponse<TEnv>(rejection: Response, phase: OriginCheckPhase, request: Request, env: TEnv, url: URL, ctx: RequestStageContext<TEnv>): Response;
+export interface RequestPassesOptions<TEnv> {
+    ctx: RequestStageContext<TEnv>;
+    reqCtx: RequestContext<TEnv>;
+    /** The visitor's request and raw URL: the first pass. */
+    request: Request;
+    url: URL;
+    env: TEnv;
+    variables: Record<string, any>;
+    /** The visitor's global middleware, when the caller matched it already. */
+    firstPassMiddleware?: Array<{
+        entry: MiddlewareEntry<TEnv>;
+        params: Record<string, string>;
+    }>;
+    /** Runs before a pass's global chain; dispatch matches the pass there. */
+    beforePass?: (request: Request, url: URL, index: number) => Promise<void>;
+    /** The core handler a pass's global chain wraps. */
+    core: (request: Request, url: URL) => Promise<Response>;
+    onHop?: RewritePassesOptions["onHop"];
+    refuse?: RewritePassesOptions["refuse"];
+}
+export interface RequestPassesResult extends RewritePassesResult {
+    /** Whether the last pass ran a global middleware chain. */
+    hasMiddleware: boolean;
+}
+/**
+ * One pass per URL: the global middleware chain matched on the pass's path,
+ * wrapping the core handler. A `throw rewrite()` from global or route
+ * middleware unwinds the pass, and the next one runs the same request as
+ * the target from the top, as a direct visit would (rsc/rewrite-passes.ts).
+ */
+export declare function runRequestPasses<TEnv>(opts: RequestPassesOptions<TEnv>): Promise<RequestPassesResult>;
+/**
+ * The flat match handleResponseRoute takes, with params at the top level,
+ * built from a response-route plan.
+ */
+export declare function responseRouteMatch(plan: ResponseRoutePlan<any>): ResponseRouteMatch;
+export interface ServeResponseRouteOptions<TEnv> {
+    match: ResponseRouteMatch;
+    /** The matched route's key, for the timeout report. */
+    routeKey: string | undefined;
+    /** The pass's request, raw URL and env. */
+    request: Request;
+    url: URL;
+    env: TEnv;
+    variables: Record<string, any>;
+    /**
+     * Receives the handler's work when the deadline wins. The handler leaves
+     * it running; dispatch cancels its body.
+     */
+    abandon?: (work: Promise<Response>) => void;
+}
+/**
+ * A response route: its handler (rsc/response-route-handler.ts) under the
+ * renderStartMs deadline, which starts here, inside the global chain, so
+ * global middleware time never counts toward it.
+ */
+export declare function serveResponseRoute<TEnv>(ctx: RequestStageContext<TEnv>, opts: ServeResponseRouteOptions<TEnv>): Promise<Response>;
+/**
+ * Handle a timeout by reporting the error, emitting telemetry,
+ * and returning either the custom onTimeout response or a default 504.
+ */
+export declare function timeoutResponse<TEnv>(ctx: RequestStageContext<TEnv>, request: Request, env: TEnv, url: URL, phase: TimeoutPhase, durationMs: number, routeKey?: string, actionId?: string): Promise<Response>;
+export interface FinalizeRequestOptions<TEnv> {
+    ctx: RequestStageContext<TEnv>;
+    reqCtx: RequestContext<TEnv>;
+    /** The visitor's request, raw URL and env. */
+    request: Request;
+    url: URL;
+    env: TEnv;
+    /** runRequestPasses' result. */
+    hasMiddleware: boolean;
+    rewrittenTo?: string;
+    /** Runs on the response before the open-redirect guard. */
+    beforeGuard?: (response: Response) => void;
+}
+/**
+ * The response the global chain returned, made ready to leave: a partial or
+ * action request's redirect converted, onResponse callbacks drained, the
+ * rewrite header, the open-redirect guard and the stream-idle watchdog.
+ */
+export declare function finalizeRequestResponse<TEnv>(downstream: Response, opts: FinalizeRequestOptions<TEnv>): Response;

package/dist/types/rsc/response-cache-serve.d.ts

@@ -5,23 +5,18 @@
  * matched entry tree, condition eval, key resolution (route key() > store
  * keyGenerator > default, CacheScope.resolveKeyFrom), tag resolution,
  * pre-handler-callback timing, and the fresh-hit / SWR-revalidate /
- * miss-write branches — for BOTH the production
- * response-route handler (rsc/response-route-handler.ts) and the dispatch testing
- * primitive (testing/dispatch.ts), so the two can never drift.
+ * miss-write branches — for the response-route handler
+ * (rsc/response-route-handler.ts), which the production handler and the
+ * dispatch testing primitive both run (rsc/request-stages.ts
+ * serveResponseRoute), so the two can never drift.
  *
- * Plugin-rsc hazard: cache-scope.ts pulls @vitejs/plugin-rsc (via segment-codec),
- * which the non-Vite unit-test runner cannot resolve, and this module is on the
- * testing barrel's EAGER graph (dispatch imports it). So `createCacheScope` is
- * NOT imported here at runtime — it is INJECTED by the caller (production
- * imports it statically; dispatch lazy-imports it only once a response route
- * matches). The only runtime imports here are plugin-rsc-free
- * (helpers' isCacheableStatus/finalizeResponse, traverseBack); cache-scope is a
- * type-only import (erased at build).
+ * `createCacheScope` is injected by the caller: the response-route handler
+ * passes the real one, unit tests a stub.
  */
 import type { CacheScope } from "../cache/cache-scope.js";
 import { type RequestContext } from "../server/request-context.js";
 import type { EntryCacheConfig, EntryData } from "../server/context.js";
-/** Injected cache-scope builder (kept off this module's runtime import graph). */
+/** Injected cache-scope builder. */
 export interface CacheScopeDeps {
     createCacheScope: (config: EntryCacheConfig | undefined, parent?: CacheScope | null) => CacheScope | null;
 }

package/dist/types/rsc/response-route-handler.d.ts

@@ -7,7 +7,7 @@
  */
 import type { MiddlewareFn } from "../router/middleware.js";
 import { type EntryData } from "../server/context.js";
-import type { HandlerContext } from "./handler-context.js";
+import type { RequestStageContext } from "./request-stages.js";
 export interface ResponseRouteMatch {
     responseType: string;
     handler: Function;
@@ -26,4 +26,4 @@ export interface ResponseRouteMatch {
  * For partial (client-side navigation) requests, returns X-RSC-Reload
  * so the browser triggers a hard navigation to the response route URL.
  */
-export declare function handleResponseRoute<TEnv>(handlerCtx: HandlerContext<TEnv>, preview: ResponseRouteMatch, request: Request, env: TEnv, url: URL, variables: Record<string, any>): Promise<Response>;
+export declare function handleResponseRoute<TEnv>(handlerCtx: Pick<RequestStageContext<TEnv>, "callOnError" | "getRequiredRouteMap" | "reportResponseRouteError">, preview: ResponseRouteMatch, request: Request, env: TEnv, url: URL, variables: Record<string, any>): Promise<Response>;

package/dist/types/rsc/routine-plan.d.ts

@@ -62,7 +62,7 @@ export declare function step<T>(name: string, execute: () => T | Promise<T>): Ro
  *
  * Settlement tracking follows the RETURNED value: a returned promise is
  * observed until it settles; a scheduler that fires-and-forgets internally
- * (e.g. scheduleShellCapture via runBackground) returns void, so its trace
+ * (e.g. planShellCapture via runBackground) returns void, so its trace
  * entry settles at the scheduling call, not at background completion. That is
  * deliberate — the plan's contract ends at the handoff.
  */

package/dist/types/rsc/server-action.d.ts

@@ -27,8 +27,8 @@ import type { MatchResult } from "../types.js";
  * the revalidation phase so it runs INSIDE the same route-middleware wrapper as
  * a successful revalidation — route middleware (context vars, headers, cookies)
  * must apply to the error render too, matching the module doc's "identical to a
- * normal render". When `errorBoundary` is set, `actionContext` is unused (the
- * boundary is already matched; no matchPartial is run).
+ * normal render". That render is the action's revalidation, cut at the
+ * boundary (ActionContext.boundary).
  */
 export interface ActionContinuation {
     returnValue: {

package/dist/types/rsc/shell-capture-constants.d.ts

@@ -139,7 +139,7 @@ export declare const POST_QUIESCE_TASK_HOPS = 16;
  * short is an acceptable loss — every terminal path backs the key off anyway),
  * and below workerd's ~30s waitUntil grace so the cap timer still fires in a
  * live context. When workerd kills the context BEFORE the cap fires, the timer
- * dies with it — that stranding is healed by scheduleShellCapture's staleness
+ * dies with it — that stranding is healed by planShellCapture's staleness
  * check on the stampede guard, keyed off the same constant.
  */
 export declare const SHELL_CAPTURE_TASK_HARD_CAP_MS = 25000;