@awesome-ecs/abstract 0.30.0 → 0.32.0

package/dist/{index-BVkmidEx.d.cts → index-D3rS2RFG.d.mts}

@@ -1,44 +1,8 @@
-import { _ as IEntityProxy, f as EntityTypeUid, g as EntityProxy, h as IEntityModel, i as Immutable, m as IEntity, p as EntityUid, v as IEntityProxyRepository } from "./identity-component-DLDaOTyK.cjs";
-import { c as IEntitySnapshot, d as EntityEventSubscriptionOptions, f as EntityEventUid, g as IEventData, o as IEntityUpdate, p as IEntityEvent } from "./index-BguFn1Xj.cjs";
+import { _ as ConfigRecord, a as IEntity, c as IEntityProxy, f as ComponentTypeUid, i as EntityUid, l as IEntityProxyRepository, o as IEntityModel, r as EntityTypeUid, s as EntityProxy } from "./index-b5BtWAvO.mjs";
+import { r as Immutable } from "./types-C1ojaDL4.mjs";
+import { c as IEntitySnapshot, d as EntityEventSubscriptionOptions, f as EntityEventUid, g as IEventData, o as IEntityUpdate, p as IEntityEvent, v as IEntityConfigSnapshot } from "./index-C1hRAjM-.mjs";
+import { c as IMiddleware, l as IPipelineContext, o as IPipeline, u as PipelineRuntime } from "./index-CeqaKmWR.mjs";
 
-//#region src/utils/dispatch-sequential.d.ts
-/**
- * Executes a function for each item in an iterable, sequentially.
- *
- * Uses a sync fast-path: iterates synchronously until the first Promise is
- * encountered, then switches to async for the remainder. If no item produces
- * a Promise, the entire call stays synchronous with zero async overhead.
- *
- * @param items - The iterable to iterate over.
- * @param fn - The function to call for each item. May return void or a Promise.
- * @returns void if all calls were synchronous, or a Promise if any were async.
- */
-declare function dispatchSequential<T>(items: Iterable<T>, fn: (item: T) => void | Promise<void>): void | Promise<void>;
-//#endregion
-//#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.
@@ -114,320 +78,136 @@ interface ILoggerOptions {
   enabled: Map<LogLevel, boolean>;
 }
 //#endregion
-//#region src/utils/performance.d.ts
-type TickMetricEntry = {
-  name: string;
-  category: string;
-  totalMs: number;
-  count: number;
-};
-type TickSnapshot = {
-  tickIndex: number;
-  tickDurationMs: number;
-  fps: number;
-  queueSize: number;
-  timestamp: number;
-  metrics: TickMetricEntry[];
-  render?: RenderSnapshot;
-};
-type RenderSnapshot = {
-  frameTimeMs: number;
-  renderTimeMs: number;
-  gpuFrameTimeMs: number;
-  drawCalls: number;
-  activeMeshesEvalMs: number;
-  cameraRenderMs: number;
-  totalVertices: number;
-  activeIndices: number;
-};
-type MiddlewareMetricsSummary = {
-  name: string;
-  category: PipelineCategoryName;
-  count: number;
-  totalMs: number;
-  avgMs: number;
-  minMs: number;
-  maxMs: number;
-  lastMs: number;
-};
-//#endregion
-//#region src/utils/performance-timer.d.ts
-/**
- * Unique identifier for a timer instance.
- */
-type PerformanceTimerUid = number;
-/**
- * Options for identifying and categorizing performance metrics.
- * Used by pipeline factories and performance decorators.
- */
-type PerformanceMetricOptions = {
-  name?: string;
-  category?: string;
-};
+//#region src/systems/pipeline/system-context-config.d.ts
 /**
- * Record of a completed timer measurement.
- * Captures timing information for performance analysis and profiling.
+ * Config-specific API for the current system execution.
+ *
+ * The runtime applies config patches before the config phase runs. This context
+ * records the component config values immediately before the patch was applied,
+ * then exposes both previous and current values to config middleware.
  */
-interface PerformanceTimeEntry {
-  /**
-   * The name identifying this timer.
-   */
-  name: string;
-  /**
-   * The category of this metric (e.g. 'module', 'runtime', 'system').
-   */
-  category?: string;
+interface ISystemContextConfigReadonly {
   /**
-   * Timestamp in milliseconds when the timer started.
+   * Returns true when the current entity update included a config patch for
+   * this component type.
    */
-  startedAt: number;
+  hasChanged(componentType: ComponentTypeUid): boolean;
   /**
-   * Timestamp in milliseconds when the timer ended.
+   * Returns the component's current config values after the runtime-applied
+   * config patch.
    */
-  endedAt?: number;
+  getCurrentValue<TConfig extends ConfigRecord>(componentType: ComponentTypeUid): Immutable<TConfig> | undefined;
   /**
-   * 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).
-   * @param category - Optional category for grouping metrics.
-   * @returns A unique identifier for this timer instance.
-   */
-  startTimer(name: string, category?: 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.
+   * Returns the component config values captured immediately before the
+   * runtime-applied config patch, or undefined when the component did not
+   * change in this update.
    */
-  endTimer(timerUid: PerformanceTimerUid): PerformanceTimeEntry;
-}
-//#endregion
-//#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 {
+  getPreviousValue<TConfig extends ConfigRecord>(componentType: ComponentTypeUid): Immutable<TConfig> | undefined;
   /**
-   * The runtime state and control interface for the pipeline.
-   * Allows middleware to query and influence pipeline behavior.
+   * Queues a config update for an entity. Config updates use the normal entity
+   * update path, but carry only component config patches.
    */
-  readonly runtime?: PipelineRuntime;
+  updateConfig<TConfig extends ConfigRecord>(target: IEntityProxy, config: IEntityConfigSnapshot<TConfig>): void;
 }
 /**
- * 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.
+ * Config-specific API for the current system execution.
  *
- * @template TContext The context type passed through the middleware chain.
+ * The runtime applies config patches before the config phase runs. This context
+ * records the component config values immediately before the patch was applied,
+ * then exposes both previous and current values to config middleware.
+ *
+ * The mutable API includes an `applyConfig` method for the runtime to set the current update,
+ * apply its config patch, and capture previous values.
+ * Systems middleware should use the readonly variant.
  */
-interface IMiddleware<TContext extends IPipelineContext> {
-  /**
-   * Optional name for debugging and logging purposes.
-   */
-  readonly name?: string;
+interface ISystemContextConfig extends ISystemContextConfigReadonly {
   /**
-   * 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.
+   * Sets the current entity update, applies its config patch, and captures previous values for change detection.
+   * @param update The current entity update.
+   * @param isInitializing Specify whether the entity is initializing.
    */
-  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>;
+  applyConfig(update: IEntityUpdate | undefined, isInitializing?: boolean): void;
 }
 //#endregion
-//#region src/pipelines/middleware-runner.d.ts
+//#region src/systems/pipeline/system-middleware.d.ts
+type SystemMiddlewareName = string;
+type SystemModuleName = string;
+type MiddlewareRegistry = Map<SystemMiddlewareName, SystemModuleName>;
+type MiddlewareRegistryReadonly = ReadonlyMap<SystemMiddlewareName, SystemModuleName>;
 /**
- * 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.).
+ * A middleware unit that operates within the system pipeline.
+ * System middleware receive comprehensive context about the entity being processed
+ * and can influence entity state and behavior through various APIs.
  *
- * @template TContext The type of context passed to middleware.
+ * @template TEntity - The entity type this middleware handles.
  */
-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>;
-}
+type ISystemMiddleware<TEntity extends IEntity> = IMiddleware<ISystemContext<TEntity>>;
 //#endregion
-//#region src/pipelines/pipeline.d.ts
+//#region src/systems/pipeline/system-context-control.d.ts
+declare enum SystemContextControlState {
+  none = "none",
+  enableCurrentSystem = "enableCurrentSystem",
+  disableCurrentSystem = "disableCurrentSystem",
+  enableCurrentModule = "enableCurrentModule",
+  disableCurrentModule = "disableCurrentModule"
+}
 /**
- * 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 for controlling the execution of systems and modules within a system context.
+ * This allows middleware to enable or disable specific systems or entire modules for the current entity.
  */
-interface IPipeline<TContext extends IPipelineContext> {
-  /**
-   * The pipeline's name, useful for debugging and logging.
-   */
-  readonly name?: string;
+interface ISystemContextControl {
   /**
-   * The number of middleware currently registered in this pipeline.
+   * Disables the current system for the current entity.
    */
-  readonly length?: number;
+  disableCurrentSystem(): void;
   /**
-   * Direct access to the ordered list of registered middleware.
-   * Allows inspection of the execution chain.
+   * Re-enables the current system for the current entity.
    */
-  readonly middleware?: Immutable<IMiddleware<TContext>[]>;
+  enableCurrentSystem(): void;
   /**
-   * 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.
+   * Disables the current module for the current entity.
    */
-  use(middleware: Immutable<IMiddleware<TContext>>): this;
+  disableCurrentModule(): void;
   /**
-   * 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.
+   * Re-enables the current module for the current entity.
    */
-  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>;
+  enableCurrentModule(): 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.
+ * Extended system context interface that includes control state for middleware to manage system and module execution.
+ * This allows middleware to query and modify the execution state of systems and modules during pipeline processing.
  */
-interface IParentContext<N extends IPipelineContext> extends IPipelineContext {
+interface ISystemContextControlState extends ISystemContextControl {
   /**
-   * The nested pipeline to execute for each context in nestedContexts.
+   * Current state of system/module execution control, indicating whether the current system or module is enabled or disabled.
    */
-  readonly nestedPipeline: IPipeline<INestedContext<this>>;
+  readonly state: SystemContextControlState;
   /**
-   * Contexts to pass to the nested pipeline.
-   * The parent pipeline iterates these and executes the nested pipeline for each.
+   * Checks if a specific middleware is currently disabled in the context, allowing middleware to conditionally execute logic based on the enabled/disabled state of other middleware.
+   * @param middleware - The middleware to check for disabled state.
+   * @returns True if the specified middleware is currently disabled, false otherwise.
    */
-  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 {
+  isMiddlewareDisabled(middleware: ISystemMiddleware<IEntity>): boolean;
   /**
-   * The current context item being processed in the nested pipeline.
+   * Disables a specific middleware in the context.
+   * @param middleware - The middleware to disable.
    */
-  readonly current: P extends IParentContext<infer N> ? N : never;
+  disableMiddleware(middleware: ISystemMiddleware<IEntity>): void;
   /**
-   * The previous context item (if this is not the first iteration).
+   * Enables a specific middleware in the context.
+   * @param middleware - The middleware to enable.
    */
-  readonly previous?: P extends IParentContext<infer N> ? N : never;
+  enableMiddleware(middleware: ISystemMiddleware<IEntity>): void;
   /**
-   * Reference back to the parent pipeline context.
+   * Disables an entire module of middleware in the context.
+   * @param middleware - A middleware from the module to disable.
    */
-  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>;
+  disableModule(middleware: ISystemMiddleware<IEntity>): 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).
+   * Enables an entire module of middleware in the context.
+   * @param middleware - A middleware from the module to enable.
    */
-  cleanup(context: Partial<TContext>, middleware: IMiddleware<TContext>[]): void | Promise<void>;
+  enableModule(middleware: ISystemMiddleware<IEntity>): void;
 }
 //#endregion
 //#region src/systems/pipeline/system-context-events.d.ts
@@ -591,7 +371,7 @@ interface ISystemContextRepository {
    */
   getEntity<TEntity extends IEntity>(proxy: EntityProxy<TEntity> | EntityTypeUid): Immutable<TEntity>;
   /**
-   * Queues an entity for update.
+   * Enqueues an entity for update.
    * Triggers the update pipeline for the entity.
    * @param target - Optional specific entity to update. Defaults to current entity in context.
    */
@@ -612,7 +392,7 @@ interface ISystemContextRepository {
  */
 interface ISystemContextScheduler {
   /**
-   * Schedules an entity for update.
+   * Schedules or replaces an entity update schedule.
    * If no target is specified, schedules the current entity.
    * If no interval is specified, schedules on a default interval.
    * @param target - Optional entity to schedule. Defaults to current entity in context.
@@ -633,6 +413,30 @@ interface ISystemContextScheduler {
   hasSchedule(target?: IEntityProxy): boolean;
 }
 //#endregion
+//#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/systems/pipeline/system-context-snapshot.d.ts
 /**
  * System context API for entity serialization and state transfer.
@@ -685,6 +489,10 @@ interface ISystemContext<TEntity extends IEntity> extends IPipelineContext {
    * The entity currently being processed by this middleware.
    */
   readonly entity: Immutable<TEntity>;
+  /**
+   * Config metadata and config-update API for the current update.
+   */
+  readonly config: Immutable<ISystemContextConfigReadonly>;
   /**
    * Information about the update triggering this system execution.
    * Contains type (update/remove) and optional model/snapshot data.
@@ -694,6 +502,10 @@ interface ISystemContext<TEntity extends IEntity> extends IPipelineContext {
    * Event system API for publishing and subscribing to entity events.
    */
   readonly events: Immutable<ISystemContextEvents>;
+  /**
+   * Logging interface for debug and diagnostic output.
+   */
+  readonly logger: Immutable<ILogger>;
   /**
    * Proxy management API for establishing and managing entity relationships.
    */
@@ -711,9 +523,13 @@ interface ISystemContext<TEntity extends IEntity> extends IPipelineContext {
    */
   readonly snapshot: Immutable<ISystemContextSnapshot>;
   /**
-   * Logging interface for debug and diagnostic output.
+   * Control API for enabling/disabling the current system or entire module during execution.
    */
-  readonly logger: Immutable<ILogger>;
+  readonly systems: Immutable<ISystemContextControl>;
+  /**
+   * The per-entity runtime state and control interface for this system context.
+   */
+  readonly runtime: PipelineRuntime;
 }
 //#endregion
 //#region src/systems/pipeline/system-context-mutable.d.ts
@@ -730,6 +546,117 @@ interface IMutableSystemContext<TEntity extends IEntity> extends ISystemContext<
   setRuntime(runtime: PipelineRuntime): void;
 }
 //#endregion
+//#region src/utils/dispatch-sequential.d.ts
+/**
+ * Executes a function for each item in an iterable, sequentially.
+ *
+ * Uses a sync fast-path: iterates synchronously until the first Promise is
+ * encountered, then switches to async for the remainder. If no item produces
+ * a Promise, the entire call stays synchronous with zero async overhead.
+ *
+ * @param items - The iterable to iterate over.
+ * @param fn - The function to call for each item. May return void or a Promise.
+ * @returns void if all calls were synchronous, or a Promise if any were async.
+ */
+declare function dispatchSequential<T>(items: Iterable<T>, fn: (item: T) => void | Promise<void>): void | Promise<void>;
+//#endregion
+//#region src/utils/performance.d.ts
+type TickMetricEntry = {
+  name: string;
+  category: string;
+  totalMs: number;
+  count: number;
+};
+type TickSnapshot = {
+  tickIndex: number;
+  tickDurationMs: number;
+  fps: number;
+  queueSize: number;
+  timestamp: number;
+  metrics: TickMetricEntry[];
+  render?: RenderSnapshot;
+};
+type RenderSnapshot = {
+  frameTimeMs: number;
+  renderTimeMs: number;
+  gpuFrameTimeMs: number;
+  drawCalls: number;
+  activeMeshesEvalMs: number;
+  cameraRenderMs: number;
+  totalVertices: number;
+  activeIndices: number;
+};
+type MiddlewareMetricsSummary = {
+  name: string;
+  category: PipelineCategoryName;
+  count: number;
+  totalMs: number;
+  avgMs: number;
+  minMs: number;
+  maxMs: number;
+  lastMs: number;
+};
+//#endregion
+//#region src/utils/performance-timer.d.ts
+/**
+ * Unique identifier for a timer instance.
+ */
+type PerformanceTimerUid = number;
+/**
+ * Options for identifying and categorizing performance metrics.
+ * Used by pipeline factories and performance decorators.
+ */
+type PerformanceMetricOptions = {
+  name?: string;
+  category?: string;
+};
+/**
+ * Record of a completed timer measurement.
+ * Captures timing information for performance analysis and profiling.
+ */
+interface PerformanceTimeEntry {
+  /**
+   * The name identifying this timer.
+   */
+  name: string;
+  /**
+   * The category of this metric (e.g. 'module', 'runtime', 'system').
+   */
+  category?: 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).
+   * @param category - Optional category for grouping metrics.
+   * @returns A unique identifier for this timer instance.
+   */
+  startTimer(name: string, category?: 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
 //#region src/factories/context-factory.d.ts
 /**
  * Creates and caches per-entity system contexts.
@@ -745,9 +672,10 @@ interface IContextFactory {
    * On subsequent calls, returns the cached context.
    * @template TEntity - The entity type for which the system context is being created.
    * @param entity - The entity to create or retrieve the context for.
+   * @param registry - Optional middleware registry to associate with the context for pipeline execution.
    * @returns The mutable system context for the entity.
    */
-  getOrCreateContext<TEntity extends IEntity>(entity: Immutable<TEntity>): IMutableSystemContext<TEntity>;
+  getOrCreateContext<TEntity extends IEntity>(entity: Immutable<TEntity>, registry?: MiddlewareRegistryReadonly): IMutableSystemContext<TEntity>;
   /**
    * Retrieves a previously cached system context by entity UID.
    * @template TEntity - The entity type.
@@ -772,7 +700,7 @@ type PipelineCategoryName = string;
 /**
  * Built-in metric categories for classifying pipeline and middleware performance entries.
  *
- * - `module` — System module pipelines (initialize, update, render, sync phases).
+ * - `module` — System module pipelines (initialize, config, update, render, sync phases).
  * - `runtime` — Runtime orchestration pipeline and its middleware.
  * - `system` — Individual system middleware within a module pipeline.
  */
@@ -784,7 +712,7 @@ declare enum PipelineCategory {
 /**
  * Options for identifying and categorizing performance metrics on pipelines.
  */
-type PipelineMetricOptions = {
+type PipelineOptions = {
   /** Display name for the pipeline in performance metrics. */pipelineName: string; /** Category assigned to pipeline-level metric entries. */
   pipelineCategory: PipelineCategoryName; /** Category assigned to per-middleware metric entries within this pipeline. */
   middlewareCategory: PipelineCategoryName;
@@ -801,12 +729,12 @@ interface IPipelineFactory {
    * @param options - Optional performance metric options (name, category) for the pipeline.
    * @returns A new pipeline instance ready for middleware registration.
    */
-  createPipeline<TContext extends IPipelineContext>(options?: PipelineMetricOptions): IPipeline<TContext>;
+  createPipeline<TContext extends IPipelineContext>(options?: PipelineOptions): IPipeline<TContext>;
 }
 //#endregion
 //#region src/systems/system-type.d.ts
 /**
- * The four phases of entity system execution in each frame.
+ * The five phases of entity system execution in each frame.
  * Each phase serves a specific purpose in the entity lifecycle and can be extended by custom system types.
  * The runtime handles each phase in order, allowing systems to perform stage-specific operations.
  */
@@ -816,69 +744,51 @@ declare enum SystemType {
    * Runs once when the entity is first created or initialized.
    */
   initialize = 0,
+  /**
+   * Config application and config-dependent resource reconciliation.
+   * Runs on entity creation and on updates that carry a config payload.
+   */
+  config = 1,
   /**
    * Main logic and state updates for the entity.
    * Runs on every update to change entity behavior and properties.
    */
-  update = 1,
+  update = 2,
   /**
    * Output and visualization operations.
    * Runs after updates to render or display the entity state.
    */
-  render = 2,
+  render = 3,
   /**
    * Synchronization and persistence.
    * Runs last to synchronize state with external systems or storage.
    */
-  sync = 3
+  sync = 4
 }
 //#endregion
-//#region src/systems/module/systems-module.d.ts
-/**
- * Collection of pipelines for a specific entity type.
- * Defines the complete system processing flow for one entity category.
- *
- * @template TEntity - The entity type this module processes.
- */
-interface ISystemsModule<TEntity extends IEntity> {
+//#region src/systems/module/systems-module-builder.d.ts
+interface ISystemsModuleBuilderReadonly<TEntity extends IEntity> {
   /**
-   * The pipelines for this entity type.
-   * Each pipeline contains middleware that operates on the entity.
+   * The Module's name.
    */
-  readonly pipelines: ReadonlyMap<SystemType, Immutable<IPipeline<ISystemContext<TEntity>>>>;
+  readonly name: string;
   /**
-   * Optional factory function to initialize new entity instances.
-   * If provided, is called when a new entity of this type is created.
-   * @param model - The initialization model.
-   * @returns The initialized entity.
+   * Read-only map of system pipelines keyed by SystemType.
    */
-  readonly initEntity?: (model: IEntityModel) => TEntity;
+  readonly pipelines: ReadonlyMap<SystemType, IPipeline<ISystemContext<TEntity>>>;
   /**
-   * If true, this entity type creates a new scope boundary when initialized.
-   * A new scope ID is auto-generated. All child entities inherit this scope.
-   * Typically used for root entities like Engine.
+   * Read-only registry mapping middleware names to their originating module names.
    */
-  readonly scopeRoot?: boolean;
+  readonly middlewareRegistry: MiddlewareRegistryReadonly;
   /**
-   * If true, this entity type registers itself as a scoped proxy when initialized.
-   * It joins the inherited scope and becomes resolvable via `context.proxies.get()`
-   * by any entity in the same scope. Throws if no scope exists.
-   * Typically used for scope-wide entities like Scene, Input, AssetsManager.
+   * Whether this entity type is a scope root. When initialized, a new scope is auto-generated and all child entities inherit it.
    */
-  readonly scopedProxy?: boolean;
+  readonly scopeRoot: boolean;
+  /**
+   * Whether this entity type is a scoped proxy. When initialized, the entity registers itself in the inherited scope, making it resolvable via `context.proxies.get()` by any entity in the same scope.
+   */
+  readonly scopedProxy: boolean;
 }
-//#endregion
-//#region src/systems/pipeline/system-middleware.d.ts
-/**
- * A middleware unit that operates within the system pipeline.
- * System middleware receive comprehensive context about the entity being processed
- * and can influence entity state and behavior through various APIs.
- *
- * @template TEntity - The entity type this middleware handles.
- */
-type ISystemMiddleware<TEntity extends IEntity> = IMiddleware<ISystemContext<TEntity>>;
-//#endregion
-//#region src/systems/module/systems-module-builder.d.ts
 /**
  * Builder pattern interface for constructing system modules.
  * Allows incremental registration of systems and modules for an entity type.
@@ -886,28 +796,12 @@ type ISystemMiddleware<TEntity extends IEntity> = IMiddleware<ISystemContext<TEn
  *
  * @template TEntity - The entity type for which systems are being added.
  */
-interface ISystemsModuleBuilder<TEntity extends IEntity> {
-  /**
-   * The Module Builder's name.
-   */
-  readonly name: string;
-  /**
-   * The pipelines being built.
-   * Accessible during and after construction.
-   */
-  readonly pipelines: ReadonlyMap<SystemType, IPipeline<ISystemContext<TEntity>>>;
-  /**
-   * Whether this entity type is a scope root.
-   */
-  readonly scopeRoot: boolean;
-  /**
-   * Whether this entity type is a scoped proxy.
-   */
-  readonly scopedProxy: boolean;
+interface ISystemsModuleBuilder<TEntity extends IEntity> extends ISystemsModuleBuilderReadonly<TEntity> {
+  readonly middlewareRegistry: MiddlewareRegistry;
   /**
    * Registers middleware systems for a specific pipeline stage.
    * The middleware are added to the pipeline in the order provided.
-   * @param type - The pipeline stage (initialize, update, render, sync).
+   * @param type - The pipeline stage (initialize, config, update, render, sync).
    * @param systems - Array of middleware to add.
    * @returns This builder for method chaining.
    */
@@ -936,6 +830,27 @@ interface ISystemsModuleBuilder<TEntity extends IEntity> {
   setScopedProxy(): this;
 }
 //#endregion
+//#region src/systems/module/systems-module.d.ts
+/**
+ * Collection of pipelines for a specific entity type.
+ * Defines the complete system processing flow for one entity category.
+ *
+ * @template TEntity - The entity type this module processes.
+ */
+interface ISystemsModule<TEntity extends IEntity> {
+  /**
+   * The builder instance used to construct this module.
+   */
+  readonly builder: ISystemsModuleBuilderReadonly<TEntity>;
+  /**
+   * Optional factory function to initialize new entity instances.
+   * If provided, is called when a new entity of this type is created.
+   * @param model - The initialization model.
+   * @returns The initialized entity.
+   */
+  readonly initEntity?: (model: IEntityModel) => TEntity;
+}
+//#endregion
 //#region src/systems/module/systems-module-repository.d.ts
 /**
  * Central registry for all systems modules in the ECS.
@@ -980,9 +895,9 @@ interface ISystemsRuntime {
    * Processes a single entity update through its system pipeline.
    * If no update is provided, may dequeue one from an internal queue.
    * @param update - Optional specific update to process. If omitted, dequeues the next update.
-   * @returns Array of pipeline results containing execution metrics and data.
+   * @returns Pipeline results containing execution data and metrics.
    */
-  runTick(update?: IEntityUpdate): PerformanceTimeEntry[] | void;
+  runTick(update?: IEntityUpdate): PipelineRuntime | Promise<PipelineRuntime> | void;
 }
 //#endregion
 //#region src/systems/runtime/systems-runtime-context.d.ts
@@ -998,6 +913,10 @@ interface ISystemsRuntimeContext<TEntity extends IEntity> extends IPipelineConte
    * Indicates if the system pipeline should perform initialization for the current entity.
    */
   readonly shouldInitialize?: boolean;
+  /**
+   * Indicates if the config system phase should run for the current entity.
+   */
+  readonly shouldConfigure?: boolean;
   /**
    * The systems module for the current entity type.
    */
@@ -1061,5 +980,5 @@ interface ISystemsFactory {
   createSystemsModuleBuilder<TEntity extends IEntity>(name: string): ISystemsModuleBuilder<TEntity>;
 }
 //#endregion
-export { IMiddleware as A, TickSnapshot as B, IPipelineRunner as C, IParentMiddleware as D, IParentContext as E, PerformanceTimeEntry as F, dispatchSequential as G, ILoggerOptions as H, PerformanceTimerUid as I, MiddlewareMetricsSummary as L, PipelineRuntime as M, IPerformanceTimer as N, IPipeline as O, PerformanceMetricOptions as P, RenderSnapshot as R, ISystemContextEvents as S, INestedMiddleware as T, LogLevel as U, ILogger as V, IJsonSerializer as W, ISystemContext as _, ISystemsRuntime as a, ISystemContextRepository as b, ISystemMiddleware as c, IPipelineFactory as d, PipelineCategory as f, IMutableSystemContext as g, IContextFactory as h, ISystemsRuntimeContext as i, IPipelineContext as j, IMiddlewareRunner as k, ISystemsModule as l, PipelineMetricOptions as m, IRuntimeFactory as n, ISystemsModuleRepository as o, PipelineCategoryName as p, ISystemsRuntimeMiddleware as r, ISystemsModuleBuilder as s, ISystemsFactory as t, SystemType as u, ISystemContextSnapshot as v, INestedContext as w, ISystemContextProxies as x, ISystemContextScheduler as y, TickMetricEntry as z };
-//# sourceMappingURL=index-BVkmidEx.d.cts.map
+export { ISystemContextRepository as A, SystemModuleName as B, TickSnapshot as C, ISystemContextSnapshot as D, ISystemContext as E, SystemContextControlState as F, LogLevel as G, ISystemContextConfigReadonly as H, ISystemMiddleware as I, MiddlewareRegistry as L, ISystemContextEvents as M, ISystemContextControl as N, IJsonSerializer as O, ISystemContextControlState as P, MiddlewareRegistryReadonly as R, TickMetricEntry as S, IMutableSystemContext as T, ILogger as U, ISystemContextConfig as V, ILoggerOptions as W, PerformanceMetricOptions as _, ISystemsRuntime as a, MiddlewareMetricsSummary as b, ISystemsModuleBuilder as c, IPipelineFactory as d, PipelineCategory as f, IPerformanceTimer as g, IContextFactory as h, ISystemsRuntimeContext as i, ISystemContextProxies as j, ISystemContextScheduler as k, ISystemsModuleBuilderReadonly as l, PipelineOptions as m, IRuntimeFactory as n, ISystemsModuleRepository as o, PipelineCategoryName as p, ISystemsRuntimeMiddleware as r, ISystemsModule as s, ISystemsFactory as t, SystemType as u, PerformanceTimeEntry as v, dispatchSequential as w, RenderSnapshot as x, PerformanceTimerUid as y, SystemMiddlewareName as z };
+//# sourceMappingURL=index-D3rS2RFG.d.mts.map