Save/restore context['route'] across execute() dispatch

match() no longer writes to context — that was leaking the inner
match into the outer's context whenever execute() was called for a
sub-request, breaking outer-request shutdown hooks doing
->inject('route') and the http.route telemetry attribute.

execute() now sets context['route'] right before dispatching and
restores the prior value (or null) in a finally clause, so nested
execute() calls don't trample each other's frame.

Adds testSubrequestRestoresOuterRoute as a regression test.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: loks0n

src/Http/Http.php

@@ -517,16 +517,7 @@ public function match(Request $request): ?RouteMatch
         $method = $request->getMethod();
         $method = (self::REQUEST_METHOD_HEAD === $method) ? self::REQUEST_METHOD_GET : $method;
 
-        $match = Router::match($method, $url);
-
-        if ($match === null) {
-            return null;
-        }
-
-        $route = $match->route;
-        $this->context()->set('route', fn() => $route, []);
-
-        return $match;
+        return Router::match($method, $url);
     }
 
     /**
@@ -600,6 +591,10 @@ 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
@@ -667,6 +662,8 @@ public function execute(Request $request, Response $response): static
                     }
                 }
             }
+        } finally {
+            $context->set('route', fn() => $priorRoute, []);
         }
 
         return $this;

tests/HttpTest.php

@@ -710,6 +710,37 @@ public function testCanRunRequest(): void
         $this->assertStringNotContainsString('HELLO', $result);
     }
 
+    public function testSubrequestRestoresOuterRoute(): void
+    {
+        $_SERVER['REQUEST_METHOD'] = 'GET';
+
+        $captured = [];
+
+        Http::shutdown()
+            ->inject('route')
+            ->action(function (Route $route) use (&$captured) {
+                $captured[] = $route->getPath();
+            });
+
+        Http::get('/inner')->action(function () {
+            // no-op handler — only here so the inner dispatch matches
+        });
+
+        Http::get('/outer')->action(function () {
+            $inner = new Request();
+            $inner->setMethod('GET');
+            $inner->setURI('/inner');
+            $this->http->execute($inner, new Response());
+        });
+
+        $_SERVER['REQUEST_URI'] = '/outer';
+        $this->http->execute(new Request(), new Response());
+
+        // Inner's shutdown fires first (with inner route), then outer's
+        // shutdown — which must see the outer route, not the inner one.
+        $this->assertEquals(['/inner', '/outer'], $captured);
+    }
+
     public function testWildcardRoute(): void
     {
         $method = $_SERVER['REQUEST_METHOD'] ?? null;