Classes
Single source of truth for boot-time auth redirect wiring.
These methods are typically the same across all guards.
Tagged cache for any-mode tag semantics.
Redis-optimized concurrency limiter.
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 extension is installed with required version.
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 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 tags using lazy cleanup mode (fast).
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 from any 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.
Dispatched inside the coroutine in the finally block after command execution completes.
Dispatched inside the coroutine after the command's handle method completes successfully.
Dispatched inside the coroutine, immediately before the command's handle method is called.
Cached build instructions for a concrete class.
Cached dependency parameter metadata.
Coordinates one cacheable first resolution across coroutines.
Marks objects stored in coroutine context that need deep-copying when context is copied between coroutines.
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.
This interface is intentionally empty and exists to improve IDE support.
NOTE: Do not use constructor property promotion here.
This interface is intentionally empty and exists to improve IDE support.
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.
A singleton pool for reusing Channel instances.
Wrapper for passing exceptions through channels.
Exception thrown when parallel execution encounters one or more errors.
Go-style WaitGroup for waiting on multiple coroutines.
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.
Provides the ability to transform a model to a JSON resource.
Declare the model class for a factory using an attribute.
Interface for connection resolvers that maintain internal caches.
Database connection pool.
Factory for creating and caching database connection pools.
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.
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.
Tracks configuration mutations made during application boot for worker replay.
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 any-mode tag operations.
Database connection resolver for the testing environment.
Testing-aware transaction manager that properly handles RefreshDatabase's wrapper transaction.
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.
Prefer Guzzle for PSR-18 HTTP client auto-discovery.
Retain iterable chunks so the Swoole bridge can stop production after a failed write.
Per-request Inertia state stored in coroutine Context.
Represents a paginated property that can be merged during partial reloads.
Wraps the resolved context log processor in a known type.
Store idle objects independently of execution mode and signal coroutine waiters.
AAGUID to authenticator name mapping.
This class provides a static interface to the webauthn-lib package, handling serialization, deserialization, and validation of WebAuthn ceremonies.
Build Permission relations from one immutable partition and team snapshot.
Store idle connections independently of execution mode and signal coroutine waiters.
Abstract base class for pooled connections.
A frequency implementation that checks idle connections at a constant interval.
Event dispatched when a connection is released back to the pool.
Tracks connection frequency to enable low-frequency pool flushing.
Abstract connection that maintains a keepalive heartbeat.
Interface for frequency trackers that can detect low-frequency usage.
Manage reusable connections with explicit ownership and terminal teardown.
Configuration options for a connection pool.
Configuration for a simple pool.
A simple pooled connection that uses a callback to create connections.
A simple pool that creates connections via a callback.
Factory for creating and managing simple pools.
Logger implementation for coroutine-based Task execution.
Keep the reserving Pheanstalk connection pinned until the backend's terminal release, bury, or delete command has completed.
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.
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.
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 handle pagination directly.
Contract for engines that paginate directly from the database.
Contract 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 job customization and engine access.
Provides full-text search capabilities to Eloquent models.
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.
Enrich the Sentry scope with the IP address of the request.
Adds log context data to Sentry events.
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.
Base class for all federated login providers.
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.
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.
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.
Loads migration paths 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.
Assertions for verifying that a policy's query-aware methods (Scope, Select) produce the same results as the per-instance PHP method.
Process-local after-each cleanup callbacks for apps and packages.
Coordinates exactly one global cleanup after every test method.
Compiled validation plan for a single attribute.
Execute batched database queries for wildcard exists/unique validation.
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.
Marker interface for database presence rules (exists/unique).
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.
Presence verifier that returns pre-computed results 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.