@timber-js/app 0.2.0-alpha.20 → 0.2.0-alpha.201

package/src/server/primitives.ts

@@ -3,9 +3,15 @@
 // These are the core runtime signals that components, middleware, and access gates
 // use to control request flow. See design/10-error-handling.md.
 
-import type { JsonSerializable } from './types.js';
-import { getWaitUntil as _getWaitUntil } from './waituntil-bridge.js';
-import { isDebug } from './debug.js';
+import type { JsonSerializable } from './types.ts';
+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 {
+  assertRelativeRedirectPath,
+  validateExternalRedirectUrl,
+} from '../shared/href-validation.ts';
 
 // ─── Dev-mode validation ────────────────────────────────────────────────────
 
@@ -97,16 +103,95 @@ function warnIfNotSerializable(data: unknown, callerName: string): void {
   }
 }
 
+// ─── 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.
  */
 export class DenySignal extends Error {
+  readonly [DENY_BRAND] = true;
   readonly status: number;
   readonly data: JsonSerializable | undefined;
 
+  /**
+   * Ordered list of segment keys that own matching deny pages for this
+   * signal, best match first. Present = addressed (a boundary should
+   * render it); absent = unplaced (the re-render fallback serves it).
+   *
+   * In-tree hoists stamp a single-element list (`[entry.ownerKey]`) —
+   * identical to the pre-TIM-1450 `ownerKey`. Late addressing (TIM-1450)
+   * stamps the full candidate list so the client can find the first
+   * *reachable* owner via its ancestry context, eliminating the
+   * owner-below-throw-site escape.
+   *
+   * See design/04-authorization.md §"Where a Deny Page Renders", TIM-1356.
+   */
+  owners?: string[];
+
+  /**
+   * When true, the pipeline must respond with `rscErrorEnvelope` so the
+   * client hard-navigates instead of attempting to render a deny page
+   * from the RSC payload. Set by AccessGate when a skipped segment
+   * denies — rendering the deny page in-tree would appear inside the
+   * client's cached layout chrome (TIM-1074). See TIM-1363.
+   */
+  _hardNavigate?: boolean;
+
   constructor(status: number, data?: JsonSerializable) {
     super(`Access denied with status ${status}`);
     this.name = 'DenySignal';
@@ -143,58 +228,66 @@ export class DenySignal extends Error {
   }
 }
 
+/** Options for deny(). */
+export interface DenyOptions {
+  /** Human-readable message (logged server-side, not sent to client). */
+  message?: string;
+  /**
+   * JSON-serializable data forwarded as the `data` prop to status-code files
+   * and `denied.tsx`. Named `dangerouslyPassData` because this data crosses
+   * the RSC → client serialization boundary — do not pass sensitive server
+   * state (tokens, internal IDs, database rows).
+   */
+  dangerouslyPassData?: JsonSerializable;
+}
+
 /**
- * Universal denial primitive. Throws a `DenySignal` that the framework catches.
+ * Universal denial/error primitive. Throws a `DenySignal` that the framework catches.
  *
  * - In segment context (outside Suspense): produces HTTP status code
  * - In slot context: graceful degradation → denied.tsx → default.tsx → null
  * - Inside Suspense (hold window): promoted to pre-flush behavior
  * - Inside Suspense (after flush): error boundary + noindex meta
  *
- * @param status - Any 4xx HTTP status code. Defaults to 403.
- * @param data - Optional JSON-serializable data passed as `dangerouslyPassData` prop to status-code files.
- */
-export function deny(status: number = 403, data?: JsonSerializable): never {
-  if (status < 400 || status > 499) {
-    throw new Error(
-      `deny() requires a 4xx status code, got ${status}. ` +
-        'For 5xx errors, throw a RenderError instead.'
-    );
-  }
-  warnIfNotSerializable(data, 'deny()');
-  throw new DenySignal(status, data);
-}
-
-/**
- * Convenience alias for `deny(404)`.
+ * ```ts
+ * deny()                                                        // 403 (default)
+ * deny(404)                                                     // 404
+ * deny(503, { message: 'Maintenance' })                         // server-only log message
+ * deny(404, { dangerouslyPassData: { resourceId: params.id } }) // explicit client opt-in
+ * ```
  *
- * Provided for Next.js API compatibility — libraries and user code that
- * call `notFound()` from `next/navigation` get the same behavior as
- * `deny(404)` in timber.
+ * 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.
+ *
+ * @param status - HTTP status code (4xx or 5xx). Default: 403.
+ * @param options - Optional message and/or data to pass to the client.
  */
-export function notFound(): never {
-  throw new DenySignal(404);
+export function deny(status?: number, options?: DenyOptions): never {
+  const resolvedStatus = status ?? 403;
+  const resolvedData = options?.dangerouslyPassData;
+
+  if (resolvedStatus < 400 || resolvedStatus > 599) {
+    throw new Error(`deny() requires a 4xx or 5xx status code, got ${resolvedStatus}.`);
+  }
+  warnIfNotSerializable(resolvedData, 'deny()');
+  throw new DenySignal(resolvedStatus, resolvedData);
 }
 
-/**
- * Next.js redirect type discriminator.
- *
- * Provided for API compatibility with libraries that import `RedirectType`
- * from `next/navigation`. In timber, `redirect()` always uses `replace`
- * semantics (no history entry for the redirect itself).
- */
-export const RedirectType = {
-  push: 'push',
-  replace: 'replace',
-} as const;
+// Single source of truth shared with the client next/navigation shim —
+// see shared/redirect-type.ts.
+export { RedirectType } from '../shared/redirect-type.ts';
 
 // ─── RedirectSignal ─────────────────────────────────────────────────────────
 
 /**
  * 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.
  */
 export class RedirectSignal extends Error {
+  readonly [REDIRECT_BRAND] = true;
   readonly location: string;
   readonly status: number;
 
@@ -206,46 +299,116 @@ export class RedirectSignal extends Error {
   }
 }
 
-/** Pattern matching absolute URLs: http(s):// or protocol-relative // */
-const ABSOLUTE_URL_RE = /^(?:[a-zA-Z][a-zA-Z\d+\-.]*:|\/\/)/;
+// ─── Signal Detection ───────────────────────────────────────────────────────
 
 /**
- * Redirect to a relative path. Rejects absolute and protocol-relative URLs.
- * Use `redirectExternal()` for external redirects with an allow-list.
+ * 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).
  *
- * @param path - Relative path (e.g. '/login', 'settings', '/login?returnTo=/dash')
- * @param status - HTTP redirect status code (3xx). Defaults to 302.
+ * See also: isFrameworkSignalError() in client/browser-dev.ts (client-only).
  */
-export function redirect(path: string, status: number = 302): never {
-  if (status < 300 || status > 399) {
-    throw new Error(`redirect() requires a 3xx status code, got ${status}.`);
+export function isControlFlowSignal(error: unknown): boolean {
+  if (isDenySignal(error) || isRedirectSignal(error)) {
+    return true;
   }
-  if (ABSOLUTE_URL_RE.test(path)) {
-    throw new Error(
-      `redirect() only accepts relative URLs. Got absolute URL: "${path}". ` +
-        'Use redirectExternal(url, allowList) for external redirects.'
-    );
+  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
+      }
+    }
   }
-  throw new RedirectSignal(path, status);
+  return false;
+}
+
+/**
+ * Options for redirect() — alternative to passing a bare status code.
+ */
+export interface RedirectOptions {
+  /** HTTP redirect status code (3xx). Defaults to 302 (or 308 when `permanent: true`). */
+  status?: number;
+  /**
+   * When true, defaults the status to 308 (Permanent Redirect, preserves HTTP method).
+   * If `status` is also provided, `status` takes precedence.
+   *
+   * @example
+   * redirect('/new-path', { permanent: true });       // 308
+   * redirect('/new-path', { permanent: true, status: 301 }); // 301
+   */
+  permanent?: boolean;
+  /**
+   * Preserve search params from the current request URL on the redirect target.
+   *
+   * - `true` — preserve ALL current search params (target params take precedence)
+   * - `string[]` — preserve only the named params (e.g. `['private', 'token']`)
+   *
+   * Target path's own query params always take precedence over preserved ones.
+   */
+  preserveSearchParams?: true | string[];
 }
 
 /**
- * Permanent redirect to a relative path. Shorthand for `redirect(path, 308)`.
+ * Redirect to a relative path. Rejects absolute and protocol-relative URLs.
+ * Use `redirectExternal()` for external redirects with an allow-list.
+ *
+ * @param path - Relative path (e.g. '/login', 'settings', '/login?returnTo=/dash')
+ * @param statusOrOptions - HTTP status code (3xx, default 302) or options object.
+ *
+ * @example
+ * // Simple redirect
+ * redirect('/login');
  *
- * Uses 308 (Permanent Redirect) which preserves the HTTP method — the browser
- * will replay POST requests to the new location. This matches Next.js behavior.
+ * // With status code
+ * redirect('/login', 301);
  *
- * @param path - Relative path (e.g. '/new-page', '/dashboard')
+ * // With preserved search params
+ * redirect(`/docs/${version}/${slug}`, { preserveSearchParams: ['foo'] });
  */
-export function permanentRedirect(path: string): never {
-  redirect(path, 308);
+export function redirect(path: string, statusOrOptions?: number | RedirectOptions): never {
+  let status: number;
+  let preserveSearchParams: true | string[] | undefined;
+
+  if (typeof statusOrOptions === 'number') {
+    status = statusOrOptions;
+  } else if (statusOrOptions) {
+    // Explicit status wins. Otherwise permanent: true → 308, default → 302.
+    status = statusOrOptions.status ?? (statusOrOptions.permanent ? 308 : 302);
+    preserveSearchParams = statusOrOptions.preserveSearchParams;
+  } else {
+    status = 302;
+  }
+
+  if (status < 300 || status > 399) {
+    throw new Error(`redirect() requires a 3xx status code, got ${status}.`);
+  }
+  // Relative-only validation shared with the client next/navigation shim —
+  // strips C0 controls and normalizes backslashes before the scheme check.
+  assertRelativeRedirectPath(path);
+
+  let resolvedPath = path;
+  if (preserveSearchParams) {
+    const currentSearch = getRequestSearchString();
+    resolvedPath = mergePreservedSearchParams(path, currentSearch, preserveSearchParams);
+  }
+
+  throw new RedirectSignal(resolvedPath, status);
 }
 
 /**
- * Redirect to an external URL. The hostname must be in the provided allow-list.
+ * Redirect to an external URL. The origin must be in the provided allow-list.
+ *
+ * Only http: and https: schemes are permitted. The allow-list is matched
+ * against full origins (scheme + host + port), not bare hostnames.
  *
  * @param url - Absolute URL to redirect to.
- * @param allowList - Array of allowed hostnames (e.g. ['example.com', 'auth.example.com']).
+ * @param allowList - Array of allowed origins (e.g. ['https://example.com', 'https://auth.example.com']).
  * @param status - HTTP redirect status code (3xx). Defaults to 302.
  */
 export function redirectExternal(url: string, allowList: string[], status: number = 302): never {
@@ -253,21 +416,8 @@ export function redirectExternal(url: string, allowList: string[], status: numbe
     throw new Error(`redirectExternal() requires a 3xx status code, got ${status}.`);
   }
 
-  let hostname: string;
-  try {
-    hostname = new URL(url).hostname;
-  } catch {
-    throw new Error(`redirectExternal() received an invalid URL: "${url}"`);
-  }
-
-  if (!allowList.includes(hostname)) {
-    throw new Error(
-      `redirectExternal() target "${hostname}" is not in the allow-list. ` +
-        `Allowed: [${allowList.join(', ')}]`
-    );
-  }
-
-  throw new RedirectSignal(url, status);
+  const canonicalUrl = validateExternalRedirectUrl(url, allowList);
+  throw new RedirectSignal(canonicalUrl, status);
 }
 
 // ─── RenderError ────────────────────────────────────────────────────────────
@@ -297,11 +447,14 @@ export interface RenderErrorDigest<
  *   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;
@@ -324,11 +477,6 @@ export class RenderError<
 
 // ─── waitUntil ──────────────────────────────────────────────────────────────
 
-/** Minimal interface for adapters that support background work. */
-export interface WaitUntilAdapter {
-  waitUntil?(promise: Promise<unknown>): void;
-}
-
 // Intentional per-app singleton — warn-once flag that persists for the
 // lifetime of the process/isolate. Not per-request; do not migrate to ALS.
 let _waitUntilWarned = false;
@@ -337,30 +485,20 @@ let _waitUntilWarned = false;
  * Register a promise to be kept alive after the response is sent.
  * Maps to `ctx.waitUntil()` on Cloudflare Workers and similar platforms.
  *
- * In production, the platform adapter installs a per-request waitUntil
- * function via ALS (see waituntil-bridge.ts). This function checks the
- * ALS bridge first, then falls back to the legacy adapter argument.
- *
- * If neither is available, a warning is logged once and the promise is
- * left to resolve (or reject) without being tracked.
+ * The platform adapter installs a per-request waitUntil function via ALS
+ * (see waituntil-bridge.ts). If no ALS handler is available, a warning
+ * is logged once and the promise is left to resolve (or reject) without
+ * being tracked.
  *
  * @param promise - The background work to keep alive.
- * @param adapter - Optional legacy adapter (prefer ALS bridge in production).
  */
-export function waitUntil(promise: Promise<unknown>, adapter?: WaitUntilAdapter): void {
-  // Check ALS bridge first (installed by generated entry points)
+export function waitUntil(promise: Promise<unknown>): void {
   const alsFn = _getWaitUntil();
   if (alsFn) {
     alsFn(promise);
     return;
   }
 
-  // Fall back to legacy adapter argument
-  if (adapter && typeof adapter.waitUntil === 'function') {
-    adapter.waitUntil(promise);
-    return;
-  }
-
   if (!_waitUntilWarned) {
     _waitUntilWarned = true;
     console.warn(
@@ -390,13 +528,17 @@ export function _resetWaitUntilWarning(): void {
  *
  * 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 {
-  constructor(
-    message: string,
-    public readonly cause: unknown
-  ) {
+  readonly [SSR_STREAM_ERROR_BRAND] = true;
+  override readonly cause: unknown;
+
+  constructor(message: string, cause: unknown) {
     super(message);
     this.name = 'SsrStreamError';
+    this.cause = cause;
   }
 }

package/src/server/publish-params.ts

@@ -0,0 +1,42 @@
+/**
+ * Publishing the request's params onto the RSC payload.
+ *
+ * Every tree the server sends the browser goes through here: the ordinary
+ * route payload (`route-element-builder.ts`), both deny renderers
+ * (`deny-renderer.ts`) and the error renderer. One helper rather than a wrap
+ * at each site, because these previously *were* separate sites — a response
+ * header, an inline script, and a second copy of each on the deny path — and
+ * the deny path shipping empty params was the bug that came of it (TIM-1285).
+ *
+ * Reads the request store rather than taking params as an argument, so a
+ * caller cannot pass a different record than the one the request rendered
+ * with. See design/41-global-params.md §"Transport".
+ */
+
+import { toPlainRecord } from '../shared/param-value.ts';
+import type { RscPayloadRoot } from '../shared/payload-root.ts';
+import { getSegmentParamsForClient, getSlotParamsForClient } from './request-context.ts';
+
+/**
+ * Build the payload root: the tree, and the params it rendered with beside it.
+ *
+ * The params are a *sibling* of the tree, not a provider around it. A provider
+ * inside the payload is shadowed by the retained tree's own provider on a
+ * partial navigation, and its props are not readable at the instant the root
+ * row resolves — see `shared/payload-root.ts` for both, and TIM-1297. The
+ * client renders the one provider readers see, above the merge point.
+ *
+ * The records are flattened to plain objects on the way out. Every param
+ * record the framework builds is `Object.create(null)` (design/13-security.md
+ * #36b/#36c), and React Flight rejects a null prototype — "Classes or null
+ * prototypes are not supported". `ParamsProvider` restores the prototype on
+ * the other side, so what the app reads is unchanged; only the wire
+ * representation differs.
+ */
+export function withPublishedParams(element: React.ReactElement): RscPayloadRoot {
+  return {
+    tree: element,
+    params: toPlainRecord(getSegmentParamsForClient()),
+    slotParams: toPlainRecord(getSlotParamsForClient() ?? null),
+  };
+}

package/src/server/render-timeout.ts

@@ -0,0 +1,108 @@
+/**
+ * Render timeout utilities for SSR streaming pipeline.
+ *
+ * Provides a RenderTimeoutError class and a helper to create
+ * timeout-guarded AbortSignals. Used to defend against hung RSC
+ * streams and infinite SSR renders.
+ *
+ * Design doc: 02-rendering-pipeline.md §"Streaming Constraints"
+ */
+
+/**
+ * Error thrown when an SSR render or RSC stream read exceeds the
+ * configured timeout. Callers can check `instanceof RenderTimeoutError`
+ * to distinguish timeout from other errors and return a 504 or close
+ * the connection cleanly.
+ */
+export class RenderTimeoutError extends Error {
+  readonly timeoutMs: number;
+
+  constructor(timeoutMs: number, context?: string) {
+    const message = context
+      ? `Render timeout after ${timeoutMs}ms: ${context}`
+      : `Render timeout after ${timeoutMs}ms`;
+    super(message);
+    this.name = 'RenderTimeoutError';
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+/**
+ * Result of createRenderTimeout — an AbortSignal that fires after
+ * the given duration, plus a cancel function to clear the timer
+ * when the render completes normally.
+ */
+export interface RenderTimeout {
+  /** AbortSignal that aborts after timeoutMs. */
+  signal: AbortSignal;
+  /** Cancel the timeout timer. Call this when the render completes. */
+  cancel: () => void;
+}
+
+/**
+ * Create a render timeout that aborts after the given duration.
+ *
+ * Returns an AbortSignal and a cancel function. The signal fires
+ * with a RenderTimeoutError as the abort reason after `timeoutMs`.
+ * Call `cancel()` when the render completes to prevent the timeout
+ * from firing.
+ *
+ * If an existing `parentSignal` is provided, the returned signal
+ * aborts when either the parent signal or the timeout fires —
+ * whichever comes first.
+ */
+export function createRenderTimeout(timeoutMs: number, parentSignal?: AbortSignal): RenderTimeout {
+  const controller = new AbortController();
+  const reason = new RenderTimeoutError(timeoutMs, 'RSC stream read timed out');
+
+  const timer = setTimeout(() => controller.abort(reason), timeoutMs);
+
+  let onParentAbort: (() => void) | null = null;
+
+  if (parentSignal) {
+    if (parentSignal.aborted) {
+      clearTimeout(timer);
+      controller.abort(parentSignal.reason);
+    } else {
+      onParentAbort = () => {
+        clearTimeout(timer);
+        controller.abort(parentSignal.reason);
+      };
+      parentSignal.addEventListener('abort', onParentAbort, { once: true });
+    }
+  }
+
+  return {
+    signal: controller.signal,
+    cancel: () => {
+      clearTimeout(timer);
+      if (onParentAbort && parentSignal) {
+        parentSignal.removeEventListener('abort', onParentAbort);
+        onParentAbort = null;
+      }
+    },
+  };
+}
+
+/**
+ * Race a promise against a timeout. Rejects with RenderTimeoutError
+ * if the promise does not resolve within `timeoutMs`.
+ *
+ * Used to guard individual `rscReader.read()` calls inside pullLoop.
+ */
+export function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  context?: string
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout>;
+  const timeoutPromise = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new RenderTimeoutError(timeoutMs, context));
+    }, timeoutMs);
+  });
+
+  return Promise.race([promise, timeoutPromise]).finally(() => {
+    clearTimeout(timer!);
+  });
+}

package/src/server/render-utils.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared render-phase utilities — used by both the Node.js and Web
+ * stream wrappers. Pure functions only; no stream-shape dependencies.
+ *
+ * Consolidated from duplicated copies in node-stream-transforms.ts,
+ * ssr-render.ts, and rsc-entry/helpers.ts. See TIM-1071 item 1.
+ */
+
+import { nonceAttr } from './csp-nonce.ts';
+
+/**
+ * Check if an error is an abort error (connection closed by client).
+ *
+ * When the browser aborts a request (page refresh, navigation away),
+ * the AbortSignal fires and React/streams throw an AbortError. This
+ * is not an application error — suppress it from error boundaries and logs.
+ */
+export function isAbortError(error: unknown): boolean {
+  if (error instanceof DOMException && error.name === 'AbortError') return true;
+  if (error instanceof Error && error.name === 'AbortError') return true;
+  return false;
+}
+
+/**
+ * Inline script that adds `<meta name="robots" content="noindex">` to the
+ * document head. Injected when a render-phase error replaces the shell so
+ * search engines don't index error pages.
+ *
+ * MUST be byte-identical across all stream wrappers (Node and Web) for a
+ * given nonce to ensure consistent Content-Length headers — which is why
+ * both wrappers call this one function rather than inlining the string.
+ */
+export function noindexScript(nonce?: string): string {
+  return `<script${nonceAttr(nonce)}>document.head.appendChild(Object.assign(document.createElement("meta"),{name:"robots",content:"noindex"}))</script>`;
+}