@lagless/core 0.0.33

package/dist/lib/input/rpc-history.d.ts

@@ -0,0 +1,40 @@
+import { RPC } from './rpc.js';
+import { IAbstractInputConstructor } from '../types/index.js';
+import { InputRegistry } from './input-registry.js';
+export declare class RPCHistory {
+    private readonly _history;
+    static excludeLocalRPCs(rpcs: ReadonlyArray<RPC>, localPlayerSlot: number): RPC[];
+    addRPC(rpc: RPC): void;
+    addBatch(rpcs: ReadonlyArray<RPC>): void;
+    /**
+     * Returns a new array of RPCs matching the given input type at the specified tick.
+     * Each call allocates a fresh array — safe to store and use across multiple calls.
+     */
+    collectTickRPCs<TInputCtor extends IAbstractInputConstructor>(tick: number, InputCtor: TInputCtor): ReadonlyArray<RPC<InstanceType<TInputCtor>>>;
+    removePlayerInputsAtTick(playerSlot: number, tick: number, seq: number): void;
+    clear(): void;
+    get size(): number;
+    get totalRPCCount(): number;
+    debugExportAsJSON(): string;
+    /**
+     * Exports entire history to a compact binary format.
+     * @param registry - InputRegistry for serializing input data
+     * @returns ArrayBuffer containing serialized history
+     */
+    export(registry: InputRegistry): ArrayBuffer;
+    /**
+     * Imports history from binary format, replacing current content.
+     * @param registry - InputRegistry for deserializing input data
+     * @param buffer - ArrayBuffer containing serialized history
+     */
+    import(registry: InputRegistry, buffer: ArrayBuffer): void;
+    private prepareExportData;
+    private calculateExportSize;
+    private writeHeader;
+    private writeTickEntries;
+    private readHeader;
+    private readTickEntry;
+    /** Insert rpc into arr maintaining sorted order by (playerSlot, ordinal). */
+    private insertSorted;
+}
+//# sourceMappingURL=rpc-history.d.ts.map

package/dist/lib/input/rpc-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-history.d.ts","sourceRoot":"","sources":["../../../src/lib/input/rpc-history.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAiDpD,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiC;WAM5C,gBAAgB,CAAC,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,EAAE,eAAe,EAAE,MAAM,GAAG,GAAG,EAAE;IAQjF,MAAM,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI;IAStB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI;IA6B/C;;;OAGG;IACI,eAAe,CAAC,UAAU,SAAS,yBAAyB,EACjE,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,UAAU,GACpB,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC;IAaxC,wBAAwB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAmB7E,KAAK,IAAI,IAAI;IAIpB,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,aAAa,IAAI,MAAM,CAMjC;IAMM,iBAAiB,IAAI,MAAM;IAsBlC;;;;OAIG;IACI,MAAM,CAAC,QAAQ,EAAE,aAAa,GAAG,WAAW;IAgBnD;;;;OAIG;IACI,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IAgCjE,OAAO,CAAC,iBAAiB;IA6BzB,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,gBAAgB;IAwCxB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,aAAa;IAmDrB,6EAA6E;IAC7E,OAAO,CAAC,YAAY;CAOrB"}

package/dist/lib/input/rpc-history.js

@@ -0,0 +1,308 @@
+import { RPC } from './rpc.js';
+import { InputBinarySchema, FieldType, fieldTypeSizeBytes, LE } from '@lagless/binary';
+// ─────────────────────────────────────────────────────────────────────────────
+// Constants
+// ─────────────────────────────────────────────────────────────────────────────
+const RPC_HISTORY_FORMAT_VERSION = 1;
+/**
+ * Binary format layout:
+ *
+ * [Header]
+ *   version:   Uint8   (format version for forward compatibility)
+ *   tickCount: Uint32  (number of unique ticks)
+ *
+ * [Per Tick Block] × tickCount
+ *   tick:     Uint32  (tick number)
+ *   rpcCount: Uint16  (number of RPCs for this tick)
+ *
+ * [Per RPC Entry] × rpcCount
+ *   seq:        Uint32  (sequence number)
+ *   playerSlot: Uint8   (player slot)
+ *   dataLength: Uint16  (byte length of packed input data)
+ *   data:       Uint8[] (InputBinarySchema packed data including inputId & ordinal)
+ */ const HEADER_SIZE = fieldTypeSizeBytes[FieldType.Uint8] + // version
+fieldTypeSizeBytes[FieldType.Uint32]; // tickCount
+const TICK_HEADER_SIZE = fieldTypeSizeBytes[FieldType.Uint32] + // tick
+fieldTypeSizeBytes[FieldType.Uint16]; // rpcCount
+const RPC_HEADER_SIZE = fieldTypeSizeBytes[FieldType.Uint32] + // seq
+fieldTypeSizeBytes[FieldType.Uint8] + // playerSlot
+fieldTypeSizeBytes[FieldType.Uint16]; // dataLength
+const compareRPCs = (a, b)=>a.meta.playerSlot - b.meta.playerSlot || a.meta.ordinal - b.meta.ordinal || a.meta.seq - b.meta.seq;
+// ─────────────────────────────────────────────────────────────────────────────
+// RPCHistory
+// ─────────────────────────────────────────────────────────────────────────────
+export class RPCHistory {
+    // ─────────────────────────────────────────────────────────────────────────
+    // Static utilities
+    // ─────────────────────────────────────────────────────────────────────────
+    static excludeLocalRPCs(rpcs, localPlayerSlot) {
+        return rpcs.filter((rpc)=>rpc.meta.playerSlot !== localPlayerSlot);
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Public read/write methods
+    // ─────────────────────────────────────────────────────────────────────────
+    addRPC(rpc) {
+        let tickRPCs = this._history.get(rpc.meta.tick);
+        if (!tickRPCs) {
+            tickRPCs = [];
+            this._history.set(rpc.meta.tick, tickRPCs);
+        }
+        this.insertSorted(tickRPCs, rpc);
+    }
+    addBatch(rpcs) {
+        if (rpcs.length === 0) return;
+        // Group incoming RPCs by tick to minimize Map lookups and sorts
+        const perTick = new Map();
+        for (const rpc of rpcs){
+            let group = perTick.get(rpc.meta.tick);
+            if (!group) {
+                group = [];
+                perTick.set(rpc.meta.tick, group);
+            }
+            group.push(rpc);
+        }
+        // Merge per-tick groups into history and sort once per tick
+        for (const [tick, newRPCs] of perTick){
+            const existing = this._history.get(tick);
+            if (!existing) {
+                newRPCs.sort(compareRPCs);
+                this._history.set(tick, newRPCs);
+            } else {
+                existing.push(...newRPCs);
+                existing.sort(compareRPCs);
+            }
+        }
+    }
+    /**
+   * Returns a new array of RPCs matching the given input type at the specified tick.
+   * Each call allocates a fresh array — safe to store and use across multiple calls.
+   */ collectTickRPCs(tick, InputCtor) {
+        const rpcs = this._history.get(tick);
+        if (!rpcs) return [];
+        const result = [];
+        for (const rpc of rpcs){
+            if (rpc.inputId === InputCtor.id) {
+                result.push(rpc);
+            }
+        }
+        return result;
+    }
+    removePlayerInputsAtTick(playerSlot, tick, seq) {
+        const tickRPCs = this._history.get(tick);
+        if (!tickRPCs || tickRPCs.length === 0) return;
+        let writeIndex = 0;
+        for(let readIndex = 0; readIndex < tickRPCs.length; readIndex++){
+            const rpc = tickRPCs[readIndex];
+            if (!(rpc.meta.playerSlot === playerSlot && rpc.meta.seq === seq)) {
+                tickRPCs[writeIndex++] = rpc;
+            }
+        }
+        tickRPCs.length = writeIndex;
+        if (writeIndex === 0) {
+            this._history.delete(tick);
+        }
+    }
+    clear() {
+        this._history.clear();
+    }
+    get size() {
+        return this._history.size;
+    }
+    get totalRPCCount() {
+        let count = 0;
+        for (const rpcs of this._history.values()){
+            count += rpcs.length;
+        }
+        return count;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Serialization
+    // ─────────────────────────────────────────────────────────────────────────
+    debugExportAsJSON() {
+        const exportObj = {};
+        for (const [tick, rpcs] of this._history){
+            exportObj[tick] = rpcs.map((rpc)=>({
+                    inputId: rpc.inputId,
+                    seq: rpc.meta.seq,
+                    playerSlot: rpc.meta.playerSlot,
+                    ordinal: rpc.meta.ordinal,
+                    data: rpc.data
+                }));
+        }
+        return JSON.stringify(exportObj, null, 2);
+    }
+    /**
+   * Exports entire history to a compact binary format.
+   * @param registry - InputRegistry for serializing input data
+   * @returns ArrayBuffer containing serialized history
+   */ export(registry) {
+        // First pass: pack all RPC data and calculate total size
+        const tickEntries = this.prepareExportData(registry);
+        const totalSize = this.calculateExportSize(tickEntries);
+        // Second pass: write to buffer
+        const buffer = new ArrayBuffer(totalSize);
+        const view = new DataView(buffer);
+        const uint8View = new Uint8Array(buffer);
+        const offset = this.writeHeader(view, tickEntries.length);
+        this.writeTickEntries(view, uint8View, offset, tickEntries);
+        return buffer;
+    }
+    /**
+   * Imports history from binary format, replacing current content.
+   * @param registry - InputRegistry for deserializing input data
+   * @param buffer - ArrayBuffer containing serialized history
+   */ import(registry, buffer) {
+        const view = new DataView(buffer);
+        let offset = 0;
+        // Validate and read header
+        const { version, tickCount } = this.readHeader(view, offset);
+        offset += HEADER_SIZE;
+        if (version !== RPC_HISTORY_FORMAT_VERSION) {
+            throw new Error(`Unsupported RPCHistory format version: ${version} (expected ${RPC_HISTORY_FORMAT_VERSION})`);
+        }
+        // Clear existing data and read all ticks
+        this._history.clear();
+        for(let i = 0; i < tickCount; i++){
+            const result = this.readTickEntry(view, buffer, offset, registry);
+            offset = result.nextOffset;
+            if (result.rpcs.length > 0) {
+                result.rpcs.sort(compareRPCs);
+                this._history.set(result.tick, result.rpcs);
+            }
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Private: Export helpers
+    // ─────────────────────────────────────────────────────────────────────────
+    prepareExportData(registry) {
+        const entries = [];
+        for (const [tick, rpcs] of this._history){
+            const rpcEntries = [];
+            for (const rpc of rpcs){
+                const packedData = InputBinarySchema.packBatch(registry, [
+                    {
+                        inputId: rpc.inputId,
+                        ordinal: rpc.meta.ordinal,
+                        values: rpc.data
+                    }
+                ]);
+                rpcEntries.push({
+                    seq: rpc.meta.seq,
+                    playerSlot: rpc.meta.playerSlot,
+                    packedData
+                });
+            }
+            entries.push({
+                tick,
+                rpcs: rpcEntries
+            });
+        }
+        // Sort by tick for deterministic output
+        entries.sort((a, b)=>a.tick - b.tick);
+        return entries;
+    }
+    calculateExportSize(tickEntries) {
+        let size = HEADER_SIZE;
+        for (const entry of tickEntries){
+            size += TICK_HEADER_SIZE;
+            for (const rpc of entry.rpcs){
+                size += RPC_HEADER_SIZE + rpc.packedData.byteLength;
+            }
+        }
+        return size;
+    }
+    writeHeader(view, tickCount) {
+        let offset = 0;
+        view.setUint8(offset, RPC_HISTORY_FORMAT_VERSION);
+        offset += fieldTypeSizeBytes[FieldType.Uint8];
+        view.setUint32(offset, tickCount, LE);
+        offset += fieldTypeSizeBytes[FieldType.Uint32];
+        return offset;
+    }
+    writeTickEntries(view, uint8View, startOffset, tickEntries) {
+        let offset = startOffset;
+        for (const entry of tickEntries){
+            // Write tick header
+            view.setUint32(offset, entry.tick, LE);
+            offset += fieldTypeSizeBytes[FieldType.Uint32];
+            view.setUint16(offset, entry.rpcs.length, LE);
+            offset += fieldTypeSizeBytes[FieldType.Uint16];
+            // Write RPC entries
+            for (const rpc of entry.rpcs){
+                view.setUint32(offset, rpc.seq, LE);
+                offset += fieldTypeSizeBytes[FieldType.Uint32];
+                view.setUint8(offset, rpc.playerSlot);
+                offset += fieldTypeSizeBytes[FieldType.Uint8];
+                view.setUint16(offset, rpc.packedData.byteLength, LE);
+                offset += fieldTypeSizeBytes[FieldType.Uint16];
+                // Copy packed data
+                uint8View.set(new Uint8Array(rpc.packedData), offset);
+                offset += rpc.packedData.byteLength;
+            }
+        }
+        return offset;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Private: Import helpers
+    // ─────────────────────────────────────────────────────────────────────────
+    readHeader(view, offset) {
+        const version = view.getUint8(offset);
+        const tickCount = view.getUint32(offset + fieldTypeSizeBytes[FieldType.Uint8], LE);
+        return {
+            version,
+            tickCount
+        };
+    }
+    readTickEntry(view, buffer, startOffset, registry) {
+        let offset = startOffset;
+        // Read tick header
+        const tick = view.getUint32(offset, LE);
+        offset += fieldTypeSizeBytes[FieldType.Uint32];
+        const rpcCount = view.getUint16(offset, LE);
+        offset += fieldTypeSizeBytes[FieldType.Uint16];
+        const rpcs = [];
+        // Read RPC entries
+        for(let j = 0; j < rpcCount; j++){
+            const seq = view.getUint32(offset, LE);
+            offset += fieldTypeSizeBytes[FieldType.Uint32];
+            const playerSlot = view.getUint8(offset);
+            offset += fieldTypeSizeBytes[FieldType.Uint8];
+            const dataLength = view.getUint16(offset, LE);
+            offset += fieldTypeSizeBytes[FieldType.Uint16];
+            // Extract and unpack input data
+            const dataSlice = buffer.slice(offset, offset + dataLength);
+            offset += dataLength;
+            const unpacked = InputBinarySchema.unpackBatch(registry, dataSlice);
+            if (unpacked.length !== 1) {
+                throw new Error(`Invalid RPC data: expected 1 input, got ${unpacked.length} at tick ${tick}`);
+            }
+            const { inputId, ordinal, values } = unpacked[0];
+            rpcs.push(new RPC(inputId, {
+                tick,
+                seq,
+                ordinal,
+                playerSlot
+            }, values));
+        }
+        return {
+            tick,
+            rpcs,
+            nextOffset: offset
+        };
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Private: Sorting
+    // ─────────────────────────────────────────────────────────────────────────
+    /** Insert rpc into arr maintaining sorted order by (playerSlot, ordinal). */ insertSorted(arr, rpc) {
+        let i = arr.length;
+        while(i > 0 && compareRPCs(arr[i - 1], rpc) > 0){
+            i--;
+        }
+        arr.splice(i, 0, rpc);
+    }
+    constructor(){
+        this._history = new Map();
+    }
+}
+
+//# sourceMappingURL=rpc-history.js.map

package/dist/lib/input/rpc-history.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/input/rpc-history.ts"],"sourcesContent":["import { RPC } from './rpc.js';\nimport { IAbstractInputConstructor } from '../types/index.js';\nimport { InputRegistry } from './input-registry.js';\nimport { InputBinarySchema, FieldType, fieldTypeSizeBytes, LE } from '@lagless/binary';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Constants\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst RPC_HISTORY_FORMAT_VERSION = 1;\n\n/**\n * Binary format layout:\n *\n * [Header]\n *   version:   Uint8   (format version for forward compatibility)\n *   tickCount: Uint32  (number of unique ticks)\n *\n * [Per Tick Block] × tickCount\n *   tick:     Uint32  (tick number)\n *   rpcCount: Uint16  (number of RPCs for this tick)\n *\n * [Per RPC Entry] × rpcCount\n *   seq:        Uint32  (sequence number)\n *   playerSlot: Uint8   (player slot)\n *   dataLength: Uint16  (byte length of packed input data)\n *   data:       Uint8[] (InputBinarySchema packed data including inputId & ordinal)\n */\n\nconst HEADER_SIZE =\n  fieldTypeSizeBytes[FieldType.Uint8] +   // version\n  fieldTypeSizeBytes[FieldType.Uint32];   // tickCount\n\nconst TICK_HEADER_SIZE =\n  fieldTypeSizeBytes[FieldType.Uint32] +  // tick\n  fieldTypeSizeBytes[FieldType.Uint16];   // rpcCount\n\nconst RPC_HEADER_SIZE =\n  fieldTypeSizeBytes[FieldType.Uint32] +  // seq\n  fieldTypeSizeBytes[FieldType.Uint8] +   // playerSlot\n  fieldTypeSizeBytes[FieldType.Uint16];   // dataLength\n\nconst compareRPCs = (a: RPC, b: RPC): number =>\n  a.meta.playerSlot - b.meta.playerSlot\n  || a.meta.ordinal - b.meta.ordinal\n  || a.meta.seq - b.meta.seq;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// RPCHistory\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport class RPCHistory {\n  private readonly _history: Map<number, RPC[]> = new Map();\n\n  // ─────────────────────────────────────────────────────────────────────────\n  // Static utilities\n  // ─────────────────────────────────────────────────────────────────────────\n\n  public static excludeLocalRPCs(rpcs: ReadonlyArray<RPC>, localPlayerSlot: number): RPC[] {\n    return rpcs.filter((rpc) => rpc.meta.playerSlot !== localPlayerSlot);\n  }\n\n  // ─────────────────────────────────────────────────────────────────────────\n  // Public read/write methods\n  // ─────────────────────────────────────────────────────────────────────────\n\n  public addRPC(rpc: RPC): void {\n    let tickRPCs = this._history.get(rpc.meta.tick);\n    if (!tickRPCs) {\n      tickRPCs = [];\n      this._history.set(rpc.meta.tick, tickRPCs);\n    }\n    this.insertSorted(tickRPCs, rpc);\n  }\n\n  public addBatch(rpcs: ReadonlyArray<RPC>): void {\n    if (rpcs.length === 0) return;\n\n    // Group incoming RPCs by tick to minimize Map lookups and sorts\n    const perTick = new Map<number, RPC[]>();\n\n    for (const rpc of rpcs) {\n      let group = perTick.get(rpc.meta.tick);\n      if (!group) {\n        group = [];\n        perTick.set(rpc.meta.tick, group);\n      }\n      group.push(rpc);\n    }\n\n    // Merge per-tick groups into history and sort once per tick\n    for (const [tick, newRPCs] of perTick) {\n      const existing = this._history.get(tick);\n\n      if (!existing) {\n        newRPCs.sort(compareRPCs);\n        this._history.set(tick, newRPCs);\n      } else {\n        existing.push(...newRPCs);\n        existing.sort(compareRPCs);\n      }\n    }\n  }\n\n  /**\n   * Returns a new array of RPCs matching the given input type at the specified tick.\n   * Each call allocates a fresh array — safe to store and use across multiple calls.\n   */\n  public collectTickRPCs<TInputCtor extends IAbstractInputConstructor>(\n    tick: number,\n    InputCtor: TInputCtor\n  ): ReadonlyArray<RPC<InstanceType<TInputCtor>>> {\n    const rpcs = this._history.get(tick);\n    if (!rpcs) return [];\n\n    const result: RPC<InstanceType<TInputCtor>>[] = [];\n    for (const rpc of rpcs) {\n      if (rpc.inputId === InputCtor.id) {\n        result.push(rpc as RPC<InstanceType<TInputCtor>>);\n      }\n    }\n    return result;\n  }\n\n  public removePlayerInputsAtTick(playerSlot: number, tick: number, seq: number): void {\n    const tickRPCs = this._history.get(tick);\n    if (!tickRPCs || tickRPCs.length === 0) return;\n\n    let writeIndex = 0;\n    for (let readIndex = 0; readIndex < tickRPCs.length; readIndex++) {\n      const rpc = tickRPCs[readIndex];\n      if (!(rpc.meta.playerSlot === playerSlot && rpc.meta.seq === seq)) {\n        tickRPCs[writeIndex++] = rpc;\n      }\n    }\n\n    tickRPCs.length = writeIndex;\n\n    if (writeIndex === 0) {\n      this._history.delete(tick);\n    }\n  }\n\n  public clear(): void {\n    this._history.clear();\n  }\n\n  public get size(): number {\n    return this._history.size;\n  }\n\n  public get totalRPCCount(): number {\n    let count = 0;\n    for (const rpcs of this._history.values()) {\n      count += rpcs.length;\n    }\n    return count;\n  }\n\n  // ─────────────────────────────────────────────────────────────────────────\n  // Serialization\n  // ─────────────────────────────────────────────────────────────────────────\n\n  public debugExportAsJSON(): string {\n    const exportObj: Record<number, Array<{\n      inputId: number;\n      seq: number;\n      playerSlot: number;\n      ordinal: number;\n      data: unknown;\n    }>> = {};\n\n    for (const [tick, rpcs] of this._history) {\n      exportObj[tick] = rpcs.map((rpc) => ({\n        inputId: rpc.inputId,\n        seq: rpc.meta.seq,\n        playerSlot: rpc.meta.playerSlot,\n        ordinal: rpc.meta.ordinal,\n        data: rpc.data,\n      }));\n    }\n\n    return JSON.stringify(exportObj, null, 2);\n  }\n\n  /**\n   * Exports entire history to a compact binary format.\n   * @param registry - InputRegistry for serializing input data\n   * @returns ArrayBuffer containing serialized history\n   */\n  public export(registry: InputRegistry): ArrayBuffer {\n    // First pass: pack all RPC data and calculate total size\n    const tickEntries = this.prepareExportData(registry);\n    const totalSize = this.calculateExportSize(tickEntries);\n\n    // Second pass: write to buffer\n    const buffer = new ArrayBuffer(totalSize);\n    const view = new DataView(buffer);\n    const uint8View = new Uint8Array(buffer);\n\n    const offset = this.writeHeader(view, tickEntries.length);\n    this.writeTickEntries(view, uint8View, offset, tickEntries);\n\n    return buffer;\n  }\n\n  /**\n   * Imports history from binary format, replacing current content.\n   * @param registry - InputRegistry for deserializing input data\n   * @param buffer - ArrayBuffer containing serialized history\n   */\n  public import(registry: InputRegistry, buffer: ArrayBuffer): void {\n    const view = new DataView(buffer);\n    let offset = 0;\n\n    // Validate and read header\n    const { version, tickCount } = this.readHeader(view, offset);\n    offset += HEADER_SIZE;\n\n    if (version !== RPC_HISTORY_FORMAT_VERSION) {\n      throw new Error(\n        `Unsupported RPCHistory format version: ${version} (expected ${RPC_HISTORY_FORMAT_VERSION})`\n      );\n    }\n\n    // Clear existing data and read all ticks\n    this._history.clear();\n\n    for (let i = 0; i < tickCount; i++) {\n      const result = this.readTickEntry(view, buffer, offset, registry);\n      offset = result.nextOffset;\n\n      if (result.rpcs.length > 0) {\n        result.rpcs.sort(compareRPCs);\n        this._history.set(result.tick, result.rpcs);\n      }\n    }\n  }\n\n  // ─────────────────────────────────────────────────────────────────────────\n  // Private: Export helpers\n  // ─────────────────────────────────────────────────────────────────────────\n\n  private prepareExportData(registry: InputRegistry): ExportTickEntry[] {\n    const entries: ExportTickEntry[] = [];\n\n    for (const [tick, rpcs] of this._history) {\n      const rpcEntries: ExportRPCEntry[] = [];\n\n      for (const rpc of rpcs) {\n        const packedData = InputBinarySchema.packBatch(registry, [{\n          inputId: rpc.inputId,\n          ordinal: rpc.meta.ordinal,\n          values: rpc.data,\n        }]);\n\n        rpcEntries.push({\n          seq: rpc.meta.seq,\n          playerSlot: rpc.meta.playerSlot,\n          packedData,\n        });\n      }\n\n      entries.push({ tick, rpcs: rpcEntries });\n    }\n\n    // Sort by tick for deterministic output\n    entries.sort((a, b) => a.tick - b.tick);\n\n    return entries;\n  }\n\n  private calculateExportSize(tickEntries: ExportTickEntry[]): number {\n    let size = HEADER_SIZE;\n\n    for (const entry of tickEntries) {\n      size += TICK_HEADER_SIZE;\n      for (const rpc of entry.rpcs) {\n        size += RPC_HEADER_SIZE + rpc.packedData.byteLength;\n      }\n    }\n\n    return size;\n  }\n\n  private writeHeader(view: DataView, tickCount: number): number {\n    let offset = 0;\n\n    view.setUint8(offset, RPC_HISTORY_FORMAT_VERSION);\n    offset += fieldTypeSizeBytes[FieldType.Uint8];\n\n    view.setUint32(offset, tickCount, LE);\n    offset += fieldTypeSizeBytes[FieldType.Uint32];\n\n    return offset;\n  }\n\n  private writeTickEntries(\n    view: DataView,\n    uint8View: Uint8Array,\n    startOffset: number,\n    tickEntries: ExportTickEntry[]\n  ): number {\n    let offset = startOffset;\n\n    for (const entry of tickEntries) {\n      // Write tick header\n      view.setUint32(offset, entry.tick, LE);\n      offset += fieldTypeSizeBytes[FieldType.Uint32];\n\n      view.setUint16(offset, entry.rpcs.length, LE);\n      offset += fieldTypeSizeBytes[FieldType.Uint16];\n\n      // Write RPC entries\n      for (const rpc of entry.rpcs) {\n        view.setUint32(offset, rpc.seq, LE);\n        offset += fieldTypeSizeBytes[FieldType.Uint32];\n\n        view.setUint8(offset, rpc.playerSlot);\n        offset += fieldTypeSizeBytes[FieldType.Uint8];\n\n        view.setUint16(offset, rpc.packedData.byteLength, LE);\n        offset += fieldTypeSizeBytes[FieldType.Uint16];\n\n        // Copy packed data\n        uint8View.set(new Uint8Array(rpc.packedData), offset);\n        offset += rpc.packedData.byteLength;\n      }\n    }\n\n    return offset;\n  }\n\n  // ─────────────────────────────────────────────────────────────────────────\n  // Private: Import helpers\n  // ─────────────────────────────────────────────────────────────────────────\n\n  private readHeader(view: DataView, offset: number): { version: number; tickCount: number } {\n    const version = view.getUint8(offset);\n    const tickCount = view.getUint32(offset + fieldTypeSizeBytes[FieldType.Uint8], LE);\n    return { version, tickCount };\n  }\n\n  private readTickEntry(\n    view: DataView,\n    buffer: ArrayBuffer,\n    startOffset: number,\n    registry: InputRegistry\n  ): { tick: number; rpcs: RPC[]; nextOffset: number } {\n    let offset = startOffset;\n\n    // Read tick header\n    const tick = view.getUint32(offset, LE);\n    offset += fieldTypeSizeBytes[FieldType.Uint32];\n\n    const rpcCount = view.getUint16(offset, LE);\n    offset += fieldTypeSizeBytes[FieldType.Uint16];\n\n    const rpcs: RPC[] = [];\n\n    // Read RPC entries\n    for (let j = 0; j < rpcCount; j++) {\n      const seq = view.getUint32(offset, LE);\n      offset += fieldTypeSizeBytes[FieldType.Uint32];\n\n      const playerSlot = view.getUint8(offset);\n      offset += fieldTypeSizeBytes[FieldType.Uint8];\n\n      const dataLength = view.getUint16(offset, LE);\n      offset += fieldTypeSizeBytes[FieldType.Uint16];\n\n      // Extract and unpack input data\n      const dataSlice = buffer.slice(offset, offset + dataLength);\n      offset += dataLength;\n\n      const unpacked = InputBinarySchema.unpackBatch(registry, dataSlice);\n\n      if (unpacked.length !== 1) {\n        throw new Error(\n          `Invalid RPC data: expected 1 input, got ${unpacked.length} at tick ${tick}`\n        );\n      }\n\n      const { inputId, ordinal, values } = unpacked[0];\n      rpcs.push(new RPC(inputId, { tick, seq, ordinal, playerSlot }, values));\n    }\n\n    return { tick, rpcs, nextOffset: offset };\n  }\n\n  // ─────────────────────────────────────────────────────────────────────────\n  // Private: Sorting\n  // ─────────────────────────────────────────────────────────────────────────\n\n  /** Insert rpc into arr maintaining sorted order by (playerSlot, ordinal). */\n  private insertSorted(arr: RPC[], rpc: RPC): void {\n    let i = arr.length;\n    while (i > 0 && compareRPCs(arr[i - 1], rpc) > 0) {\n      i--;\n    }\n    arr.splice(i, 0, rpc);\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Internal types\n// ─────────────────────────────────────────────────────────────────────────────\n\ninterface ExportRPCEntry {\n  readonly seq: number;\n  readonly playerSlot: number;\n  readonly packedData: ArrayBuffer;\n}\n\ninterface ExportTickEntry {\n  readonly tick: number;\n  readonly rpcs: ExportRPCEntry[];\n}\n"],"names":["RPC","InputBinarySchema","FieldType","fieldTypeSizeBytes","LE","RPC_HISTORY_FORMAT_VERSION","HEADER_SIZE","Uint8","Uint32","TICK_HEADER_SIZE","Uint16","RPC_HEADER_SIZE","compareRPCs","a","b","meta","playerSlot","ordinal","seq","RPCHistory","excludeLocalRPCs","rpcs","localPlayerSlot","filter","rpc","addRPC","tickRPCs","_history","get","tick","set","insertSorted","addBatch","length","perTick","Map","group","push","newRPCs","existing","sort","collectTickRPCs","InputCtor","result","inputId","id","removePlayerInputsAtTick","writeIndex","readIndex","delete","clear","size","totalRPCCount","count","values","debugExportAsJSON","exportObj","map","data","JSON","stringify","export","registry","tickEntries","prepareExportData","totalSize","calculateExportSize","buffer","ArrayBuffer","view","DataView","uint8View","Uint8Array","offset","writeHeader","writeTickEntries","import","version","tickCount","readHeader","Error","i","readTickEntry","nextOffset","entries","rpcEntries","packedData","packBatch","entry","byteLength","setUint8","setUint32","startOffset","setUint16","getUint8","getUint32","rpcCount","getUint16","j","dataLength","dataSlice","slice","unpacked","unpackBatch","arr","splice"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/lib/input/rpc.d.ts

@@ -0,0 +1,8 @@
+import { IAbstractInput, InputData, InputMeta } from '../types/index.js';
+export declare class RPC<TInput extends IAbstractInput = IAbstractInput> {
+    readonly inputId: IAbstractInput['id'];
+    readonly meta: InputMeta;
+    readonly data: InputData<TInput>;
+    constructor(inputId: IAbstractInput['id'], meta: InputMeta, data: InputData<TInput>);
+}
+//# sourceMappingURL=rpc.d.ts.map

package/dist/lib/input/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../../src/lib/input/rpc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEzE,qBAAa,GAAG,CAAC,MAAM,SAAS,cAAc,GAAG,cAAc;aAE3C,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC;aAC7B,IAAI,EAAE,SAAS;aACf,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC;gBAFvB,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,EAC7B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC;CAG1C"}

package/dist/lib/input/rpc.js

@@ -0,0 +1,9 @@
+export class RPC {
+    constructor(inputId, meta, data){
+        this.inputId = inputId;
+        this.meta = meta;
+        this.data = data;
+    }
+}
+
+//# sourceMappingURL=rpc.js.map

package/dist/lib/input/rpc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/input/rpc.ts"],"sourcesContent":["import { IAbstractInput, InputData, InputMeta } from '../types/index.js';\n\nexport class RPC<TInput extends IAbstractInput = IAbstractInput> {\n  constructor(\n    public readonly inputId: IAbstractInput['id'],\n    public readonly meta: InputMeta,\n    public readonly data: InputData<TInput>,\n  ) {\n  }\n}\n"],"names":["RPC","constructor","inputId","meta","data"],"rangeMappings":";;;;;;","mappings":"AAEA,OAAO,MAAMA;IACXC,YACE,AAAgBC,OAA6B,EAC7C,AAAgBC,IAAe,EAC/B,AAAgBC,IAAuB,CACvC;aAHgBF,UAAAA;aACAC,OAAAA;aACAC,OAAAA;IAElB;AACF"}

package/dist/lib/mem/abstract-memory.interface.d.ts

@@ -0,0 +1,6 @@
+import { MemoryTracker } from '@lagless/binary';
+export interface IAbstractMemory {
+    init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void;
+    calculateSize(tracker: MemoryTracker): void;
+}
+//# sourceMappingURL=abstract-memory.interface.d.ts.map

package/dist/lib/mem/abstract-memory.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-memory.interface.d.ts","sourceRoot":"","sources":["../../../src/lib/mem/abstract-memory.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;IAC7D,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;CAC7C"}

package/dist/lib/mem/abstract-memory.interface.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=abstract-memory.interface.js.map

package/dist/lib/mem/abstract-memory.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/mem/abstract-memory.interface.ts"],"sourcesContent":["import { MemoryTracker } from '@lagless/binary';\n\nexport interface IAbstractMemory {\n  init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void;\n  calculateSize(tracker: MemoryTracker): void;\n}\n"],"names":[],"rangeMappings":"","mappings":"AAEA,WAGC"}

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

@@ -0,0 +1,5 @@
+export * from './mem.js';
+export * from './managers/prng-manager.js';
+export * from './managers/entities-manager.js';
+export * from './managers/player-resources-manager.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/mem/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wCAAwC,CAAC"}

package/dist/lib/mem/index.js

@@ -0,0 +1,6 @@
+export * from './mem.js';
+export * from './managers/prng-manager.js';
+export * from './managers/entities-manager.js';
+export * from './managers/player-resources-manager.js';
+
+//# sourceMappingURL=index.js.map

package/dist/lib/mem/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/mem/index.ts"],"sourcesContent":["export * from './mem.js';\nexport * from './managers/prng-manager.js';\nexport * from './managers/entities-manager.js';\nexport * from './managers/player-resources-manager.js';\n"],"names":[],"rangeMappings":";;;","mappings":"AAAA,cAAc,WAAW;AACzB,cAAc,6BAA6B;AAC3C,cAAc,iCAAiC;AAC/C,cAAc,yCAAyC"}

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

@@ -0,0 +1,15 @@
+import { IAbstractMemory } from '../abstract-memory.interface.js';
+import { ECSConfig } from '../../ecs-config.js';
+import { ECSDeps, IComponentConstructor, IComponentInstance } from '../../types/index.js';
+import { MemoryTracker } from '@lagless/binary';
+export declare class ComponentsManager implements IAbstractMemory {
+    private readonly _ECSConfig;
+    private readonly _ECSDeps;
+    private readonly _componentsInstances;
+    constructor(_ECSConfig: ECSConfig, _ECSDeps: ECSDeps);
+    init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void;
+    calculateSize(tracker: MemoryTracker): void;
+    get<Ctor extends IComponentConstructor>(ComponentConstructor: Ctor): InstanceType<Ctor>;
+    [Symbol.iterator](): MapIterator<[IComponentConstructor, IComponentInstance]>;
+}
+//# sourceMappingURL=components-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"components-manager.d.ts","sourceRoot":"","sources":["../../../../src/lib/mem/managers/components-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,qBAAa,iBAAkB,YAAW,eAAe;IAG3C,OAAO,CAAC,QAAQ,CAAC,UAAU;IAAa,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAF7E,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAwD;gBAEhE,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,IAAI,SAAS,qBAAqB,EAAE,oBAAoB,EAAE,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC;IAQvF,CAAC,MAAM,CAAC,QAAQ,CAAC;CAGzB"}

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

@@ -0,0 +1,30 @@
+export class ComponentsManager {
+    init(arrayBuffer, tracker) {
+        for (const ComponentConstructor of this._ECSDeps.components){
+            const componentInstance = new ComponentConstructor(this._ECSConfig.maxEntities, arrayBuffer, tracker);
+            this._componentsInstances.set(ComponentConstructor, componentInstance);
+        }
+    }
+    calculateSize(tracker) {
+        for (const ComponentDefinition of this._ECSDeps.components){
+            ComponentDefinition.calculateSize(this._ECSConfig.maxEntities, tracker);
+        }
+    }
+    get(ComponentConstructor) {
+        const componentInstance = this._componentsInstances.get(ComponentConstructor);
+        if (!componentInstance) {
+            throw new Error(`Component ${ComponentConstructor.name} not found`);
+        }
+        return componentInstance;
+    }
+    [Symbol.iterator]() {
+        return this._componentsInstances.entries();
+    }
+    constructor(_ECSConfig, _ECSDeps){
+        this._ECSConfig = _ECSConfig;
+        this._ECSDeps = _ECSDeps;
+        this._componentsInstances = new Map();
+    }
+}
+
+//# sourceMappingURL=components-manager.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/mem/managers/components-manager.ts"],"sourcesContent":["import { IAbstractMemory } from '../abstract-memory.interface.js';\nimport { ECSConfig } from '../../ecs-config.js';\nimport { ECSDeps, IComponentConstructor, IComponentInstance } from '../../types/index.js';\nimport { MemoryTracker } from '@lagless/binary';\n\nexport class ComponentsManager implements IAbstractMemory {\n  private readonly _componentsInstances = new Map<IComponentConstructor, IComponentInstance>();\n\n  constructor(private readonly _ECSConfig: ECSConfig, private readonly _ECSDeps: ECSDeps) {}\n\n  public init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void {\n    for (const ComponentConstructor of this._ECSDeps.components) {\n      const componentInstance = new ComponentConstructor(this._ECSConfig.maxEntities, arrayBuffer, tracker);\n      this._componentsInstances.set(ComponentConstructor, componentInstance);\n    }\n  }\n\n  public calculateSize(tracker: MemoryTracker): void {\n    for (const ComponentDefinition of this._ECSDeps.components) {\n      ComponentDefinition.calculateSize(this._ECSConfig.maxEntities, tracker);\n    }\n  }\n\n  public get<Ctor extends IComponentConstructor>(ComponentConstructor: Ctor): InstanceType<Ctor> {\n    const componentInstance = this._componentsInstances.get(ComponentConstructor);\n    if (!componentInstance) {\n      throw new Error(`Component ${ComponentConstructor.name} not found`);\n    }\n    return componentInstance as InstanceType<Ctor>;\n  }\n\n  public [Symbol.iterator]() {\n    return this._componentsInstances.entries();\n  }\n}\n"],"names":["ComponentsManager","init","arrayBuffer","tracker","ComponentConstructor","_ECSDeps","components","componentInstance","_ECSConfig","maxEntities","_componentsInstances","set","calculateSize","ComponentDefinition","get","Error","name","Symbol","iterator","entries","constructor","Map"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAKA,OAAO,MAAMA;IAKJC,KAAKC,WAAwB,EAAEC,OAAsB,EAAQ;QAClE,KAAK,MAAMC,wBAAwB,IAAI,CAACC,QAAQ,CAACC,UAAU,CAAE;YAC3D,MAAMC,oBAAoB,IAAIH,qBAAqB,IAAI,CAACI,UAAU,CAACC,WAAW,EAAEP,aAAaC;YAC7F,IAAI,CAACO,oBAAoB,CAACC,GAAG,CAACP,sBAAsBG;QACtD;IACF;IAEOK,cAAcT,OAAsB,EAAQ;QACjD,KAAK,MAAMU,uBAAuB,IAAI,CAACR,QAAQ,CAACC,UAAU,CAAE;YAC1DO,oBAAoBD,aAAa,CAAC,IAAI,CAACJ,UAAU,CAACC,WAAW,EAAEN;QACjE;IACF;IAEOW,IAAwCV,oBAA0B,EAAsB;QAC7F,MAAMG,oBAAoB,IAAI,CAACG,oBAAoB,CAACI,GAAG,CAACV;QACxD,IAAI,CAACG,mBAAmB;YACtB,MAAM,IAAIQ,MAAM,CAAC,UAAU,EAAEX,qBAAqBY,IAAI,CAAC,UAAU,CAAC;QACpE;QACA,OAAOT;IACT;IAEO,CAACU,OAAOC,QAAQ,CAAC,GAAG;QACzB,OAAO,IAAI,CAACR,oBAAoB,CAACS,OAAO;IAC1C;IAzBAC,YAAY,AAAiBZ,UAAqB,EAAE,AAAiBH,QAAiB,CAAE;aAA3DG,aAAAA;aAAwCH,WAAAA;aAFpDK,uBAAuB,IAAIW;IAE6C;AA0B3F"}

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

@@ -0,0 +1,31 @@
+import { FiltersManager } from './filters-manager.js';
+import { ComponentsManager } from './components-manager.js';
+import { IAbstractMemory } from '../abstract-memory.interface.js';
+import { ECSConfig } from '../../ecs-config.js';
+import { Prefab } from '../../prefab.js';
+import { IComponentConstructor } from '../../types/index.js';
+import { MemoryTracker } from '@lagless/binary';
+/** Sentinel value indicating an entity slot is unused / removed. */
+export declare const ENTITY_REMOVED_MASK = 4294967295;
+export declare class EntitiesManager implements IAbstractMemory {
+    private readonly _ECSConfig;
+    private readonly _ComponentsMemory;
+    private readonly _FiltersMemory;
+    private _nextEntityId;
+    private _removedEntitiesLength;
+    private _removedEntities;
+    private _entitiesComponentsMasks;
+    constructor(_ECSConfig: ECSConfig, _ComponentsMemory: ComponentsManager, _FiltersMemory: FiltersManager);
+    createEntity(prefab?: Prefab): number;
+    removeEntity(entity: number): void;
+    isEntityAlive(entity: number): boolean;
+    addComponent(entity: number, ComponentConstructor: IComponentConstructor): void;
+    removeComponent(entity: number, ComponentConstructor: IComponentConstructor): void;
+    hasComponent(entity: number, ComponentConstructor: IComponentConstructor): boolean;
+    hasPrefab(entity: number, prefab: Prefab): boolean;
+    private updateFilters;
+    private popRemovedEntities;
+    init(arrayBuffer: ArrayBuffer, tracker: MemoryTracker): void;
+    calculateSize(tracker: MemoryTracker): void;
+}
+//# sourceMappingURL=entities-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entities-manager.d.ts","sourceRoot":"","sources":["../../../../src/lib/mem/managers/entities-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,oEAAoE;AACpE,eAAO,MAAM,mBAAmB,aAAa,CAAC;AAE9C,qBAAa,eAAgB,YAAW,eAAe;IAOnD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,cAAc;IARjC,OAAO,CAAC,aAAa,CAAe;IACpC,OAAO,CAAC,sBAAsB,CAAe;IAC7C,OAAO,CAAC,gBAAgB,CAAe;IACvC,OAAO,CAAC,wBAAwB,CAAe;gBAG5B,UAAU,EAAE,SAAS,EACrB,iBAAiB,EAAE,iBAAiB,EACpC,cAAc,EAAE,cAAc;IAG1C,YAAY,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM;IA6BrC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAmBlC,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAKtC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,oBAAoB,EAAE,qBAAqB,GAAG,IAAI;IAK/E,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,oBAAoB,EAAE,qBAAqB,GAAG,IAAI;IAKlF,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,oBAAoB,EAAE,qBAAqB,GAAG,OAAO;IAOlF,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAUzD,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,kBAAkB;IAWnB,IAAI,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAe5D,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;CAMnD"}