@awesome-ecs/abstract 0.22.0 → 0.24.0

package/dist/index-BWmhFdFg.d.mts

@@ -0,0 +1,148 @@
+//#region src/utils/json-serializer.d.ts
+/**
+ * Custom JSON serialization and deserialization interface.
+ * Allows different serialization strategies for handling complex types.
+ * Used for entity snapshots, events, and any data needing JSON conversion.
+ */
+interface IJsonSerializer {
+  /**
+   * Converts an object to a serializable JSON representation.
+   * Handles types that don't serialize naturally (dates, maps, custom objects, etc.).
+   * @param value - The object to serialize.
+   * @returns A JSON-serializable representation.
+   */
+  serializeCustom(value: object): string;
+  /**
+   * Converts a JSON string back to its original object type.
+   * Reconstructs complex types from their serialized form.
+   * @template TObject - The target object type.
+   * @param text - The JSON string to deserialize.
+   * @returns The deserialized object of the specified type.
+   */
+  parseCustom<TObject>(text: string): TObject;
+}
+//#endregion
+//#region src/utils/logger.d.ts
+/**
+ * Logger interface for debug and diagnostic output.
+ * Supports multiple log levels for controlling verbosity.
+ * Implementations can target different outputs (console, file, remote, etc.).
+ */
+interface ILogger {
+  /**
+   * Logs a message with a specified severity level.
+   * @param level - The severity level of the message.
+   * @param message - The primary message content.
+   * @param args - Additional arguments to include in the log output.
+   */
+  log(level: LogLevel, message: any, ...args: any[]): void;
+  /**
+   * Logs detailed diagnostic information.
+   * Typically the lowest level, most verbose output.
+   * @param message - The message to log.
+   * @param args - Additional data.
+   */
+  trace(message: any, ...args: any[]): void;
+  /**
+   * Logs debug-level information.
+   * Useful during development and troubleshooting.
+   * @param message - The message to log.
+   * @param args - Additional data.
+   */
+  debug(message: any, ...args: any[]): void;
+  /**
+   * Logs warning-level messages.
+   * Indicates potentially problematic conditions.
+   * @param message - The message to log.
+   * @param args - Additional data.
+   */
+  warn(message: any, ...args: any[]): void;
+  /**
+   * Logs error-level messages.
+   * Indicates error conditions that may require attention.
+   * @param message - The message to log.
+   * @param args - Additional data.
+   */
+  error(message: any, ...args: any[]): void;
+}
+/**
+ * Logging severity levels in increasing order.
+ */
+declare enum LogLevel {
+  /**
+   * Most detailed, diagnostic-level logging.
+   */
+  trace = 0,
+  /**
+   * Development and debugging information.
+   */
+  debug = 1,
+  /**
+   * Warning-level conditions.
+   */
+  warn = 2,
+  /**
+   * Error-level conditions.
+   */
+  error = 3
+}
+/**
+ * Configuration options for logger instances.
+ */
+interface ILoggerOptions {
+  /**
+   * Enables/disables each log level.
+   * If a level is disabled, log calls at that level are ignored.
+   */
+  enabled: Map<LogLevel, boolean>;
+}
+//#endregion
+//#region src/utils/performance-timer.d.ts
+/**
+ * Unique identifier for a timer instance.
+ */
+type PerformanceTimerUid = number;
+/**
+ * Record of a completed timer measurement.
+ * Captures timing information for performance analysis and profiling.
+ */
+interface PerformanceTimeEntry {
+  /**
+   * The name identifying this timer.
+   */
+  name: string;
+  /**
+   * Timestamp in milliseconds when the timer started.
+   */
+  startedAt: number;
+  /**
+   * Timestamp in milliseconds when the timer ended.
+   */
+  endedAt?: number;
+  /**
+   * Duration in milliseconds that elapsed.
+   */
+  msPassed?: number;
+}
+/**
+ * Interface for measuring operation duration.
+ * Provides start/stop functionality for performance profiling.
+ * Used throughout the system to collect timing metrics.
+ */
+interface IPerformanceTimer {
+  /**
+   * Starts a new timer.
+   * @param name - Label for this timer (used in results).
+   * @returns A unique identifier for this timer instance.
+   */
+  startTimer(name: string): PerformanceTimerUid;
+  /**
+   * Stops a timer and returns the recorded metrics.
+   * @param timerUid - The timer identifier returned by startTimer.
+   * @returns Complete timing entry with start, end, and duration.
+   */
+  endTimer(timerUid: PerformanceTimerUid): PerformanceTimeEntry;
+}
+//#endregion
+export { ILoggerOptions as a, ILogger as i, PerformanceTimeEntry as n, LogLevel as o, PerformanceTimerUid as r, IJsonSerializer as s, IPerformanceTimer as t };
+//# sourceMappingURL=index-BWmhFdFg.d.mts.map

package/dist/index-CfEs8NEA.d.mts

@@ -0,0 +1,328 @@
+import { a as IEntity, c as IEntityProxy, n as IdentityComponent, o as IEntityModel, p as IComponent, r as EntityTypeUid } from "./identity-component-CgzvgBVh.mjs";
+
+//#region src/entities/entity-events.d.ts
+/**
+ * Represents a unique identifier for an entity event.
+ * Can be either a string or a number.
+ */
+type EntityEventUid = string | number;
+/**
+ * A filter function for entity event subscriptions.
+ * Returns true if the event should be processed, false otherwise.
+ */
+type EntityEventSubscriptionFilter = (event: IEntityEvent<IEventData>) => boolean;
+/**
+ * The `IEventData` interface represents the data associated with an entity event.
+ * It contains at least the `Event Unique Identifier`.
+ */
+interface IEventData {
+  uid: EntityEventUid;
+}
+/**
+ * Represents a publishable event in the entity system.
+ * Enables loosely-coupled communication between entities through an Observer pattern.
+ * Events include origin, optional target, and typed data payload.
+ *
+ * @template TEventData - The type of data carried by this event.
+ */
+interface IEntityEvent<TEventData extends IEventData> {
+  /**
+   * The entity that originated this event.
+   */
+  origin: IEntityProxy;
+  /**
+   * Optional target entity for this event.
+   * If omitted, the event is broadcast to all subscribers.
+   */
+  target?: IEntityProxy;
+  /**
+   * The event payload containing type-specific data.
+   */
+  data: TEventData;
+  /**
+   * The scope of the dispatching entity.
+   * When set, the event is only delivered to subscribers in the same scope.
+   */
+  scopeId?: string;
+}
+/**
+ * Options for subscribing to an entity event.
+ */
+interface EntityEventSubscriptionOptions {
+  /**
+   * Optional function to determine which specific events are processed.
+   */
+  filter?: EntityEventSubscriptionFilter;
+  /**
+   * The scope of the subscribing entity.
+   * When set, the subscriber only receives events from the same scope.
+   */
+  scopeId?: string;
+}
+/**
+ * Manages subscriptions and dispatching for entity events.
+ * Implements the Observer pattern to decouple event producers from consumers.
+ * Tracks which entities are interested in which event types and maintains subscription state.
+ */
+interface IEntityEventsManager {
+  /**
+   * Subscribes an entity to a specific event type.
+   * The entity will be notified when events of that type are dispatched.
+   * @param uid - The event type to subscribe to.
+   * @param entity - The entity registering for this event type.
+   * @param options - Optional subscription options (filter, scopeId).
+   */
+  subscribe(uid: EntityEventUid, entity: IEntityProxy, options?: EntityEventSubscriptionOptions): void;
+  /**
+   * Unsubscribes an entity from a specific event type.
+   * The entity will no longer receive notifications for this event type.
+   * @param uid - The event type to unsubscribe from.
+   * @param entity - The entity unregistering from this event type.
+   */
+  unsubscribe(uid: EntityEventUid, entity: IEntityProxy): void;
+  /**
+   * Retrieves all entities subscribed to a specific event.
+   * @param event - The event to get subscriptions for.
+   * @returns Array of entities subscribed to this event.
+   */
+  getSubscriptions(event: IEntityEvent<IEventData>): IEntityProxy[];
+  /**
+   * Retrieves all event types an entity is subscribed to.
+   * @param entity - The entity to query.
+   * @returns Array of event type identifiers this entity is listening to.
+   */
+  getSubscriptionsForEntity(entity: IEntityProxy): EntityEventUid[];
+  /**
+   * Removes all subscriptions system-wide.
+   */
+  clearSubscriptions(): void;
+  /**
+   * Removes all subscriptions for a specific event type.
+   * @param uid - The event type to remove subscriptions from.
+   */
+  clearSubscriptionsForEvent(uid: EntityEventUid): void;
+  /**
+   * Removes all subscriptions for a specific entity.
+   * @param entity - The entity to remove all subscriptions for.
+   */
+  clearSubscriptionsForEntity(entity: IEntityProxy): void;
+}
+/**
+ * Event dispatcher for publishing events to interested entities.
+ * Responsible for routing events to their subscribers through the update queue.
+ */
+interface IEntityEventsDispatcher {
+  /**
+   * Publishes a single event to subscribers.
+   * The event is routed based on subscriptions or explicit target(s).
+   * @param event - The event to dispatch.
+   * @param targets - Optional specific entities to send to. If provided, event is only sent to these targets.
+   */
+  dispatchEvent(event: IEntityEvent<IEventData>, ...targets: IEntityProxy[]): void;
+  /**
+   * Publishes multiple events to subscribers.
+   * Efficiently dispatches an array of events in bulk.
+   * @param events - The events to dispatch.
+   * @param targets - Optional specific entities to send to. If provided, events are only sent to these targets.
+   */
+  dispatchEvents(events: IEntityEvent<IEventData>[], ...targets: IEntityProxy[]): void;
+}
+//#endregion
+//#region src/entities/entity-snapshot.d.ts
+/**
+ * A serializable representation of entity state.
+ * Captures full or partial entity state including components, relationships, and events.
+ * Snapshots enable state replication, persistence, and delta updates from external sources.
+ */
+interface IEntitySnapshot {
+  /**
+   * The entity's identity information if included in the snapshot.
+   */
+  readonly identity?: Readonly<IdentityComponent<IEntityModel>>;
+  /**
+   * Entity components to be included in the snapshot.
+   * Only components marked as serializable are typically included.
+   */
+  readonly components?: IComponent[];
+  /**
+   * Entity relationships (proxies) to include in the snapshot.
+   */
+  readonly proxies?: IEntityProxy[];
+  /**
+   * Events associated with the entity to include in the snapshot.
+   */
+  readonly events?: IEntityEvent<IEventData>[];
+}
+/**
+ * Handles snapshot creation and application.
+ * Provides abstraction for converting between entities and their serializable snapshots.
+ * Used for state persistence, synchronization, and entity updates from external sources.
+ */
+interface IEntitySnapshotProvider {
+  /**
+   * Applies a snapshot state to an entity.
+   * Updates the entity's components, relationships, and events based on the snapshot.
+   * @param entity - The entity to update.
+   * @param snapshot - The state to apply.
+   */
+  applySnapshot(entity: IEntity, snapshot: IEntitySnapshot): void;
+  /**
+   * Creates a snapshot capturing the current state of an entity.
+   * Serializes all or specified parts of the entity for storage or transmission.
+   * @param entity - The entity to snapshot.
+   * @returns A serializable representation of the entity state.
+   */
+  createSnapshot(entity: IEntity): IEntitySnapshot;
+}
+//#endregion
+//#region src/entities/entity-queue.d.ts
+/**
+ * Specifies the action to be performed on an entity.
+ * Updates are categorized to enable different processing paths in the runtime.
+ */
+declare enum EntityUpdateType {
+  /**
+   * Indicates the entity should be updated with new data.
+   */
+  update = "update",
+  /**
+   * Indicates the entity should be removed from the system.
+   */
+  remove = "remove"
+}
+/**
+ * Represents a queued entity state change or removal.
+ * Updates flow through the system to be processed by entity update handlers.
+ */
+interface IEntityUpdate {
+  /**
+   * The type of operation: update or remove.
+   */
+  readonly type: EntityUpdateType;
+  /**
+   * The entity being affected by this update.
+   */
+  readonly entity: IEntityProxy;
+  /**
+   * Optional model data for initialization or reconfiguration.
+   */
+  readonly model?: IEntityModel;
+  /**
+   * Optional serialized state to apply to the entity.
+   */
+  readonly snapshot?: IEntitySnapshot;
+}
+/**
+ * Queue interface for managing pending entity updates.
+ * Different implementations may use different prioritization strategies (e.g., priority queues, FIFO, ordered by entity type).
+ * Updates are consumed by the runtime and dispatched to appropriate entity systems.
+ */
+interface IEntityUpdateQueue {
+  /**
+   * The current number of updates in the queue.
+   */
+  readonly size: number;
+  /**
+   * Adds an update to the queue for processing.
+   * @param change - The update to queue.
+   */
+  enqueue(change: IEntityUpdate): void;
+  /**
+   * Removes and returns the next update from the queue.
+   * The specific update returned depends on the queue's prioritization strategy.
+   * @returns The next queued update.
+   */
+  dequeue(): IEntityUpdate;
+  /**
+   * Views the next update without removing it.
+   * Useful for inspection before dequeuing.
+   * @returns The next update in the queue.
+   */
+  peek(): IEntityUpdate;
+  /**
+   * Removes all updates from the queue.
+   */
+  clear(): void;
+}
+//#endregion
+//#region src/entities/entity-repository.d.ts
+/**
+ * Central storage for all active entities in the system.
+ * The repository provides CRUD operations and is the source of truth for entity existence and state.
+ * All entity access and modifications go through this repository.
+ */
+interface IEntityRepository {
+  /**
+   * The total number of entities currently stored.
+   */
+  readonly size: number;
+  /**
+   * Checks if an entity exists in storage.
+   * @param proxy - Reference to the entity to check.
+   * @returns True if the entity exists, false otherwise.
+   */
+  has(proxy: IEntityProxy): boolean;
+  /**
+   * Retrieves an entity from storage by proxy.
+   * @template TEntity - The expected entity type.
+   * @param proxy - Reference to the entity to retrieve.
+   * @returns The requested entity.
+   */
+  get<TEntity extends IEntity>(proxy: IEntityProxy): TEntity;
+  /**
+   * Retrieves all entities of a specific type.
+   * @template TEntity - The entity type to retrieve.
+   * @param entityType - The type identifier to filter by.
+   * @returns Array of all entities matching the type.
+   */
+  getAll<TEntity extends IEntity>(entityType: EntityTypeUid): TEntity[];
+  /**
+   * Iterates over all entities regardless of type.
+   * @returns An iterator over all stored entities.
+   */
+  listAll(): IterableIterator<IEntity>;
+  /**
+   * Stores or updates an entity.
+   * @param entity - The entity to store.
+   */
+  set(entity: IEntity): void;
+  /**
+   * Removes an entity from storage.
+   * @param proxy - Reference to the entity to remove.
+   */
+  delete(proxy: IEntityProxy): void;
+  /**
+   * Removes all entities of a specific type from storage.
+   * @param entityType - The type identifier for entities to remove.
+   */
+  clear(entityType: EntityTypeUid): void;
+}
+//#endregion
+//#region src/entities/entity-scheduler.d.ts
+/**
+ * Manages time-based scheduling of entity updates.
+ * Entities are registered with intervals and receive updates at the specified cadence, or on the next frame (engine-dependent).
+ */
+interface IEntityScheduler {
+  /**
+   * Registers an entity for periodic updates.
+   * @param entityProxy - The entity to schedule.
+   * @param intervalMs - Update frequency in milliseconds. If omitted, a default interval is used.
+   */
+  schedule(entityProxy: IEntityProxy, intervalMs?: number): void;
+  /**
+   * Unregisters an entity from the scheduler.
+   * The entity will no longer receive periodic updates.
+   * @param entityProxy - The entity to unschedule.
+   */
+  remove(entityProxy: IEntityProxy): void;
+  /**
+   * Checks if an entity is currently scheduled for updates.
+   * @param entityProxy - The entity to check.
+   * @returns True if the entity is scheduled, false otherwise.
+   */
+  has(entityProxy: IEntityProxy): boolean;
+}
+//#endregion
+export { IEntityUpdateQueue as a, EntityEventSubscriptionFilter as c, IEntityEvent as d, IEntityEventsDispatcher as f, IEntityUpdate as i, EntityEventSubscriptionOptions as l, IEventData as m, IEntityRepository as n, IEntitySnapshot as o, IEntityEventsManager as p, EntityUpdateType as r, IEntitySnapshotProvider as s, IEntityScheduler as t, EntityEventUid as u };
+//# sourceMappingURL=index-CfEs8NEA.d.mts.map

package/dist/index-D4jK3qG1.d.mts

@@ -0,0 +1,224 @@
+import { n as Immutable } from "./types-CnDtpKsY.mjs";
+import { n as PerformanceTimeEntry } from "./index-BWmhFdFg.mjs";
+
+//#region src/pipelines/pipeline-context.d.ts
+/**
+ * Base interface for all pipeline context objects.
+ * Provides hooks for runtime state and control flow during pipeline execution.
+ */
+interface IPipelineContext {
+  /**
+   * The runtime state and control interface for the pipeline.
+   * Allows middleware to query and influence pipeline behavior.
+   */
+  readonly runtime?: PipelineRuntime;
+}
+/**
+ * Runtime state and control interface for pipeline execution.
+ * Allows middleware to query status and influence pipeline flow.
+ */
+type PipelineRuntime = {
+  /**
+   * Flag to request pipeline halt.
+   * Set to true to stop executing remaining middleware (cleanup still runs).
+   */
+  shouldStop?: boolean;
+  /**
+   * Optional error state if an exception occurred during execution.
+   */
+  error?: any;
+  /**
+   * Results collected from middleware execution.
+   * Typically includes performance metrics and operational results.
+   */
+  readonly metrics?: PerformanceTimeEntry[];
+};
+//#endregion
+//#region src/pipelines/middleware.d.ts
+/**
+ * The basic unit of work in a pipeline.
+ * Middleware are chained together to form processing pipelines.
+ * Each middleware can inspect/modify context during dispatch and perform cleanup on their changes.
+ *
+ * @template TContext The context type passed through the middleware chain.
+ */
+interface IMiddleware<TContext extends IPipelineContext> {
+  /**
+   * Optional name for debugging and logging purposes.
+   */
+  readonly name?: string;
+  /**
+   * Optional guard condition before running the action.
+   * Allows middleware to skip execution based on context state.
+   * @param context The current pipeline context.
+   * @returns True to execute action, false to skip.
+   */
+  shouldRun?(context: TContext): boolean;
+  /**
+   * The main unit of work executed as part of the pipeline.
+   * Middlewares execute in registration order during dispatch phase.
+   * Can read and modify the context to influence downstream middleware and results.
+   * @param context The pipeline context containing all relevant state.
+   */
+  action(context: TContext): void | Promise<void>;
+  /**
+   * Optional cleanup function executed during pipeline teardown.
+   * Middlewares execute in reverse registration order during cleanup phase.
+   * Used to release resources, clear temporary state, and perform final operations.
+   * @param context The pipeline context (may be in modified state from action phases).
+   */
+  cleanup?(context: TContext): void | Promise<void>;
+}
+//#endregion
+//#region src/pipelines/middleware-runner.d.ts
+/**
+ * Customizes how middleware is executed within a pipeline.
+ * Allows decorators to wrap, intercept, or modify middleware execution behavior.
+ * Useful for implementing middleware decorators (logging, timing, error handling, etc.).
+ *
+ * @template TContext The type of context passed to middleware.
+ */
+interface IMiddlewareRunner<TContext extends IPipelineContext> {
+  /**
+   * Decides how to execute a middleware's action.
+   * Can add pre/post processing, error handling, or performance tracking around the middleware.
+   * @param context The current pipeline context.
+   * @param middleware The middleware whose action should be executed.
+   */
+  dispatch(context: TContext, middleware: IMiddleware<TContext>): void | Promise<void>;
+  /**
+   * Decides how to execute a middleware's cleanup.
+   * Can add pre/post processing or error handling around cleanup operations.
+   * @param context The current pipeline context.
+   * @param middleware The middleware whose cleanup should be executed.
+   */
+  cleanup(context: TContext, middleware: IMiddleware<TContext>): void | Promise<void>;
+}
+//#endregion
+//#region src/pipelines/pipeline.d.ts
+/**
+ * A composable middleware chain for ordered execution of operations.
+ * Pipelines provide a framework for registering and executing middleware with dispatch and cleanup phases.
+ * Used throughout the ECS system for entity initialization, updates, rendering, and synchronization.
+ *
+ * @template TContext - The context type passed to all registered middleware.
+ */
+interface IPipeline<TContext extends IPipelineContext> {
+  /**
+   * The pipeline's name, useful for debugging and logging.
+   */
+  readonly name?: string;
+  /**
+   * The number of middleware currently registered in this pipeline.
+   */
+  readonly length?: number;
+  /**
+   * Direct access to the ordered list of registered middleware.
+   * Allows inspection of the execution chain.
+   */
+  readonly middleware?: Immutable<IMiddleware<TContext>[]>;
+  /**
+   * Registers middleware to be executed as part of this pipeline.
+   * Middleware is added to the end of the chain and executed in registration order during dispatch.
+   * @param middleware - The middleware to register.
+   * @returns This instance for method chaining.
+   */
+  use(middleware: Immutable<IMiddleware<TContext>>): this;
+  /**
+   * Executes the dispatch phase with all registered middleware in order.
+   * Each middleware's action is called, allowing modifications to context state.
+   * Execution continues until all middleware complete or a middleware requests early termination.
+   * @param context - The context object passed to all middleware.
+   */
+  dispatch(context: Partial<TContext>): void | Promise<void>;
+  /**
+   * Executes the cleanup phase with all registered middleware in reverse order.
+   * Allows middleware to perform resource cleanup and final operations.
+   * Typically called after dispatch to ensure proper teardown.
+   *
+   * @param context - The context object that will be passed to each middleware function.
+   */
+  cleanup(context: Partial<TContext>): void | Promise<void>;
+}
+//#endregion
+//#region src/pipelines/pipeline-nested.d.ts
+/**
+ * Context for a parent pipeline containing nested pipelines.
+ * Allows coordination between outer and inner pipeline execution.
+ *
+ * @template N - The context type for the nested pipelines.
+ */
+interface IParentContext<N extends IPipelineContext> extends IPipelineContext {
+  /**
+   * The nested pipeline to execute for each context in nestedContexts.
+   */
+  readonly nestedPipeline: IPipeline<INestedContext<this>>;
+  /**
+   * Contexts to pass to the nested pipeline.
+   * The parent pipeline iterates these and executes the nested pipeline for each.
+   */
+  readonly nestedContexts: Partial<N>[];
+}
+/**
+ * Context for a nested pipeline.
+ * Provides access to both current and previous nested context data plus the parent context.
+ *
+ * @template P - The context type of the parent pipeline.
+ */
+interface INestedContext<P extends IParentContext<any>> extends IPipelineContext {
+  /**
+   * The current context item being processed in the nested pipeline.
+   */
+  readonly current: P extends IParentContext<infer N> ? N : never;
+  /**
+   * The previous context item (if this is not the first iteration).
+   */
+  readonly previous?: P extends IParentContext<infer N> ? N : never;
+  /**
+   * Reference back to the parent pipeline context.
+   */
+  readonly parent: P;
+}
+/**
+ * Middleware executing within a nested pipeline.
+ *
+ * @template P - The context type of the parent pipeline.
+ */
+type INestedMiddleware<P extends IParentContext<any>> = IMiddleware<INestedContext<P>>;
+/**
+ * Middleware executing within a parent pipeline (containing nested pipelines).
+ *
+ * @template P - The context type of the parent pipeline.
+ */
+type IParentMiddleware<P extends IParentContext<any>> = IMiddleware<P>;
+//#endregion
+//#region src/pipelines/pipeline-runner.d.ts
+/**
+ * Executes an array of middleware in a controlled sequence.
+ * Supports custom execution strategies through implementation flexibility.
+ * Used by pipelines to manage complex middleware chains with features like early termination and nested pipelines.
+ *
+ * @template TContext - The context type passed to all middleware.
+ */
+interface IPipelineRunner<TContext extends IPipelineContext> {
+  /**
+   * Executes the action phase of all middleware in sequence.
+   * Middleware at startIndex and onward are executed in order.
+   * Execution may terminate early if middleware requests it via context.runtime.shouldStop.
+   * @param context - The context passed to each middleware action.
+   * @param middleware - The ordered middleware array to execute.
+   * @param startIndex - Optional starting position in the middleware array (default: 0).
+   */
+  dispatch(context: Partial<TContext>, middleware: IMiddleware<TContext>[], startIndex?: number): void | Promise<void>;
+  /**
+   * Executes the cleanup phase of all middleware in reverse order.
+   * All middleware cleanup functions are called (if defined), regardless of errors.
+   * Allows proper resource release and final state management.
+   * @param context - The context passed to each middleware cleanup.
+   * @param middleware - The ordered middleware array for cleanup (reversed during execution).
+   */
+  cleanup(context: Partial<TContext>, middleware: IMiddleware<TContext>[]): void | Promise<void>;
+}
+//#endregion
+export { IParentMiddleware as a, IMiddleware as c, IParentContext as i, IPipelineContext as l, INestedContext as n, IPipeline as o, INestedMiddleware as r, IMiddlewareRunner as s, IPipelineRunner as t, PipelineRuntime as u };
+//# sourceMappingURL=index-D4jK3qG1.d.mts.map