Make 'route' injection frame-local instead of stateful

loks0n · claude · loks0n · commit b58bfab57000 · 2026-05-05T20:08:13.000+01:00
The save/restore pattern was just bookkeeping around a shared mutable
slot — anything else writing to context['route'] during dispatch would
break the restore, and a missed restore in any branch leaks the inner
match into the outer frame.

Drop context['route'] entirely. Pass the dispatch frame's Route through
to getArguments and special-case the 'route' injection there. Each
dispatch frame (including sub-requests via execute()) carries its own
matched Route as a parameter; nested calls can't trample each other
because there's no shared state to trample.

Telemetry in run() now reads the outer match by calling match() once
locally — match() is pure and cheap.

Co-Authored-By: Claude Opus 4.7 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/Http/Http.php b/src/Http/Http.php
@@ -552,23 +552,23 @@ public function execute(Request $request, Response $response): static
                     foreach (self::$options as $option) { // Group options hooks
                         /** @var Hook $option */
                         if (\in_array($group, $option->getGroups())) {
-                            \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams()));
+                            \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams(), $match->route));
                         }
                     }
                 }
 
                 foreach (self::$options as $option) { // Global options hooks
                     /** @var Hook $option */
                     if (\in_array('*', $option->getGroups())) {
-                        \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams()));
+                        \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams(), $match?->route));
                     }
                 }
             } catch (\Throwable $e) {
                 foreach (self::$errors as $error) { // Global error hooks
                     /** @var Hook $error */
                     if (\in_array('*', $error->getGroups())) {
                         $this->context()->set('error', fn() => $e, []);
-                        \call_user_func_array($error->getAction(), $this->getArguments($error, [], $request->getParams()));
+                        \call_user_func_array($error->getAction(), $this->getArguments($error, [], $request->getParams(), $match?->route));
                     }
                 }
             }
@@ -591,15 +591,11 @@ public function execute(Request $request, Response $response): static
         $arguments = [];
         $groups = $route->getGroups();
 
-        $context = $this->context();
-        $priorRoute = $context->has('route') ? $context->get('route') : null;
-        $context->set('route', fn() => $route, []);
-
         try {
             if ($route->getHook()) {
                 foreach (self::$init as $hook) { // Global init hooks
                     if (\in_array('*', $hook->getGroups())) {
-                        $arguments = $this->getArguments($hook, $match->params, $request->getParams());
+                        $arguments = $this->getArguments($hook, $match->params, $request->getParams(), $route);
                         \call_user_func_array($hook->getAction(), $arguments);
                     }
                 }
@@ -608,21 +604,21 @@ public function execute(Request $request, Response $response): static
             foreach ($groups as $group) {
                 foreach (self::$init as $hook) { // Group init hooks
                     if (\in_array($group, $hook->getGroups())) {
-                        $arguments = $this->getArguments($hook, $match->params, $request->getParams());
+                        $arguments = $this->getArguments($hook, $match->params, $request->getParams(), $route);
                         \call_user_func_array($hook->getAction(), $arguments);
                     }
                 }
             }
 
             if (!$response->isSent()) {
-                $arguments = $this->getArguments($route, $match->params, $request->getParams());
+                $arguments = $this->getArguments($route, $match->params, $request->getParams(), $route);
                 \call_user_func_array($route->getAction(), $arguments);
             }
 
             foreach ($groups as $group) {
                 foreach (self::$shutdown as $hook) { // Group shutdown hooks
                     if (\in_array($group, $hook->getGroups())) {
-                        $arguments = $this->getArguments($hook, $match->params, $request->getParams());
+                        $arguments = $this->getArguments($hook, $match->params, $request->getParams(), $route);
                         \call_user_func_array($hook->getAction(), $arguments);
                     }
                 }
@@ -631,7 +627,7 @@ public function execute(Request $request, Response $response): static
             if ($route->getHook()) {
                 foreach (self::$shutdown as $hook) { // Group shutdown hooks
                     if (\in_array('*', $hook->getGroups())) {
-                        $arguments = $this->getArguments($hook, $match->params, $request->getParams());
+                        $arguments = $this->getArguments($hook, $match->params, $request->getParams(), $route);
                         \call_user_func_array($hook->getAction(), $arguments);
                     }
                 }
@@ -643,7 +639,7 @@ public function execute(Request $request, Response $response): static
                 foreach (self::$errors as $error) { // Group error hooks
                     if (\in_array($group, $error->getGroups())) {
                         try {
-                            $arguments = $this->getArguments($error, $match->params, $request->getParams());
+                            $arguments = $this->getArguments($error, $match->params, $request->getParams(), $route);
                             \call_user_func_array($error->getAction(), $arguments);
                         } catch (\Throwable $e) {
                             throw new Exception('Error handler had an error: ' . $e->getMessage(), 500, $e);
@@ -655,15 +651,13 @@ public function execute(Request $request, Response $response): static
             foreach (self::$errors as $error) { // Global error hooks
                 if (\in_array('*', $error->getGroups())) {
                     try {
-                        $arguments = $this->getArguments($error, $match->params, $request->getParams());
+                        $arguments = $this->getArguments($error, $match->params, $request->getParams(), $route);
                         \call_user_func_array($error->getAction(), $arguments);
                     } catch (\Throwable $e) {
                         throw new Exception('Error handler had an error: ' . $e->getMessage(), 500, $e);
                     }
                 }
             }
-        } finally {
-            $context->set('route', fn() => $priorRoute, []);
         }
 
         return $this;
@@ -677,7 +671,7 @@ public function execute(Request $request, Response $response): static
      * @return array<int, mixed>
      * @throws Exception
      */
-    protected function getArguments(Hook $hook, array $values, array $requestParams): array
+    protected function getArguments(Hook $hook, array $values, array $requestParams, ?Route $route = null): array
     {
         $arguments = [];
         foreach ($hook->getParams() as $key => $param) { // Get value from route or request object
@@ -727,6 +721,13 @@ protected function getArguments(Hook $hook, array $values, array $requestParams)
         }
 
         foreach ($hook->getInjections() as $injection) {
+            // 'route' is frame-local: pass the dispatch frame's matched Route
+            // through directly instead of routing through shared context.
+            if ($injection['name'] === 'route') {
+                $arguments[$injection['order']] = $route;
+                continue;
+            }
+
             $arguments[$injection['order']] = $this->adapter->context()->get($injection['name']);
         }
 
@@ -756,13 +757,11 @@ public function run(Request $request, Response $response): static
         $start = microtime(true);
         $result = $this->runInternal($request, $response);
 
-        $route = $this->context()->has('route') ? $this->context()->get('route') : null;
-
         $requestDuration = microtime(true) - $start;
         $attributes = [
             'url.scheme' => $request->getProtocol(),
             'http.request.method' => $request->getMethod(),
-            'http.route' => $route instanceof Route ? $route->getPath() : null,
+            'http.route' => $this->match($request)?->route->getPath(),
             'http.response.status_code' => $response->getStatusCode(),
         ];
         $this->requestDuration->record($requestDuration, $attributes);

Original file line number	Diff line number	Diff line change
`@@ -552,23 +552,23 @@ public function execute(Request $request, Response $response): static`
`552`	`552`	`foreach (self::$options as $option) { // Group options hooks`
`553`	`553`	`/** @var Hook $option */`
`554`	`554`	`if (\in_array($group, $option->getGroups())) {`
`555`		`- \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams()));`
	`555`	`+ \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams(), $match->route));`
`556`	`556`	`}`
`557`	`557`	`}`
`558`	`558`	`}`
`559`	`559`
`560`	`560`	`foreach (self::$options as $option) { // Global options hooks`
`561`	`561`	`/** @var Hook $option */`
`562`	`562`	`if (\in_array('*', $option->getGroups())) {`
`563`		`- \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams()));`
	`563`	`+ \call_user_func_array($option->getAction(), $this->getArguments($option, [], $request->getParams(), $match?->route));`
`564`	`564`	`}`
`565`	`565`	`}`
`566`	`566`	`} catch (\Throwable $e) {`
`567`	`567`	`foreach (self::$errors as $error) { // Global error hooks`
`568`	`568`	`/** @var Hook $error */`
`569`	`569`	`if (\in_array('*', $error->getGroups())) {`
`570`	`570`	`$this->context()->set('error', fn() => $e, []);`
`571`		`- \call_user_func_array($error->getAction(), $this->getArguments($error, [], $request->getParams()));`
	`571`	`+ \call_user_func_array($error->getAction(), $this->getArguments($error, [], $request->getParams(), $match?->route));`
`572`	`572`	`}`
`573`	`573`	`}`
`574`	`574`	`}`
`@@ -591,15 +591,11 @@ public function execute(Request $request, Response $response): static`
`591`	`591`	`$arguments = [];`
`592`	`592`	`$groups = $route->getGroups();`
`593`	`593`
`594`		`- $context = $this->context();`
`595`		`- $priorRoute = $context->has('route') ? $context->get('route') : null;`
`596`		`- $context->set('route', fn() => $route, []);`
`597`		`-`
`598`	`594`	`try {`
`599`	`595`	`if ($route->getHook()) {`
`600`	`596`	`foreach (self::$init as $hook) { // Global init hooks`
`601`	`597`	`if (\in_array('*', $hook->getGroups())) {`
`602`		`- $arguments = $this->getArguments($hook, $match->params, $request->getParams());`
	`598`	`+ $arguments = $this->getArguments($hook, $match->params, $request->getParams(), $route);`
`603`	`599`	`\call_user_func_array($hook->getAction(), $arguments);`
`604`	`600`	`}`
`605`	`601`	`}`
`@@ -608,21 +604,21 @@ public function execute(Request $request, Response $response): static`
`608`	`604`	`foreach ($groups as $group) {`
`609`	`605`	`foreach (self::$init as $hook) { // Group init hooks`
`610`	`606`	`if (\in_array($group, $hook->getGroups())) {`
`611`		`- $arguments = $this->getArguments($hook, $match->params, $request->getParams());`
	`607`	`+ $arguments = $this->getArguments($hook, $match->params, $request->getParams(), $route);`
`612`	`608`	`\call_user_func_array($hook->getAction(), $arguments);`
`613`	`609`	`}`
`614`	`610`	`}`
`615`	`611`	`}`
`616`	`612`
`617`	`613`	`if (!$response->isSent()) {`
`618`		`- $arguments = $this->getArguments($route, $match->params, $request->getParams());`
	`614`	`+ $arguments = $this->getArguments($route, $match->params, $request->getParams(), $route);`
`619`	`615`	`\call_user_func_array($route->getAction(), $arguments);`
`620`	`616`	`}`
`621`	`617`
`622`	`618`	`foreach ($groups as $group) {`
`623`	`619`	`foreach (self::$shutdown as $hook) { // Group shutdown hooks`
`624`	`620`	`if (\in_array($group, $hook->getGroups())) {`
`625`		`- $arguments = $this->getArguments($hook, $match->params, $request->getParams());`
	`621`	`+ $arguments = $this->getArguments($hook, $match->params, $request->getParams(), $route);`
`626`	`622`	`\call_user_func_array($hook->getAction(), $arguments);`
`627`	`623`	`}`
`628`	`624`	`}`
`@@ -631,7 +627,7 @@ public function execute(Request $request, Response $response): static`
`631`	`627`	`if ($route->getHook()) {`
`632`	`628`	`foreach (self::$shutdown as $hook) { // Group shutdown hooks`
`633`	`629`	`if (\in_array('*', $hook->getGroups())) {`
`634`		`- $arguments = $this->getArguments($hook, $match->params, $request->getParams());`
	`630`	`+ $arguments = $this->getArguments($hook, $match->params, $request->getParams(), $route);`
`635`	`631`	`\call_user_func_array($hook->getAction(), $arguments);`
`636`	`632`	`}`
`637`	`633`	`}`
`@@ -643,7 +639,7 @@ public function execute(Request $request, Response $response): static`
`643`	`639`	`foreach (self::$errors as $error) { // Group error hooks`
`644`	`640`	`if (\in_array($group, $error->getGroups())) {`
`645`	`641`	`try {`
`646`		`- $arguments = $this->getArguments($error, $match->params, $request->getParams());`
	`642`	`+ $arguments = $this->getArguments($error, $match->params, $request->getParams(), $route);`
`647`	`643`	`\call_user_func_array($error->getAction(), $arguments);`
`648`	`644`	`} catch (\Throwable $e) {`
`649`	`645`	`throw new Exception('Error handler had an error: ' . $e->getMessage(), 500, $e);`
`@@ -655,15 +651,13 @@ public function execute(Request $request, Response $response): static`
`655`	`651`	`foreach (self::$errors as $error) { // Global error hooks`
`656`	`652`	`if (\in_array('*', $error->getGroups())) {`
`657`	`653`	`try {`
`658`		`- $arguments = $this->getArguments($error, $match->params, $request->getParams());`
	`654`	`+ $arguments = $this->getArguments($error, $match->params, $request->getParams(), $route);`
`659`	`655`	`\call_user_func_array($error->getAction(), $arguments);`
`660`	`656`	`} catch (\Throwable $e) {`
`661`	`657`	`throw new Exception('Error handler had an error: ' . $e->getMessage(), 500, $e);`
`662`	`658`	`}`
`663`	`659`	`}`
`664`	`660`	`}`
`665`		`- } finally {`
`666`		`- $context->set('route', fn() => $priorRoute, []);`
`667`	`661`	`}`
`668`	`662`
`669`	`663`	`return $this;`
`@@ -677,7 +671,7 @@ public function execute(Request $request, Response $response): static`
`677`	`671`	`* @return array<int, mixed>`
`678`	`672`	`* @throws Exception`
`679`	`673`	`*/`
`680`		`- protected function getArguments(Hook $hook, array $values, array $requestParams): array`
	`674`	`+ protected function getArguments(Hook $hook, array $values, array $requestParams, ?Route $route = null): array`
`681`	`675`	`{`
`682`	`676`	`$arguments = [];`
`683`	`677`	`foreach ($hook->getParams() as $key => $param) { // Get value from route or request object`
`@@ -727,6 +721,13 @@ protected function getArguments(Hook $hook, array $values, array $requestParams)`
`727`	`721`	`}`
`728`	`722`
`729`	`723`	`foreach ($hook->getInjections() as $injection) {`
	`724`	`+ // 'route' is frame-local: pass the dispatch frame's matched Route`
	`725`	`+ // through directly instead of routing through shared context.`
	`726`	`+ if ($injection['name'] === 'route') {`
	`727`	`+ $arguments[$injection['order']] = $route;`
	`728`	`+ continue;`
	`729`	`+ }`
	`730`	`+`
`730`	`731`	`$arguments[$injection['order']] = $this->adapter->context()->get($injection['name']);`
`731`	`732`	`}`
`732`	`733`
`@@ -756,13 +757,11 @@ public function run(Request $request, Response $response): static`
`756`	`757`	`$start = microtime(true);`
`757`	`758`	`$result = $this->runInternal($request, $response);`
`758`	`759`
`759`		`- $route = $this->context()->has('route') ? $this->context()->get('route') : null;`
`760`		`-`
`761`	`760`	`$requestDuration = microtime(true) - $start;`
`762`	`761`	`$attributes = [`
`763`	`762`	`'url.scheme' => $request->getProtocol(),`
`764`	`763`	`'http.request.method' => $request->getMethod(),`
`765`		`- 'http.route' => $route instanceof Route ? $route->getPath() : null,`
	`764`	`+ 'http.route' => $this->match($request)?->route->getPath(),`
`766`	`765`	`'http.response.status_code' => $response->getStatusCode(),`
`767`	`766`	`];`
`768`	`767`	`$this->requestDuration->record($requestDuration, $attributes);`