@woosh/meep-engine 2.165.6 → 2.165.7

package/src/engine/ecs/EntityManager.d.ts

@@ -42,7 +42,7 @@ export class EntityManager {
      * @readonly
      * @type {System[]}
      */
-    readonly systems: System<any, any, any, any, any>[];
+    readonly systems: System<any>[];
     /**
      * Current order of execution.
      * Note: this can be smaller that the number of registered systems, as systems are only added to the execution order once their startup finishes
@@ -62,13 +62,13 @@ export class EntityManager {
      * @readonly
      */
     readonly on: {
-        systemStarted: Signal<any, any, any, any, any, any, any, any>;
-        systemStopped: Signal<any, any, any, any, any, any, any, any>;
+        systemStarted: Signal;
+        systemStopped: Signal;
         /**
          * @type {Signal<System>}
          */
-        systemAdded: Signal<System<any, any, any, any, any>>;
-        systemRemoved: Signal<any, any, any, any, any, any, any, any>;
+        systemAdded: any;
+        systemRemoved: Signal;
     };
     /**
      *
@@ -189,13 +189,13 @@ export class EntityManager {
      * @returns {Promise} resolution depends on {@link EntityManager}'s state, if running - promise resolves after system startup. Otherwise, the promise will be resolved immediately.
      * @throws {IllegalStateException}
      */
-    addSystem(system: System<any, any, any, any, any>): Promise<any>;
+    addSystem(system: System<any>): Promise<any>;
     /**
      *
      * @param {System} system
      * @returns {Promise<boolean>}
      */
-    removeSystem(system: System<any, any, any, any, any>): Promise<boolean>;
+    removeSystem(system: System<any>): Promise<boolean>;
     /**
      * @private
      * @param {System} system
@@ -222,13 +222,13 @@ export class EntityManager {
      * @param {Class} systemClass
      * @returns {Promise.<System>}
      */
-    promiseSystem(systemClass: Class): Promise<System<any, any, any, any, any>>;
+    promiseSystem(systemClass: Class): Promise<System<any>>;
     /**
      * @param {Class} SystemClass
      * @param {SystemState} state
      * @returns {Promise.<System>}
      */
-    promiseSystemInState(SystemClass: Class, state: SystemState): Promise<System<any, any, any, any, any>>;
+    promiseSystemInState(SystemClass: Class, state: SystemState): Promise<System<any>>;
     /**
      * This method is asynchronous by nature, it will not be done until each system has finished its shutdown
      * Make sure to use callback to be notified when the shutdown has completed
@@ -248,4 +248,5 @@ export class EntityManager {
 import { System } from "./System.js";
 import Signal from "../../core/events/signal/Signal.js";
 import { EntityComponentDataset } from "./EntityComponentDataset.js";
+import { SystemState } from "./System.js";
 //# sourceMappingURL=EntityManager.d.ts.map

package/src/engine/ecs/EntityManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAgBU,MAAM;;;;;;;;;AAiBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,iCAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;qBADO,uCAAc;;MAI1B;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IAEf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BAmFC;IAED;;;OAGG;IACH,uBAFa,OAAO,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,IAAI,aAAS,CAiBzB;IAGD;;;OAGG;IACH,6BAFW,MAAM,QA8EhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,iEA6DC;IAED;;;;OAIG;IACH,uDAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAmCC;IAED;;;;;OAKG;IACH,oBAqFC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,mCAFa,wCAAgB,CA0B5B;IAED;;;;OAIG;IACH,8DAFa,wCAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAoFC;IAGL;;OAEG;IACH,yBArtBe,sBAAsB,UAqtBA;IACrC;;OAEG;IACH,0BAAqC;CATpC;uBAh+BmC,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B"}
+{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAgBU,MAAM;;;;;;;;;AAiBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,aAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;;;MAGL;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IAEf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BAmFC;IAED;;;OAGG;IACH,uBAFa,OAAO,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,IAAI,aAAS,CAiBzB;IAGD;;;OAGG;IACH,6BAFW,MAAM,QA8EhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,6CA6DC;IAED;;;;OAIG;IACH,mCAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAmCC;IAED;;;;;OAKG;IACH,oBAqFC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,mCAFa,oBAAgB,CA0B5B;IAED;;;;OAIG;IACH,gDAHW,WAAW,GACT,oBAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAoFC;IAGL;;OAEG;IACH,yBArtBe,sBAAsB,UAqtBA;IACrC;;OAEG;IACH,0BAAqC;CATpC;uBAh+BmC,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B;4BAEhC,aAAa"}

package/src/engine/ecs/EntityObserver.d.ts

@@ -1,13 +1,80 @@
-import {EntityComponentDataset} from "./EntityComponentDataset";
-
-interface Type<T> extends Function {
-    new(...args: any[]): T;
-}
-
-export class EntityObserver {
-    constructor(componentTypes: Type<any>[], completedCallback: (...args: any) => any, brokenCallback: (...args: any) => any, thisArg?: any)
-
-    connect(dataset: EntityComponentDataset): void
-
-    disconnect(): void
-}
+/**
+ * Signaling component query.
+ * Enables definition of a component class tuple, which will then be observed; for any entity that completes the tuple - a notification will be dispatched, same for any broken tuples.
+ * see {@link EntityComponentDataset.addObserver}/{@link EntityComponentDataset.removeObserver}.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class EntityObserver {
+    /**
+     *
+     * @param {Array} componentTypes
+     * @param {function(components:Array)} completedCallback
+     * @param {function(components:Array)} brokenCallback
+     * @param {*} [thisArg=undefined] will assume {@link this} value inside callbacks
+     * @constructor
+     */
+    constructor(componentTypes: any[], completedCallback: any, brokenCallback: any, thisArg?: any);
+    /**
+     *
+     * @type {BitSet}
+     */
+    componentMask: BitSet;
+    /**
+     * Mapping from component index to position in array of observed component types,
+     * this is used to build arguments for callbacks
+     * @type {number[]}
+     */
+    componentIndexMapping: number[];
+    /**
+     * Currently attached dataset. `null` when not attached.
+     * @type {EntityComponentDataset|null}
+     */
+    dataset: EntityComponentDataset | null;
+    /**
+     * @type {number}
+     */
+    componentTypeCount: number;
+    /**
+     *
+     * @type {function(Array)}
+     */
+    callbackComplete: (arg0: any[]) => any;
+    /**
+     *
+     * @type {function(Array)}
+     */
+    callbackBroken: (arg0: any[]) => any;
+    /**
+     *
+     * @type {Array}
+     */
+    componentTypes: any[];
+    /**
+     *
+     * @type {*}
+     */
+    thisArg: any;
+    /**
+     *
+     * @param {Array} componentTypeMap
+     */
+    build(componentTypeMap: any[]): void;
+    /**
+     * A shortcut for {@link EntityComponentDataset.addObserver}
+     * @param {EntityComponentDataset} dataset
+     */
+    connect(dataset: EntityComponentDataset): void;
+    /**
+     *
+     * @return {boolean}
+     */
+    get isConnected(): boolean;
+    /**
+     * A shortcut for {@link EntityComponentDataset.removeObserver}
+     */
+    disconnect(): void;
+}
+import { BitSet } from "../../core/binary/BitSet.js";
+//# sourceMappingURL=EntityObserver.d.ts.map

package/src/engine/ecs/System.d.ts

@@ -1,33 +1,162 @@
-import {EntityManager} from "./EntityManager";
-
-interface Type<T> extends Function {
-    new(...args: any[]): T;
-}
-
-export class System<A, B = any, C = any, D = any, E = any> {
-    constructor()
-
-    readonly dependencies: Type<any>[]
-
-    protected readonly entityManager: EntityManager
-
-    startup(em: EntityManager): Promise<void>
-
-    shutdown(em: EntityManager): Promise<void>
-
-    link(a: A, entity: number): void
-    link(a: A, b: B, entity: number): void
-    link(a: A, b: B, c: C, entity: number): void
-    link(a: A, b: B, c: C, d: D, entity: number): void
-    link(a: A, b: B, c: C, d: D, e: E, entity: number): void
-
-    unlink(a: A, entity: number): void
-    unlink(a: A, b: B, entity: number): void
-    unlink(a: A, b: B, c: C, entity: number): void
-    unlink(a: A, b: B, c: C, d: D, entity: number): void
-    unlink(a: A, b: B, c: C, d: D, e: E, entity: number): void
-
-    update(time_delta: number): void
-
-    fixedUpdate(time_delta: number): void
-}
+/**
+ * Base class to extend ECS systems from.
+ * A System defines some behavior over a tuple of components.
+ * Override base methods as needed to achieve desired behavior. The system already offers {@link update} and {@link fixedUpdate} methods for time-based simulation.
+ * If you have event-driven requirements - make use of {@link link} and {@link unlink} methods, as well as messaging facilities of {@link EntityComponentDataset}.
+ *
+ * @template C
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ *
+ * @example
+ *   class FallDamageSystem{
+ *       dependencies = [Health, Physics]
+ *
+ *       listeners = []; // internal storage
+ *
+ *       link(health: Health, physics: Physics, entity: number){
+ *           const listener = () => health.value -= 10; // receive damage on fall
+ *           physics.onContact.add(listener);
+ *           this.listeners[entity] = listener; // remember for later
+ *       }
+ *
+ *       unlink(health: Health, physics: Physics, entity: number){
+ *           const listener = this.listeners[entity];
+ *           physics.onContact.remove(listener);
+ *           delete this.listeners[entity]; // cleanup
+ *       }
+ *   }
+ */
+export class System<C> {
+    /**
+     * Reference to the attached {@link EntityManager}, usually set during {@link startup}
+     * Useful for gaining access to other Systems, via {@link EntityManager.getSystem} as well as the associated dataset via {@link EntityManager.dataset}
+     * @protected
+     * @type {EntityManager}
+     */
+    protected entityManager: EntityManager;
+    /**
+     * Managed internally by {@link EntityManager}, do not modify manually
+     * @readonly
+     * @type {ObservedValue.<SystemState>}
+     */
+    readonly state: any;
+    /**
+     * Component classes which have to be present before the system links an entity.
+     * May be left empty: such a system observes no entity tuple, {@link link}/{@link unlink} are never invoked,
+     * and it is driven purely by {@link startup}/{@link shutdown} and the {@link update}/{@link fixedUpdate} methods.
+     * NOTE: do not modify this while the system is running.
+     * @see link
+     * @see unlink
+     * @readonly
+     * @type {Array}
+     */
+    readonly dependencies: any[];
+    /**
+     * Component types that are used internally by the system and how they are used
+     * Main benefit of doing so is twofold:
+     *      - Helps the engine figure out the best execution order for system to make sure that updates propagate as quickly as possible
+     *      - Declaring this helps EntityManager to ensure that all relevant component types are properly registered for the system
+     *
+     * NOTE: specifying this is optional. The engine will still work.
+     * NOTE: do not modify this while the system is running
+     * @readonly
+     * @type {ResourceAccessSpecification[]}
+     */
+    readonly components_used: ResourceAccessSpecification[];
+    /**
+     * @returns {Array} Component classes
+     */
+    get referenced_components(): any[];
+    /**
+     * Does not check if the component is present, will return 0 if not present.
+     * @template T
+     * @param {T} Klass
+     * @return {number} bitmask of {@link ResourceAccessKind}
+     */
+    getAccessForComponent<T>(Klass: T): number;
+    /**
+     * Invoked before {@link System} is used for the first time.
+     * Managed by {@link EntityManager}'s lifecycle. Do not call this manually.
+     * @param {EntityManager} entityManager
+     * @returns {Promise<void>}
+     * @see shutdown
+     */
+    startup(entityManager: EntityManager): Promise<void>;
+    /**
+     * Invoked when {@link System} is no longer needed.
+     * Good place to clean up any held resourced and terminate owned processes.
+     * Managed by {@link EntityManager}'s lifecycle. Do not call this manually.
+     * @param {EntityManager} entityManager
+     * @returns {Promise<void>}
+     * @see startup
+     */
+    shutdown(entityManager: EntityManager): Promise<void>;
+    /**
+     * Called automatically when an entity gets a complete component tuple {@link this.dependencies}.
+     * Inputs are the same as dependencies, only instances instead of classes, plus there is an extra argument at the end, which is the entity ID.
+     * Never invoked when {@link this.dependencies} is empty.
+     * see {@link EntityObserver} for more implementation detail
+     */
+    link(component: any, entity: any): void;
+    /**
+     * Called automatically when an entity breaks component tuple {@link this.dependencies}.
+     * Inputs are the same as dependencies, only instances instead of classes, plus there is an extra argument at the end, which is the entity ID.
+     * Never invoked when {@link this.dependencies} is empty.
+     * see {@link EntityObserver} for more implementation detail
+     */
+    unlink(component: any, entity: any): void;
+    /**
+     * Invoked when a dataset is attached to the system, this happens before any entities are linked.
+     * Happens as a result of {@link EntityManager.attachDataset}.
+     * It is generally advised *NOT* to modify the dataset here.
+     * Managed by {@link EntityManager}'s lifecycle. Do not call this manually.
+     *
+     * This method is entirely optional, it provides advanced functionality for situations where datasets are being switched on the fly.
+     *
+     * see {@link handleDatasetDetached} for the reverse.
+     * @param {EntityComponentDataset} dataset
+     */
+    handleDatasetAttached(dataset: EntityComponentDataset): void;
+    /**
+     * Invoked when dataset is about to be detached from the system, this happens after all entities have been unlinked.
+     * Happens as a result of {@link EntityManager.detachDataset}.
+     * It is generally advised *NOT* to modify the dataset here.
+     * Managed by {@link EntityManager}'s lifecycle. Do not call this manually.
+     *
+     * This method is entirely optional, it provides advanced functionality for situations where datasets are being switched on the fly.
+     *
+     * see {@link handleDatasetAttached} for the reverse.
+     * @param {EntityComponentDataset} dataset
+     */
+    handleDatasetDetached(dataset: EntityComponentDataset): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isSystem: boolean;
+    /**
+     * Fixed update function, every step happens with the same exact time increment
+     * useful for systems that must have a fixed time step to be predictable and stable, such as physics
+     * @type {function(time_delta_seconds:number)} time delta will always be the same value, controlled via {@link EntityManager.fixedUpdateStepSize}
+     */
+    fixedUpdate: (arg0: time_delta_seconds) => number;
+    /**
+     * This update is generally synchronized with the render loop.
+     * Note that this time step can vary depending on system conditions and hardware we are running on.
+     * It is generally safe to assume that this update will happen once per frame, but it is not guaranteed.
+     * Also, note that when the application window/tab is suspended, the next update step can have a very large value.
+     * @type {function(time_delta_seconds:number)}
+     */
+    update: (arg0: time_delta_seconds) => number;
+}
+export type SystemState = number;
+export namespace SystemState {
+    let INITIAL: number;
+    let STARTING: number;
+    let RUNNING: number;
+    let STOPPING: number;
+    let STOPPED: number;
+}
+//# sourceMappingURL=System.d.ts.map

package/src/engine/ecs/animation/AnimationSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class AnimationSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof Animation;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/ecs/animation/AnimationSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/AnimationSerializationAdapter.js"],"names":[],"mappings":"AAIA;;IAEI,wBAAkB;IAClB,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,SAAS,QAKnB;IAED;;;;OAIG;IACH,yCAFW,SAAS,QAKnB;CACJ;gDA5B+C,sDAAsD;0BAE5E,gBAAgB"}
+{"version":3,"file":"AnimationSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/AnimationSerializationAdapter.js"],"names":[],"mappings":"AAIA;;IAEI,wBAAkB;IAGlB;;;;OAIG;IACH,uCAFW,SAAS,QAKnB;IAED;;;;OAIG;IACH,yCAFW,SAAS,QAKnB;CACJ;gDA5B+C,sDAAsD;0BAE5E,gBAAgB"}

package/src/engine/ecs/attachment/AttachmentSystem.d.ts

@@ -1,4 +1,4 @@
-export class AttachmentSystem extends System<any, any, any, any, any> {
+export class AttachmentSystem extends System<any> {
     constructor();
     dependencies: (typeof Transform | typeof Attachment)[];
     components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof AttachmentSockets> | ResourceAccessSpecification<typeof Mesh>)[];

package/src/engine/ecs/attachment/AttachmentSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AttachmentSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/attachment/AttachmentSystem.js"],"names":[],"mappings":"AAWA;IARuC,cAAmB;IAUtD,uDAAuC;IAEvC,sKAIE;IAEF;;;OAGG;IACH,SAFU,MAAM,EAAE,CAEL;IAEb;;;OAGG;IACH,UAFU,IAAI,MAAM,oBAAmB,CAElB;IAErB;;;OAGG;IACH,oBAFU,IAAI,MAAM,EAAE,mBAAmB,CAAC,CAEX;IAG/B;;;;OAIG;IACH,kBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,aAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,MAAM,CAwBlB;IAGD;;;;;OAKG;IACH,iBAJW,UAAU,aACV,SAAS,UACT,MAAM,QAKhB;IAED,uBA6IC;IAED;;;;;OAKG;IACH,mBAJW,UAAU,aACV,SAAS,UACT,MAAM,QAqChB;IAED,oBAUC;IAED,6BAaC;CACJ;uBA5TsB,cAAc;0BAEX,2BAA2B;2BAD1B,iBAAiB;4CAOA,oDAAoD;kCAL9D,iCAAiC;iBAElD,iCAAiC"}
+{"version":3,"file":"AttachmentSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/attachment/AttachmentSystem.js"],"names":[],"mappings":"AAWA;;IAEI,uDAAuC;IAEvC,sKAIE;IAEF;;;OAGG;IACH,SAFU,MAAM,EAAE,CAEL;IAEb;;;OAGG;IACH,UAFU,IAAI,MAAM,oBAAmB,CAElB;IAErB;;;OAGG;IACH,oBAFU,IAAI,MAAM,EAAE,mBAAmB,CAAC,CAEX;IAG/B;;;;OAIG;IACH,kBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,aAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,MAAM,CAwBlB;IAGD;;;;;OAKG;IACH,iBAJW,UAAU,aACV,SAAS,UACT,MAAM,QAKhB;IAED,uBA6IC;IAED;;;;;OAKG;IACH,mBAJW,UAAU,aACV,SAAS,UACT,MAAM,QAqChB;IAED,oBAUC;IAED,6BAaC;CACJ;uBA5TsB,cAAc;0BAEX,2BAA2B;2BAD1B,iBAAiB;4CAOA,oDAAoD;kCAL9D,iCAAiC;iBAElD,iCAAiC"}

package/src/engine/ecs/components/PropertySetSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class PropertySetSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof PropertySet;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/ecs/components/PropertySetSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PropertySetSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/components/PropertySetSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAGI,0BAAoB;IACpB,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,WAAW,QAIrB;IAED;;;;OAIG;IACH,yCAFW,WAAW,QAMrB;CACJ;gDA5B+C,sDAAsD;wBAC9E,kBAAkB"}
+{"version":3,"file":"PropertySetSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/components/PropertySetSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAGI,0BAAoB;IAGpB;;;;OAIG;IACH,uCAFW,WAAW,QAIrB;IAED;;;;OAIG;IACH,yCAFW,WAAW,QAMrB;CACJ;gDA5B+C,sDAAsD;wBAC9E,kBAAkB"}

package/src/engine/ecs/components/SerializationMetadataSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class SerializationMetadataSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof SerializationMetadata;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/ecs/components/SerializationMetadataSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SerializationMetadataSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/components/SerializationMetadataSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,oCAA8B;IAC9B,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,qBAAqB,QAI/B;IAED;;;;OAIG;IACH,yCAFW,qBAAqB,QAI/B;CACJ;gDAzB+C,sDAAsD;sCAChE,4BAA4B"}
+{"version":3,"file":"SerializationMetadataSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/components/SerializationMetadataSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,oCAA8B;IAG9B;;;;OAIG;IACH,uCAFW,qBAAqB,QAI/B;IAED;;;;OAIG;IACH,yCAFW,qBAAqB,QAI/B;CACJ;gDAzB+C,sDAAsD;sCAChE,4BAA4B"}

package/src/engine/ecs/components/TagSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class TagSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof Tag;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/ecs/components/TagSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TagSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/components/TagSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,kBAAY;IACZ,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,GAAG,QAcb;IAED;;;;OAIG;IACH,yCAFW,GAAG,QAYb;CACJ;gDA3C+C,sDAAsD;gBACtF,UAAU"}
+{"version":3,"file":"TagSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/components/TagSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,kBAAY;IAGZ;;;;OAIG;IACH,uCAFW,GAAG,QAcb;IAED;;;;OAIG;IACH,yCAFW,GAAG,QAYb;CACJ;gDA3C+C,sDAAsD;gBACtF,UAAU"}

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.d.ts

@@ -36,7 +36,7 @@ export class DynamicRuleDescriptionTable extends StaticKnowledgeDataTable<any> {
      * @returns {DynamicRuleDescription[]}
      */
     match(context: any): DynamicRuleDescription[];
-    link(database: any, assetManager: any, executor: any): any;
+    link(database: any, assetManager: any, executor: any): Promise<any>;
     parse(json: any): DynamicRuleDescription;
 }
 import { StaticKnowledgeDataTable } from "../../../knowledge/database/StaticKnowledgeDataTable.js";

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicRuleDescriptionTable.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.js"],"names":[],"mappings":"AAMA;;IAEI;;;;OAIG;IACH,yCAAsC;IAEtC;;;;OAIG;IACH,iCAAyC;IAEzC;;;;OAIG;IACH,oDAFY,sBAAsB,EAAE,GAAC,SAAS,CAI7C;IAED;;;OAGG;IACH,kBAFY,uBAAuB,CAclC;IAED,mBA8BC;IAED;;;;OAIG;IACH,yBAFa,sBAAsB,GAAC,SAAS,CAmC5C;IAED;;;;OAIG;IACH,qBAFa,sBAAsB,EAAE,CAgCpC;IAED,2DAIC;IAED,yCAMC;CAEJ;yCA1KwC,yDAAyD;uCAC3D,6BAA6B;wCAF5B,uEAAuE"}
+{"version":3,"file":"DynamicRuleDescriptionTable.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.js"],"names":[],"mappings":"AAMA;;IAEI;;;;OAIG;IACH,yCAAsC;IAEtC;;;;OAIG;IACH,iCAAyC;IAEzC;;;;OAIG;IACH,oDAFY,sBAAsB,EAAE,GAAC,SAAS,CAI7C;IAED;;;OAGG;IACH,kBAFY,uBAAuB,CAclC;IAED,mBA8BC;IAED;;;;OAIG;IACH,yBAFa,sBAAsB,GAAC,SAAS,CAmC5C;IAED;;;;OAIG;IACH,qBAFa,sBAAsB,EAAE,CAgCpC;IAED,oEAIC;IAED,yCAMC;CAEJ;yCA1KwC,yDAAyD;uCAC3D,6BAA6B;wCAF5B,uEAAuE"}

package/src/engine/ecs/fow/FogOfWar.d.ts

@@ -34,7 +34,7 @@ export class FogOfWar {
      */
     fadeMask: RowFirstTable;
     on: {
-        textureChanged: Signal<any, any, any, any, any, any, any, any>;
+        textureChanged: Signal;
     };
     /**
      *

package/src/engine/ecs/fow/FogOfWarRevealerSystem.d.ts

@@ -1,4 +1,4 @@
-export class FogOfWarRevealerSystem extends System<any, any, any, any, any> {
+export class FogOfWarRevealerSystem extends System<any> {
     /**
      *
      * @param {number} team

package/src/engine/ecs/fow/FogOfWarSystem.d.ts

@@ -1,4 +1,4 @@
-export class FogOfWarSystem extends System<any, any, any, any, any> {
+export class FogOfWarSystem extends System<any> {
     /**
      *
      * @param {GraphicsEngine} graphics
@@ -23,11 +23,6 @@ export class FogOfWarSystem extends System<any, any, any, any, any> {
      * @returns {VisibilityFilter}
      */
     buildVisibilityFilter(): VisibilityFilter;
-    /**
-     *
-     * @param {EntityManager} entityManager
-     */
-    startup(entityManager: EntityManager): Promise<void>;
     renderTarget: any;
     shutdown(entityManager: any): Promise<void>;
     /**

package/src/engine/ecs/fow/FogOfWarSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarSystem.js"],"names":[],"mappings":"AAwBA;IACI;;;OAGG;IACH,sCA0BC;IAvBG;;;OAGG;IACH,yBAAwB;IAExB,mDAAuC;IAEvC,gEAEC;IAED,mCAAoD;IAIpD;;;OAGG;IACH,eAFU,aAAa,CAEE;IAEzB,uBAAuB;IAG3B;;;OAGG;IACH,yBAFa,gBAAgB,CAuE5B;IAED;;;OAGG;IACH,qDA6EC;IA7DG,kBAAgC;IA+DpC,4CAEC;IAED;;;;;OAKG;IACH,UAJW,QAAQ,WACR,OAAO,UACP,MAAM,QAmBhB;IAED,kDAQC;IAED,6BAUC;CACJ;uBAzPsB,cAAc;oBACjB,2BAA2B;yBACtB,eAAe;4CAdI,oDAAoD;iCAS/D,sDAAsD;8BAPzD,0CAA0C"}
+{"version":3,"file":"FogOfWarSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarSystem.js"],"names":[],"mappings":"AAwBA;IACI;;;OAGG;IACH,sCA0BC;IAvBG;;;OAGG;IACH,yBAAwB;IAExB,mDAAuC;IAEvC,gEAEC;IAED,mCAAoD;IAIpD;;;OAGG;IACH,eAFU,aAAa,CAEE;IAEzB,uBAAuB;IAG3B;;;OAGG;IACH,yBAFa,gBAAgB,CAuE5B;IAsBG,kBAAgC;IA+DpC,4CAEC;IAED;;;;;OAKG;IACH,UAJW,QAAQ,WACR,OAAO,UACP,MAAM,QAmBhB;IAED,kDAQC;IAED,6BAUC;CACJ;uBAzPsB,cAAc;oBACjB,2BAA2B;yBACtB,eAAe;4CAdI,oDAAoD;iCAS/D,sDAAsD;8BAPzD,0CAA0C"}

package/src/engine/ecs/fow/serialization/FogOfWarRevealerSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class FogOfWarRevealerSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof FogOfWarRevealer;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/ecs/fow/serialization/FogOfWarRevealerSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarRevealerSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/serialization/FogOfWarRevealerSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,+BAAyB;IACzB,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,gBAAgB,QAI1B;IAED;;;;OAIG;IACH,yCAFW,gBAAgB,QAI1B;CACJ;gDAzB+C,yDAAyD;iCACxE,wBAAwB"}
+{"version":3,"file":"FogOfWarRevealerSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/serialization/FogOfWarRevealerSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,+BAAyB;IAGzB;;;;OAIG;IACH,uCAFW,gBAAgB,QAI1B;IAED;;;;OAIG;IACH,yCAFW,gBAAgB,QAI1B;CACJ;gDAzB+C,yDAAyD;iCACxE,wBAAwB"}

package/src/engine/ecs/fow/serialization/FogOfWarSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class FogOfWarSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof FogOfWar;
-    version: number;
     __sampler_serializer: Sampler2DSerializationAdapter;
     /**
      *

package/src/engine/ecs/fow/serialization/FogOfWarSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/serialization/FogOfWarSerializationAdapter.js"],"names":[],"mappings":"AAQA;;IAEI,uBAAiB;IACjB,gBAAY;IAEZ,oDAA2D;IAE3D;;;;OAIG;IACH,uCAFW,QAAQ,QAyBlB;IAED;;;;OAIG;IACH,yCAFW,QAAQ,QAgClB;CACJ;gDAjF+C,yDAAyD;yBAChF,gBAAgB;8CAKlC,kFAAkF"}
+{"version":3,"file":"FogOfWarSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/fow/serialization/FogOfWarSerializationAdapter.js"],"names":[],"mappings":"AAQA;;IAEI,uBAAiB;IAGjB,oDAA2D;IAE3D;;;;OAIG;IACH,uCAFW,QAAQ,QAyBlB;IAED;;;;OAIG;IACH,yCAFW,QAAQ,QAgClB;CACJ;gDAjF+C,yDAAyD;yBAChF,gBAAgB;8CAKlC,kFAAkF"}

package/src/engine/ecs/gui/GUIElement.d.ts

@@ -1,5 +1,115 @@
-import View from "../../../view/View";
-
-export default class GUIElement {
-    static fromView(view: View): GUIElement
-}
+export type GUIElementFlag = number;
+export namespace GUIElementFlag {
+    let Managed: number;
+    let Initialized: number;
+}
+export default GUIElement;
+declare class GUIElement {
+    /**
+     *
+     * @param {View} view
+     * @returns {GUIElement}
+     */
+    static fromView(view: View): GUIElement;
+    /**
+     *
+     * @param j
+     * @return {GUIElement}
+     */
+    static fromJSON(j: any): GUIElement;
+    /**
+     *
+     * @type {View}
+     */
+    view: View;
+    /**
+     *
+     * @type {String}
+     */
+    klass: string;
+    /**
+     *
+     * @type {Object}
+     */
+    parameters: any;
+    /**
+     * ranges from 0..1 in both X and Y, controls anchor point of element positioning
+     * @type {Vector2}
+     */
+    anchor: Vector2;
+    /**
+     * Used for visual grouping of elements, system will create and manage named containers to group elements together
+     * @readonly
+     * @type {String|null}
+     */
+    readonly group: string | null;
+    /**
+     * @private
+     * @type {number}
+     */
+    private flags;
+    /**
+     *
+     * @type {ObservedBoolean}
+     */
+    visible: ObservedBoolean;
+    /**
+     *
+     * @param {number|GUIElementFlag} flag
+     * @returns {void}
+     */
+    setFlag(flag: number | GUIElementFlag): void;
+    /**
+     *
+     * @param {number|GUIElementFlag} flag
+     * @returns {void}
+     */
+    clearFlag(flag: number | GUIElementFlag): void;
+    /**
+     *
+     * @param {number|GUIElementFlag} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag: number | GUIElementFlag, value: boolean): void;
+    /**
+     *
+     * @param {number|GUIElementFlag} flag
+     * @returns {boolean}
+     */
+    getFlag(flag: number | GUIElementFlag): boolean;
+    /**
+     *
+     * @param {GUIElement} other
+     * @returns {boolean}
+     */
+    equals(other: GUIElement): boolean;
+    /**
+     *
+     * @return {number}
+     */
+    hash(): number;
+    fromJSON({ klass, parameters, anchor, group, visible }: {
+        klass: any;
+        parameters?: {};
+        anchor?: Vector2;
+        group?: any;
+        visible?: boolean;
+    }): void;
+    toJSON(): {
+        klass: string;
+        parameters: any;
+        anchor: {
+            x: number;
+            y: number;
+        };
+        group: string;
+        visible: boolean;
+    };
+}
+declare namespace GUIElement {
+    let typeName: string;
+    let serializable: boolean;
+}
+import Vector2 from '../../../core/geom/Vector2.js';
+import ObservedBoolean from "../../../core/model/ObservedBoolean.js";
+//# sourceMappingURL=GUIElement.d.ts.map

package/src/engine/ecs/gui/GUIElementSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class GUIElementSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof GUIElement;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer