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

package/src/server/prebuilt-runtime.ts

@@ -38,11 +38,11 @@ import { createElement } from 'react';
 import { requestContextAls, type RequestContextStore } from './als-registry.ts';
 import type { CoercedParams } from '../shared/param-value.ts';
 import type { SlotParamsRecord } from '../shared/slot-params.ts';
-import { computeComponentCacheKey, splitSlotProps, tryCanonicalize } from './prebuilt/cache-key.ts';
+import { computeComponentCacheKey, tryCanonicalize } from './prebuilt/cache-key.ts';
 import {
-  isChildrenSlotOutletElement,
   resolveSlotNames,
   prepareSlotRender,
+  withoutChildrenOutlet,
   wrapInSlotsProvider,
 } from './prebuilt/slots.ts';
 import {
@@ -51,11 +51,12 @@ import {
   shouldCheckKeyDiscipline,
 } from './prebuilt/key-discipline.ts';
 import {
+  createCaptureScope,
   isCaptureActive,
   noteWrapperRender,
-  beginCapture,
-  endCapture,
+  type NestedWrapperRender,
 } from './prebuilt/capture-state.ts';
+import { hasRuntimeLifetime, resolveTags, warnNestingClamps } from './prebuilt/lifetime.ts';
 import {
   hasPrebuiltPayloadSource,
   lookupPrebuiltPayload,
@@ -64,6 +65,10 @@ import {
 } from './prebuilt/payload-source.ts';
 import { lookupOverlay, storeOverlayEntry, overlayKey } from './prebuilt/overlay.ts';
 import { getWaitUntil } from './waituntil-bridge.ts';
+import { runBackgroundFlight } from './pipeline-helpers.ts';
+import { runOutsideReactCacheScope } from './react-cache-scope.ts';
+import { readAllBytesWithDeadline } from './stream-utils.ts';
+import { DEFAULT_RENDER_TIMEOUT_MS } from './render-timeout.ts';
 import { createSingleflight } from '../cache/singleflight.ts';
 import {
   currentInvalidationEpoch,
@@ -72,10 +77,12 @@ import {
 } from '../cache/invalidation-epoch.ts';
 
 /** Default timeout for component re-renders (overridden by renderTimeoutMs). */
-const DEFAULT_COMPONENT_TIMEOUT_MS = 30_000;
+const DEFAULT_COMPONENT_TIMEOUT_MS = DEFAULT_RENDER_TIMEOUT_MS;
 
 /** Singleflight for component re-renders (inline and background). */
-let componentSingleflight = createSingleflight({ timeoutMs: DEFAULT_COMPONENT_TIMEOUT_MS });
+let componentSingleflight = createSingleflight({
+  timeoutMs: DEFAULT_COMPONENT_TIMEOUT_MS,
+});
 let componentTimeoutMs = DEFAULT_COMPONENT_TIMEOUT_MS;
 
 /**
@@ -89,6 +96,14 @@ export function setComponentRefreshTimeout(timeoutMs: number): void {
 
 let warnedNoWaitUntil = false;
 
+/**
+ * (outer, inner) pairs already warned about by request-time captures.
+ * Process-wide: re-renders of a hot component repeat, and the warning is
+ * about the code, not the request. Bounded by the number of wrapped
+ * components in the app.
+ */
+const warnedNestingPairs = new Set<string>();
+
 /**
  * Options captured from the `cache.component(fn, opts)` call site.
  *
@@ -205,12 +220,7 @@ function isSlotRenderKeyable(dataProps: Record<string, unknown>): boolean {
   if (!store) return false;
   const keyParams = resolveKeyParams(store);
   if (keyParams === null) return false;
-  let keyProps = dataProps;
-  if (isChildrenSlotOutletElement(keyProps.children)) {
-    const { children: _children, ...rest } = keyProps;
-    keyProps = rest;
-  }
-  return computeComponentCacheKey(keyProps, keyParams) !== null;
+  return computeComponentCacheKey(withoutChildrenOutlet(dataProps), keyParams) !== null;
 }
 
 /** Wrap payload bytes as a single-chunk ReadableStream for the decoder. */
@@ -223,28 +233,6 @@ function bytesToStream(bytes: Uint8Array): ReadableStream<Uint8Array> {
   });
 }
 
-/** Whether the component has a runtime lifetime (ttl or tags). */
-function hasRuntimeLifetime(options: PrebuiltComponentOptions): boolean {
-  return options.ttl !== undefined || (options.tags !== undefined && options.tags !== null);
-}
-
-/**
- * Resolve tags from options (may be static array or function of props).
- * Function-form tags receive DATA props only — slot props are excluded so
- * the tags fn never sees SlotOutlet placeholders (capture paths pass
- * placeholder-substituted props) and tags stay deterministic per key.
- */
-function resolveTags(options: PrebuiltComponentOptions, props: Record<string, unknown>): string[] {
-  if (!options.tags) return [];
-  if (Array.isArray(options.tags)) return options.tags;
-  const slots = options.slots;
-  // The split cannot fail here — capture paths pass framework-built shell
-  // props — but stay total: fall back to the props as given.
-  const fnProps =
-    slots && slots.length > 0 ? (splitSlotProps(props, slots)?.dataProps ?? props) : props;
-  return options.tags(fnProps);
-}
-
 // ─── Slot components (TIM-1173) ──────────────────────────────────────────
 
 /**
@@ -324,6 +312,12 @@ function getCaptureTimeoutMs(): number {
   return componentTimeoutMs;
 }
 
+/** A request-time capture: the payload and the wrappers baked into it. */
+interface CapturedPayload {
+  bytes: Uint8Array;
+  nested: NestedWrapperRender[];
+}
+
 /**
  * Render a component in isolation and capture its flight payload bytes.
  * Used for inline re-renders (tombstone/miss) and SWR background re-renders.
@@ -334,15 +328,19 @@ function getCaptureTimeoutMs(): number {
 async function captureComponentPayload(
   id: string,
   component: ServerComponent,
-  props: Record<string, unknown>
-): Promise<Uint8Array> {
+  props: Record<string, unknown>,
+  options: PrebuiltComponentOptions
+): Promise<CapturedPayload> {
   const { renderToReadableStream } = requireRscFunctions();
   const element = createElement(component as RenderableComponent, props);
-  // Activate capture state so nested cache.component wrappers render live
-  // (bake flat into this entry) per design/45 §Nesting Semantics.
-  // beginCapture/endCapture MUST be in the same try/finally to prevent
-  // leaked capture state on early throws.
-  let renderErrored = false;
+  // Render inside a capture scope so nested cache.component wrappers render
+  // live (bake flat into this entry) per design/45 §Nesting Semantics. The
+  // scope is this capture's async context only — concurrent requests
+  // rendering the same or other wrapped components never see it (TIM-1536).
+  const capture = createCaptureScope(id, options, props);
+  // The first error the capture render hit, kept so a failed capture
+  // reports the component's own error rather than a stand-in.
+  let renderError: { error: unknown } | undefined;
 
   // Key-discipline diagnostic (design/45 §Enforcement): proxy the ALS
   // store to detect request-context reads during the capture render.
@@ -350,59 +348,31 @@ async function captureComponentPayload(
   const store = requestContextAls.getStore();
   const discipline = store && shouldCheckKeyDiscipline(id) ? createKeyDisciplineProxy(store) : null;
 
-  const doCapture = async (): Promise<Uint8Array> => {
-    beginCapture(id);
-    try {
-      const stream: ReadableStream<Uint8Array> = renderToReadableStream(element, {
-        onError() {
-          renderErrored = true;
-          return '';
-        },
-      });
-      const reader = stream.getReader();
-      const chunks: Uint8Array[] = [];
-      let totalLength = 0;
-      const deadline = Date.now() + getCaptureTimeoutMs();
-      try {
-        for (;;) {
-          const remaining = deadline - Date.now();
-          if (remaining <= 0) {
-            throw new Error(
-              `[timber] component re-render capture exceeded ${getCaptureTimeoutMs()}ms`
-            );
-          }
-          let timer: ReturnType<typeof setTimeout> | undefined;
-          const { done, value } = await Promise.race([
-            reader.read(),
-            new Promise<never>((_, reject) => {
-              timer = setTimeout(
-                () => reject(new Error(`[timber] component re-render stream read timed out`)),
-                remaining
-              );
-            }),
-          ]);
-          clearTimeout(timer);
-          if (done) break;
-          chunks.push(value);
-          totalLength += value.byteLength;
-        }
-      } finally {
-        reader.cancel().catch(() => {});
-      }
-      if (renderErrored) {
-        throw new Error('[timber] component re-render produced error rows — not caching');
-      }
-      const result = new Uint8Array(totalLength);
-      let offset = 0;
-      for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.byteLength;
-      }
-      return result;
-    } finally {
-      endCapture();
-    }
-  };
+  const doCapture = (): Promise<Uint8Array> =>
+    capture.run(async () => {
+      // Outside the request's React.cache scope: this payload is stored
+      // cross-request (and the capture is singleflight-coalesced across
+      // requests), so it must not bake in values memoized for the request
+      // that happened to trigger it. Flight gives the capture its own
+      // per-render cache instead (TIM-1529).
+      const stream: ReadableStream<Uint8Array> = runOutsideReactCacheScope(() =>
+        renderToReadableStream(element, {
+          onError(error: unknown) {
+            renderError ??= { error };
+            return '';
+          },
+        })
+      );
+      const bytes = await readAllBytesWithDeadline(
+        stream,
+        getCaptureTimeoutMs(),
+        '[timber] component re-render capture'
+      );
+      // Error rows are never cached. The component's own error is what
+      // failed, so it is what the caller logs and reports.
+      if (renderError) throw renderError.error;
+      return bytes;
+    });
 
   const bytes = discipline
     ? await requestContextAls.run(discipline.proxy, doCapture)
@@ -412,7 +382,28 @@ async function captureComponentPayload(
     emitKeyDisciplineWarning(id, discipline.accessedApis);
   }
 
-  return bytes;
+  return { bytes, nested: capture.nestedRenders() };
+}
+
+/**
+ * Store a captured entry in the overlay, then say which embedded
+ * components it clamps (design/45 §Nesting Semantics, TIM-1545). The
+ * warning follows the store: a capture that is discarded (aborted,
+ * invalidated mid-render, failed store) holds no clamped copy, and must
+ * not spend the pair's one warning.
+ */
+async function storeCapturedEntry(
+  id: string,
+  cacheKey: string,
+  captured: CapturedPayload,
+  options: PrebuiltComponentOptions,
+  tags: string[],
+  hasSeed: boolean
+): Promise<void> {
+  await storeOverlayEntry(id, cacheKey, captured.bytes, { ttl: options.ttl, tags, hasSeed });
+  warnNestingClamps({ id, options, tags }, captured.nested, warnedNestingPairs, (m) =>
+    console.warn(m)
+  );
 }
 
 /**
@@ -435,7 +426,7 @@ async function inlineRerender(
   try {
     const payload = await componentSingleflight.do(sfKey, async (signal) => {
       const startEpoch = currentInvalidationEpoch();
-      const bytes = await captureComponentPayload(id, component, props);
+      const captured = await captureComponentPayload(id, component, props, options);
       // Skip the store if aborted (singleflight timeout) or if the
       // key/tags were invalidated while rendering (TIM-1028 guard).
       if (
@@ -443,13 +434,9 @@ async function inlineRerender(
         hasRuntimeLifetime(options) &&
         !wasInvalidatedSince(startEpoch, oKey, tags)
       ) {
-        await storeOverlayEntry(id, cacheKey, bytes, {
-          ttl: options.ttl,
-          tags,
-          hasSeed,
-        });
+        await storeCapturedEntry(id, cacheKey, captured, options, tags, hasSeed);
       }
-      return bytes;
+      return captured.bytes;
     });
     return await revivePayload(id, payload, outcome);
   } catch (error) {
@@ -461,10 +448,12 @@ async function inlineRerender(
 /**
  * Snapshot the request context values needed for a background re-render.
  * Creates a FRESH store with copied values — the original ALS store is
- * not referenced after capture.
+ * not referenced after capture. The `Request` itself is shared, not
+ * copied: the re-render reports its failure against it.
  */
 function snapshotRequestContext(store: RequestContextStore): RequestContextStore {
   return {
+    request: store.request,
     headers: new Headers(store.headers),
     originalHeaders: new Headers(store.originalHeaders),
     cookieHeader: store.cookieHeader,
@@ -499,19 +488,28 @@ function backgroundRerender(
 
   const work = requestContextAls.run(snapshot, () =>
     componentSingleflight
-      .do(sfKey, async (signal) => {
-        const bytes = await captureComponentPayload(id, component, props);
-        if (!signal.aborted && !wasInvalidatedSince(startEpoch, oKey, tags)) {
-          await storeOverlayEntry(id, cacheKey, bytes, {
-            ttl: options.ttl,
-            tags,
-            hasSeed,
-          });
-        }
-      })
-      .catch((error) => {
-        console.error(`[timber] cache.component background re-render failed for "${id}":`, error);
-      })
+      // The stale payload already answered the request, so nothing else sees
+      // a failure here: logged and reported once per flight. Inline re-render
+      // and revive failures are only logged: a live render answers instead.
+      .do(sfKey, (signal) =>
+        runBackgroundFlight(
+          signal,
+          async () => {
+            const captured = await captureComponentPayload(id, component, props, options);
+            if (!signal.aborted && !wasInvalidatedSince(startEpoch, oKey, tags)) {
+              await storeCapturedEntry(id, cacheKey, captured, options, tags, hasSeed);
+            }
+          },
+          (error) =>
+            console.error(
+              `[timber] cache.component background re-render failed for "${id}":`,
+              error
+            )
+        )
+      )
+      // runBackgroundFlight never rejects; only the singleflight timeout,
+      // which it already reported, can reject the flight.
+      .catch(() => {})
   );
 
   if (waitUntil) {
@@ -564,12 +562,10 @@ async function tryRevivePayload(
   // unkey the render there any more than on the non-slot path (codex P2
   // on PR #890).
   const allProps = (props ?? {}) as Record<string, unknown>;
-  let keyProps = keyPropsOverride ?? allProps;
-  if (isChildrenSlotOutletElement(keyProps.children)) {
-    const { children: _children, ...rest } = keyProps;
-    keyProps = rest;
-  }
-  const cacheKey = computeComponentCacheKey(keyProps, keyParams);
+  const cacheKey = computeComponentCacheKey(
+    withoutChildrenOutlet(keyPropsOverride ?? allProps),
+    keyParams
+  );
   if (cacheKey === null) return null;
 
   const outcome =
@@ -717,16 +713,16 @@ export function __prebuilt<C extends ServerComponent>(
   registry.set(id, { id, component, options });
 
   const wrapper = async (props: Parameters<C>[0]) => {
-    // Build-time only: report this render to the active capture pass —
-    // cycle detection (throws) and nesting-clamp warnings (design/45
-    // §Nesting Semantics). A single null-check at request time.
-    noteWrapperRender(id, options);
+    // Report this render to the enclosing capture, if any — cycle
+    // detection (throws) and nesting-clamp warnings (design/45 §Nesting
+    // Semantics). Outside a capture this is a single store lookup.
+    noteWrapperRender(id, options, props as Record<string, unknown>);
     if (isCaptureActive()) {
-      // Nested wrapper inside a build-time capture: render live so the
-      // subtree bakes flat into the enclosing entry (design/45 §Nesting).
+      // Nested wrapper inside a capture: render live so the subtree
+      // bakes flat into the enclosing entry (design/45 §Nesting).
       // This deliberately bypasses fallbackOnMissingSegmentParams: false —
       // that option means "never serve non-prebuilt content", and a
-      // build-time render IS prebuilt content; throwing here would
+      // capture render IS the cached content; throwing here would
       // spuriously fail the outer entry (codex P2 on PR #836).
       return createElement(component as RenderableComponent, props as Record<string, unknown>);
     }

package/src/server/primitives.ts

@@ -1,4 +1,4 @@
-// Server-side primitives: deny, redirect, redirectExternal, RenderError, waitUntil, SsrStreamError
+// Server-side primitives: deny, redirect, redirectExternal, waitUntil
 //
 // These are the core runtime signals that components, middleware, and access gates
 // use to control request flow. See design/10-error-handling.md.
@@ -8,6 +8,7 @@ import { getWaitUntil as _getWaitUntil } from './waituntil-bridge.ts';
 import { isDebug } from './debug.ts';
 import { getRequestSearchString } from './request-context.ts';
 import { mergePreservedSearchParams } from '../shared/merge-search-params.ts';
+import { DENY_BRAND, REDIRECT_BRAND } from './signal-identity.ts';
 import {
   assertRelativeRedirectPath,
   validateExternalRedirectUrl,
@@ -97,71 +98,19 @@ function warnIfNotSerializable(data: unknown, callerName: string): void {
   if (issue) {
     console.warn(
       `[timber] ${callerName}: ${issue}. ` +
-        'Data passed to deny() or RenderError must be JSON-serializable because ' +
+        'Data passed to deny() must be JSON-serializable because ' +
         'the post-flush path uses JSON.stringify, not React Flight.'
     );
   }
 }
 
-// ─── Signal branding ────────────────────────────────────────────────────────
-//
-// Catch sites must NOT use `instanceof` on these classes. In dev, an HMR
-// program reload clears the RSC module cache; a request that is mid-render
-// still holds the catch sites from the old evaluation of this module while
-// user code loaded after the reload throws from the new one. The two
-// evaluations are distinct classes, so `instanceof` fails and a correct
-// deny() falls through every catch site as an unhandled 500 (TIM-1499).
-//
-// Each class stamps a `Symbol.for` brand on its instances in the constructor.
-// `Symbol.for` keys live in the realm-wide symbol registry, so every
-// evaluation of this module — and every module graph in the same process —
-// agrees on the key. The `is*` predicates below check the brand and are the
-// only supported way to detect a signal. The classes themselves are NOT
-// anchored on globalThis: a re-evaluated module must hand out its own
-// (possibly updated) class, not a stale one.
-//
-// See design/18-build-system.md §"Dev Mode: Signal Identity Across Program Reloads".
-
-const DENY_BRAND: unique symbol = Symbol.for('timber:signal.deny');
-const REDIRECT_BRAND: unique symbol = Symbol.for('timber:signal.redirect');
-const RENDER_ERROR_BRAND: unique symbol = Symbol.for('timber:signal.render-error');
-const SSR_STREAM_ERROR_BRAND: unique symbol = Symbol.for('timber:signal.ssr-stream-error');
-
-function hasBrand(value: unknown, brand: symbol): boolean {
-  return typeof value === 'object' && value !== null && brand in value;
-}
-
-/** True for any `DenySignal`, regardless of which module evaluation created it. */
-export function isDenySignal(error: unknown): error is DenySignal {
-  return hasBrand(error, DENY_BRAND);
-}
-
-/** True for any `RedirectSignal`, regardless of which module evaluation created it. */
-export function isRedirectSignal(error: unknown): error is RedirectSignal {
-  return hasBrand(error, REDIRECT_BRAND);
-}
-
-/** True for any `RenderError`, regardless of which module evaluation created it. */
-export function isRenderError(error: unknown): error is RenderError {
-  return hasBrand(error, RENDER_ERROR_BRAND);
-}
-
-/**
- * True for any `SsrStreamError`. This one also crosses Vite environments:
- * it is thrown in SSR and caught in RSC, which are separate module graphs in
- * the same process — the brand is the only identity the two share.
- */
-export function isSsrStreamError(error: unknown): error is SsrStreamError {
-  return hasBrand(error, SSR_STREAM_ERROR_BRAND);
-}
-
 // ─── DenySignal ─────────────────────────────────────────────────────────────
 
 /**
  * Render-phase signal thrown by `deny()`. Caught by the framework to produce
  * the correct HTTP status code (segment context) or graceful degradation (slot context).
  *
- * Detect with `isDenySignal()`, never `instanceof` — see "Signal branding" above.
+ * Detect with `isDenySignal()`, never `instanceof` — see "Signal branding" in signal-identity.ts.
  */
 export class DenySignal extends Error {
   readonly [DENY_BRAND] = true;
@@ -256,9 +205,9 @@ export interface DenyOptions {
  * deny(404, { dangerouslyPassData: { resourceId: params.id } }) // explicit client opt-in
  * ```
  *
- * Accepts any 4xx or 5xx status code. This replaces the need for
- * `throw new RenderError(...)` in user code — RenderError is now an
- * internal pipeline detail.
+ * Accepts any 4xx or 5xx status code — it is also how a page renders a 5xx
+ * status file with data. An unplanned throw needs no primitive: it renders
+ * the error page with a 500.
  *
  * @param status - HTTP status code (4xx or 5xx). Default: 403.
  * @param options - Optional message and/or data to pass to the client.
@@ -284,7 +233,7 @@ export { RedirectType } from '../shared/redirect-type.ts';
  * Render-phase signal thrown by `redirect()` and `redirectExternal()`.
  * Caught by the framework to produce a 3xx response or client-side navigation.
  *
- * Detect with `isRedirectSignal()`, never `instanceof` — see "Signal branding" above.
+ * Detect with `isRedirectSignal()`, never `instanceof` — see "Signal branding" in signal-identity.ts.
  */
 export class RedirectSignal extends Error {
   readonly [REDIRECT_BRAND] = true;
@@ -301,33 +250,6 @@ export class RedirectSignal extends Error {
 
 // ─── Signal Detection ───────────────────────────────────────────────────────
 
-/**
- * Returns true if the error is a framework control-flow signal (RedirectSignal
- * or DenySignal) rather than a genuine application error. Works both for direct
- * instances (RSC-side) and deserialized digest errors (SSR cross-boundary).
- *
- * See also: isFrameworkSignalError() in client/browser-dev.ts (client-only).
- */
-export function isControlFlowSignal(error: unknown): boolean {
-  if (isDenySignal(error) || isRedirectSignal(error)) {
-    return true;
-  }
-  if (error && typeof error === 'object') {
-    const digest = (error as { digest?: unknown }).digest;
-    if (typeof digest === 'string') {
-      try {
-        const parsed = JSON.parse(digest) as { type?: unknown } | null;
-        if (parsed && typeof parsed === 'object') {
-          return parsed.type === 'redirect' || parsed.type === 'deny';
-        }
-      } catch {
-        // Not valid digest JSON
-      }
-    }
-  }
-  return false;
-}
-
 /**
  * Options for redirect() — alternative to passing a bare status code.
  */
@@ -420,61 +342,6 @@ export function redirectExternal(url: string, allowList: string[], status: numbe
   throw new RedirectSignal(canonicalUrl, status);
 }
 
-// ─── RenderError ────────────────────────────────────────────────────────────
-
-/**
- * Typed digest that crosses the RSC → client boundary.
- * The `code` identifies the error class; `data` carries JSON-serializable context.
- */
-export interface RenderErrorDigest<
-  TCode extends string = string,
-  TData extends JsonSerializable = JsonSerializable,
-> {
-  code: TCode;
-  data: TData;
-}
-
-/**
- * Typed throw for render-phase errors that carry structured context to error boundaries.
- *
- * The `digest` (code + data) is serialized into the RSC stream separately from the
- * Error instance — only the digest crosses the RSC → client boundary.
- *
- * @example
- * ```ts
- * throw new RenderError('PRODUCT_NOT_FOUND', {
- *   title: 'Product not found',
- *   resourceId: params.id,
- * })
- * ```
- *
- * Detect with `isRenderError()`, never `instanceof` — see "Signal branding" above.
- */
-export class RenderError<
-  TCode extends string = string,
-  TData extends JsonSerializable = JsonSerializable,
-> extends Error {
-  readonly [RENDER_ERROR_BRAND] = true;
-  readonly code: TCode;
-  readonly digest: RenderErrorDigest<TCode, TData>;
-  readonly status: number;
-
-  constructor(code: TCode, data: TData, options?: { status?: number }) {
-    super(`RenderError: ${code}`);
-    this.name = 'RenderError';
-    this.code = code;
-    this.digest = { code, data };
-
-    warnIfNotSerializable(data, 'RenderError');
-
-    const status = options?.status ?? 500;
-    if (status < 400 || status > 599) {
-      throw new Error(`RenderError status must be 4xx or 5xx, got ${status}.`);
-    }
-    this.status = status;
-  }
-}
-
 // ─── waitUntil ──────────────────────────────────────────────────────────────
 
 // Intentional per-app singleton — warn-once flag that persists for the
@@ -515,30 +382,3 @@ export function waitUntil(promise: Promise<unknown>): void {
 export function _resetWaitUntilWarning(): void {
   _waitUntilWarned = false;
 }
-
-// ─── SsrStreamError ─────────────────────────────────────────────────────────
-
-/**
- * Error thrown when SSR's renderToReadableStream fails due to an error
- * in the decoded RSC stream (e.g., uncontained slot errors).
- *
- * The RSC entry checks for this error type in its catch block to avoid
- * re-executing server components via renderDenyPage. Instead, it renders
- * a bare deny/error page without layout wrapping.
- *
- * Defined in primitives.ts (not ssr-entry.ts) because ssr-entry.ts imports
- * react-dom/server which cannot be loaded in the RSC environment.
- *
- * Detect with `isSsrStreamError()` — it is thrown in the SSR environment and
- * caught in RSC, so `instanceof` never matches. See "Signal branding" above.
- */
-export class SsrStreamError extends Error {
-  readonly [SSR_STREAM_ERROR_BRAND] = true;
-  override readonly cause: unknown;
-
-  constructor(message: string, cause: unknown) {
-    super(message);
-    this.name = 'SsrStreamError';
-    this.cause = cause;
-  }
-}