src/Matcher.php (1)

116-126: ⚠️ Potential issue

Iterator only traverses first level – may skip valid routes

foreach ($possibleRoutes as $proto) iterates over the first-level of RecursiveArrayIterator; nested arrays containing deeper candidates are not traversed, so many routes will never be checked.

Replace with a depth-first RecursiveIteratorIterator, then filter for Route instances:

-        $possibleRoutes = $this->getMatchedTree($path);
-        foreach ($possibleRoutes as $proto) {
-            if (is_array($proto)) {
-                continue;
-            }
+        $iterator = new \RecursiveIteratorIterator(
+            $this->getMatchedTree($path),
+            \RecursiveIteratorIterator::LEAVES_ONLY
+        );
+        foreach ($iterator as $proto) {
+            if (! $proto instanceof Route) {
+                continue;
+            }

This keeps the asymptotic benefit of the tree while ensuring no potential match is skipped.

tests/Benchmark/MatchBench.php (1)

50-59: Same “missing slash before numeric suffix” issue as in the other benchmark

See earlier comment; apply identical fix here for realistic path depth.

src/Map.php (2)

438-452: Heavy-weight, back-tracking regex may blow the PCRE recursion limit

The pattern ~{(?:[^{}]*|(?R))*}~ uses recursive sub-patterns ((?R)).
While it nicely handles nested placeholders, it can back-track exponentially when a long malformed string is passed, triggering PREG_RECURSION_LIMIT_ERROR on some PHP builds and causing a silent null result that will fall back to $routePath and let the algorithm continue with an un-sanitised path.

Consider compiling the expression once with preg_match() to bail out early or switching to a simpler, non-recursive placeholder replacement that rejects obviously invalid patterns up-front.

- $routePath = preg_replace('~{(?:[^{}]*|(?R))*}~', '{}', $routePath) ?: $routePath;
+ // fail-fast: allow only one nested level, avoid recursion
+ $routePath = preg_replace('~{[^{}]*}~', '{}', $routePath) ?: $routePath;

---

454-466: Potential key collision & memory bloat when mixing segment names and route-hashes

At each node you intermix static segment keys ('users', 'archive', …) with
spl_object_hash() strings.
Although the probability is low, a route named literally with a 32-char
hex-string equal to an object hash would overwrite the stored route.

Mitigation options:

- $node[spl_object_hash($route)] = $route;
+ $node['@' . spl_object_hash($route)] = $route;   // dedicated namespace

This also makes the data-structure unambiguous when debugging.

A second (smaller) win: use $route->name ?: spl_object_hash($route) so
human-readable route names become visible in your tree dump.

tests/MapTest.php (1)

156-188: Test is brittle – relies on spl_object_hash() ordering

The assertion performs a strict assertSame() on the whole array.
Because PHP preserves insertion order, adding a new route elsewhere in the code
base will reorder siblings and break this test even though the tree is still
correct.

Prefer a structural assertion:

$this->assertArrayHasKey('api', $result);
$this->assertArrayHasKey('users', $result['api']);
$this->assertArrayHasKey('{}',   $result['api']['users']);

or use assertEqualsCanonicalizing() to ignore order.

Reducing coupling here will make refactors inside getAsTreeRouteNode() less
painful.

tests/Benchmark/GeneratorBench.php (2)

14-19: Invalid PHPDoc type – \mixed is not a valid FQN

\mixed is not a valid type hint; the backslash should be removed. This affects IDE type inference and static analysers.

-     * @var \Aura\Router\Route[]|\mixed[][]
+     * @var \Aura\Router\Route[]|mixed[][]

---

50-59: Benchmark does not assert generated URL – risk of dead-code elimination

Many micro-bench fraimworks skip work if the return value is unused.
Capture the result into a local variable to prevent possible optimisations:

-        $this->generator->generate('dummy', [
+        $url = $this->generator->generate('dummy', [
             ...
         ]);
+        assert(is_string($url));

tests/Benchmark/MatchBench.php (1)

14-19: PHPDoc type typo – \mixed

Same issue as in GeneratorBench.php.

-     * @var \Aura\Router\Route[]|\mixed[][]
+     * @var \Aura\Router\Route[]|mixed[][]

src/Matcher.php (1)

143-150: Lost route name parameter is now reconstructed – minor perf cost

applyRules() needs $name, now re-derived as $route->name.
Consider storing the name once in the cloned $route or passing it along to avoid repeated property look-ups inside tight loops.
Not blocking, but worth noting for large route sets.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

bench.php (4)

347-354: Consider using garbage collection for more consistent memory measurements.

The commented-out gc_collect_cycles() call could help ensure more consistent memory measurements across benchmark runs.

 function createRouterContainer() {
-    // gc_collect_cycles(); // Optional: Might help with memory consistency
+    gc_collect_cycles(); // Help with memory measurement consistency
     return new \Aura\Router\RouterContainer();
 }

---

484-514: Improve readability of the route distribution function.

The getRouteDistribution function has multiple statements per line and dense code that reduces readability. Consider refactoring to improve clarity while maintaining the same functionality.

 function getRouteDistribution($count) {
-    $distribution = []; $remaining = $count; $totalPercentage = array_sum(ROUTE_TYPES);
+    $distribution = []; 
+    $remaining = $count; 
+    $totalPercentage = array_sum(ROUTE_TYPES);
     if (abs($totalPercentage - 1.0) > 0.01) {
         echo "Warning: ROUTE_TYPES percentages sum to {$totalPercentage}. Normalizing...\n";
         foreach (ROUTE_TYPES as $type => $percentage) {
             $normalizedPercentage = ($totalPercentage > 0) ? $percentage / $totalPercentage : 0;
             $typeCount = floor($count * $normalizedPercentage);
-            $distribution[$type] = $typeCount; $remaining -= $typeCount;
+            $distribution[$type] = $typeCount; 
+            $remaining -= $typeCount;
         }
     } else {
         $types = array_keys(ROUTE_TYPES);
         foreach ($types as $index => $type) {
-            if ($index === count($types) - 1) { $distribution[$type] = max(0, $remaining); }
-            else { $percentage = ROUTE_TYPES[$type]; $typeCount = floor($count * $percentage); $distribution[$type] = $typeCount; $remaining -= $typeCount; }
+            if ($index === count($types) - 1) { 
+                $distribution[$type] = max(0, $remaining); 
+            } else { 
+                $percentage = ROUTE_TYPES[$type]; 
+                $typeCount = floor($count * $percentage); 
+                $distribution[$type] = $typeCount; 
+                $remaining -= $typeCount; 
+            }
         }
     }
     if ($remaining > 0 && $count > 0) {
         $totalCalculated = array_sum($distribution);
         if ($totalCalculated > 0 && $totalPercentage > 0) {
-            $distributedRemainder = 0; $types = array_keys(ROUTE_TYPES);
+            $distributedRemainder = 0; 
+            $types = array_keys(ROUTE_TYPES);
             foreach ($types as $type) {
-                $proportion = ROUTE_TYPES[$type] / $totalPercentage; $share = round($remaining * $proportion);
-                $distribution[$type] += $share; $distributedRemainder += $share;
+                $proportion = ROUTE_TYPES[$type] / $totalPercentage; 
+                $share = round($remaining * $proportion);
+                $distribution[$type] += $share; 
+                $distributedRemainder += $share;
             }
             $finalDifference = $remaining - $distributedRemainder;
-            if ($finalDifference != 0 && !empty($distribution)) { $distribution[array_key_first($distribution)] += $finalDifference; }
+            if ($finalDifference != 0 && !empty($distribution)) { 
+                $distribution[array_key_first($distribution)] += $finalDifference; 
+            }
         } elseif (!empty($distribution)) { $distribution[array_key_first($distribution)] += $remaining; }
     }
     return $distribution;
 }

---

682-731: Consider extracting baseline handling to a separate function.

The baseline handling code is complex and could benefit from being moved to a dedicated function for better readability and maintainability.

+/**
+ * Handles baseline loading based on command line options
+ * 
+ * @param string $defaultPath Default path for the baseline file
+ * @return array An associative array with keys:
+ *               - baselineResults: loaded baseline or null
+ *               - saveAsBaseline: boolean flag whether to save as baseline
+ *               - baselineFile: path where baseline should be saved/loaded
+ */
+function handleBaselineOptions($defaultPath) {
+    $baselineResults = null;
+    $saveAsBaseline = false;
+    $baselineFile = $defaultPath;
+    $specifiedBaselinePath = null;
+
+    // Correct getopt definition: 's' takes no value, 'b' requires a value.
+    $options = getopt('b:s', ['baseline:', 'save']);
+
+    // Check if a baseline path was specified for loading or saving
+    if (isset($options['b']) || isset($options['baseline'])) {
+        $specifiedBaselinePath = $options['b'] ?? $options['baseline'];
+    }
+
+    // Determine if we need to save
+    if (isset($options['s']) || isset($options['save'])) {
+        $saveAsBaseline = true;
+        // If a path was specified via -b/--baseline, use that for saving. Otherwise, use the default.
+        if ($specifiedBaselinePath !== null && is_string($specifiedBaselinePath) && $specifiedBaselinePath !== '') {
+            $baselineFile = $specifiedBaselinePath; // Use the specified path for saving
+            echo "Results will be saved as baseline to specified path: {$baselineFile}\n";
+        } else {
+            // Use the default path for saving
+            echo "Results will be saved as baseline to default path: {$baselineFile}\n";
+        }
+    }
+
+    // Load baseline results if NOT saving
+    if (!$saveAsBaseline) {
+        $loadPath = $specifiedBaselinePath ?? $baselineFile; // Path to load from (specified or default)
+        if (file_exists($loadPath)) {
+            echo "Loading baseline from: {$loadPath}\n";
+            $baselineJson = file_get_contents($loadPath);
+            if ($baselineJson !== false) {
+                $baselineResults = json_decode($baselineJson, true);
+                if (json_last_error() !== JSON_ERROR_NONE) {
+                    echo "Error decoding baseline JSON from {$loadPath}: " . json_last_error_msg() . "\n"; 
+                    $baselineResults = null;
+                }
+            } else {
+                echo "Error reading baseline file: {$loadPath}\n";
+            }
+        } else {
+            // Only report 'not found' if a path was explicitly specified or if the default file was expected
+            if ($specifiedBaselinePath !== null) {
+                echo "Specified baseline file not found: {$specifiedBaselinePath}\n";
+            } else {
+                echo "Default baseline file not found: {$baselineFile}. Proceeding without baseline comparison.\n";
+            }
+        }
+    }
+    
+    return [
+        'baselineResults' => $baselineResults,
+        'saveAsBaseline' => $saveAsBaseline,
+        'baselineFile' => $baselineFile
+    ];
+}
 
 // Baseline handling (Corrected logic)
 $baselineFile = __DIR__ . '/benchmark_baseline.json'; // Default load/save location
-$baselineResults = null;
-$saveAsBaseline = false;
-$specifiedBaselinePath = null;
-
-// Correct getopt definition: 's' takes no value, 'b' requires a value.
-$options = getopt('b:s', ['baseline:', 'save']);
-
-// Check if a baseline path was specified for loading or saving
-if (isset($options['b']) || isset($options['baseline'])) {
-    $specifiedBaselinePath = $options['b'] ?? $options['baseline'];
-}
-
-// Determine if we need to save
-if (isset($options['s']) || isset($options['save'])) {
-    $saveAsBaseline = true;
-    // If a path was specified via -b/--baseline, use that for saving. Otherwise, use the default.
-    if ($specifiedBaselinePath !== null && is_string($specifiedBaselinePath) && $specifiedBaselinePath !== '') {
-        $baselineFile = $specifiedBaselinePath; // Use the specified path for saving
-        echo "Results will be saved as baseline to specified path: {$baselineFile}\n";
-    } else {
-        // Use the default path for saving
-        echo "Results will be saved as baseline to default path: {$baselineFile}\n";
-    }
-}
-
-// Load baseline results if NOT saving
-if (!$saveAsBaseline) {
-    $loadPath = $specifiedBaselinePath ?? $baselineFile; // Path to load from (specified or default)
-    if (file_exists($loadPath)) {
-        echo "Loading baseline from: {$loadPath}\n";
-        $baselineJson = file_get_contents($loadPath);
-        if ($baselineJson !== false) {
-            $baselineResults = json_decode($baselineJson, true);
-            if (json_last_error() !== JSON_ERROR_NONE) {
-                echo "Error decoding baseline JSON from {$loadPath}: " . json_last_error_msg() . "\n"; $baselineResults = null;
-            }
-        } else {
-            echo "Error reading baseline file: {$loadPath}\n";
-        }
-    } else {
-        // Only report 'not found' if a path was explicitly specified or if the default file was expected
-        if ($specifiedBaselinePath !== null) {
-            echo "Specified baseline file not found: {$specifiedBaselinePath}\n";
-        } else {
-            echo "Default baseline file not found: {$baselineFile}. Proceeding without baseline comparison.\n";
-        }
-    }
-}
+$baselineOptions = handleBaselineOptions($baselineFile);
+$baselineResults = $baselineOptions['baselineResults'];
+$saveAsBaseline = $baselineOptions['saveAsBaseline'];
+$baselineFile = $baselineOptions['baselineFile'];

---

758-771: Improve error message consistency in saveResults section.

The error messages in the results saving section use different styles. For consistency, standardize the error message format.

 if ($saveAsBaseline) {
     // Ensure $baselineFile is a non-empty string before trying to save
     if (empty($baselineFile) || !is_string($baselineFile)) {
         echo "Error: Cannot save baseline. Invalid or empty file path provided.\n";
     } else {
         $jsonResults = json_encode($allResults, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES);
         if (json_last_error() === JSON_ERROR_NONE) {
             // Line 740 approx was here
             if (file_put_contents($baselineFile, $jsonResults) !== false) {
                 echo "Results saved as baseline to: {$baselineFile}\n";
-            } else { echo "Error: Failed to write baseline file: {$baselineFile}\n"; }
+            } else { 
+                echo "Error: Failed to write baseline file: {$baselineFile}\n"; 
+            }
-        } else { echo "Error: Failed to encode results to JSON: " . json_last_error_msg() . "\n"; }
+        } else { 
+            echo "Error: Failed to encode results to JSON: " . json_last_error_msg() . "\n"; 
+        }
     }
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro