Classes
Single source of truth for boot-time auth redirect wiring.
These methods are typically the same across all guards.
Keep failed user lookups local to the coroutine that resolved them.
Track dispatch lock ownership until a queue accepts the job.
Tagged cache for any-mode tag semantics.
Redis-optimized concurrency limiter.
Coordinate shared model cache fills and exact invalidations.
Base for tag sets whose tags namespace the item keyspace.
Tagged cache for namespaced tag semantics.
Namespace for the sentinel array value stored in place of null by the nullable cache wrapper methods.
Any-mode tag set for Redis 8.0+ enhanced tagging.
Any-mode tagged cache for Redis 8.0+ enhanced tagging.
Context object that bundles shared state for benchmark scenarios.
Formats and displays benchmark results.
Simple container for benchmark scenario results.
Tests bulk write (putMany) performance with tags.
Tests cleanup command performance after creating orphaned tags.
Tests deep tagging with a single tag across many items.
Tests heavy tagging with many tags per item.
Tests non-tagged cache operations (put, get, forget, remember, putMany, add).
Tests read performance after tagged write operations.
Interface for benchmark scenarios.
Tests standard tagging with write and flush operations.
Provides store detection functionality for commands.
Result container for Doctor checks.
Tests add() operation (only stores if key doesn't exist).
Tests basic cache operations: put, get, has, missing, forget, pull, remember.
Tests bulk operations: putMany() and many().
Checks and displays cache store configuration.
Interface for functional Doctor checks.
Verifies that cleanup properly removes all test data.
Tests Redis atomicity under concurrent coroutine operations.
Tests edge cases: null, zero, empty string, special characters, complex data.
Interface for environment/requirement checks.
Tests TTL expiration behavior.
Tests flush behavior semantics.
Tests forever() storage (no expiration).
Checks that hash-field expiration commands are available.
Verifies Redis hash structures are created correctly.
Tests increment and decrement operations with and without tags.
Tests performance with large datasets (500+ items).
Tests memory leak prevention through tag reference expiration.
Tests operations with multiple tags.
Checks that PHPRedis is installed with the version required by the tag mode.
Checks that Redis/Valkey version meets requirements.
Tests rapid sequential operations.
Tests shared tag flush behavior and orphan handling.
Tests tagged cache operations: tagged put, get, flush.
Tests remember() and rememberForever() with tags.
Context object holding shared state for Doctor checks.
Exception thrown when the benchmark command runs out of memory.
Store an item in the cache if it doesn't exist (non-tagged).
Store an item in the cache if it doesn't exist, with all tag tracking.
Adds a cache key reference to all tag sorted sets.
Decrement a value in the cache with all tag tracking.
Flushes stale entries from tag sorted sets.
Store an item in the cache indefinitely with all tag tracking.
Increment a value in the cache with all tag tracking.
Prune stale and orphaned entries from all-mode tag sorted sets.
Store an item in the cache with all tag tracking.
Store multiple items in the cache with all tag tracking.
Adjust the expiration time of a tagged cache item and its tag entries.
Store an item in the cache if it doesn't exist, with tags support.
Decrement the value of an item in the cache with tags support.
Flush scanned tag members without deleting concurrently added memberships.
Store an item in the cache indefinitely with tags support.
Remove an item from the cache along with its tag membership.
Get all items (keys and values) for the given tags.
Get all keys associated with a tag.
Increment the value of an item in the cache with tags support.
Prune orphaned fields and registry entries from any-mode tag hashes.
Store an item in the cache with tags support.
Store multiple items in the cache with tags support.
Adjust the expiration time of a cached item and its tag metadata.
Decrement the value of an item in the cache.
Remove all items from the cache (flush the database).
Store an item in the cache indefinitely (no expiration).
Remove an item from the cache.
Retrieve an item from the cache by key.
Increment the value of an item in the cache.
Retrieve multiple items from the cache by key.
Store an item in the cache for a given number of seconds.
Store multiple items in the cache (non-tagged).
Adjust the expiration time of a cached item.
Detects monitoring and profiling tools that affect benchmark accuracy.
Handles serialization for cache values.
Mode-aware context for Redis cache operations.
Builds Redis-internal tag storage key names.
Fallback implementations for stores without native multi-key operations.
Any-mode tag set for the stack store.
Any-mode tagged cache for the stack store.
Coordinates multi-step Swoole table row mutations across workers.
Generic namespaced tag set for stores without a native tag index.
Decode serialized-closure responses produced by the framework subprocess command.
Track recent borrowing activity to shrink pools during periods of low usage.
Manage reusable connections with explicit ownership and terminal teardown.
Check one idle connection at each interval, independently of borrowing activity.
Abstract connection that maintains a keepalive heartbeat.
Dispatched inside the command execution boundary after execution completes.
Dispatched inside the command execution boundary after its handle method completes successfully.
Dispatched inside the command execution boundary, immediately before its handle method is called.
Define a binding selected by a boot-stable condition.
Cached reflection analysis used to resolve an unbound concrete class.
Mutable state for one container resolution chain.
Cached dependency parameter metadata.
Coordinates one cacheable first resolution across coroutines.
Marks objects that control what is installed when coroutine context is copied between coroutines.
Capability interface for cache wrappers that can bypass non-authoritative read layers.
Capability interface for cache layers that expose raw reads (returns the value as it was stored, including the internal NullSentinel::VALUE marker used by the nullable cache methods).
A lock that supports refreshing its TTL and inspecting remaining lifetime.
Marker interface for commands that should only run one instance at a time.
Mark a class as requiring a fresh instance for every unbound resolution.
This interface is intentionally empty and exists to improve IDE support.
Do not use constructor property promotion here.
This interface is intentionally empty and exists to improve IDE support.
Image transformations must be immutable because cloned pipelines share their instances.
A held concurrency-limiter slot.
A lease that supports refreshing its TTL and inspecting remaining lifetime.
Low-level PSR-3 logger that writes directly to stdout.
Coordinate short key-scoped critical sections across Swoole workers.
A singleton pool for reusing Channel instances.
An independently canceled child whose owner remains active.
Wrapper for passing exceptions through channels.
Exception thrown when parallel execution encounters one or more errors.
Store idle objects independently of execution mode and signal coroutine waiters.
Resolve one shared instance per process through the container. Separate instances create competing native waits for the same signal and lose earlier handlers.
Go-style WaitGroup for waiting on multiple coroutines.
Immutable options and hooks shared by one complete construction operation.
Immutable property order for lean construction.
Immutable construction and transformation metadata for one data class.
Immutable property order for lean transformation.
Immutable output from one complete validation-rule compilation.
Retain one translated rule path and its collection-wide identity.
Interface for connection resolvers that maintain internal caches.
Standalone database manager for non-production use outside full application bootstrap.
Resolves database connections from a connection pool.
Manages database transaction callbacks in a coroutine-safe manner.
Mark a static method as a boot method for a trait.
Mark a method as an initialize method for a trait.
Declare observers for a model using an attribute.
Mark a method as a local query scope.
Declare global scopes to be automatically applied to the model.
Declare the Eloquent builder class for a model using an attribute.
Declare the factory class for a model using an attribute.
Declare the policy class for a model using an attribute.
Declare the resource class for a model using an attribute.
Declare the resource collection class for a model using an attribute.
Forwarded query methods operate on this builder, so their value type is TModel.
Provides the ability to transform a model to a JSON resource.
Declare the model class for a factory using an attribute.
Resolve declared builders while preserving Eloquent and relation forwarding.
Describe a forwarded fluent method whose runtime result is the receiving object.
Describe Eloquent builder methods forwarded through models.
Describe a builder method forwarded through an Eloquent model.
Resolve model methods exposed as named Eloquent scopes.
Preserve model-relative parameter types on an exposed scope method.
Bind model-relative types resolved for an Eloquent receiver.
Describe model scopes exposed through models, builders, and relations.
Describe a model scope as invoked through an Eloquent receiver.
Database connection pool.
Wraps a database Connection for use with Hypervel's connection pool.
A simple, non-pooled connection resolver for testing and Capsule environments.
Static registry of aspect class rules and priorities.
Runtime cache of resolved aspects per class::method.
Registry of AST visitors used during proxy class generation.
Marks generated AOP proxies without injecting callable behavior.
Generate AOP proxy classes for registered aspects.
Manages class map overrides applied to Composer's autoloader.
Adapt operation-scoped access to a Flysystem operator.
Isolate every filesystem path behind a dynamically resolved prefix on a fixed disk or one resolved for each operation.
Prevent Symfony Terminal from repeatedly spawning stty when headless.
Resolve dump sources for consumers that provide $basePath and $compiledViewPath properties.
Resolve source links for consumers that provide a $basePath property.
Tracks configuration mutations made during application boot for worker replay.
The shared response and cancellation boundary for framework health routes.
Run a test without configuring the Hypervel framework.
Add Algolia support to an integration test.
Provides a test helper for invoking a method through the AOP pipeline without relying on generated proxies.
Add Meilisearch support to an integration test.
Provides per-worker database isolation for parallel testing.
Provides Redis integration testing support.
Provides test server integration testing support.
Add Typesense support to an integration test.
Skips tests when the environment doesn't support Redis hash field expiration.
Database connection resolver for the testing environment.
Testing-aware transaction manager that properly handles RefreshDatabase's wrapper transaction.
This concern may be combined with RefreshDatabase or DatabaseTransactions; each trait should manage its own connections. It cannot be combined with DatabaseMigrations or LazilyRefreshDatabase.
Generated from protobuf message grpc.health.v1.HealthCheckRequest.
Generated from protobuf message grpc.health.v1.HealthCheckResponse.
Protobuf type grpc.health.v1.HealthCheckResponse.ServingStatus.
Generated from protobuf message grpc.health.v1.HealthListRequest.
Generated from protobuf message grpc.health.v1.HealthListResponse.
Map service and protocol failures without invoking the HTTP exception renderer.
Carry a complete protocol-owned gRPC response to the HTTP/2 bridge.
Isolate gRPC routes while retaining Hypervel's normal dispatch machinery.
Carry a lazily produced protocol-owned gRPC stream to the HTTP/2 bridge.
Decode and scope one supported inbound gRPC call.
Map failures at the closest gRPC middleware boundary.
Convert service values and failures into protocol-owned gRPC responses.
Serve the isolated gRPC router on its dedicated HTTP/2 listener.
Base event for HTTP server request lifecycle observations.
Store Swoole's already-separated headers directly, avoiding HeaderBag::set() normalization for every header while still parsing Cache-Control once.
Inline Symfony's side-effect-free common response preparation path.
Prefer Guzzle for PSR-18 HTTP client auto-discovery.
Retain iterable chunks so the Swoole bridge can stop production after a failed write.
Response headers optimized for Swoole emission.
Share one lazy source across every image derived from it.
Inertia configuration and request state stored in coroutine Context.
Represents a paginated property that can be merged during partial reloads.
Validate not-before timestamps during normal decoding and refresh.
Wraps the resolved context log processor in a known type.
Hosts must declare a protected array $poolableDrivers containing their default poolable drivers.
Hold one execution unit's inherited context and locally attached scopes.
Store OpenTelemetry context in Hypervel's coroutine-local context.
Represent one context attachment owned by a single execution unit.
Retain a replayable OpenTelemetry instrumentation-scope descriptor.
Keep a pre-fork logger handle usable after a worker provider is bound.
Defer real logger creation until a worker-local provider is available.
Detach deferred callbacks when their bound target is collected.
Keep a pre-fork counter usable after a worker meter is bound.
Keep a pre-fork gauge usable after a worker meter is bound.
Keep a pre-fork histogram usable after a worker meter is bound.
Keep pre-fork metric instruments and callbacks usable after worker binding.
Defer real meter creation until a worker-local provider is available.
Keep one detachable observable callback active across worker rebinding.
Keep a pre-fork observable counter and its creation callbacks replayable.
Keep a pre-fork observable gauge and its creation callbacks replayable.
Keep a pre-fork observable up-down counter and its callbacks replayable.
Keep a pre-fork up-down counter usable after a worker meter is bound.
Keep a pre-fork tracer handle usable after a worker provider is bound.
Defer real tracer creation until a worker-local provider is available.
Create OTLP/HTTP exporters with coroutine-compatible Guzzle transports.
Resolve operation origins through one shared context-key identity.
AAGUID to authenticator name mapping.
This class provides a static interface to the webauthn-lib package, handling serialization, deserialization, and validation of WebAuthn ceremonies.
Track registration and ownership for one permission cache settlement.
Build Permission relations from one immutable partition and team snapshot.
An immutable description of a class-string pipeline pipe.
Track bounded incremental output owned by a Task operation.
Logger implementation for in-process Task execution.
Own one interruptible prompt animation coroutine and its render failure.
Encode and incrementally decode Task transport frames.
Keep the reserving Pheanstalk connection pinned until the backend's terminal release, bury, or delete command has completed.
Hold rate limiter state local to one cooperative worker.
Exception thrown when a Lua script execution fails.
A held slot in a Redis funnel limiter.
Shared Redis Lua scripts for lock and limiter primitives.
Flush (delete) Redis keys matching a pattern.
Safely scan the Redis keyspace for keys matching a pattern.
Redis Cluster connection using phpredis RedisCluster client.
Standard phpredis connection for standalone Redis and Sentinel.
Classify Redis cancellation and preserve failure precedence during cleanup.
Abstract base class for pooled Redis connections with Laravel-style method transformations.
Pool-aware Redis connection proxy.
Coroutine multi-exec trait.
Immutable scoped proxy for the ArrayChannelManager.
Isolated HTTP request handler for the Reverb WebSocket server port.
Isolated router for Reverb's HTTP API and WebSocket routes.
WebSocket handshake handler for the Reverb server port.
This extended pipeline catches any exceptions that occur during each slice.
Report a transport failure that occurred before an API returned a response.
Sanctum authentication guard.
Mark columns for full-text search in the DatabaseEngine.
Mark columns for prefix search in the DatabaseEngine.
Fluent search query builder for searchable models.
Delete all search indexes.
Delete a search index.
Flush all model records from the search index.
Import model records into the search index.
Create a search index.
Import the given model into the search index via chunked, queued jobs.
Sync configured index settings with the search engine.
Resolves a model argument to a fully-qualified class name.
Contract for engines that support deleting documents by filter.
Contract for engines that handle pagination directly.
Contract for engines that paginate directly from the database.
Internal shape for models that can be indexed and searched.
Contract for engines that support updating index settings.
Manages search engine instances and driver creation.
Algolia search engine implementation (v4 client).
In-memory search engine using database queries and Collection filtering.
Database search engine implementation.
Abstract base class for search engine implementations.
Meilisearch search engine implementation.
Retry policy for the Meilisearch HTTP client.
No-op engine for disabling search functionality.
Typesense search engine implementation.
Event fired when models are flushed from the search index.
Event fired when models are imported to the search index.
Exception thrown when an operation is not supported by the search engine.
Base exception for Scout-related errors.
Queue job that re-queries an ID range and dispatches a MakeSearchable for it.
Queue job that makes models searchable by updating them in the search index.
Queue job that removes models from the search index.
Collection wrapper that uses Scout keys for queue serialization.
Observer that handles search index updates for Eloquent models.
Scout utility class for lifecycle customization and engine access.
Provides full-text search capabilities to Eloquent models.
Deferred Scout jobs owned by one coroutine's exit callback.
Global scope that adds batch search macros to the query builder.
AOP aspect that instruments all Guzzle HTTP client requests.
Track pushed scopes and spans using coroutine-local storage.
Decorates the underlying filesystem by wrapping all calls to it with tracing.
Open the outer request context whose deferred end flushes buffered telemetry.
Enrich the Sentry scope with the IP address of the request.
Adds log context data to Sentry events.
Job middleware that overrides the Sentry trace sampling decision for the job's transaction.
A reference-counted Sentry runtime context shared by coroutine owners.
Collect coroutine-enabled Swoole processes by name.
Extends Symfony Command directly — NOT Hypervel\Console\Command — because the Swoole server must own the event loop. Hypervel\Console\Command brings coroutine wrapping and signal traits that start the event loop before Server::start().
No-op fallback dispatcher used by ServerFactory when no real dispatcher is set.
Carbon's immutable magic modifier metadata names its base class even though these methods preserve subclasses at runtime.
Provides access to protected and private members of an object.
Core framework service providers loaded for every Hypervel application.
Some transformations may return a base collection when an implementation cannot preserve its concrete item contract.
Guesses the MIME type using the PECL extension FileInfo.
ProcessUtils is a bunch of utility methods.
Serializable version of SplPriorityQueue.
Cached string transformations for known-finite inputs.
System information utilities for benchmarking and diagnostics.
Coroutine-owned Telescope queues and deferred storage state.
Telescope supplies created_at for every entry even though its migration permits null.
Meta-attribute that resolves to actual attribute classes based on group.
Calls a test method for database setup with deferred execution support.
Calls a test method with the application instance for environment setup.
Calls a test method with the router instance for route definition.
Skips the test if the required database driver is not configured.
Skips the test if the required environment variable is missing.
Resets the database state before and after all tests in a class.
Sets a config value directly.
Sets an environment variable for the duration of a test.
Load named Testbench migration sets for the test.
Creates and bootstraps the application for testbench tests.
Provides assertion helpers for test cases.
Handles parsing and executing test method attributes.
Provides assertion helpers and cleanup utilities for testing file publishing.
Composes the Testbench testing concerns into a single upstream-facing trait.
Interface for attributes that handle actions via a callback.
Interface for attributes that run after all tests in a class.
Interface for attributes that run after each test.
Interface for attributes that run before all tests in a class.
Interface for attributes that run before each test.
Interface for attributes that are directly invokable.
Interface for meta-attributes that resolve to actual attribute classes.
Marker interface for testing feature attributes.
Collection for deferred testing feature callbacks.
Base testbench console kernel with empty bootstrappers.
Decorates a Symfony Process to return ProcessResult when terminated.
Process result with additional passthrough methods for testbench.
Executes a command in a subprocess using the testbench CLI.
Minimal HTTP Kernel for testbench.
Parses PHPUnit test case attributes for testing features.
Base test case for package testing with testbench features.
Assert that query-aware policy results match per-model Gate checks.
Process-local after-each cleanup callbacks for apps and packages.
Coordinates exactly one global cleanup after every test method.
Base test case for coroutine-aware tests that do not boot an application.
Keep empty translation-group results isolated to one execution.
Compiled validation plan for a single attribute.
Query database-presence candidates in groups.
Run validation performance benchmarks.
Parser with the original O(n²) wildcard expansion for baseline benchmarks.
Baseline validator using the pre-rewrite validateAttribute() loop AND the original O(n²) wildcard expansion.
A validation check that delegates to an existing validate*() method or Rule object.
A single inline validation check within a compiled rule plan.
Execute compiled AttributePlans against validation data.
Return database-proven presence facts from batched queries.
Compile pipe-string or array rules into an AttributePlan.
Worker-lifetime LRU cache of compiled rule plans.
Provides default implementation of ValidatesWhenResolved contract.