@lagless/core 0.0.36 → 0.0.39

package/LICENSE

@@ -0,0 +1,26 @@
+Creative Commons Attribution-NonCommercial 4.0 International
+
+Copyright (c) 2025 Lagless
+
+This work is licensed under the Creative Commons
+Attribution-NonCommercial 4.0 International License.
+
+You are free to:
+
+  Share — copy and redistribute the material in any medium or format
+  Adapt — remix, transform, and build upon the material
+
+Under the following terms:
+
+  Attribution — You must give appropriate credit, provide a link to
+  the license, and indicate if changes were made. You may do so in
+  any reasonable manner, but not in any way that suggests the licensor
+  endorses you or your use.
+
+  NonCommercial — You may not use the material for commercial purposes.
+
+  No additional restrictions — You may not apply legal terms or
+  technological measures that legally restrict others from doing
+  anything the license permits.
+
+Full license text: https://creativecommons.org/licenses/by-nc/4.0/legalcode

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './lib/prefab.js';
+export * from './lib/di/index.js';
+export * from './lib/mem/index.js';
+export * from './lib/ecs-config.js';
+export * from './lib/ecs-runner.js';
+export * from './lib/types/index.js';
+export * from './lib/input/index.js';
+export * from './lib/ecs-simulation.js';
+export * from './lib/signals/signal.js';
+export * from './lib/hash-verification/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC"}

package/dist/lib/di/di-container.d.ts

@@ -0,0 +1,7 @@
+export type Token<T = any> = new (...args: any[]) => T;
+export declare class Container {
+    private readonly _singletons;
+    resolve<T>(cls: Token<T>): T;
+    register<T>(cls: Token<T>, instance: T): void;
+}
+//# sourceMappingURL=di-container.d.ts.map

package/dist/lib/di/di-container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"di-container.d.ts","sourceRoot":"","sources":["../../../src/lib/di/di-container.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,CAAC,CAAC,GAAG,GAAG,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAEvD,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyB;IAE9C,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC;IAgB5B,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI;CAGrD"}

package/dist/lib/di/di-decorators.d.ts

@@ -0,0 +1,4 @@
+import type { Token } from './di-container.js';
+export declare function ECSSignal(...overrideDeps: Token[]): ClassDecorator;
+export declare function ECSSystem(...overrideDeps: Token[]): ClassDecorator;
+//# sourceMappingURL=di-decorators.d.ts.map

package/dist/lib/di/di-decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"di-decorators.d.ts","sourceRoot":"","sources":["../../../src/lib/di/di-decorators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAO/C,wBAAgB,SAAS,CAAC,GAAG,YAAY,EAAE,KAAK,EAAE,GAAG,cAAc,CAiElE;AAED,wBAAgB,SAAS,CAAC,GAAG,YAAY,EAAE,KAAK,EAAE,GAAG,cAAc,CAoElE"}

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

@@ -0,0 +1,3 @@
+export * from './di-container.js';
+export * from './di-decorators.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/di/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}

package/dist/lib/ecs-config.d.ts

@@ -0,0 +1,16 @@
+export type RawSeed = Uint8Array;
+export declare class ECSConfig {
+    readonly seed: RawSeed;
+    readonly maxEntities: number;
+    readonly maxPlayers: number;
+    readonly initialInputDelayTick: number;
+    readonly minInputDelayTick: number;
+    readonly maxInputDelayTick: number;
+    readonly fps: number;
+    readonly frameLength: number;
+    readonly snapshotRate: number;
+    readonly snapshotHistorySize: number;
+    readonly maxNudgePerFrame: number;
+    constructor(options?: Partial<ECSConfig>);
+}
+//# sourceMappingURL=ecs-config.d.ts.map

package/dist/lib/ecs-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecs-config.d.ts","sourceRoot":"","sources":["../../src/lib/ecs-config.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC;AAIjC,qBAAa,SAAS;IACpB,SAAgB,IAAI,EAAE,OAAO,CAAC;IAC9B,SAAgB,WAAW,EAAE,MAAM,CAAC;IACpC,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,qBAAqB,EAAE,MAAM,CAAC;IAC9C,SAAgB,iBAAiB,EAAE,MAAM,CAAC;IAC1C,SAAgB,iBAAiB,EAAE,MAAM,CAAC;IAC1C,SAAgB,GAAG,EAAE,MAAM,CAAC;IAC5B,SAAgB,WAAW,EAAE,MAAM,CAAC;IACpC,SAAgB,YAAY,EAAE,MAAM,CAAC;IACrC,SAAgB,mBAAmB,EAAE,MAAM,CAAC;IAC5C,SAAgB,gBAAgB,EAAE,MAAM,CAAC;gBAE7B,OAAO,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC;CAazC"}

package/dist/lib/ecs-runner.d.ts

@@ -0,0 +1,20 @@
+import { Container } from './di/index.js';
+import { ECSConfig } from './ecs-config.js';
+import { ECSSimulation } from './ecs-simulation.js';
+import { AbstractInputProvider } from './input/index.js';
+import { ECSDeps, IECSSystemConstructor } from './types/index.js';
+import { ISignalConstructor } from './signals/signal.js';
+export declare abstract class ECSRunner {
+    readonly Config: ECSConfig;
+    readonly InputProviderInstance: AbstractInputProvider;
+    readonly Systems: Array<IECSSystemConstructor>;
+    readonly Signals: Array<ISignalConstructor>;
+    readonly Deps: ECSDeps;
+    readonly DIContainer: Container;
+    readonly Simulation: ECSSimulation;
+    protected constructor(Config: ECSConfig, InputProviderInstance: AbstractInputProvider, Systems: Array<IECSSystemConstructor>, Signals: Array<ISignalConstructor> | undefined, Deps: ECSDeps, simulation?: ECSSimulation, extraRegistrations?: Array<[unknown, unknown]>);
+    start(): void;
+    update(dt: number): void;
+    dispose(): void;
+}
+//# sourceMappingURL=ecs-runner.d.ts.map

package/dist/lib/ecs-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecs-runner.d.ts","sourceRoot":"","sources":["../../src/lib/ecs-runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAGlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,8BAAsB,SAAS;aAKX,MAAM,EAAE,SAAS;aACjB,qBAAqB,EAAE,qBAAqB;aAC5C,OAAO,EAAE,KAAK,CAAC,qBAAqB,CAAC;aACrC,OAAO,EAAE,KAAK,CAAC,kBAAkB,CAAC;aAClC,IAAI,EAAE,OAAO;IAR/B,SAAgB,WAAW,EAAE,SAAS,CAAC;IACvC,SAAgB,UAAU,EAAE,aAAa,CAAC;IAE1C,SAAS,aACS,MAAM,EAAE,SAAS,EACjB,qBAAqB,EAAE,qBAAqB,EAC5C,OAAO,EAAE,KAAK,CAAC,qBAAqB,CAAC,EACrC,OAAO,EAAE,KAAK,CAAC,kBAAkB,CAAC,YAAK,EACvC,IAAI,EAAE,OAAO,EAC7B,UAAU,CAAC,EAAE,aAAa,EAC1B,kBAAkB,CAAC,EAAE,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAkDzC,KAAK,IAAI,IAAI;IAIb,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIxB,OAAO,IAAI,IAAI;CAMvB"}

package/dist/lib/ecs-runner.js

@@ -15,14 +15,14 @@ export class ECSRunner {
         this.InputProviderInstance.dispose();
         this.Simulation.disposeSignals();
     }
-    constructor(Config, InputProviderInstance, Systems, Signals = [], Deps){
+    constructor(Config, InputProviderInstance, Systems, Signals = [], Deps, simulation, extraRegistrations){
         this.Config = Config;
         this.InputProviderInstance = InputProviderInstance;
         this.Systems = Systems;
         this.Signals = Signals;
         this.Deps = Deps;
         this.DIContainer = new Container();
-        this.Simulation = new ECSSimulation(this.Config, this.Deps, this.InputProviderInstance);
+        this.Simulation = simulation != null ? simulation : new ECSSimulation(this.Config, this.Deps, this.InputProviderInstance);
         this.InputProviderInstance.init(this.Simulation);
         const mem = this.Simulation.mem;
         this.DIContainer.register(ECSConfig, this.Config);
@@ -44,6 +44,12 @@ export class ECSRunner {
         }
         // player resources
         this.DIContainer.register(PlayerResources, mem.playerResourcesManager.PlayerResources);
+        // extra registrations (from subclasses like PhysicsRunner3d)
+        if (extraRegistrations) {
+            for (const [token, instance] of extraRegistrations){
+                this.DIContainer.register(token, instance);
+            }
+        }
         // signals
         const signalInstances = this.Signals.map((SignalConstructor)=>{
             return this.DIContainer.resolve(SignalConstructor);

package/dist/lib/ecs-runner.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/lib/ecs-runner.ts"],"sourcesContent":["import { Container } from './di/index.js';\nimport { ECSConfig } from './ecs-config.js';\nimport { ECSSimulation } from './ecs-simulation.js';\nimport { AbstractInputProvider } from './input/index.js';\nimport { ECSDeps, IECSSystemConstructor } from './types/index.js';\nimport { InputProvider } from './input/index.js';\nimport { EntitiesManager, PlayerResources, PRNG } from './mem/index.js';\nimport { ISignalConstructor } from './signals/signal.js';\n\nexport abstract class ECSRunner {\n  public readonly DIContainer: Container;\n  public readonly Simulation: ECSSimulation;\n\n  protected constructor(\n    public readonly Config: ECSConfig,\n    public readonly InputProviderInstance: AbstractInputProvider,\n    public readonly Systems: Array<IECSSystemConstructor>,\n    public readonly Signals: Array<ISignalConstructor> = [],\n    public readonly Deps: ECSDeps,\n  ) {\n    this.DIContainer = new Container();\n    this.Simulation = new ECSSimulation(this.Config, this.Deps, this.InputProviderInstance);\n    this.InputProviderInstance.init(this.Simulation);\n\n    const mem = this.Simulation.mem;\n\n    this.DIContainer.register(ECSConfig, this.Config);\n    this.DIContainer.register(InputProvider, this.InputProviderInstance);\n    this.DIContainer.register(ECSSimulation, this.Simulation);\n    this.DIContainer.register(EntitiesManager, mem.entitiesManager);\n    this.DIContainer.register(PRNG, mem.prngManager.prng);\n\n    // components\n    for (const [ ComponentConstructor, ComponentInstance ] of mem.componentsManager) {\n      this.DIContainer.register(ComponentConstructor, ComponentInstance);\n    }\n    // singletons\n    for (const [ SingletonConstructor, SingletonInstance ] of mem.singletonsManager) {\n      this.DIContainer.register(SingletonConstructor, SingletonInstance);\n    }\n    // filters\n    for (const [ FilterConstructor, FilterInstance ] of mem.filtersManager) {\n      this.DIContainer.register(FilterConstructor, FilterInstance);\n    }\n    // player resources\n    this.DIContainer.register(PlayerResources, mem.playerResourcesManager.PlayerResources);\n\n    // signals\n    const signalInstances = this.Signals.map((SignalConstructor) => {\n      return this.DIContainer.resolve(SignalConstructor);\n    });\n    this.Simulation.initSignals(signalInstances);\n\n    // systems\n    const systemInstances = this.Systems.map((SystemConstructor) => {\n      return this.DIContainer.resolve(SystemConstructor);\n    });\n\n    this.Simulation.registerSystems(systemInstances);\n  }\n\n  public start(): void {\n    this.Simulation.start();\n  }\n\n  public update(dt: number): void {\n    this.Simulation.update(dt);\n  }\n\n  public dispose(): void {\n    // ECSRunner disposed\n    this.InputProviderInstance.dispose();\n    this.Simulation.disposeSignals();\n\n  }\n}\n"],"names":["Container","ECSConfig","ECSSimulation","InputProvider","EntitiesManager","PlayerResources","PRNG","ECSRunner","start","Simulation","update","dt","dispose","InputProviderInstance","disposeSignals","Config","Systems","Signals","Deps","DIContainer","init","mem","register","entitiesManager","prngManager","prng","ComponentConstructor","ComponentInstance","componentsManager","SingletonConstructor","SingletonInstance","singletonsManager","FilterConstructor","FilterInstance","filtersManager","playerResourcesManager","signalInstances","map","SignalConstructor","resolve","initSignals","systemInstances","SystemConstructor","registerSystems"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,SAAS,QAAQ,gBAAgB;AAC1C,SAASC,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,aAAa,QAAQ,sBAAsB;AAGpD,SAASC,aAAa,QAAQ,mBAAmB;AACjD,SAASC,eAAe,EAAEC,eAAe,EAAEC,IAAI,QAAQ,iBAAiB;AAGxE,OAAO,MAAeC;IAoDbC,QAAc;QACnB,IAAI,CAACC,UAAU,CAACD,KAAK;IACvB;IAEOE,OAAOC,EAAU,EAAQ;QAC9B,IAAI,CAACF,UAAU,CAACC,MAAM,CAACC;IACzB;IAEOC,UAAgB;QACrB,qBAAqB;QACrB,IAAI,CAACC,qBAAqB,CAACD,OAAO;QAClC,IAAI,CAACH,UAAU,CAACK,cAAc;IAEhC;IA7DA,YACE,AAAgBC,MAAiB,EACjC,AAAgBF,qBAA4C,EAC5D,AAAgBG,OAAqC,EACrD,AAAgBC,UAAqC,EAAE,EACvD,AAAgBC,IAAa,CAC7B;aALgBH,SAAAA;aACAF,wBAAAA;aACAG,UAAAA;aACAC,UAAAA;aACAC,OAAAA;QAEhB,IAAI,CAACC,WAAW,GAAG,IAAInB;QACvB,IAAI,CAACS,UAAU,GAAG,IAAIP,cAAc,IAAI,CAACa,MAAM,EAAE,IAAI,CAACG,IAAI,EAAE,IAAI,CAACL,qBAAqB;QACtF,IAAI,CAACA,qBAAqB,CAACO,IAAI,CAAC,IAAI,CAACX,UAAU;QAE/C,MAAMY,MAAM,IAAI,CAACZ,UAAU,CAACY,GAAG;QAE/B,IAAI,CAACF,WAAW,CAACG,QAAQ,CAACrB,WAAW,IAAI,CAACc,MAAM;QAChD,IAAI,CAACI,WAAW,CAACG,QAAQ,CAACnB,eAAe,IAAI,CAACU,qBAAqB;QACnE,IAAI,CAACM,WAAW,CAACG,QAAQ,CAACpB,eAAe,IAAI,CAACO,UAAU;QACxD,IAAI,CAACU,WAAW,CAACG,QAAQ,CAAClB,iBAAiBiB,IAAIE,eAAe;QAC9D,IAAI,CAACJ,WAAW,CAACG,QAAQ,CAAChB,MAAMe,IAAIG,WAAW,CAACC,IAAI;QAEpD,aAAa;QACb,KAAK,MAAM,CAAEC,sBAAsBC,kBAAmB,IAAIN,IAAIO,iBAAiB,CAAE;YAC/E,IAAI,CAACT,WAAW,CAACG,QAAQ,CAACI,sBAAsBC;QAClD;QACA,aAAa;QACb,KAAK,MAAM,CAAEE,sBAAsBC,kBAAmB,IAAIT,IAAIU,iBAAiB,CAAE;YAC/E,IAAI,CAACZ,WAAW,CAACG,QAAQ,CAACO,sBAAsBC;QAClD;QACA,UAAU;QACV,KAAK,MAAM,CAAEE,mBAAmBC,eAAgB,IAAIZ,IAAIa,cAAc,CAAE;YACtE,IAAI,CAACf,WAAW,CAACG,QAAQ,CAACU,mBAAmBC;QAC/C;QACA,mBAAmB;QACnB,IAAI,CAACd,WAAW,CAACG,QAAQ,CAACjB,iBAAiBgB,IAAIc,sBAAsB,CAAC9B,eAAe;QAErF,UAAU;QACV,MAAM+B,kBAAkB,IAAI,CAACnB,OAAO,CAACoB,GAAG,CAAC,CAACC;YACxC,OAAO,IAAI,CAACnB,WAAW,CAACoB,OAAO,CAACD;QAClC;QACA,IAAI,CAAC7B,UAAU,CAAC+B,WAAW,CAACJ;QAE5B,UAAU;QACV,MAAMK,kBAAkB,IAAI,CAACzB,OAAO,CAACqB,GAAG,CAAC,CAACK;YACxC,OAAO,IAAI,CAACvB,WAAW,CAACoB,OAAO,CAACG;QAClC;QAEA,IAAI,CAACjC,UAAU,CAACkC,eAAe,CAACF;IAClC;AAgBF"}
+{"version":3,"sources":["../../src/lib/ecs-runner.ts"],"sourcesContent":["import { Container } from './di/index.js';\nimport { ECSConfig } from './ecs-config.js';\nimport { ECSSimulation } from './ecs-simulation.js';\nimport { AbstractInputProvider } from './input/index.js';\nimport { ECSDeps, IECSSystemConstructor } from './types/index.js';\nimport { InputProvider } from './input/index.js';\nimport { EntitiesManager, PlayerResources, PRNG } from './mem/index.js';\nimport { ISignalConstructor } from './signals/signal.js';\n\nexport abstract class ECSRunner {\n  public readonly DIContainer: Container;\n  public readonly Simulation: ECSSimulation;\n\n  protected constructor(\n    public readonly Config: ECSConfig,\n    public readonly InputProviderInstance: AbstractInputProvider,\n    public readonly Systems: Array<IECSSystemConstructor>,\n    public readonly Signals: Array<ISignalConstructor> = [],\n    public readonly Deps: ECSDeps,\n    simulation?: ECSSimulation,\n    extraRegistrations?: Array<[unknown, unknown]>,\n  ) {\n    this.DIContainer = new Container();\n    this.Simulation = simulation ?? new ECSSimulation(this.Config, this.Deps, this.InputProviderInstance);\n    this.InputProviderInstance.init(this.Simulation);\n\n    const mem = this.Simulation.mem;\n\n    this.DIContainer.register(ECSConfig, this.Config);\n    this.DIContainer.register(InputProvider, this.InputProviderInstance);\n    this.DIContainer.register(ECSSimulation, this.Simulation);\n    this.DIContainer.register(EntitiesManager, mem.entitiesManager);\n    this.DIContainer.register(PRNG, mem.prngManager.prng);\n\n    // components\n    for (const [ ComponentConstructor, ComponentInstance ] of mem.componentsManager) {\n      this.DIContainer.register(ComponentConstructor, ComponentInstance);\n    }\n    // singletons\n    for (const [ SingletonConstructor, SingletonInstance ] of mem.singletonsManager) {\n      this.DIContainer.register(SingletonConstructor, SingletonInstance);\n    }\n    // filters\n    for (const [ FilterConstructor, FilterInstance ] of mem.filtersManager) {\n      this.DIContainer.register(FilterConstructor, FilterInstance);\n    }\n    // player resources\n    this.DIContainer.register(PlayerResources, mem.playerResourcesManager.PlayerResources);\n\n    // extra registrations (from subclasses like PhysicsRunner3d)\n    if (extraRegistrations) {\n      for (const [token, instance] of extraRegistrations) {\n        this.DIContainer.register(token as new (...args: unknown[]) => unknown, instance);\n      }\n    }\n\n    // signals\n    const signalInstances = this.Signals.map((SignalConstructor) => {\n      return this.DIContainer.resolve(SignalConstructor);\n    });\n    this.Simulation.initSignals(signalInstances);\n\n    // systems\n    const systemInstances = this.Systems.map((SystemConstructor) => {\n      return this.DIContainer.resolve(SystemConstructor);\n    });\n\n    this.Simulation.registerSystems(systemInstances);\n  }\n\n  public start(): void {\n    this.Simulation.start();\n  }\n\n  public update(dt: number): void {\n    this.Simulation.update(dt);\n  }\n\n  public dispose(): void {\n    // ECSRunner disposed\n    this.InputProviderInstance.dispose();\n    this.Simulation.disposeSignals();\n\n  }\n}\n"],"names":["Container","ECSConfig","ECSSimulation","InputProvider","EntitiesManager","PlayerResources","PRNG","ECSRunner","start","Simulation","update","dt","dispose","InputProviderInstance","disposeSignals","Config","Systems","Signals","Deps","simulation","extraRegistrations","DIContainer","init","mem","register","entitiesManager","prngManager","prng","ComponentConstructor","ComponentInstance","componentsManager","SingletonConstructor","SingletonInstance","singletonsManager","FilterConstructor","FilterInstance","filtersManager","playerResourcesManager","token","instance","signalInstances","map","SignalConstructor","resolve","initSignals","systemInstances","SystemConstructor","registerSystems"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/lib/ecs-simulation.d.ts

@@ -0,0 +1,64 @@
+import { Mem } from './mem/index.js';
+import { ECSConfig } from './ecs-config.js';
+import { SimulationClock, SnapshotHistory } from '@lagless/misc';
+import { ECSDeps, IECSSystem } from './types/index.js';
+import { AbstractInputProvider } from './input/index.js';
+export declare class ECSSimulation {
+    protected readonly _ECSConfig: ECSConfig;
+    private readonly _ECSDeps;
+    private readonly _inputProvider;
+    readonly mem: Mem;
+    readonly clock: SimulationClock;
+    private readonly _signalsRegistry;
+    private readonly _frameLength;
+    private readonly _snapshotRate;
+    protected readonly _initialSnapshot: ArrayBuffer;
+    private readonly _systems;
+    private readonly _onTickHandlers;
+    private readonly _onRollbackHandlers;
+    private readonly _onStateTransferHandlers;
+    private _interpolationFactor;
+    protected _snapshotHistory: SnapshotHistory<ArrayBuffer>;
+    private _hashTrackingInterval;
+    private _hashHistory;
+    get tick(): number;
+    get interpolationFactor(): number;
+    constructor(_ECSConfig: ECSConfig, _ECSDeps: ECSDeps, _inputProvider: AbstractInputProvider);
+    addTickHandler(handler: (tick: number) => void): () => void;
+    removeTickHandler(handler: (tick: number) => void): void;
+    addRollbackHandler(handler: (tick: number) => void): () => void;
+    addStateTransferHandler(handler: (tick: number) => void): () => void;
+    registerSystems(systems: IECSSystem[]): void;
+    initSignals(signals: import('./signals/signal.js').Signal[]): void;
+    disposeSignals(): void;
+    throwIfSystemsNotRegistered(): void;
+    get frameLength(): number;
+    get inputProvider(): AbstractInputProvider;
+    enableHashTracking(interval: number): void;
+    getHashAtTick(tick: number): number | undefined;
+    start(): void;
+    /**
+     * Apply external state received from another client (late-join / reconnect).
+     * Replaces the entire simulation state, sets the tick, and resets history.
+     */
+    applyExternalState(state: ArrayBuffer, tick: number): void;
+    /**
+     * Export simulation state for network state transfer (late-join / reconnect).
+     * Override in subclasses to include additional state (e.g. physics world).
+     */
+    exportStateForTransfer(): ArrayBuffer;
+    /**
+     * Apply state received from network state transfer (late-join / reconnect).
+     * Override in subclasses to restore additional state (e.g. physics world).
+     */
+    applyStateFromTransfer(blob: ArrayBuffer, tick: number): void;
+    protected notifyStateTransferHandlers(tick: number): void;
+    update(dt: number): void;
+    private checkAndRollback;
+    private simulationTicks;
+    protected rollback(tick: number): void;
+    protected simulate(tick: number): void;
+    private storeSnapshotIfNeeded;
+    protected saveSnapshot(tick: number): void;
+}
+//# sourceMappingURL=ecs-simulation.d.ts.map

package/dist/lib/ecs-simulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecs-simulation.d.ts","sourceRoot":"","sources":["../../src/lib/ecs-simulation.ts"],"names":[],"mappings":"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"}

package/dist/lib/ecs-simulation.js

@@ -19,6 +19,18 @@ export class ECSSimulation {
     removeTickHandler(handler) {
         this._onTickHandlers.delete(handler);
     }
+    addRollbackHandler(handler) {
+        this._onRollbackHandlers.add(handler);
+        return ()=>{
+            this._onRollbackHandlers.delete(handler);
+        };
+    }
+    addStateTransferHandler(handler) {
+        this._onStateTransferHandlers.add(handler);
+        return ()=>{
+            this._onStateTransferHandlers.delete(handler);
+        };
+    }
     registerSystems(systems) {
         if (this._systems.length !== 0) throw new Error('Systems already registered');
         for (const system of systems){
@@ -39,6 +51,15 @@ export class ECSSimulation {
     get frameLength() {
         return this._frameLength;
     }
+    get inputProvider() {
+        return this._inputProvider;
+    }
+    enableHashTracking(interval) {
+        this._hashTrackingInterval = interval;
+    }
+    getHashAtTick(tick) {
+        return this._hashHistory.get(tick);
+    }
     start() {
         this.clock.start();
     }
@@ -59,6 +80,24 @@ export class ECSSimulation {
         this.clock.setAccumulatedTime(tick * this._frameLength);
         // Reset signals — old predictions are invalid
         this._signalsRegistry.dispose();
+        // Clear hash history — old hashes are from a different timeline
+        this._hashHistory.clear();
+    }
+    /**
+   * Export simulation state for network state transfer (late-join / reconnect).
+   * Override in subclasses to include additional state (e.g. physics world).
+   */ exportStateForTransfer() {
+        return this.mem.exportSnapshot();
+    }
+    /**
+   * Apply state received from network state transfer (late-join / reconnect).
+   * Override in subclasses to restore additional state (e.g. physics world).
+   */ applyStateFromTransfer(blob, tick) {
+        this.applyExternalState(blob, tick);
+        this.notifyStateTransferHandlers(tick);
+    }
+    notifyStateTransferHandlers(tick) {
+        for (const handler of this._onStateTransferHandlers)handler(tick);
     }
     update(dt) {
         this.clock.update(dt);
@@ -75,6 +114,7 @@ export class ECSSimulation {
         const rollbackTick = this._inputProvider.getInvalidateRollbackTick();
         if (rollbackTick === undefined || rollbackTick > currentTick) return;
         this.rollback(rollbackTick);
+        for (const handler of this._onRollbackHandlers)handler(this.tick);
     }
     simulationTicks(currentTick, toTick) {
         if (toTick - currentTick > 1) {
@@ -83,10 +123,22 @@ export class ECSSimulation {
         while(currentTick < toTick){
             this.mem.tickManager.setTick(++currentTick);
             this.simulate(currentTick);
-            this._signalsRegistry.onTick(currentTick);
+            if (this._hashTrackingInterval > 0 && currentTick % this._hashTrackingInterval === 0) {
+                this._hashHistory.set(currentTick, this.mem.getHash());
+            }
+            this._signalsRegistry.onTick(this._inputProvider.verifiedTick);
             this.storeSnapshotIfNeeded(currentTick);
             for (const handler of this._onTickHandlers)handler(currentTick);
         }
+        // Prune old hash entries
+        if (this._hashHistory.size > 0) {
+            const pruneBelow = this._inputProvider.verifiedTick - 600;
+            if (pruneBelow > 0) {
+                for (const tick of this._hashHistory.keys()){
+                    if (tick < pruneBelow) this._hashHistory.delete(tick);
+                }
+            }
+        }
     }
     rollback(tick) {
         this._signalsRegistry.onBeforeRollback(tick);
@@ -124,7 +176,11 @@ export class ECSSimulation {
         this._inputProvider = _inputProvider;
         this._systems = new Array();
         this._onTickHandlers = new Set();
+        this._onRollbackHandlers = new Set();
+        this._onStateTransferHandlers = new Set();
         this._interpolationFactor = 0;
+        this._hashTrackingInterval = 0;
+        this._hashHistory = new Map();
         this.mem = new Mem(this._ECSConfig, this._ECSDeps);
         this._frameLength = this._ECSConfig.frameLength;
         this._snapshotRate = this._ECSConfig.snapshotRate;

package/dist/lib/ecs-simulation.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/lib/ecs-simulation.ts"],"sourcesContent":["import { MathOps } from '@lagless/math';\nimport { Mem } from './mem/index.js';\nimport { ECSConfig } from './ecs-config.js';\nimport { SimulationClock, SnapshotHistory, createLogger } from '@lagless/misc';\nimport { ECSDeps, IECSSystem } from './types/index.js';\nimport { AbstractInputProvider } from './input/index.js';\nimport { SignalsRegistry } from './signals/signals.registry.js';\n\nconst log = createLogger('ECSSimulation');\n\nexport class ECSSimulation {\n  public readonly mem: Mem;\n  public readonly clock: SimulationClock;\n  private readonly _signalsRegistry: SignalsRegistry;\n  private readonly _frameLength: number;\n  private readonly _snapshotRate: number;\n  private readonly _initialSnapshot!: ArrayBuffer;\n  private readonly _systems = new Array<IECSSystem>();\n  private readonly _onTickHandlers = new Set<(tick: number) => void>();\n\n  private _interpolationFactor = 0;\n  private _snapshotHistory: SnapshotHistory<ArrayBuffer>;\n\n  public get tick(): number {\n    return this.mem.tickManager.tick;\n  }\n\n  public get interpolationFactor(): number {\n    return this._interpolationFactor;\n  }\n\n  constructor(\n    private readonly _ECSConfig: ECSConfig,\n    private readonly _ECSDeps: ECSDeps,\n    private readonly _inputProvider: AbstractInputProvider,\n  ) {\n    this.mem = new Mem(this._ECSConfig, this._ECSDeps);\n    this._frameLength = this._ECSConfig.frameLength;\n    this._snapshotRate = this._ECSConfig.snapshotRate;\n    this._snapshotHistory = new SnapshotHistory<ArrayBuffer>(this._ECSConfig.snapshotHistorySize);\n    this._initialSnapshot = this.mem.exportSnapshot();\n    this.clock = new SimulationClock(_ECSConfig.frameLength, _ECSConfig.maxNudgePerFrame);\n    this._signalsRegistry = new SignalsRegistry();\n  }\n\n  public addTickHandler(handler: (tick: number) => void): () => void {\n    this._onTickHandlers.add(handler);\n    return () => {\n      this._onTickHandlers.delete(handler);\n    };\n  }\n\n  public removeTickHandler(handler: (tick: number) => void): void {\n    this._onTickHandlers.delete(handler);\n  }\n\n  public registerSystems(systems: IECSSystem[]): void {\n    if (this._systems.length !== 0) throw new Error('Systems already registered');\n\n    for (const system of systems) {\n      this._systems.push(system);\n    }\n  }\n\n  public initSignals(signals: import('./signals/signal.js').Signal[]): void {\n    this._signalsRegistry.init(signals);\n  }\n\n  public disposeSignals(): void {\n    this._signalsRegistry.dispose();\n  }\n\n  public throwIfSystemsNotRegistered(): void {\n    if (this._systems.length === 0) {\n      throw new Error('No systems registered.');\n    }\n  }\n\n  public get frameLength(): number {\n    return this._frameLength;\n  }\n\n  public start(): void {\n    this.clock.start();\n  }\n\n  /**\n   * Apply external state received from another client (late-join / reconnect).\n   * Replaces the entire simulation state, sets the tick, and resets history.\n   */\n  public applyExternalState(state: ArrayBuffer, tick: number): void {\n    log.info(`Applying external state at tick ${tick} (${state.byteLength} bytes)`);\n\n    // Apply the snapshot to memory\n    this.mem.applySnapshot(state);\n\n    // Set tick (snapshot may have been taken at a different tick than requested)\n    this.mem.tickManager.setTick(tick);\n\n    // Reset snapshot history — old snapshots are from a different timeline\n    this._snapshotHistory = new SnapshotHistory<ArrayBuffer>(this._ECSConfig.snapshotHistorySize);\n\n    // Save the received state as the new baseline snapshot\n    this.saveSnapshot(tick);\n\n    // Adjust clock to match the new tick\n    this.clock.setAccumulatedTime(tick * this._frameLength);\n\n    // Reset signals — old predictions are invalid\n    this._signalsRegistry.dispose();\n  }\n\n  public update(dt: number) {\n    this.clock.update(dt);\n\n    const targetTick = Math.floor(this.clock.accumulatedTime / this._frameLength);\n\n    this.checkAndRollback(this.mem.tickManager.tick);\n    this.simulationTicks(this.mem.tickManager.tick, targetTick);\n\n    this._inputProvider.update();\n\n    const simTick = this.mem.tickManager.tick;\n    const tickTime = simTick * this._frameLength;\n    const leftover = this.clock.accumulatedTime - tickTime;\n\n    this._interpolationFactor = MathOps.clamp01(leftover / this._frameLength);\n  }\n\n  private checkAndRollback(currentTick: number) {\n    const rollbackTick = this._inputProvider.getInvalidateRollbackTick();\n\n    if (rollbackTick === undefined || rollbackTick > currentTick) return;\n\n    this.rollback(rollbackTick);\n  }\n\n  private simulationTicks(currentTick: number, toTick: number): void {\n    if (toTick - currentTick > 1) {\n      log.warn(`Simulation ticks: ${currentTick} -> ${toTick} (simulate ${toTick - currentTick})`);\n    }\n\n    while (currentTick < toTick) {\n      this.mem.tickManager.setTick(++currentTick);\n      this.simulate(currentTick);\n      this._signalsRegistry.onTick(currentTick);\n      this.storeSnapshotIfNeeded(currentTick);\n      for (const handler of this._onTickHandlers) handler(currentTick);\n    }\n  }\n\n  protected rollback(tick: number): void {\n    this._signalsRegistry.onBeforeRollback(tick);\n    let snapshot: ArrayBuffer;\n\n    try {\n      snapshot = this._snapshotHistory.getNearest(tick);\n      log.warn(`Rollback to tick ${tick} succeeded`);\n    } catch {\n      snapshot = this._initialSnapshot;\n      log.warn(`Rollback to tick ${tick} failed, using initial snapshot`);\n    }\n\n    this.mem.applySnapshot(snapshot);\n    this._snapshotHistory.rollback(this.mem.tickManager.tick);\n  }\n\n  protected simulate(tick: number): void {\n    for (let i = 0; i < this._systems.length; i++) {\n      this._systems[i].update(tick);\n    }\n  }\n\n  private storeSnapshotIfNeeded(tick: number): void {\n    if (this._snapshotRate === 0) return;\n\n    if (tick % this._snapshotRate === 0) {\n      this.saveSnapshot(tick);\n    }\n\n    if (tick % 200 === 0) {\n      log.debug(`Mem Hash at tick ${tick}: ${this.mem.getHash()}`);\n    }\n  }\n\n  protected saveSnapshot(tick: number): void {\n    this._snapshotHistory.set(tick, this.mem.exportSnapshot());\n  }\n}\n"],"names":["MathOps","Mem","SimulationClock","SnapshotHistory","createLogger","SignalsRegistry","log","ECSSimulation","tick","mem","tickManager","interpolationFactor","_interpolationFactor","addTickHandler","handler","_onTickHandlers","add","delete","removeTickHandler","registerSystems","systems","_systems","length","Error","system","push","initSignals","signals","_signalsRegistry","init","disposeSignals","dispose","throwIfSystemsNotRegistered","frameLength","_frameLength","start","clock","applyExternalState","state","info","byteLength","applySnapshot","setTick","_snapshotHistory","_ECSConfig","snapshotHistorySize","saveSnapshot","setAccumulatedTime","update","dt","targetTick","Math","floor","accumulatedTime","checkAndRollback","simulationTicks","_inputProvider","simTick","tickTime","leftover","clamp01","currentTick","rollbackTick","getInvalidateRollbackTick","undefined","rollback","toTick","warn","simulate","onTick","storeSnapshotIfNeeded","onBeforeRollback","snapshot","getNearest","_initialSnapshot","i","_snapshotRate","debug","getHash","set","exportSnapshot","constructor","_ECSDeps","Array","Set","snapshotRate","maxNudgePerFrame"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["../../src/lib/ecs-simulation.ts"],"sourcesContent":["import { MathOps } from '@lagless/math';\nimport { Mem } from './mem/index.js';\nimport { ECSConfig } from './ecs-config.js';\nimport { SimulationClock, SnapshotHistory, createLogger } from '@lagless/misc';\nimport { ECSDeps, IECSSystem } from './types/index.js';\nimport { AbstractInputProvider } from './input/index.js';\nimport { SignalsRegistry } from './signals/signals.registry.js';\n\nconst log = createLogger('ECSSimulation');\n\nexport class ECSSimulation {\n  public readonly mem: Mem;\n  public readonly clock: SimulationClock;\n  private readonly _signalsRegistry: SignalsRegistry;\n  private readonly _frameLength: number;\n  private readonly _snapshotRate: number;\n  protected readonly _initialSnapshot!: ArrayBuffer;\n  private readonly _systems = new Array<IECSSystem>();\n  private readonly _onTickHandlers = new Set<(tick: number) => void>();\n  private readonly _onRollbackHandlers = new Set<(tick: number) => void>();\n  private readonly _onStateTransferHandlers = new Set<(tick: number) => void>();\n\n  private _interpolationFactor = 0;\n  protected _snapshotHistory: SnapshotHistory<ArrayBuffer>;\n  private _hashTrackingInterval = 0;\n  private _hashHistory = new Map<number, number>();\n\n  public get tick(): number {\n    return this.mem.tickManager.tick;\n  }\n\n  public get interpolationFactor(): number {\n    return this._interpolationFactor;\n  }\n\n  constructor(\n    protected readonly _ECSConfig: ECSConfig,\n    private readonly _ECSDeps: ECSDeps,\n    private readonly _inputProvider: AbstractInputProvider,\n  ) {\n    this.mem = new Mem(this._ECSConfig, this._ECSDeps);\n    this._frameLength = this._ECSConfig.frameLength;\n    this._snapshotRate = this._ECSConfig.snapshotRate;\n    this._snapshotHistory = new SnapshotHistory<ArrayBuffer>(this._ECSConfig.snapshotHistorySize);\n    this._initialSnapshot = this.mem.exportSnapshot();\n    this.clock = new SimulationClock(_ECSConfig.frameLength, _ECSConfig.maxNudgePerFrame);\n    this._signalsRegistry = new SignalsRegistry();\n  }\n\n  public addTickHandler(handler: (tick: number) => void): () => void {\n    this._onTickHandlers.add(handler);\n    return () => {\n      this._onTickHandlers.delete(handler);\n    };\n  }\n\n  public removeTickHandler(handler: (tick: number) => void): void {\n    this._onTickHandlers.delete(handler);\n  }\n\n  public addRollbackHandler(handler: (tick: number) => void): () => void {\n    this._onRollbackHandlers.add(handler);\n    return () => { this._onRollbackHandlers.delete(handler); };\n  }\n\n  public addStateTransferHandler(handler: (tick: number) => void): () => void {\n    this._onStateTransferHandlers.add(handler);\n    return () => { this._onStateTransferHandlers.delete(handler); };\n  }\n\n  public registerSystems(systems: IECSSystem[]): void {\n    if (this._systems.length !== 0) throw new Error('Systems already registered');\n\n    for (const system of systems) {\n      this._systems.push(system);\n    }\n  }\n\n  public initSignals(signals: import('./signals/signal.js').Signal[]): void {\n    this._signalsRegistry.init(signals);\n  }\n\n  public disposeSignals(): void {\n    this._signalsRegistry.dispose();\n  }\n\n  public throwIfSystemsNotRegistered(): void {\n    if (this._systems.length === 0) {\n      throw new Error('No systems registered.');\n    }\n  }\n\n  public get frameLength(): number {\n    return this._frameLength;\n  }\n\n  public get inputProvider(): AbstractInputProvider {\n    return this._inputProvider;\n  }\n\n  public enableHashTracking(interval: number): void {\n    this._hashTrackingInterval = interval;\n  }\n\n  public getHashAtTick(tick: number): number | undefined {\n    return this._hashHistory.get(tick);\n  }\n\n  public start(): void {\n    this.clock.start();\n  }\n\n  /**\n   * Apply external state received from another client (late-join / reconnect).\n   * Replaces the entire simulation state, sets the tick, and resets history.\n   */\n  public applyExternalState(state: ArrayBuffer, tick: number): void {\n    log.info(`Applying external state at tick ${tick} (${state.byteLength} bytes)`);\n\n    // Apply the snapshot to memory\n    this.mem.applySnapshot(state);\n\n    // Set tick (snapshot may have been taken at a different tick than requested)\n    this.mem.tickManager.setTick(tick);\n\n    // Reset snapshot history — old snapshots are from a different timeline\n    this._snapshotHistory = new SnapshotHistory<ArrayBuffer>(this._ECSConfig.snapshotHistorySize);\n\n    // Save the received state as the new baseline snapshot\n    this.saveSnapshot(tick);\n\n    // Adjust clock to match the new tick\n    this.clock.setAccumulatedTime(tick * this._frameLength);\n\n    // Reset signals — old predictions are invalid\n    this._signalsRegistry.dispose();\n\n    // Clear hash history — old hashes are from a different timeline\n    this._hashHistory.clear();\n  }\n\n  /**\n   * Export simulation state for network state transfer (late-join / reconnect).\n   * Override in subclasses to include additional state (e.g. physics world).\n   */\n  public exportStateForTransfer(): ArrayBuffer {\n    return this.mem.exportSnapshot();\n  }\n\n  /**\n   * Apply state received from network state transfer (late-join / reconnect).\n   * Override in subclasses to restore additional state (e.g. physics world).\n   */\n  public applyStateFromTransfer(blob: ArrayBuffer, tick: number): void {\n    this.applyExternalState(blob, tick);\n    this.notifyStateTransferHandlers(tick);\n  }\n\n  protected notifyStateTransferHandlers(tick: number): void {\n    for (const handler of this._onStateTransferHandlers) handler(tick);\n  }\n\n  public update(dt: number) {\n    this.clock.update(dt);\n\n    const targetTick = Math.floor(this.clock.accumulatedTime / this._frameLength);\n\n    this.checkAndRollback(this.mem.tickManager.tick);\n    this.simulationTicks(this.mem.tickManager.tick, targetTick);\n\n    this._inputProvider.update();\n\n    const simTick = this.mem.tickManager.tick;\n    const tickTime = simTick * this._frameLength;\n    const leftover = this.clock.accumulatedTime - tickTime;\n\n    this._interpolationFactor = MathOps.clamp01(leftover / this._frameLength);\n  }\n\n  private checkAndRollback(currentTick: number) {\n    const rollbackTick = this._inputProvider.getInvalidateRollbackTick();\n\n    if (rollbackTick === undefined || rollbackTick > currentTick) return;\n\n    this.rollback(rollbackTick);\n\n    for (const handler of this._onRollbackHandlers) handler(this.tick);\n  }\n\n  private simulationTicks(currentTick: number, toTick: number): void {\n    if (toTick - currentTick > 1) {\n      log.warn(`Simulation ticks: ${currentTick} -> ${toTick} (simulate ${toTick - currentTick})`);\n    }\n\n    while (currentTick < toTick) {\n      this.mem.tickManager.setTick(++currentTick);\n      this.simulate(currentTick);\n\n      if (this._hashTrackingInterval > 0 && currentTick % this._hashTrackingInterval === 0) {\n        this._hashHistory.set(currentTick, this.mem.getHash());\n      }\n\n      this._signalsRegistry.onTick(this._inputProvider.verifiedTick);\n      this.storeSnapshotIfNeeded(currentTick);\n      for (const handler of this._onTickHandlers) handler(currentTick);\n    }\n\n    // Prune old hash entries\n    if (this._hashHistory.size > 0) {\n      const pruneBelow = this._inputProvider.verifiedTick - 600;\n      if (pruneBelow > 0) {\n        for (const tick of this._hashHistory.keys()) {\n          if (tick < pruneBelow) this._hashHistory.delete(tick);\n        }\n      }\n    }\n  }\n\n  protected rollback(tick: number): void {\n    this._signalsRegistry.onBeforeRollback(tick);\n    let snapshot: ArrayBuffer;\n\n    try {\n      snapshot = this._snapshotHistory.getNearest(tick);\n      log.warn(`Rollback to tick ${tick} succeeded`);\n    } catch {\n      snapshot = this._initialSnapshot;\n      log.warn(`Rollback to tick ${tick} failed, using initial snapshot`);\n    }\n\n    this.mem.applySnapshot(snapshot);\n    this._snapshotHistory.rollback(this.mem.tickManager.tick);\n  }\n\n  protected simulate(tick: number): void {\n    for (let i = 0; i < this._systems.length; i++) {\n      this._systems[i].update(tick);\n    }\n  }\n\n  private storeSnapshotIfNeeded(tick: number): void {\n    if (this._snapshotRate === 0) return;\n\n    if (tick % this._snapshotRate === 0) {\n      this.saveSnapshot(tick);\n    }\n\n    if (tick % 200 === 0) {\n      log.debug(`Mem Hash at tick ${tick}: ${this.mem.getHash()}`);\n    }\n  }\n\n  protected saveSnapshot(tick: number): void {\n    this._snapshotHistory.set(tick, this.mem.exportSnapshot());\n  }\n}\n"],"names":["MathOps","Mem","SimulationClock","SnapshotHistory","createLogger","SignalsRegistry","log","ECSSimulation","tick","mem","tickManager","interpolationFactor","_interpolationFactor","addTickHandler","handler","_onTickHandlers","add","delete","removeTickHandler","addRollbackHandler","_onRollbackHandlers","addStateTransferHandler","_onStateTransferHandlers","registerSystems","systems","_systems","length","Error","system","push","initSignals","signals","_signalsRegistry","init","disposeSignals","dispose","throwIfSystemsNotRegistered","frameLength","_frameLength","inputProvider","_inputProvider","enableHashTracking","interval","_hashTrackingInterval","getHashAtTick","_hashHistory","get","start","clock","applyExternalState","state","info","byteLength","applySnapshot","setTick","_snapshotHistory","_ECSConfig","snapshotHistorySize","saveSnapshot","setAccumulatedTime","clear","exportStateForTransfer","exportSnapshot","applyStateFromTransfer","blob","notifyStateTransferHandlers","update","dt","targetTick","Math","floor","accumulatedTime","checkAndRollback","simulationTicks","simTick","tickTime","leftover","clamp01","currentTick","rollbackTick","getInvalidateRollbackTick","undefined","rollback","toTick","warn","simulate","set","getHash","onTick","verifiedTick","storeSnapshotIfNeeded","size","pruneBelow","keys","onBeforeRollback","snapshot","getNearest","_initialSnapshot","i","_snapshotRate","debug","constructor","_ECSDeps","Array","Set","Map","snapshotRate","maxNudgePerFrame"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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;CA2ClC"}

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

@@ -15,15 +15,20 @@
             safe.lastReportedHash = rpc.data.hash;
             safe.lastReportedHashTick = rpc.data.atTick;
         }
+        // Only compare hashes for ticks that are verified (server-confirmed, no
+        // future rollback possible). This replaces the old heuristic delay.
+        const verifiedTick = this._InputProvider.verifiedTick;
         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;
+            if (safeA.lastReportedHashTick > verifiedTick) 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 (safeB.lastReportedHashTick > verifiedTick) continue;
                 if (safeA.lastReportedHashTick === safeB.lastReportedHashTick && safeA.lastReportedHash !== safeB.lastReportedHash) {
                     safeA.hashMismatchCount++;
                     safeB.hashMismatchCount++;

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

@@ -1 +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"}
+{"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    // Only compare hashes for ticks that are verified (server-confirmed, no\n    // future rollback possible). This replaces the old heuristic delay.\n    const verifiedTick = this._InputProvider.verifiedTick;\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      if (safeA.lastReportedHashTick > verifiedTick) 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        if (safeB.lastReportedHashTick > verifiedTick) 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","verifiedTick","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,wEAAwE;QACxE,oEAAoE;QACpE,MAAMC,eAAe,IAAI,CAAChB,cAAc,CAACgB,YAAY;QAErD,MAAMC,aAAa,IAAI,CAACC,UAAU,CAACD,UAAU;QAC7C,IAAK,IAAIE,IAAI,GAAGA,IAAIF,YAAYE,IAAK;YACnC,MAAMC,KAAK,IAAI,CAACf,gBAAgB,CAACC,GAAG,CAAC,IAAI,CAACC,oBAAoB,EAAEY;YAChE,MAAME,QAAQD,GAAGV,IAAI;YACrB,IAAIW,MAAMC,SAAS,KAAK,KAAKD,MAAMP,oBAAoB,KAAK,GAAG;YAC/D,IAAIO,MAAMP,oBAAoB,GAAGE,cAAc;YAE/C,IAAK,IAAIO,IAAIJ,IAAI,GAAGI,IAAIN,YAAYM,IAAK;gBACvC,MAAMC,KAAK,IAAI,CAACnB,gBAAgB,CAACC,GAAG,CAAC,IAAI,CAACC,oBAAoB,EAAEgB;gBAChE,MAAME,QAAQD,GAAGd,IAAI;gBACrB,IAAIe,MAAMH,SAAS,KAAK,KAAKG,MAAMX,oBAAoB,KAAK,GAAG;gBAC/D,IAAIW,MAAMX,oBAAoB,GAAGE,cAAc;gBAE/C,IAAIK,MAAMP,oBAAoB,KAAKW,MAAMX,oBAAoB,IAC3DO,MAAMV,gBAAgB,KAAKc,MAAMd,gBAAgB,EAAE;oBACnDU,MAAMK,iBAAiB;oBACvBD,MAAMC,iBAAiB;oBAEvB,IAAI,CAACC,iBAAiB,CAACC,IAAI,CAAC9B,MAAM;wBAChC+B,OAAOV;wBACPW,OAAOP;wBACPQ,OAAOV,MAAMV,gBAAgB;wBAC7BqB,OAAOP,MAAMd,gBAAgB;wBAC7BI,QAAQM,MAAMP,oBAAoB;oBACpC;gBACF;YACF;QACF;IACF;IA5DAmB,YACE,AAAmBf,UAAqB,EACxC,AAAmBlB,cAAqC,EACxD,AAAmBK,gBAAiC,EACpD,AAAmBsB,iBAAmC,CACtD;aAJmBT,aAAAA;aACAlB,iBAAAA;aACAK,mBAAAA;aACAsB,oBAAAA;IAClB;AAwDL"}

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,CAc5G"}

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

@@ -6,14 +6,17 @@
  */ 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
-            });
+        const verifiedTick = runner.Simulation.inputProvider.verifiedTick;
+        const latestReportTick = Math.floor(verifiedTick / config.reportInterval) * config.reportInterval;
+        if (latestReportTick > lastReportedTick && latestReportTick > 0) {
+            const hash = runner.Simulation.getHashAtTick(latestReportTick);
+            if (hash !== undefined) {
+                lastReportedTick = latestReportTick;
+                addRPC(config.reportHashRpc, {
+                    hash,
+                    atTick: latestReportTick
+                });
+            }
         }
     };
 }

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

@@ -1 +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"}
+{"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 verifiedTick = runner.Simulation.inputProvider.verifiedTick;\n    const latestReportTick = Math.floor(verifiedTick / config.reportInterval) * config.reportInterval;\n    if (latestReportTick > lastReportedTick && latestReportTick > 0) {\n      const hash = runner.Simulation.getHashAtTick(latestReportTick);\n      if (hash !== undefined) {\n        lastReportedTick = latestReportTick;\n        addRPC(config.reportHashRpc, { hash, atTick: latestReportTick });\n      }\n    }\n  };\n}\n"],"names":["createHashReporter","runner","config","lastReportedTick","addRPC","verifiedTick","Simulation","inputProvider","latestReportTick","Math","floor","reportInterval","hash","getHashAtTick","undefined","reportHashRpc","atTick"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":"AAaA;;;;;CAKC,GACD,OAAO,SAASA,mBAAmBC,MAAiB,EAAEC,MAA0B;IAC9E,IAAIC,mBAAmB,CAAC;IAExB,OAAO,CAACC;QACN,MAAMC,eAAeJ,OAAOK,UAAU,CAACC,aAAa,CAACF,YAAY;QACjE,MAAMG,mBAAmBC,KAAKC,KAAK,CAACL,eAAeH,OAAOS,cAAc,IAAIT,OAAOS,cAAc;QACjG,IAAIH,mBAAmBL,oBAAoBK,mBAAmB,GAAG;YAC/D,MAAMI,OAAOX,OAAOK,UAAU,CAACO,aAAa,CAACL;YAC7C,IAAII,SAASE,WAAW;gBACtBX,mBAAmBK;gBACnBJ,OAAOF,OAAOa,aAAa,EAAE;oBAAEH;oBAAMI,QAAQR;gBAAiB;YAChE;QACF;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/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