@timber-js/app 0.2.0-alpha.207 → 0.2.0-alpha.209

package/dist/server/route-element-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-element-builder.d.ts","sourceRoot":"","sources":["../../src/server/route-element-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAO9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAMhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAO5D;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,UAAU,GAChB,MAAM,EAAE,CAGV;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAID,+CAA+C;AAC/C,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC3C,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAED,+CAA+C;AAC/C,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,OAAO,EAAE,cAAc,CAAC;IACxB,wDAAwD;IACxD,gBAAgB,EAAE,oBAAoB,EAAE,CAAC;IACzC,qCAAqC;IACrC,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,4DAA4D;IAC5D,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;OAIG;IACH,YAAY,EAAE,aAAa,EAAE,CAAC;IAC9B;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,EAAE,CAAC;CACjC;AA2DD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,UAAU,EACjB,YAAY,CAAC,EAAE,mBAAmB,EAClC,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,EACxC,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3C,OAAO,CAAC,kBAAkB,CAAC,CAyZ7B"}
+{"version":3,"file":"route-element-builder.d.ts","sourceRoot":"","sources":["../../src/server/route-element-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAQ9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAMhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAQ5D;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,UAAU,GAChB,MAAM,EAAE,CAGV;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAID,+CAA+C;AAC/C,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC3C,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAED,+CAA+C;AAC/C,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,OAAO,EAAE,cAAc,CAAC;IACxB,wDAAwD;IACxD,gBAAgB,EAAE,oBAAoB,EAAE,CAAC;IACzC,qCAAqC;IACrC,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,4DAA4D;IAC5D,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B;;;;OAIG;IACH,YAAY,EAAE,aAAa,EAAE,CAAC;IAC9B;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,EAAE,CAAC;CACjC;AA2DD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,UAAU,EACjB,YAAY,CAAC,EAAE,mBAAmB,EAClC,eAAe,CAAC,EAAE,eAAe,GAAG,IAAI,EACxC,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3C,OAAO,CAAC,kBAAkB,CAAC,CA4Z7B"}

package/dist/server/route-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-handler.d.ts","sourceRoot":"","sources":["../../src/server/route-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAO/C,+DAA+D;AAC/D,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAE1F,2DAA2D;AAC3D,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,YAAY,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAE/E,wEAAwE;AACxE,MAAM,MAAM,WAAW,GAAG;KACvB,CAAC,IAAI,UAAU,CAAC,CAAC,EAAE,YAAY;CACjC,CAAC;AAOF;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,WAAW,GAAG,UAAU,EAAE,CAyBpE;AAID;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CAwC/F"}
+{"version":3,"file":"route-handler.d.ts","sourceRoot":"","sources":["../../src/server/route-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAQ/C,+DAA+D;AAC/D,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAE1F,2DAA2D;AAC3D,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,YAAY,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAE/E,wEAAwE;AACxE,MAAM,MAAM,WAAW,GAAG;KACvB,CAAC,IAAI,UAAU,CAAC,CAAC,EAAE,YAAY;CACjC,CAAC;AAOF;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,WAAW,GAAG,UAAU,EAAE,CAyBpE;AAID;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,CAyC/F"}

package/dist/server/route-matcher.d.ts

@@ -55,6 +55,13 @@ export declare function createRouteMatcher(manifest: ManifestRoot): (pathname: s
  * the canonical route.
  */
 export declare function collectMiddlewareChain(chain: ManifestSegmentNode[]): MiddlewareFn[];
+/**
+ * Whether a matched chain renders as an API route: its leaf has a
+ * `route.ts` and no `page.tsx`. The same test `renderRoute` dispatches on,
+ * so every answer about a route's format — early hints, deny format, error
+ * format, error reporting — agrees with what actually ran.
+ */
+export declare function isApiRouteChain(segments: readonly ManifestSegmentNode[]): boolean;
 /** Result of matching a metadata route. */
 export interface MetadataRouteMatch {
     /** The metadata route type (sitemap, robots, icon, etc.) */

package/dist/server/route-matcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-matcher.d.ts","sourceRoot":"","sources":["../../src/server/route-matcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAKL,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAY9B,6DAA6D;AAC7D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,YAAY,CAAC,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAa,SAAQ,SAAS,CAAC,YAAY,CAAC;IAC3D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,YAAY,GACrB,CAAC,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,IAAI,CAEzC;AAqBD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,mBAAmB,EAAE,GAAG,YAAY,EAAE,CAcnF;AAID,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IACjC,4DAA4D;IAC5D,IAAI,EAAE,iBAAiB,CAAC;IACxB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,IAAI,EAAE,YAAY,CAAC;IACnB,0DAA0D;IAC1D,OAAO,EAAE,mBAAmB,CAAC;IAC7B;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,wEAAwE;IACxE,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;CAClD;AAcD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,YAAY,GACrB,CAAC,QAAQ,EAAE,MAAM,KAAK,kBAAkB,GAAG,IAAI,CAEjD"}
+{"version":3,"file":"route-matcher.d.ts","sourceRoot":"","sources":["../../src/server/route-matcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAKL,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAY9B,6DAA6D;AAC7D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAAC,YAAY,CAAC,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAa,SAAQ,SAAS,CAAC,YAAY,CAAC;IAC3D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,YAAY,GACrB,CAAC,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,IAAI,CAEzC;AAwBD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,mBAAmB,EAAE,GAAG,YAAY,EAAE,CAcnF;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,GAAG,OAAO,CAGjF;AAID,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IACjC,4DAA4D;IAC5D,IAAI,EAAE,iBAAiB,CAAC;IACxB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,IAAI,EAAE,YAAY,CAAC;IACnB,0DAA0D;IAC1D,OAAO,EAAE,mBAAmB,CAAC;IAC7B;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB,wEAAwE;IACxE,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;CAClD;AAcD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,YAAY,GACrB,CAAC,QAAQ,EAAE,MAAM,KAAK,kBAAkB,GAAG,IAAI,CAEjD"}

package/dist/server/rsc-entry/action-middleware-runner.d.ts

@@ -19,48 +19,48 @@
  */
 import { DenySignal, RedirectSignal } from '../primitives.ts';
 import type { RouteMatch } from '../pipeline.ts';
-/** Coerce a matched route's segment params via its `params.ts` codecs. */
-export type CoerceSegmentParamsFn = (match: RouteMatch) => Promise<void>;
+import type { ReactCacheScope } from '../react-cache-scope.ts';
 /**
- * Outcome of running middleware on an action request, surfaced from the
- * inner `runWithRequestContext` scope so the outer dispatcher can convert
- * it to a Response (short-circuit) or continue to the action handler.
+ * Outcome of running a route's middleware chain, surfaced from the inner
+ * `runWithRequestContext` scope as a value. Its one consumer is the
+ * revalidation renderer, which turns every variant but `continue` into
+ * a thrown signal or a dropped revalidation.
  *
- * Each variant carries the post-middleware Set-Cookie snapshot so the
- * outer scope can apply cookies to whichever Response it ultimately
- * returns. The middleware ALS scope ends before the action ALS scope
- * begins, so cookie state must be threaded explicitly across the boundary
- * via `seedRequestCookies` (cookie reads) and `setCookieHeaders` (cookie
- * writes).
+ * Only `continue` carries state out of the scope: the request-header
+ * overlay, which the renderer applies to the action's scope so the
+ * revalidated tree sees middleware-injected headers. Cookies the chain sets
+ * stay in the inner scope and are discarded with it; see the renderer's
+ * docstring for why.
  */
 export type MiddlewareOutcome = {
     kind: 'continue';
     overlay: Headers;
-    cookies: Map<string, string>;
-    setCookieHeaders: string[];
 } | {
     kind: 'short-circuit';
     response: Response;
-    setCookieHeaders: string[];
 } | {
     kind: 'redirect';
     signal: RedirectSignal;
-    setCookieHeaders: string[];
 } | {
     kind: 'deny';
     signal: DenySignal;
-    match: RouteMatch;
-    setCookieHeaders: string[];
-} | {
-    kind: 'param-coercion-error';
 } | {
     kind: 'error';
     error: unknown;
 };
+/** The inner request scope's inputs, besides the request itself. */
+export interface MiddlewareScope {
+    /** The `React.cache` scope the revalidated tree will render in. */
+    reactCacheScope: ReactCacheScope;
+    /** The action's post-mutation cookies, as the inner scope's cookies. */
+    cookies?: Map<string, string>;
+}
 /**
  * Run the matched route's middleware chain inside a fresh request-context
- * scope, captured as a `MiddlewareOutcome` value the outer dispatcher can
- * translate to a Response or use as the seed for the action handler.
+ * scope, captured as a `MiddlewareOutcome` value.
+ *
+ * `match` must already carry coerced segment params: coercion runs before
+ * middleware, in the caller, as it does in the page pipeline.
  */
-export declare function runMiddlewareForAction(req: Request, match: RouteMatch, coerceSegmentParams: CoerceSegmentParamsFn): Promise<MiddlewareOutcome>;
+export declare function runMiddlewareForAction(req: Request, match: RouteMatch, { reactCacheScope, cookies }: MiddlewareScope): Promise<MiddlewareOutcome>;
 //# sourceMappingURL=action-middleware-runner.d.ts.map

package/dist/server/rsc-entry/action-middleware-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"action-middleware-runner.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/action-middleware-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAUH,OAAO,EAAkC,UAAU,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAE9F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,0EAA0E;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEzE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,GACzB;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,GACD;IACE,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,EAAE,QAAQ,CAAC;IACnB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,GACD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,cAAc,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,UAAU,CAAC;IAClB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,GACD;IACE,IAAI,EAAE,sBAAsB,CAAC;CAC9B,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEN;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,UAAU,EACjB,mBAAmB,EAAE,qBAAqB,GACzC,OAAO,CAAC,iBAAiB,CAAC,CAoF5B"}
+{"version":3,"file":"action-middleware-runner.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/action-middleware-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AASH,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,cAAc,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAEtC,oEAAoE;AACpE,MAAM,WAAW,eAAe;IAC9B,mEAAmE;IACnE,eAAe,EAAE,eAAe,CAAC;IACjC,wEAAwE;IACxE,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,UAAU,EACjB,EAAE,eAAe,EAAE,OAAO,EAAE,EAAE,eAAe,GAC5C,OAAO,CAAC,iBAAiB,CAAC,CAyD5B"}

package/dist/server/rsc-entry/api-handler.d.ts

@@ -4,6 +4,13 @@
  * Runs access.ts standalone for all segments in the chain (no React render
  * pass, no AccessGate component). Then dispatches to the route handler.
  * See design/04-authorization.md §"Auth in API Routes".
+ *
+ * Nothing thrown here is answered here. A `deny()` or `redirect()` from
+ * `access.ts` or a method handler, and every other error, propagates to the
+ * pipeline: its deny fallback answers a route.ts match in the JSON status
+ * format, its redirect builder sends the 3xx, and its error outcome answers
+ * errors in the same JSON format. There is one translator for each, not one
+ * per route type (TIM-1537, TIM-1533).
  */
 import type { ManifestSegmentNode } from '../route-matcher.ts';
 /**

package/dist/server/rsc-entry/api-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-handler.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/api-handler.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAS/D;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,eAAe,EAAE,OAAO,GACvB,OAAO,CAAC,QAAQ,CAAC,CAsDnB"}
+{"version":3,"file":"api-handler.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/api-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAO/D;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,eAAe,EAAE,OAAO,GACvB,OAAO,CAAC,QAAQ,CAAC,CA0CnB"}

package/dist/server/rsc-entry/deny-fallback.d.ts

@@ -1,17 +1,23 @@
 /**
  * Deny fallback renderer — renders the deny page (403.tsx, 404.tsx, etc.)
- * for DenySignals that escape from middleware or the render phase.
+ * for DenySignals that escape from proxy, middleware, or the render phase,
+ * and the 404 page for a URL no route matches.
+ *
+ * This is the one module that assembles deny pages. Renderers report a
+ * captured deny by rethrowing it; the pipeline's outcome translator calls
+ * this. See design/49-explicit-subsystem-boundaries.md §"C".
  *
  * Extracted from index.ts (TIM-968) as a pure move. The factory captures
  * the root segment and client bootstrap config once at handler creation;
- * the returned function is wired into `PipelineConfig.renderDenyFallback`
- * and reused by the action-dispatch wrapper.
+ * the returned function is wired into `PipelineConfig.renderDenyFallback`.
  *
  * Design docs: 04-authorization.md, 10-error-handling.md
  */
+import type { DefaultPageRenderer } from '../deny-renderer.ts';
 import type { ClientBootstrapConfig } from '../html-injectors.ts';
-import type { PipelineConfig } from '../pipeline.ts';
-import type { ManifestSegmentNode } from '../route-matcher.ts';
+import type { RouteMatch } from '../pipeline.ts';
+import type { DenySignal } from '../primitives.ts';
+import { type ManifestSegmentNode } from '../route-matcher.ts';
 /**
  * Create the pipeline's deny fallback renderer.
  *
@@ -21,9 +27,29 @@ import type { ManifestSegmentNode } from '../route-matcher.ts';
  * route's `401.json` are picked up. Fall back to the root chain when no
  * match is available (e.g. proxy-stage deny before route matching).
  * See TIM-822, design/04-authorization.md, design/10-error-handling.md.
+ *
+ * The page is clamped to the denied segment exactly as the renderer clamps a
+ * captured deny: the index an AccessGate or layout recorded in request ALS
+ * bounds the status-file walk and the layout shell, so a thrown deny never
+ * selects a status file below the denial or runs the denied segment's
+ * layout. It is read here, at call time, rather than passed by the pipeline:
+ * the store is RSC-owned and the pipeline does not know it exists.
+ *
+ * The index is a position in the matched chain, so it is applied only when
+ * there is one. A proxy-phase deny arrives with no match (root-only chain),
+ * and one thrown after `await next()` shares the request store with the
+ * render it replaced — that render's denied index describes a different
+ * deny and must not clamp this one. A middleware-phase deny runs before
+ * render, so no index has been recorded. See TIM-1525, design/49-explicit-subsystem-boundaries.md §P0.
  */
 export declare function createDenyFallbackRenderer(options: {
     rootSegment: ManifestSegmentNode;
     clientBootstrap: ClientBootstrapConfig;
-}): NonNullable<PipelineConfig['renderDenyFallback']>;
+}): DenyFallbackRenderer;
+/**
+ * The deny fallback. `defaultPage` replaces the framework default status
+ * page when no status file answers — the dev 404 route listing for an
+ * unmatched URL.
+ */
+export type DenyFallbackRenderer = (deny: DenySignal, req: Request, responseHeaders: Headers, matchedRoute?: RouteMatch, defaultPage?: DefaultPageRenderer) => Promise<Response>;
 //# sourceMappingURL=deny-fallback.d.ts.map

package/dist/server/rsc-entry/deny-fallback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deny-fallback.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/deny-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAElE,OAAO,KAAK,EAAE,cAAc,EAAc,MAAM,gBAAgB,CAAC;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAK/D;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE;IAClD,WAAW,EAAE,mBAAmB,CAAC;IACjC,eAAe,EAAE,qBAAqB,CAAC;CACxC,GAAG,WAAW,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC,CAgDpD"}
+{"version":3,"file":"deny-fallback.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/deny-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAe,MAAM,qBAAqB,CAAC;AAE5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGlE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAmB,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAKhF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE;IAClD,WAAW,EAAE,mBAAmB,CAAC;IACjC,eAAe,EAAE,qBAAqB,CAAC;CACxC,GAAG,oBAAoB,CAiFvB;AAED;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,CACjC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,OAAO,EACZ,eAAe,EAAE,OAAO,EACxB,YAAY,CAAC,EAAE,UAAU,EACzB,WAAW,CAAC,EAAE,mBAAmB,KAC9B,OAAO,CAAC,QAAQ,CAAC,CAAC"}

package/dist/server/rsc-entry/error-renderer.d.ts

@@ -1,5 +1,6 @@
 /**
- * RSC Error & No-Match Renderers — handles error pages and 404s.
+ * RSC Error Renderer — handles error pages. (The 404 page for an unmatched
+ * URL is a deny page, assembled by `deny-fallback.ts`.)
  *
  * Error pages are 'use client' components rendered through the RSC → SSR
  * pipeline: the Error is converted to SerializableError, wrapped with
@@ -10,7 +11,7 @@
 import type { RouteMatch } from '../pipeline.ts';
 import type { ManifestSegmentNode } from '../route-matcher.ts';
 import type { ClientBootstrapConfig } from '../html-injectors.ts';
-import type { DefaultPageRenderer, LayoutEntry } from '../deny-renderer.ts';
+import type { LayoutEntry } from '../deny-renderer.ts';
 /**
  * A manifest file reference with lazy import and path.
  * Mirrors the shape from ManifestSegmentNode but kept local to avoid
@@ -21,7 +22,7 @@ export interface GlobalErrorFile {
     filePath: string;
 }
 /**
- * Render an error page for unhandled throws or RenderError outside Suspense.
+ * Render an error page for an unhandled throw outside Suspense.
  *
  * All error pages (TSX and MDX) go through RSC → SSR:
  * - TSX: ErrorReconstituter wrapper converts SerializableError → real Error
@@ -31,21 +32,13 @@ export interface GlobalErrorFile {
  * envelope instead. Every tier below produces an HTML document, and the
  * client's Flight decoder is waiting for `text/x-component`; handing it HTML
  * crashes the decode. The check lives here rather than at the call sites
- * because it holds for all five of them, and the deny path's equivalent split
- * (`renderDenyPage` / `renderDenyPageAsRsc`) had already been forgotten at one
- * of this function's — the synchronous render-error exit in `render-route.ts`
- * (TIM-1322). Four of the five are unreachable for an RSC request today
- * (`render-route.ts` returns the payload before it reaches SSR, and
- * `outcomeToResponse` answers RSC errors itself), so this fires on one path
- * and guards the rest against drift.
+ * because it holds for every one of them, and the deny path's equivalent split
+ * (the deny fallback's page / Flight branches) had already been forgotten at one
+ * of this function's — a since-deleted synchronous render-error exit in
+ * `render-route.ts` (TIM-1322). Neither remaining caller is reachable for an
+ * RSC request today (`render-route.ts` returns the payload before it reaches
+ * SSR, and `outcomeToResponse` answers RSC errors itself), so this guards
+ * against drift rather than firing on a live path.
  */
 export declare function renderErrorPage(error: unknown, status: number, segments: ManifestSegmentNode[], layoutComponents: LayoutEntry[], req: Request, match: RouteMatch, responseHeaders: Headers, clientBootstrap: ClientBootstrapConfig, globalError?: GlobalErrorFile, firstDeniedIndex?: number): Promise<Response>;
-/**
- * Render a 404 page for URLs that don't match any route.
- *
- * Uses the root segment's 404.tsx (or 4xx.tsx / error.tsx fallback)
- * wrapped in the root layout, via the same renderDenyPage path
- * used for in-route deny() calls.
- */
-export declare function renderNoMatchPage(req: Request, rootSegment: ManifestSegmentNode, responseHeaders: Headers, clientBootstrap: ClientBootstrapConfig, defaultPage?: DefaultPageRenderer): Promise<Response>;
 //# sourceMappingURL=error-renderer.d.ts.map

package/dist/server/rsc-entry/error-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-renderer.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/error-renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAIlE,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAe5E;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB;AA6GD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,gBAAgB,EAAE,WAAW,EAAE,EAC/B,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,UAAU,EACjB,eAAe,EAAE,OAAO,EACxB,eAAe,EAAE,qBAAqB,EACtC,WAAW,CAAC,EAAE,eAAe,EAC7B,gBAAgB,SAAW,GAC1B,OAAO,CAAC,QAAQ,CAAC,CA4DnB;AA2HD;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,OAAO,EACZ,WAAW,EAAE,mBAAmB,EAChC,eAAe,EAAE,OAAO,EACxB,eAAe,EAAE,qBAAqB,EACtC,WAAW,CAAC,EAAE,mBAAmB,GAChC,OAAO,CAAC,QAAQ,CAAC,CAmCnB"}
+{"version":3,"file":"error-renderer.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/error-renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGlE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAcvD;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;CAClB;AA+GD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,gBAAgB,EAAE,WAAW,EAAE,EAC/B,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,UAAU,EACjB,eAAe,EAAE,OAAO,EACxB,eAAe,EAAE,qBAAqB,EACtC,WAAW,CAAC,EAAE,eAAe,EAC7B,gBAAgB,SAAW,GAC1B,OAAO,CAAC,QAAQ,CAAC,CA6DnB"}

package/dist/server/rsc-entry/helpers.d.ts

@@ -23,7 +23,6 @@ export declare function buildSegmentInfo(segments: ManifestSegmentNode[], layout
     component: (...args: unknown[]) => unknown;
     segment: ManifestSegmentNode;
 }>, slotSkipInfo?: SlotSkipEntry[], skippedSegmentKeys?: string[], firstDeniedIndex?: number): SegmentInfo[];
-export { buildRedirectResponse } from '../pipeline-helpers.ts';
 export { isAbortError } from '../render-utils.ts';
 export { escapeHtml } from '../utils/escape-html.ts';
 //# sourceMappingURL=helpers.d.ts.map

package/dist/server/rsc-entry/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,gBAAgB,EAAE,KAAK,CAAC;IACtB,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC3C,OAAO,EAAE,mBAAmB,CAAC;CAC9B,CAAC,EACF,YAAY,CAAC,EAAE,aAAa,EAAE,EAC9B,kBAAkB,CAAC,EAAE,MAAM,EAAE,EAC7B,gBAAgB,SAAW,GAC1B,WAAW,EAAE,CAsEf;AAMD,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAIzD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,gBAAgB,EAAE,KAAK,CAAC;IACtB,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IAC3C,OAAO,EAAE,mBAAmB,CAAC;CAC9B,CAAC,EACF,YAAY,CAAC,EAAE,aAAa,EAAE,EAC9B,kBAAkB,CAAC,EAAE,MAAM,EAAE,EAC7B,gBAAgB,SAAW,GAC1B,WAAW,EAAE,CAsEf;AAKD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/server/rsc-entry/index.d.ts

@@ -1,15 +1,10 @@
-import type { PipelineConfig } from '../pipeline.ts';
+import type { DevHooks } from '../../dev-tools/dev-page-shell.ts';
 /**
- * Set the dev source-map handler.
- *
- * Called by the dev server after importing this module to wire Vite's
- * module graph source-mapping into the error rendering pipeline. Errors
- * rendered by renderErrorPage / renderFallbackError will have their
- * stack traces rewritten to show original source positions.
- *
- * No-op in production.
+ * Set the dev hooks. Called by the dev server after it imports this module;
+ * the handler reads them at request time, so a later call takes effect on
+ * the next request.
  */
-export declare function setDevSourceMapHandler(handler: (error: Error) => void): void;
+export declare function setDevHooks(hooks: DevHooks): void;
 export { runWithEarlyHintsSender } from '../early-hints-sender.ts';
 export { runWithWaitUntil } from '../waituntil-bridge.ts';
 export { runWithWorkersCachePurge } from '../workers-cache-bridge.ts';
@@ -36,11 +31,6 @@ export declare function __timber_capturePrebuilt(options: import('../prebuilt-bu
  * See design/11-platform.md §"static output mode".
  */
 export declare function __timber_generateStaticSite(options: import('../static-generator.ts').StaticGenerationOptions): Promise<import('../static-generator.ts').StaticGenerationSummary>;
-/**
- * The pipeline configuration object. Exported so the dev server can set
- * `devPipelineErrorHandler` after import without a module-level singleton.
- */
-export declare const pipelineConfig: PipelineConfig;
 declare const _default: (req: Request) => Promise<Response>;
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/dist/server/rsc-entry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/index.ts"],"names":[],"mappings":"AA+CA,OAAO,KAAK,EAAuB,cAAc,EAAc,MAAM,gBAAgB,CAAC;AAqCtF;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAE5E;AA8UD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAInE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAK1D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAItE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,wBAAwB,EAAE,cAAc,GACvD,OAAO,CAAC,OAAO,wBAAwB,EAAE,cAAc,CAAC,CAE1D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,wBAAwB,EAAE,uBAAuB,GAChE,OAAO,CAAC,OAAO,wBAAwB,EAAE,uBAAuB,CAAC,CAQnE;AAgDD;;;GAGG;AACH,eAAO,MAAM,cAAc,gBAAmB,CAAC;8BAb1B,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/index.ts"],"names":[],"mappings":"AA0CA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AA8ClE;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAEjD;AA6VD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAInE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAK1D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAItE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,wBAAwB,EAAE,cAAc,GACvD,OAAO,CAAC,OAAO,wBAAwB,EAAE,cAAc,CAAC,CAE1D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,wBAAwB,EAAE,uBAAuB,GAChE,OAAO,CAAC,OAAO,wBAAwB,EAAE,uBAAuB,CAAC,CAQnE;8BAwCoB,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC"}

package/dist/server/rsc-entry/render-route.d.ts

@@ -5,12 +5,11 @@
  * pipeline construction. This module owns the steps that happen *after*
  * the pipeline has matched a route and before it commits a response:
  * element-tree build, RSC Flight render, and dispatch to either the SSR
- * HTML path or the RSC payload path. It also handles the
- * synchronous-signal escape hatches (deny / redirect / render error
- * thrown during stream creation) so the entry doesn't carry that logic.
+ * HTML path or the RSC payload path. A deny or redirect captured during the
+ * render is rethrown to the pipeline, which answers it.
  *
  * The function is parameterized over its dependencies — `clientBootstrap`,
- * `clientJsDisabled`, `rootSegment`, `globalError` — so the entry passes
+ * `clientJsDisabled`, `renderDenyFallback`, `globalError` — so the entry passes
  * them in once at handler-construction time and they ride along on every
  * call. No globals, no closures over the entry's createRequestHandler
  * scope.
@@ -20,7 +19,7 @@
 import type { BuildManifest } from '../build-manifest.ts';
 import type { ClientBootstrapConfig } from '../html-injectors.ts';
 import type { InterceptionContext, RouteMatch } from '../pipeline.ts';
-import type { ManifestSegmentNode } from '../route-matcher.ts';
+import type { DenyFallbackRenderer } from './deny-fallback.ts';
 /**
  * Static-per-handler dependencies for `renderRoute` — captured once at
  * handler construction so each per-request call site only has to pass
@@ -30,7 +29,7 @@ export interface RenderRouteDeps {
     clientBootstrap: ClientBootstrapConfig;
     clientJsDisabled: boolean;
     clientSegmentCache: boolean;
-    rootSegment: ManifestSegmentNode;
+    renderDenyFallback: DenyFallbackRenderer;
     buildManifest: BuildManifest;
     globalError?: {
         load: () => Promise<unknown>;

package/dist/server/rsc-entry/render-route.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-route.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/render-route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAW1D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAc/D;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,qBAAqB,CAAC;IACvC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,WAAW,EAAE,mBAAmB,CAAC;IACjC,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAClE;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,UAAU,EACjB,eAAe,EAAE,OAAO,EACxB,IAAI,EAAE,eAAe,EACrB,YAAY,CAAC,EAAE,mBAAmB,GACjC,OAAO,CAAC,QAAQ,CAAC,CAsNnB"}
+{"version":3,"file":"render-route.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/render-route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAS1D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAOtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAM/D;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,qBAAqB,CAAC;IACvC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,kBAAkB,EAAE,oBAAoB,CAAC;IACzC,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAClE;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,UAAU,EACjB,eAAe,EAAE,OAAO,EACxB,IAAI,EAAE,eAAe,EACrB,YAAY,CAAC,EAAE,mBAAmB,GACjC,OAAO,CAAC,QAAQ,CAAC,CA4JnB"}

package/dist/server/rsc-entry/render-signals.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Render signals — the deny / redirect / unhandled-error state one RSC
+ * render captures, and the recorder that writes it.
+ *
+ * Kept apart from `rsc-stream.ts` so the contract carries no Flight runtime:
+ * consumers and tests can hold signals without loading the renderer.
+ *
+ * Design docs: 02-rendering-pipeline.md §"Single-Pass Rendering",
+ *              49-explicit-subsystem-boundaries.md §"C"
+ */
+import type { DenySignal, RedirectSignal } from '../primitives.ts';
+/**
+ * Signal state captured during RSC rendering. Read-only for consumers: only
+ * the render that produced it records into it (`createSignalRecorder`).
+ *
+ * Signals fire asynchronously via `onError` during stream consumption.
+ * The first deny wins; a later redirect replaces an earlier one.
+ *
+ * The two notification channels are values the producer owns and returns,
+ * not callback slots a consumer assigns after the fact. A slot only works if
+ * no `await` separates `renderRscStream()` from the assignment — add one and
+ * an early signal fires into an empty slot with no trace. A promise that has
+ * already resolved, and an `AbortSignal` that is already aborted, carry the
+ * early event to a late reader.
+ */
+export interface RenderSignals {
+    readonly denySignal: DenySignal | null;
+    /**
+     * The first deny that no in-tree catch site could place — no `owners`, so
+     * no boundary may claim its error row and only the re-render fallback can
+     * produce a page for it.
+     *
+     * Tracked apart from `denySignal` because one render can produce both. A
+     * deep page can hoist a 404 to a boundary that will render it while an
+     * outer layout separately throws a 403 nothing matches; whichever lands in
+     * `denySignal` first, the unplaced one still needs the fallback, and
+     * deciding from `denySignal.owners` alone would strand it. See TIM-1356.
+     */
+    readonly unplacedDeny: DenySignal | null;
+    readonly redirectSignal: RedirectSignal | null;
+    /**
+     * Resolves when the first deny or redirect is captured; never rejects.
+     * Consumers race it to react the instant `onError` fires instead of
+     * polling with setTimeout/queueMicrotask.
+     */
+    readonly captured: Promise<void>;
+    /**
+     * Aborted when the first unhandled (non-signal) error is captured. Halts
+     * Flight data injection into the inline stream (TIM-938).
+     */
+    readonly unhandledError: AbortSignal;
+}
+/** The write side of `RenderSignals`, held by the render that captures. */
+export interface SignalRecorder {
+    readonly signals: RenderSignals;
+    deny(signal: DenySignal): void;
+    redirect(signal: RedirectSignal): void;
+    unhandledError(): void;
+}
+/**
+ * Create the signal state for one render. `renderRscStream()` records into
+ * it from Flight's `onError`; tests record into it to stand in for Flight.
+ */
+export declare function createSignalRecorder(): SignalRecorder;
+//# sourceMappingURL=render-signals.d.ts.map

package/dist/server/rsc-entry/render-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-signals.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/render-signals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEnE;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IACvC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,YAAY,EAAE,UAAU,GAAG,IAAI,CAAC;IACzC,QAAQ,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC;IAC/C;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC;CACtC;AAED,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;IACvC,cAAc,IAAI,IAAI,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAwCrD"}

package/dist/server/rsc-entry/revalidate-renderer.d.ts

@@ -26,21 +26,9 @@
  * design/13-security.md §"Server actions silently bypass middleware".
  */
 import type { BuildManifest } from '../build-manifest.ts';
-import type { RouteMatcher } from '../pipeline.ts';
-import type { RevalidateRenderer } from '../actions.ts';
-import { type CoerceSegmentParamsFn } from './action-middleware-runner.ts';
-/**
- * Sentinel thrown when revalidation cannot proceed because middleware
- * returned a short-circuit `Response` (a non-redirect HTTP response that
- * we cannot translate back to an element tree). `executeAction` catches
- * this and drops the revalidation — the action result is still delivered,
- * but no `_tree` is piggybacked onto the response. The matching name
- * `RevalidationDropped` is exported so callers can identify it via
- * `instanceof` without leaking the message text to clients.
- */
-export declare class RevalidationDropped extends Error {
-    constructor(message: string);
-}
+import type { RouteMatch, RouteMatcher } from '../pipeline.ts';
+import { type RevalidateRenderer } from '../actions.ts';
+import type { CoercedParams } from '../../shared/param-value.ts';
 /** Result of validating a `revalidatePath()` argument. */
 type PathValidation = {
     ok: true;
@@ -68,6 +56,8 @@ type PathValidation = {
  * same shape the page pipeline matches.
  */
 export declare function validateRevalidatePath(path: unknown): PathValidation;
+/** Coerce a matched route's raw segment params via its `app/schema.ts` codecs. */
+export type CoerceSegmentParamsFn = (match: RouteMatch) => Promise<CoercedParams>;
 /** Dependencies for the revalidate renderer factory. */
 export interface RevalidateRendererDeps {
     matchRoute: RouteMatcher;
@@ -80,7 +70,7 @@ export interface RevalidateRendererDeps {
  * The returned renderer:
  *   1. Validates the requested path.
  *   2. Matches the canonicalized path against the route tree.
- *   3. Coerces segment params via the matched chain's `params.ts` codecs.
+ *   3. Coerces segment params via the `app/schema.ts` codecs.
  *   4. Runs the matched route's `middleware.ts` chain inside a fresh
  *      `runWithRequestContext` scope (via `runMiddlewareForAction`).
  *      Deny/redirect signals are re-thrown so `executeAction` can apply

package/dist/server/rsc-entry/revalidate-renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"revalidate-renderer.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/revalidate-renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAI1D,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAK/D,OAAO,KAAK,EAAE,kBAAkB,EAAsB,MAAM,eAAe,CAAC;AAE5E,OAAO,EAA0B,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAGnG;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED,0DAA0D;AAC1D,KAAK,cAAc,GACf;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC9C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,cAAc,CAiCpE;AAwBD,wDAAwD;AACxD,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,YAAY,CAAC;IACzB,mBAAmB,EAAE,qBAAqB,CAAC;IAC3C,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,sBAAsB,GAC3B,CAAC,GAAG,EAAE,OAAO,KAAK,kBAAkB,CA4KtC"}
+{"version":3,"file":"revalidate-renderer.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/revalidate-renderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAK1D,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAM/D,OAAO,EAEL,KAAK,kBAAkB,EAExB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAKjE,0DAA0D;AAC1D,KAAK,cAAc,GACf;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC9C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,cAAc,CAiCpE;AAwBD,kFAAkF;AAClF,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AAElF,wDAAwD;AACxD,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,YAAY,CAAC;IACzB,mBAAmB,EAAE,qBAAqB,CAAC;IAC3C,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,sBAAsB,GAC3B,CAAC,GAAG,EAAE,OAAO,KAAK,kBAAkB,CAiLtC"}

package/dist/server/rsc-entry/rsc-payload.d.ts

@@ -21,7 +21,7 @@
 import type { LayoutComponentEntry } from '../route-element-builder.ts';
 import type { ManifestSegmentNode } from '../route-matcher.ts';
 import type { SlotSkipEntry } from '../slot-resolver.ts';
-import type { RenderSignals } from './rsc-stream.ts';
+import type { RenderSignals } from './render-signals.ts';
 /**
  * Build an RSC payload Response for a client-side navigation request.
  *
@@ -35,11 +35,15 @@ import type { RenderSignals } from './rsc-stream.ts';
  * plus one macrotask turn. Nothing is held for it. A signal that lands
  * inside the window still gets a server-level answer — a redirect response,
  * the fallback deny page, the hard-navigate envelope — because the race
- * below and the one timer turn after it deliver it for free. A signal that
+ * below and the one timer turn after it deliver it for free. This function
+ * reports that signal rather than answering it: it cancels the stream and
+ * rethrows, and the pipeline's outcome translator builds the redirect or
+ * calls the deny fallback (`rsc-entry/deny-fallback.ts`), exactly as for a
+ * signal thrown out of render (design/49 §"C"). A signal that
  * lands after it is a row in the stream, and the client's boundaries answer
  * it. Waiting for the shell components to settle (TIM-1045, TIM-1208) made
  * the payload path pretend to a status contract it could not keep for
  * nested components, and was removed in TIM-1495.
  */
-export declare function buildRscPayloadResponse(req: Request, rscStream: ReadableStream<Uint8Array>, signals: RenderSignals, segments: ManifestSegmentNode[], layoutComponents: LayoutComponentEntry[], responseHeaders: Headers, skippedSegments?: string[], slotSkipInfo?: SlotSkipEntry[]): Promise<Response>;
+export declare function buildRscPayloadResponse(rscStream: ReadableStream<Uint8Array>, signals: RenderSignals, segments: ManifestSegmentNode[], layoutComponents: LayoutComponentEntry[], responseHeaders: Headers, skippedSegments?: string[], slotSkipInfo?: SlotSkipEntry[]): Promise<Response>;
 //# sourceMappingURL=rsc-payload.d.ts.map

package/dist/server/rsc-entry/rsc-payload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rsc-payload.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/rsc-payload.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAOzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAWrD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,OAAO,EACZ,SAAS,EAAE,cAAc,CAAC,UAAU,CAAC,EACrC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,gBAAgB,EAAE,oBAAoB,EAAE,EACxC,eAAe,EAAE,OAAO,EACxB,eAAe,CAAC,EAAE,MAAM,EAAE,EAC1B,YAAY,CAAC,EAAE,aAAa,EAAE,GAC7B,OAAO,CAAC,QAAQ,CAAC,CAwPnB"}
+{"version":3,"file":"rsc-payload.d.ts","sourceRoot":"","sources":["../../../src/server/rsc-entry/rsc-payload.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAOzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAWzD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,uBAAuB,CAC3C,SAAS,EAAE,cAAc,CAAC,UAAU,CAAC,EACrC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,mBAAmB,EAAE,EAC/B,gBAAgB,EAAE,oBAAoB,EAAE,EACxC,eAAe,EAAE,OAAO,EACxB,eAAe,CAAC,EAAE,MAAM,EAAE,EAC1B,YAAY,CAAC,EAAE,aAAa,EAAE,GAC7B,OAAO,CAAC,QAAQ,CAAC,CAuNnB"}

package/dist/server/rsc-entry/rsc-stream.d.ts

@@ -2,63 +2,18 @@
  * RSC Stream Renderer — Creates the RSC Flight stream with signal tracking.
  *
  * Wraps `renderToReadableStream` from `@vitejs/plugin-rsc/rsc` and captures
- * render-phase signals (DenySignal, RedirectSignal, RenderError) thrown by
+ * render-phase signals (DenySignal, RedirectSignal) thrown by
  * components during streaming. These signals are tracked in a shared
- * `RenderSignals` object so the caller can decide the HTTP response.
+ * read-only `RenderSignals` object so the caller can decide the HTTP response.
  *
  * Design docs: 02-rendering-pipeline.md §"Single-Pass Rendering",
  *              13-security.md §"Errors don't leak"
  */
 import type { RscPayloadRoot } from '../../shared/payload-root.ts';
 import { type DenyPageEntry } from '../deny-boundary.ts';
-import { DenySignal, RedirectSignal } from '../primitives.ts';
-/**
- * Mutable signal state captured during RSC rendering.
- *
- * Signals fire asynchronously via `onError` during stream consumption.
- * The first signal of each type wins — subsequent signals are ignored.
- *
- * `onSignal` is an optional callback fired when a DenySignal or
- * RedirectSignal is captured. Consumers use it with Promise.race to
- * react immediately instead of polling with setTimeout/queueMicrotask.
- */
-export interface RenderSignals {
-    denySignal: DenySignal | null;
-    /**
-     * The first deny that no in-tree catch site could place — no `owners`, so
-     * no boundary may claim its error row and only the re-render fallback can
-     * produce a page for it.
-     *
-     * Tracked apart from `denySignal` because one render can produce both. A
-     * deep page can hoist a 404 to a boundary that will render it while an
-     * outer layout separately throws a 403 nothing matches; whichever lands in
-     * `denySignal` first, the unplaced one still needs the fallback, and
-     * deciding from `denySignal.owners` alone would strand it. See TIM-1356.
-     */
-    unplacedDeny: DenySignal | null;
-    redirectSignal: RedirectSignal | null;
-    renderError: {
-        error: unknown;
-        status: number;
-    } | null;
-    /**
-     * The last unhandled error seen by RSC onError that isn't a signal.
-     * Used as a fallback when SSR fails (SsrStreamError) but no structured
-     * signal was captured — provides the original error for the error page
-     * instead of relying on SsrStreamError.cause extraction.
-     *
-     * NOT used for page-level error detection (that would break Suspense
-     * error isolation). Only consumed when SSR actually fails.
-     */
-    lastUnhandledError: unknown | null;
-    /** Callback fired when a redirect or deny signal is captured in onError. */
-    onSignal?: () => void;
-    /** Callback fired when an unhandled error (non-signal) is captured. Used
-     *  to halt Flight data injection into the inline stream. */
-    onUnhandledError?: () => void;
-}
+import { type RenderSignals } from './render-signals.ts';
 export interface RscStreamResult {
-    rscStream: ReadableStream<Uint8Array> | undefined;
+    rscStream: ReadableStream<Uint8Array>;
     signals: RenderSignals;
 }
 /**
@@ -67,10 +22,10 @@ export interface RscStreamResult {
  * The stream serializes server components as rendered output and client
  * components ("use client") as serialized references with module ID + export name.
  *
- * DenySignal detection: deny() in sync components throws during
- * renderToReadableStream (caught in try/catch). deny() in async components
- * fires onError during stream consumption. Signals are captured in the
- * returned `signals` object for the caller to handle.
+ * Signals are captured in the returned `signals` object for the caller to
+ * handle. Every one arrives through `onError`, never as a throw from this
+ * call: Flight starts rendering in a microtask after the stream is created,
+ * so even a component that throws synchronously is reported asynchronously.
  */
 export declare function renderRscStream(payload: RscPayloadRoot, req: Request, leafDenyChain?: DenyPageEntry[]): RscStreamResult;
 //# sourceMappingURL=rsc-stream.d.ts.map