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

package/src/server/tree-match.ts

@@ -66,6 +66,27 @@ export function matchUrlParts<TFile>(
   return null;
 }
 
+/**
+ * Yield every match for the given URL parts, in priority order.
+ *
+ * Same matching semantics as `matchUrlParts` — static > affixed-dynamic >
+ * bare-dynamic > catch-all > optional-catch-all — but instead of returning
+ * the first match, it yields all of them. Used by the metadata route matcher,
+ * which needs to try alternate owner segments when the first match doesn't
+ * own the requested metadata file.
+ */
+export function* matchUrlPartsAll<TFile>(
+  root: SegmentNode<TFile>,
+  parts: string[],
+  options?: TreeMatchOptions
+): Generator<TreeMatchResult<TFile>> {
+  const chain: SegmentNode<TFile>[] = [];
+  const params: Record<string, string | string[]> = {};
+  const requireTerminal = options?.requireTerminal ?? true;
+
+  yield* matchNodeAll(root, parts, 0, chain, params, requireTerminal);
+}
+
 // ─── Internal ─────────────────────────────────────────────────────────────
 
 /**
@@ -107,6 +128,59 @@ function isTerminal<TFile>(node: SegmentNode<TFile>): boolean {
   return !!(node.page || node.route);
 }
 
+/**
+ * Specificity tier for a segment. Lower = more specific. Matches the
+ * priority order in `matchNode`: static > affixed-dynamic > bare-dynamic >
+ * catch-all > optional-catch-all.
+ */
+function segmentTier<TFile>(node: SegmentNode<TFile>): number {
+  if (node.segmentType === 'static') return 0;
+  if (node.segmentType === 'dynamic' && (node.paramPrefix || node.paramSuffix)) return 1;
+  if (node.segmentType === 'dynamic') return 2;
+  if (node.segmentType === 'catch-all') return 3;
+  if (node.segmentType === 'optional-catch-all') return 4;
+  return 2;
+}
+
+/**
+ * Score a bare-dynamic candidate by running `matchNode` against its subtree
+ * with the remaining URL parts, then reading the tier of each segment in
+ * the matched chain. Returns a tier array that is compared lexicographically
+ * — the candidate whose chain has a lower tier at the first differing
+ * position is more specific.
+ *
+ * Delegates entirely to `matchNode`, so every segment type and priority
+ * rule is inherited automatically — no second copy to drift.
+ */
+function subtreeMatchScore<TFile>(
+  node: SegmentNode<TFile>,
+  parts: string[],
+  index: number,
+  requireTerminal: boolean
+): number[] {
+  const chain: SegmentNode<TFile>[] = [];
+  const params: Record<string, string | string[]> = {};
+  if (!matchNode(node, parts, index, chain, params, requireTerminal)) return [];
+  // Skip the first entry (the candidate node itself — it's the bare-dynamic
+  // we're scoring, which is the same tier for all candidates).
+  return chain.slice(1).map((seg) => segmentTier(seg));
+}
+
+/**
+ * Compare two tier arrays lexicographically. Negative means `a` is more
+ * specific (should be tried first).
+ */
+function compareTierArrays(a: number[], b: number[]): number {
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    // A shorter match is less specific — missing entries treated as worst tier.
+    const ta = i < a.length ? a[i] : 5;
+    const tb = i < b.length ? b[i] : 5;
+    if (ta !== tb) return ta - tb;
+  }
+  return 0;
+}
+
 /** Combined affix length for specificity ordering. */
 function affixLength<TFile>(node: SegmentNode<TFile>): number {
   return (node.paramPrefix?.length ?? 0) + (node.paramSuffix?.length ?? 0);
@@ -206,32 +280,177 @@ function matchNode<TFile>(
   }
 
   // 3. Bare dynamic segments ([param])
+  //    When multiple bare dynamics compete (common with route groups that
+  //    flatten into the same parent), sort by subtree specificity so a
+  //    branch containing a static match for the NEXT URL part is tried
+  //    first. Without this, the winner depends on children order and
+  //    renaming a route group can flip it — the exact shape the collision
+  //    validator exists to reject.
+  const bareDynamic = effective.filter(
+    ({ child }) =>
+      child.segmentType === 'dynamic' && child.paramName && !child.paramPrefix && !child.paramSuffix
+  );
+  if (bareDynamic.length > 1 && index + 1 < parts.length) {
+    const scores = new Map<SegmentNode<TFile>, number[]>();
+    for (const { child } of bareDynamic) {
+      scores.set(child, subtreeMatchScore(child, parts, index + 1, requireTerminal));
+    }
+    bareDynamic.sort((a, b) => compareTierArrays(scores.get(a.child)!, scores.get(b.child)!));
+  }
+  for (const { child, groupChain } of bareDynamic) {
+    chain.push(...groupChain);
+    const prev = params[child.paramName!];
+    params[child.paramName!] = part;
+    if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) {
+      return true;
+    }
+    // Backtrack
+    chain.length -= groupChain.length;
+    if (prev !== undefined) {
+      params[child.paramName!] = prev;
+    } else {
+      delete params[child.paramName!];
+    }
+  }
+
+  // 4. Catch-all segments ([...param]) — must be terminal unless the
+  // caller passed requireTerminal:false (metadata route matching needs to
+  // find the owning segment even when it has no page).
   for (const { child, groupChain } of effective) {
     if (
-      child.segmentType === 'dynamic' &&
+      child.segmentType === 'catch-all' &&
       child.paramName &&
-      !child.paramPrefix &&
-      !child.paramSuffix
+      (!requireTerminal || isTerminal(child))
     ) {
-      chain.push(...groupChain);
-      const prev = params[child.paramName];
-      params[child.paramName] = part;
-      if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) {
-        return true;
+      chain.push(...groupChain, child);
+      params[child.paramName] = parts.slice(index);
+      return true;
+    }
+  }
+
+  // 5. Optional catch-all segments ([[...param]]) — same terminal rule
+  for (const { child, groupChain } of effective) {
+    if (
+      child.segmentType === 'optional-catch-all' &&
+      child.paramName &&
+      (!requireTerminal || isTerminal(child))
+    ) {
+      chain.push(...groupChain, child);
+      params[child.paramName] = parts.slice(index);
+      return true;
+    }
+  }
+
+  chain.pop();
+  return false;
+}
+
+/**
+ * Generator twin of `matchNode` — yields every match instead of returning
+ * the first. Each yield snapshots `chain` and `params` so the caller gets
+ * independent results. After yielding, backtracking continues to find the
+ * next match.
+ */
+function* matchNodeAll<TFile>(
+  node: SegmentNode<TFile>,
+  parts: string[],
+  index: number,
+  chain: SegmentNode<TFile>[],
+  params: Record<string, string | string[]>,
+  requireTerminal: boolean
+): Generator<TreeMatchResult<TFile>> {
+  chain.push(node);
+
+  if (index >= parts.length) {
+    if (!requireTerminal || isTerminal(node)) {
+      yield { chain: [...chain], params: { ...params } };
+    }
+
+    for (const child of node.children) {
+      if (child.segmentType === 'group') {
+        yield* matchNodeAll(child, parts, index, chain, params, requireTerminal);
       }
-      // Backtrack
+    }
+
+    const effective = collectEffectiveChildren(node);
+    for (const { child, groupChain } of effective) {
+      if (child.segmentType === 'optional-catch-all' && (!requireTerminal || isTerminal(child))) {
+        chain.push(...groupChain, child);
+        yield { chain: [...chain], params: { ...params } };
+        chain.length -= groupChain.length + 1;
+      }
+    }
+
+    chain.pop();
+    return;
+  }
+
+  const part = parts[index];
+  const effective = collectEffectiveChildren(node);
+
+  // 1. Static segments
+  for (const { child, groupChain } of effective) {
+    if (child.segmentType === 'static' && child.segmentName === part) {
+      chain.push(...groupChain);
+      yield* matchNodeAll(child, parts, index + 1, chain, params, requireTerminal);
+      chain.length -= groupChain.length;
+    }
+  }
+
+  // 2. Affixed dynamic segments
+  const affixed = effective.filter(
+    ({ child }) =>
+      child.segmentType === 'dynamic' && child.paramName && (child.paramPrefix || child.paramSuffix)
+  );
+  affixed.sort((a, b) => affixLength(b.child) - affixLength(a.child));
+  for (const { child, groupChain } of affixed) {
+    const prefix = child.paramPrefix ?? '';
+    const suffix = child.paramSuffix ?? '';
+    if (
+      part.length > prefix.length + suffix.length &&
+      (!prefix || part.startsWith(prefix)) &&
+      (!suffix || part.endsWith(suffix))
+    ) {
+      const value = part.slice(prefix.length, part.length - (suffix.length || 0));
+      chain.push(...groupChain);
+      const prev = params[child.paramName!];
+      params[child.paramName!] = value;
+      yield* matchNodeAll(child, parts, index + 1, chain, params, requireTerminal);
       chain.length -= groupChain.length;
       if (prev !== undefined) {
-        params[child.paramName] = prev;
+        params[child.paramName!] = prev;
       } else {
-        delete params[child.paramName];
+        delete params[child.paramName!];
       }
     }
   }
 
-  // 4. Catch-all segments ([...param]) — must be terminal unless the
-  // caller passed requireTerminal:false (metadata route matching needs to
-  // find the owning segment even when it has no page).
+  // 3. Bare dynamic segments
+  const bareDynamic = effective.filter(
+    ({ child }) =>
+      child.segmentType === 'dynamic' && child.paramName && !child.paramPrefix && !child.paramSuffix
+  );
+  if (bareDynamic.length > 1 && index + 1 < parts.length) {
+    const scores = new Map<SegmentNode<TFile>, number[]>();
+    for (const { child } of bareDynamic) {
+      scores.set(child, subtreeMatchScore(child, parts, index + 1, requireTerminal));
+    }
+    bareDynamic.sort((a, b) => compareTierArrays(scores.get(a.child)!, scores.get(b.child)!));
+  }
+  for (const { child, groupChain } of bareDynamic) {
+    chain.push(...groupChain);
+    const prev = params[child.paramName!];
+    params[child.paramName!] = part;
+    yield* matchNodeAll(child, parts, index + 1, chain, params, requireTerminal);
+    chain.length -= groupChain.length;
+    if (prev !== undefined) {
+      params[child.paramName!] = prev;
+    } else {
+      delete params[child.paramName!];
+    }
+  }
+
+  // 4. Catch-all segments
   for (const { child, groupChain } of effective) {
     if (
       child.segmentType === 'catch-all' &&
@@ -239,12 +458,19 @@ function matchNode<TFile>(
       (!requireTerminal || isTerminal(child))
     ) {
       chain.push(...groupChain, child);
+      const prev = params[child.paramName];
       params[child.paramName] = parts.slice(index);
-      return true;
+      yield { chain: [...chain], params: { ...params } };
+      chain.length -= groupChain.length + 1;
+      if (prev !== undefined) {
+        params[child.paramName] = prev;
+      } else {
+        delete params[child.paramName];
+      }
     }
   }
 
-  // 5. Optional catch-all segments ([[...param]]) — same terminal rule
+  // 5. Optional catch-all segments
   for (const { child, groupChain } of effective) {
     if (
       child.segmentType === 'optional-catch-all' &&
@@ -252,11 +478,17 @@ function matchNode<TFile>(
       (!requireTerminal || isTerminal(child))
     ) {
       chain.push(...groupChain, child);
+      const prev = params[child.paramName];
       params[child.paramName] = parts.slice(index);
-      return true;
+      yield { chain: [...chain], params: { ...params } };
+      chain.length -= groupChain.length + 1;
+      if (prev !== undefined) {
+        params[child.paramName] = prev;
+      } else {
+        delete params[child.paramName];
+      }
     }
   }
 
   chain.pop();
-  return false;
 }

package/dist/_chunks/tree-match-CdbvYTBz.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-match-CdbvYTBz.js","names":[],"sources":["../../src/server/tree-match.ts"],"sourcesContent":["/**\n * Shared URL-matching tree walker for segment trees.\n *\n * Both the main route matcher (`route-matcher.ts`) and slot resolver\n * (`slot-resolver.ts`) need to walk a SegmentNode tree, matching URL\n * parts against children with the same priority semantics:\n *\n *   static > dynamic > catch-all > optional-catch-all\n *\n * Before this module, each had its own walker with subtle divergences\n * (different group handling, missing backtracking, incomplete\n * optional-catch-all support). This shared walker is the single\n * source of truth for URL-to-segment matching.\n *\n * See design/07-routing.md §\"Request Lifecycle\" and TIM-940.\n */\n\nimport type { SegmentNode } from '../routing/types.ts';\n\n// ─── Public API ───────────────────────────────────────────────────────────\n\n/** Result of matching URL parts against a segment tree. */\nexport interface TreeMatchResult<TFile> {\n  /** Matched segment chain from root to leaf, inclusive. */\n  chain: SegmentNode<TFile>[];\n  /** Collected params, keyed by param name. Catch-all params are string[]. */\n  params: Record<string, string | string[]>;\n}\n\nexport interface TreeMatchOptions {\n  /**\n   * When true (default), only match if the leaf node has a page or route\n   * handler. Set to false for metadata route matching, where we just need\n   * to find the owning segment regardless of whether it has a page.\n   */\n  requireTerminal?: boolean;\n}\n\n/**\n * Match URL path parts against a segment tree.\n *\n * Walks the tree depth-first with backtracking, applying priority\n * ordering globally across group boundaries. Returns the matched\n * segment chain and collected params, or null if no route matches.\n *\n * By default, a match requires a terminal node (one with `page` or\n * `route`) at the leaf. Pass `{ requireTerminal: false }` to match\n * any segment (used by metadata route matching).\n *\n * @param root  The root segment node to start matching from.\n * @param parts URL path parts (e.g. ['blog', 'hello-world']).\n *              Empty array matches the root itself (if terminal).\n */\nexport function matchUrlParts<TFile>(\n  root: SegmentNode<TFile>,\n  parts: string[],\n  options?: TreeMatchOptions\n): TreeMatchResult<TFile> | null {\n  const chain: SegmentNode<TFile>[] = [];\n  const params: Record<string, string | string[]> = {};\n  const requireTerminal = options?.requireTerminal ?? true;\n\n  if (matchNode(root, parts, 0, chain, params, requireTerminal)) {\n    return { chain, params };\n  }\n  return null;\n}\n\n// ─── Internal ─────────────────────────────────────────────────────────────\n\n/**\n * A child node flattened through group segments, along with the\n * chain of group nodes that must appear in the segment chain\n * before the child to preserve the tree path.\n */\ninterface EffectiveChild<TFile> {\n  child: SegmentNode<TFile>;\n  groupChain: SegmentNode<TFile>[];\n}\n\n/**\n * Flatten children through group segments.\n *\n * Groups are transparent for URL matching — their non-group descendants\n * are returned with the chain of group nodes leading to them. This lets\n * the caller apply priority ordering (static > dynamic > catch-all >\n * optional-catch-all) across all groups uniformly instead of per-group.\n */\nfunction collectEffectiveChildren<TFile>(\n  node: SegmentNode<TFile>,\n  groupChain: SegmentNode<TFile>[] = []\n): EffectiveChild<TFile>[] {\n  const result: EffectiveChild<TFile>[] = [];\n  for (const child of node.children) {\n    if (child.segmentType === 'group') {\n      const nested = collectEffectiveChildren(child, [...groupChain, child]);\n      result.push(...nested);\n    } else {\n      result.push({ child, groupChain });\n    }\n  }\n  return result;\n}\n\n/** A node is terminal if it can serve a response (has a page or route handler). */\nfunction isTerminal<TFile>(node: SegmentNode<TFile>): boolean {\n  return !!(node.page || node.route);\n}\n\n/** Combined affix length for specificity ordering. */\nfunction affixLength<TFile>(node: SegmentNode<TFile>): number {\n  return (node.paramPrefix?.length ?? 0) + (node.paramSuffix?.length ?? 0);\n}\n\n/**\n * Recursive depth-first matcher with backtracking.\n *\n * Mutates `chain` and `params` in place for performance; backtracks\n * (restores previous state) when a candidate doesn't lead to a match.\n */\nfunction matchNode<TFile>(\n  node: SegmentNode<TFile>,\n  parts: string[],\n  index: number,\n  chain: SegmentNode<TFile>[],\n  params: Record<string, string | string[]>,\n  requireTerminal: boolean\n): boolean {\n  chain.push(node);\n\n  // All parts consumed — check if this node is terminal (or any node if !requireTerminal)\n  if (index >= parts.length) {\n    if (!requireTerminal || isTerminal(node)) return true;\n\n    // Groups don't consume URL segments, so a group child's page can\n    // match at the same URL depth. Recurse into groups transparently.\n    for (const child of node.children) {\n      if (child.segmentType === 'group') {\n        if (matchNode(child, parts, index, chain, params, requireTerminal)) {\n          return true;\n        }\n      }\n    }\n\n    // Optional catch-all with zero segments (direct and through groups).\n    // The param is NOT set — matching Next.js semantics for [[...slug]]\n    // with no path segments.\n    const effective = collectEffectiveChildren(node);\n    for (const { child, groupChain } of effective) {\n      if (child.segmentType === 'optional-catch-all' && (!requireTerminal || isTerminal(child))) {\n        chain.push(...groupChain, child);\n        return true;\n      }\n    }\n\n    chain.pop();\n    return false;\n  }\n\n  const part = parts[index];\n\n  // Flatten children through groups so priority ordering applies globally.\n  const effective = collectEffectiveChildren(node);\n\n  // 1. Static segments (exact name match)\n  for (const { child, groupChain } of effective) {\n    if (child.segmentType === 'static' && child.segmentName === part) {\n      chain.push(...groupChain);\n      if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) {\n        return true;\n      }\n      chain.length -= groupChain.length;\n    }\n  }\n\n  // 2. Affixed dynamic segments (e.g. img-[id].png) — more specific than bare dynamic.\n  //    Sorted by specificity: longer combined prefix+suffix wins.\n  const affixed = effective.filter(\n    ({ child }) =>\n      child.segmentType === 'dynamic' && child.paramName && (child.paramPrefix || child.paramSuffix)\n  );\n  affixed.sort((a, b) => affixLength(b.child) - affixLength(a.child));\n  for (const { child, groupChain } of affixed) {\n    const prefix = child.paramPrefix ?? '';\n    const suffix = child.paramSuffix ?? '';\n    if (\n      part.length > prefix.length + suffix.length &&\n      (!prefix || part.startsWith(prefix)) &&\n      (!suffix || part.endsWith(suffix))\n    ) {\n      const value = part.slice(prefix.length, part.length - (suffix.length || 0));\n      chain.push(...groupChain);\n      const prev = params[child.paramName!];\n      params[child.paramName!] = value;\n      if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) {\n        return true;\n      }\n      // Backtrack\n      chain.length -= groupChain.length;\n      if (prev !== undefined) {\n        params[child.paramName!] = prev;\n      } else {\n        delete params[child.paramName!];\n      }\n    }\n  }\n\n  // 3. Bare dynamic segments ([param])\n  for (const { child, groupChain } of effective) {\n    if (\n      child.segmentType === 'dynamic' &&\n      child.paramName &&\n      !child.paramPrefix &&\n      !child.paramSuffix\n    ) {\n      chain.push(...groupChain);\n      const prev = params[child.paramName];\n      params[child.paramName] = part;\n      if (matchNode(child, parts, index + 1, chain, params, requireTerminal)) {\n        return true;\n      }\n      // Backtrack\n      chain.length -= groupChain.length;\n      if (prev !== undefined) {\n        params[child.paramName] = prev;\n      } else {\n        delete params[child.paramName];\n      }\n    }\n  }\n\n  // 4. Catch-all segments ([...param]) — must be terminal unless the\n  // caller passed requireTerminal:false (metadata route matching needs to\n  // find the owning segment even when it has no page).\n  for (const { child, groupChain } of effective) {\n    if (\n      child.segmentType === 'catch-all' &&\n      child.paramName &&\n      (!requireTerminal || isTerminal(child))\n    ) {\n      chain.push(...groupChain, child);\n      params[child.paramName] = parts.slice(index);\n      return true;\n    }\n  }\n\n  // 5. Optional catch-all segments ([[...param]]) — same terminal rule\n  for (const { child, groupChain } of effective) {\n    if (\n      child.segmentType === 'optional-catch-all' &&\n      child.paramName &&\n      (!requireTerminal || isTerminal(child))\n    ) {\n      chain.push(...groupChain, child);\n      params[child.paramName] = parts.slice(index);\n      return true;\n    }\n  }\n\n  chain.pop();\n  return false;\n}\n"],"mappings":"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"}