@timber-js/app 0.2.0-alpha.57 → 0.2.0-alpha.59

package/src/server/rsc-entry/error-renderer.ts

@@ -1,33 +1,36 @@
 /**
  * RSC Error & No-Match Renderers — handles error pages and 404s.
  *
- * Error pages use two rendering paths depending on file format:
- * - TSX/JSX ('use client'): SSR-only render via Fizz (bypasses RSC Flight)
- * - MDX (server component): RSC → SSR (plain props, no Error serialization issue)
+ * All error pages (TSX and MDX) render through the RSC → SSR pipeline:
+ * - TSX ('use client'): Error is converted to SerializableError, wrapped
+ *   with ErrorReconstituter to reconstitute a real Error on the client.
+ * - MDX (server component): Receives plain props ({ status }), no wrapper needed.
  *
- * The SSR-only path exists because Error objects are not RSC-serializable.
- * React Flight throws "Only plain objects can be passed to Client Components"
- * when Error instances are passed as props to 'use client' components.
+ * This unified approach replaces the former SSR-only bypass for TSX error
+ * pages. See design/spike-TIM-565-unify-error-pages.md for the full analysis.
  *
  * Design docs: 10-error-handling.md §"Three-Tier Error Page Rendering"
  */
 
 import { createElement } from 'react';
-import { renderToReadableStream } from '#/rsc-runtime/rsc.js';
-
-import type { RouteMatch } from '#/server/pipeline.js';
-import { logRenderError } from '#/server/logger.js';
-import type { ManifestSegmentNode } from '#/server/route-matcher.js';
-import { DenySignal, RenderError } from '#/server/primitives.js';
-import type { ClientBootstrapConfig } from '#/server/html-injectors.js';
-import { flightInitScript } from '#/server/flight-scripts.js';
-import { renderDenyPage } from '#/server/deny-renderer.js';
-import type { LayoutEntry } from '#/server/deny-renderer.js';
-import type { NavContext } from '#/server/ssr-entry.js';
+import { renderToReadableStream } from '../../rsc-runtime/rsc.js';
+
+import type { RouteMatch } from '../pipeline.js';
+import { logRenderError } from '../logger.js';
+import type { ManifestSegmentNode } from '../route-matcher.js';
+import { DenySignal, RenderError } from '../primitives.js';
+import type { ClientBootstrapConfig } from '../html-injectors.js';
+import { flightInitScript } from '../flight-scripts.js';
+import { renderDenyPage } from '../deny-renderer.js';
+import type { LayoutEntry } from '../deny-renderer.js';
+import type { NavContext } from '../ssr-entry.js';
 import { createDebugChannelSink } from './helpers.js';
-import { getCookiesForSsr } from '#/server/request-context.js';
+import { getCookiesForSsr } from '../request-context.js';
 import { callSsr } from './ssr-bridge.js';
-import { callSsrErrorPage } from './ssr-error-bridge.js';
+import { teeWithErrorPropagation } from '../stream-utils.js';
+import { isDevMode } from '../debug.js';
+import { ErrorReconstituter } from '../../client/error-reconstituter.js';
+import type { SerializableError } from '../../client/error-reconstituter.js';
 
 /**
  * A manifest file reference with lazy import and path.
@@ -55,14 +58,12 @@ function isMdxFile(filePath: string): boolean {
  * Result of walking the segment chain for an error file.
  */
 interface ErrorFileResolution {
-  /** The loaded component (for MDX RSC path) */
+  /** The loaded component */
   component: (...args: unknown[]) => unknown;
   /** Index of the segment where the file was found */
   segmentIndex: number;
   /** Whether the file is MDX (server component) */
   isMdx: boolean;
-  /** File path for SSR-only import */
-  filePath: string;
 }
 
 /**
@@ -91,7 +92,6 @@ async function resolveErrorFile(
             component: mod.default as (...args: unknown[]) => unknown,
             segmentIndex: i,
             isMdx: isMdxFile(specificFile.filePath),
-            filePath: specificFile.filePath,
           };
         }
       }
@@ -105,7 +105,6 @@ async function resolveErrorFile(
             component: mod.default as (...args: unknown[]) => unknown,
             segmentIndex: i,
             isMdx: isMdxFile(categoryFile.filePath),
-            filePath: categoryFile.filePath,
           };
         }
       }
@@ -119,7 +118,6 @@ async function resolveErrorFile(
           component: mod.default as (...args: unknown[]) => unknown,
           segmentIndex: i,
           isMdx: isMdxFile(segment.error.filePath),
-          filePath: segment.error.filePath,
         };
       }
     }
@@ -140,12 +138,28 @@ function getLayoutsForErrorFile(
   return layoutComponents.filter((lc) => resolvedSegments.has(lc.segment));
 }
 
+/**
+ * Convert an error to a SerializableError for RSC Flight serialization.
+ * Stack traces are stripped in production (gated by isDevMode).
+ *
+ * See design/13-security.md §"Debug Flag Security Boundary" — uses isDevMode(),
+ * not isDebug(), because this data crosses the RSC → client boundary.
+ */
+function toSerializableError(error: unknown): SerializableError {
+  const err = error instanceof Error ? error : new Error(String(error));
+  return {
+    message: err.message,
+    name: err.name,
+    ...(isDevMode() && err.stack ? { stack: err.stack } : {}),
+  };
+}
+
 /**
  * Render an error page for unhandled throws or RenderError outside Suspense.
  *
- * Uses two rendering paths:
- * - TSX/JSX: SSR-only (bypass RSC, render directly through Fizz)
- * - MDX: RSC → SSR (server components need Flight, but props are plain)
+ * All error pages (TSX and MDX) go through RSC → SSR:
+ * - TSX: ErrorReconstituter wrapper converts SerializableError → real Error
+ * - MDX: Plain props ({ status }), no wrapper needed
  */
 export async function renderErrorPage(
   error: unknown,
@@ -158,8 +172,6 @@ export async function renderErrorPage(
   clientBootstrap: ClientBootstrapConfig,
   globalError?: GlobalErrorFile
 ): Promise<Response> {
-  const h = createElement as (...args: unknown[]) => React.ReactElement;
-
   // Walk segments from leaf to root to find the error component
   const resolution = await resolveErrorFile(status, segments);
 
@@ -181,28 +193,14 @@ export async function renderErrorPage(
     return new Response(null, { status, headers: responseHeaders });
   }
 
-  const { component: errorComponent, segmentIndex, isMdx, filePath } = resolution;
+  const { component: errorComponent, segmentIndex, isMdx } = resolution;
   const layoutsToWrap = getLayoutsForErrorFile(segments, layoutComponents, segmentIndex);
 
-  // MDX error pages go through RSC → SSR (server components, plain props)
-  if (isMdx) {
-    return renderErrorPageViaMdx(
-      errorComponent,
-      status,
-      layoutsToWrap,
-      req,
-      match,
-      responseHeaders,
-      clientBootstrap,
-      h
-    );
-  }
-
-  // TSX error pages: SSR-only render (bypass RSC Flight)
-  return renderErrorPageViaSsrOnly(
+  return renderErrorPageViaRsc(
     error,
+    errorComponent,
+    isMdx,
     status,
-    filePath,
     layoutsToWrap,
     req,
     match,
@@ -212,77 +210,47 @@ export async function renderErrorPage(
 }
 
 /**
- * TSX error page: SSR-only render, bypasses RSC Flight entirely.
+ * Render an error page through the RSC → SSR pipeline.
  *
- * Passes component file paths to the SSR environment which imports them
- * (resolving 'use client' references to actual modules) and builds the
- * element tree for Fizz. Error objects are passed as-is — Fizz has no
- * serialization constraint on props.
+ * Handles both TSX and MDX error pages:
+ * - TSX: Wrapped with ErrorReconstituter to reconstitute Error on client
+ * - MDX: Receives plain props ({ status }), rendered as server component
  */
-async function renderErrorPageViaSsrOnly(
+async function renderErrorPageViaRsc(
   error: unknown,
+  errorComponent: (...args: unknown[]) => unknown,
+  isMdx: boolean,
   status: number,
-  errorFilePath: string,
   layoutsToWrap: LayoutEntry[],
   req: Request,
   match: RouteMatch,
   responseHeaders: Headers,
   clientBootstrap: ClientBootstrapConfig
 ): Promise<Response> {
-  // Build digest prop for RenderError, null for unhandled errors
-  const digest =
-    error instanceof RenderError ? { code: error.code, data: error.digest.data } : null;
-
-  // Collect layout file paths (root → leaf order) for SSR-env import.
-  // Layouts have filePaths on their segment's layout ManifestFile.
-  const layoutPaths: string[] = [];
-  for (const lc of layoutsToWrap) {
-    if (lc.segment.layout) {
-      layoutPaths.push(lc.segment.layout.filePath);
-    }
-  }
+  const h = createElement as (...args: unknown[]) => React.ReactElement;
+  const url = new URL(req.url);
 
-  // Render directly through Fizz in the SSR environment — no RSC Flight stream.
-  // Do NOT inject flightInitScript() here: this path bypasses RSC Flight
-  // entirely, so there are no data rows to consume. Injecting the [0]
-  // bootstrap signal causes the client to call createFromReadableStream
-  // on an empty stream, which fails. See TIM-552.
-  return callSsrErrorPage({
-    pathname: new URL(req.url).pathname,
-    params: match.params,
-    searchParams: Object.fromEntries(new URL(req.url).searchParams),
-    statusCode: status,
-    responseHeaders,
-    headHtml: '',
-    bootstrapScriptContent: clientBootstrap.bootstrapScriptContent,
-    signal: req.signal,
-    cookies: getCookiesForSsr(),
-    errorProps: {
-      error: error instanceof Error ? error : new Error(String(error)),
+  let element: React.ReactElement;
+
+  if (isMdx) {
+    // MDX error pages receive plain props — no Error serialization issue
+    element = h(errorComponent, { status });
+  } else {
+    // TSX error pages: wrap with ErrorReconstituter for Error reconstitution.
+    // The ErrorReconstituter is a 'use client' component that receives
+    // SerializableError (plain object) and reconstitutes a real Error
+    // before passing to the user's error component.
+    const serializedError = toSerializableError(error);
+    const digest =
+      error instanceof RenderError ? { code: error.code, data: error.digest.data } : null;
+
+    element = h(ErrorReconstituter, {
+      error: serializedError,
       digest,
       reset: undefined,
-    },
-    errorComponentPath: errorFilePath,
-    layoutPaths,
-  });
-}
-
-/**
- * MDX error page: RSC → SSR render. MDX is a server component and needs
- * the Flight pipeline, but it receives plain props (no Error object).
- */
-async function renderErrorPageViaMdx(
-  errorComponent: (...args: unknown[]) => unknown,
-  status: number,
-  layoutsToWrap: LayoutEntry[],
-  req: Request,
-  match: RouteMatch,
-  responseHeaders: Headers,
-  clientBootstrap: ClientBootstrapConfig,
-  h: (...args: unknown[]) => React.ReactElement
-): Promise<Response> {
-  // MDX error pages receive {} or { status } — no Error object
-  let element = h(errorComponent, { status });
+      component: errorComponent,
+    });
+  }
 
   // Wrap in layouts
   for (let i = layoutsToWrap.length - 1; i >= 0; i--) {
@@ -290,39 +258,43 @@ async function renderErrorPageViaMdx(
     element = h(component, null, element);
   }
 
-  // Render through RSC → SSR (same as deny pages)
-  const rscStream = renderToReadableStream(element, {
-    onError(err: unknown) {
-      logRenderError({ method: req.method, path: new URL(req.url).pathname, error: err });
-    },
-    debugChannel: createDebugChannelSink(),
-  });
-
-  const [ssrStream, inlineStream] = rscStream.tee();
-
-  const navContext: NavContext = {
-    pathname: new URL(req.url).pathname,
-    params: match.params,
-    searchParams: Object.fromEntries(new URL(req.url).searchParams),
-    statusCode: status,
-    responseHeaders,
-    headHtml: flightInitScript(),
-    bootstrapScriptContent: clientBootstrap.bootstrapScriptContent,
-    rscStream: inlineStream,
-    cookies: getCookiesForSsr(),
-  };
+  // Render through RSC → SSR (same path as deny pages)
+  try {
+    const rscStream = renderToReadableStream(element, {
+      onError(err: unknown) {
+        logRenderError({ method: req.method, path: url.pathname, error: err });
+      },
+      debugChannel: createDebugChannelSink(),
+    });
+
+    const [ssrStream, inlineStream] = teeWithErrorPropagation(rscStream);
 
-  return callSsr(ssrStream, navContext);
+    const navContext: NavContext = {
+      pathname: url.pathname,
+      params: match.params,
+      searchParams: Object.fromEntries(url.searchParams),
+      statusCode: status,
+      responseHeaders,
+      headHtml: flightInitScript(),
+      bootstrapScriptContent: clientBootstrap.bootstrapScriptContent,
+      rscStream: inlineStream,
+      cookies: getCookiesForSsr(),
+    };
+
+    return callSsr(ssrStream, navContext);
+  } catch (renderError) {
+    // Error page itself failed to render — fall through to bare response.
+    // This guards against recursive errors in user error page code.
+    logRenderError({ method: req.method, path: url.pathname, error: renderError });
+    return new Response(null, { status, headers: responseHeaders });
+  }
 }
 
 /**
  * Tier 2 — Render global-error.tsx as a standalone full-page replacement.
  *
  * No layout wrapping. The component must provide its own <html> and <body>.
- * Uses SSR-only render (bypasses RSC Flight) since global-error.tsx is
- * a 'use client' component receiving { error, digest, reset }.
- *
- * MDX global-error files go through RSC → SSR with plain props.
+ * All formats (TSX and MDX) go through RSC → SSR.
  *
  * See design/10-error-handling.md §"Tier 2 — Global Error Page"
  */
@@ -335,63 +307,26 @@ async function renderGlobalErrorPage(
   responseHeaders: Headers,
   clientBootstrap: ClientBootstrapConfig
 ): Promise<Response> {
-  const h = createElement as (...args: unknown[]) => React.ReactElement;
-
-  if (isMdxFile(globalError.filePath)) {
-    // MDX global-error: RSC → SSR with plain props (no Error object)
-    const mod = (await globalError.load()) as Record<string, unknown>;
-    if (!mod.default) {
-      return new Response(null, { status, headers: responseHeaders });
-    }
-    const component = mod.default as (...args: unknown[]) => unknown;
-    const element = h(component, { status });
-
-    const rscStream = renderToReadableStream(element, {
-      onError(err: unknown) {
-        logRenderError({ method: req.method, path: new URL(req.url).pathname, error: err });
-      },
-      debugChannel: createDebugChannelSink(),
-    });
-
-    const [ssrStream, inlineStream] = rscStream.tee();
-
-    const navContext: NavContext = {
-      pathname: new URL(req.url).pathname,
-      params: match.params,
-      searchParams: Object.fromEntries(new URL(req.url).searchParams),
-      statusCode: status,
-      responseHeaders,
-      headHtml: flightInitScript(),
-      bootstrapScriptContent: clientBootstrap.bootstrapScriptContent,
-      rscStream: inlineStream,
-      cookies: getCookiesForSsr(),
-    };
-
-    return callSsr(ssrStream, navContext);
+  const mod = (await globalError.load()) as Record<string, unknown>;
+  if (!mod.default) {
+    return new Response(null, { status, headers: responseHeaders });
   }
 
-  // TSX/JSX global-error: SSR-only render, no layouts
-  const digest =
-    error instanceof RenderError ? { code: error.code, data: error.digest.data } : null;
+  const component = mod.default as (...args: unknown[]) => unknown;
+  const isMdx = isMdxFile(globalError.filePath);
 
-  return callSsrErrorPage({
-    pathname: new URL(req.url).pathname,
-    params: match.params,
-    searchParams: Object.fromEntries(new URL(req.url).searchParams),
-    statusCode: status,
+  // Reuse the unified RSC path with no layouts
+  return renderErrorPageViaRsc(
+    error,
+    component,
+    isMdx,
+    status,
+    [], // No layouts — global-error is standalone
+    req,
+    match,
     responseHeaders,
-    headHtml: '',
-    bootstrapScriptContent: clientBootstrap.bootstrapScriptContent,
-    signal: req.signal,
-    cookies: getCookiesForSsr(),
-    errorProps: {
-      error: error instanceof Error ? error : new Error(String(error)),
-      digest,
-      reset: undefined,
-    },
-    errorComponentPath: globalError.filePath,
-    layoutPaths: [], // No layouts — global-error is standalone
-  });
+    clientBootstrap
+  );
 }
 
 /**

package/src/server/rsc-entry/helpers.ts

@@ -4,8 +4,8 @@
  * Small, stateless functions used across the RSC entry modules.
  */
 
-import type { ManifestSegmentNode } from '#/server/route-matcher.js';
-import { RedirectSignal } from '#/server/primitives.js';
+import type { ManifestSegmentNode } from '../route-matcher.js';
+import { RedirectSignal } from '../primitives.js';
 
 /** RSC content type for client navigation payload requests. */
 export const RSC_CONTENT_TYPE = 'text/x-component';

package/src/server/rsc-entry/index.ts

@@ -24,38 +24,38 @@ import buildManifest from 'virtual:timber-build-manifest';
 // @ts-expect-error — virtual module provided by timber-entries plugin
 import loadUserInstrumentation from 'virtual:timber-instrumentation';
 
-import type { FormRerender } from '#/server/action-handler.js';
-import { handleActionRequest, isActionRequest } from '#/server/action-handler.js';
-import type { BodyLimitsConfig } from '#/server/body-limits.js';
-import type { BuildManifest } from '#/server/build-manifest.js';
+import type { FormRerender } from '../action-handler.js';
+import { handleActionRequest, isActionRequest } from '../action-handler.js';
+import type { BodyLimitsConfig } from '../body-limits.js';
+import type { BuildManifest } from '../build-manifest.js';
 import {
   buildFontPreloadTags,
   buildModulepreloadTags,
   collectRouteFonts,
   collectRouteModulepreloads,
-} from '#/server/build-manifest.js';
-import type { LayoutEntry } from '#/server/deny-renderer.js';
-import { renderDenyPage, renderDenyPageAsRsc } from '#/server/deny-renderer.js';
-import { resolveLogMode } from '#/server/dev-logger.js';
-import { sendEarlyHints103 } from '#/server/early-hints-sender.js';
-import { collectEarlyHintHeaders } from '#/server/early-hints.js';
-import { runWithFormFlash } from '#/server/form-flash.js';
-import type { ClientBootstrapConfig } from '#/server/html-injectors.js';
-import { buildClientScripts } from '#/server/html-injectors.js';
-import type { InterceptionContext, PipelineConfig, RouteMatch } from '#/server/pipeline.js';
-import { createPipeline, coerceSegmentParams } from '#/server/pipeline.js';
-import { DenySignal, RedirectSignal } from '#/server/primitives.js';
+} from '../build-manifest.js';
+import type { LayoutEntry } from '../deny-renderer.js';
+import { renderDenyPage, renderDenyPageAsRsc } from '../deny-renderer.js';
+import { resolveLogMode } from '../dev-logger.js';
+import { sendEarlyHints103 } from '../early-hints-sender.js';
+import { collectEarlyHintHeaders } from '../early-hints.js';
+import { runWithFormFlash } from '../form-flash.js';
+import type { ClientBootstrapConfig } from '../html-injectors.js';
+import { buildClientScripts } from '../html-injectors.js';
+import type { InterceptionContext, PipelineConfig, RouteMatch } from '../pipeline.js';
+import { createPipeline, coerceSegmentParams } from '../pipeline.js';
+import { DenySignal, RedirectSignal } from '../primitives.js';
 import {
   buildRouteElement,
   RouteSignalWithContext,
   ParamCoercionError,
-} from '#/server/route-element-builder.js';
-import type { ManifestSegmentNode } from '#/server/route-matcher.js';
-import { createMetadataRouteMatcher, createRouteMatcher } from '#/server/route-matcher.js';
-import { initDevTracing } from '#/server/tracing.js';
+} from '../route-element-builder.js';
+import type { ManifestSegmentNode } from '../route-matcher.js';
+import { createMetadataRouteMatcher, createRouteMatcher } from '../route-matcher.js';
+import { initDevTracing } from '../tracing.js';
 
-import { renderFallbackError as renderFallback } from '#/server/fallback-error.js';
-import { loadInstrumentation } from '#/server/instrumentation.js';
+import { renderFallbackError as renderFallback } from '../fallback-error.js';
+import { loadInstrumentation } from '../instrumentation.js';
 import { handleApiRoute } from './api-handler.js';
 import { renderErrorPage, renderNoMatchPage } from './error-renderer.js';
 import {
@@ -65,13 +65,14 @@ import {
   isRscPayloadRequest,
   type DebugComponentEntry,
 } from './helpers.js';
-import { parseClientStateTree } from '#/server/state-tree-diff.js';
+import { parseClientStateTree } from '../state-tree-diff.js';
 import { buildRscPayloadResponse } from './rsc-payload.js';
 import { renderRscStream } from './rsc-stream.js';
 import { renderSsrResponse } from './ssr-renderer.js';
 import { callSsr } from './ssr-bridge.js';
-import { isDebug, isDevMode, setDebugFromConfig } from '#/server/debug.js';
-import { recordTiming } from '#/server/server-timing.js';
+import { isDebug, isDevMode, setDebugFromConfig } from '../debug.js';
+import { recordTiming } from '../server-timing.js';
+import { requestContextAls } from '../als-registry.js';
 
 /**
  * Resolve the Server-Timing mode from timber.config.ts.
@@ -113,11 +114,9 @@ export function setDevPipelineErrorHandler(
   _devPipelineErrorHandler = handler;
 }
 
-// Dev-only: holds a getter for the current request's RSC debug components.
-// Updated on each renderRscStream call so the onPipelineError callback can
-// include component tree context for render-phase errors. This is request-
-// scoped by convention — each renderRoute call sets it before returning.
-let _lastDebugComponentsGetter: (() => DebugComponentEntry[]) | undefined;
+// Dev-only: debug components getter is stored per-request in ALS
+// (RequestContextStore.debugComponentsGetter) to avoid cross-request
+// race conditions. See TIM-557.
 
 /**
  * Create the RSC request handler from the route manifest.
@@ -139,7 +138,7 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     | string
     | undefined;
   if (deploymentId) {
-    const { setDeploymentId } = await import('#/server/version-skew.js');
+    const { setDeploymentId } = await import('../version-skew.js');
     setDeploymentId(deploymentId);
   }
 
@@ -251,9 +250,10 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
           if (_devPipelineErrorHandler) {
             // For render-phase errors, include RSC debug component data
             // from the Flight debug channel (if available from the current request).
+            const store = requestContextAls.getStore();
             const debugComponents =
-              phase === 'render' && _lastDebugComponentsGetter
-                ? _lastDebugComponentsGetter()
+              phase === 'render' && store?.debugComponentsGetter
+                ? store.debugComponentsGetter()
                 : undefined;
             _devPipelineErrorHandler(error, phase, debugComponents);
           }
@@ -487,9 +487,13 @@ async function renderRoute(
   const _rscStart = performance.now();
   const { rscStream, signals, getDebugComponents } = renderRscStream(element, _req);
 
-  // Store the debug components getter so onPipelineError can include
-  // component tree context for render-phase errors (dev mode only).
-  _lastDebugComponentsGetter = getDebugComponents;
+  // Store the debug components getter in ALS so onPipelineError can
+  // include component tree context for render-phase errors (dev mode only).
+  // Per-request via ALS — no cross-request race. See TIM-557.
+  const alsStore = requestContextAls.getStore();
+  if (alsStore) {
+    alsStore.debugComponentsGetter = getDebugComponents;
+  }
   recordTiming({
     name: 'rsc-init',
     dur: Math.round(performance.now() - _rscStart),
@@ -580,10 +584,10 @@ async function renderRoute(
 
 // Re-export for generated entry points (e.g., Nitro node-server/bun) to wrap
 // the handler with per-request 103 Early Hints sender via ALS.
-export { runWithEarlyHintsSender } from '#/server/early-hints-sender.js';
+export { runWithEarlyHintsSender } from '../early-hints-sender.js';
 
 // Re-export for generated entry points to wrap the handler with per-request
 // waitUntil support via ALS. See design/11-platform.md §"waitUntil()".
-export { runWithWaitUntil } from '#/server/waituntil-bridge.js';
+export { runWithWaitUntil } from '../waituntil-bridge.js';
 
 export default await createRequestHandler(routeManifest, config);

package/src/server/rsc-entry/rsc-payload.ts

@@ -9,12 +9,12 @@
  *              16-metadata.md §"Head Elements"
  */
 
-import type { LayoutEntry } from '#/server/deny-renderer.js';
-import { renderDenyPageAsRsc } from '#/server/deny-renderer.js';
-import type { RouteMatch } from '#/server/pipeline.js';
-import type { RedirectSignal } from '#/server/primitives.js';
-import type { HeadElement, LayoutComponentEntry } from '#/server/route-element-builder.js';
-import type { ManifestSegmentNode } from '#/server/route-matcher.js';
+import type { LayoutEntry } from '../deny-renderer.js';
+import { renderDenyPageAsRsc } from '../deny-renderer.js';
+import type { RouteMatch } from '../pipeline.js';
+import type { RedirectSignal } from '../primitives.js';
+import type { HeadElement, LayoutComponentEntry } from '../route-element-builder.js';
+import type { ManifestSegmentNode } from '../route-matcher.js';
 
 import {
   buildRedirectResponse,

package/src/server/rsc-entry/rsc-stream.ts

@@ -10,13 +10,13 @@
  *              13-security.md §"Errors don't leak"
  */
 
-import { renderToReadableStream } from '#/rsc-runtime/rsc.js';
+import { renderToReadableStream } from '../../rsc-runtime/rsc.js';
 
 import { randomUUID } from 'node:crypto';
 
-import { logRenderError } from '#/server/logger.js';
-import { DenySignal, RedirectSignal, RenderError } from '#/server/primitives.js';
-import { checkAndWarnRscPropError } from '#/server/rsc-prop-warnings.js';
+import { logRenderError } from '../logger.js';
+import { DenySignal, RedirectSignal, RenderError } from '../primitives.js';
+import { checkAndWarnRscPropError } from '../rsc-prop-warnings.js';
 
 import {
   createDebugChannelSink,
@@ -24,8 +24,8 @@ import {
   isAbortError,
   type DebugComponentEntry,
 } from './helpers.js';
-import { isDebug } from '#/server/debug.js';
-import { isDevMode } from '#/server/debug.js';
+import { isDebug } from '../debug.js';
+import { isDevMode } from '../debug.js';
 
 /**
  * Mutable signal state captured during RSC rendering.

package/src/server/rsc-entry/ssr-bridge.ts

@@ -4,13 +4,13 @@
 
 /// <reference types="@vitejs/plugin-rsc/types" />
 
-import type { NavContext } from '#/server/ssr-entry.js';
+import type { NavContext } from '../ssr-entry.js';
 
 export async function callSsr(
   rscStream: ReadableStream<Uint8Array>,
   navContext: NavContext
 ): Promise<Response> {
-  const ssrEntry = await import.meta.viteRsc.import<typeof import('#/server/ssr-entry.js')>(
+  const ssrEntry = await import.meta.viteRsc.import<typeof import('../ssr-entry.js')>(
     '../ssr-entry.js',
     { environment: 'ssr' }
   );