@lagless/core 0.0.33

package/dist/lib/hash-verification/abstract-hash-verification.system.d.ts

@@ -0,0 +1,32 @@
+import type { IECSSystem, IAbstractInputConstructor, IPlayerResourceConstructor } from '../types/index.js';
+import type { ECSConfig } from '../ecs-config.js';
+import type { AbstractInputProvider } from '../input/abstract-input-provider.js';
+import type { PlayerResources } from '../mem/managers/player-resources-manager.js';
+import type { DivergenceSignal } from './divergence.signal.js';
+/**
+ * Abstract base class for ECS hash verification systems.
+ *
+ * Subclass this in your game simulation and provide the concrete
+ * `_reportHashRpc` and `_playerResourceClass` from your codegen.
+ *
+ * The subclass must use `@ECSSystem()` decorator and declare constructor
+ * params for DI injection matching the base constructor signature.
+ */
+export declare abstract class AbstractHashVerificationSystem implements IECSSystem {
+    protected readonly _ECSConfig: ECSConfig;
+    protected readonly _InputProvider: AbstractInputProvider;
+    protected readonly _PlayerResources: PlayerResources;
+    protected readonly _DivergenceSignal: DivergenceSignal;
+    constructor(_ECSConfig: ECSConfig, _InputProvider: AbstractInputProvider, _PlayerResources: PlayerResources, _DivergenceSignal: DivergenceSignal);
+    /**
+     * The codegen-generated ReportHash input constructor.
+     * Must have `{ readonly id: number }` and conform to `IAbstractInputConstructor`.
+     */
+    protected abstract readonly _reportHashRpc: IAbstractInputConstructor;
+    /**
+     * The codegen-generated PlayerResource class constructor.
+     */
+    protected abstract readonly _playerResourceClass: IPlayerResourceConstructor;
+    update(tick: number): void;
+}
+//# sourceMappingURL=abstract-hash-verification.system.d.ts.map

package/dist/lib/hash-verification/abstract-hash-verification.system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-hash-verification.system.d.ts","sourceRoot":"","sources":["../../../src/lib/hash-verification/abstract-hash-verification.system.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC3G,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6CAA6C,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAY/D;;;;;;;;GAQG;AACH,8BAAsB,8BAA+B,YAAW,UAAU;IAEtE,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,SAAS;IACxC,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,qBAAqB;IACxD,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,eAAe;IACpD,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,gBAAgB;gBAHnC,UAAU,EAAE,SAAS,EACrB,cAAc,EAAE,qBAAqB,EACrC,gBAAgB,EAAE,eAAe,EACjC,iBAAiB,EAAE,gBAAgB;IAGxD;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,cAAc,EAAE,yBAAyB,CAAC;IAEtE;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,oBAAoB,EAAE,0BAA0B,CAAC;IAEtE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAqClC"}

package/dist/lib/hash-verification/abstract-hash-verification.system.js

@@ -0,0 +1,49 @@
+/**
+ * Abstract base class for ECS hash verification systems.
+ *
+ * Subclass this in your game simulation and provide the concrete
+ * `_reportHashRpc` and `_playerResourceClass` from your codegen.
+ *
+ * The subclass must use `@ECSSystem()` decorator and declare constructor
+ * params for DI injection matching the base constructor signature.
+ */ export class AbstractHashVerificationSystem {
+    update(tick) {
+        const rpcs = this._InputProvider.collectTickRPCs(tick, this._reportHashRpc);
+        for (const rpc of rpcs){
+            const playerResource = this._PlayerResources.get(this._playerResourceClass, rpc.meta.playerSlot);
+            const safe = playerResource.safe;
+            safe.lastReportedHash = rpc.data.hash;
+            safe.lastReportedHashTick = rpc.data.atTick;
+        }
+        const maxPlayers = this._ECSConfig.maxPlayers;
+        for(let a = 0; a < maxPlayers; a++){
+            const pa = this._PlayerResources.get(this._playerResourceClass, a);
+            const safeA = pa.safe;
+            if (safeA.connected === 0 || safeA.lastReportedHashTick === 0) continue;
+            for(let b = a + 1; b < maxPlayers; b++){
+                const pb = this._PlayerResources.get(this._playerResourceClass, b);
+                const safeB = pb.safe;
+                if (safeB.connected === 0 || safeB.lastReportedHashTick === 0) continue;
+                if (safeA.lastReportedHashTick === safeB.lastReportedHashTick && safeA.lastReportedHash !== safeB.lastReportedHash) {
+                    safeA.hashMismatchCount++;
+                    safeB.hashMismatchCount++;
+                    this._DivergenceSignal.emit(tick, {
+                        slotA: a,
+                        slotB: b,
+                        hashA: safeA.lastReportedHash,
+                        hashB: safeB.lastReportedHash,
+                        atTick: safeA.lastReportedHashTick
+                    });
+                }
+            }
+        }
+    }
+    constructor(_ECSConfig, _InputProvider, _PlayerResources, _DivergenceSignal){
+        this._ECSConfig = _ECSConfig;
+        this._InputProvider = _InputProvider;
+        this._PlayerResources = _PlayerResources;
+        this._DivergenceSignal = _DivergenceSignal;
+    }
+}
+
+//# sourceMappingURL=abstract-hash-verification.system.js.map

package/dist/lib/hash-verification/abstract-hash-verification.system.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/hash-verification/abstract-hash-verification.system.ts"],"sourcesContent":["import type { IECSSystem, IAbstractInputConstructor, IPlayerResourceConstructor } from '../types/index.js';\nimport type { ECSConfig } from '../ecs-config.js';\nimport type { AbstractInputProvider } from '../input/abstract-input-provider.js';\nimport type { PlayerResources } from '../mem/managers/player-resources-manager.js';\nimport type { DivergenceSignal } from './divergence.signal.js';\n\n/**\n * Minimum fields that a PlayerResource must expose for hash verification.\n */\ninterface HashPlayerResourceProxy {\n  connected: number;\n  lastReportedHash: number;\n  lastReportedHashTick: number;\n  hashMismatchCount: number;\n}\n\n/**\n * Abstract base class for ECS hash verification systems.\n *\n * Subclass this in your game simulation and provide the concrete\n * `_reportHashRpc` and `_playerResourceClass` from your codegen.\n *\n * The subclass must use `@ECSSystem()` decorator and declare constructor\n * params for DI injection matching the base constructor signature.\n */\nexport abstract class AbstractHashVerificationSystem implements IECSSystem {\n  constructor(\n    protected readonly _ECSConfig: ECSConfig,\n    protected readonly _InputProvider: AbstractInputProvider,\n    protected readonly _PlayerResources: PlayerResources,\n    protected readonly _DivergenceSignal: DivergenceSignal,\n  ) {}\n\n  /**\n   * The codegen-generated ReportHash input constructor.\n   * Must have `{ readonly id: number }` and conform to `IAbstractInputConstructor`.\n   */\n  protected abstract readonly _reportHashRpc: IAbstractInputConstructor;\n\n  /**\n   * The codegen-generated PlayerResource class constructor.\n   */\n  protected abstract readonly _playerResourceClass: IPlayerResourceConstructor;\n\n  public update(tick: number): void {\n    const rpcs = this._InputProvider.collectTickRPCs(tick, this._reportHashRpc) as unknown as Array<{ meta: { playerSlot: number }, data: { hash: number, atTick: number } }>;\n\n    for (const rpc of rpcs) {\n      const playerResource = this._PlayerResources.get(this._playerResourceClass, rpc.meta.playerSlot) as unknown as { safe: HashPlayerResourceProxy };\n      const safe = playerResource.safe as HashPlayerResourceProxy;\n      safe.lastReportedHash = rpc.data.hash;\n      safe.lastReportedHashTick = rpc.data.atTick;\n    }\n\n    const maxPlayers = this._ECSConfig.maxPlayers;\n    for (let a = 0; a < maxPlayers; a++) {\n      const pa = this._PlayerResources.get(this._playerResourceClass, a) as unknown as { safe: HashPlayerResourceProxy };\n      const safeA = pa.safe as HashPlayerResourceProxy;\n      if (safeA.connected === 0 || safeA.lastReportedHashTick === 0) continue;\n\n      for (let b = a + 1; b < maxPlayers; b++) {\n        const pb = this._PlayerResources.get(this._playerResourceClass, b) as unknown as { safe: HashPlayerResourceProxy };\n        const safeB = pb.safe as HashPlayerResourceProxy;\n        if (safeB.connected === 0 || safeB.lastReportedHashTick === 0) continue;\n\n        if (safeA.lastReportedHashTick === safeB.lastReportedHashTick &&\n          safeA.lastReportedHash !== safeB.lastReportedHash) {\n          safeA.hashMismatchCount++;\n          safeB.hashMismatchCount++;\n\n          this._DivergenceSignal.emit(tick, {\n            slotA: a,\n            slotB: b,\n            hashA: safeA.lastReportedHash,\n            hashB: safeB.lastReportedHash,\n            atTick: safeA.lastReportedHashTick,\n          });\n        }\n      }\n    }\n  }\n}\n"],"names":["AbstractHashVerificationSystem","update","tick","rpcs","_InputProvider","collectTickRPCs","_reportHashRpc","rpc","playerResource","_PlayerResources","get","_playerResourceClass","meta","playerSlot","safe","lastReportedHash","data","hash","lastReportedHashTick","atTick","maxPlayers","_ECSConfig","a","pa","safeA","connected","b","pb","safeB","hashMismatchCount","_DivergenceSignal","emit","slotA","slotB","hashA","hashB","constructor"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAgBA;;;;;;;;CAQC,GACD,OAAO,MAAeA;IAmBbC,OAAOC,IAAY,EAAQ;QAChC,MAAMC,OAAO,IAAI,CAACC,cAAc,CAACC,eAAe,CAACH,MAAM,IAAI,CAACI,cAAc;QAE1E,KAAK,MAAMC,OAAOJ,KAAM;YACtB,MAAMK,iBAAiB,IAAI,CAACC,gBAAgB,CAACC,GAAG,CAAC,IAAI,CAACC,oBAAoB,EAAEJ,IAAIK,IAAI,CAACC,UAAU;YAC/F,MAAMC,OAAON,eAAeM,IAAI;YAChCA,KAAKC,gBAAgB,GAAGR,IAAIS,IAAI,CAACC,IAAI;YACrCH,KAAKI,oBAAoB,GAAGX,IAAIS,IAAI,CAACG,MAAM;QAC7C;QAEA,MAAMC,aAAa,IAAI,CAACC,UAAU,CAACD,UAAU;QAC7C,IAAK,IAAIE,IAAI,GAAGA,IAAIF,YAAYE,IAAK;YACnC,MAAMC,KAAK,IAAI,CAACd,gBAAgB,CAACC,GAAG,CAAC,IAAI,CAACC,oBAAoB,EAAEW;YAChE,MAAME,QAAQD,GAAGT,IAAI;YACrB,IAAIU,MAAMC,SAAS,KAAK,KAAKD,MAAMN,oBAAoB,KAAK,GAAG;YAE/D,IAAK,IAAIQ,IAAIJ,IAAI,GAAGI,IAAIN,YAAYM,IAAK;gBACvC,MAAMC,KAAK,IAAI,CAAClB,gBAAgB,CAACC,GAAG,CAAC,IAAI,CAACC,oBAAoB,EAAEe;gBAChE,MAAME,QAAQD,GAAGb,IAAI;gBACrB,IAAIc,MAAMH,SAAS,KAAK,KAAKG,MAAMV,oBAAoB,KAAK,GAAG;gBAE/D,IAAIM,MAAMN,oBAAoB,KAAKU,MAAMV,oBAAoB,IAC3DM,MAAMT,gBAAgB,KAAKa,MAAMb,gBAAgB,EAAE;oBACnDS,MAAMK,iBAAiB;oBACvBD,MAAMC,iBAAiB;oBAEvB,IAAI,CAACC,iBAAiB,CAACC,IAAI,CAAC7B,MAAM;wBAChC8B,OAAOV;wBACPW,OAAOP;wBACPQ,OAAOV,MAAMT,gBAAgB;wBAC7BoB,OAAOP,MAAMb,gBAAgB;wBAC7BI,QAAQK,MAAMN,oBAAoB;oBACpC;gBACF;YACF;QACF;IACF;IAtDAkB,YACE,AAAmBf,UAAqB,EACxC,AAAmBjB,cAAqC,EACxD,AAAmBK,gBAAiC,EACpD,AAAmBqB,iBAAmC,CACtD;aAJmBT,aAAAA;aACAjB,iBAAAA;aACAK,mBAAAA;aACAqB,oBAAAA;IAClB;AAkDL"}

package/dist/lib/hash-verification/create-hash-reporter.d.ts

@@ -0,0 +1,16 @@
+import type { ECSRunner } from '../ecs-runner.js';
+import type { IAbstractInputConstructor, InputData } from '../types/index.js';
+type AddRPCFn = <TInputCtor extends IAbstractInputConstructor>(InputCtor: TInputCtor, data: InputData<InstanceType<TInputCtor>>) => void;
+export interface HashReporterConfig {
+    reportInterval: number;
+    reportHashRpc: IAbstractInputConstructor;
+}
+/**
+ * Creates a hash reporter function for use in `drainInputs`.
+ *
+ * The returned function should be called from your `drainInputs` callback.
+ * It periodically reports the simulation state hash via the ReportHash RPC.
+ */
+export declare function createHashReporter(runner: ECSRunner, config: HashReporterConfig): (addRPC: AddRPCFn) => void;
+export {};
+//# sourceMappingURL=create-hash-reporter.d.ts.map

package/dist/lib/hash-verification/create-hash-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-hash-reporter.d.ts","sourceRoot":"","sources":["../../../src/lib/hash-verification/create-hash-reporter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,yBAAyB,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9E,KAAK,QAAQ,GAAG,CAAC,UAAU,SAAS,yBAAyB,EAC3D,SAAS,EAAE,UAAU,EACrB,IAAI,EAAE,SAAS,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,KACtC,IAAI,CAAC;AAEV,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,yBAAyB,CAAC;CAC1C;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,kBAAkB,GAAG,CAAC,MAAM,EAAE,QAAQ,KAAK,IAAI,CAe5G"}

package/dist/lib/hash-verification/create-hash-reporter.js

@@ -0,0 +1,21 @@
+/**
+ * Creates a hash reporter function for use in `drainInputs`.
+ *
+ * The returned function should be called from your `drainInputs` callback.
+ * It periodically reports the simulation state hash via the ReportHash RPC.
+ */ export function createHashReporter(runner, config) {
+    let lastReportedTick = -1;
+    return (addRPC)=>{
+        const currentTick = runner.Simulation.tick;
+        if (currentTick > 0 && currentTick % config.reportInterval === 0 && currentTick !== lastReportedTick) {
+            lastReportedTick = currentTick;
+            const hash = runner.Simulation.mem.getHash();
+            addRPC(config.reportHashRpc, {
+                hash,
+                atTick: currentTick
+            });
+        }
+    };
+}
+
+//# sourceMappingURL=create-hash-reporter.js.map

package/dist/lib/hash-verification/create-hash-reporter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/hash-verification/create-hash-reporter.ts"],"sourcesContent":["import type { ECSRunner } from '../ecs-runner.js';\nimport type { IAbstractInputConstructor, InputData } from '../types/index.js';\n\ntype AddRPCFn = <TInputCtor extends IAbstractInputConstructor>(\n  InputCtor: TInputCtor,\n  data: InputData<InstanceType<TInputCtor>>,\n) => void;\n\nexport interface HashReporterConfig {\n  reportInterval: number;\n  reportHashRpc: IAbstractInputConstructor;\n}\n\n/**\n * Creates a hash reporter function for use in `drainInputs`.\n *\n * The returned function should be called from your `drainInputs` callback.\n * It periodically reports the simulation state hash via the ReportHash RPC.\n */\nexport function createHashReporter(runner: ECSRunner, config: HashReporterConfig): (addRPC: AddRPCFn) => void {\n  let lastReportedTick = -1;\n\n  return (addRPC: AddRPCFn) => {\n    const currentTick = runner.Simulation.tick;\n    if (\n      currentTick > 0 &&\n      currentTick % config.reportInterval === 0 &&\n      currentTick !== lastReportedTick\n    ) {\n      lastReportedTick = currentTick;\n      const hash = runner.Simulation.mem.getHash();\n      addRPC(config.reportHashRpc, { hash, atTick: currentTick });\n    }\n  };\n}\n"],"names":["createHashReporter","runner","config","lastReportedTick","addRPC","currentTick","Simulation","tick","reportInterval","hash","mem","getHash","reportHashRpc","atTick"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":"AAaA;;;;;CAKC,GACD,OAAO,SAASA,mBAAmBC,MAAiB,EAAEC,MAA0B;IAC9E,IAAIC,mBAAmB,CAAC;IAExB,OAAO,CAACC;QACN,MAAMC,cAAcJ,OAAOK,UAAU,CAACC,IAAI;QAC1C,IACEF,cAAc,KACdA,cAAcH,OAAOM,cAAc,KAAK,KACxCH,gBAAgBF,kBAChB;YACAA,mBAAmBE;YACnB,MAAMI,OAAOR,OAAOK,UAAU,CAACI,GAAG,CAACC,OAAO;YAC1CP,OAAOF,OAAOU,aAAa,EAAE;gBAAEH;gBAAMI,QAAQR;YAAY;QAC3D;IACF;AACF"}

package/dist/lib/hash-verification/divergence.signal.d.ts

@@ -0,0 +1,11 @@
+import { Signal } from '../signals/signal.js';
+export interface DivergenceData {
+    slotA: number;
+    slotB: number;
+    hashA: number;
+    hashB: number;
+    atTick: number;
+}
+export declare class DivergenceSignal extends Signal<DivergenceData> {
+}
+//# sourceMappingURL=divergence.signal.d.ts.map

package/dist/lib/hash-verification/divergence.signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"divergence.signal.d.ts","sourceRoot":"","sources":["../../../src/lib/hash-verification/divergence.signal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,gBAAiB,SAAQ,MAAM,CAAC,cAAc,CAAC;CAAG"}

package/dist/lib/hash-verification/divergence.signal.js

@@ -0,0 +1,5 @@
+import { Signal } from '../signals/signal.js';
+export class DivergenceSignal extends Signal {
+}
+
+//# sourceMappingURL=divergence.signal.js.map

package/dist/lib/hash-verification/divergence.signal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/hash-verification/divergence.signal.ts"],"sourcesContent":["import { Signal } from '../signals/signal.js';\n\nexport interface DivergenceData {\n  slotA: number;\n  slotB: number;\n  hashA: number;\n  hashB: number;\n  atTick: number;\n}\n\nexport class DivergenceSignal extends Signal<DivergenceData> {}\n"],"names":["Signal","DivergenceSignal"],"rangeMappings":";;","mappings":"AAAA,SAASA,MAAM,QAAQ,uBAAuB;AAU9C,OAAO,MAAMC,yBAAyBD;AAAwB"}

package/dist/lib/hash-verification/index.d.ts

@@ -0,0 +1,4 @@
+export { DivergenceSignal, type DivergenceData } from './divergence.signal.js';
+export { AbstractHashVerificationSystem } from './abstract-hash-verification.system.js';
+export { createHashReporter, type HashReporterConfig } from './create-hash-reporter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/hash-verification/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/hash-verification/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC/E,OAAO,EAAE,8BAA8B,EAAE,MAAM,wCAAwC,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/lib/hash-verification/index.js

@@ -0,0 +1,5 @@
+export { DivergenceSignal } from './divergence.signal.js';
+export { AbstractHashVerificationSystem } from './abstract-hash-verification.system.js';
+export { createHashReporter } from './create-hash-reporter.js';
+
+//# sourceMappingURL=index.js.map

package/dist/lib/hash-verification/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/hash-verification/index.ts"],"sourcesContent":["export { DivergenceSignal, type DivergenceData } from './divergence.signal.js';\nexport { AbstractHashVerificationSystem } from './abstract-hash-verification.system.js';\nexport { createHashReporter, type HashReporterConfig } from './create-hash-reporter.js';\n"],"names":["DivergenceSignal","AbstractHashVerificationSystem","createHashReporter"],"rangeMappings":";;","mappings":"AAAA,SAASA,gBAAgB,QAA6B,yBAAyB;AAC/E,SAASC,8BAA8B,QAAQ,yCAAyC;AACxF,SAASC,kBAAkB,QAAiC,4BAA4B"}

package/dist/lib/input/abstract-input-provider.d.ts

@@ -0,0 +1,61 @@
+import { ECSSimulation } from '../ecs-simulation.js';
+import { IAbstractInputConstructor } from '../types/index.js';
+import { ECSConfig } from '../ecs-config.js';
+import { InputRegistry } from './input-registry.js';
+import { RPCHistory } from './rpc-history.js';
+import { RPC } from './rpc.js';
+export declare abstract class AbstractInputProvider {
+    readonly ecsConfig: ECSConfig;
+    protected readonly _inputRegistry: InputRegistry;
+    private _nextSeq;
+    private _nextOrdinal;
+    private readonly _inputDrainers;
+    protected _frameRPCBuffer: Array<RPC>;
+    protected _frameLength: number;
+    protected _disposed: boolean;
+    protected _currentInputDelay: number;
+    protected _simulation: ECSSimulation;
+    protected readonly _rpcHistory: RPCHistory;
+    abstract playerSlot: number;
+    abstract getInvalidateRollbackTick(): void | number;
+    constructor(ecsConfig: ECSConfig, _inputRegistry: InputRegistry);
+    get currentInputDelay(): number;
+    get rpcHistory(): RPCHistory;
+    get inputRegistry(): InputRegistry;
+    /** @internal — used only by addLocalRpc for ordinal assignment */
+    private getNextOrdinal;
+    update(): void;
+    init(simulation: ECSSimulation): void;
+    dispose(): void;
+    protected resetSequences(): void;
+    private addLocalRpc;
+    /**
+     * Add an RPC received from a remote player via the network.
+     * Used by RelayInputProvider when receiving TickInputFanout.
+     */
+    addRemoteRpc(rpc: RPC): void;
+    /**
+     * Add multiple remote RPCs at once (batch from fanout).
+     */
+    addRemoteRpcBatch(rpcs: ReadonlyArray<RPC>): void;
+    /**
+     * Remove a specific RPC from history.
+     * Used when server sends CancelInput.
+     */
+    removeRpcAt(playerSlot: number, tick: number, seq: number): void;
+    /**
+     * Dynamically change the input delay (in ticks).
+     * Used by InputDelayController based on network conditions.
+     */
+    setInputDelay(ticks: number): void;
+    drainInputs(fn: InputDrainerFn): () => void;
+    collectTickRPCs<TInputCtor extends IAbstractInputConstructor>(tick: number, InputCtor: TInputCtor): ReadonlyArray<RPC<InstanceType<TInputCtor>>>;
+    /**
+     * Get the last buffered local RPCs from this frame.
+     * Used by RelayInputProvider to send local inputs to the server.
+     */
+    getFrameRPCBuffer(): ReadonlyArray<RPC>;
+}
+type InputDrainerFn = (addRPC: AbstractInputProvider['addLocalRpc']) => void;
+export {};
+//# sourceMappingURL=abstract-input-provider.d.ts.map

package/dist/lib/input/abstract-input-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-input-provider.d.ts","sourceRoot":"","sources":["../../../src/lib/input/abstract-input-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,yBAAyB,EAAwB,MAAM,mBAAmB,CAAC;AACpF,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAK/B,8BAAsB,qBAAqB;aAiBvB,SAAS,EAAE,SAAS;IACpC,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,aAAa;IAjBlD,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAkC;IACjE,SAAS,CAAC,eAAe,EAAE,KAAK,CAAC,GAAG,CAAC,CAAM;IAC3C,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC;IAE/B,SAAS,CAAC,SAAS,UAAS;IAC5B,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACrC,SAAS,CAAC,WAAW,EAAG,aAAa,CAAC;IACtC,SAAS,CAAC,QAAQ,CAAC,WAAW,aAAoB;IAElD,SAAgB,UAAU,EAAE,MAAM,CAAC;aAEnB,yBAAyB,IAAI,IAAI,GAAG,MAAM;gBAGxC,SAAS,EAAE,SAAS,EACjB,cAAc,EAAE,aAAa;IAQlD,IAAW,iBAAiB,IAAI,MAAM,CAErC;IAED,IAAW,UAAU,IAAI,UAAU,CAElC;IAED,IAAW,aAAa,IAAI,aAAa,CAExC;IAID,kEAAkE;IAClE,OAAO,CAAC,cAAc;IAIf,MAAM,IAAI,IAAI;IAOd,IAAI,CAAC,UAAU,EAAE,aAAa,GAAG,IAAI;IAIrC,OAAO,IAAI,IAAI;IAItB,SAAS,CAAC,cAAc,IAAI,IAAI;IAQhC,OAAO,CAAC,WAAW,CAcjB;IAIF;;;OAGG;IACI,YAAY,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI;IAKnC;;OAEG;IACI,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI;IAKxD;;;OAGG;IACI,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAOvE;;;OAGG;IACI,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAalC,WAAW,CAAC,EAAE,EAAE,cAAc,GAAG,MAAM,IAAI;IAQ3C,eAAe,CAAC,UAAU,SAAS,yBAAyB,EACjE,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,UAAU,GACpB,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC;IAI/C;;;OAGG;IACI,iBAAiB,IAAI,aAAa,CAAC,GAAG,CAAC;CAG/C;AAED,KAAK,cAAc,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC"}

package/dist/lib/input/abstract-input-provider.js

@@ -0,0 +1,110 @@
+import { RPCHistory } from './rpc-history.js';
+import { RPC } from './rpc.js';
+import { createLogger } from '@lagless/misc';
+const log = createLogger('InputProvider');
+export class AbstractInputProvider {
+    // ─── Public Getters ─────────────────────────────────────
+    get currentInputDelay() {
+        return this._currentInputDelay;
+    }
+    get rpcHistory() {
+        return this._rpcHistory;
+    }
+    get inputRegistry() {
+        return this._inputRegistry;
+    }
+    // ─── Lifecycle ──────────────────────────────────────────
+    /** @internal — used only by addLocalRpc for ordinal assignment */ getNextOrdinal() {
+        return this._nextOrdinal++;
+    }
+    update() {
+        this._frameRPCBuffer.length = 0;
+        this._inputDrainers.forEach((drainFn)=>drainFn(this.addLocalRpc));
+        if (this._frameRPCBuffer.length > 0) this._nextSeq++;
+    }
+    init(simulation) {
+        this._simulation = simulation;
+    }
+    dispose() {
+        this._disposed = true;
+    }
+    resetSequences() {
+        this._nextSeq = 1;
+        this._nextOrdinal = 1;
+        this._frameRPCBuffer.length = 0;
+    }
+    // ─── Remote Input (from network) ────────────────────────
+    /**
+   * Add an RPC received from a remote player via the network.
+   * Used by RelayInputProvider when receiving TickInputFanout.
+   */ addRemoteRpc(rpc) {
+        this._rpcHistory.addRPC(rpc);
+        log.debug(`Remote RPC tick=${rpc.meta.tick} seq=${rpc.meta.seq} slot=${rpc.meta.playerSlot} inputId=${rpc.inputId}`);
+    }
+    /**
+   * Add multiple remote RPCs at once (batch from fanout).
+   */ addRemoteRpcBatch(rpcs) {
+        this._rpcHistory.addBatch(rpcs);
+        log.debug(`Remote RPC batch: ${rpcs.length} RPCs`);
+    }
+    /**
+   * Remove a specific RPC from history.
+   * Used when server sends CancelInput.
+   */ removeRpcAt(playerSlot, tick, seq) {
+        this._rpcHistory.removePlayerInputsAtTick(playerSlot, tick, seq);
+        log.debug(`Removed RPC slot=${playerSlot} tick=${tick} seq=${seq}`);
+    }
+    // ─── Input Delay ────────────────────────────────────────
+    /**
+   * Dynamically change the input delay (in ticks).
+   * Used by InputDelayController based on network conditions.
+   */ setInputDelay(ticks) {
+        const clamped = Math.max(this.ecsConfig.minInputDelayTick, Math.min(ticks, this.ecsConfig.maxInputDelayTick));
+        if (clamped !== this._currentInputDelay) {
+            log.debug(`Input delay changed: ${this._currentInputDelay} → ${clamped}`);
+            this._currentInputDelay = clamped;
+        }
+    }
+    // ─── Query ──────────────────────────────────────────────
+    drainInputs(fn) {
+        this._inputDrainers.add(fn);
+        return ()=>{
+            this._inputDrainers.delete(fn);
+        };
+    }
+    collectTickRPCs(tick, InputCtor) {
+        return this._rpcHistory.collectTickRPCs(tick, InputCtor);
+    }
+    /**
+   * Get the last buffered local RPCs from this frame.
+   * Used by RelayInputProvider to send local inputs to the server.
+   */ getFrameRPCBuffer() {
+        return this._frameRPCBuffer;
+    }
+    constructor(ecsConfig, _inputRegistry){
+        this.ecsConfig = ecsConfig;
+        this._inputRegistry = _inputRegistry;
+        this._nextSeq = 1;
+        this._nextOrdinal = 1;
+        this._inputDrainers = new Set();
+        this._frameRPCBuffer = [];
+        this._disposed = false;
+        this._rpcHistory = new RPCHistory();
+        this.addLocalRpc = (InputCtor, data)=>{
+            const newRPCMeta = {
+                tick: this._simulation.tick + this._currentInputDelay,
+                seq: this._nextSeq,
+                ordinal: this.getNextOrdinal(),
+                playerSlot: this.playerSlot
+            };
+            const rpc = new RPC(InputCtor.id, newRPCMeta, data);
+            this._frameRPCBuffer.push(rpc);
+            this._rpcHistory.addRPC(rpc);
+            log.debug(`Local RPC tick=${newRPCMeta.tick} delay=${this._currentInputDelay} seq=${newRPCMeta.seq} slot=${newRPCMeta.playerSlot} inputId=${InputCtor.id}`);
+        };
+        this._frameLength = this.ecsConfig.frameLength;
+        this._currentInputDelay = this.ecsConfig.initialInputDelayTick;
+    }
+}
+
+//# sourceMappingURL=abstract-input-provider.js.map

package/dist/lib/input/abstract-input-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/input/abstract-input-provider.ts"],"sourcesContent":["import { ECSSimulation } from '../ecs-simulation.js';\nimport { IAbstractInputConstructor, InputData, InputMeta } from '../types/index.js';\nimport { ECSConfig } from '../ecs-config.js';\nimport { InputRegistry } from './input-registry.js';\nimport { RPCHistory } from './rpc-history.js';\nimport { RPC } from './rpc.js';\nimport { createLogger } from '@lagless/misc';\n\nconst log = createLogger('InputProvider');\n\nexport abstract class AbstractInputProvider {\n  private _nextSeq = 1;\n  private _nextOrdinal = 1;\n  private readonly _inputDrainers: Set<InputDrainerFn> = new Set();\n  protected _frameRPCBuffer: Array<RPC> = [];\n  protected _frameLength: number;\n\n  protected _disposed = false;\n  protected _currentInputDelay: number;\n  protected _simulation!: ECSSimulation;\n  protected readonly _rpcHistory = new RPCHistory();\n\n  public abstract playerSlot: number;\n\n  public abstract getInvalidateRollbackTick(): void | number;\n\n  constructor(\n    public readonly ecsConfig: ECSConfig,\n    protected readonly _inputRegistry: InputRegistry,\n  ) {\n    this._frameLength = this.ecsConfig.frameLength;\n    this._currentInputDelay = this.ecsConfig.initialInputDelayTick;\n  }\n\n  // ─── Public Getters ─────────────────────────────────────\n\n  public get currentInputDelay(): number {\n    return this._currentInputDelay;\n  }\n\n  public get rpcHistory(): RPCHistory {\n    return this._rpcHistory;\n  }\n\n  public get inputRegistry(): InputRegistry {\n    return this._inputRegistry;\n  }\n\n  // ─── Lifecycle ──────────────────────────────────────────\n\n  /** @internal — used only by addLocalRpc for ordinal assignment */\n  private getNextOrdinal(): number {\n    return this._nextOrdinal++;\n  }\n\n  public update(): void {\n    this._frameRPCBuffer.length = 0;\n    this._inputDrainers.forEach((drainFn) => drainFn(this.addLocalRpc));\n\n    if (this._frameRPCBuffer.length > 0) this._nextSeq++;\n  }\n\n  public init(simulation: ECSSimulation): void {\n    this._simulation = simulation;\n  }\n\n  public dispose(): void {\n    this._disposed = true;\n  }\n\n  protected resetSequences(): void {\n    this._nextSeq = 1;\n    this._nextOrdinal = 1;\n    this._frameRPCBuffer.length = 0;\n  }\n\n  // ─── Local Input (from drainers) ────────────────────────\n\n  private addLocalRpc = <TInputCtor extends IAbstractInputConstructor>(\n    InputCtor: TInputCtor,\n    data: InputData<InstanceType<TInputCtor>>,\n  ): void => {\n    const newRPCMeta: InputMeta = {\n      tick: this._simulation.tick + this._currentInputDelay,\n      seq: this._nextSeq,\n      ordinal: this.getNextOrdinal(),\n      playerSlot: this.playerSlot,\n    };\n    const rpc = new RPC(InputCtor.id, newRPCMeta, data);\n    this._frameRPCBuffer.push(rpc);\n    this._rpcHistory.addRPC(rpc);\n    log.debug(`Local RPC tick=${newRPCMeta.tick} delay=${this._currentInputDelay} seq=${newRPCMeta.seq} slot=${newRPCMeta.playerSlot} inputId=${InputCtor.id}`);\n  };\n\n  // ─── Remote Input (from network) ────────────────────────\n\n  /**\n   * Add an RPC received from a remote player via the network.\n   * Used by RelayInputProvider when receiving TickInputFanout.\n   */\n  public addRemoteRpc(rpc: RPC): void {\n    this._rpcHistory.addRPC(rpc);\n    log.debug(`Remote RPC tick=${rpc.meta.tick} seq=${rpc.meta.seq} slot=${rpc.meta.playerSlot} inputId=${rpc.inputId}`);\n  }\n\n  /**\n   * Add multiple remote RPCs at once (batch from fanout).\n   */\n  public addRemoteRpcBatch(rpcs: ReadonlyArray<RPC>): void {\n    this._rpcHistory.addBatch(rpcs);\n    log.debug(`Remote RPC batch: ${rpcs.length} RPCs`);\n  }\n\n  /**\n   * Remove a specific RPC from history.\n   * Used when server sends CancelInput.\n   */\n  public removeRpcAt(playerSlot: number, tick: number, seq: number): void {\n    this._rpcHistory.removePlayerInputsAtTick(playerSlot, tick, seq);\n    log.debug(`Removed RPC slot=${playerSlot} tick=${tick} seq=${seq}`);\n  }\n\n  // ─── Input Delay ────────────────────────────────────────\n\n  /**\n   * Dynamically change the input delay (in ticks).\n   * Used by InputDelayController based on network conditions.\n   */\n  public setInputDelay(ticks: number): void {\n    const clamped = Math.max(\n      this.ecsConfig.minInputDelayTick,\n      Math.min(ticks, this.ecsConfig.maxInputDelayTick),\n    );\n    if (clamped !== this._currentInputDelay) {\n      log.debug(`Input delay changed: ${this._currentInputDelay} → ${clamped}`);\n      this._currentInputDelay = clamped;\n    }\n  }\n\n  // ─── Query ──────────────────────────────────────────────\n\n  public drainInputs(fn: InputDrainerFn): () => void {\n    this._inputDrainers.add(fn);\n\n    return () => {\n      this._inputDrainers.delete(fn);\n    };\n  }\n\n  public collectTickRPCs<TInputCtor extends IAbstractInputConstructor>(\n    tick: number,\n    InputCtor: TInputCtor\n  ): ReadonlyArray<RPC<InstanceType<TInputCtor>>> {\n    return this._rpcHistory.collectTickRPCs(tick, InputCtor);\n  }\n\n  /**\n   * Get the last buffered local RPCs from this frame.\n   * Used by RelayInputProvider to send local inputs to the server.\n   */\n  public getFrameRPCBuffer(): ReadonlyArray<RPC> {\n    return this._frameRPCBuffer;\n  }\n}\n\ntype InputDrainerFn = (addRPC: AbstractInputProvider['addLocalRpc']) => void;\n"],"names":["RPCHistory","RPC","createLogger","log","AbstractInputProvider","currentInputDelay","_currentInputDelay","rpcHistory","_rpcHistory","inputRegistry","_inputRegistry","getNextOrdinal","_nextOrdinal","update","_frameRPCBuffer","length","_inputDrainers","forEach","drainFn","addLocalRpc","_nextSeq","init","simulation","_simulation","dispose","_disposed","resetSequences","addRemoteRpc","rpc","addRPC","debug","meta","tick","seq","playerSlot","inputId","addRemoteRpcBatch","rpcs","addBatch","removeRpcAt","removePlayerInputsAtTick","setInputDelay","ticks","clamped","Math","max","ecsConfig","minInputDelayTick","min","maxInputDelayTick","drainInputs","fn","add","delete","collectTickRPCs","InputCtor","getFrameRPCBuffer","constructor","Set","data","newRPCMeta","ordinal","id","push","_frameLength","frameLength","initialInputDelayTick"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -0,0 +1,8 @@
+export * from './rpc.js';
+export * from './rpc-history.js';
+export * from './input-registry.js';
+export * from './local-input-provider.js';
+export * from './abstract-input-provider.js';
+export * from './input-provider-di-token.js';
+export * from './replay-input-provider.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/input/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC"}

package/dist/lib/input/index.js

@@ -0,0 +1,9 @@
+export * from './rpc.js';
+export * from './rpc-history.js';
+export * from './input-registry.js';
+export * from './local-input-provider.js';
+export * from './abstract-input-provider.js';
+export * from './input-provider-di-token.js';
+export * from './replay-input-provider.js';
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/input/index.ts"],"sourcesContent":["export * from './rpc.js';\nexport * from './rpc-history.js';\nexport * from './input-registry.js';\nexport * from './local-input-provider.js';\nexport * from './abstract-input-provider.js';\nexport * from './input-provider-di-token.js';\nexport * from './replay-input-provider.js';\n"],"names":[],"rangeMappings":";;;;;;","mappings":"AAAA,cAAc,WAAW;AACzB,cAAc,mBAAmB;AACjC,cAAc,sBAAsB;AACpC,cAAc,4BAA4B;AAC1C,cAAc,+BAA+B;AAC7C,cAAc,+BAA+B;AAC7C,cAAc,6BAA6B"}

package/dist/lib/input/input-provider-di-token.d.ts

@@ -0,0 +1,6 @@
+import { AbstractInputProvider } from './abstract-input-provider.js';
+export declare class InputProvider extends AbstractInputProvider {
+    playerSlot: number;
+    getInvalidateRollbackTick(): undefined;
+}
+//# sourceMappingURL=input-provider-di-token.d.ts.map

package/dist/lib/input/input-provider-di-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-provider-di-token.d.ts","sourceRoot":"","sources":["../../../src/lib/input/input-provider-di-token.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE,qBAAa,aAAc,SAAQ,qBAAqB;IACtC,UAAU,SAAM;IAEzB,yBAAyB;CAGjC"}

package/dist/lib/input/input-provider-di-token.js

@@ -0,0 +1,12 @@
+import { AbstractInputProvider } from './abstract-input-provider.js';
+export class InputProvider extends AbstractInputProvider {
+    getInvalidateRollbackTick() {
+        return undefined;
+    }
+    constructor(...args){
+        super(...args);
+        this.playerSlot = -1;
+    }
+}
+
+//# sourceMappingURL=input-provider-di-token.js.map

package/dist/lib/input/input-provider-di-token.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/input/input-provider-di-token.ts"],"sourcesContent":["import { AbstractInputProvider } from './abstract-input-provider.js';\n\nexport class InputProvider extends AbstractInputProvider {\n  public override playerSlot = -1;\n\n  public getInvalidateRollbackTick() {\n    return undefined;\n  }\n}\n"],"names":["AbstractInputProvider","InputProvider","getInvalidateRollbackTick","undefined","playerSlot"],"rangeMappings":";;;;;;;;;","mappings":"AAAA,SAASA,qBAAqB,QAAQ,+BAA+B;AAErE,OAAO,MAAMC,sBAAsBD;IAG1BE,4BAA4B;QACjC,OAAOC;IACT;;;aAJgBC,aAAa,CAAC;;AAKhC"}

package/dist/lib/input/input-registry.d.ts

@@ -0,0 +1,8 @@
+import { IAbstractInput, IAbstractInputConstructor } from '../types/index.js';
+export declare class InputRegistry {
+    private readonly _inputs;
+    private readonly _idToInputMap;
+    constructor(_inputs: IAbstractInputConstructor[]);
+    get(inputId: number): IAbstractInput;
+}
+//# sourceMappingURL=input-registry.d.ts.map

package/dist/lib/input/input-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-registry.d.ts","sourceRoot":"","sources":["../../../src/lib/input/input-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAE9E,qBAAa,aAAa;IAOtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAH1B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;gBAGhD,OAAO,EAAE,yBAAyB,EAAE;IAYhD,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc;CAM5C"}

package/dist/lib/input/input-registry.js

@@ -0,0 +1,21 @@
+export class InputRegistry {
+    get(inputId) {
+        const input = this._idToInputMap.get(inputId);
+        if (!input) throw new Error(`Input with id ${inputId} not found`);
+        return input;
+    }
+    constructor(_inputs){
+        this._inputs = _inputs;
+        this._idToInputMap = new Map();
+        for (const InputCtor of this._inputs){
+            const InputInstance = new InputCtor();
+            const id = InputInstance.id;
+            this._idToInputMap.set(id, InputInstance);
+        // this._inputToIdMap.set(InputInstance, id);
+        // this._inputCtorToIdMap.set(InputCtor, id);
+        // this._idToInputCtorMap.set(id, InputCtor);
+        }
+    }
+}
+
+//# sourceMappingURL=input-registry.js.map

package/dist/lib/input/input-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/input/input-registry.ts"],"sourcesContent":["import { IAbstractInput, IAbstractInputConstructor } from '../types/index.js';\n\nexport class InputRegistry {\n  // private readonly _inputCtorToIdMap = new Map<IAbstractInputConstructor, number>();\n  // private readonly _idToInputCtorMap = new Map<number, IAbstractInputConstructor>();\n  // private readonly _inputToIdMap = new Map<IAbstractInput, number>();\n  private readonly _idToInputMap = new Map<number, IAbstractInput>();\n\n  constructor(\n    private readonly _inputs: IAbstractInputConstructor[],\n  ) {\n    for (const InputCtor of this._inputs) {\n      const InputInstance = new InputCtor();\n      const id = InputInstance.id;\n      this._idToInputMap.set(id, InputInstance);\n      // this._inputToIdMap.set(InputInstance, id);\n      // this._inputCtorToIdMap.set(InputCtor, id);\n      // this._idToInputCtorMap.set(id, InputCtor);\n    }\n  }\n\n  public get(inputId: number): IAbstractInput {\n    const input = this._idToInputMap.get(inputId);\n    if (!input) throw new Error(`Input with id ${inputId} not found`);\n\n    return input;\n  }\n}\n"],"names":["InputRegistry","get","inputId","input","_idToInputMap","Error","constructor","_inputs","Map","InputCtor","InputInstance","id","set"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA;IAmBJC,IAAIC,OAAe,EAAkB;QAC1C,MAAMC,QAAQ,IAAI,CAACC,aAAa,CAACH,GAAG,CAACC;QACrC,IAAI,CAACC,OAAO,MAAM,IAAIE,MAAM,CAAC,cAAc,EAAEH,QAAQ,UAAU,CAAC;QAEhE,OAAOC;IACT;IAlBAG,YACE,AAAiBC,OAAoC,CACrD;aADiBA,UAAAA;aAHFH,gBAAgB,IAAII;QAKnC,KAAK,MAAMC,aAAa,IAAI,CAACF,OAAO,CAAE;YACpC,MAAMG,gBAAgB,IAAID;YAC1B,MAAME,KAAKD,cAAcC,EAAE;YAC3B,IAAI,CAACP,aAAa,CAACQ,GAAG,CAACD,IAAID;QAC3B,6CAA6C;QAC7C,6CAA6C;QAC7C,6CAA6C;QAC/C;IACF;AAQF"}

package/dist/lib/input/local-input-provider.d.ts

@@ -0,0 +1,6 @@
+import { AbstractInputProvider } from './abstract-input-provider.js';
+export declare class LocalInputProvider extends AbstractInputProvider {
+    playerSlot: number;
+    getInvalidateRollbackTick(): void | number;
+}
+//# sourceMappingURL=local-input-provider.d.ts.map

package/dist/lib/input/local-input-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-input-provider.d.ts","sourceRoot":"","sources":["../../../src/lib/input/local-input-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE,qBAAa,kBAAmB,SAAQ,qBAAqB;IAC3C,UAAU,SAAK;IAEf,yBAAyB,IAAI,IAAI,GAAG,MAAM;CAG3D"}

package/dist/lib/input/local-input-provider.js

@@ -0,0 +1,12 @@
+import { AbstractInputProvider } from './abstract-input-provider.js';
+export class LocalInputProvider extends AbstractInputProvider {
+    getInvalidateRollbackTick() {
+        return undefined;
+    }
+    constructor(...args){
+        super(...args);
+        this.playerSlot = 0;
+    }
+}
+
+//# sourceMappingURL=local-input-provider.js.map

package/dist/lib/input/local-input-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/input/local-input-provider.ts"],"sourcesContent":["import { AbstractInputProvider } from './abstract-input-provider.js';\n\nexport class LocalInputProvider extends AbstractInputProvider {\n  public override playerSlot = 0;\n\n  public override getInvalidateRollbackTick(): void | number {\n    return undefined;\n  }\n}\n"],"names":["AbstractInputProvider","LocalInputProvider","getInvalidateRollbackTick","undefined","playerSlot"],"rangeMappings":";;;;;;;;;","mappings":"AAAA,SAASA,qBAAqB,QAAQ,+BAA+B;AAErE,OAAO,MAAMC,2BAA2BD;IAGtBE,4BAA2C;QACzD,OAAOC;IACT;;;aAJgBC,aAAa;;AAK/B"}

package/dist/lib/input/replay-input-provider.d.ts

@@ -0,0 +1,12 @@
+import { AbstractInputProvider } from './abstract-input-provider.js';
+import { ECSConfig } from '../ecs-config.js';
+import { InputRegistry } from './input-registry.js';
+export declare class ReplayInputProvider extends AbstractInputProvider {
+    playerSlot: number;
+    getInvalidateRollbackTick(): undefined;
+    constructor(replayData: ArrayBuffer, ecsConfig: ECSConfig, inputRegistry: InputRegistry);
+    update(): void;
+    static exportReplay(seed: Uint8Array, maxPlayers: number, fps: number, replayData: ArrayBuffer): ArrayBuffer;
+    static createFromReplay(replay: ArrayBuffer, inputRegistry: InputRegistry): ReplayInputProvider;
+}
+//# sourceMappingURL=replay-input-provider.d.ts.map

package/dist/lib/input/replay-input-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-input-provider.d.ts","sourceRoot":"","sources":["../../../src/lib/input/replay-input-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAQpD,qBAAa,mBAAoB,SAAQ,qBAAqB;IAC5C,UAAU,SAAK;IAEf,yBAAyB;gBAKvC,UAAU,EAAE,WAAW,EACvB,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,aAAa;IAMd,MAAM,IAAI,IAAI;WAIhB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,GAAG,WAAW;WAWrG,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,GAAG,mBAAmB;CAUvG"}

package/dist/lib/input/replay-input-provider.js

@@ -0,0 +1,46 @@
+import { AbstractInputProvider } from './abstract-input-provider.js';
+import { ECSConfig } from '../ecs-config.js';
+const SEED_OFFSET = 0;
+const SEED_LENGTH = 16;
+const MAX_PLAYERS_OFFSET = SEED_OFFSET + SEED_LENGTH;
+const FPS_OFFSET = MAX_PLAYERS_OFFSET + 1;
+const REPLAY_DATA_OFFSET = FPS_OFFSET + 1;
+export class ReplayInputProvider extends AbstractInputProvider {
+    getInvalidateRollbackTick() {
+        return undefined;
+    }
+    update() {
+    // do nothing, all inputs are pre-recorded
+    }
+    static exportReplay(seed, maxPlayers, fps, replayData) {
+        const replay = new ArrayBuffer(REPLAY_DATA_OFFSET + replayData.byteLength);
+        const replayUint8 = new Uint8Array(replay);
+        replayUint8.set(seed, SEED_OFFSET);
+        const replayView = new DataView(replay);
+        replayView.setUint8(MAX_PLAYERS_OFFSET, maxPlayers);
+        replayView.setUint8(FPS_OFFSET, fps);
+        replayUint8.set(new Uint8Array(replayData), REPLAY_DATA_OFFSET);
+        return replay;
+    }
+    static createFromReplay(replay, inputRegistry) {
+        const replayUint8 = new Uint8Array(replay);
+        const seed = replayUint8.slice(SEED_OFFSET, SEED_OFFSET + SEED_LENGTH);
+        const replayView = new DataView(replay);
+        const maxPlayers = replayView.getUint8(MAX_PLAYERS_OFFSET);
+        const fps = replayView.getUint8(FPS_OFFSET);
+        const rpcData = replay.slice(REPLAY_DATA_OFFSET);
+        const ecsConfig = new ECSConfig({
+            maxPlayers,
+            seed,
+            fps
+        });
+        return new ReplayInputProvider(rpcData, ecsConfig, inputRegistry);
+    }
+    constructor(replayData, ecsConfig, inputRegistry){
+        super(ecsConfig, inputRegistry);
+        this.playerSlot = 0;
+        this._rpcHistory.import(inputRegistry, replayData);
+    }
+}
+
+//# sourceMappingURL=replay-input-provider.js.map

package/dist/lib/input/replay-input-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/input/replay-input-provider.ts"],"sourcesContent":["import { AbstractInputProvider } from './abstract-input-provider.js';\nimport { ECSConfig } from '../ecs-config.js';\nimport { InputRegistry } from './input-registry.js';\n\nconst SEED_OFFSET = 0;\nconst SEED_LENGTH = 16;\nconst MAX_PLAYERS_OFFSET = SEED_OFFSET + SEED_LENGTH;\nconst FPS_OFFSET = MAX_PLAYERS_OFFSET + 1;\nconst REPLAY_DATA_OFFSET = FPS_OFFSET + 1;\n\nexport class ReplayInputProvider extends AbstractInputProvider {\n  public override playerSlot = 0;\n\n  public override getInvalidateRollbackTick() {\n    return undefined;\n  }\n\n  constructor(\n    replayData: ArrayBuffer,\n    ecsConfig: ECSConfig,\n    inputRegistry: InputRegistry,\n  ) {\n    super(ecsConfig, inputRegistry);\n    this._rpcHistory.import(inputRegistry, replayData);\n  }\n\n  public override update(): void {\n    // do nothing, all inputs are pre-recorded\n  }\n\n  public static exportReplay(seed: Uint8Array, maxPlayers: number, fps: number, replayData: ArrayBuffer): ArrayBuffer {\n    const replay = new ArrayBuffer(REPLAY_DATA_OFFSET + replayData.byteLength);\n    const replayUint8 = new Uint8Array(replay);\n    replayUint8.set(seed, SEED_OFFSET);\n    const replayView = new DataView(replay);\n    replayView.setUint8(MAX_PLAYERS_OFFSET, maxPlayers);\n    replayView.setUint8(FPS_OFFSET, fps);\n    replayUint8.set(new Uint8Array(replayData), REPLAY_DATA_OFFSET);\n    return replay;\n  }\n\n  public static createFromReplay(replay: ArrayBuffer, inputRegistry: InputRegistry): ReplayInputProvider {\n    const replayUint8 = new Uint8Array(replay);\n    const seed = replayUint8.slice(SEED_OFFSET, SEED_OFFSET + SEED_LENGTH);\n    const replayView = new DataView(replay);\n    const maxPlayers = replayView.getUint8(MAX_PLAYERS_OFFSET);\n    const fps = replayView.getUint8(FPS_OFFSET);\n    const rpcData = replay.slice(REPLAY_DATA_OFFSET);\n    const ecsConfig = new ECSConfig({ maxPlayers, seed, fps });\n    return new ReplayInputProvider(rpcData, ecsConfig, inputRegistry);\n  }\n}\n"],"names":["AbstractInputProvider","ECSConfig","SEED_OFFSET","SEED_LENGTH","MAX_PLAYERS_OFFSET","FPS_OFFSET","REPLAY_DATA_OFFSET","ReplayInputProvider","getInvalidateRollbackTick","undefined","update","exportReplay","seed","maxPlayers","fps","replayData","replay","ArrayBuffer","byteLength","replayUint8","Uint8Array","set","replayView","DataView","setUint8","createFromReplay","inputRegistry","slice","getUint8","rpcData","ecsConfig","constructor","playerSlot","_rpcHistory","import"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,qBAAqB,QAAQ,+BAA+B;AACrE,SAASC,SAAS,QAAQ,mBAAmB;AAG7C,MAAMC,cAAc;AACpB,MAAMC,cAAc;AACpB,MAAMC,qBAAqBF,cAAcC;AACzC,MAAME,aAAaD,qBAAqB;AACxC,MAAME,qBAAqBD,aAAa;AAExC,OAAO,MAAME,4BAA4BP;IAGvBQ,4BAA4B;QAC1C,OAAOC;IACT;IAWgBC,SAAe;IAC7B,0CAA0C;IAC5C;IAEA,OAAcC,aAAaC,IAAgB,EAAEC,UAAkB,EAAEC,GAAW,EAAEC,UAAuB,EAAe;QAClH,MAAMC,SAAS,IAAIC,YAAYX,qBAAqBS,WAAWG,UAAU;QACzE,MAAMC,cAAc,IAAIC,WAAWJ;QACnCG,YAAYE,GAAG,CAACT,MAAMV;QACtB,MAAMoB,aAAa,IAAIC,SAASP;QAChCM,WAAWE,QAAQ,CAACpB,oBAAoBS;QACxCS,WAAWE,QAAQ,CAACnB,YAAYS;QAChCK,YAAYE,GAAG,CAAC,IAAID,WAAWL,aAAaT;QAC5C,OAAOU;IACT;IAEA,OAAcS,iBAAiBT,MAAmB,EAAEU,aAA4B,EAAuB;QACrG,MAAMP,cAAc,IAAIC,WAAWJ;QACnC,MAAMJ,OAAOO,YAAYQ,KAAK,CAACzB,aAAaA,cAAcC;QAC1D,MAAMmB,aAAa,IAAIC,SAASP;QAChC,MAAMH,aAAaS,WAAWM,QAAQ,CAACxB;QACvC,MAAMU,MAAMQ,WAAWM,QAAQ,CAACvB;QAChC,MAAMwB,UAAUb,OAAOW,KAAK,CAACrB;QAC7B,MAAMwB,YAAY,IAAI7B,UAAU;YAAEY;YAAYD;YAAME;QAAI;QACxD,OAAO,IAAIP,oBAAoBsB,SAASC,WAAWJ;IACrD;IAjCAK,YACEhB,UAAuB,EACvBe,SAAoB,EACpBJ,aAA4B,CAC5B;QACA,KAAK,CAACI,WAAWJ;aAXHM,aAAa;QAY3B,IAAI,CAACC,WAAW,CAACC,MAAM,CAACR,eAAeX;IACzC;AA2BF"}