Trim verbose comments and docblocks

Most of the explanatory blocks I added are restating obvious behavior
or duplicating what the PR description covers. Reduce to one-liners
where intent isn't already clear from the code.

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

Author: loks0n

src/Http/Adapter.php

@@ -13,16 +13,9 @@ abstract public function onRequest(callable $callback): void;
     abstract public function start(): void;
 
     /**
-     * Return the container for the current execution context:
-     *
-     * - Inside a request, the per-request container (coroutine-local
-     *   under the Swoole adapters), with parent-chain fallback to the
-     *   global container — so singleton lookups still resolve.
-     * - Outside a request (boot, onStart hooks), the global container
-     *   directly.
-     *
-     * Callers don't need to know which "scope" they're in; they get
-     * the right container for where they are.
+     * Container for the current execution context: the per-request
+     * container inside a request (coroutine-local under Swoole, with
+     * parent-chain fallback to global), the global container otherwise.
      */
     abstract public function getContext(): Container;
 }

src/Http/Http.php

@@ -136,11 +136,7 @@ public function __construct(Adapter $server, string $timezone)
         date_default_timezone_set($timezone);
         $this->files = new Files();
         $this->server = $server;
-        // Capture the global container at construction. INVARIANT: `Http`
-        // is constructed at boot, never inside a request. With no
-        // coroutine active, getContext() returns the global container
-        // directly — so this capture is stable for the lifetime of the
-        // Http instance.
+        // Captures the global container; assumes Http is constructed at boot, not inside a request.
         $this->container = $server->getContext();
         $this->setTelemetry(new NoTelemetry());
     }
@@ -411,13 +407,8 @@ public function setResource(string $name, callable $callback, array $injections
     }
 
     /**
-     * Set a request-scoped value on the current request's context container.
-     *
-     * The framework convention is: `setResource()` registers singletons on
-     * the global container; `setContext()` registers per-request values on
-     * the adapter's request container, which is coroutine-local under the
-     * Swoole adapters. `getResource()` reads from the request container
-     * with parent-fallback to the global one, so either kind resolves.
+     * Register a per-request value on the context container.
+     * Counterpart to setResource() for global singletons.
      *
      * @param list<string> $injections
      */
@@ -605,9 +596,7 @@ public function execute(Route $route, Request $request, Response $response): sta
         $context = $this->server->getContext();
         $match = $context->has('match') ? $context->get('match') : null;
         if (!$match instanceof RouteMatch || $match->route !== $route) {
-            // execute() called directly (e.g. from a test) without a prior
-            // match() — synthesize a RouteMatch so shutdown / error hooks
-            // injecting 'match' still see the route they're running under.
+            // execute() called directly without a prior match().
             $match = new RouteMatch($route, '');
             $context->set('match', fn() => $match);
         }
@@ -636,11 +625,6 @@ public function execute(Route $route, Request $request, Response $response): sta
             if (!$response->isSent()) {
                 $arguments = $this->getArguments($route, $pathValues, $request->getParams());
 
-                // Update the per-request RouteMatch with the resolved+
-                // validated argument map so shutdown / error hooks can
-                // read the same values the action saw — e.g. for label
-                // substitution like {request.fileId}. Race-free because
-                // the context container is per-request.
                 $resolved = [];
                 foreach ($route->getParams() as $name => $param) {
                     $resolved[$name] = $arguments[$param['order']] ?? null;
@@ -791,10 +775,6 @@ private function runInternal(Request $request, Response $response): static
 
         $this->setContext('request', fn() => $request);
         $this->setContext('response', fn() => $response);
-        // Seed 'match' to null up front so requestHooks, the global error
-        // path, and any pre-routing code can read it without tripping the
-        // "Failed to find resource" error from getResource('match'). It
-        // gets overwritten with the real RouteMatch once match() runs.
         $this->setContext('match', fn() => null);
 
         try {
@@ -869,8 +849,7 @@ private function runInternal(Request $request, Response $response): static
         }
 
         if (null === $route && null !== self::$wildcardRoute) {
-            // Clone so we can stamp the request URI onto $path without
-            // mutating the singleton shared across concurrent coroutines.
+            // Clone before stamping $path so concurrent coroutines don't fight over the singleton.
             $route = clone self::$wildcardRoute;
             $path = parse_url($request->getURI(), PHP_URL_PATH);
             $path = \is_string($path) ? ($path === '' ? '/' : $path) : '/';

src/Http/RouteMatch.php

@@ -5,23 +5,13 @@
 namespace Utopia\Http;
 
 /**
- * Bundle of everything the framework knows about how the current request
- * was routed: the matched Route, the prepared-path key it was matched
- * under (`$path`, with placeholders like ":::") and the name-keyed map
- * of resolved argument values.
+ * Routing state for the current request: the matched Route, the
+ * prepared-path key it matched under (placeholders → ":::"), and the
+ * resolved+validated argument map. `$arguments` is empty until
+ * `Http::execute()` writes it just before the route action runs;
+ * available to the action and downstream shutdown / error hooks.
  *
- * `$route` and `$path` are immutable. `$arguments` starts empty and is
- * written by the framework once — right before the route action runs,
- * after `getArguments()` has resolved and validated the action's
- * parameters. From that point on (action body, shutdown hooks, error
- * hooks) it holds the same values the action received.
- *
- * Init hooks run *before* this write, so they see `$arguments === []`.
- * The mutable property is safe because the RouteMatch lives on the
- * per-request context container (coroutine-local under the Swoole
- * adapters), so only the request's own coroutine touches it.
- *
- * Inject it into a hook or action with `->inject('match')`.
+ * Inject with `->inject('match')`.
  */
 final class RouteMatch
 {