@timber-js/app 0.2.0-alpha.204 → 0.2.0-alpha.206

package/src/server/route-matcher.ts

@@ -18,7 +18,7 @@ import {
   resolveServePathForFile,
   type MetadataRouteType,
 } from './metadata-routes.ts';
-import { matchUrlParts } from './tree-match.ts';
+import { matchUrlParts, matchUrlPartsAll } from './tree-match.ts';
 
 // ─── Manifest Types ───────────────────────────────────────────────────────
 //
@@ -190,30 +190,44 @@ function matchMetadataPathname(
 
   let segment: ManifestSegmentNode;
   let params: Record<string, string | string[]>;
+  let file: ManifestFile | null = null;
 
-  if (prefixParts.length === 0) {
-    segment = root;
-    params = {};
-  } else {
-    const result = matchUrlParts(root, prefixParts, { requireTerminal: false });
-    if (!result) return null;
-    segment = result.chain[result.chain.length - 1];
-    params = result.params;
-  }
+  // Find the metadata file owner. For prefix matches, iterate all matching
+  // segments in priority order — when competing bare-dynamic groups match
+  // the same prefix, the first may not own the file. For root-level matches,
+  // search all group children since findMetadataRouteInSegment may return
+  // a file with the wrong extension when multiple groups own the same
+  // convention with different static types.
+  segment = root;
+  params = {};
+  const candidates = [...metadataOwnerCandidates(root, prefixParts)];
 
-  // Non-nestable routes (robots, manifest, favicon) only serve from root
-  if (!convention.nestable && segment !== root) return null;
+  // Two passes: direct owners first (node itself + groups), then
+  // zero-segment optional-catch-all descent. A direct owner across any
+  // candidate must beat a zero-segment catch-all on an earlier candidate.
+  for (const allowCatchAll of [false, true]) {
+    for (const candidate of candidates) {
+      if (!convention.nestable && candidate.segment !== root) continue;
+      const found = findMetadataRouteInSegment(
+        candidate.segment,
+        baseName,
+        allowCatchAll && convention.nestable
+      );
+      if (!found) continue;
+      if (convention.serveExtension) {
+        const resolvedServePath = resolveServePathForFile(baseName, found.filePath);
+        if (lastPart !== resolvedServePath) continue;
+      }
+      segment = candidate.segment;
+      params = candidate.params;
+      file = found;
+      break;
+    }
+    if (file) break;
+  }
 
-  const file = findMetadataRouteInSegment(segment, baseName, convention.nestable);
   if (!file) return null;
 
-  // Validate the requested URL extension matches the file's resolved serve path.
-  // Prevents /icon.svg matching when only icon.png exists.
-  if (convention.serveExtension) {
-    const resolvedServePath = resolveServePathForFile(baseName, file.filePath);
-    if (lastPart !== resolvedServePath) return null;
-  }
-
   const ext = file.filePath.slice(file.filePath.lastIndexOf('.') + 1);
   const isStatic = isStaticMetadataExtension(baseName, ext);
   const contentType = isStatic
@@ -265,3 +279,42 @@ function findMetadataRouteInSegment(
   }
   return null;
 }
+
+/**
+ * Yield candidate owner segments for a metadata route.
+ *
+ * For root-level metadata (empty prefix), yields the root and then each
+ * transparent group child — so extension validation can skip a group that
+ * owns the wrong static type and find the right one. For prefix matches,
+ * delegates to `matchUrlPartsAll` which handles all segment kinds.
+ */
+function* metadataOwnerCandidates(
+  root: ManifestSegmentNode,
+  prefixParts: string[]
+): Generator<{ segment: ManifestSegmentNode; params: Record<string, string | string[]> }> {
+  if (prefixParts.length === 0) {
+    yield { segment: root, params: {} };
+    // Also yield each group child individually so the caller can validate
+    // extensions per-group rather than taking the first file found.
+    for (const child of root.children) {
+      if (child.segmentType === 'group') {
+        yield* groupDescendants(child);
+      }
+    }
+  } else {
+    for (const result of matchUrlPartsAll(root, prefixParts, { requireTerminal: false })) {
+      yield { segment: result.chain[result.chain.length - 1], params: result.params };
+    }
+  }
+}
+
+function* groupDescendants(
+  node: ManifestSegmentNode
+): Generator<{ segment: ManifestSegmentNode; params: Record<string, string | string[]> }> {
+  yield { segment: node, params: {} };
+  for (const child of node.children) {
+    if (child.segmentType === 'group') {
+      yield* groupDescendants(child);
+    }
+  }
+}

package/src/server/rsc-entry/deny-fallback.ts

@@ -17,7 +17,6 @@ import { logRenderError } from '../logger.ts';
 import type { PipelineConfig, RouteMatch } from '../pipeline.ts';
 import type { ManifestSegmentNode } from '../route-matcher.ts';
 import { loadModule } from '../safe-load.ts';
-import { createDebugChannelSink } from './helpers.ts';
 import { isRscRequest } from '../../shared/rsc-media-type.ts';
 import { callSsr } from './ssr-bridge.ts';
 
@@ -69,14 +68,7 @@ export function createDenyFallbackRenderer(options: {
     // request is an RSC payload request — mirroring the normal render path.
     // See design/19-client-navigation.md §"RSC Payload Handling" and TIM-823.
     if (isRscRequest(req)) {
-      return renderDenyPageAsRsc(
-        deny,
-        chain,
-        layoutComponents,
-        req,
-        responseHeaders,
-        createDebugChannelSink
-      );
+      return renderDenyPageAsRsc(deny, chain, layoutComponents, req, responseHeaders);
     }
     return renderDenyPage(
       deny,
@@ -86,7 +78,6 @@ export function createDenyFallbackRenderer(options: {
       match,
       responseHeaders,
       clientBootstrap,
-      createDebugChannelSink,
       callSsr
     );
   };

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

@@ -23,7 +23,6 @@ import { getCspNonce } from '../csp-nonce.ts';
 import { renderDenyPage, renderDenyPageAsRsc } from '../deny-renderer.ts';
 import type { DefaultPageRenderer, LayoutEntry } from '../deny-renderer.ts';
 import type { NavContext } from '../ssr-bridge-types.ts';
-import { createDebugChannelSink } from './helpers.ts';
 import { isRscRequest } from '../../shared/rsc-media-type.ts';
 import { withPublishedParams } from '../publish-params.ts';
 import { getCookiesForSsr } from '../cookie-context.ts';
@@ -291,7 +290,6 @@ async function renderErrorPageViaRsc(
       onError(err: unknown) {
         logRenderError({ method: req.method, path: url.pathname, error: err });
       },
-      debugChannel: createDebugChannelSink(),
     });
 
     const [ssrStream, inlineStream] = teeWithErrorPropagation(rscStream);
@@ -402,14 +400,7 @@ export async function renderNoMatchPage(
   const match: RouteMatch = { segments, segmentParams: {}, middlewareChain: [] };
 
   if (isRscRequest(req)) {
-    return renderDenyPageAsRsc(
-      deny,
-      segments,
-      layoutComponents,
-      req,
-      responseHeaders,
-      createDebugChannelSink
-    );
+    return renderDenyPageAsRsc(deny, segments, layoutComponents, req, responseHeaders);
   }
 
   return renderDenyPage(
@@ -420,7 +411,6 @@ export async function renderNoMatchPage(
     match,
     responseHeaders,
     clientBootstrap,
-    createDebugChannelSink,
     callSsr,
     defaultPage
   );

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

@@ -5,104 +5,12 @@
  */
 
 import type { ManifestSegmentNode } from '../route-matcher.ts';
-import { swallow } from '../logger.ts';
 import { computeSegmentKeys, computeSegmentTreePaths } from '../../routing/segment-keys.ts';
 import type { SegmentInfo } from '../../shared/segment-info.ts';
 import type { SlotSkipEntry } from '../slot-resolver.ts';
 import { isClientReference } from '../utils/element-type.ts';
 import { isStaticRequestDependent } from '../request-dep.ts';
 
-/**
- * No-op — returns undefined so no debugChannel is passed to Flight.
- * Debug rows ride the main stream inline (React's default behavior).
- *
- * Production Flight emits no debug rows. In dev, inline debug rows
- * are handled by the Flight client for owner stack resolution.
- *
- * A writable-only debugChannel triggers a react-server-dom-webpack
- * >=19.3.0 Flight client regression (owner/stack refs parsed after
- * stream close produce "Connection closed" errors).
- */
-export function createDebugChannelSink(): undefined {
-  return undefined;
-}
-
-// ─── Debug Channel Collector (dev mode only) ────────────────────────────
-
-/**
- * Parsed component debug info extracted from the Flight debug channel.
- *
- * Contains only component names, environment labels, and stack frames —
- * never source code or props. See design/13-security.md §"Server source
- * never reaches the client".
- */
-export interface DebugComponentEntry {
-  name: string;
-  env: string | null;
-  key: string | null;
-  stack: unknown[] | null;
-}
-
-/**
- * Parse React Flight debug rows into component entries.
- *
- * The Flight debug channel writes rows in `hexId:json\n` format. Each row
- * with a JSON object containing a `name` field is a component debug info
- * entry. Rows without `name` (timing rows, reference rows like `D"$id"`)
- * are skipped.
- *
- * Security: `props` are explicitly stripped from parsed entries — they may
- * contain rendered output or user data. Only `name`, `env`, `key`, and
- * `stack` are retained.
- */
-export function parseDebugRows(text: string): DebugComponentEntry[] {
-  if (!text) return [];
-
-  const entries: DebugComponentEntry[] = [];
-  const lines = text.split('\n');
-
-  for (const line of lines) {
-    if (!line) continue;
-
-    // Flight row format: hexId:payload
-    const colonIdx = line.indexOf(':');
-    if (colonIdx === -1) continue;
-
-    let payload = line.slice(colonIdx + 1);
-
-    // React Flight debug rows may have a type-tag prefix before the JSON
-    // object (e.g., "D{...}" for debug info rows). Strip the single-char
-    // tag so the JSON parser sees the object. Non-JSON payloads like
-    // D"$a" reference rows are caught by the JSON.parse try/catch below.
-    // See TIM-556.
-    if (payload.length > 0 && payload[0] !== '{' && payload[0] !== '[' && payload[0] !== '"') {
-      payload = payload.slice(1);
-    }
-
-    // Skip payloads that still aren't JSON objects after tag stripping
-    if (!payload.startsWith('{')) continue;
-
-    try {
-      const parsed = JSON.parse(payload);
-      if (typeof parsed !== 'object' || parsed === null) continue;
-      if (typeof parsed.name !== 'string') continue;
-
-      // Strip props — may contain source-derived data or user data.
-      // Only retain: name, env, key, stack.
-      entries.push({
-        name: parsed.name,
-        env: parsed.env ?? null,
-        key: parsed.key ?? null,
-        stack: Array.isArray(parsed.stack) ? parsed.stack : null,
-      });
-    } catch (e) {
-      swallow(e, 'malformed JSON in RSC client reference row');
-    }
-  }
-
-  return entries;
-}
-
 /**
  * Build segment metadata for the X-Timber-Segments response header.
  * Describes the rendered segment chain with request-dependency status,

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

@@ -60,7 +60,6 @@ import { renderNoMatchPage } from './error-renderer.ts';
 import { renderRoute } from './render-route.ts';
 import { isDebug, isDevMode, setDebugFromConfig } from '../debug.ts';
 import { setSourceMapCallback } from '../dev-source-map.ts';
-import { requestContextAls } from '../als-registry.ts';
 import { capturePrebuiltPayloads } from '../prebuilt-builder.ts';
 import { setPrebuiltPayloadSource } from '../prebuilt/payload-source.ts';
 import { setRscFunctions, setComponentRefreshTimeout } from '../prebuilt-runtime.ts';
@@ -97,10 +96,6 @@ export function setDevSourceMapHandler(handler: (error: Error) => void): void {
   setSourceMapCallback(handler);
 }
 
-// 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.
  *
@@ -299,7 +294,6 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
           rootSegment: manifest.root,
           buildManifest: typedBuildManifest,
           globalError: manifest.globalError,
-          devDebugRegistry: pipelineConfig.devDebugRegistry,
         },
         interception
       );
@@ -351,14 +345,7 @@ async function createRequestHandler(manifest: typeof routeManifest, runtimeConfi
     onPipelineError: isDev
       ? (error: Error, phase: string) => {
           if (pipelineConfig.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' && store?.debugComponentsGetter
-                ? store.debugComponentsGetter()
-                : undefined;
-            pipelineConfig.devPipelineErrorHandler(error, phase, debugComponents);
+            pipelineConfig.devPipelineErrorHandler(error, phase);
           }
         }
       : undefined,

package/src/server/rsc-entry/render-route.ts

@@ -35,13 +35,12 @@ import { buildRouteElement, NoPageComponentError } from '../route-element-builde
 import { ParamCoercionError } from '../param-coercion.ts';
 import type { ManifestSegmentNode } from '../route-matcher.ts';
 import { recordTiming } from '../server-timing.ts';
-import { requestContextAls } from '../als-registry.ts';
 import { parseClientStateTree } from '../state-tree-diff.ts';
 
 import { getFirstDeniedSegmentIndex } from '../deny-boundary.ts';
 import { handleApiRoute } from './api-handler.ts';
 import { renderErrorPage, renderNoMatchPage } from './error-renderer.ts';
-import { buildRedirectResponse, createDebugChannelSink } from './helpers.ts';
+import { buildRedirectResponse } from './helpers.ts';
 import { isRscRequest } from '../../shared/rsc-media-type.ts';
 import { buildRscPayloadResponse } from './rsc-payload.ts';
 import { renderRscStream } from './rsc-stream.ts';
@@ -60,7 +59,6 @@ export interface RenderRouteDeps {
   rootSegment: ManifestSegmentNode;
   buildManifest: BuildManifest;
   globalError?: { load: () => Promise<unknown>; filePath: string };
-  devDebugRegistry?: import('../../dev-tools/debug-channel.ts').DebugChannelRegistry;
 }
 
 /**
@@ -199,24 +197,8 @@ export async function renderRoute(
 
   // Render to RSC Flight stream with signal tracking.
   const _rscStart = performance.now();
-  // Only wire the HMR debug transport for HTML requests. RSC payload
-  // requests (client navigations) don't serve HTML with __timber_debug_id,
-  // so the browser can't subscribe — skip to avoid orphaned sessions.
-  const debugRegistry = isRscRequest(req) || clientJsDisabled ? undefined : deps.devDebugRegistry;
-  const { rscStream, signals, getDebugComponents, debugRequestId } = renderRscStream(
-    payload,
-    req,
-    leafDenyChain,
-    debugRegistry
-  );
+  const { rscStream, signals } = renderRscStream(payload, req, leafDenyChain);
 
-  // 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),
@@ -239,7 +221,6 @@ export async function renderRoute(
         layoutComponents as LayoutEntry[],
         req,
         responseHeaders,
-        createDebugChannelSink,
         getFirstDeniedSegmentIndex()
       );
     }
@@ -251,7 +232,6 @@ export async function renderRoute(
       match,
       responseHeaders,
       clientBootstrap,
-      createDebugChannelSink,
       callSsr,
       undefined,
       getFirstDeniedSegmentIndex()
@@ -310,6 +290,5 @@ export async function renderRoute(
     deferSuspenseFor,
     globalError,
     slotSkipInfo,
-    debugRequestId,
   });
 }

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

@@ -26,7 +26,7 @@ import type { LayoutComponentEntry } from '../route-element-builder.ts';
 import type { ManifestSegmentNode } from '../route-matcher.ts';
 import type { SlotSkipEntry } from '../slot-resolver.ts';
 
-import { buildRedirectResponse, buildSegmentInfo, createDebugChannelSink } from './helpers.ts';
+import { buildRedirectResponse, buildSegmentInfo } from './helpers.ts';
 import { RSC_CONTENT_TYPE } from '../../shared/rsc-media-type.ts';
 
 import { rscErrorEnvelope } from '../rsc-error-envelope.ts';
@@ -178,7 +178,6 @@ export async function buildRscPayloadResponse(
       layoutComponents as LayoutEntry[],
       req,
       responseHeaders,
-      createDebugChannelSink,
       getDeniedIdx()
     );
   }

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

@@ -27,8 +27,7 @@ import {
 } from '../primitives.ts';
 import { checkAndWarnRscPropError } from '../rsc-prop-warnings.ts';
 
-import { isAbortError, type DebugComponentEntry } from './helpers.ts';
-import type { DebugChannelRegistry } from '../../dev-tools/debug-channel.ts';
+import { isAbortError } from './helpers.ts';
 import { isDebug } from '../debug.ts';
 import { isDevMode } from '../debug.ts';
 
@@ -78,10 +77,6 @@ export interface RenderSignals {
 export interface RscStreamResult {
   rscStream: ReadableStream<Uint8Array> | undefined;
   signals: RenderSignals;
-  /** Dev-only: server component debug info from the Flight debug channel. */
-  getDebugComponents?: () => DebugComponentEntry[];
-  /** Dev-only: request ID for the debug channel HMR transport. */
-  debugRequestId?: string;
 }
 
 /**
@@ -98,8 +93,7 @@ export interface RscStreamResult {
 export function renderRscStream(
   payload: RscPayloadRoot,
   req: Request,
-  leafDenyChain?: DenyPageEntry[],
-  devDebugRegistry?: DebugChannelRegistry
+  leafDenyChain?: DenyPageEntry[]
 ): RscStreamResult {
   const signals: RenderSignals = {
     denySignal: null,
@@ -111,14 +105,6 @@ export function renderRscStream(
 
   let rscStream: ReadableStream<Uint8Array> | undefined;
 
-  // No debugChannel — debug rows ride the main RSC stream inline.
-  // Production Flight emits none. In dev, the browser Flight client
-  // handles inline debug rows for owner stack resolution (React's
-  // default behavior). A writable-only debugChannel triggers a
-  // react-server-dom-webpack >=19.3.0 Flight client regression.
-  const debugChannel = undefined;
-  const debugRequestId = undefined;
-
   try {
     rscStream = renderToReadableStream(
       payload,
@@ -243,7 +229,6 @@ export function renderRscStream(
             errorId,
           });
         },
-        debugChannel,
       },
       {
         onClientReference(info: { id: string; name: string; deps: unknown }) {
@@ -272,16 +257,5 @@ export function renderRscStream(
     }
   }
 
-  return {
-    rscStream,
-    signals,
-    // In production, the debug channel collector's getComponents is available.
-    // In dev mode, debug rows ride the main stream (no separate channel), so
-    // this is undefined — the error overlay uses stack traces directly.
-    getDebugComponents:
-      debugChannel && 'getComponents' in debugChannel
-        ? (debugChannel as { getComponents: () => DebugComponentEntry[] }).getComponents
-        : undefined,
-    debugRequestId,
-  };
+  return { rscStream, signals };
 }

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

@@ -27,12 +27,7 @@ import type { SlotSkipEntry } from '../slot-resolver.ts';
 import type { NavContext } from '../ssr-bridge-types.ts';
 
 import { htmlEscapeJsonString } from '../flight-scripts.ts';
-import {
-  buildRedirectResponse,
-  buildSegmentInfo,
-  createDebugChannelSink,
-  isAbortError,
-} from './helpers.ts';
+import { buildRedirectResponse, buildSegmentInfo, isAbortError } from './helpers.ts';
 import { getCookiesForSsr } from '../cookie-context.ts';
 import { getDenyStatus, getFirstDeniedSegmentIndex } from '../deny-boundary.ts';
 import { renderErrorPage, type GlobalErrorFile } from './error-renderer.ts';
@@ -105,7 +100,6 @@ interface SsrRenderOptions {
   /** Tier 2 global-error.tsx file, if present in app/. */
   globalError?: GlobalErrorFile;
   slotSkipInfo?: SlotSkipEntry[];
-  debugRequestId?: string;
 }
 
 /**
@@ -198,12 +192,7 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
       clientBootstrap.preloadLinks +
       // Initialize __timber_f in <head> so it exists before any streaming
       // chunk scripts arrive in <body>. See flight-scripts.ts, LOCAL-415.
-      (clientJsDisabled ? '' : flightInitScript(nonce)) +
-      // Embed the debug channel request ID so the browser can subscribe
-      // to the correct HMR debug stream for owner stack resolution.
-      (opts.debugRequestId && !clientJsDisabled
-        ? `<script${nonceAttr(nonce)}>self.__timber_debug_id=${htmlEscapeJsonString(JSON.stringify(opts.debugRequestId))}</script>`
-        : ''),
+      (clientJsDisabled ? '' : flightInitScript(nonce)),
     getHeadSegmentScript: clientJsDisabled
       ? undefined
       : () =>
@@ -250,7 +239,6 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
         match,
         responseHeaders,
         clientBootstrap,
-        createDebugChannelSink,
         callSsr,
         undefined,
         resolvedDeniedIndex()
@@ -437,7 +425,6 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
           match,
           responseHeaders,
           clientBootstrap,
-          createDebugChannelSink,
           callSsr,
           undefined,
           resolvedDeniedIndex()

package/src/server/slot-resolver.ts

@@ -156,12 +156,7 @@ export async function resolveSlotElement(
             const rendered = await scope(() =>
               (SlotPage as (props: Record<string, unknown>) => unknown)(props)
             );
-            return containSlotSubtree(
-              rendered as React.ReactNode,
-              denyFallback,
-              undefined,
-              slotNode.segmentName
-            );
+            return containSlotSubtree(rendered as React.ReactNode, denyFallback);
           } catch (error) {
             // RedirectSignal must propagate — the pipeline handles redirects
             // at the top level. Swallowing it here would silently return
@@ -194,20 +189,12 @@ export async function resolveSlotElement(
         element,
         h,
         scope,
-        denyFallback,
-        slotNode.segmentName
+        denyFallback
       );
 
       // Wrap with slot root's layout — INSIDE the access gate, so the layout
       // server component never executes when access.ts denies. See TIM-1074.
-      element = await wrapWithLayout(
-        slotNode,
-        element,
-        h,
-        scope,
-        denyFallback,
-        slotNode.segmentName
-      );
+      element = await wrapWithLayout(slotNode, element, h, scope, denyFallback);
 
       // Wrap in SlotAccessGate if slot root has access.ts. The gate is
       // OUTSIDE the layout, matching the segment model in
@@ -303,8 +290,7 @@ async function wrapWithIntermediateSegments(
   element: React.ReactElement,
   h: CreateElementFn,
   scope?: SlotParamScope,
-  denyFallback?: React.ReactNode,
-  slotName?: string
+  denyFallback?: React.ReactNode
 ): Promise<React.ReactElement> {
   for (let i = chain.length - 1; i > 0; i--) {
     const seg = chain[i];
@@ -314,7 +300,7 @@ async function wrapWithIntermediateSegments(
       errorBoundaryComponent: TimberErrorBoundary,
       isSlotBoundary: true,
     });
-    element = await wrapWithLayout(seg, element, h, scope, denyFallback, slotName);
+    element = await wrapWithLayout(seg, element, h, scope, denyFallback);
     element = await wrapWithAccessGate(seg, element, h, scope);
   }
   return element;
@@ -355,16 +341,10 @@ function ScopedSlotLayout(props: {
   layout: (props: Record<string, unknown>) => unknown;
   scope: SlotParamScope;
   denyFallback: React.ReactNode;
-  slotName: string | undefined;
   children: React.ReactElement;
 }): unknown {
   const rendered = props.scope(() => props.layout({ children: props.children }));
-  return containSlotSubtree(
-    rendered as React.ReactNode,
-    props.denyFallback,
-    props.children,
-    props.slotName
-  );
+  return containSlotSubtree(rendered as React.ReactNode, props.denyFallback, props.children);
 }
 
 /**
@@ -382,8 +362,7 @@ async function wrapWithLayout(
   element: React.ReactElement,
   h: CreateElementFn,
   scope?: SlotParamScope,
-  denyFallback: React.ReactNode = null,
-  slotName?: string
+  denyFallback: React.ReactNode = null
 ): Promise<React.ReactElement> {
   if (!node.layout) return element;
   const Layout = await loadComponent(node.layout);
@@ -394,7 +373,6 @@ async function wrapWithLayout(
     layout: Layout as (props: Record<string, unknown>) => unknown,
     scope,
     denyFallback,
-    slotName,
     children: element,
   });
 }