@timber-js/app 0.2.0-alpha.116 → 0.2.0-alpha.118

package/src/server/route-matcher.ts

@@ -17,6 +17,7 @@ import {
   resolveStaticContentType,
   type MetadataRouteType,
 } from './metadata-routes.js';
+import { matchUrlParts } from './tree-match.js';
 
 // ─── Manifest Types ───────────────────────────────────────────────────────
 //
@@ -72,24 +73,19 @@ export function createRouteMatcher(
 /**
  * Match a canonical pathname against the segment tree.
  *
- * Splits the pathname into segments and walks the tree depth-first.
- * Returns the segment chain and extracted params on match.
+ * Splits the pathname into segments and delegates to the shared
+ * tree walker. Collects middleware from the matched segment chain.
  */
 function matchPathname(root: ManifestSegmentNode, pathname: string): RouteMatch | null {
-  // Split pathname into segments: "/blog/hello-world" → ["blog", "hello-world"]
-  // "/" → [] (empty segments)
   const parts = pathname === '/' ? [] : pathname.slice(1).split('/');
 
-  const segments: ManifestSegmentNode[] = [];
-  const params: Record<string, string | string[]> = {};
-
-  const matched = matchSegments(root, parts, 0, segments, params);
-  if (!matched) return null;
+  const result = matchUrlParts(root, parts);
+  if (!result) return null;
 
   // Collect middleware from all segments in the chain, root to leaf.
   // Each middleware is lazy-loaded via dynamic import on first invocation.
   const middlewareChain: MiddlewareFn[] = [];
-  for (const segment of segments) {
+  for (const segment of result.chain) {
     if (segment.middleware) {
       const loader = segment.middleware.load;
       middlewareChain.push(async (ctx) => {
@@ -102,168 +98,12 @@ function matchPathname(root: ManifestSegmentNode, pathname: string): RouteMatch
   }
 
   return {
-    segments,
-    segmentParams: params,
+    segments: result.chain,
+    segmentParams: result.params,
     middlewareChain,
   };
 }
 
-/**
- * An effective child flattened through group segments.
- * Includes the chain of group nodes that must be added to the segments
- * array before the child itself (to preserve the group → child nesting
- * that the renderer expects).
- */
-interface EffectiveChild {
-  child: ManifestSegmentNode;
-  groupChain: ManifestSegmentNode[];
-}
-
-/**
- * Collect effective children by flattening through group segments.
- *
- * Groups are transparent for URL matching — their non-group descendants
- * are returned with the chain of group nodes that lead to them. This
- * allows the caller to apply priority ordering (static > dynamic > ...)
- * across all groups uniformly instead of per-group.
- */
-function collectEffectiveChildren(
-  node: ManifestSegmentNode,
-  groupChain: ManifestSegmentNode[] = []
-): EffectiveChild[] {
-  const result: EffectiveChild[] = [];
-  for (const child of node.children) {
-    if (child.segmentType === 'group') {
-      // Look through the group — its children become effective children
-      // with this group prepended to their chain
-      const nested = collectEffectiveChildren(child, [...groupChain, child]);
-      result.push(...nested);
-    } else {
-      result.push({ child, groupChain });
-    }
-  }
-  return result;
-}
-
-/**
- * Recursively match URL segments against the segment tree.
- *
- * Priority order for children at each level:
- *   1. Static segments (exact match)
- *   2. Dynamic segments ([param])
- *   3. Catch-all segments ([...param])
- *   4. Optional catch-all segments ([[...param]])
- *
- * Groups are transparent — they don't consume URL segments. Children
- * are flattened through groups so that priority ordering applies across
- * all groups uniformly (a static in group A always beats a dynamic in
- * group B, regardless of group ordering).
- */
-function matchSegments(
-  node: ManifestSegmentNode,
-  parts: string[],
-  index: number,
-  segments: ManifestSegmentNode[],
-  params: Record<string, string | string[]>
-): boolean {
-  segments.push(node);
-
-  // All parts consumed — check if this node has a page or route
-  if (index >= parts.length) {
-    if (node.page || node.route) {
-      return true;
-    }
-
-    // Check group children (they don't consume URL segments)
-    for (const child of node.children) {
-      if (child.segmentType === 'group') {
-        if (matchSegments(child, parts, index, segments, params)) {
-          return true;
-        }
-      }
-    }
-
-    // Check optional catch-all children (direct and through groups)
-    const effective = collectEffectiveChildren(node);
-    for (const { child, groupChain } of effective) {
-      if (child.segmentType === 'optional-catch-all') {
-        if (child.page || child.route) {
-          segments.push(...groupChain, child);
-          // Zero segments → param is undefined (not set), matching Next.js semantics
-          return true;
-        }
-      }
-    }
-
-    segments.pop();
-    return false;
-  }
-
-  const part = parts[index];
-
-  // Flatten children through groups so priority ordering applies globally
-  // across all groups, not per-group.
-  const effective = collectEffectiveChildren(node);
-
-  // 1. Static segments
-  for (const { child, groupChain } of effective) {
-    if (child.segmentType === 'static' && child.segmentName === part) {
-      segments.push(...groupChain);
-      if (matchSegments(child, parts, index + 1, segments, params)) {
-        return true;
-      }
-      // Backtrack group chain
-      segments.length -= groupChain.length;
-    }
-  }
-
-  // 2. Dynamic segments ([param])
-  for (const { child, groupChain } of effective) {
-    if (child.segmentType === 'dynamic' && child.paramName) {
-      segments.push(...groupChain);
-      const prevParam = params[child.paramName];
-      params[child.paramName] = part;
-      if (matchSegments(child, parts, index + 1, segments, params)) {
-        return true;
-      }
-      // Backtrack
-      segments.length -= groupChain.length;
-      if (prevParam !== undefined) {
-        params[child.paramName] = prevParam;
-      } else {
-        delete params[child.paramName];
-      }
-    }
-  }
-
-  // 3. Catch-all segments ([...param])
-  for (const { child, groupChain } of effective) {
-    if (child.segmentType === 'catch-all' && child.paramName) {
-      if (child.page || child.route) {
-        const remaining = parts.slice(index);
-        segments.push(...groupChain, child);
-        params[child.paramName] = remaining;
-        return true;
-      }
-    }
-  }
-
-  // 4. Optional catch-all segments ([[...param]])
-  for (const { child, groupChain } of effective) {
-    if (child.segmentType === 'optional-catch-all' && child.paramName) {
-      if (child.page || child.route) {
-        const remaining = parts.slice(index);
-        segments.push(...groupChain, child);
-        params[child.paramName] = remaining;
-        return true;
-      }
-    }
-  }
-
-  segments.pop();
-  return false;
-}
-
 // ─── Metadata Route Matcher ─────────────────────────────────────────────
 
 /** Result of matching a metadata route. */

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

@@ -53,6 +53,9 @@ export interface RenderSignals {
   lastUnhandledError: unknown | null;
   /** Callback fired when a redirect or deny signal is captured in onError. */
   onSignal?: () => void;
+  /** Callback fired when an unhandled error (non-signal) is captured. Used
+   *  to halt Flight data injection into the inline stream. */
+  onUnhandledError?: () => void;
 }
 
 export interface RscStreamResult {
@@ -165,6 +168,7 @@ export function renderRscStream(element: React.ReactElement, req: Request): RscS
           // if SSR fails (SsrStreamError). This is NOT used for page-level
           // error detection — only as a fallback when SSR actually fails.
           signals.lastUnhandledError = error;
+          signals.onUnhandledError?.();
 
           // Return a digest so React emits a per-row error in the Flight
           // stream instead of leaving the lazy reference unresolved.

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

@@ -124,6 +124,14 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
     [ssrStream, inlineStream] = teeWithErrorPropagation(rscStream);
   }
 
+  // Wire an AbortController so the Flight injector stops writing <script>
+  // tags when an unhandled RSC error is detected. Without this, React's
+  // Flight encoder may write model data for a chunk that already received
+  // an error row, causing the client's Flight decoder to crash with
+  // "enqueueModel is not a function". See TIM-938.
+  const errorAbort = new AbortController();
+  signals.onUnhandledError = () => errorAbort.abort();
+
   // Embed segment metadata in HTML for initial hydration.
   // The client reads this to populate its segment cache before the
   // first navigation, enabling state tree diffing from the start.
@@ -159,6 +167,7 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
     deferSuspenseFor: deferSuspenseFor > 0 ? deferSuspenseFor : undefined,
     signal: req.signal,
     cookies: getCookiesForSsr(),
+    _errorSignal: errorAbort.signal,
   };
 
   // Helper: check if render-phase signals were captured and return the
@@ -280,6 +289,7 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
     // Connection abort — the client disconnected (page refresh, navigation
     // away). No response needed; return empty 499 (client closed request).
     if (isAbortError(ssrError) || req.signal?.aborted) {
+      inlineStream?.cancel().catch(() => {});
       return new Response(null, { status: 499 });
     }
 
@@ -302,6 +312,12 @@ export async function renderSsrResponse(opts: SsrRenderOptions): Promise<Respons
       ssrError instanceof SsrStreamError ||
       (ssrError instanceof Error && ssrError.name === 'SsrStreamError');
     if (isSsrStreamError) {
+      // Cancel the teed inline stream — SSR failed so this response will
+      // be replaced by renderErrorPage which creates its own clean streams.
+      // Without explicit cancellation the orphaned tee branch keeps the
+      // RSC source stream alive, preventing garbage collection.
+      inlineStream?.cancel().catch(() => {});
+
       if (signals.redirectSignal) {
         return buildRedirectResponse(req, signals.redirectSignal, responseHeaders);
       }

package/src/server/slot-resolver.ts

@@ -26,6 +26,9 @@ import type { InterceptionContext, RouteMatch } from './pipeline.js';
 import { DenySignal, RedirectSignal } from './primitives.js';
 import { logRenderError } from './logger.js';
 import type { ManifestSegmentNode } from './route-matcher.js';
+import { setSlotParams } from './request-context.js';
+import { coerceSlotParams } from './param-coercion.js';
+import { matchUrlParts } from './tree-match.js';
 
 type CreateElementFn = (...args: unknown[]) => React.ReactElement;
 
@@ -57,89 +60,6 @@ async function renderDefaultFallback(
   return h(DefaultComp, {});
 }
 
-// ─── Segment Tree Matching ──────────────────────────────────────────────────
-
-/**
- * Find a matching child node for a URL segment name.
- *
- * Tries matches in priority order:
- * 1. Static segment (exact name match)
- * 2. Dynamic segment ([param])
- * 3. Catch-all or optional-catch-all ([...param] / [[...param]])
- * 4. Group children (transparent wrappers)
- *
- * Returns `{ node, consumesRest }` where `consumesRest` is true for catch-all
- * segments that consume all remaining URL parts.
- */
-function findMatchingChild(
-  children: ManifestSegmentNode[],
-  segmentName: string
-): { node: ManifestSegmentNode; consumesRest: boolean } | null {
-  // 1. Static match
-  for (const child of children) {
-    if (child.segmentType === 'static' && child.segmentName === segmentName) {
-      return { node: child, consumesRest: false };
-    }
-  }
-
-  // 2. Dynamic match
-  for (const child of children) {
-    if (child.segmentType === 'dynamic') {
-      return { node: child, consumesRest: false };
-    }
-  }
-
-  // 3. Catch-all match — consumes all remaining segments
-  for (const child of children) {
-    if (child.segmentType === 'catch-all' || child.segmentType === 'optional-catch-all') {
-      return { node: child, consumesRest: true };
-    }
-  }
-
-  // 4. Group children (transparent)
-  for (const child of children) {
-    if (child.segmentType === 'group') {
-      for (const groupChild of child.children ?? []) {
-        if (groupChild.segmentName === segmentName) {
-          return { node: groupChild, consumesRest: false };
-        }
-      }
-    }
-  }
-
-  return null;
-}
-
-/**
- * Walk a segment tree from `startNode`, matching each part in `parts` against
- * child nodes. Returns the chain of matched nodes (including startNode) and the
- * final node, or null if any part fails to match.
- */
-function walkSegmentTree(
-  startNode: ManifestSegmentNode,
-  parts: { segmentName: string }[] | string[],
-  initialChain: ManifestSegmentNode[] = [startNode]
-): { chain: ManifestSegmentNode[]; leaf: ManifestSegmentNode } | null {
-  const chain = [...initialChain];
-  let currentNode = startNode;
-
-  for (const part of parts) {
-    const segName = typeof part === 'string' ? part : part.segmentName;
-    const directChildren = currentNode.children ?? [];
-    const match = findMatchingChild(directChildren, segName);
-
-    if (!match) return null;
-
-    chain.push(match.node);
-    currentNode = match.node;
-
-    // Catch-all segments consume all remaining parts
-    if (match.consumesRest) break;
-  }
-
-  return { chain, leaf: currentNode };
-}
-
 // ─── Slot Element Resolution ────────────────────────────────────────────────
 
 /**
@@ -157,7 +77,8 @@ export async function resolveSlotElement(
   slotNode: ManifestSegmentNode,
   match: RouteMatch,
   h: CreateElementFn,
-  interception?: InterceptionContext
+  interception?: InterceptionContext,
+  parentTreePath?: string
 ): Promise<React.ReactElement | null> {
   // When interception is active, try to match intercepting children in this
   // slot against the target pathname. If an intercepting child matches, render
@@ -169,6 +90,22 @@ export async function resolveSlotElement(
     : findSlotMatch(slotNode, match);
 
   if (slotMatch) {
+    // Store per-slot params in ALS so getSegmentParams(segmentPath) returns
+    // the slot's own param types (e.g. catch-all → string[] vs dynamic → string).
+    if (parentTreePath && Object.keys(slotMatch.slotParams).length > 0) {
+      // Build the full tree path: parent prefix + slot chain segment names.
+      const slotSuffix = slotMatch.chain
+        .map((s) => s.segmentName)
+        .filter(Boolean)
+        .join('/');
+      const prefix = parentTreePath === '/' ? '' : parentTreePath;
+      const fullSlotPath = `${prefix}/${slotSuffix}`;
+
+      // Coerce slot params through global schema codecs (same as main route).
+      const coerced = coerceSlotParams(slotMatch.chain, slotMatch.slotParams);
+      setSlotParams(fullSlotPath, coerced);
+    }
+
     const SlotPage = await loadComponent(slotMatch.page);
     if (SlotPage) {
       // Load default.tsx fallback for notFound() handling in the slot page.
@@ -334,6 +271,8 @@ interface SlotMatchResult {
   page: NonNullable<ManifestSegmentNode['page']>;
   /** The full chain of slot nodes traversed (slot root → … → leaf with page). */
   chain: ManifestSegmentNode[];
+  /** Params collected from the slot's segment chain (may differ from main route params). */
+  slotParams: Record<string, string | string[]>;
 }
 
 /**
@@ -374,26 +313,54 @@ function findSlotMatch(slotNode: ManifestSegmentNode, match: RouteMatch): SlotMa
   // against the slot's children.
   const remainingSegments = parentIndex >= 0 ? segments.slice(parentIndex + 1) : [];
 
-  // If no remaining segments, the slot's own page matches
-  if (remainingSegments.length === 0) {
-    if (slotNode.page) {
-      return { page: slotNode.page, chain: [slotNode] };
-    }
-    // Check for optional-catch-all child — [[...slug]] matches zero segments
-    for (const child of slotNode.children ?? []) {
-      if (child.segmentType === 'optional-catch-all' && child.page) {
-        return { page: child.page, chain: [slotNode, child] };
+  // Extract raw URL parts from the remaining main-route segments.
+  // Use rawSegmentParams (pre-coercion) to ensure we get actual URL strings,
+  // not codec-transformed values. Fall back to segmentParams for tests/compat.
+  const rawParams = match.rawSegmentParams ?? match.segmentParams ?? {};
+  const urlParts = extractUrlParts(remainingSegments, rawParams);
+
+  // Match URL parts against the slot's segment tree using the shared walker.
+  // Handles zero parts (slot's own page), catch-all, optional-catch-all,
+  // groups, backtracking, and correct priority ordering.
+  const result = matchUrlParts(slotNode, urlParts);
+  if (!result) return null;
+
+  const leaf = result.chain[result.chain.length - 1];
+  if (!leaf.page) return null;
+
+  return { page: leaf.page, chain: result.chain, slotParams: result.params };
+}
+
+/**
+ * Extract raw URL path parts from a main-route segment chain.
+ *
+ * Each dynamic segment consumed one URL part (its param value).
+ * Static segments consumed their own name. Groups are transparent.
+ * Catch-all segments consumed multiple parts (their param value is string[]).
+ *
+ * Uses rawSegmentParams (pre-coercion) to get actual URL strings.
+ * Values are coerced to String() defensively in case a codec leaked
+ * a non-string value into the params map.
+ */
+function extractUrlParts(
+  segments: ManifestSegmentNode[],
+  mainParams: Record<string, string | string[]>
+): string[] {
+  const parts: string[] = [];
+  for (const seg of segments) {
+    if (seg.segmentType === 'group') continue;
+    if (seg.segmentType === 'static') {
+      parts.push(seg.segmentName);
+    } else if (seg.paramName) {
+      const value = mainParams[seg.paramName];
+      if (Array.isArray(value)) {
+        parts.push(...value.map(String));
+      } else if (value !== undefined) {
+        parts.push(String(value));
       }
     }
-    return null;
-  }
-
-  // Walk the slot's children to match remaining URL segments
-  const result = walkSegmentTree(slotNode, remainingSegments);
-  if (result && result.leaf.page) {
-    return { page: result.leaf.page, chain: result.chain };
   }
-  return null;
+  return parts;
 }
 
 /**
@@ -429,19 +396,19 @@ function findInterceptingMatch(
     }
     if (matchIdx < 0) continue;
 
-    // Walk the intercepting child's sub-tree to match remaining target parts
+    // Match remaining target parts against the intercepting child's sub-tree.
     const remaining = targetParts.slice(matchIdx + 1);
-
-    if (remaining.length === 0) {
-      if (child.page) {
-        return { page: child.page, chain: [slotNode, child] };
+    const result = matchUrlParts(child, remaining);
+    if (result) {
+      const leaf = result.chain[result.chain.length - 1];
+      if (leaf.page) {
+        return {
+          page: leaf.page,
+          // Prepend slotNode — matchUrlParts starts from child, not slot root
+          chain: [slotNode, ...result.chain],
+          slotParams: result.params,
+        };
       }
-      continue;
-    }
-
-    const result = walkSegmentTree(child, remaining, [slotNode, child]);
-    if (result && result.leaf.page) {
-      return { page: result.leaf.page, chain: result.chain };
     }
   }
 

package/src/server/ssr-entry.ts

@@ -157,6 +157,14 @@ export interface NavContext {
     /** Whether the Node.js native stream path was used */
     nodeStreams: boolean;
   };
+
+  /**
+   * Signal that fires when an unhandled RSC error is detected.
+   * The Flight injector checks this before writing each script tag —
+   * when aborted, it stops injecting Flight data to prevent corrupted
+   * chunks from crashing the client's Flight decoder.
+   */
+  _errorSignal?: AbortSignal;
 }
 
 /**
@@ -291,6 +299,7 @@ export async function handleSsr(
         const headInjector = createNodeHeadInjector(navContext.headHtml);
         const flightInjector = createNodeFlightInjector(navContext.rscStream, {
           renderTimeoutMs,
+          errorSignal: navContext._errorSignal,
         });
         const moveSuffix = createNodeMoveSuffixTransform();
 
@@ -350,7 +359,12 @@ export async function handleSsr(
       // structure (TIM-527).
       let outputStream = htmlStream.pipeThrough(createBufferedTransformStream());
       outputStream = injectHead(outputStream, navContext.headHtml);
-      outputStream = injectRscPayload(outputStream, navContext.rscStream, renderTimeoutMs);
+      outputStream = injectRscPayload(
+        outputStream,
+        navContext.rscStream,
+        renderTimeoutMs,
+        navContext._errorSignal
+      );
       const _pipelineEnd = performance.now();
 
       navContext._ssrTimings = {