@lagless/core 0.0.33

package/dist/lib/mem/managers/entities-manager.js

@@ -0,0 +1,106 @@
+/** Sentinel value indicating an entity slot is unused / removed. */ export const ENTITY_REMOVED_MASK = 0xFFFFFFFF;
+export class EntitiesManager {
+    createEntity(prefab) {
+        let entity = this.popRemovedEntities();
+        if (entity === undefined) {
+            entity = this._nextEntityId[0];
+            this._nextEntityId[0]++;
+        }
+        if (entity >= this._ECSConfig.maxEntities) {
+            throw new Error(`Maximum number of entities (${this._ECSConfig.maxEntities}) exceeded`);
+        }
+        this._entitiesComponentsMasks[entity] = 0;
+        if (prefab) {
+            for (const [ComponentConstructor, Values] of prefab){
+                const componentInstance = this._ComponentsMemory.get(ComponentConstructor);
+                this._entitiesComponentsMasks[entity] |= ComponentConstructor.ID;
+                if (!Values) continue;
+                for (const [fieldName, value] of Object.entries(Values)){
+                    if (value === undefined) continue;
+                    componentInstance.unsafe[fieldName][entity] = value;
+                }
+            }
+        }
+        this.updateFilters(entity, this._entitiesComponentsMasks[entity]);
+        return entity;
+    }
+    removeEntity(entity) {
+        if (entity < 0 || entity >= this._ECSConfig.maxEntities) {
+            throw new Error(`Entity ID ${entity} is out of bounds`);
+        }
+        // Guard against double removal
+        if (this._entitiesComponentsMasks[entity] === ENTITY_REMOVED_MASK) {
+            return;
+        }
+        this._entitiesComponentsMasks[entity] = ENTITY_REMOVED_MASK;
+        // Add the entity to the removed entities stack
+        this._removedEntities[this._removedEntitiesLength[0]] = entity;
+        this._removedEntitiesLength[0]++;
+        this.updateFilters(entity, ENTITY_REMOVED_MASK);
+    }
+    isEntityAlive(entity) {
+        if (entity < 0 || entity >= this._ECSConfig.maxEntities) return false;
+        return this._entitiesComponentsMasks[entity] !== ENTITY_REMOVED_MASK;
+    }
+    addComponent(entity, ComponentConstructor) {
+        this._entitiesComponentsMasks[entity] |= ComponentConstructor.ID;
+        this.updateFilters(entity, this._entitiesComponentsMasks[entity]);
+    }
+    removeComponent(entity, ComponentConstructor) {
+        this._entitiesComponentsMasks[entity] &= ~ComponentConstructor.ID;
+        this.updateFilters(entity, this._entitiesComponentsMasks[entity]);
+    }
+    hasComponent(entity, ComponentConstructor) {
+        if (entity < 0 || entity >= this._ECSConfig.maxEntities) {
+            throw new Error(`Entity ID ${entity} is out of bounds`);
+        }
+        return (this._entitiesComponentsMasks[entity] & ComponentConstructor.ID) !== 0;
+    }
+    hasPrefab(entity, prefab) {
+        for (const [ComponentConstructor] of prefab){
+            if ((this._entitiesComponentsMasks[entity] & ComponentConstructor.ID) === 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    updateFilters(entity, componentMask) {
+        if (componentMask === ENTITY_REMOVED_MASK || componentMask === 0) {
+            this._FiltersMemory.removeEntityFromAllFilters(entity);
+        } else {
+            this._FiltersMemory.updateEntityInAllFilters(entity, componentMask);
+        }
+    }
+    popRemovedEntities() {
+        if (this._removedEntitiesLength[0] === 0) {
+            return undefined;
+        }
+        const entity = this._removedEntities[this._removedEntitiesLength[0] - 1];
+        this._removedEntitiesLength[0]--;
+        return entity;
+    }
+    init(arrayBuffer, tracker) {
+        this._nextEntityId = new Uint32Array(arrayBuffer, tracker.ptr, 1);
+        tracker.add(this._nextEntityId.byteLength);
+        this._removedEntitiesLength = new Uint32Array(arrayBuffer, tracker.ptr, 1);
+        tracker.add(this._removedEntitiesLength.byteLength);
+        this._removedEntities = new Uint32Array(arrayBuffer, tracker.ptr, this._ECSConfig.maxEntities);
+        tracker.add(this._removedEntities.byteLength);
+        this._entitiesComponentsMasks = new Uint32Array(arrayBuffer, tracker.ptr, this._ECSConfig.maxEntities);
+        this._entitiesComponentsMasks.fill(ENTITY_REMOVED_MASK);
+        tracker.add(this._entitiesComponentsMasks.byteLength);
+    }
+    calculateSize(tracker) {
+        tracker.add(Uint32Array.BYTES_PER_ELEMENT); // nextEntityId
+        tracker.add(Uint32Array.BYTES_PER_ELEMENT); // removedEntitiesLength
+        tracker.add(this._ECSConfig.maxEntities * Uint32Array.BYTES_PER_ELEMENT); // removedEntities
+        tracker.add(this._ECSConfig.maxEntities * Uint32Array.BYTES_PER_ELEMENT); // entitiesComponentsMasks
+    }
+    constructor(_ECSConfig, _ComponentsMemory, _FiltersMemory){
+        this._ECSConfig = _ECSConfig;
+        this._ComponentsMemory = _ComponentsMemory;
+        this._FiltersMemory = _FiltersMemory;
+    }
+}
+
+//# sourceMappingURL=entities-manager.js.map

package/dist/lib/mem/managers/entities-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/mem/managers/entities-manager.ts"],"sourcesContent":["import { FiltersManager } from './filters-manager.js';\nimport { ComponentsManager } from './components-manager.js';\nimport { IAbstractMemory } from '../abstract-memory.interface.js';\nimport { ECSConfig } from '../../ecs-config.js';\nimport { Prefab } from '../../prefab.js';\nimport { IComponentConstructor } from '../../types/index.js';\nimport { MemoryTracker } from '@lagless/binary';\n\n/** Sentinel value indicating an entity slot is unused / removed. */\nexport const ENTITY_REMOVED_MASK = 0xFFFFFFFF;\n\nexport class EntitiesManager implements IAbstractMemory {\n  private _nextEntityId!: Uint32Array;\n  private _removedEntitiesLength!: Uint32Array;\n  private _removedEntities!: Uint32Array;\n  private _entitiesComponentsMasks!: Uint32Array;\n\n  constructor(\n    private readonly _ECSConfig: ECSConfig,\n    private readonly _ComponentsMemory: ComponentsManager,\n    private readonly _FiltersMemory: FiltersManager,\n  ) {}\n\n  public createEntity(prefab?: Prefab): number {\n    let entity = this.popRemovedEntities();\n    if (entity === undefined) {\n      entity = this._nextEntityId[0];\n      this._nextEntityId[0]++;\n    }\n    if (entity >= this._ECSConfig.maxEntities) {\n      throw new Error(`Maximum number of entities (${this._ECSConfig.maxEntities}) exceeded`);\n    }\n\n    this._entitiesComponentsMasks[entity] = 0;\n\n    if (prefab) {\n      for (const [ ComponentConstructor, Values ] of prefab) {\n        const componentInstance = this._ComponentsMemory.get(ComponentConstructor);\n        this._entitiesComponentsMasks[entity] |= ComponentConstructor.ID;\n        if (!Values) continue;\n        for (const [ fieldName, value ] of Object.entries(Values)) {\n          if (value === undefined) continue;\n          componentInstance.unsafe[fieldName as keyof typeof componentInstance.unsafe][entity] = value;\n        }\n      }\n    }\n\n    this.updateFilters(entity, this._entitiesComponentsMasks[entity]);\n\n    return entity;\n  }\n\n  public removeEntity(entity: number): void {\n    if (entity < 0 || entity >= this._ECSConfig.maxEntities) {\n      throw new Error(`Entity ID ${entity} is out of bounds`);\n    }\n\n    // Guard against double removal\n    if (this._entitiesComponentsMasks[entity] === ENTITY_REMOVED_MASK) {\n      return;\n    }\n\n    this._entitiesComponentsMasks[entity] = ENTITY_REMOVED_MASK;\n\n    // Add the entity to the removed entities stack\n    this._removedEntities[this._removedEntitiesLength[0]] = entity;\n    this._removedEntitiesLength[0]++;\n\n    this.updateFilters(entity, ENTITY_REMOVED_MASK);\n  }\n\n  public isEntityAlive(entity: number): boolean {\n    if (entity < 0 || entity >= this._ECSConfig.maxEntities) return false;\n    return this._entitiesComponentsMasks[entity] !== ENTITY_REMOVED_MASK;\n  }\n\n  public addComponent(entity: number, ComponentConstructor: IComponentConstructor): void {\n    this._entitiesComponentsMasks[entity] |= ComponentConstructor.ID;\n    this.updateFilters(entity, this._entitiesComponentsMasks[entity]);\n  }\n\n  public removeComponent(entity: number, ComponentConstructor: IComponentConstructor): void {\n    this._entitiesComponentsMasks[entity] &= ~ComponentConstructor.ID;\n    this.updateFilters(entity, this._entitiesComponentsMasks[entity]);\n  }\n\n  public hasComponent(entity: number, ComponentConstructor: IComponentConstructor): boolean {\n    if (entity < 0 || entity >= this._ECSConfig.maxEntities) {\n      throw new Error(`Entity ID ${entity} is out of bounds`);\n    }\n    return (this._entitiesComponentsMasks[entity] & ComponentConstructor.ID) !== 0;\n  }\n\n  public hasPrefab(entity: number, prefab: Prefab): boolean {\n    for (const [ ComponentConstructor ] of prefab) {\n      if ((this._entitiesComponentsMasks[entity] & ComponentConstructor.ID) === 0) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  private updateFilters(entity: number, componentMask: number): void {\n    if (componentMask === ENTITY_REMOVED_MASK || componentMask === 0) {\n      this._FiltersMemory.removeEntityFromAllFilters(entity);\n    } else {\n      this._FiltersMemory.updateEntityInAllFilters(entity, componentMask);\n    }\n  }\n\n  private popRemovedEntities(): number | undefined {\n    if (this._removedEntitiesLength[0] === 0) {\n      return undefined;\n    }\n\n    const entity = this._removedEntities[this._removedEntitiesLength[0] - 1];\n    this._removedEntitiesLength[0]--;\n\n    return entity;\n  }\n\n  public init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void {\n    this._nextEntityId = new Uint32Array(arrayBuffer, tracker.ptr, 1);\n    tracker.add(this._nextEntityId.byteLength);\n\n    this._removedEntitiesLength = new Uint32Array(arrayBuffer, tracker.ptr, 1);\n    tracker.add(this._removedEntitiesLength.byteLength);\n\n    this._removedEntities = new Uint32Array(arrayBuffer, tracker.ptr, this._ECSConfig.maxEntities);\n    tracker.add(this._removedEntities.byteLength);\n\n    this._entitiesComponentsMasks = new Uint32Array(arrayBuffer, tracker.ptr, this._ECSConfig.maxEntities);\n    this._entitiesComponentsMasks.fill(ENTITY_REMOVED_MASK);\n    tracker.add(this._entitiesComponentsMasks.byteLength);\n  }\n\n  public calculateSize(tracker: MemoryTracker): void {\n    tracker.add(Uint32Array.BYTES_PER_ELEMENT); // nextEntityId\n    tracker.add(Uint32Array.BYTES_PER_ELEMENT); // removedEntitiesLength\n    tracker.add(this._ECSConfig.maxEntities * Uint32Array.BYTES_PER_ELEMENT); // removedEntities\n    tracker.add(this._ECSConfig.maxEntities * Uint32Array.BYTES_PER_ELEMENT); // entitiesComponentsMasks\n  }\n}\n"],"names":["ENTITY_REMOVED_MASK","EntitiesManager","createEntity","prefab","entity","popRemovedEntities","undefined","_nextEntityId","_ECSConfig","maxEntities","Error","_entitiesComponentsMasks","ComponentConstructor","Values","componentInstance","_ComponentsMemory","get","ID","fieldName","value","Object","entries","unsafe","updateFilters","removeEntity","_removedEntities","_removedEntitiesLength","isEntityAlive","addComponent","removeComponent","hasComponent","hasPrefab","componentMask","_FiltersMemory","removeEntityFromAllFilters","updateEntityInAllFilters","init","arrayBuffer","tracker","Uint32Array","ptr","add","byteLength","fill","calculateSize","BYTES_PER_ELEMENT","constructor"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/lib/mem/managers/filters-manager.d.ts

@@ -0,0 +1,17 @@
+import { ECSConfig } from '../../ecs-config.js';
+import { IAbstractMemory } from '../abstract-memory.interface.js';
+import { ECSDeps, IFilterConstructor, IFilterInstance } from '../../types/index.js';
+import { MemoryTracker } from '@lagless/binary';
+export declare class FiltersManager implements IAbstractMemory {
+    private readonly _ECSConfig;
+    private readonly _ECSDeps;
+    private readonly _filtersInstances;
+    constructor(_ECSConfig: ECSConfig, _ECSDeps: ECSDeps);
+    init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void;
+    calculateSize(tracker: MemoryTracker): void;
+    get<FilterCtor extends IFilterConstructor>(FilterConstructor: FilterCtor): InstanceType<FilterCtor>;
+    [Symbol.iterator](): MapIterator<[IFilterConstructor, IFilterInstance]>;
+    removeEntityFromAllFilters(entity: number): void;
+    updateEntityInAllFilters(entity: number, componentsMask: number): void;
+}
+//# sourceMappingURL=filters-manager.d.ts.map

package/dist/lib/mem/managers/filters-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filters-manager.d.ts","sourceRoot":"","sources":["../../../../src/lib/mem/managers/filters-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACpF,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,qBAAa,cAAe,YAAW,eAAe;IAGxC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAAa,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAF7E,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAkD;gBAEvD,UAAU,EAAE,SAAS,EAAmB,QAAQ,EAAE,OAAO;IAE/E,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAO5D,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAM3C,GAAG,CAAC,UAAU,SAAS,kBAAkB,EAAE,iBAAiB,EAAE,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC;IAQnG,CAAC,MAAM,CAAC,QAAQ,CAAC;IAIjB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMhD,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI;CAc9E"}

package/dist/lib/mem/managers/filters-manager.js

@@ -0,0 +1,46 @@
+export class FiltersManager {
+    init(arrayBuffer, tracker) {
+        for (const FilterConstructor of this._ECSDeps.filters){
+            const filterInstance = new FilterConstructor(this._ECSConfig.maxEntities, arrayBuffer, tracker);
+            this._filtersInstances.set(FilterConstructor, filterInstance);
+        }
+    }
+    calculateSize(tracker) {
+        for (const FilterDefinition of this._ECSDeps.filters){
+            FilterDefinition.calculateSize(this._ECSConfig.maxEntities, tracker);
+        }
+    }
+    get(FilterConstructor) {
+        const filterInstance = this._filtersInstances.get(FilterConstructor);
+        if (!filterInstance) {
+            throw new Error(`Filter ${FilterConstructor.name} not found`);
+        }
+        return filterInstance;
+    }
+    [Symbol.iterator]() {
+        return this._filtersInstances.entries();
+    }
+    removeEntityFromAllFilters(entity) {
+        for (const filterInstance of this._filtersInstances.values()){
+            filterInstance.removeEntityFromFilter(entity);
+        }
+    }
+    updateEntityInAllFilters(entity, componentsMask) {
+        for (const filterInstance of this._filtersInstances.values()){
+            const includeOk = !filterInstance.includeMask || (componentsMask & filterInstance.includeMask) === filterInstance.includeMask;
+            const excludeOk = !filterInstance.excludeMask || (componentsMask & filterInstance.excludeMask) === 0;
+            if (includeOk && excludeOk) {
+                filterInstance.addEntityToFilter(entity);
+            } else {
+                filterInstance.removeEntityFromFilter(entity);
+            }
+        }
+    }
+    constructor(_ECSConfig, _ECSDeps){
+        this._ECSConfig = _ECSConfig;
+        this._ECSDeps = _ECSDeps;
+        this._filtersInstances = new Map();
+    }
+}
+
+//# sourceMappingURL=filters-manager.js.map

package/dist/lib/mem/managers/filters-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/mem/managers/filters-manager.ts"],"sourcesContent":["import { ECSConfig } from '../../ecs-config.js';\nimport { IAbstractMemory } from '../abstract-memory.interface.js';\nimport { ECSDeps, IFilterConstructor, IFilterInstance } from '../../types/index.js';\nimport { MemoryTracker } from '@lagless/binary';\n\nexport class FiltersManager implements IAbstractMemory {\n  private readonly _filtersInstances = new Map<IFilterConstructor, IFilterInstance>();\n\n  constructor(private readonly _ECSConfig: ECSConfig, private readonly _ECSDeps: ECSDeps) {}\n\n  public init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void {\n    for (const FilterConstructor of this._ECSDeps.filters) {\n      const filterInstance = new FilterConstructor(this._ECSConfig.maxEntities, arrayBuffer, tracker);\n      this._filtersInstances.set(FilterConstructor, filterInstance);\n    }\n  }\n\n  public calculateSize(tracker: MemoryTracker): void {\n    for (const FilterDefinition of this._ECSDeps.filters) {\n      FilterDefinition.calculateSize(this._ECSConfig.maxEntities, tracker);\n    }\n  }\n\n  public get<FilterCtor extends IFilterConstructor>(FilterConstructor: FilterCtor): InstanceType<FilterCtor> {\n    const filterInstance = this._filtersInstances.get(FilterConstructor);\n    if (!filterInstance) {\n      throw new Error(`Filter ${FilterConstructor.name} not found`);\n    }\n    return filterInstance as InstanceType<FilterCtor>;\n  }\n\n  public [Symbol.iterator]() {\n    return this._filtersInstances.entries();\n  }\n\n  public removeEntityFromAllFilters(entity: number): void {\n    for (const filterInstance of this._filtersInstances.values()) {\n      filterInstance.removeEntityFromFilter(entity);\n    }\n  }\n\n  public updateEntityInAllFilters(entity: number, componentsMask: number): void {\n    for (const filterInstance of this._filtersInstances.values()) {\n      const includeOk = !filterInstance.includeMask\n        || (componentsMask & filterInstance.includeMask) === filterInstance.includeMask;\n      const excludeOk = !filterInstance.excludeMask\n        || (componentsMask & filterInstance.excludeMask) === 0;\n\n      if (includeOk && excludeOk) {\n        filterInstance.addEntityToFilter(entity);\n      } else {\n        filterInstance.removeEntityFromFilter(entity);\n      }\n    }\n  }\n}\n"],"names":["FiltersManager","init","arrayBuffer","tracker","FilterConstructor","_ECSDeps","filters","filterInstance","_ECSConfig","maxEntities","_filtersInstances","set","calculateSize","FilterDefinition","get","Error","name","Symbol","iterator","entries","removeEntityFromAllFilters","entity","values","removeEntityFromFilter","updateEntityInAllFilters","componentsMask","includeOk","includeMask","excludeOk","excludeMask","addEntityToFilter","constructor","Map"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,OAAO,MAAMA;IAKJC,KAAKC,WAAwB,EAAEC,OAAsB,EAAQ;QAClE,KAAK,MAAMC,qBAAqB,IAAI,CAACC,QAAQ,CAACC,OAAO,CAAE;YACrD,MAAMC,iBAAiB,IAAIH,kBAAkB,IAAI,CAACI,UAAU,CAACC,WAAW,EAAEP,aAAaC;YACvF,IAAI,CAACO,iBAAiB,CAACC,GAAG,CAACP,mBAAmBG;QAChD;IACF;IAEOK,cAAcT,OAAsB,EAAQ;QACjD,KAAK,MAAMU,oBAAoB,IAAI,CAACR,QAAQ,CAACC,OAAO,CAAE;YACpDO,iBAAiBD,aAAa,CAAC,IAAI,CAACJ,UAAU,CAACC,WAAW,EAAEN;QAC9D;IACF;IAEOW,IAA2CV,iBAA6B,EAA4B;QACzG,MAAMG,iBAAiB,IAAI,CAACG,iBAAiB,CAACI,GAAG,CAACV;QAClD,IAAI,CAACG,gBAAgB;YACnB,MAAM,IAAIQ,MAAM,CAAC,OAAO,EAAEX,kBAAkBY,IAAI,CAAC,UAAU,CAAC;QAC9D;QACA,OAAOT;IACT;IAEO,CAACU,OAAOC,QAAQ,CAAC,GAAG;QACzB,OAAO,IAAI,CAACR,iBAAiB,CAACS,OAAO;IACvC;IAEOC,2BAA2BC,MAAc,EAAQ;QACtD,KAAK,MAAMd,kBAAkB,IAAI,CAACG,iBAAiB,CAACY,MAAM,GAAI;YAC5Df,eAAegB,sBAAsB,CAACF;QACxC;IACF;IAEOG,yBAAyBH,MAAc,EAAEI,cAAsB,EAAQ;QAC5E,KAAK,MAAMlB,kBAAkB,IAAI,CAACG,iBAAiB,CAACY,MAAM,GAAI;YAC5D,MAAMI,YAAY,CAACnB,eAAeoB,WAAW,IACxC,AAACF,CAAAA,iBAAiBlB,eAAeoB,WAAW,AAAD,MAAOpB,eAAeoB,WAAW;YACjF,MAAMC,YAAY,CAACrB,eAAesB,WAAW,IACxC,AAACJ,CAAAA,iBAAiBlB,eAAesB,WAAW,AAAD,MAAO;YAEvD,IAAIH,aAAaE,WAAW;gBAC1BrB,eAAeuB,iBAAiB,CAACT;YACnC,OAAO;gBACLd,eAAegB,sBAAsB,CAACF;YACxC;QACF;IACF;IA9CAU,YAAY,AAAiBvB,UAAqB,EAAE,AAAiBH,QAAiB,CAAE;aAA3DG,aAAAA;aAAwCH,WAAAA;aAFpDK,oBAAoB,IAAIsB;IAEgD;AA+C3F"}

package/dist/lib/mem/managers/player-resources-manager.d.ts

@@ -0,0 +1,21 @@
+import { IAbstractMemory } from '../abstract-memory.interface.js';
+import { ECSConfig } from '../../ecs-config.js';
+import { ECSDeps, IPlayerResourceConstructor, IPlayerResourceInstance, ISingletonConstructor } from '../../types/index.js';
+import { MemoryTracker } from '@lagless/binary';
+export declare class PlayerResourcesManager implements IAbstractMemory {
+    private readonly _ECSConfig;
+    private readonly _ECSDeps;
+    private readonly _playerResourcesRegistry;
+    readonly PlayerResources: PlayerResources;
+    constructor(_ECSConfig: ECSConfig, _ECSDeps: ECSDeps);
+    init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void;
+    calculateSize(tracker: MemoryTracker): void;
+    get<Ctor extends ISingletonConstructor>(SingletonConstructor: Ctor, playerSlot: number): InstanceType<Ctor>;
+    [Symbol.iterator](): MapIterator<[IPlayerResourceConstructor, IPlayerResourceInstance[]]>;
+}
+export declare class PlayerResources {
+    private readonly _playerResourcesManager;
+    constructor(_playerResourcesManager: PlayerResourcesManager);
+    get<Ctor extends IPlayerResourceConstructor>(PlayerResourceConstructor: Ctor, playerSlot: number): InstanceType<Ctor>;
+}
+//# sourceMappingURL=player-resources-manager.d.ts.map

package/dist/lib/mem/managers/player-resources-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"player-resources-manager.d.ts","sourceRoot":"","sources":["../../../../src/lib/mem/managers/player-resources-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EACL,OAAO,EACP,0BAA0B,EAC1B,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,qBAAa,sBAAuB,YAAW,eAAe;IAIhD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAAa,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAH7E,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAyE;IAClH,SAAgB,eAAe,EAAE,eAAe,CAAC;gBAEpB,UAAU,EAAE,SAAS,EAAmB,QAAQ,EAAE,OAAO;IAI/E,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAW5D,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAQ3C,GAAG,CAAC,IAAI,SAAS,qBAAqB,EAAE,oBAAoB,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC;IAkB3G,CAAC,MAAM,CAAC,QAAQ,CAAC;CAGzB;AAED,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,uBAAuB;gBAAvB,uBAAuB,EAAE,sBAAsB;IAErE,GAAG,CAAC,IAAI,SAAS,0BAA0B,EAChD,yBAAyB,EAAE,IAAI,EAC/B,UAAU,EAAE,MAAM,GACjB,YAAY,CAAC,IAAI,CAAC;CAGtB"}

package/dist/lib/mem/managers/player-resources-manager.js

@@ -0,0 +1,52 @@
+export class PlayerResourcesManager {
+    init(arrayBuffer, tracker) {
+        for (const PlayerResourceConstructor of this._ECSDeps.playerResources){
+            const playerResourceForSlots = new Array();
+            for(let i = 0; i < this._ECSConfig.maxPlayers; i++){
+                const playerResourceInstance = new PlayerResourceConstructor(arrayBuffer, tracker);
+                playerResourceForSlots.push(playerResourceInstance);
+            }
+            this._playerResourcesRegistry.set(PlayerResourceConstructor, playerResourceForSlots);
+        }
+    }
+    calculateSize(tracker) {
+        for (const PlayerResourceConstructor of this._ECSDeps.playerResources){
+            for(let i = 0; i < this._ECSConfig.maxPlayers; i++){
+                PlayerResourceConstructor.calculateSize(tracker);
+            }
+        }
+    }
+    get(SingletonConstructor, playerSlot) {
+        if (playerSlot < 0 || playerSlot >= this._ECSConfig.maxPlayers) {
+            throw new Error(`Player slot ${playerSlot} is out of bounds`);
+        }
+        const playerResourceInstances = this._playerResourcesRegistry.get(SingletonConstructor);
+        if (!playerResourceInstances) {
+            throw new Error(`Player resource ${SingletonConstructor.name} not found`);
+        }
+        const playerResourceInstance = playerResourceInstances[playerSlot];
+        if (!playerResourceInstance) {
+            throw new Error(`Player resource instance for slot ${playerSlot} not found`);
+        }
+        return playerResourceInstance;
+    }
+    [Symbol.iterator]() {
+        return this._playerResourcesRegistry.entries();
+    }
+    constructor(_ECSConfig, _ECSDeps){
+        this._ECSConfig = _ECSConfig;
+        this._ECSDeps = _ECSDeps;
+        this._playerResourcesRegistry = new Map();
+        this.PlayerResources = new PlayerResources(this);
+    }
+}
+export class PlayerResources {
+    get(PlayerResourceConstructor, playerSlot) {
+        return this._playerResourcesManager.get(PlayerResourceConstructor, playerSlot);
+    }
+    constructor(_playerResourcesManager){
+        this._playerResourcesManager = _playerResourcesManager;
+    }
+}
+
+//# sourceMappingURL=player-resources-manager.js.map

package/dist/lib/mem/managers/player-resources-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/mem/managers/player-resources-manager.ts"],"sourcesContent":["import { IAbstractMemory } from '../abstract-memory.interface.js';\nimport { ECSConfig } from '../../ecs-config.js';\nimport {\n  ECSDeps,\n  IPlayerResourceConstructor,\n  IPlayerResourceInstance,\n  ISingletonConstructor,\n} from '../../types/index.js';\nimport { MemoryTracker } from '@lagless/binary';\n\nexport class PlayerResourcesManager implements IAbstractMemory {\n  private readonly _playerResourcesRegistry = new Map<IPlayerResourceConstructor, Array<IPlayerResourceInstance>>();\n  public readonly PlayerResources: PlayerResources;\n\n  constructor(private readonly _ECSConfig: ECSConfig, private readonly _ECSDeps: ECSDeps) {\n    this.PlayerResources = new PlayerResources(this);\n  }\n\n  public init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void {\n    for (const PlayerResourceConstructor of this._ECSDeps.playerResources) {\n      const playerResourceForSlots = new Array<IPlayerResourceInstance>();\n      for (let i = 0; i < this._ECSConfig.maxPlayers; i++) {\n        const playerResourceInstance = new PlayerResourceConstructor(arrayBuffer, tracker);\n        playerResourceForSlots.push(playerResourceInstance);\n      }\n      this._playerResourcesRegistry.set(PlayerResourceConstructor, playerResourceForSlots);\n    }\n  }\n\n  public calculateSize(tracker: MemoryTracker): void {\n    for (const PlayerResourceConstructor of this._ECSDeps.playerResources) {\n      for (let i = 0; i < this._ECSConfig.maxPlayers; i++) {\n        PlayerResourceConstructor.calculateSize(tracker);\n      }\n    }\n  }\n\n  public get<Ctor extends ISingletonConstructor>(SingletonConstructor: Ctor, playerSlot: number): InstanceType<Ctor> {\n    if (playerSlot < 0 || playerSlot >= this._ECSConfig.maxPlayers) {\n      throw new Error(`Player slot ${playerSlot} is out of bounds`);\n    }\n\n    const playerResourceInstances = this._playerResourcesRegistry.get(SingletonConstructor);\n    if (!playerResourceInstances) {\n      throw new Error(`Player resource ${SingletonConstructor.name} not found`);\n    }\n\n    const playerResourceInstance = playerResourceInstances[playerSlot];\n    if (!playerResourceInstance) {\n      throw new Error(`Player resource instance for slot ${playerSlot} not found`);\n    }\n\n    return playerResourceInstance as InstanceType<Ctor>;\n  }\n\n  public [Symbol.iterator]() {\n    return this._playerResourcesRegistry.entries();\n  }\n}\n\nexport class PlayerResources {\n  constructor(private readonly _playerResourcesManager: PlayerResourcesManager) {}\n\n  public get<Ctor extends IPlayerResourceConstructor>(\n    PlayerResourceConstructor: Ctor,\n    playerSlot: number\n  ): InstanceType<Ctor> {\n    return this._playerResourcesManager.get(PlayerResourceConstructor, playerSlot);\n  }\n}\n"],"names":["PlayerResourcesManager","init","arrayBuffer","tracker","PlayerResourceConstructor","_ECSDeps","playerResources","playerResourceForSlots","Array","i","_ECSConfig","maxPlayers","playerResourceInstance","push","_playerResourcesRegistry","set","calculateSize","get","SingletonConstructor","playerSlot","Error","playerResourceInstances","name","Symbol","iterator","entries","constructor","Map","PlayerResources","_playerResourcesManager"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAUA,OAAO,MAAMA;IAQJC,KAAKC,WAAwB,EAAEC,OAAsB,EAAQ;QAClE,KAAK,MAAMC,6BAA6B,IAAI,CAACC,QAAQ,CAACC,eAAe,CAAE;YACrE,MAAMC,yBAAyB,IAAIC;YACnC,IAAK,IAAIC,IAAI,GAAGA,IAAI,IAAI,CAACC,UAAU,CAACC,UAAU,EAAEF,IAAK;gBACnD,MAAMG,yBAAyB,IAAIR,0BAA0BF,aAAaC;gBAC1EI,uBAAuBM,IAAI,CAACD;YAC9B;YACA,IAAI,CAACE,wBAAwB,CAACC,GAAG,CAACX,2BAA2BG;QAC/D;IACF;IAEOS,cAAcb,OAAsB,EAAQ;QACjD,KAAK,MAAMC,6BAA6B,IAAI,CAACC,QAAQ,CAACC,eAAe,CAAE;YACrE,IAAK,IAAIG,IAAI,GAAGA,IAAI,IAAI,CAACC,UAAU,CAACC,UAAU,EAAEF,IAAK;gBACnDL,0BAA0BY,aAAa,CAACb;YAC1C;QACF;IACF;IAEOc,IAAwCC,oBAA0B,EAAEC,UAAkB,EAAsB;QACjH,IAAIA,aAAa,KAAKA,cAAc,IAAI,CAACT,UAAU,CAACC,UAAU,EAAE;YAC9D,MAAM,IAAIS,MAAM,CAAC,YAAY,EAAED,WAAW,iBAAiB,CAAC;QAC9D;QAEA,MAAME,0BAA0B,IAAI,CAACP,wBAAwB,CAACG,GAAG,CAACC;QAClE,IAAI,CAACG,yBAAyB;YAC5B,MAAM,IAAID,MAAM,CAAC,gBAAgB,EAAEF,qBAAqBI,IAAI,CAAC,UAAU,CAAC;QAC1E;QAEA,MAAMV,yBAAyBS,uBAAuB,CAACF,WAAW;QAClE,IAAI,CAACP,wBAAwB;YAC3B,MAAM,IAAIQ,MAAM,CAAC,kCAAkC,EAAED,WAAW,UAAU,CAAC;QAC7E;QAEA,OAAOP;IACT;IAEO,CAACW,OAAOC,QAAQ,CAAC,GAAG;QACzB,OAAO,IAAI,CAACV,wBAAwB,CAACW,OAAO;IAC9C;IA3CAC,YAAY,AAAiBhB,UAAqB,EAAE,AAAiBL,QAAiB,CAAE;aAA3DK,aAAAA;aAAwCL,WAAAA;aAHpDS,2BAA2B,IAAIa;QAI9C,IAAI,CAACC,eAAe,GAAG,IAAIA,gBAAgB,IAAI;IACjD;AA0CF;AAEA,OAAO,MAAMA;IAGJX,IACLb,yBAA+B,EAC/Be,UAAkB,EACE;QACpB,OAAO,IAAI,CAACU,uBAAuB,CAACZ,GAAG,CAACb,2BAA2Be;IACrE;IAPAO,YAAY,AAAiBG,uBAA+C,CAAE;aAAjDA,0BAAAA;IAAkD;AAQjF"}

package/dist/lib/mem/managers/prng-manager.d.ts

@@ -0,0 +1,36 @@
+import { MemoryTracker } from '@lagless/binary';
+import { ECSConfig, RawSeed } from '../../ecs-config.js';
+import { IAbstractMemory } from '../abstract-memory.interface.js';
+export declare class PRNG {
+    private readonly _PRNGManager;
+    constructor(_PRNGManager: PRNGManager);
+    getFloat(): number;
+    getFloat53(): number;
+    getRandomInt(from: number, to: number): number;
+    getRandomIntInclusive(from: number, to: number): number;
+}
+export declare class PRNGManager implements IAbstractMemory {
+    private readonly _ECSConfig;
+    private _state;
+    readonly prng: PRNG;
+    private readonly _tmpSeedBuffer;
+    constructor(_ECSConfig: ECSConfig);
+    init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void;
+    calculateSize(tracker: MemoryTracker): void;
+    /** Returns a uniform float in [0, 1). Uses 32 random bits. */
+    getFloat(): number;
+    /** Returns a float in [0, 1) using 53 bits of randomness (two 32-bit draws). */
+    getFloat53(): number;
+    /** Returns integer in [from, to) without modulo bias. */
+    getRandomInt(from: number, to: number): number;
+    /** Returns integer in [from, to] without modulo bias. */
+    getRandomIntInclusive(from: number, to: number): number;
+    /** Re-seed the PRNG from a 16-byte seed (e.g. received via ServerHello). */
+    reseed(seed: RawSeed): void;
+    /** Seed from 128 bits (Uint8Array of 16 bytes). */
+    private seed128;
+    /** Core step: returns next uint32. */
+    private nextUint32;
+    getSeedHash(): string;
+}
+//# sourceMappingURL=prng-manager.d.ts.map

package/dist/lib/mem/managers/prng-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prng-manager.d.ts","sourceRoot":"","sources":["../../../../src/lib/mem/managers/prng-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAIlE,qBAAa,IAAI;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,EAAE,WAAW;IAE/C,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAI9C,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;CAG/D;AAED,qBAAa,WAAY,YAAW,eAAe;IAO/C,OAAO,CAAC,QAAQ,CAAC,UAAU;IAN7B,OAAO,CAAC,MAAM,CAAe;IAC7B,SAAgB,IAAI,EAAE,IAAI,CAAC;IAE3B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAsB;gBAGlC,UAAU,EAAE,SAAS;IAKjC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAU5D,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAIlD,8DAA8D;IACvD,QAAQ,IAAI,MAAM;IAKzB,gFAAgF;IACzE,UAAU,IAAI,MAAM;IAO3B,yDAAyD;IAClD,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAWrD,yDAAyD;IAClD,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAQ9D,4EAA4E;IACrE,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAIlC,mDAAmD;IACnD,OAAO,CAAC,OAAO;IA0Bf,sCAAsC;IACtC,OAAO,CAAC,UAAU;IAoBX,WAAW,IAAI,MAAM;CAM7B"}

package/dist/lib/mem/managers/prng-manager.js

@@ -0,0 +1,126 @@
+const STATE_TYPED_ARRAY_LENGTH = 4;
+export class PRNG {
+    getFloat() {
+        return this._PRNGManager.getFloat();
+    }
+    getFloat53() {
+        return this._PRNGManager.getFloat53();
+    }
+    getRandomInt(from, to) {
+        return this._PRNGManager.getRandomInt(from, to);
+    }
+    getRandomIntInclusive(from, to) {
+        return this._PRNGManager.getRandomIntInclusive(from, to);
+    }
+    constructor(_PRNGManager){
+        this._PRNGManager = _PRNGManager;
+    }
+}
+export class PRNGManager {
+    init(arrayBuffer, tracker) {
+        this._state = new Uint32Array(arrayBuffer, tracker.ptr, STATE_TYPED_ARRAY_LENGTH);
+        tracker.add(this._state.byteLength);
+        // Accept various seed inputs:
+        // - this._ECSConfig.seed may be: number | Uint32Array(4) | Uint8Array(16) | string (UUID)
+        this.seed128(this._ECSConfig.seed);
+    // Seed initialized: hash ${this.getSeedHash()}
+    }
+    calculateSize(tracker) {
+        tracker.add(Uint32Array.BYTES_PER_ELEMENT * STATE_TYPED_ARRAY_LENGTH);
+    }
+    /** Returns a uniform float in [0, 1). Uses 32 random bits. */ getFloat() {
+        // Division by 2^32 gives a uniform grid on IEEE-754; good enough for most gameplay.
+        return this.nextUint32() / 0x100000000;
+    }
+    /** Returns a float in [0, 1) using 53 bits of randomness (two 32-bit draws). */ getFloat53() {
+        // Combine two draws into a 53-bit mantissa: (hi << 27) | (lo >>> 5), then / 2^53
+        const hi = this.nextUint32() >>> 5; // 27 bits
+        const lo = this.nextUint32() >>> 6; // 26 bits
+        return (hi * 0x4000000 + lo) / 0x20000000000000; // 2^26 + 2^53 denominator
+    }
+    /** Returns integer in [from, to) without modulo bias. */ getRandomInt(from, to) {
+        if (to <= from) throw new Error(`Invalid range: from (${from}) >= to (${to})`);
+        const span = to - from >>> 0;
+        const lim = (0x100000000 - span) % span; // rejection threshold
+        let x;
+        do {
+            x = this.nextUint32();
+        }while (x >>> 0 < lim)
+        return from + x % span;
+    }
+    /** Returns integer in [from, to] without modulo bias. */ getRandomIntInclusive(from, to) {
+        if (to < from) throw new Error(`Invalid range: from (${from}) > to (${to})`);
+        // Map to [0, span) then add 'from'
+        return this.getRandomInt(from, to + 1);
+    }
+    // ---------- Seeding ----------
+    /** Re-seed the PRNG from a 16-byte seed (e.g. received via ServerHello). */ reseed(seed) {
+        this.seed128(seed);
+    }
+    /** Seed from 128 bits (Uint8Array of 16 bytes). */ seed128(seed) {
+        const s = this._state;
+        this._tmpSeedBuffer.set(seed);
+        const a = readU32LE(this._tmpSeedBuffer, 0);
+        const b = readU32LE(this._tmpSeedBuffer, 4);
+        const c = readU32LE(this._tmpSeedBuffer, 8);
+        const d = readU32LE(this._tmpSeedBuffer, 12);
+        // Scramble each word to avoid weak seeds and reduce correlation.
+        s[0] = mix32(a);
+        s[1] = mix32(b);
+        s[2] = mix32(c);
+        s[3] = mix32(d);
+        // xoshiro requires a non-zero state; if all zero, fixup with a constant.
+        if ((s[0] | s[1] | s[2] | s[3]) === 0) {
+            // Use a fixed odd constant pattern then mix again.
+            s[0] = mix32(0xA3C59AC3);
+            s[1] = mix32(0x3C6EF372);
+            s[2] = mix32(0x9E3779B9);
+            s[3] = mix32(0xBB67AE85);
+        }
+    }
+    // ---------- Core generator: xoshiro128** ----------
+    /** Core step: returns next uint32. */ nextUint32() {
+        // Output function for xoshiro128**: rotl(s1 * 5, 7) * 9
+        const s = this._state;
+        const result = rotl32(Math.imul(s[1] * 5, 1) >>> 0, 7);
+        const out = Math.imul(result, 9) >>> 0;
+        // State transition (xoshiro128 family)
+        const t = s[1] << 9 >>> 0;
+        s[2] ^= s[0];
+        s[3] ^= s[1];
+        s[1] ^= s[2];
+        s[0] ^= s[3];
+        s[2] ^= t;
+        s[3] = rotl32(s[3], 11);
+        return out >>> 0;
+    }
+    getSeedHash() {
+        // Simple hash of the seed state for logging/identification.
+        const s = this._state;
+        const hash = mix32(s[0] ^ rotl32(s[1], 8) ^ rotl32(s[2], 16) ^ rotl32(s[3], 24));
+        return hash.toString(16).padStart(8, '0');
+    }
+    constructor(_ECSConfig){
+        this._ECSConfig = _ECSConfig;
+        this._tmpSeedBuffer = new Uint8Array(16);
+        this.prng = new PRNG(this);
+    }
+}
+// ---------- Helper functions (pure, inlineable) ----------
+/** 32-bit left rotate. */ function rotl32(x, k) {
+    return (x << k | x >>> 32 - k) >>> 0;
+}
+/** Strong 32-bit mixer (Murmur3 finalizer). */ function mix32(x) {
+    x >>>= 0;
+    x ^= x >>> 16;
+    x = Math.imul(x, 0x85ebca6b) >>> 0;
+    x ^= x >>> 13;
+    x = Math.imul(x, 0xc2b2ae35) >>> 0;
+    x ^= x >>> 16;
+    return x >>> 0;
+}
+/** Read little-endian u32 from bytes[offset..offset+3]. */ function readU32LE(bytes, off) {
+    return (bytes[off] | bytes[off + 1] << 8 | bytes[off + 2] << 16 | bytes[off + 3] << 24) >>> 0;
+}
+
+//# sourceMappingURL=prng-manager.js.map

package/dist/lib/mem/managers/prng-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/mem/managers/prng-manager.ts"],"sourcesContent":["import { MemoryTracker } from '@lagless/binary';\nimport { ECSConfig, RawSeed } from '../../ecs-config.js';\nimport { IAbstractMemory } from '../abstract-memory.interface.js';\n\nconst STATE_TYPED_ARRAY_LENGTH = 4;\n\nexport class PRNG {\n  constructor(private readonly _PRNGManager: PRNGManager) {}\n\n  public getFloat(): number {\n    return this._PRNGManager.getFloat();\n  }\n\n  public getFloat53(): number {\n    return this._PRNGManager.getFloat53();\n  }\n\n  public getRandomInt(from: number, to: number): number {\n    return this._PRNGManager.getRandomInt(from, to);\n  }\n\n  public getRandomIntInclusive(from: number, to: number): number {\n    return this._PRNGManager.getRandomIntInclusive(from, to);\n  }\n}\n\nexport class PRNGManager implements IAbstractMemory {\n  private _state!: Uint32Array; // s0,s1,s2,s3\n  public readonly prng: PRNG;\n\n  private readonly _tmpSeedBuffer = new Uint8Array(16);\n\n  constructor(\n    private readonly _ECSConfig: ECSConfig,\n  ) {\n    this.prng = new PRNG(this);\n  }\n\n  public init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void {\n    this._state = new Uint32Array(arrayBuffer, tracker.ptr, STATE_TYPED_ARRAY_LENGTH);\n    tracker.add(this._state.byteLength);\n\n    // Accept various seed inputs:\n    // - this._ECSConfig.seed may be: number | Uint32Array(4) | Uint8Array(16) | string (UUID)\n    this.seed128(this._ECSConfig.seed);\n    // Seed initialized: hash ${this.getSeedHash()}\n  }\n\n  public calculateSize(tracker: MemoryTracker): void {\n    tracker.add(Uint32Array.BYTES_PER_ELEMENT * STATE_TYPED_ARRAY_LENGTH);\n  }\n\n  /** Returns a uniform float in [0, 1). Uses 32 random bits. */\n  public getFloat(): number {\n    // Division by 2^32 gives a uniform grid on IEEE-754; good enough for most gameplay.\n    return this.nextUint32() / 0x1_0000_0000;\n  }\n\n  /** Returns a float in [0, 1) using 53 bits of randomness (two 32-bit draws). */\n  public getFloat53(): number {\n    // Combine two draws into a 53-bit mantissa: (hi << 27) | (lo >>> 5), then / 2^53\n    const hi = this.nextUint32() >>> 5;  // 27 bits\n    const lo = this.nextUint32() >>> 6;  // 26 bits\n    return (hi * 0x4000000 + lo) / 0x2000_0000_0000_00; // 2^26 + 2^53 denominator\n  }\n\n  /** Returns integer in [from, to) without modulo bias. */\n  public getRandomInt(from: number, to: number): number {\n    if (to <= from) throw new Error(`Invalid range: from (${from}) >= to (${to})`);\n    const span = (to - from) >>> 0;\n    const lim = (0x1_0000_0000 - span) % span; // rejection threshold\n    let x: number;\n    do {\n      x = this.nextUint32();\n    } while ((x >>> 0) < lim);\n    return from + (x % span);\n  }\n\n  /** Returns integer in [from, to] without modulo bias. */\n  public getRandomIntInclusive(from: number, to: number): number {\n    if (to < from) throw new Error(`Invalid range: from (${from}) > to (${to})`);\n    // Map to [0, span) then add 'from'\n    return this.getRandomInt(from, to + 1);\n  }\n\n  // ---------- Seeding ----------\n\n  /** Re-seed the PRNG from a 16-byte seed (e.g. received via ServerHello). */\n  public reseed(seed: RawSeed): void {\n    this.seed128(seed);\n  }\n\n  /** Seed from 128 bits (Uint8Array of 16 bytes). */\n  private seed128(seed: RawSeed): void {\n    const s = this._state;\n\n    this._tmpSeedBuffer.set(seed);\n\n    const a = readU32LE(this._tmpSeedBuffer, 0);\n    const b = readU32LE(this._tmpSeedBuffer, 4);\n    const c = readU32LE(this._tmpSeedBuffer, 8);\n    const d = readU32LE(this._tmpSeedBuffer, 12);\n\n    // Scramble each word to avoid weak seeds and reduce correlation.\n    s[0] = mix32(a);\n    s[1] = mix32(b);\n    s[2] = mix32(c);\n    s[3] = mix32(d);\n\n    // xoshiro requires a non-zero state; if all zero, fixup with a constant.\n    if ((s[0] | s[1] | s[2] | s[3]) === 0) {\n      // Use a fixed odd constant pattern then mix again.\n      s[0] = mix32(0xA3C59AC3); s[1] = mix32(0x3C6EF372);\n      s[2] = mix32(0x9E3779B9); s[3] = mix32(0xBB67AE85);\n    }\n  }\n\n  // ---------- Core generator: xoshiro128** ----------\n\n  /** Core step: returns next uint32. */\n  private nextUint32(): number {\n    // Output function for xoshiro128**: rotl(s1 * 5, 7) * 9\n    const s = this._state;\n    const result = rotl32(Math.imul(s[1] * 5, 1) >>> 0, 7);\n    const out = Math.imul(result, 9) >>> 0;\n\n    // State transition (xoshiro128 family)\n    const t = (s[1] << 9) >>> 0;\n\n    s[2] ^= s[0];\n    s[3] ^= s[1];\n    s[1] ^= s[2];\n    s[0] ^= s[3];\n\n    s[2] ^= t;\n    s[3] = rotl32(s[3], 11);\n\n    return out >>> 0;\n  }\n\n  public getSeedHash(): string {\n    // Simple hash of the seed state for logging/identification.\n    const s = this._state;\n    const hash = mix32(s[0] ^ rotl32(s[1], 8) ^ rotl32(s[2], 16) ^ rotl32(s[3], 24));\n    return hash.toString(16).padStart(8, '0');\n  }\n}\n\n// ---------- Helper functions (pure, inlineable) ----------\n\n/** 32-bit left rotate. */\nfunction rotl32(x: number, k: number): number {\n  return ((x << k) | (x >>> (32 - k))) >>> 0;\n}\n\n/** Strong 32-bit mixer (Murmur3 finalizer). */\nfunction mix32(x: number): number {\n  x >>>= 0;\n  x ^= x >>> 16;\n  x = Math.imul(x, 0x85ebca6b) >>> 0;\n  x ^= x >>> 13;\n  x = Math.imul(x, 0xc2b2ae35) >>> 0;\n  x ^= x >>> 16;\n  return x >>> 0;\n}\n\n/** Read little-endian u32 from bytes[offset..offset+3]. */\nfunction readU32LE(bytes: Uint8Array, off: number): number {\n  return (\n    bytes[off] |\n    (bytes[off + 1] << 8) |\n    (bytes[off + 2] << 16) |\n    (bytes[off + 3] << 24)\n  ) >>> 0;\n}\n"],"names":["STATE_TYPED_ARRAY_LENGTH","PRNG","getFloat","_PRNGManager","getFloat53","getRandomInt","from","to","getRandomIntInclusive","constructor","PRNGManager","init","arrayBuffer","tracker","_state","Uint32Array","ptr","add","byteLength","seed128","_ECSConfig","seed","calculateSize","BYTES_PER_ELEMENT","nextUint32","hi","lo","Error","span","lim","x","reseed","s","_tmpSeedBuffer","set","a","readU32LE","b","c","d","mix32","result","rotl32","Math","imul","out","t","getSeedHash","hash","toString","padStart","Uint8Array","prng","k","bytes","off"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/lib/mem/managers/singletons-manager.d.ts

@@ -0,0 +1,13 @@
+import { MemoryTracker } from '@lagless/binary';
+import { IAbstractMemory } from '../abstract-memory.interface.js';
+import { ECSDeps, ISingletonConstructor, ISingletonInstance } from '../../types/index.js';
+export declare class SingletonsManager implements IAbstractMemory {
+    private readonly _ECSDeps;
+    private readonly _singletonsInstances;
+    constructor(_ECSDeps: ECSDeps);
+    init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void;
+    calculateSize(tracker: MemoryTracker): void;
+    get<Ctor extends ISingletonConstructor>(SingletonConstructor: Ctor): InstanceType<Ctor>;
+    [Symbol.iterator](): MapIterator<[ISingletonConstructor, ISingletonInstance]>;
+}
+//# sourceMappingURL=singletons-manager.d.ts.map

package/dist/lib/mem/managers/singletons-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singletons-manager.d.ts","sourceRoot":"","sources":["../../../../src/lib/mem/managers/singletons-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1F,qBAAa,iBAAkB,YAAW,eAAe;IAG3C,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAFrC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAwD;gBAEhE,QAAQ,EAAE,OAAO;IAEvC,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAO5D,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAM3C,GAAG,CAAC,IAAI,SAAS,qBAAqB,EAAE,oBAAoB,EAAE,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC;IAQvF,CAAC,MAAM,CAAC,QAAQ,CAAC;CAGzB"}

package/dist/lib/mem/managers/singletons-manager.js

@@ -0,0 +1,29 @@
+export class SingletonsManager {
+    init(arrayBuffer, tracker) {
+        for (const SingletonConstructor of this._ECSDeps.singletons){
+            const singletonInstance = new SingletonConstructor(arrayBuffer, tracker);
+            this._singletonsInstances.set(SingletonConstructor, singletonInstance);
+        }
+    }
+    calculateSize(tracker) {
+        for (const SingletonDefinition of this._ECSDeps.singletons){
+            SingletonDefinition.calculateSize(tracker);
+        }
+    }
+    get(SingletonConstructor) {
+        const singletonInstance = this._singletonsInstances.get(SingletonConstructor);
+        if (!singletonInstance) {
+            throw new Error(`Singleton ${SingletonConstructor.name} not found`);
+        }
+        return singletonInstance;
+    }
+    [Symbol.iterator]() {
+        return this._singletonsInstances.entries();
+    }
+    constructor(_ECSDeps){
+        this._ECSDeps = _ECSDeps;
+        this._singletonsInstances = new Map();
+    }
+}
+
+//# sourceMappingURL=singletons-manager.js.map

package/dist/lib/mem/managers/singletons-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/mem/managers/singletons-manager.ts"],"sourcesContent":["import { MemoryTracker } from '@lagless/binary';\nimport { IAbstractMemory } from '../abstract-memory.interface.js';\nimport { ECSDeps, ISingletonConstructor, ISingletonInstance } from '../../types/index.js';\n\nexport class SingletonsManager implements IAbstractMemory {\n  private readonly _singletonsInstances = new Map<ISingletonConstructor, ISingletonInstance>();\n\n  constructor(private readonly _ECSDeps: ECSDeps) {}\n\n  public init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void {\n    for (const SingletonConstructor of this._ECSDeps.singletons) {\n      const singletonInstance = new SingletonConstructor(arrayBuffer, tracker);\n      this._singletonsInstances.set(SingletonConstructor, singletonInstance);\n    }\n  }\n\n  public calculateSize(tracker: MemoryTracker): void {\n    for (const SingletonDefinition of this._ECSDeps.singletons) {\n      SingletonDefinition.calculateSize(tracker);\n    }\n  }\n\n  public get<Ctor extends ISingletonConstructor>(SingletonConstructor: Ctor): InstanceType<Ctor> {\n    const singletonInstance = this._singletonsInstances.get(SingletonConstructor);\n    if (!singletonInstance) {\n      throw new Error(`Singleton ${SingletonConstructor.name} not found`);\n    }\n    return singletonInstance as InstanceType<Ctor>;\n  }\n\n  public [Symbol.iterator]() {\n    return this._singletonsInstances.entries();\n  }\n}\n"],"names":["SingletonsManager","init","arrayBuffer","tracker","SingletonConstructor","_ECSDeps","singletons","singletonInstance","_singletonsInstances","set","calculateSize","SingletonDefinition","get","Error","name","Symbol","iterator","entries","constructor","Map"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAIA,OAAO,MAAMA;IAKJC,KAAKC,WAAwB,EAAEC,OAAsB,EAAQ;QAClE,KAAK,MAAMC,wBAAwB,IAAI,CAACC,QAAQ,CAACC,UAAU,CAAE;YAC3D,MAAMC,oBAAoB,IAAIH,qBAAqBF,aAAaC;YAChE,IAAI,CAACK,oBAAoB,CAACC,GAAG,CAACL,sBAAsBG;QACtD;IACF;IAEOG,cAAcP,OAAsB,EAAQ;QACjD,KAAK,MAAMQ,uBAAuB,IAAI,CAACN,QAAQ,CAACC,UAAU,CAAE;YAC1DK,oBAAoBD,aAAa,CAACP;QACpC;IACF;IAEOS,IAAwCR,oBAA0B,EAAsB;QAC7F,MAAMG,oBAAoB,IAAI,CAACC,oBAAoB,CAACI,GAAG,CAACR;QACxD,IAAI,CAACG,mBAAmB;YACtB,MAAM,IAAIM,MAAM,CAAC,UAAU,EAAET,qBAAqBU,IAAI,CAAC,UAAU,CAAC;QACpE;QACA,OAAOP;IACT;IAEO,CAACQ,OAAOC,QAAQ,CAAC,GAAG;QACzB,OAAO,IAAI,CAACR,oBAAoB,CAACS,OAAO;IAC1C;IAzBAC,YAAY,AAAiBb,QAAiB,CAAE;aAAnBA,WAAAA;aAFZG,uBAAuB,IAAIW;IAEK;AA0BnD"}

package/dist/lib/mem/managers/tick-manager.d.ts

@@ -0,0 +1,10 @@
+import { MemoryTracker } from '@lagless/binary';
+import { IAbstractMemory } from '../abstract-memory.interface.js';
+export declare class TickManager implements IAbstractMemory {
+    private _tickTypedArray;
+    get tick(): number;
+    setTick(tick: number): void;
+    init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void;
+    calculateSize(tracker: MemoryTracker): void;
+}
+//# sourceMappingURL=tick-manager.d.ts.map

package/dist/lib/mem/managers/tick-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tick-manager.d.ts","sourceRoot":"","sources":["../../../../src/lib/mem/managers/tick-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAElE,qBAAa,WAAY,YAAW,eAAe;IACjD,OAAO,CAAC,eAAe,CAAe;IAEtC,IAAW,IAAI,IAAI,MAAM,CAExB;IAEM,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAI3B,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAM5D,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;CAGnD"}

package/dist/lib/mem/managers/tick-manager.js

@@ -0,0 +1,18 @@
+export class TickManager {
+    get tick() {
+        return this._tickTypedArray[0];
+    }
+    setTick(tick) {
+        this._tickTypedArray[0] = tick;
+    }
+    init(arrayBuffer, tracker) {
+        this._tickTypedArray = new Uint32Array(arrayBuffer, tracker.ptr, 1);
+        tracker.add(Uint32Array.BYTES_PER_ELEMENT);
+        this._tickTypedArray[0] = 0;
+    }
+    calculateSize(tracker) {
+        tracker.add(Uint32Array.BYTES_PER_ELEMENT);
+    }
+}
+
+//# sourceMappingURL=tick-manager.js.map

package/dist/lib/mem/managers/tick-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/mem/managers/tick-manager.ts"],"sourcesContent":["import { MemoryTracker } from '@lagless/binary';\nimport { IAbstractMemory } from '../abstract-memory.interface.js';\n\nexport class TickManager implements IAbstractMemory {\n  private _tickTypedArray!: Uint32Array;\n\n  public get tick(): number {\n    return this._tickTypedArray[0];\n  }\n\n  public setTick(tick: number): void {\n    this._tickTypedArray[0] = tick;\n  }\n\n  public init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void {\n    this._tickTypedArray = new Uint32Array(arrayBuffer, tracker.ptr, 1);\n    tracker.add(Uint32Array.BYTES_PER_ELEMENT);\n    this._tickTypedArray[0] = 0;\n  }\n\n  public calculateSize(tracker: MemoryTracker): void {\n    tracker.add(Uint32Array.BYTES_PER_ELEMENT);\n  }\n}\n"],"names":["TickManager","tick","_tickTypedArray","setTick","init","arrayBuffer","tracker","Uint32Array","ptr","add","BYTES_PER_ELEMENT","calculateSize"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":"AAGA,OAAO,MAAMA;IAGX,IAAWC,OAAe;QACxB,OAAO,IAAI,CAACC,eAAe,CAAC,EAAE;IAChC;IAEOC,QAAQF,IAAY,EAAQ;QACjC,IAAI,CAACC,eAAe,CAAC,EAAE,GAAGD;IAC5B;IAEOG,KAAKC,WAAwB,EAAEC,OAAsB,EAAQ;QAClE,IAAI,CAACJ,eAAe,GAAG,IAAIK,YAAYF,aAAaC,QAAQE,GAAG,EAAE;QACjEF,QAAQG,GAAG,CAACF,YAAYG,iBAAiB;QACzC,IAAI,CAACR,eAAe,CAAC,EAAE,GAAG;IAC5B;IAEOS,cAAcL,OAAsB,EAAQ;QACjDA,QAAQG,GAAG,CAACF,YAAYG,iBAAiB;IAC3C;AACF"}

package/dist/lib/mem/mem.d.ts

@@ -0,0 +1,28 @@
+import { ECSDeps } from '../types/index.js';
+import { ECSConfig } from '../ecs-config.js';
+import { ComponentsManager } from './managers/components-manager.js';
+import { EntitiesManager } from './managers/entities-manager.js';
+import { SingletonsManager } from './managers/singletons-manager.js';
+import { FiltersManager } from './managers/filters-manager.js';
+import { PlayerResourcesManager } from './managers/player-resources-manager.js';
+import { TickManager } from './managers/tick-manager.js';
+import { PRNGManager } from './managers/prng-manager.js';
+export declare class Mem {
+    private readonly _ECSConfig;
+    private readonly _ECSDeps;
+    readonly tickManager: TickManager;
+    readonly prngManager: PRNGManager;
+    readonly componentsManager: ComponentsManager;
+    readonly singletonsManager: SingletonsManager;
+    readonly filtersManager: FiltersManager;
+    readonly entitiesManager: EntitiesManager;
+    readonly playerResourcesManager: PlayerResourcesManager;
+    private readonly _arrayBuffer;
+    private readonly _memoryManagers;
+    constructor(_ECSConfig: ECSConfig, _ECSDeps: ECSDeps);
+    exportSnapshot(): ArrayBuffer;
+    applySnapshot(arrayBuffer: ArrayBuffer): void;
+    private calculateSize;
+    getHash(): number;
+}
+//# sourceMappingURL=mem.d.ts.map

package/dist/lib/mem/mem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mem.d.ts","sourceRoot":"","sources":["../../../src/lib/mem/mem.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAGzD,qBAAa,GAAG;IAYF,OAAO,CAAC,QAAQ,CAAC,UAAU;IAAa,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAX7E,SAAgB,WAAW,EAAE,WAAW,CAAC;IACzC,SAAgB,WAAW,EAAE,WAAW,CAAC;IACzC,SAAgB,iBAAiB,EAAE,iBAAiB,CAAC;IACrD,SAAgB,iBAAiB,EAAE,iBAAiB,CAAC;IACrD,SAAgB,cAAc,EAAE,cAAc,CAAC;IAC/C,SAAgB,eAAe,EAAE,eAAe,CAAC;IACjD,SAAgB,sBAAsB,EAAE,sBAAsB,CAAC;IAE/D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAC3C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAyB;gBAE5B,UAAU,EAAE,SAAS,EAAmB,QAAQ,EAAE,OAAO;IA8B/E,cAAc,IAAI,WAAW;IAI7B,aAAa,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAQpD,OAAO,CAAC,aAAa;IAUd,OAAO,IAAI,MAAM;CAQzB"}