Composes API configuration, endpoint registration, authorization and response services.

Carries the resolved API runtime policy and its nested security and framework settings.

Collects typed API configuration overrides for later ordered resolution.

Merges ordered API definitions into one normalized immutable runtime configuration.

Captures the resolved route and authorization policy for one framework-owned API endpoint.

Selects the built-in API authentication configuration, or disables built-in authentication.

Groups the resolved registration policies for framework-owned API endpoints.

Holds the configured credential and scopes for the built-in external bearer authenticator.

Serves a Swagger UI shell pointing at the configured OpenAPI endpoint and version-pinned assets.

Serializes the current generated OpenAPI document as a UTF-8 JSON response.

Projects the canonical endpoint registry and runtime configuration into an OpenAPI 3.1 document.

Describes one immutable API route, its controller target and its authorization metadata.

Holds validated authorization and OpenAPI details shared by endpoint registration and generation.

Contributes application-owned endpoints to the canonical API registry during provider boot.

Materializes registered API endpoint definitions as named framework routes under one prefix.

Owns the canonical ordered API endpoint set and enforces unique names and method-path pairs.

Binds canonical router matches to registered API endpoint security metadata.

Applies the shared normalization rules used for API prefixes, routes and request matching.

Contributes enabled health, OpenAPI and documentation endpoints from resolved framework policy.

Reports basic framework availability with version identity and a clock-derived timestamp.

Enforces endpoint access, authenticated trust and scopes before API controller dispatch.

Defines the stable PSR-7 request attribute key for an authorized API identity.

Converts failures for registered API endpoints into safe Problem Details responses.

Creates the framework API envelope as immutable UTF-8 JSON responses.

Creates RFC 9457-style Problem Details responses without exposing exception internals.

Verifies request credentials and returns only identity claims established by that verification.

Carries the authenticated API principal, its permissions and its verified trust boundary.

Provides fail-closed authentication when no API credential mechanism is configured.

Requires every endpoint scope unless the authenticated identity owns the administrative scope.

Verifies one configured bearer token in constant time and creates an external API identity.

Enforces the PSR-6 key restrictions shared by framework cache implementations.

Provides cache-aside convenience operations over one PSR-6 cache pool.

Registers typed cache configuration, the supported PSR-6 pools, and cache convenience services.

Carries the resolved default cache store and its backend-specific settings.

Builds one ordered cache configuration contribution for the typed config pipeline.

Merges ordered cache definitions into one normalized immutable runtime configuration.

Carries the resolved file store location, key namespace prefix, and default lifetime.

Reports an unsafe or unusable cache persistence boundary that cannot be treated as a cache miss.

Represents rejection of an empty cache key or one containing PSR-6 reserved characters.

Stores PSR-6 cache entries in request-local memory with lazy expiration.

Holds one PSR-6 cache value together with its original hit state and optional expiration.

Persists PSR-6 values in authenticated, non-executable files below one private cache root.

Implements a validating PSR-6 sink where reads always miss and mutations always succeed.

Describes the command currently executing inside an isolated command scope.

Holds validated metadata used to register and lazily resolve a CLI command.

Provides immutable access to the arguments of the current command invocation.

Defines command metadata and the executable entry point used by the CLI runtime.

Executes a command inside a fresh command scope with invocation-specific services.

Writes command output to separate standard-output and standard-error streams.

Registers command metadata and resolves command names and aliases for execution.

Carries resolved command metadata and class-based registrations.

Builds the raw command configuration accepted by the configuration pipeline.

Validates raw command configuration and produces runtime command metadata.

Registers the shared command registry and command-scope invoker services.

Provides current time through an injectable boundary without exposing its time source.

Reads wall-clock time in an explicitly configured timezone or PHP's current default timezone.

Creates application-supplied breadcrumb trails and renders them through the framework's canonical breadcrumb renderer.

Stores one caller-owned breadcrumb label and its optional navigable URL.

Renders generic breadcrumb trail data as escaped semantic BreadcrumbList markup.

Registers the stateless breadcrumb renderer and component for application use.

Holds ordered caller-owned breadcrumb items until a renderer presents them.

Maps view-facing component names to container services and resolves them on demand.

Registers built-in components, their configuration and the view-facing component registry.

Holds the resolved mapping from component names to their implementation classes.

Collects component registrations contributed by an application or module.

Merges component definitions into a validated immutable configuration.

Holds the resolved defaults applied when page metadata leaves a standard value unset.

Collects metadata defaults contributed by an application or module.

Merges ordered metadata definitions into defaults consumable by the metadata component.

Applies configured defaults to page metadata and creates its renderer.

Carries page-specific metadata independently from its HTML rendering.

Builds the HTML metadata block from ordered, replaceable metadata sections.

Registers metadata configuration resolution and the metadata rendering component.

Shares immutable page metadata and tag-list rendering among metadata sections.

Dc

Renders Dublin Core metadata derived from the page's standard values.

Renders Open Graph and Facebook-specific metadata from page metadata and custom values.

Renders standard document, SEO, canonical and alternate-language metadata.

Defines a metadata section that contributes HTML tags to a page head.

Renders Twitter Card metadata using page defaults and supported custom overrides.

Provides immutable attribute-based metadata tags while escaping their name and content.

Renders an alternate-language link tag from a language code and URL.

Renders an escaped character-set declaration when one is configured.

Renders a Dublin Core metadata declaration.

Renders a relation link tag from a relation name and URL.

Renders a name-based HTML metadata declaration.

Renders a property-based Open Graph metadata declaration.

Defines an HTML metadata tag that can suppress itself when its value is empty.

Renders an escaped document title when a title is available.

Renders a Twitter Card metadata declaration.

Holds the resolved defaults that govern pagination creation and rendering.

Collects pagination defaults contributed by an application or module.

Merges ordered pagination definitions and normalizes them into usable defaults.

Provides the application-facing entry point for creating and rendering pagination.

Creates pagination results from rows or query builders using the current request as fallback context.

Renders accessible pagination navigation from immutable pagination state.

Couples the rows of one page with the state required to navigate its result set.

Registers resolved pagination configuration and request-scoped pagination services.

Describes one requested page and derives its offsets, navigation state and page URLs.

Resolves concrete object graphs through reflection while keeping explicit definitions and their lifecycle caches in one root-owned runtime container.

Explicit class decorator contract. The inner service is passed to decorate(), while constructor dependencies continue to use normal container autowiring.

Resolves an explicitly declared service collection from the frozen container plan.

Coordinates the shared root-container bootstrap for application entrypoints.

Performs runtime registry registration after the definition plan is frozen.

CLI application kernel for Lemonade Framework applications.

Factory for constructing CLI application kernels.

Mutable runtime configuration store for framework and application settings.

Carries application-wide runtime values resolved from host configuration and bootstrap context.

Defines application-wide runtime values supplied by the host application.

Resolves ordered application configuration definitions into immutable runtime configuration.

Persists compiled configuration as authenticated data below private application storage.

Reconstructs supported configuration definitions from compiled cache data.

Produces configuration output with sensitive values redacted.

Loads typed configuration definitions from PHP and YAML source files.

Loads application configuration for HTTP and CLI entrypoints.

Registers the root typed-configuration services used before application providers run.

Provides array-backed storage and normalization for typed configuration definitions.

Defines the typed representation of one named configuration module.

Registers and retrieves typed configuration definitions by module key.

Reports an unsafe or unavailable filesystem boundary for compiled application configuration.

Holds the framework service-provider classes resolved from configuration.

Defines framework service-provider configuration values.

Resolves framework provider definitions into validated runtime configuration.

Loads the framework's built-in typed configuration definitions.

Canonicalizes primitive values consumed by internal configuration resolvers.

Carries one loaded definition together with its environment and source dependencies.

Holds host application service-provider classes resolved from configuration.

Defines host application service-provider configuration values.

Resolves host provider definitions into validated runtime configuration.

Parses YAML configuration files through the installed YAML parser.

Maps YAML aliases and module keys to typed definition classes accepted by the configuration loader.

Maps parsed YAML documents into typed configuration definitions.

Resolves YAML environment directives and records their consumed variable names.

Carries the immutable environment, path, and debug boundaries resolved for one application bootstrap.

Route-to-controller dispatcher for HTTP requests.

Registers the foundational framework services required by the core runtime.

Registers service definitions without resolving runtime services.

Records uncaught runtime and PHP diagnostics through the error channel, including bootstrap fallback.

Installs the framework-wide PHP diagnostic policy for one PHP request.

Main bootstrap and runtime facade for the Lemonade Framework HTTP application layer.

Immutable metadata accessor for the framework name, version, and powered-by header values.

Carries the immutable configuration subset required by the pre-bootstrap health fast path.

Serves an eligible public framework health request before the full HTTP bootstrap runs.

Builds framework HTTP responses with PSR-17 factories while preserving streaming response bodies

HTTP application kernel for Lemonade Framework applications.

Factory for assembling the HTTP application kernel.

Carries the immutable application policy resolved for built-in framework logging.

Resolves layered logging definitions into the framework's minimal built-in logging policy.

Identifies a log path, permission, identity, or publication state that cannot be made private safely.

Resolves built-in channels inside application storage and outside the public web root.

Provides framework-owned app, error and request log channels.

Registers logging policy, named channels, and the default PSR-3 application logger.

Writes private daily JSON-line logs without following symbolic links or weakening filesystem permissions.

Creates configured providers from services that are safe during bootstrap.

Defines the contract for framework service providers.

Collects named database connection contributions for layered framework configuration.

Merges ordered database configuration contributions into runtime connection definitions.

Holds the selected default connection and all resolved named connection configurations.

Selects the concrete connection implementation for a resolved driver configuration.

Defines the lifecycle, execution, escaping, and atomic transaction operations of one database connection.

Carries normalized connection settings independently of configuration source format.

Provides database operations and driver capabilities to framework consumers.

Defines the database driver operations used by the framework database layer.

Owns driver and schema-grammar factories registered for supported connection drivers.

Builds a Database facade with a matching connection and registered driver implementation.

Supplies cached array and object projections over a driver-specific result cursor.

Defines the legacy-compatible result cursor and projection operations exposed by database drivers.

Registers the configured connection, driver, query facade, and schema services.

Shares value escaping adapters that delegate SQL literal quoting to the active connection.

Shares nested transaction bookkeeping while issuing physical boundaries only for the outermost scope.

Owns a lazily connected MySQLi session, parameter binding, transaction state, and optional database instrumentation.

Defines MySQLi-specific operations used by the MySQL driver in addition to the generic connection contract.

Executes framework database operations through the legacy MySQL connection.

Registers MySQL-specific connection adapters, driver services, and schema grammar factories.

Captures raw MySQL execution output together with write metadata needed by the driver facade.

Describes one MySQL result column in framework and legacy-compatible representations.

Applies MySQL backtick quoting and the configured prefix to SQL identifiers.

Adapts a MySQLi result handle to cached framework result projections.

Compiles framework schema definitions to MySQL and MariaDB DDL with configured table prefixes.

Renders MySQL literals, expressions, and identifiers for schema compilation.

Adapts an ODBC resource to the framework connection contract with transaction support.

Provides ODBC query execution and identifier handling through an ODBC connection.

Registers ODBC-specific driver and schema-grammar factories.

Captures the statement resource and affected row count produced by an ODBC execution.

Describes one ODBC result column as exposed by the ODBC extension metadata API.

Provides the odbc identifier escaper contract for the database subsystem.

Provides the odbc result contract for the database subsystem.

Provides the odbc schema grammar contract for the database subsystem.

Escapes ODBC string literals and LIKE patterns using the active ODBC connection.

Adapts a PDO connection to the framework connection contract with transaction and optional instrumentation.

Provides SQL execution and identifier handling for generic PDO-backed connections.

Registers PDO-specific driver and schema-grammar factories.

Derives a PDO DSN from explicit configuration while preserving an explicitly supplied DSN.

Provides the pdo result contract for the database subsystem.

Registers SQLite grammar and identifier services for PDO-backed SQLite connections.

Escapes SQLite identifier parts with SQLite-compatible quoting rules.

Provides the sqlite schema grammar contract for the database subsystem.

Escapes SQLite string literals and LIKE patterns through the PDO connection.

Represents invalid database configuration or use that prevents a driver operation from proceeding.

Receives individual database timings and original bindings, without results or exception details.

Lets long-lived connections report into a fresh, explicitly bounded SQL capture.

Accumulates only query count and duration for one explicitly observed operation scope.

CLI command that runs pending database migrations.

CLI command that displays the migration status.

Signals that a migration class cannot be discovered or mapped to a valid migration identifier.

Registers migration classes from one explicitly configured PSR-4 directory.

Contract for a one-way database migration.

Registry of explicitly registered migration class strings.

Orchestrates pending migrations over the registry, state history, and schema API.

Registers migration infrastructure and CLI commands.

Manages the persistent history of applied migrations.

Immutable snapshot of the migration status known to the framework.

Provides the model contract for the database subsystem.

Builds immutable SQL query descriptions with validated structured clauses and explicit raw SQL boundaries.

Provides the array database result contract for the database subsystem.

Collects modifiers for one column while its owning table blueprint is being defined.

Collects the referenced table, columns, and actions for a table-level foreign key.

Collects declarative column, index, foreign-key, and table-option changes for one table.

Provides the column definition contract for the database subsystem.

Provides the foreign key definition contract for the database subsystem.

Provides the index definition contract for the database subsystem.

Provides the sql expression contract for the database subsystem.

Provides the table definition contract for the database subsystem.

Provides the table options contract for the database subsystem.

Compiles and executes schema changes through the active driver's grammar and query interface.

Turns schema blueprints and immutable table definitions into driver-specific SQL statements.

Defines SQL compilation for portable schema operations without executing the resulting statements.

Escapes one SQL identifier part according to a driver's identifier quoting rules.

Protects compound table and column references while preserving supported SQL aliases and expressions.

Escapes identifier parts with a supplied pair of SQL quote characters.

Serves cached and generated sitemaps through bounded response body streams

Normalizes sitemap URLs and serializes them either to a target stream or as lazy XML chunks

Defines local filesystem mutations and lazy directory traversal with typed failures instead of native warnings.

Defines read-only file access whose failures are reported through one typed filesystem boundary.

Defines exclusive callback execution keyed by a lock-file path.

Derives deterministic bounded-fan-out directory paths from identifiers.

Identifies a filesystem boundary failure and retains its operation category through stable error codes.

Exposes the framework's filesystem collaborators through one facade while retaining their typed failure contracts.

Registers the shared local-filesystem contracts, facade, path generator, and legacy service IDs.

Performs local directory and file-tree operations while translating native failures to filesystem contracts.

Reads file metadata and contents while normalizing unavailable or unreadable paths to filesystem exceptions.

Executes callbacks under an exclusive local file lock and preserves callback failures as filesystem causes.

Exposes uploaded-file input without interpreting or restructuring its values.

Stores HTTP header values under case-insensitive canonical names.

Provides read-only access to a named collection of request input values.

Preserves the server-bag API while delegating trusted values to the central request policy.

Registers the optional PHP-HTTP cURL adapter as the configured PSR-18 client.

Registers the optional Guzzle adapter as the configured PSR-18 client.

Registers the transport-neutral configuration shared by optional HTTP client adapters.

Registers the optional Symfony adapter as the configured PSR-18 client.

Carries the resolved cross-origin response policy used by CORS middleware.

Builds one composable layer of cross-origin resource sharing configuration.

Merges ordered CORS definition layers into one normalized runtime policy.

Carries the resolved templates used to render framework HTTP error pages.

Builds one composable layer of HTTP error-page template configuration.

Merges ordered error-page definitions into normalized runtime template names.

Carries the resolved switch controlling HTML response minification.

Builds one composable layer of HTML minification configuration.

Merges ordered HTML minification definitions into one runtime setting.

Carries transport-neutral timeout and TLS settings for configured HTTP clients.

Builds one composable layer of outbound HTTP client configuration.

Merges ordered HTTP client definitions into one normalized transport policy.

Carries the immutable trust policy used to resolve externally visible request metadata.

Builds one composable layer of inbound HTTP server trust configuration.

Merges inbound server definitions into one validated fail-closed trust policy.

Renders configured HTML error views with safe fallbacks and development-only diagnostics.

Allows an HTTP integration to render selected exceptions before the default HTML fallback is used.

Marks an application-level resource miss that HTTP error handling maps to a 404 response.

Registers the framework HTTP pipeline, request-scoped dispatch services, and resolved HTTP configuration.

Produces an allowlisted HTTP context that excludes query strings, cookies, bodies, and every header value except a validated request identifier.

Records completed HTTP exchanges that satisfy the configured request-log threshold.

Terminates a matched middleware pipeline by invoking its selected controller action.

Applies the resolved CORS policy and terminates valid preflight requests.

Reuses a trusted pre-match or matches the request, publishes its RouteMatch, and delegates to route middleware.

Translates expected HTTP failures and unexpected throwables into safe responses and error records.

Minifies non-empty HTML responses when enabled while preserving response immutability.

Executes an ordered PSR-15 middleware chain before a terminal request handler.

Resolves middleware class names through the application container in declared order.

Maintains the ordered middleware class list used to build the global HTTP pipeline.

Supplies automatic OPTIONS responses when no explicit OPTIONS route owns a path.

Adds the framework's configured identification header to downstream responses.

Represents a one-pass response body that reads lazy producer chunks without assembling the full content in memory

Emits PSR-7 responses by forwarding readable body chunks without materializing the full body

Creates PSR-7 server requests from the active PHP request globals.

Represents ambiguous or malformed request metadata that cannot safely cross the proxy trust boundary.

Derives logging and content-negotiation metadata without reparsing proxy trust inputs.

Removes control bytes and unsafe key characters from nested request input maps.

Compiles exact hostnames and bounded suffix wildcards for request-origin validation.

Resolves client identity and external request origin across one explicit proxy trust boundary.

Captures one immutable, trust-aware view of externally visible request metadata.

Exposes raw server parameters separately from trust-resolved request origin metadata.

Matches peer IP addresses against an explicit, prevalidated set of exact addresses and CIDR networks.

Compacts safe HTML whitespace while preserving raw-text blocks, text blocks, and conditional comments.

Provides application controllers with consistently typed responses and one-pass streamed bodies.

Encodes decoded images into a supported output format without choosing where the resulting bytes are stored.

Persists already encoded image bytes at a caller-selected path.

Transforms decoded bitmap images while keeping the concrete image backend hidden from application code.

Resolves a validated public image reference into a URL for presentation.

Renders a complete variant in one backend-controlled pass, without exposing intermediate mutable images.

Signals that GD or the codec required by an otherwise supported format is unavailable at runtime.

Signals that accepted image data could not be decoded into a bitmap.

Signals that a decoded image could not be serialized by an available encoder.

Base category for failures raised by the framework image capability.

Signals a GD failure while creating, cropping, resizing, or normalizing an image.

Signals that image input, geometry, or encoder options violate a documented invariant.

Signals persistence failure after bytes have already been encoded.

Signals that a bitmap format is outside the capability's supported format set.

Writes already encoded image bytes to a caller-selected filesystem path.

Centralizes GD runtime initialization and codec availability checks.

Encodes decoded images into a supported output format.

Decodes supported bitmap sources and produces transformed image values without exposing the underlying GD resource to callers.

Produces a derived variant directly from a source file in one GD decode and resample pass.

Registers shared image processing and root-relative presentation services.

Stores disposable variants atomically and serializes generation for one deterministic target path

Coordinates one cache-aware decode, render, encode, and atomic publication flow for a derived variant

Resolves bounded persistent-original and public-variant paths without making originals public by default

Renders public image references as escaped HTML image markup.

Defines validated presentation attributes for image markup without affecting image processing.

Resolves public image references to root-relative upload URLs.

Defines a positive crop area; containment within a source image is validated by the processor.

Holds a normalized immutable bitmap value while keeping the mutable GD resource outside the public image API.

Carries encoded image bytes with the format and dimensions produced by an encoder

Identifies one persistent image asset without assigning it an application-specific owner

Defines the pixels used where a source image does not cover its variant canvas.

Describes validated bitmap dimensions with strictly positive width and height

Points to a versioned persistent source without exposing an absolute path or requiring public delivery.

Carries an explicitly validated encoder quality in the inclusive 0–100 range.

Describes a publicly addressable image with its actual format and dimensions.

Identifies a caller-provided local bitmap source without coupling image processing to uploads or requests.

Defines the complete immutable rendering contract for one derived image.

Is a deterministic SHA-256 identity for a source version and its normalized rendering definition

Reads and combines physical translation files while retaining their provenance

Resolves source catalogs and runtime overrides with the configured locale fallback

Keeps source-only resolution until an application supplies a mutable override source

Provides explicit mutable values over read-only source translations

Describes a registered translation resource root and its optional owner

Exposes physical source translations without the mutable override layer

Carries one source value before a higher-precedence layer replaces it

Describes the effective source value for a locale, group and key identity

Describes the layer and resource root that provide a source value

Signals that catalog composition would assign one extension or MIME value to multiple families.

Composes immutable MIME knowledge after all framework and application providers register.

Carries one normalized media type without client-supplied parameters.

Provides immutable extension and server-detected MIME indexes with unambiguous accepted values.

Defines one format family with canonical detection, safe suffixes, and risk metadata.

Supplies deterministic application-owned MIME families during catalog composition.

Detects a file's media type from server-visible content rather than client metadata.

Detects normalized MIME values from server-visible file content.

Controls explicit client exposure of HTTP metrics independently of environment and debug mode.

Defines one configuration layer for explicitly exposing HTTP diagnostic headers.

Resolves ordered diagnostic exposure settings without consulting environment or debug state.

Exposes a completed summary through headers without reading or replacing the response body.

Creates an optional request-local observer before application providers bootstrap.

Receives optional profiling data without owning the framework's HTTP measurements.

Freezes one completed HTTP interval and its SQL totals without retaining request data.

Runs the HTTP entrypoint's operation and publishes one summary after its request scope closes.

Creates fresh database queue tables and validates existing tables without altering them implicitly.

Carries a validated queue topology whose default names one configured built-in transport.

Builds typed queue configuration entries for transport topology, handlers, and database lease policy.

Merges queue definitions while rejecting every explicit transport topology that cannot dispatch safely.

Carries validated database queue storage names and bounded delivery lease policy.

Identifies deterministic queue-envelope failures that must terminate the persisted job.

Reports that a database delivery no longer owns a live reservation and therefore cannot mutate its job.

Supplies the trusted database-time expression for queue dialects with reliable conditional write counts.

Rejects missing or pre-lease queue tables without attempting an implicit schema migration.

Immutable snapshot of one queue job execution.

Resolves one registered handler inside an isolated Job scope and closes that scope after invocation.

Defines an explicit, application-owned mapping between one message object and JSON-compatible data.

Maps stable queue aliases to explicitly trusted message classes and codecs.

Persists registered messages in bounded, versioned JSON envelopes authenticated before hydration.

Binds one renewable transport delivery to the handler's isolated Job scope.

Allows a database-backed handler to cooperatively extend its current delivery lease.

Carries the opaque ownership fence issued for one persistent delivery attempt.

Registers synchronous queue execution and lazily composes the authenticated database transport.

Carries a message together with immutable transport metadata for one delivery attempt.

Extends a queue transport with cooperative renewal of an already owned delivery lease.

Persists authenticated queue envelopes and fences each database delivery with an expiring owner token.

Marks immediate in-process execution and rejects attempts to use it as persistent queue storage.

Stores fixed-window buckets atomically in a MySQL or MariaDB table.

Defines a strictly positive maximum number of attempts within one fixed window.

Carries an immutable bucket decision after a status check or recorded attempt.

Registers the database-backed fixed-window limiter as a framework infrastructure service.

Limits repeated events by opaque caller-defined keys without exposing storage details.

An explicit controller method endpoint.

Represents a failed route lookup without retaining a request query string.

Carries the immutable route identity and extracted parameters selected by the canonical Router.

Canonical path normalization shared by route registration and matching.

Declares routes owned by a service provider or independently installable capability.

Collects provider-owned route registrars until routing bootstrap is finalized.

Defines request attributes exchanged at the routing dispatch boundary.

Collects immutable route definitions and resolves requests after registration freezes.

Provides bcrypt-compatible password hashing without truncating newly hashed long passwords.

Enforces the default CSRF token on unsafe requests and exposes it on every response.

Maintains independently named tokens inside the default session's CSRF namespace.

Defines the stable transport names used to submit CSRF tokens.

Exposes session-backed CSRF tokens and escaped hidden fields to templates.

Registers framework security mechanisms while leaving authentication policy and identity ownership to applications.

Signals a TOTP setting which cannot safely produce or verify interoperable codes.

Signals a Base32 credential that is malformed or too short for new TOTP use.

Signals that PHP could not obtain cryptographically secure random bytes for a new credential.

Encodes canonical unpadded Base32 and accepts human-entered Base32 formatting on input.

Computes RFC 6238 codes from already validated secret bytes and a counter time-step.

Keeps secret bytes out of object properties so PHP representation helpers cannot export them.

Holds interoperable TOTP parameters without selecting an issuer, identity, or MFA policy.

Builds a standard otpauth URI and leaves QR rendering and delivery entirely to the consumer.

Holds a canonical, minimum-strength Base32 TOTP secret without implicit string conversion.

Creates new 160-bit TOTP credentials using PHP's operating-system CSPRNG only.

Reports whether a code matched and, only on success, which counter step a host may consume for replay protection.

Verifies a fixed-width TOTP code at the framework clock without retaining replay or identity state.

Limits clock-skew acceptance around the current time-step to a small fixed maximum.

Carries the resolved settings used to construct the configured session storage

Builds declarative session configuration entries for application config sources

Resolves layered session configuration definitions into one runtime configuration

Carries the browser cookie identity and SameSite policy for one session.

Carries the table selection for database-backed session storage

Carries a local, traversal-free path selection for private file-backed session storage.

Carries the writable path selection for native PHP session storage

Carries the connection and key namespace settings for Redis-backed sessions

Provides request-scoped access to keyed session state.

Reports that a session backend cannot preserve its configured persistence or security guarantees.

Signals that resolved session configuration selected an unavailable storage driver

Provides keyed transient values stored inside the current session

Stores flash values in one normalized namespace of the current session

Delegates the public session contract to the configured storage implementation

Creates independent session instances from resolved framework session configuration.

Defines the canonical probability for request-driven session garbage collection.

Generates and validates canonical identifiers for non-native session storage.

Isolates a logical key space inside one parent session without owning its lifecycle.

Registers the host application's canonical session and flash bag services

Persists sliding sessions in a consumer-owned table with bounded opportunistic cleanup.

Persists sliding sessions in private atomically replaced files

Adapts PHP's native session runtime with framework-configured cookie and garbage-collection policy.

Normalizes phpredis return values for the session storage lifecycle.

Defines the Redis operations required by session lifecycle management.

Persists sliding sessions in Redis and delegates physical cleanup to key TTL.

Sends and expires the browser cookie that carries one session identifier.

Defines persistence and identifier lifecycle operations used by the session facade.

Resolves absolute application URLs only from explicit configuration or validated request metadata.

Converts configuration byte limits into positive integers without accepting lossy numeric formats.

Env

Reads typed environment values from framework-supported process sources in precedence order.

Generates best-effort ASCII slugs for use in URLs.

Provides the operational CLI entry point that reclaims expired sessions and orphaned upload snapshots.

Holds safe default limits for chunk reservations, transport, metadata, and temporary cleanup.

Coordinates sequential chunk transport before delegating completed files to the existing upload pipeline.

Carries immutable metadata for one active sequential upload assembled in temporary storage.

Read-only public snapshot of one active chunk upload session.

Persists and serializes temporary chunk sessions below the application's writable path.

Carries one resolved generic-upload policy after extension validation and byte-size parsing.

Carries one resolved image-upload policy, including re-encoding and dimension boundaries.

Defines immutable source values for named generic-file and image upload profiles.

Converts typed upload definitions into fail-fast runtime policies consumed by UploadFactory.

Reports that a chunk session cannot reserve bounded temporary capacity without exceeding server policy.

Reports client-controlled upload input that fails transport, policy, content, or quota validation.

Defines the resolved generic-upload policy passed to validation and storage services.

Validates generic uploads against transport, byte limits, explicit extension policy, and detected content.

Carries image upload policy with catalog-backed extension validation.

Adds image decoding, detected-image MIME agreement, and dimension checks to the generic upload boundary.

Identifies one sealed private snapshot whose size and digest were measured while its bytes were written.

Keeps a shared lock alive while validators and publication consume one staging snapshot.

Creates sealed upload snapshots in private writable storage while enforcing byte limits during streaming.

Publishes caller-asserted snapshots inside visibility-specific storage boundaries.

Exposes request-scoped uploaders whose named profiles are resolved against the current application context.

Resolves visibility-specific upload roots and rejects paths that escape them or traverse symbolic links.

Makes the central authorization decision for a classified format and an upload storage visibility.

Coordinates validation, storage, and optional image processing for uploaded files.

Registers upload validation, risk and path policy, storage, and request-scoped upload entry points.

Executes generic uploads against one immutable resolved policy.

Executes image uploads against one immutable resolved policy.

Describes a persisted upload while exposing a public-relative path only for public storage.

Extends a persisted upload reference with dimensions verified from the final bitmap bytes.

Couples the detected MIME family with the fully decoded pixels verified from the same staged snapshot.

Verifies one reCAPTCHA token and includes only the trust-resolved client address.

Accepts unmodified UTF-8 passwords between 15 and 128 Unicode characters.

Exposes request-local URL, old-input and flash operations to rendered views.

Renders PHP templates while keeping layout state and request helpers on one isolated view instance.

Exposes URL, localization, image, and session-backed CSRF operations to one request's views.

Bootstrap-time registry for provider-owned, namespaced PHP view resources.

Registers the reusable view prototype and request-scoped rendering graph.