Classes
The Agent User Interaction (AG-UI) protocol's input side.
Dispatched once per failed attempt, including attempts failover recovers from.
Dispatched once per failed attempt, including attempts failover recovers from.
Dispatched once per failed attempt, including attempts failover recovers from.
Dispatched once per failed attempt, including attempts failover recovers from.
Dispatched once per failed attempt, including attempts failover recovers from.
Dispatched once per failed attempt, including attempts failover recovers from.
Distinguish a consumer's early stop from a provider failure when recording a turn.
Share completed credentials across one provider's gateways without sharing a pending AWS promise.
Send AWS requests through the framework's synchronous coroutine transport.
A generation step handed to agent middleware before the model is called.
A conversation message as it was persisted, with its JSON columns decoded.
Own the sender while generation and its database transactions stay in the caller.
The Agent User Interaction (AG-UI) protocol.
The Vercel AI SDK data stream protocol.
Controls whether and which tool a model must call, mapped to each provider's native tool_choice field.
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.
Encrypts Mercure updates end to end, so the hub never sees their content.
Keep a publishing client's network state exclusive to its current coroutine.
Track dispatch lock ownership until a queue accepts the job.
Tagged cache for any-mode tag semantics.
Redis-optimized concurrency limiter.
Values read through a namespaced tag set are memoized by this instance.
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.
Dispatched when coroutine cancellation stops a scheduled task after its starting notification, before or while its outcome is published.
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.
Another coroutine's cancellation, which this operation reports as an ordinary failure.
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.
The casts, normalizers and automatic lazy attributes resolved for one creation operation.
Immutable property order for lean construction.
Creates data objects by filling, validating, and constructing them over one ConstructionState.
Immutable construction and transformation metadata for one data class.
Immutable property order for lean transformation.
Immutable output from one complete validation-rule compilation.
Rejects the discriminator of a property-morphable node whose morph Fill could not resolve.
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.
Unlike Laravel, the templates are variant, so an accessor can declare a wider type than its getter returns, such as Attribute<string, never> for a getter returning a non-empty string.
Unlike Laravel, this declares no @mixin Builder: Builder is its only user, and the bare mixin made
PHPStan accept on every builder whatever the builder of an unknown model accepts.
Provides the ability to transform a model to a JSON resource.
Declare the model class for a factory using an attribute.
Let a pooled driver return its physical connection to the pool between operations.
Keep a caller's logical connection stable while its physical sessions are pooled.
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.
Worker-wide aspect rules used to generate proxies and compile dispatch chains.
Cache immutable aspect chains for the worker's intercepted methods.
Registry of AST visitors used during proxy class generation.
Marks generated AOP proxies without injecting callable behavior.
Generate AOP proxy classes for registered aspects.
Keep package class replacements separate from the application's Composer map.
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.
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.
Opt into real-hub tests with MERCURE_URL and isolate each test's topics.
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.
The request-scoped head data and response status.
Normalized head state: a collection of tag builders with layer semantics.
Registers the withHead() route macros.
A tag builder holding a single string value.
Base event for HTTP server request lifecycle observations.
Dispatched when coroutine cancellation stops a received request before its lifecycle, including termination, completes.
Store Swoole's already-separated headers directly, avoiding HeaderBag::set() normalization for every header while still parsing Cache-Control once.
Drive one transfer from the response consumer, including across coroutine handoff.
Retain one native connection cache without retaining a request or its callbacks.
Deliver streaming responses without sharing an active cURL multi handle.
The approved proxy could not be resolved or reached.
Keep transfers and their cancellation callbacks within their owning coroutine.
Drain each coroutine's callbacks independently and cancel unfinished work at exit, preserving the original queue outside coroutines.
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.
Adapt Guzzle's PSR-7 resource bridge so stream callers retain cancellation failures.
Share one lazy source across every image derived from it.
Builds an {IncomingEntry} from a request/response pair plus the per-request collector payload. This is pure entry construction: no response mutation, no recording. The recorder owns lineage/header/tag concerns and hands the result here.
Maps Inertia prop wrapper instances to the stable metadata the extension renders.
Keys for values stashed on the request attribute bag ($request->attributes) during the devtools request lifecycle. Unlike DevToolsHeader, these never leave the process: they carry state between the recorder, the collector, and the entry builder.
Records the Inertia request lifecycle for the devtools extension, holding the per-request collection state and delegating to {SourceLocator}, {PropClassifier}, {@see Collector} and {IncomingEntryBuilder}.
Resolves source-code locations for devtools: the caller frame of a share()/render() call, the line a prop key is defined on, the share() method body, and a route action's reflection. Pure lookup, no collector or request state.
Inertia configuration and request state stored in coroutine Context.
Represents a paginated property that can be merged during partial reloads.
Mark a validation that refresh skips because the refresh window replaces it.
Reuse parsed keys without duplicating lcobucci's ECDSA signature conversion.
Wraps the resolved context log processor in a known type.
Keep named clients with their owner when coroutine context is copied.
Keep custom credentials removed after a redirect leaves their configured origin.
Own the response independently of later connection negotiations.
Keep an MCP invocation's request available through eager and lazy handlers.
Relate a node to other nodes of its own class.
Legacy Slack message with attachments.
Preserve notification transport objects across serialization without serializing live streams.
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.
Upstream's vendor symlink and manifest rebuild are omitted: Hypervel's Testbench bootstrapper links the package's vendor directory, and the manifest rebuilds itself.
Invalidate the result cache when an attribute-registered extension is added or removed.
Gives the callbacks of a relation's when() and unless() their builder as a "this" type.
Collects the calls to methods marked as boot-time or test-only, with the receiver evidence a worker-shared restriction needs. The rule judges them by the operation the call runs in.
Collects a try whose block runs an operation that can deliver cancellation, where the catch receiving the cancellation doesn't propagate it. The rule reports those that run in a request, job or operation.
Collects the unusable schema dumps of the connections whose models have undeclared properties read, so they are reported at the dumps themselves once the analysis has finished.
Collects the constant container resolutions that make a class worker-shared, the route closures that handle requests, the helpers a method calls on its own instance, and the config writes through the global repository.
Collects the classes that are worker-lifetime roots by declaration, the request or operation state their promoted constructor parameters keep, and the observers models register when they boot.
Collects the assignments and unset() calls that set or unset an offset of the global configuration repository, such as config()['app.locale'] = 'fr', which change it like Repository::set(). Each is read with the scope at the write, wherever it sits, such as inside a return or an arrow function.
Collects writes to global variables, which the whole worker shares like static properties: a
$GLOBALS[...] write wherever it sits, and a write through a name a function's top-level global
statement binds. Detecting the second walks the function's own statements, since PHPStan's scope
doesn't say which variables are global. A request, user or model value written through a plain
variable is collected too, so the rule can tell what such a global write keeps.
Collects the reassigned parameters whose injected values the worker-state checks rely on: a constructor's request or operation state, a configuration repository, and, for restricted calls, any method parameter that may hold an object.
Collects the property writes the worker-state checks may report: writes that keep request or operation state, request-keyed cache entries, and writes in methods that may run while handling a request or job.
Upstream collects only the key. The missing-translation rule resolves each lookup through the booted translator, so the call's locale, fallback and operation are collected with it.
Infers user types from the configured guard providers, assuming a guard returns its provider's users.
Invalidate the whole result cache when an input that every file can depend on changes.
Prevents infinite recursion when resolving methods/properties through class-reflection extensions. Modeled after PHPStan's RecursionGuard.
Declare the custom builder inputs that methods forwarded to an Eloquent builder are described from.
Resolve the builders and queries that Eloquent models forward their calls to, as the runtime does.
Resolve the builder macros that model traits add through their global scopes.
Describe the relation methods that __call() handles: a model's relations that resolveRelationUsing() registers and its through{Relation}() calls, and a pending has-through relationship's has{Relation}() calls.
Resolve declared builders while preserving Eloquent and relation forwarding.
Describe the methods an Eloquent model's call() and callStatic() handle.
Type the call forms of an Eloquent builder's macro() and mixin() that differ: Builder::__callStatic() binds a global macro to the builder, and an instance mixin() reaches the query's, returning the builder.
Add a registered macro's exception to a method its @method tag types.
Declare the routing macro parameters for analysis without running provider boot.
Declare the builder macros that SearchableScope adds, for static analysis.
Declare the builder macros that SoftDeletingScope adds, for static analysis.
Type the calls a manager forwards to its default driver.
Resolve model methods exposed as named Eloquent scopes.
Bind model-relative types resolved for an Eloquent receiver.
Describe model scopes exposed through models, builders, and relations.
Passes an Optional's method calls to the object it holds. The call returns null when the Optional may hold something else, and only null when it never holds an object.
Resolves a Redis command written in another casing than its documented tag.
The facts of a configured database connection that schema inference reads.
Resolves the configuration facts of the booted application's database connections.
Applies migrations to the schema facts of the connections they run on.
The schema facts of the connection that migrations run on, which its pooled and routed connections share.
Maps database column types to the PHP types PDO fetches and accepts, for each driver.
Reads the schema dumps that schema:dump writes for the booted connections.
Read the class name an attribute argument gives, as instantiating the attribute evaluates it.
A required parameter of a callable type the package builds, such as an expected eager-loading callback.
Describe a relation method that a __call() handles without arguments, such as a relation that resolveRelationUsing() registers or a model's through{Relation}().
A builder method synthesized for a call that the builder's __call() handles.
Describe a forwarded fluent method whose runtime result is the receiving object.
Describe a method that another object handles for the receiver.
Describe a method an Eloquent model's call() or callStatic() handles, which is callable both ways.
Describe an Eloquent builder's macro() or mixin(), which both its call() and callStatic() accept.
Preserve model-relative parameter types on an exposed scope method.
Describe a model scope as invoked through an Eloquent receiver.
Describe a method that a proxy passes to its target, returning what the proxy returns.
Describe a target method's parameter as a proxy receives it. A proxy's __call() gets the argument values, so the caller's variable is never passed by reference. The parameter has none of PHPStan's extended metadata, such as a closure binding the target declares.
Describe a read-only property that a proxy reads from its target, typed as what the proxy returns, with the target property's deprecation.
Finds the files that values read through reflection come from, for result cache dependencies.
Describe the routing macro using its native signature and receiver-specific result.
Types the guards that the booted auth manager creates, and the users they return.
Types the framework's cast definition helpers, such as AsCollection::of(), as the cast string they build from constant arguments, so a model's casts() method can be read without running it.
Types the drivers that the booted Concurrency manager creates.
Types Conditionable's when() and unless() by how many arguments they receive, as their bodies do. Without a callback argument they return a proxy, which takes its condition from a given value, or else from the next property or method it passes on. With one, even null, they return the instance or what the callback or default returns.
Upstream's ConfigFacadeCollectionDynamicStaticMethodReturnTypeExtension types only collection(); this also types get() and the typed getters, like the repository.
This also covers the Application contract, which extends the container contract, so upstream's ApplicationMakeDynamicReturnTypeExtension is omitted. Upstream's ContainerArrayAccessDynamicMethodReturnTypeExtension is omitted because the container does not support ArrayAccess.
Type the keys of a new cursor paginator as integers.
Return a model's own collection class from the builder methods that return Eloquent collections.
Return the model's own builder from toQuery(), which runs the first model's newModelQuery().
Record whether a factory created through new() or times() makes one model or several.
Types the disks that the booted filesystem manager creates.
The filesystem Factory contract keeps its declaration, because another implementation can resolve disks in its own way.
Hypervel: registered for FormRequest and the Validator contract, whose safe() is the same operation.
Types guard() on the auth factory like the Auth facade's guard(). Upstream types only the facade, so auth()->guard('web') kept the declared Guard.
Type logger()'s logger as the booted binding, as for app(LoggerInterface::class).
Type url()'s generator as the booted binding, as for app(UrlGenerator::class), so the generator's own methods, such as full(), and its macros are available.
Upstream's view() stub returns the factory for an explicit null view name, which makes a view and fails. view() returns its factory only when called without arguments.
Types the arrays a model serializes to from its database attributes, appends and visibility.
Return the related model's own collection class from relation methods that return Eloquent collections.
Upstream types every disk as FilesystemAdapter. Pooled and custom disks are other filesystems, so each disk is typed from the booted configuration instead, and cloud() is not supported.
Reports Arr::get() and Arr::pull() keys that never exist, through PHPStan's own offset check.
Reports a binding whose concrete class name is an alias of its own abstract.
Upstream checks only Config::collection(); repository calls, including config()->collection(), are checked too.
Reports typed config getters, such as Config::integer(), whose value never has the getter's type, so the call always throws.
Reports a pooled resource that escapes the callback it is lent to.
Reports caught exceptions kept with ??=, which loses a later failure's cancellation.
Reports an exact CanceledException catch backed by a later catch of every exception.
Reports instanceof CanceledException checks, which miss cancellation carried by another exception.
Reports child coroutines started inside a database transaction callback.
Reports coroutines started directly through Swoole or the engine.
Recommend the fakeable Sleep class over the native sleep() and usleep() functions.
Reports boot-time and test-only markers whose conditions would silently disable or misstate the restriction RestrictedCallRule enforces.
Reports calls to methods marked as boot-time or test-only from code that runs while handling a request, job or operation.
Reports a catch that swallows the cancellation of an operation in code that runs while handling a request, job or operation, so the canceled work carries on.
Reports a Swoole table created directly in a service provider's register() or boot().
The worker lifetimes of one analysis: which classes the booted container shares across requests, which methods handle a request or run a job, and which parameters it fills with fresh or shared values.
The worker-state model of one analysis, shared by the rules that judge collected code by the request, job or operation it runs in: the booted lifetimes, with the collected route closures and parameter reassignments.
Collects the boot-independent facts of the checks that judge code by the request, job or operation it runs in, and builds the shared model the rules apply the booted lifetimes with.
Reports request and operation state kept in worker-shared objects, static properties, global variables and config, and request-keyed caches that grow for the worker's lifetime.
Reports a Carbon date change whose result is discarded, which leaves an immutable date unchanged.
Reads configuration property declarations and the class attributes that can replace them, for the rules recommending attributes over legacy model and queue properties.
Reports a transaction() callback that ends the transaction it runs in.
Reports schema columns whose types Hypervel's conventions replace.
This rule validates that the properties a model appends are computed properties, which serialization reads through a get accessor or a class cast.
Check the column arguments of the pagination methods and pluck(), and the columns a dynamic where names, against the model's properties.
Report relations a concrete model's default $with and $withCount eager loads do not define.
Share how the model rules read models, including the model a call on a model, builder or relation queries.
Catches environment reads outside of the config directory.
Report calls a model forwards to its query builder, which an explicit query() or newQuery() call makes clear.
Recommend model configuration attributes over the properties they replace, which remain supported.
Recommend protected #[Scope] methods over legacy scopeX() methods, which remain supported.
Upstream compares each key with the keys in the lang files. This rule asks the booted translator, so fallbacks, JSON, namespaces and boot-added lines count, and reports only keys whose group exists.
Catches inefficient instantiation of models using Model::make().
Reports PHP's native request, response and session APIs, which act on PHP's own SAPI state rather than the request and response a Swoole worker is handling.
Unlike upstream, scopes and accessors are recognized as the runtime finds them: a legacy scope by its name and a first parameter that takes the builder, and an accessor by its native Attribute return type. Only a private method is made protected automatically, because a public one can have callers in other files.
This rule checks for unnecessary heavy operations on the Collection class that could have instead been performed on the Builder class.
This rule checks for unnecessary calls Enumerable::toArray() that
could have used all() instead. The toArray() method recursively
converts all Arrayable items in the Enumerable to an array and if
none of the items are Arrayable, it is unnecessary map call.
Reports a service provider registering a model's observers with observe(), where the Laravel convention is #[ObservedBy] on the model.
A queued job that uses the Batchable trait must respect early batch
cancellation, either by checking $this->batch()?->cancelled() at the start of
handle(), or by registering the SkipIfBatchCancelled middleware from
middleware().
Every job added to a batch must use the Batchable trait.
A queued job dispatched inside a DB::transaction(...) closure must defer its
dispatch until the transaction commits, by chaining ->afterCommit() on the
dispatch, declaring $afterCommit = true, implementing ShouldQueueAfterCommit,
or using a queue connection that does either.
A queued job (one implementing ShouldQueue) that holds an Eloquent model in a
property must use the SerializesModels trait.
A job implementing ShouldBeUnique must not be dispatched through the bulk or
batch entry points: Bus::batch([...]), Bus::bulk([...]), Queue::bulk([...]),
or a batch's add().
Recommend queue attributes over the configuration properties they replace, which remain supported.
Every job implementing ShouldBeUnique must declare how long it stays unique,
with a #[UniqueFor] attribute, a public uniqueFor() method or a public
$uniqueFor property.
A parameterized job implementing ShouldBeUnique must declare uniqueId,
either as a method (public function uniqueId(): string) or a property
(public $uniqueId).
Reports connection-bound Redis methods, such as client() or auth(), called through the pooled proxy or the manager.
Report relation names, such as those an eager load or relationship query names, that a model does not define.
Report relationship queries and eager loads that name a relation the model does not define.
Reports a #[BindWhen] condition whose code, including its nested callbacks, contains a read of the current request or user.
Reports a Socialite provider subclass using a property that holds only the provider's default.
Reports a config read whose value always has one type that a typed getter returns.
Reports a config value that is an uncast env() read with a bool, int or float default.
Reports calls that reach a method marked #[Unsupported], which always throws.
Reports the schema dumps that model property types could not use, once each, at the dump.
Upstream matches the written name and takes the first argument as the value, so an
unpacked list or a reordered named argument was misread. Its fix dropped the evaluation
of the other arguments, and took the value from the analyzed tree instead of the fixer's
copy of the call, which broke the fixed file for values such as new Foo().
Upstream matches the written name and takes the first two arguments by position, so an
unpacked list or reordered named arguments were misread. It also reported callbacks that
are not callable, which throw instead of returning the value. Its fix dropped the
evaluation of the other arguments, and took the value from the analyzed tree instead of
the fixer's copy of the call, which broke the fixed file for values such as new Foo().
Recommend arrays over pipe-separated rule strings in Data's #[Rule] attribute.
Recommend arrays over pipe-separated rule strings returned from a form request's or Data class's rules().
Recommend arrays over pipe-separated rule strings passed to the validator, its wrappers and prompts.
Finds the validation rule strings the framework splits at "|", where they are written.
Declares that a file whose own PHPDoc uses a view-string depends on which views exist.
Declares that a call to a function whose signature uses a view-string depends on which views exist.
The inputs the booted application was built from: the files the boot ran or read, the environment variables it can read and the files whose presence it checks.
Follows a key through an array like Arr::get(), asking PHPStan whether each segment exists.
Finds the code Blade compiles in a view by following Blade's own passes, without compiling the view.
A config array whose keys are known, so ConfigParser can compose config sources without typing their values. Each value is another config array, an expression in a config file (typed when a lookup reaches it), a type, or null when unknown.
Types config values from the sources Hypervel loads: the application's config files, the framework's config files beneath them, and the package files providers merge.
Finds what a booted application loads into its configuration besides its own config files: the framework defaults, the package files providers merge, and the keys that providers and bootstrappers write. ConfigParser composes these into config types.
Reads a class's methods from its source, such as the constructor its instances run.
Turns the configured config, migration and schema paths into the directories to scan and watch.
Collect the environment variables the traversed files read for EnvironmentVariableScanner.
The environment variables as the process received them, before the application boots.
Find the environment variables a set of PHP files can read.
Finds the method a facade's static call runs without running application code: neither the accessor nor the root is executed.
Types a higher-order collection proxy as the collection method it names, called with a callback that returns what the proxied member returns, so each result follows that method's own signature.
Types the properties and methods a HigherOrderWhenProxy passes to its target. A proxy without a condition takes it from the member and returns itself. A proxy with a condition returns the member's value when the condition holds, and the target otherwise.
Resolves the instance names that a manager method's name argument can select.
A \RecursiveDirectoryIterator that skips the redundant first rewind().
The inputs the booted application was built from, declared as one dependency by everything that reads the booted application.
Removes the pulled key from the array passed by reference to Arr::pull().
The builder a model's newQuery() creates, written builder-of
The collection a model's queries return, written collection-of
The expected type of a relation-keyed map, built per key from the map a call passes.
Clear a factory's count after createMany(), createManyQuietly() or makeMany(), which clear it at runtime.
Read a PHPDoc union of a builder and a model, such as Builder|User, as Builder<User>.
A string naming a database property of a model, written model-property
Ensures a 'model-property' type in PHPDoc is recognized to be of type ModelPropertyType.
The relationship a model's relation path names, written relation-of<TModel, 'path'>.
The custom 'view-string' type class. It's a subset of the string type. Every string that passes the view()->exists($string) test is a valid view-string type.
Ensures a 'view-string' type in PHPDoc is recognized to be of type ViewStringType.
AAGUID to authenticator name mapping.
This class provides a static interface to the webauthn-lib package, handling serialization, deserialization, and validation of WebAuthn ceremonies.
Identify public key requirements that may be disclosed in protocol errors.
Coordinate authentication lookups and invalidation across model and query writes.
Keep parsed keys and reusable servers together for one immutable settings set.
Preserve the backing row needed to extend retention when this key signs.
Shares a database store's stored values between servers through a cache store.
Feature values held for the current coroutine.
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.
Keep asynchronous processes with their starting coroutine without retaining completed processes.
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.
Dispatched when coroutine cancellation stops a job's queueing, or interrupts the notification of its outcome.
Coordinate cleanup for one attempt across its job coroutine and timeout monitor.
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 request exchange that could not complete, such as a failed connection or a transfer that broke while receiving the response.
Every request and pending request uses this trait, so body traits need no upstream HasBody contract or
ChecksForHasBody check.
Sanctum authentication guard.
Preserve declared type identity separately from a domain's resolved base.
A type declared with CREATE TYPE ... AS ENUM.
How an input's statements affect tables, views and user types that existed before it.
Read a schema dump statement by statement into immutable results.
A column whose facts may still change before the schema is frozen.
Split SQL into statements and tokens located in the original source.
Lex mysqldump and mariadb-dump output as the mysql client splits it.
The definitions, identity lookups and issues of one parse.
Lex plain-text pg_dump output with psql's statement boundaries.
Lex SQLite schema output with the statement boundaries of sqlite3_complete().
A table whose facts may still change before the schema is frozen.
The tokens of one statement, read in runs and never past its terminator.
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 semantic and hybrid search.
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.
Turbopuffer search engine implementation.
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.
Turbopuffer API client.
Associate spans with one conversation, including spans started before its ID is known.
Own the current coroutine's AI span stack while sharing invocation lookup with its children.
Share bounded invocation lookup between a trace's participating coroutines.
Track pushed scopes and spans using coroutine-local storage.
Instrument the requests of every Guzzle client: the HTTP client, directly constructed clients and third-party SDKs built on Guzzle.
Decorates the underlying filesystem by wrapping all calls to it with tracing.
Open the outer request context whose deferred end flushes buffered telemetry.
Filters the values of the cookies Hypervel uses for sessions and authentication because they are very sensitive.
Enrich the Sentry scope with the IP address of the request.
The SDK's Hub with a layer stack per coroutine instead of per instance.
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.
Shut the server down gracefully on SIGINT (Ctrl+C), the same way Swoole handles SIGTERM.
Track only active response producers, so disconnects cannot cancel later request work.
Keep a shared credential provider's pending work in the coroutine invoking it.
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.
Reports secondary failures at boundaries that must keep the failure they are already handling.
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.
A connection selected on a queue fake, which records jobs on the fake and sends the jobs it does not fake to that connection.
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.
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.