@awesome-ecs/abstract 0.33.0 → 0.34.0

package/dist/{index-HeCQLTSE.d.cts → index-DMZSrHoB.d.cts}

@@ -1,4 +1,4 @@
-import { r as Immutable } from "./types-COxeVghs.cjs";
+import { r as Immutable } from "./types-BaCGIrym.cjs";
 
 //#region src/components/config.d.ts
 /**
@@ -120,6 +120,117 @@ interface IComponentWithConfig<TConfig extends ConfigRecord> extends IComponent
   readonly config: TConfig;
 }
 //#endregion
+//#region src/components/identity-component.d.ts
+/**
+ * The `BasicComponentType` enum defines the types of basic components available.
+ */
+declare enum BasicComponentType {
+  identity = "identity"
+}
+/**
+ * The mandatory metadata component for every entity.
+ * Contains core information that defines what an entity is and when it was last updated.
+ * This component is immutable after creation and uniquely identifies each entity.
+ *
+ * @template TModel - The entity model type containing initialization data.
+ */
+interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
+  /**
+   * The entity type classification.
+   * Categorizes entities into logical types, allowing systems to selectively operate on specific entity categories.
+   */
+  readonly entityType: EntityTypeUid;
+  /**
+   * The initialization model for this entity.
+   * Provides the minimal data structure used when the entity was first created.
+   * Serves as a reference point for the entity's initial configuration.
+   *
+   * @type {Immutable<TModel>}
+   */
+  readonly model: Immutable<TModel>;
+  /**
+   * The proxy for this entity, derived from `entityType` and `model.uid`.
+   */
+  readonly proxy: IEntityProxy;
+  /**
+   * The timestamp of the entity's last system update.
+   * Useful for calculating elapsed time (delta time) between consecutive updates.
+   * Helps systems make time-aware decisions.
+   *
+   * @type {Date | undefined}
+   */
+  readonly lastUpdated?: Date;
+}
+//#endregion
+//#region src/entities/entity.d.ts
+/**
+ * Represents the unique identifier for an entity type.
+ * Can be either a string or a number.
+ */
+type EntityTypeUid = string | number;
+/**
+ * Represents the unique identifier for an entity.
+ * Can be either a string or a number.
+ */
+type EntityUid = string | number;
+/**
+ * Represents the core identification and initialization data for an entity.
+ * @template TProxyTypes - A readonly array of entity type IDs that must be provided as proxies when creating an entity.
+ *                         Use `[]` for concrete models without creation-time proxies.
+ *                         Omit the generic only for broad infrastructure APIs that accept any model.
+ */
+type IEntityModel<TProxyTypes extends readonly EntityTypeUid[] | void = void> = {
+  /**
+   * The unique identifier for this entity instance.
+   */
+  readonly uid: EntityUid;
+  /**
+   * The scope this entity belongs to.
+   * Automatically set by the framework — scopeRoot entities generate a UUID,
+   * child entities inherit from their parent via addEntity().
+   */
+  readonly scopeId?: string;
+} & ([TProxyTypes] extends [void] ? {
+  readonly proxies?: Readonly<Record<EntityTypeUid, IEntityProxy>>;
+} : TProxyTypes extends readonly [] ? {
+  readonly proxies?: Readonly<Record<EntityTypeUid, never>>;
+} : TProxyTypes extends readonly EntityTypeUid[] ? {
+  readonly proxies: RequiredProxies<TProxyTypes>;
+} : never);
+declare const EntityModelType: unique symbol;
+interface IEntityModelRef<TModel extends IEntityModel> {
+  readonly [EntityModelType]?: TModel;
+}
+/**
+ * Extract the model type carried by an entity's identity component.
+ */
+type ModelOf<TEntity> = TEntity extends IEntityModelRef<infer TModel> ? TModel : IEntityModel;
+/**
+ * Base entity contract.
+ *
+ * Concrete entity types extend this interface and declare their own component and proxy
+ * members directly, for example `readonly terrain: TerrainComponent` or
+ * `readonly gridProxy: EntityProxy<GridEntity>`.
+ */
+interface IEntity {
+  /**
+   * The identity component containing core entity metadata and initialization information.
+   * Every entity has exactly one identity component that persists for the entity's lifetime.
+   */
+  readonly identity: Readonly<IdentityComponent<ModelOf<this>>>;
+}
+/**
+ * Entity contract carrying the concrete model type for `ModelOf<TEntity>` inference.
+ */
+interface IEntityWith<TModel extends IEntityModel> extends IEntity, IEntityModelRef<TModel> {}
+/**
+ * Runtime entity spec consumed by dispatchers.
+ */
+type IEntitySpec<TEntity extends IEntity> = {
+  readonly type: EntityTypeUid;
+  readonly init: (model: ModelOf<TEntity>) => TEntity;
+};
+//#endregion
 //#region src/entities/entity-proxies.d.ts
 /**
  * Represents a reference (pointer) to another entity.
@@ -139,11 +250,13 @@ interface IEntityProxy {
 }
 /**
  * A typed variant of `IEntityProxy` that carries compile-time type information.
- * This allows IDEs to provide better type inference and type-checking when working with entity relationships.
+ * This allows IDEs to infer the entity type when resolving a proxy through a repository.
  *
  * @template TEntity - The specific entity type that this proxy references.
  */
 interface EntityProxy<TEntity extends IEntity> extends IEntityProxy {}
+type EntityProxyLookup<TEntity extends IEntity = IEntity> = EntityTypeUid | EntityProxy<TEntity>;
+type EntityProxyManyLookup<TEntity extends IEntity = IEntity> = EntityProxyLookup<TEntity>;
 /**
  * A helper type to create a typed entity proxy.
  */
@@ -152,9 +265,9 @@ type TypedEntityProxy<T extends EntityTypeUid> = {
   entityUid: EntityUid;
 };
 /**
- * A mapped type that transforms an array of EntityType into an array of TypedEntityProxy.
+ * A model-level record of required entity proxies, keyed by entity type.
  */
-type RequiredProxies<TProxyTypes extends readonly EntityTypeUid[]> = [...{ [I in keyof TProxyTypes]: TypedEntityProxy<TProxyTypes[I]> }, ...IEntityProxy[]];
+type RequiredProxies<TProxyTypes extends readonly EntityTypeUid[]> = { readonly [TType in TProxyTypes[number]]: TypedEntityProxy<TType> };
 /**
  * Extracts the union of EntityTypeUid values declared as required proxies on an entity model.
  * Resolves to `never` if the model declares no required proxies, which makes proxy lookups
@@ -162,7 +275,7 @@ type RequiredProxies<TProxyTypes extends readonly EntityTypeUid[]> = [...{ [I in
  *
  * @template TModel - The entity model to inspect.
  */
-type ProxyTypesOf<TModel> = TModel extends IEntityModel<infer P> ? P[number] : never;
+type ProxyTypesOf<TModel> = TModel extends IEntityModel<infer P> ? P extends readonly EntityTypeUid[] ? P[number] : never : never;
 /**
  * Central registry for managing entity-to-entity relationships through proxies.
  * Maintains bidirectional proxy links, ensuring consistency across all entity references.
@@ -204,20 +317,20 @@ interface IEntityProxyRepository {
    * @param targetType - The entity type of the target proxy to retrieve.
    * @returns The entity proxy, or null if not found.
    */
-  get(source: IEntityProxy, targetType: EntityTypeUid): IEntityProxy | null;
+  getProxy<TEntity extends IEntity = IEntity>(source: IEntityProxy, targetType: EntityTypeUid): EntityProxy<TEntity> | null;
   /**
    * Retrieves all proxies of a specific type for a source entity.
    * @param source - The proxy of the source entity.
    * @param targetType - The entity type of the target proxies to retrieve.
    * @returns A readonly array of entity proxies.
    */
-  getMany(source: IEntityProxy, targetType: EntityTypeUid): Readonly<IEntityProxy[]>;
+  getProxies<TEntity extends IEntity = IEntity>(source: IEntityProxy, targetType: EntityTypeUid): Readonly<EntityProxy<TEntity>[]>;
   /**
    * Retrieves all proxies for a source entity.
    * @param source - The proxy of the source entity.
    * @returns A readonly map of entity type UIDs to an array of their proxies.
    */
-  getAll(source: IEntityProxy): ReadonlyMap<EntityTypeUid, Readonly<IEntityProxy[]>>;
+  getAllProxies(source: IEntityProxy): ReadonlyMap<EntityTypeUid, Readonly<IEntityProxy[]>>;
   /**
    * Registers an entity as a scoped proxy, making it resolvable by any entity in the same scope.
    * Only entity types marked as scopeRoot or scopedProxy should be registered.
@@ -231,7 +344,7 @@ interface IEntityProxyRepository {
    * @param entityType - The entity type to resolve.
    * @returns The scoped proxy, or null if none exists.
    */
-  getScopedProxy(scopeId: string, entityType: EntityTypeUid): IEntityProxy | null;
+  getScopedProxy<TEntity extends IEntity = IEntity>(scopeId: string, entityType: EntityTypeUid): EntityProxy<TEntity> | null;
   /**
    * Removes an entity from the scoped proxy index.
    * Called during entity cleanup to unregister from scope resolution.
@@ -241,100 +354,20 @@ interface IEntityProxyRepository {
   removeScopedProxy(entity: IEntityProxy, scopeId: string): void;
 }
 //#endregion
-//#region src/entities/entity.d.ts
-/**
- * Represents the unique identifier for an entity type.
- * Can be either a string or a number.
- */
-type EntityTypeUid = string | number;
-/**
- * Represents the unique identifier for an entity.
- * Can be either a string or a number.
- */
-type EntityUid = string | number;
-/**
- * Represents the core identification and initialization data for an entity.
- * @template TProxyTypes - A readonly array of entity type IDs that must be provided as proxies when creating an entity.
- *                         When non-empty, the `proxies` property is required on the model.
- */
-type IEntityModel<TProxyTypes extends readonly EntityTypeUid[] = readonly []> = {
-  /**
-   * The unique identifier for this entity instance.
-   */
-  readonly uid: EntityUid;
-  /**
-   * The scope this entity belongs to.
-   * Automatically set by the framework — scopeRoot entities generate a UUID,
-   * child entities inherit from their parent via addEntity().
-   */
-  readonly scopeId?: string;
-} & (TProxyTypes extends readonly [] ? {
-  readonly proxies?: RequiredProxies<TProxyTypes>;
-} : {
-  readonly proxies: RequiredProxies<TProxyTypes>;
-});
-/**
- * The core entity interface representing a composition of components and relationships.
- * Entities are immutable containers that store data (components) and maintain relationships (proxies) to other entities.
- * State modifications occur exclusively through system operations, maintaining data integrity and enabling safe concurrent access.
- *
- * Implementations should provide strongly-typed accessors for components and proxies specific to their entity type,
- * enhancing IDE support and type safety without adding behavior beyond data access.
- */
-interface IEntity {
-  /**
-   * The set of components attached to this entity.
-   * Components are the primary data storage mechanism, mapped by their unique type identifiers.
-   */
-  readonly components: ReadonlyMap<ComponentTypeUid, IComponent>;
-  /**
-   * The identity component containing core entity metadata and initialization information.
-   * Every entity has exactly one identity component that persists for the entity's lifetime.
-   */
-  readonly identity: Readonly<IdentityComponent<IEntityModel>>;
-  /**
-   * A reference to this entity's own proxy.
-   */
-  readonly myProxy: Readonly<EntityProxy<this>>;
-}
-//#endregion
-//#region src/components/identity-component.d.ts
-/**
- * The `BasicComponentType` enum defines the types of basic components available.
- */
-declare enum BasicComponentType {
-  identity = "identity"
-}
+//#region src/components/component-repository.d.ts
 /**
- * The mandatory metadata component for every entity.
- * Contains core information that defines what an entity is and when it was last updated.
- * This component is immutable after creation and uniquely identifies each entity.
+ * The runtime source of truth for component instances, keyed by entity proxy.
  *
- * @template TModel - The entity model type containing initialization data.
+ * Generic `get<TComponent>` lets callsites narrow on demand without any global
+ * `ComponentTypeMap` augmentation. Most reads go through typed component fields on
+ * `context.entity`; direct `repository.get` is the escape hatch.
  */
-interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
-  /**
-   * The entity type classification.
-   * Categorizes entities into logical types, allowing systems to selectively operate on specific entity categories.
-   */
-  readonly entityType: EntityTypeUid;
-  /**
-   * The initialization model for this entity.
-   * Provides the minimal data structure used when the entity was first created.
-   * Serves as a reference point for the entity's initial configuration.
-   *
-   * @type {Immutable<TModel>}
-   */
-  readonly model: Immutable<TModel>;
-  /**
-   * The timestamp of the entity's last system update.
-   * Useful for calculating elapsed time (delta time) between consecutive updates.
-   * Helps systems make time-aware decisions.
-   *
-   * @type {Date | undefined}
-   */
-  readonly lastUpdated?: Date;
+interface IComponentRepository {
+  setMany(key: IEntityProxy, components: readonly IComponent[]): void;
+  get<TComponent extends IComponent = IComponent>(key: IEntityProxy, type: ComponentTypeUid): TComponent | undefined;
+  getAll(key: IEntityProxy): readonly IComponent[];
+  removeAll(key: IEntityProxy): void;
 }
 //#endregion
-export { ConfigOption as _, IEntity as a, IEntityProxy as c, RequiredProxies as d, TypedEntityProxy as f, ConfigCustomControlOptions as g, IComponentWithConfig as h, EntityUid as i, IEntityProxyRepository as l, IComponent as m, IdentityComponent as n, IEntityModel as o, ComponentTypeUid as p, EntityTypeUid as r, EntityProxy as s, BasicComponentType as t, ProxyTypesOf as u, ConfigRecord as v };
-//# sourceMappingURL=index-HeCQLTSE.d.cts.map
+export { ConfigCustomControlOptions as C, IComponentWithConfig as S, ConfigRecord as T, ModelOf as _, IEntityProxy as a, ComponentTypeUid as b, RequiredProxies as c, EntityUid as d, IEntity as f, IEntityWith as g, IEntitySpec as h, EntityProxyManyLookup as i, TypedEntityProxy as l, IEntityModelRef as m, EntityProxy as n, IEntityProxyRepository as o, IEntityModel as p, EntityProxyLookup as r, ProxyTypesOf as s, IComponentRepository as t, EntityTypeUid as u, BasicComponentType as v, ConfigOption as w, IComponent as x, IdentityComponent as y };
+//# sourceMappingURL=index-DMZSrHoB.d.cts.map

package/dist/{index-Tznk33g6.d.mts → index-Dbwzlrgp.d.mts}

@@ -1,4 +1,4 @@
-import { r as Immutable } from "./types-UnqKSA14.mjs";
+import { r as Immutable } from "./types-BaCGIrym.mjs";
 
 //#region src/components/config.d.ts
 /**
@@ -120,6 +120,117 @@ interface IComponentWithConfig<TConfig extends ConfigRecord> extends IComponent
   readonly config: TConfig;
 }
 //#endregion
+//#region src/components/identity-component.d.ts
+/**
+ * The `BasicComponentType` enum defines the types of basic components available.
+ */
+declare enum BasicComponentType {
+  identity = "identity"
+}
+/**
+ * The mandatory metadata component for every entity.
+ * Contains core information that defines what an entity is and when it was last updated.
+ * This component is immutable after creation and uniquely identifies each entity.
+ *
+ * @template TModel - The entity model type containing initialization data.
+ */
+interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
+  /**
+   * The entity type classification.
+   * Categorizes entities into logical types, allowing systems to selectively operate on specific entity categories.
+   */
+  readonly entityType: EntityTypeUid;
+  /**
+   * The initialization model for this entity.
+   * Provides the minimal data structure used when the entity was first created.
+   * Serves as a reference point for the entity's initial configuration.
+   *
+   * @type {Immutable<TModel>}
+   */
+  readonly model: Immutable<TModel>;
+  /**
+   * The proxy for this entity, derived from `entityType` and `model.uid`.
+   */
+  readonly proxy: IEntityProxy;
+  /**
+   * The timestamp of the entity's last system update.
+   * Useful for calculating elapsed time (delta time) between consecutive updates.
+   * Helps systems make time-aware decisions.
+   *
+   * @type {Date | undefined}
+   */
+  readonly lastUpdated?: Date;
+}
+//#endregion
+//#region src/entities/entity.d.ts
+/**
+ * Represents the unique identifier for an entity type.
+ * Can be either a string or a number.
+ */
+type EntityTypeUid = string | number;
+/**
+ * Represents the unique identifier for an entity.
+ * Can be either a string or a number.
+ */
+type EntityUid = string | number;
+/**
+ * Represents the core identification and initialization data for an entity.
+ * @template TProxyTypes - A readonly array of entity type IDs that must be provided as proxies when creating an entity.
+ *                         Use `[]` for concrete models without creation-time proxies.
+ *                         Omit the generic only for broad infrastructure APIs that accept any model.
+ */
+type IEntityModel<TProxyTypes extends readonly EntityTypeUid[] | void = void> = {
+  /**
+   * The unique identifier for this entity instance.
+   */
+  readonly uid: EntityUid;
+  /**
+   * The scope this entity belongs to.
+   * Automatically set by the framework — scopeRoot entities generate a UUID,
+   * child entities inherit from their parent via addEntity().
+   */
+  readonly scopeId?: string;
+} & ([TProxyTypes] extends [void] ? {
+  readonly proxies?: Readonly<Record<EntityTypeUid, IEntityProxy>>;
+} : TProxyTypes extends readonly [] ? {
+  readonly proxies?: Readonly<Record<EntityTypeUid, never>>;
+} : TProxyTypes extends readonly EntityTypeUid[] ? {
+  readonly proxies: RequiredProxies<TProxyTypes>;
+} : never);
+declare const EntityModelType: unique symbol;
+interface IEntityModelRef<TModel extends IEntityModel> {
+  readonly [EntityModelType]?: TModel;
+}
+/**
+ * Extract the model type carried by an entity's identity component.
+ */
+type ModelOf<TEntity> = TEntity extends IEntityModelRef<infer TModel> ? TModel : IEntityModel;
+/**
+ * Base entity contract.
+ *
+ * Concrete entity types extend this interface and declare their own component and proxy
+ * members directly, for example `readonly terrain: TerrainComponent` or
+ * `readonly gridProxy: EntityProxy<GridEntity>`.
+ */
+interface IEntity {
+  /**
+   * The identity component containing core entity metadata and initialization information.
+   * Every entity has exactly one identity component that persists for the entity's lifetime.
+   */
+  readonly identity: Readonly<IdentityComponent<ModelOf<this>>>;
+}
+/**
+ * Entity contract carrying the concrete model type for `ModelOf<TEntity>` inference.
+ */
+interface IEntityWith<TModel extends IEntityModel> extends IEntity, IEntityModelRef<TModel> {}
+/**
+ * Runtime entity spec consumed by dispatchers.
+ */
+type IEntitySpec<TEntity extends IEntity> = {
+  readonly type: EntityTypeUid;
+  readonly init: (model: ModelOf<TEntity>) => TEntity;
+};
+//#endregion
 //#region src/entities/entity-proxies.d.ts
 /**
  * Represents a reference (pointer) to another entity.
@@ -139,11 +250,13 @@ interface IEntityProxy {
 }
 /**
  * A typed variant of `IEntityProxy` that carries compile-time type information.
- * This allows IDEs to provide better type inference and type-checking when working with entity relationships.
+ * This allows IDEs to infer the entity type when resolving a proxy through a repository.
  *
  * @template TEntity - The specific entity type that this proxy references.
  */
 interface EntityProxy<TEntity extends IEntity> extends IEntityProxy {}
+type EntityProxyLookup<TEntity extends IEntity = IEntity> = EntityTypeUid | EntityProxy<TEntity>;
+type EntityProxyManyLookup<TEntity extends IEntity = IEntity> = EntityProxyLookup<TEntity>;
 /**
  * A helper type to create a typed entity proxy.
  */
@@ -152,9 +265,9 @@ type TypedEntityProxy<T extends EntityTypeUid> = {
   entityUid: EntityUid;
 };
 /**
- * A mapped type that transforms an array of EntityType into an array of TypedEntityProxy.
+ * A model-level record of required entity proxies, keyed by entity type.
  */
-type RequiredProxies<TProxyTypes extends readonly EntityTypeUid[]> = [...{ [I in keyof TProxyTypes]: TypedEntityProxy<TProxyTypes[I]> }, ...IEntityProxy[]];
+type RequiredProxies<TProxyTypes extends readonly EntityTypeUid[]> = { readonly [TType in TProxyTypes[number]]: TypedEntityProxy<TType> };
 /**
  * Extracts the union of EntityTypeUid values declared as required proxies on an entity model.
  * Resolves to `never` if the model declares no required proxies, which makes proxy lookups
@@ -162,7 +275,7 @@ type RequiredProxies<TProxyTypes extends readonly EntityTypeUid[]> = [...{ [I in
  *
  * @template TModel - The entity model to inspect.
  */
-type ProxyTypesOf<TModel> = TModel extends IEntityModel<infer P> ? P[number] : never;
+type ProxyTypesOf<TModel> = TModel extends IEntityModel<infer P> ? P extends readonly EntityTypeUid[] ? P[number] : never : never;
 /**
  * Central registry for managing entity-to-entity relationships through proxies.
  * Maintains bidirectional proxy links, ensuring consistency across all entity references.
@@ -204,20 +317,20 @@ interface IEntityProxyRepository {
    * @param targetType - The entity type of the target proxy to retrieve.
    * @returns The entity proxy, or null if not found.
    */
-  get(source: IEntityProxy, targetType: EntityTypeUid): IEntityProxy | null;
+  getProxy<TEntity extends IEntity = IEntity>(source: IEntityProxy, targetType: EntityTypeUid): EntityProxy<TEntity> | null;
   /**
    * Retrieves all proxies of a specific type for a source entity.
    * @param source - The proxy of the source entity.
    * @param targetType - The entity type of the target proxies to retrieve.
    * @returns A readonly array of entity proxies.
    */
-  getMany(source: IEntityProxy, targetType: EntityTypeUid): Readonly<IEntityProxy[]>;
+  getProxies<TEntity extends IEntity = IEntity>(source: IEntityProxy, targetType: EntityTypeUid): Readonly<EntityProxy<TEntity>[]>;
   /**
    * Retrieves all proxies for a source entity.
    * @param source - The proxy of the source entity.
    * @returns A readonly map of entity type UIDs to an array of their proxies.
    */
-  getAll(source: IEntityProxy): ReadonlyMap<EntityTypeUid, Readonly<IEntityProxy[]>>;
+  getAllProxies(source: IEntityProxy): ReadonlyMap<EntityTypeUid, Readonly<IEntityProxy[]>>;
   /**
    * Registers an entity as a scoped proxy, making it resolvable by any entity in the same scope.
    * Only entity types marked as scopeRoot or scopedProxy should be registered.
@@ -231,7 +344,7 @@ interface IEntityProxyRepository {
    * @param entityType - The entity type to resolve.
    * @returns The scoped proxy, or null if none exists.
    */
-  getScopedProxy(scopeId: string, entityType: EntityTypeUid): IEntityProxy | null;
+  getScopedProxy<TEntity extends IEntity = IEntity>(scopeId: string, entityType: EntityTypeUid): EntityProxy<TEntity> | null;
   /**
    * Removes an entity from the scoped proxy index.
    * Called during entity cleanup to unregister from scope resolution.
@@ -241,100 +354,20 @@ interface IEntityProxyRepository {
   removeScopedProxy(entity: IEntityProxy, scopeId: string): void;
 }
 //#endregion
-//#region src/entities/entity.d.ts
-/**
- * Represents the unique identifier for an entity type.
- * Can be either a string or a number.
- */
-type EntityTypeUid = string | number;
-/**
- * Represents the unique identifier for an entity.
- * Can be either a string or a number.
- */
-type EntityUid = string | number;
-/**
- * Represents the core identification and initialization data for an entity.
- * @template TProxyTypes - A readonly array of entity type IDs that must be provided as proxies when creating an entity.
- *                         When non-empty, the `proxies` property is required on the model.
- */
-type IEntityModel<TProxyTypes extends readonly EntityTypeUid[] = readonly []> = {
-  /**
-   * The unique identifier for this entity instance.
-   */
-  readonly uid: EntityUid;
-  /**
-   * The scope this entity belongs to.
-   * Automatically set by the framework — scopeRoot entities generate a UUID,
-   * child entities inherit from their parent via addEntity().
-   */
-  readonly scopeId?: string;
-} & (TProxyTypes extends readonly [] ? {
-  readonly proxies?: RequiredProxies<TProxyTypes>;
-} : {
-  readonly proxies: RequiredProxies<TProxyTypes>;
-});
-/**
- * The core entity interface representing a composition of components and relationships.
- * Entities are immutable containers that store data (components) and maintain relationships (proxies) to other entities.
- * State modifications occur exclusively through system operations, maintaining data integrity and enabling safe concurrent access.
- *
- * Implementations should provide strongly-typed accessors for components and proxies specific to their entity type,
- * enhancing IDE support and type safety without adding behavior beyond data access.
- */
-interface IEntity {
-  /**
-   * The set of components attached to this entity.
-   * Components are the primary data storage mechanism, mapped by their unique type identifiers.
-   */
-  readonly components: ReadonlyMap<ComponentTypeUid, IComponent>;
-  /**
-   * The identity component containing core entity metadata and initialization information.
-   * Every entity has exactly one identity component that persists for the entity's lifetime.
-   */
-  readonly identity: Readonly<IdentityComponent<IEntityModel>>;
-  /**
-   * A reference to this entity's own proxy.
-   */
-  readonly myProxy: Readonly<EntityProxy<this>>;
-}
-//#endregion
-//#region src/components/identity-component.d.ts
-/**
- * The `BasicComponentType` enum defines the types of basic components available.
- */
-declare enum BasicComponentType {
-  identity = "identity"
-}
+//#region src/components/component-repository.d.ts
 /**
- * The mandatory metadata component for every entity.
- * Contains core information that defines what an entity is and when it was last updated.
- * This component is immutable after creation and uniquely identifies each entity.
+ * The runtime source of truth for component instances, keyed by entity proxy.
  *
- * @template TModel - The entity model type containing initialization data.
+ * Generic `get<TComponent>` lets callsites narrow on demand without any global
+ * `ComponentTypeMap` augmentation. Most reads go through typed component fields on
+ * `context.entity`; direct `repository.get` is the escape hatch.
  */
-interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
-  /**
-   * The entity type classification.
-   * Categorizes entities into logical types, allowing systems to selectively operate on specific entity categories.
-   */
-  readonly entityType: EntityTypeUid;
-  /**
-   * The initialization model for this entity.
-   * Provides the minimal data structure used when the entity was first created.
-   * Serves as a reference point for the entity's initial configuration.
-   *
-   * @type {Immutable<TModel>}
-   */
-  readonly model: Immutable<TModel>;
-  /**
-   * The timestamp of the entity's last system update.
-   * Useful for calculating elapsed time (delta time) between consecutive updates.
-   * Helps systems make time-aware decisions.
-   *
-   * @type {Date | undefined}
-   */
-  readonly lastUpdated?: Date;
+interface IComponentRepository {
+  setMany(key: IEntityProxy, components: readonly IComponent[]): void;
+  get<TComponent extends IComponent = IComponent>(key: IEntityProxy, type: ComponentTypeUid): TComponent | undefined;
+  getAll(key: IEntityProxy): readonly IComponent[];
+  removeAll(key: IEntityProxy): void;
 }
 //#endregion
-export { ConfigOption as _, IEntity as a, IEntityProxy as c, RequiredProxies as d, TypedEntityProxy as f, ConfigCustomControlOptions as g, IComponentWithConfig as h, EntityUid as i, IEntityProxyRepository as l, IComponent as m, IdentityComponent as n, IEntityModel as o, ComponentTypeUid as p, EntityTypeUid as r, EntityProxy as s, BasicComponentType as t, ProxyTypesOf as u, ConfigRecord as v };
-//# sourceMappingURL=index-Tznk33g6.d.mts.map
+export { ConfigCustomControlOptions as C, IComponentWithConfig as S, ConfigRecord as T, ModelOf as _, IEntityProxy as a, ComponentTypeUid as b, RequiredProxies as c, EntityUid as d, IEntity as f, IEntityWith as g, IEntitySpec as h, EntityProxyManyLookup as i, TypedEntityProxy as l, IEntityModelRef as m, EntityProxy as n, IEntityProxyRepository as o, IEntityModel as p, EntityProxyLookup as r, ProxyTypesOf as s, IComponentRepository as t, EntityTypeUid as u, BasicComponentType as v, ConfigOption as w, IComponent as x, IdentityComponent as y };
+//# sourceMappingURL=index-Dbwzlrgp.d.mts.map

package/dist/{index-Bl7Cf9gi.d.cts → index-aVjnG975.d.cts}

@@ -1,4 +1,4 @@
-import { r as Immutable } from "./types-COxeVghs.cjs";
+import { r as Immutable } from "./types-BaCGIrym.cjs";
 
 //#region src/pipelines/pipeline-context.d.ts
 /**
@@ -215,4 +215,4 @@ interface IPipelineRunner<TContext extends IPipelineContext> {
 }
 //#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, PipelineDispatch as u };
-//# sourceMappingURL=index-Bl7Cf9gi.d.cts.map
+//# sourceMappingURL=index-aVjnG975.d.cts.map

package/dist/pipelines/index.d.cts

@@ -1,2 +1,2 @@
-import { a as IParentMiddleware, c as IMiddleware, i as IParentContext, l as IPipelineContext, n as INestedContext, o as IPipeline, r as INestedMiddleware, s as IMiddlewareRunner, t as IPipelineRunner, u as PipelineDispatch } from "../index-Bl7Cf9gi.cjs";
+import { a as IParentMiddleware, c as IMiddleware, i as IParentContext, l as IPipelineContext, n as INestedContext, o as IPipeline, r as INestedMiddleware, s as IMiddlewareRunner, t as IPipelineRunner, u as PipelineDispatch } from "../index-aVjnG975.cjs";
 export { IMiddleware, IMiddlewareRunner, INestedContext, INestedMiddleware, IParentContext, IParentMiddleware, IPipeline, IPipelineContext, IPipelineRunner, PipelineDispatch };

package/dist/pipelines/index.d.mts

@@ -1,2 +1,2 @@
-import { a as IParentMiddleware, c as IMiddleware, i as IParentContext, l as IPipelineContext, n as INestedContext, o as IPipeline, r as INestedMiddleware, s as IMiddlewareRunner, t as IPipelineRunner, u as PipelineDispatch } from "../index-DXbpfhHa.mjs";
+import { a as IParentMiddleware, c as IMiddleware, i as IParentContext, l as IPipelineContext, n as INestedContext, o as IPipeline, r as INestedMiddleware, s as IMiddlewareRunner, t as IPipelineRunner, u as PipelineDispatch } from "../index-B3DqdxE6.mjs";
 export { IMiddleware, IMiddlewareRunner, INestedContext, INestedMiddleware, IParentContext, IParentMiddleware, IPipeline, IPipelineContext, IPipelineRunner, PipelineDispatch };

package/dist/systems/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/systems/pipeline/system-context-control.ts","../../src/systems/system-type.ts"],"sourcesContent":["import type {\n  EntityEventSubscriptionOptions,\n  EntityEventUid\n} from '../../entities/entity-events';\nimport type { SystemModuleName } from './system-middleware';\n\nexport interface SystemContextControlTarget {\n  readonly name?: string;\n}\n\nexport enum SystemContextControlState {\n  none = 'none',\n  enableCurrentSystem = 'enableCurrentSystem',\n  disableCurrentSystem = 'disableCurrentSystem'\n}\n\n/**\n * Interface for controlling the execution of systems and modules within a system context.\n * This allows middleware to enable or disable specific systems or entire modules for the current entity.\n */\nexport interface ISystemContextControl {\n  /**\n   * Disables the current system for the current entity.\n   */\n  disableCurrentSystem(): void;\n\n  /**\n   * Re-enables the current system for the current entity.\n   */\n  enableCurrentSystem(): void;\n\n  /**\n   * Disables a module for the current entity.\n   */\n  disableModule(name: SystemModuleName): void;\n\n  /**\n   * Re-enables a module for the current entity.\n   */\n  enableModule(name: SystemModuleName): void;\n}\n\n/**\n * Extended system context interface that includes control state for middleware to manage system and module execution.\n * This allows middleware to query and modify the execution state of systems and modules during pipeline processing.\n */\nexport interface ISystemContextControlState extends ISystemContextControl {\n  /**\n   * Current state of system/module execution control, indicating whether the current system or module is enabled or disabled.\n   */\n  readonly state: SystemContextControlState;\n\n  /**\n   * 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.\n   * @param middleware - The middleware to check for disabled state.\n   * @returns True if the specified middleware is currently disabled, false otherwise.\n   */\n  isMiddlewareDisabled(middleware: SystemContextControlTarget): boolean;\n\n  /**\n   * Disables a specific middleware in the context.\n   * @param middleware - The middleware to disable.\n   */\n  disableMiddleware(middleware: SystemContextControlTarget): void;\n\n  /**\n   * Enables a specific middleware in the context.\n   * @param middleware - The middleware to enable.\n   */\n  enableMiddleware(middleware: SystemContextControlTarget): void;\n\n  /**\n   * Registers an event subscription owned by a module. This is runtime-only state:\n   * disabling the module should also detach its event subscriptions.\n   */\n  registerModuleEvent(\n    moduleName: SystemModuleName,\n    eventUid: EntityEventUid,\n    options?: EntityEventSubscriptionOptions\n  ): void;\n\n  /**\n   * Clears all runtime-owned module event subscriptions for the current entity.\n   */\n  clearModuleEvents(): void;\n}\n","/**\n * The five phases of entity system execution in each frame.\n * Each phase serves a specific purpose in the entity lifecycle and can be extended by custom system types.\n * The runtime handles each phase in order, allowing systems to perform stage-specific operations.\n */\nexport enum SystemType {\n  /**\n   * Initial setup and resource allocation for the entity.\n   * Runs once when the entity is first created or initialized.\n   */\n  initialize = 0,\n\n  /**\n   * Config application and config-dependent resource reconciliation.\n   * Runs on entity creation and on updates that carry a config payload.\n   */\n  config = 1,\n\n  /**\n   * Event reactions routed by event uid.\n   * Runs after config and before update for updates carrying events.\n   */\n  event = 2,\n\n  /**\n   * Main logic and state updates for the entity.\n   * Runs on every update to change entity behavior and properties.\n   */\n  update = 3,\n\n  /**\n   * Output and visualization operations.\n   * Runs after updates to render or display the entity state.\n   */\n  render = 4,\n\n  /**\n   * Synchronization and persistence.\n   * Runs last to synchronize state with external systems or storage.\n   */\n  sync = 5\n}\n"],"mappings":";;AAUA,IAAY,4BAAL,yBAAA,2BAAA;CACL,0BAAA,UAAA;CACA,0BAAA,yBAAA;CACA,0BAAA,0BAAA;;AACF,EAAA,CAAA,CAAA;;;;;;;;ACTA,IAAY,aAAL,yBAAA,YAAA;;;;;CAKL,WAAA,WAAA,gBAAA,KAAA;;;;;CAMA,WAAA,WAAA,YAAA,KAAA;;;;;CAMA,WAAA,WAAA,WAAA,KAAA;;;;;CAMA,WAAA,WAAA,YAAA,KAAA;;;;;CAMA,WAAA,WAAA,YAAA,KAAA;;;;;CAMA,WAAA,WAAA,UAAA,KAAA;;AACF,EAAA,CAAA,CAAA"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/systems/pipeline/system-context-control.ts","../../src/systems/system-type.ts"],"sourcesContent":["import type {\r\n  EntityEventSubscriptionOptions,\r\n  EntityEventUid\r\n} from '../../entities/entity-events';\r\nimport type { SystemModuleName } from './system-middleware';\r\n\r\nexport interface SystemContextControlTarget {\r\n  readonly name?: string;\r\n}\r\n\r\nexport enum SystemContextControlState {\r\n  none = 'none',\r\n  enableCurrentSystem = 'enableCurrentSystem',\r\n  disableCurrentSystem = 'disableCurrentSystem'\r\n}\r\n\r\n/**\r\n * Interface for controlling the execution of systems and modules within a system context.\r\n * This allows middleware to enable or disable specific systems or entire modules for the current entity.\r\n */\r\nexport interface ISystemContextControl {\r\n  /**\r\n   * Disables the current system for the current entity.\r\n   */\r\n  disableCurrentSystem(): void;\r\n\r\n  /**\r\n   * Re-enables the current system for the current entity.\r\n   */\r\n  enableCurrentSystem(): void;\r\n\r\n  /**\r\n   * Disables a module for the current entity.\r\n   */\r\n  disableModule(name: SystemModuleName): void;\r\n\r\n  /**\r\n   * Re-enables a module for the current entity.\r\n   */\r\n  enableModule(name: SystemModuleName): void;\r\n}\r\n\r\n/**\r\n * Extended system context interface that includes control state for middleware to manage system and module execution.\r\n * This allows middleware to query and modify the execution state of systems and modules during pipeline processing.\r\n */\r\nexport interface ISystemContextControlState extends ISystemContextControl {\r\n  /**\r\n   * Current state of system/module execution control, indicating whether the current system or module is enabled or disabled.\r\n   */\r\n  readonly state: SystemContextControlState;\r\n\r\n  /**\r\n   * 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.\r\n   * @param middleware - The middleware to check for disabled state.\r\n   * @returns True if the specified middleware is currently disabled, false otherwise.\r\n   */\r\n  isMiddlewareDisabled(middleware: SystemContextControlTarget): boolean;\r\n\r\n  /**\r\n   * Disables a specific middleware in the context.\r\n   * @param middleware - The middleware to disable.\r\n   */\r\n  disableMiddleware(middleware: SystemContextControlTarget): void;\r\n\r\n  /**\r\n   * Enables a specific middleware in the context.\r\n   * @param middleware - The middleware to enable.\r\n   */\r\n  enableMiddleware(middleware: SystemContextControlTarget): void;\r\n\r\n  /**\r\n   * Registers an event subscription owned by a module. This is runtime-only state:\r\n   * disabling the module should also detach its event subscriptions.\r\n   */\r\n  registerModuleEvent(\r\n    moduleName: SystemModuleName,\r\n    eventUid: EntityEventUid,\r\n    options?: EntityEventSubscriptionOptions\r\n  ): void;\r\n\r\n  /**\r\n   * Clears all runtime-owned module event subscriptions for the current entity.\r\n   */\r\n  clearModuleEvents(): void;\r\n}\r\n","/**\n * The five phases of entity system execution in each frame.\n * Each phase serves a specific purpose in the entity lifecycle and can be extended by custom system types.\n * The runtime handles each phase in order, allowing systems to perform stage-specific operations.\n */\nexport enum SystemType {\n  /**\n   * Initial setup and resource allocation for the entity.\n   * Runs once when the entity is first created or initialized.\n   */\n  initialize = 0,\n\n  /**\n   * Config application and config-dependent resource reconciliation.\n   * Runs on entity creation and on updates that carry a config payload.\n   */\n  config = 1,\n\n  /**\n   * Event reactions routed by event uid.\n   * Runs after config and before update for updates carrying events.\n   */\n  event = 2,\n\n  /**\n   * Main logic and state updates for the entity.\n   * Runs on every update to change entity behavior and properties.\n   */\n  update = 3,\n\n  /**\n   * Output and visualization operations.\n   * Runs after updates to render or display the entity state.\n   */\n  render = 4,\n\n  /**\n   * Synchronization and persistence.\n   * Runs last to synchronize state with external systems or storage.\n   */\n  sync = 5\n}\n"],"mappings":";;AAUA,IAAY,4BAAL,yBAAA,2BAAA;CACL,0BAAA,UAAA;CACA,0BAAA,yBAAA;CACA,0BAAA,0BAAA;;AACF,EAAA,CAAA,CAAA;;;;;;;;ACTA,IAAY,aAAL,yBAAA,YAAA;;;;;CAKL,WAAA,WAAA,gBAAA,KAAA;;;;;CAMA,WAAA,WAAA,YAAA,KAAA;;;;;CAMA,WAAA,WAAA,WAAA,KAAA;;;;;CAMA,WAAA,WAAA,YAAA,KAAA;;;;;CAMA,WAAA,WAAA,YAAA,KAAA;;;;;CAMA,WAAA,WAAA,UAAA,KAAA;;AACF,EAAA,CAAA,CAAA"}