packages/router-core/src/process-route-tree.ts (4)

13-18: Good extraction of scoring knobs; add brief rationale docstrings.

Constants make tuning explicit. Add 1–2 line comments on why 0.75/1/0.2 were chosen to help future maintainers adjust safely.

---

85-91: Unify PATHNAME and slash handling to one branch.

Slightly simplifies control flow and ensures slash is only treated when type is PATHNAME.

-      if (segment.value === '/') {
-        return SLASH_SCORE
-      }
-
-      if (segment.type === SEGMENT_TYPE_PATHNAME) {
-        return STATIC_SEGMENT_SCORE
-      }
+      if (segment.type === SEGMENT_TYPE_PATHNAME) {
+        return segment.value === '/' ? SLASH_SCORE : STATIC_SEGMENT_SCORE
+      }

---

99-101: Prefer explicit wildcard handling over a catch-all else.

Future segment types will be accidentally scored as wildcard. Handle the wildcard explicitly and make unknown types obvious.

-      } else {
-        baseScore = WILDCARD_PARAM_BASE_SCORE
-      }
+      } else if (segment.type === SEGMENT_TYPE_WILDCARD) {
+        baseScore = WILDCARD_PARAM_BASE_SCORE
+      } else {
+        baseScore = 0 // unknown type; intentionally lowest score
+      }

Add the missing import:

// top of file
import { SEGMENT_TYPE_WILDCARD } from './path'

---

103-117: Guard the dynamic lookahead bonus to params only; avoid awarding wildcard and rename inner loop index.

Comment says the boost is for required/optional params, but current code applies to any non-PATHNAME (including wildcard). Guard it and avoid shadowing outer i.

-      // if there is any static segment (that is not an index) after a required / optional param,
-      // we will boost this param so it ranks higher than a required/optional param without a static segment after it
-      // JUST FOR SORTING, NOT FOR MATCHING
-      for (let i = index + 1; i < parsed.length; i++) {
-        const nextSegment = parsed[i]!
-        if (
-          nextSegment.type === SEGMENT_TYPE_PATHNAME &&
-          nextSegment.value !== '/'
-        ) {
-          hasStaticAfter = true
-          return handleParam(
-            segment,
-            baseScore + STATIC_AFTER_DYNAMIC_BONUS_SCORE,
-          )
-        }
-      }
-
-      return handleParam(segment, baseScore)
+      // Only boost required/optional params when a later static segment exists (not index '/')
+      if (
+        segment.type === SEGMENT_TYPE_PARAM ||
+        segment.type === SEGMENT_TYPE_OPTIONAL_PARAM
+      ) {
+        for (let j = index + 1; j < parsed.length; j++) {
+          const nextSegment = parsed[j]!
+          if (
+            nextSegment.type === SEGMENT_TYPE_PATHNAME &&
+            nextSegment.value !== '/'
+          ) {
+            hasStaticAfter = true
+            return handleParam(
+              segment,
+              baseScore + STATIC_AFTER_DYNAMIC_BONUS_SCORE,
+            )
+          }
+        }
+      }
+      return handleParam(segment, baseScore)

Optional: precompute a suffix array like hasStaticAfterFrom[i] in O(n) to avoid O(n^2) scans per route if paths get long.

Also applies to: 120-120

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro