perf: cut per-request overhead in the HTTP lifecycle

src/container/src/Container.php

@@ -381,6 +381,24 @@ public function isScoped(string $abstract): bool
         return false;
     }
 
+    /**
+     * Determine if a scoped binding has already been resolved in this coroutine.
+     *
+     * Scoped instances live in coroutine-local context, so this is false at the
+     * start of every request even for a binding resolved many times before.
+     * Callers that would only inspect an instance can use this to avoid paying
+     * for a full resolution — and the construction it implies — when nothing in
+     * the request asked for one.
+     *
+     * Only the scoped resolution path writes this context key, so its presence
+     * already implies the binding is scoped; singletons, auto-singletons and
+     * transient bindings never produce one.
+     */
+    public function resolvedScoped(string $abstract): bool
+    {
+        return CoroutineContext::has(self::SCOPED_CONTEXT_PREFIX . $this->getAlias($abstract));
+    }
+
     /**
      * Determine if a ReflectionClass has scoping attributes applied.
      *

src/context/src/CoroutineContext.php

@@ -32,7 +32,7 @@ class CoroutineContext
      */
     public static function set(UnitEnum|string $id, mixed $value, ?int $coroutineId = null): mixed
     {
-        $id = enum_value($id);
+        $id = is_string($id) ? $id : enum_value($id);
         $context = Coroutine::getContextFor($coroutineId);
 
         if ($context !== null) {
@@ -54,7 +54,7 @@ public static function set(UnitEnum|string $id, mixed $value, ?int $coroutineId
      */
     public static function get(UnitEnum|string $id, mixed $default = null, ?int $coroutineId = null): mixed
     {
-        $id = enum_value($id);
+        $id = is_string($id) ? $id : enum_value($id);
         $context = Coroutine::getContextFor($coroutineId);
 
         if ($context !== null) {
@@ -73,7 +73,7 @@ public static function get(UnitEnum|string $id, mixed $default = null, ?int $cor
      */
     public static function has(UnitEnum|string $id, ?int $coroutineId = null): bool
     {
-        $id = enum_value($id);
+        $id = is_string($id) ? $id : enum_value($id);
         $context = Coroutine::getContextFor($coroutineId);
 
         if ($context !== null) {
@@ -90,7 +90,7 @@ public static function has(UnitEnum|string $id, ?int $coroutineId = null): bool
      */
     public static function forget(UnitEnum|string $id, ?int $coroutineId = null): void
     {
-        $id = enum_value($id);
+        $id = is_string($id) ? $id : enum_value($id);
         $context = Coroutine::getContextFor($coroutineId);
 
         if ($context !== null) {

src/foundation/src/Http/Kernel.php

@@ -81,6 +81,18 @@ class Kernel implements KernelContract
      */
     protected array $requestLifecycleDurationHandlers = [];
 
+    /**
+     * Whether each middleware name resolves to a terminable instance.
+     *
+     * Keyed by the middleware string as it appears in the stack, parameters
+     * included. Populated on first termination and reused for the worker
+     * lifetime, so repeat requests skip parsing and resolving middleware that
+     * turned out to have no terminate() method.
+     *
+     * @var array<string, bool>
+     */
+    protected array $terminableMiddleware = [];
+
     /**
      * Context key for the current request's start time.
      *
@@ -127,7 +139,10 @@ public function __construct(Application $app, Router $router)
      */
     public function handle(Request $request): Response
     {
-        CoroutineContext::set(self::REQUEST_STARTED_AT_CONTEXT_KEY, CarbonImmutable::now());
+        CoroutineContext::set(
+            self::REQUEST_STARTED_AT_CONTEXT_KEY,
+            CarbonImmutable::hasTestNow() ? CarbonImmutable::now() : microtime(true)
+        );
 
         try {
             $request->enableHttpMethodParameterOverride();
@@ -232,9 +247,9 @@ public function terminate(Request $request, Response $response): void
         }
 
         try {
-            $requestStartedAt = CoroutineContext::get(self::REQUEST_STARTED_AT_CONTEXT_KEY);
-
-            if ($requestStartedAt !== null && $this->requestLifecycleDurationHandlers !== []) {
+            if ($this->requestLifecycleDurationHandlers !== []
+                && ($requestStartedAt = $this->requestStartedAt()) !== null
+            ) {
                 $requestStartedAt = $requestStartedAt->setTimezone(
                     $this->app->make('config')->string('app.timezone')
                 );
@@ -291,12 +306,24 @@ protected function terminateMiddleware(Request $request, Response $response): vo
                 continue;
             }
 
+            // Most middleware are not terminable, and resolving each one only to
+            // find it has no terminate() is the dominant cost of this method.
+            // Whether a name resolves to something terminable is fixed once
+            // bindings are registered — those are boot-only — so the answer is
+            // memoized and non-terminable middleware skip both the name parse
+            // and the resolution on later requests.
+            if (($this->terminableMiddleware[$middleware] ?? null) === false) {
+                continue;
+            }
+
             try {
                 [$name] = $this->parseMiddleware($middleware);
 
                 $instance = $this->app->make($name);
+                $terminable = method_exists($instance, 'terminate');
+                $this->terminableMiddleware[$middleware] = $terminable;
 
-                if (method_exists($instance, 'terminate')) {
+                if ($terminable) {
                     $instance->terminate($request, $response);
                 }
             } catch (Throwable $throwable) {
@@ -333,7 +360,17 @@ public function whenRequestLifecycleIsLongerThan(DateTimeInterface|CarbonInterva
      */
     public function requestStartedAt(): ?CarbonImmutable
     {
-        return CoroutineContext::get(self::REQUEST_STARTED_AT_CONTEXT_KEY);
+        $requestStartedAt = CoroutineContext::get(self::REQUEST_STARTED_AT_CONTEXT_KEY);
+
+        if (is_float($requestStartedAt)) {
+            $requestStartedAt = CarbonImmutable::createFromTimestamp(
+                $requestStartedAt,
+                date_default_timezone_get()
+            );
+            CoroutineContext::set(self::REQUEST_STARTED_AT_CONTEXT_KEY, $requestStartedAt);
+        }
+
+        return $requestStartedAt;
     }
 
     /**

src/foundation/src/Http/Middleware/Concerns/ExcludesPaths.php

@@ -5,6 +5,7 @@
 namespace Hypervel\Foundation\Http\Middleware\Concerns;
 
 use Hypervel\Http\Request;
+use Hypervel\Support\Str;
 
 trait ExcludesPaths
 {
@@ -13,12 +14,16 @@ trait ExcludesPaths
      */
     protected function inExceptArray(Request $request): bool
     {
+        $fullUrl = null;
+        $decodedPath = null;
+
         foreach ($this->getExcludedPaths() as $except) {
             if ($except !== '/') {
                 $except = trim($except, '/');
             }
 
-            if ($request->fullUrlIs($except) || $request->is($except)) {
+            if (Str::is($except, $fullUrl ??= $request->fullUrl())
+                || Str::is($except, $decodedPath ??= $request->decodedPath())) {
                 return true;
             }
         }

src/foundation/src/Http/Middleware/InvokeDeferredCallbacks.php

@@ -26,8 +26,16 @@ public function handle(Request $request, Closure $next): Response
      */
     public function terminate(Request $request, Response $response): void
     {
-        Container::getInstance()
-            ->make(DeferredCallbackCollection::class)
+        $container = Container::getInstance();
+
+        // The collection is scoped, so it only exists here if something in this
+        // request actually called defer(). Resolving it otherwise would build a
+        // collection on every request just to iterate nothing.
+        if (! $container->resolvedScoped(DeferredCallbackCollection::class)) {
+            return;
+        }
+
+        $container->make(DeferredCallbackCollection::class)
             ->invokeWhen(fn (DeferredCallback $callback) => $response->getStatusCode() < 400 || $callback->always);
     }
 }

src/foundation/src/Http/Middleware/TransformsRequest.php

@@ -39,6 +39,10 @@ protected function clean(Request $request): void
      */
     protected function cleanParameterBag(ParameterBag $bag): void
     {
+        if ($bag->count() === 0) {
+            return;
+        }
+
         $bag->replace($this->cleanArray($bag->all()));
     }
 

src/foundation/src/Http/Middleware/TrimStrings.php

@@ -55,9 +55,13 @@ public function handle(Request $request, Closure $next): mixed
      */
     protected function transform(string $key, mixed $value): mixed
     {
+        if (! is_string($value)) {
+            return $value;
+        }
+
         $except = array_merge($this->except, static::$neverTrim);
 
-        if ($this->shouldSkip($key, $except) || ! is_string($value)) {
+        if ($this->shouldSkip($key, $except)) {
             return $value;
         }
 

src/foundation/src/WorkerCachedMaintenanceMode.php

@@ -21,8 +21,13 @@ class WorkerCachedMaintenanceMode implements MaintenanceModeContract
 
     /**
      * The time when the cached snapshot was last refreshed.
+     *
+     * Stored as a Unix timestamp float rather than a Carbon instance: this is
+     * read on every request through the global middleware stack, and Carbon's
+     * interval arithmetic costs microseconds per comparison where a float
+     * subtraction costs nanoseconds.
      */
-    protected static ?CarbonImmutable $refreshedAt = null;
+    protected static ?float $refreshedAt = null;
 
     /**
      * Create a new worker-cached maintenance mode instance.
@@ -101,7 +106,7 @@ protected function loadSnapshot(): array
             ];
 
             // Set after successful reads so failed refreshes retry on the next request.
-            static::$refreshedAt = CarbonImmutable::now();
+            static::$refreshedAt = static::now();
         }
 
         return static::$snapshot;
@@ -117,6 +122,25 @@ protected function shouldRefreshSnapshot(): bool
         }
 
         return $this->refreshInterval > 0
-            && static::$refreshedAt->addSeconds($this->refreshInterval)->lte(CarbonImmutable::now());
+            && static::now() - static::$refreshedAt >= $this->refreshInterval;
+    }
+
+    /**
+     * Get the current time as a Unix timestamp in seconds.
+     *
+     * This runs on every request through the global middleware stack, so the
+     * common path uses microtime() rather than Carbon interval arithmetic —
+     * building two Carbon instances and an interval to compare them costs
+     * microseconds where a float subtraction costs nanoseconds. Carbon is only
+     * consulted when a test now is set, so time travel still drives refreshes.
+     */
+    protected static function now(): float
+    {
+        // Sub-second precision on both sides: getTimestamp() truncates to whole
+        // seconds, which over-reports the elapsed time between two fractional
+        // instants and would refresh the snapshot before the interval is up.
+        return CarbonImmutable::hasTestNow()
+            ? CarbonImmutable::now()->getPreciseTimestamp(6) / 1_000_000
+            : microtime(true);
     }
 }