@lagless/physics-shared 0.0.38

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './lib/body-type.js';
+export * from './lib/collider-entity-map.js';
+export * from './lib/collision-layers.js';
+export * from './lib/collision-events-base.js';
+export * from './lib/physics-simulation-base.js';
+export * from './lib/physics-sync-interfaces.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,oBAAoB,CAAC;AACnC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from './lib/body-type.js';
+export * from './lib/collider-entity-map.js';
+export * from './lib/collision-layers.js';
+export * from './lib/collision-events-base.js';
+export * from './lib/physics-simulation-base.js';
+export * from './lib/physics-sync-interfaces.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './lib/body-type.js';\nexport * from './lib/collider-entity-map.js';\nexport * from './lib/collision-layers.js';\nexport * from './lib/collision-events-base.js';\nexport * from './lib/physics-simulation-base.js';\nexport * from './lib/physics-sync-interfaces.js';\n"],"names":[],"rangeMappings":";;;;;","mappings":"AAAA,cAAc,qBAAqB;AACnC,cAAc,+BAA+B;AAC7C,cAAc,4BAA4B;AAC1C,cAAc,iCAAiC;AAC/C,cAAc,mCAAmC;AACjD,cAAc,mCAAmC"}

package/dist/lib/body-type.d.ts

@@ -0,0 +1,9 @@
+/** Body type constants matching the auto-generated PhysicsRefs.bodyType field. */
+export declare const BodyType: {
+    readonly DYNAMIC: 0;
+    readonly FIXED: 1;
+    readonly KINEMATIC_POSITION: 2;
+    readonly KINEMATIC_VELOCITY: 3;
+};
+export type BodyTypeValue = typeof BodyType[keyof typeof BodyType];
+//# sourceMappingURL=body-type.d.ts.map

package/dist/lib/body-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"body-type.d.ts","sourceRoot":"","sources":["../../src/lib/body-type.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,eAAO,MAAM,QAAQ;;;;;CAKX,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,OAAO,QAAQ,CAAC,MAAM,OAAO,QAAQ,CAAC,CAAC"}

package/dist/lib/body-type.js

@@ -0,0 +1,8 @@
+/** Body type constants matching the auto-generated PhysicsRefs.bodyType field. */ export const BodyType = {
+    DYNAMIC: 0,
+    FIXED: 1,
+    KINEMATIC_POSITION: 2,
+    KINEMATIC_VELOCITY: 3
+};
+
+//# sourceMappingURL=body-type.js.map

package/dist/lib/body-type.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/body-type.ts"],"sourcesContent":["/** Body type constants matching the auto-generated PhysicsRefs.bodyType field. */\nexport const BodyType = {\n  DYNAMIC: 0,\n  FIXED: 1,\n  KINEMATIC_POSITION: 2,\n  KINEMATIC_VELOCITY: 3,\n} as const;\n\nexport type BodyTypeValue = typeof BodyType[keyof typeof BodyType];\n"],"names":["BodyType","DYNAMIC","FIXED","KINEMATIC_POSITION","KINEMATIC_VELOCITY"],"rangeMappings":";;;;;","mappings":"AAAA,gFAAgF,GAChF,OAAO,MAAMA,WAAW;IACtBC,SAAS;IACTC,OAAO;IACPC,oBAAoB;IACpBC,oBAAoB;AACtB,EAAW"}

package/dist/lib/collider-entity-map.d.ts

@@ -0,0 +1,12 @@
+export declare const UNMAPPED_ENTITY = -1;
+export declare function handleToIndex(handle: number): number;
+export declare class ColliderEntityMap {
+    private _map;
+    constructor(initialCapacity?: number);
+    set(colliderHandle: number, entity: number): void;
+    get(colliderHandle: number): number;
+    delete(colliderHandle: number): void;
+    clear(): void;
+    private _grow;
+}
+//# sourceMappingURL=collider-entity-map.d.ts.map

package/dist/lib/collider-entity-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collider-entity-map.d.ts","sourceRoot":"","sources":["../../src/lib/collider-entity-map.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,KAAK,CAAC;AAOlC,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGpD;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,IAAI,CAAa;gBAEb,eAAe,GAAE,MAAyB;IAI/C,GAAG,CAAC,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAQjD,GAAG,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM;IAMnC,MAAM,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAOpC,KAAK,IAAI,IAAI;IAIpB,OAAO,CAAC,KAAK;CAMd"}

package/dist/lib/collider-entity-map.js

@@ -0,0 +1,43 @@
+export const UNMAPPED_ENTITY = -1;
+const DEFAULT_CAPACITY = 256;
+// Reinterpret float64 bit pattern → uint32 index (low 32 bits of IEEE 754)
+const _f64 = new Float64Array(1);
+const _u32 = new Uint32Array(_f64.buffer);
+export function handleToIndex(handle) {
+    _f64[0] = handle;
+    return _u32[0]; // low 32 bits = Rapier arena index
+}
+export class ColliderEntityMap {
+    set(colliderHandle, entity) {
+        const idx = handleToIndex(colliderHandle);
+        if (idx >= this._map.length) {
+            this._grow(idx + 1);
+        }
+        this._map[idx] = entity;
+    }
+    get(colliderHandle) {
+        const idx = handleToIndex(colliderHandle);
+        if (idx >= this._map.length) return UNMAPPED_ENTITY;
+        return this._map[idx];
+    }
+    delete(colliderHandle) {
+        const idx = handleToIndex(colliderHandle);
+        if (idx < this._map.length) {
+            this._map[idx] = UNMAPPED_ENTITY;
+        }
+    }
+    clear() {
+        this._map.fill(UNMAPPED_ENTITY);
+    }
+    _grow(minCapacity) {
+        const newCapacity = Math.max(minCapacity, this._map.length * 2);
+        const newMap = new Int32Array(newCapacity).fill(UNMAPPED_ENTITY);
+        newMap.set(this._map);
+        this._map = newMap;
+    }
+    constructor(initialCapacity = DEFAULT_CAPACITY){
+        this._map = new Int32Array(initialCapacity).fill(UNMAPPED_ENTITY);
+    }
+}
+
+//# sourceMappingURL=collider-entity-map.js.map

package/dist/lib/collider-entity-map.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/collider-entity-map.ts"],"sourcesContent":["export const UNMAPPED_ENTITY = -1;\nconst DEFAULT_CAPACITY = 256;\n\n// Reinterpret float64 bit pattern → uint32 index (low 32 bits of IEEE 754)\nconst _f64 = new Float64Array(1);\nconst _u32 = new Uint32Array(_f64.buffer);\n\nexport function handleToIndex(handle: number): number {\n  _f64[0] = handle;\n  return _u32[0]; // low 32 bits = Rapier arena index\n}\n\nexport class ColliderEntityMap {\n  private _map: Int32Array;\n\n  constructor(initialCapacity: number = DEFAULT_CAPACITY) {\n    this._map = new Int32Array(initialCapacity).fill(UNMAPPED_ENTITY);\n  }\n\n  public set(colliderHandle: number, entity: number): void {\n    const idx = handleToIndex(colliderHandle);\n    if (idx >= this._map.length) {\n      this._grow(idx + 1);\n    }\n    this._map[idx] = entity;\n  }\n\n  public get(colliderHandle: number): number {\n    const idx = handleToIndex(colliderHandle);\n    if (idx >= this._map.length) return UNMAPPED_ENTITY;\n    return this._map[idx];\n  }\n\n  public delete(colliderHandle: number): void {\n    const idx = handleToIndex(colliderHandle);\n    if (idx < this._map.length) {\n      this._map[idx] = UNMAPPED_ENTITY;\n    }\n  }\n\n  public clear(): void {\n    this._map.fill(UNMAPPED_ENTITY);\n  }\n\n  private _grow(minCapacity: number): void {\n    const newCapacity = Math.max(minCapacity, this._map.length * 2);\n    const newMap = new Int32Array(newCapacity).fill(UNMAPPED_ENTITY);\n    newMap.set(this._map);\n    this._map = newMap;\n  }\n}\n"],"names":["UNMAPPED_ENTITY","DEFAULT_CAPACITY","_f64","Float64Array","_u32","Uint32Array","buffer","handleToIndex","handle","ColliderEntityMap","set","colliderHandle","entity","idx","_map","length","_grow","get","delete","clear","fill","minCapacity","newCapacity","Math","max","newMap","Int32Array","constructor","initialCapacity"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAO,MAAMA,kBAAkB,CAAC,EAAE;AAClC,MAAMC,mBAAmB;AAEzB,2EAA2E;AAC3E,MAAMC,OAAO,IAAIC,aAAa;AAC9B,MAAMC,OAAO,IAAIC,YAAYH,KAAKI,MAAM;AAExC,OAAO,SAASC,cAAcC,MAAc;IAC1CN,IAAI,CAAC,EAAE,GAAGM;IACV,OAAOJ,IAAI,CAAC,EAAE,EAAE,mCAAmC;AACrD;AAEA,OAAO,MAAMK;IAOJC,IAAIC,cAAsB,EAAEC,MAAc,EAAQ;QACvD,MAAMC,MAAMN,cAAcI;QAC1B,IAAIE,OAAO,IAAI,CAACC,IAAI,CAACC,MAAM,EAAE;YAC3B,IAAI,CAACC,KAAK,CAACH,MAAM;QACnB;QACA,IAAI,CAACC,IAAI,CAACD,IAAI,GAAGD;IACnB;IAEOK,IAAIN,cAAsB,EAAU;QACzC,MAAME,MAAMN,cAAcI;QAC1B,IAAIE,OAAO,IAAI,CAACC,IAAI,CAACC,MAAM,EAAE,OAAOf;QACpC,OAAO,IAAI,CAACc,IAAI,CAACD,IAAI;IACvB;IAEOK,OAAOP,cAAsB,EAAQ;QAC1C,MAAME,MAAMN,cAAcI;QAC1B,IAAIE,MAAM,IAAI,CAACC,IAAI,CAACC,MAAM,EAAE;YAC1B,IAAI,CAACD,IAAI,CAACD,IAAI,GAAGb;QACnB;IACF;IAEOmB,QAAc;QACnB,IAAI,CAACL,IAAI,CAACM,IAAI,CAACpB;IACjB;IAEQgB,MAAMK,WAAmB,EAAQ;QACvC,MAAMC,cAAcC,KAAKC,GAAG,CAACH,aAAa,IAAI,CAACP,IAAI,CAACC,MAAM,GAAG;QAC7D,MAAMU,SAAS,IAAIC,WAAWJ,aAAaF,IAAI,CAACpB;QAChDyB,OAAOf,GAAG,CAAC,IAAI,CAACI,IAAI;QACpB,IAAI,CAACA,IAAI,GAAGW;IACd;IAlCAE,YAAYC,kBAA0B3B,gBAAgB,CAAE;QACtD,IAAI,CAACa,IAAI,GAAG,IAAIY,WAAWE,iBAAiBR,IAAI,CAACpB;IACnD;AAiCF"}

package/dist/lib/collision-events-base.d.ts

@@ -0,0 +1,76 @@
+import { ColliderEntityMap } from './collider-entity-map.js';
+/** Minimal Rapier EventQueue interface (identical in 2D and 3D). */
+export interface IRapierEventQueue {
+    free(): void;
+    drainCollisionEvents(f: (h1: number, h2: number, started: boolean) => void): void;
+    drainContactForceEvents(f: (event: {
+        collider1(): number;
+        collider2(): number;
+        totalForceMagnitude(): number;
+        maxForceMagnitude(): number;
+        maxForceDirection(): unknown;
+    }) => void): void;
+    clear(): void;
+}
+/** Minimal world interface for checking sensor status during event drain. */
+export interface IColliderSensorChecker {
+    getCollider(handle: number): {
+        isSensor(): boolean;
+    };
+}
+/** Factory interface for creating an EventQueue. */
+export interface IEventQueueFactory {
+    new (autoDrain: boolean): IRapierEventQueue;
+}
+export declare class CollisionEventsBase {
+    private readonly _eventQueue;
+    private readonly _drainCollisionCb;
+    private readonly _drainForceCb;
+    private _currentEntityMap;
+    private _currentWorld;
+    private _collisionEnterA;
+    private _collisionEnterB;
+    private _collisionEnterCount;
+    private _collisionExitA;
+    private _collisionExitB;
+    private _collisionExitCount;
+    private _sensorEnterA;
+    private _sensorEnterB;
+    private _sensorEnterCount;
+    private _sensorExitA;
+    private _sensorExitB;
+    private _sensorExitCount;
+    private _contactForceA;
+    private _contactForceB;
+    private _contactForceMagnitude;
+    private _contactForceCount;
+    constructor(eventQueueFactory: IEventQueueFactory, initialCapacity?: number);
+    get eventQueue(): IRapierEventQueue;
+    /** Drain Rapier events into internal buffers. Clears previous events first. */
+    drain(entityMap: ColliderEntityMap, world: IColliderSensorChecker): void;
+    /** Clear all event buffers. */
+    clear(): void;
+    get collisionEnterCount(): number;
+    collisionEnterEntityA(index: number): number;
+    collisionEnterEntityB(index: number): number;
+    get collisionExitCount(): number;
+    collisionExitEntityA(index: number): number;
+    collisionExitEntityB(index: number): number;
+    get sensorEnterCount(): number;
+    sensorEnterEntityA(index: number): number;
+    sensorEnterEntityB(index: number): number;
+    get sensorExitCount(): number;
+    sensorExitEntityA(index: number): number;
+    sensorExitEntityB(index: number): number;
+    get contactForceCount(): number;
+    contactForceEntityA(index: number): number;
+    contactForceEntityB(index: number): number;
+    contactForceMagnitude(index: number): number;
+    dispose(): void;
+    private _pushCollisionEnter;
+    private _pushCollisionExit;
+    private _pushSensorEnter;
+    private _pushSensorExit;
+    private _pushContactForce;
+}
+//# sourceMappingURL=collision-events-base.d.ts.map

package/dist/lib/collision-events-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision-events-base.d.ts","sourceRoot":"","sources":["../../src/lib/collision-events-base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAmB,MAAM,0BAA0B,CAAC;AAE9E,oEAAoE;AACpE,MAAM,WAAW,iBAAiB;IAChC,IAAI,IAAI,IAAI,CAAC;IACb,oBAAoB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAAC;IAClF,uBAAuB,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,SAAS,IAAI,MAAM,CAAC;QAAC,SAAS,IAAI,MAAM,CAAC;QAAC,mBAAmB,IAAI,MAAM,CAAC;QAAC,iBAAiB,IAAI,MAAM,CAAC;QAAC,iBAAiB,IAAI,OAAO,CAAA;KAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAC1L,KAAK,IAAI,IAAI,CAAC;CACf;AAED,6EAA6E;AAC7E,MAAM,WAAW,sBAAsB;IACrC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,QAAQ,IAAI,OAAO,CAAA;KAAE,CAAC;CACtD;AAED,oDAAoD;AACpD,MAAM,WAAW,kBAAkB;IACjC,KAAK,SAAS,EAAE,OAAO,GAAG,iBAAiB,CAAC;CAC7C;AAID,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAGhD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqD;IACvF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0J;IAGxL,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,aAAa,CAAuC;IAG5D,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,oBAAoB,CAAK;IAGjC,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,mBAAmB,CAAK;IAGhC,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,iBAAiB,CAAK;IAG9B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,gBAAgB,CAAK;IAG7B,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,sBAAsB,CAAe;IAC7C,OAAO,CAAC,kBAAkB,CAAK;gBAEnB,iBAAiB,EAAE,kBAAkB,EAAE,eAAe,GAAE,MAAyB;IAwD7F,IAAW,UAAU,IAAI,iBAAiB,CAEzC;IAED,+EAA+E;IACxE,KAAK,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,EAAE,sBAAsB,GAAG,IAAI;IAY/E,+BAA+B;IACxB,KAAK,IAAI,IAAI;IASpB,IAAW,mBAAmB,IAAI,MAAM,CAAsC;IACvE,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAC5C,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAGnD,IAAW,kBAAkB,IAAI,MAAM,CAAqC;IACrE,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAC3C,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAGlD,IAAW,gBAAgB,IAAI,MAAM,CAAmC;IACjE,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IACzC,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAGhD,IAAW,eAAe,IAAI,MAAM,CAAkC;IAC/D,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IACxC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAG/C,IAAW,iBAAiB,IAAI,MAAM,CAAoC;IACnE,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAC1C,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAC1C,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAE5C,OAAO,IAAI,IAAI;IAMtB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,iBAAiB;CAW1B"}

package/dist/lib/collision-events-base.js

@@ -0,0 +1,196 @@
+import { UNMAPPED_ENTITY } from './collider-entity-map.js';
+const DEFAULT_CAPACITY = 64;
+export class CollisionEventsBase {
+    get eventQueue() {
+        return this._eventQueue;
+    }
+    /** Drain Rapier events into internal buffers. Clears previous events first. */ drain(entityMap, world) {
+        this.clear();
+        this._currentEntityMap = entityMap;
+        this._currentWorld = world;
+        this._eventQueue.drainCollisionEvents(this._drainCollisionCb);
+        this._eventQueue.drainContactForceEvents(this._drainForceCb);
+        this._currentEntityMap = null;
+        this._currentWorld = null;
+    }
+    /** Clear all event buffers. */ clear() {
+        this._collisionEnterCount = 0;
+        this._collisionExitCount = 0;
+        this._sensorEnterCount = 0;
+        this._sensorExitCount = 0;
+        this._contactForceCount = 0;
+    }
+    // --- Collision enter ---
+    get collisionEnterCount() {
+        return this._collisionEnterCount;
+    }
+    collisionEnterEntityA(index) {
+        return this._collisionEnterA[index];
+    }
+    collisionEnterEntityB(index) {
+        return this._collisionEnterB[index];
+    }
+    // --- Collision exit ---
+    get collisionExitCount() {
+        return this._collisionExitCount;
+    }
+    collisionExitEntityA(index) {
+        return this._collisionExitA[index];
+    }
+    collisionExitEntityB(index) {
+        return this._collisionExitB[index];
+    }
+    // --- Sensor enter ---
+    get sensorEnterCount() {
+        return this._sensorEnterCount;
+    }
+    sensorEnterEntityA(index) {
+        return this._sensorEnterA[index];
+    }
+    sensorEnterEntityB(index) {
+        return this._sensorEnterB[index];
+    }
+    // --- Sensor exit ---
+    get sensorExitCount() {
+        return this._sensorExitCount;
+    }
+    sensorExitEntityA(index) {
+        return this._sensorExitA[index];
+    }
+    sensorExitEntityB(index) {
+        return this._sensorExitB[index];
+    }
+    // --- Contact forces ---
+    get contactForceCount() {
+        return this._contactForceCount;
+    }
+    contactForceEntityA(index) {
+        return this._contactForceA[index];
+    }
+    contactForceEntityB(index) {
+        return this._contactForceB[index];
+    }
+    contactForceMagnitude(index) {
+        return this._contactForceMagnitude[index];
+    }
+    dispose() {
+        this._eventQueue.free();
+    }
+    // --- Internal push methods with auto-grow ---
+    _pushCollisionEnter(a, b) {
+        const idx = this._collisionEnterCount++;
+        if (idx >= this._collisionEnterA.length) {
+            this._collisionEnterA = _grow(this._collisionEnterA);
+            this._collisionEnterB = _grow(this._collisionEnterB);
+        }
+        this._collisionEnterA[idx] = a;
+        this._collisionEnterB[idx] = b;
+    }
+    _pushCollisionExit(a, b) {
+        const idx = this._collisionExitCount++;
+        if (idx >= this._collisionExitA.length) {
+            this._collisionExitA = _grow(this._collisionExitA);
+            this._collisionExitB = _grow(this._collisionExitB);
+        }
+        this._collisionExitA[idx] = a;
+        this._collisionExitB[idx] = b;
+    }
+    _pushSensorEnter(nonSensor, sensor) {
+        const idx = this._sensorEnterCount++;
+        if (idx >= this._sensorEnterA.length) {
+            this._sensorEnterA = _grow(this._sensorEnterA);
+            this._sensorEnterB = _grow(this._sensorEnterB);
+        }
+        this._sensorEnterA[idx] = nonSensor;
+        this._sensorEnterB[idx] = sensor;
+    }
+    _pushSensorExit(nonSensor, sensor) {
+        const idx = this._sensorExitCount++;
+        if (idx >= this._sensorExitA.length) {
+            this._sensorExitA = _grow(this._sensorExitA);
+            this._sensorExitB = _grow(this._sensorExitB);
+        }
+        this._sensorExitA[idx] = nonSensor;
+        this._sensorExitB[idx] = sensor;
+    }
+    _pushContactForce(a, b, magnitude) {
+        const idx = this._contactForceCount++;
+        if (idx >= this._contactForceA.length) {
+            this._contactForceA = _grow(this._contactForceA);
+            this._contactForceB = _grow(this._contactForceB);
+            this._contactForceMagnitude = _growFloat(this._contactForceMagnitude);
+        }
+        this._contactForceA[idx] = a;
+        this._contactForceB[idx] = b;
+        this._contactForceMagnitude[idx] = magnitude;
+    }
+    constructor(eventQueueFactory, initialCapacity = DEFAULT_CAPACITY){
+        // Transient references set during drain()
+        this._currentEntityMap = null;
+        this._currentWorld = null;
+        this._collisionEnterCount = 0;
+        this._collisionExitCount = 0;
+        this._sensorEnterCount = 0;
+        this._sensorExitCount = 0;
+        this._contactForceCount = 0;
+        this._eventQueue = new eventQueueFactory(false);
+        this._collisionEnterA = new Int32Array(initialCapacity);
+        this._collisionEnterB = new Int32Array(initialCapacity);
+        this._collisionExitA = new Int32Array(initialCapacity);
+        this._collisionExitB = new Int32Array(initialCapacity);
+        this._sensorEnterA = new Int32Array(initialCapacity);
+        this._sensorEnterB = new Int32Array(initialCapacity);
+        this._sensorExitA = new Int32Array(initialCapacity);
+        this._sensorExitB = new Int32Array(initialCapacity);
+        this._contactForceA = new Int32Array(initialCapacity);
+        this._contactForceB = new Int32Array(initialCapacity);
+        this._contactForceMagnitude = new Float32Array(initialCapacity);
+        // Pre-bind callbacks
+        this._drainCollisionCb = (h1, h2, started)=>{
+            const entityMap = this._currentEntityMap;
+            const world = this._currentWorld;
+            const e1 = entityMap.get(h1);
+            const e2 = entityMap.get(h2);
+            if (e1 === UNMAPPED_ENTITY || e2 === UNMAPPED_ENTITY) return;
+            const c1 = world.getCollider(h1);
+            const c2 = world.getCollider(h2);
+            const c1Sensor = c1.isSensor();
+            const c2Sensor = c2.isSensor();
+            if (c1Sensor || c2Sensor) {
+                // Convention: A = non-sensor entity, B = sensor entity
+                const nonSensorE = c1Sensor ? e2 : e1;
+                const sensorE = c1Sensor ? e1 : e2;
+                if (started) {
+                    this._pushSensorEnter(nonSensorE, sensorE);
+                } else {
+                    this._pushSensorExit(nonSensorE, sensorE);
+                }
+            } else {
+                if (started) {
+                    this._pushCollisionEnter(e1, e2);
+                } else {
+                    this._pushCollisionExit(e1, e2);
+                }
+            }
+        };
+        this._drainForceCb = (event)=>{
+            const entityMap = this._currentEntityMap;
+            const e1 = entityMap.get(event.collider1());
+            const e2 = entityMap.get(event.collider2());
+            if (e1 === UNMAPPED_ENTITY || e2 === UNMAPPED_ENTITY) return;
+            this._pushContactForce(e1, e2, event.totalForceMagnitude());
+        };
+    }
+}
+function _grow(arr) {
+    const next = new Int32Array(arr.length * 2);
+    next.set(arr);
+    return next;
+}
+function _growFloat(arr) {
+    const next = new Float32Array(arr.length * 2);
+    next.set(arr);
+    return next;
+}
+
+//# sourceMappingURL=collision-events-base.js.map

package/dist/lib/collision-events-base.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/collision-events-base.ts"],"sourcesContent":["import { ColliderEntityMap, UNMAPPED_ENTITY } from './collider-entity-map.js';\n\n/** Minimal Rapier EventQueue interface (identical in 2D and 3D). */\nexport interface IRapierEventQueue {\n  free(): void;\n  drainCollisionEvents(f: (h1: number, h2: number, started: boolean) => void): void;\n  drainContactForceEvents(f: (event: { collider1(): number; collider2(): number; totalForceMagnitude(): number; maxForceMagnitude(): number; maxForceDirection(): unknown }) => void): void;\n  clear(): void;\n}\n\n/** Minimal world interface for checking sensor status during event drain. */\nexport interface IColliderSensorChecker {\n  getCollider(handle: number): { isSensor(): boolean };\n}\n\n/** Factory interface for creating an EventQueue. */\nexport interface IEventQueueFactory {\n  new (autoDrain: boolean): IRapierEventQueue;\n}\n\nconst DEFAULT_CAPACITY = 64;\n\nexport class CollisionEventsBase {\n  private readonly _eventQueue: IRapierEventQueue;\n\n  // Pre-bound drain callbacks (zero allocation per tick)\n  private readonly _drainCollisionCb: (h1: number, h2: number, started: boolean) => void;\n  private readonly _drainForceCb: (event: { collider1(): number; collider2(): number; totalForceMagnitude(): number; maxForceMagnitude(): number; maxForceDirection(): unknown }) => void;\n\n  // Transient references set during drain()\n  private _currentEntityMap: ColliderEntityMap | null = null;\n  private _currentWorld: IColliderSensorChecker | null = null;\n\n  // Collision enter (solid bodies)\n  private _collisionEnterA: Int32Array;\n  private _collisionEnterB: Int32Array;\n  private _collisionEnterCount = 0;\n\n  // Collision exit (solid bodies)\n  private _collisionExitA: Int32Array;\n  private _collisionExitB: Int32Array;\n  private _collisionExitCount = 0;\n\n  // Sensor enter\n  private _sensorEnterA: Int32Array;\n  private _sensorEnterB: Int32Array;\n  private _sensorEnterCount = 0;\n\n  // Sensor exit\n  private _sensorExitA: Int32Array;\n  private _sensorExitB: Int32Array;\n  private _sensorExitCount = 0;\n\n  // Contact forces\n  private _contactForceA: Int32Array;\n  private _contactForceB: Int32Array;\n  private _contactForceMagnitude: Float32Array;\n  private _contactForceCount = 0;\n\n  constructor(eventQueueFactory: IEventQueueFactory, initialCapacity: number = DEFAULT_CAPACITY) {\n    this._eventQueue = new eventQueueFactory(false);\n\n    this._collisionEnterA = new Int32Array(initialCapacity);\n    this._collisionEnterB = new Int32Array(initialCapacity);\n    this._collisionExitA = new Int32Array(initialCapacity);\n    this._collisionExitB = new Int32Array(initialCapacity);\n    this._sensorEnterA = new Int32Array(initialCapacity);\n    this._sensorEnterB = new Int32Array(initialCapacity);\n    this._sensorExitA = new Int32Array(initialCapacity);\n    this._sensorExitB = new Int32Array(initialCapacity);\n    this._contactForceA = new Int32Array(initialCapacity);\n    this._contactForceB = new Int32Array(initialCapacity);\n    this._contactForceMagnitude = new Float32Array(initialCapacity);\n\n    // Pre-bind callbacks\n    this._drainCollisionCb = (h1: number, h2: number, started: boolean): void => {\n      const entityMap = this._currentEntityMap!;\n      const world = this._currentWorld!;\n\n      const e1 = entityMap.get(h1);\n      const e2 = entityMap.get(h2);\n      if (e1 === UNMAPPED_ENTITY || e2 === UNMAPPED_ENTITY) return;\n\n      const c1 = world.getCollider(h1);\n      const c2 = world.getCollider(h2);\n      const c1Sensor = c1.isSensor();\n      const c2Sensor = c2.isSensor();\n\n      if (c1Sensor || c2Sensor) {\n        // Convention: A = non-sensor entity, B = sensor entity\n        const nonSensorE = c1Sensor ? e2 : e1;\n        const sensorE = c1Sensor ? e1 : e2;\n        if (started) {\n          this._pushSensorEnter(nonSensorE, sensorE);\n        } else {\n          this._pushSensorExit(nonSensorE, sensorE);\n        }\n      } else {\n        if (started) {\n          this._pushCollisionEnter(e1, e2);\n        } else {\n          this._pushCollisionExit(e1, e2);\n        }\n      }\n    };\n\n    this._drainForceCb = (event: { collider1(): number; collider2(): number; totalForceMagnitude(): number; maxForceMagnitude(): number; maxForceDirection(): unknown }): void => {\n      const entityMap = this._currentEntityMap!;\n      const e1 = entityMap.get(event.collider1());\n      const e2 = entityMap.get(event.collider2());\n      if (e1 === UNMAPPED_ENTITY || e2 === UNMAPPED_ENTITY) return;\n      this._pushContactForce(e1, e2, event.totalForceMagnitude());\n    };\n  }\n\n  public get eventQueue(): IRapierEventQueue {\n    return this._eventQueue;\n  }\n\n  /** Drain Rapier events into internal buffers. Clears previous events first. */\n  public drain(entityMap: ColliderEntityMap, world: IColliderSensorChecker): void {\n    this.clear();\n    this._currentEntityMap = entityMap;\n    this._currentWorld = world;\n\n    this._eventQueue.drainCollisionEvents(this._drainCollisionCb);\n    this._eventQueue.drainContactForceEvents(this._drainForceCb);\n\n    this._currentEntityMap = null;\n    this._currentWorld = null;\n  }\n\n  /** Clear all event buffers. */\n  public clear(): void {\n    this._collisionEnterCount = 0;\n    this._collisionExitCount = 0;\n    this._sensorEnterCount = 0;\n    this._sensorExitCount = 0;\n    this._contactForceCount = 0;\n  }\n\n  // --- Collision enter ---\n  public get collisionEnterCount(): number { return this._collisionEnterCount; }\n  public collisionEnterEntityA(index: number): number { return this._collisionEnterA[index]; }\n  public collisionEnterEntityB(index: number): number { return this._collisionEnterB[index]; }\n\n  // --- Collision exit ---\n  public get collisionExitCount(): number { return this._collisionExitCount; }\n  public collisionExitEntityA(index: number): number { return this._collisionExitA[index]; }\n  public collisionExitEntityB(index: number): number { return this._collisionExitB[index]; }\n\n  // --- Sensor enter ---\n  public get sensorEnterCount(): number { return this._sensorEnterCount; }\n  public sensorEnterEntityA(index: number): number { return this._sensorEnterA[index]; }\n  public sensorEnterEntityB(index: number): number { return this._sensorEnterB[index]; }\n\n  // --- Sensor exit ---\n  public get sensorExitCount(): number { return this._sensorExitCount; }\n  public sensorExitEntityA(index: number): number { return this._sensorExitA[index]; }\n  public sensorExitEntityB(index: number): number { return this._sensorExitB[index]; }\n\n  // --- Contact forces ---\n  public get contactForceCount(): number { return this._contactForceCount; }\n  public contactForceEntityA(index: number): number { return this._contactForceA[index]; }\n  public contactForceEntityB(index: number): number { return this._contactForceB[index]; }\n  public contactForceMagnitude(index: number): number { return this._contactForceMagnitude[index]; }\n\n  public dispose(): void {\n    this._eventQueue.free();\n  }\n\n  // --- Internal push methods with auto-grow ---\n\n  private _pushCollisionEnter(a: number, b: number): void {\n    const idx = this._collisionEnterCount++;\n    if (idx >= this._collisionEnterA.length) {\n      this._collisionEnterA = _grow(this._collisionEnterA);\n      this._collisionEnterB = _grow(this._collisionEnterB);\n    }\n    this._collisionEnterA[idx] = a;\n    this._collisionEnterB[idx] = b;\n  }\n\n  private _pushCollisionExit(a: number, b: number): void {\n    const idx = this._collisionExitCount++;\n    if (idx >= this._collisionExitA.length) {\n      this._collisionExitA = _grow(this._collisionExitA);\n      this._collisionExitB = _grow(this._collisionExitB);\n    }\n    this._collisionExitA[idx] = a;\n    this._collisionExitB[idx] = b;\n  }\n\n  private _pushSensorEnter(nonSensor: number, sensor: number): void {\n    const idx = this._sensorEnterCount++;\n    if (idx >= this._sensorEnterA.length) {\n      this._sensorEnterA = _grow(this._sensorEnterA);\n      this._sensorEnterB = _grow(this._sensorEnterB);\n    }\n    this._sensorEnterA[idx] = nonSensor;\n    this._sensorEnterB[idx] = sensor;\n  }\n\n  private _pushSensorExit(nonSensor: number, sensor: number): void {\n    const idx = this._sensorExitCount++;\n    if (idx >= this._sensorExitA.length) {\n      this._sensorExitA = _grow(this._sensorExitA);\n      this._sensorExitB = _grow(this._sensorExitB);\n    }\n    this._sensorExitA[idx] = nonSensor;\n    this._sensorExitB[idx] = sensor;\n  }\n\n  private _pushContactForce(a: number, b: number, magnitude: number): void {\n    const idx = this._contactForceCount++;\n    if (idx >= this._contactForceA.length) {\n      this._contactForceA = _grow(this._contactForceA);\n      this._contactForceB = _grow(this._contactForceB);\n      this._contactForceMagnitude = _growFloat(this._contactForceMagnitude);\n    }\n    this._contactForceA[idx] = a;\n    this._contactForceB[idx] = b;\n    this._contactForceMagnitude[idx] = magnitude;\n  }\n}\n\nfunction _grow(arr: Int32Array): Int32Array {\n  const next = new Int32Array(arr.length * 2);\n  next.set(arr);\n  return next;\n}\n\nfunction _growFloat(arr: Float32Array): Float32Array {\n  const next = new Float32Array(arr.length * 2);\n  next.set(arr);\n  return next;\n}\n"],"names":["UNMAPPED_ENTITY","DEFAULT_CAPACITY","CollisionEventsBase","eventQueue","_eventQueue","drain","entityMap","world","clear","_currentEntityMap","_currentWorld","drainCollisionEvents","_drainCollisionCb","drainContactForceEvents","_drainForceCb","_collisionEnterCount","_collisionExitCount","_sensorEnterCount","_sensorExitCount","_contactForceCount","collisionEnterCount","collisionEnterEntityA","index","_collisionEnterA","collisionEnterEntityB","_collisionEnterB","collisionExitCount","collisionExitEntityA","_collisionExitA","collisionExitEntityB","_collisionExitB","sensorEnterCount","sensorEnterEntityA","_sensorEnterA","sensorEnterEntityB","_sensorEnterB","sensorExitCount","sensorExitEntityA","_sensorExitA","sensorExitEntityB","_sensorExitB","contactForceCount","contactForceEntityA","_contactForceA","contactForceEntityB","_contactForceB","contactForceMagnitude","_contactForceMagnitude","dispose","free","_pushCollisionEnter","a","b","idx","length","_grow","_pushCollisionExit","_pushSensorEnter","nonSensor","sensor","_pushSensorExit","_pushContactForce","magnitude","_growFloat","constructor","eventQueueFactory","initialCapacity","Int32Array","Float32Array","h1","h2","started","e1","get","e2","c1","getCollider","c2","c1Sensor","isSensor","c2Sensor","nonSensorE","sensorE","event","collider1","collider2","totalForceMagnitude","arr","next","set"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/lib/collision-layers.d.ts

@@ -0,0 +1,20 @@
+export declare class CollisionLayers {
+    private _nextBit;
+    private readonly _names;
+    private readonly _pairs;
+    /** Register a named layer, returns bit index (0..15). */
+    layer(name: string): number;
+    /** Allow interactions between two layers (bidirectional). */
+    pair(a: string, b: string): this;
+    /** Allow a layer to interact with itself. */
+    selfPair(name: string): this;
+    /**
+     * Build Rapier InteractionGroups for a given layer name.
+     * Returns u32: bits 0-15 = membership (1 << bit), bits 16-31 = filter mask.
+     */
+    groups(name: string): number;
+    /** Get bit index for a layer name. */
+    bit(name: string): number;
+    private _bit;
+}
+//# sourceMappingURL=collision-layers.d.ts.map

package/dist/lib/collision-layers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision-layers.d.ts","sourceRoot":"","sources":["../../src/lib/collision-layers.ts"],"names":[],"mappings":"AAEA,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;IAEtD,yDAAyD;IAClD,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAYlC,6DAA6D;IACtD,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAQvC,6CAA6C;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAMnC;;;OAGG;IACI,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAOnC,sCAAsC;IAC/B,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAIhC,OAAO,CAAC,IAAI;CAOb"}

package/dist/lib/collision-layers.js

@@ -0,0 +1,53 @@
+const MAX_LAYERS = 16;
+export class CollisionLayers {
+    /** Register a named layer, returns bit index (0..15). */ layer(name) {
+        if (this._names.has(name)) {
+            throw new Error(`CollisionLayers: layer "${name}" already exists`);
+        }
+        if (this._nextBit >= MAX_LAYERS) {
+            throw new Error(`CollisionLayers: maximum ${MAX_LAYERS} layers exceeded`);
+        }
+        const bit = this._nextBit++;
+        this._names.set(name, bit);
+        return bit;
+    }
+    /** Allow interactions between two layers (bidirectional). */ pair(a, b) {
+        const bitA = this._bit(a);
+        const bitB = this._bit(b);
+        this._pairs[bitA] |= 1 << bitB;
+        this._pairs[bitB] |= 1 << bitA;
+        return this;
+    }
+    /** Allow a layer to interact with itself. */ selfPair(name) {
+        const bit = this._bit(name);
+        this._pairs[bit] |= 1 << bit;
+        return this;
+    }
+    /**
+   * Build Rapier InteractionGroups for a given layer name.
+   * Returns u32: bits 0-15 = membership (1 << bit), bits 16-31 = filter mask.
+   */ groups(name) {
+        const bit = this._bit(name);
+        const membership = 1 << bit;
+        const filter = this._pairs[bit];
+        return filter << 16 | membership;
+    }
+    /** Get bit index for a layer name. */ bit(name) {
+        return this._bit(name);
+    }
+    _bit(name) {
+        const bit = this._names.get(name);
+        if (bit === undefined) {
+            throw new Error(`CollisionLayers: unknown layer "${name}"`);
+        }
+        return bit;
+    }
+    constructor(){
+        this._nextBit = 0;
+        this._names = new Map();
+        this._pairs = new Uint16Array(MAX_LAYERS) // per-layer filter mask
+        ;
+    }
+}
+
+//# sourceMappingURL=collision-layers.js.map

package/dist/lib/collision-layers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/collision-layers.ts"],"sourcesContent":["const MAX_LAYERS = 16;\n\nexport class CollisionLayers {\n  private _nextBit = 0;\n  private readonly _names = new Map<string, number>();\n  private readonly _pairs = new Uint16Array(MAX_LAYERS); // per-layer filter mask\n\n  /** Register a named layer, returns bit index (0..15). */\n  public layer(name: string): number {\n    if (this._names.has(name)) {\n      throw new Error(`CollisionLayers: layer \"${name}\" already exists`);\n    }\n    if (this._nextBit >= MAX_LAYERS) {\n      throw new Error(`CollisionLayers: maximum ${MAX_LAYERS} layers exceeded`);\n    }\n    const bit = this._nextBit++;\n    this._names.set(name, bit);\n    return bit;\n  }\n\n  /** Allow interactions between two layers (bidirectional). */\n  public pair(a: string, b: string): this {\n    const bitA = this._bit(a);\n    const bitB = this._bit(b);\n    this._pairs[bitA] |= (1 << bitB);\n    this._pairs[bitB] |= (1 << bitA);\n    return this;\n  }\n\n  /** Allow a layer to interact with itself. */\n  public selfPair(name: string): this {\n    const bit = this._bit(name);\n    this._pairs[bit] |= (1 << bit);\n    return this;\n  }\n\n  /**\n   * Build Rapier InteractionGroups for a given layer name.\n   * Returns u32: bits 0-15 = membership (1 << bit), bits 16-31 = filter mask.\n   */\n  public groups(name: string): number {\n    const bit = this._bit(name);\n    const membership = 1 << bit;\n    const filter = this._pairs[bit];\n    return (filter << 16) | membership;\n  }\n\n  /** Get bit index for a layer name. */\n  public bit(name: string): number {\n    return this._bit(name);\n  }\n\n  private _bit(name: string): number {\n    const bit = this._names.get(name);\n    if (bit === undefined) {\n      throw new Error(`CollisionLayers: unknown layer \"${name}\"`);\n    }\n    return bit;\n  }\n}\n"],"names":["MAX_LAYERS","CollisionLayers","layer","name","_names","has","Error","_nextBit","bit","set","pair","a","b","bitA","_bit","bitB","_pairs","selfPair","groups","membership","filter","get","undefined","Map","Uint16Array"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,MAAMA,aAAa;AAEnB,OAAO,MAAMC;IAKX,uDAAuD,GACvD,AAAOC,MAAMC,IAAY,EAAU;QACjC,IAAI,IAAI,CAACC,MAAM,CAACC,GAAG,CAACF,OAAO;YACzB,MAAM,IAAIG,MAAM,CAAC,wBAAwB,EAAEH,KAAK,gBAAgB,CAAC;QACnE;QACA,IAAI,IAAI,CAACI,QAAQ,IAAIP,YAAY;YAC/B,MAAM,IAAIM,MAAM,CAAC,yBAAyB,EAAEN,WAAW,gBAAgB,CAAC;QAC1E;QACA,MAAMQ,MAAM,IAAI,CAACD,QAAQ;QACzB,IAAI,CAACH,MAAM,CAACK,GAAG,CAACN,MAAMK;QACtB,OAAOA;IACT;IAEA,2DAA2D,GAC3D,AAAOE,KAAKC,CAAS,EAAEC,CAAS,EAAQ;QACtC,MAAMC,OAAO,IAAI,CAACC,IAAI,CAACH;QACvB,MAAMI,OAAO,IAAI,CAACD,IAAI,CAACF;QACvB,IAAI,CAACI,MAAM,CAACH,KAAK,IAAK,KAAKE;QAC3B,IAAI,CAACC,MAAM,CAACD,KAAK,IAAK,KAAKF;QAC3B,OAAO,IAAI;IACb;IAEA,2CAA2C,GAC3C,AAAOI,SAASd,IAAY,EAAQ;QAClC,MAAMK,MAAM,IAAI,CAACM,IAAI,CAACX;QACtB,IAAI,CAACa,MAAM,CAACR,IAAI,IAAK,KAAKA;QAC1B,OAAO,IAAI;IACb;IAEA;;;GAGC,GACD,AAAOU,OAAOf,IAAY,EAAU;QAClC,MAAMK,MAAM,IAAI,CAACM,IAAI,CAACX;QACtB,MAAMgB,aAAa,KAAKX;QACxB,MAAMY,SAAS,IAAI,CAACJ,MAAM,CAACR,IAAI;QAC/B,OAAO,AAACY,UAAU,KAAMD;IAC1B;IAEA,oCAAoC,GACpC,AAAOX,IAAIL,IAAY,EAAU;QAC/B,OAAO,IAAI,CAACW,IAAI,CAACX;IACnB;IAEQW,KAAKX,IAAY,EAAU;QACjC,MAAMK,MAAM,IAAI,CAACJ,MAAM,CAACiB,GAAG,CAAClB;QAC5B,IAAIK,QAAQc,WAAW;YACrB,MAAM,IAAIhB,MAAM,CAAC,gCAAgC,EAAEH,KAAK,CAAC,CAAC;QAC5D;QACA,OAAOK;IACT;;aAvDQD,WAAW;aACFH,SAAS,IAAImB;aACbP,SAAS,IAAIQ,YAAYxB,YAAa,wBAAwB;;;AAsDjF"}

package/dist/lib/physics-simulation-base.d.ts

@@ -0,0 +1,34 @@
+import { ECSConfig, ECSSimulation, AbstractInputProvider, ECSDeps } from '@lagless/core';
+/** Minimal interface for a physics world manager that supports snapshot/restore. */
+export interface IPhysicsWorldManagerBase {
+    takeSnapshot(): Uint8Array;
+    restoreSnapshot(data: Uint8Array): void;
+}
+export declare class PhysicsSimulationBase extends ECSSimulation {
+    private readonly _physicsWorldManager;
+    private _rapierSnapshotHistory;
+    private readonly _initialRapierSnapshot;
+    constructor(config: ECSConfig, deps: ECSDeps, inputProvider: AbstractInputProvider, _physicsWorldManager: IPhysicsWorldManagerBase);
+    protected saveSnapshot(tick: number): void;
+    protected rollback(tick: number): void;
+    applyExternalState(state: ArrayBuffer, tick: number): void;
+    /**
+     * Apply an external Rapier snapshot (e.g. from late-join state transfer).
+     */
+    applyExternalPhysicsState(rapierSnapshot: Uint8Array, tick: number): void;
+    /**
+     * Export current Rapier world snapshot for state transfer.
+     */
+    exportPhysicsSnapshot(): Uint8Array;
+    /**
+     * Export combined ECS + Rapier state for network transfer.
+     * Format: [ecsLength:u32LE][ecsBytes][rapierBytes]
+     */
+    exportStateForTransfer(): ArrayBuffer;
+    /**
+     * Apply combined ECS + Rapier state from network transfer.
+     * Splits the blob, applies ECS state, restores Rapier world, saves snapshot.
+     */
+    applyStateFromTransfer(blob: ArrayBuffer, tick: number): void;
+}
+//# sourceMappingURL=physics-simulation-base.d.ts.map

package/dist/lib/physics-simulation-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"physics-simulation-base.d.ts","sourceRoot":"","sources":["../../src/lib/physics-simulation-base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAKzF,oFAAoF;AACpF,MAAM,WAAW,wBAAwB;IACvC,YAAY,IAAI,UAAU,CAAC;IAC3B,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;CACzC;AAED,qBAAa,qBAAsB,SAAQ,aAAa;IAQpD,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IAPvC,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAa;gBAGlD,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,OAAO,EACb,aAAa,EAAE,qBAAqB,EACnB,oBAAoB,EAAE,wBAAwB;cAO9C,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;cAKhC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAkB/B,kBAAkB,CAAC,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAQ1E;;OAEG;IACI,yBAAyB,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAOhF;;OAEG;IACI,qBAAqB,IAAI,UAAU;IAI1C;;;OAGG;IACa,sBAAsB,IAAI,WAAW;IAcrD;;;OAGG;IACa,sBAAsB,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;CAoB9E"}

package/dist/lib/physics-simulation-base.js

@@ -0,0 +1,84 @@
+import { ECSSimulation } from '@lagless/core';
+import { SnapshotHistory, createLogger } from '@lagless/misc';
+const log = createLogger('PhysicsSimulationBase');
+export class PhysicsSimulationBase extends ECSSimulation {
+    saveSnapshot(tick) {
+        super.saveSnapshot(tick);
+        this._rapierSnapshotHistory.set(tick, this._physicsWorldManager.takeSnapshot());
+    }
+    rollback(tick) {
+        // Rollback ECS state first (calls super which restores ArrayBuffer)
+        super.rollback(tick);
+        // Rollback Rapier world
+        let rapierSnapshot;
+        try {
+            rapierSnapshot = this._rapierSnapshotHistory.getNearest(tick);
+            log.warn(`Rapier rollback to tick ${tick} succeeded`);
+        } catch (e) {
+            rapierSnapshot = this._initialRapierSnapshot;
+            log.warn(`Rapier rollback to tick ${tick} failed, using initial snapshot`);
+        }
+        this._physicsWorldManager.restoreSnapshot(rapierSnapshot);
+        this._rapierSnapshotHistory.rollback(this.mem.tickManager.tick);
+    }
+    applyExternalState(state, tick) {
+        // Reset rapier snapshot history BEFORE super call — super.applyExternalState()
+        // calls this.saveSnapshot(tick), which writes to _rapierSnapshotHistory.
+        // If we reset after, the old _lastTick causes "Ticks must be non-decreasing".
+        this._rapierSnapshotHistory = new SnapshotHistory(this._ECSConfig.snapshotHistorySize);
+        super.applyExternalState(state, tick);
+    }
+    /**
+   * Apply an external Rapier snapshot (e.g. from late-join state transfer).
+   */ applyExternalPhysicsState(rapierSnapshot, tick) {
+        log.info(`Applying external physics state at tick ${tick} (${rapierSnapshot.byteLength} bytes)`);
+        this._physicsWorldManager.restoreSnapshot(rapierSnapshot);
+        this._rapierSnapshotHistory = new SnapshotHistory(this._ECSConfig.snapshotHistorySize);
+        this._rapierSnapshotHistory.set(tick, this._physicsWorldManager.takeSnapshot());
+    }
+    /**
+   * Export current Rapier world snapshot for state transfer.
+   */ exportPhysicsSnapshot() {
+        return this._physicsWorldManager.takeSnapshot();
+    }
+    /**
+   * Export combined ECS + Rapier state for network transfer.
+   * Format: [ecsLength:u32LE][ecsBytes][rapierBytes]
+   */ exportStateForTransfer() {
+        const ecsSnapshot = this.mem.exportSnapshot();
+        const rapierSnapshot = this._physicsWorldManager.takeSnapshot();
+        const blob = new ArrayBuffer(4 + ecsSnapshot.byteLength + rapierSnapshot.byteLength);
+        const view = new DataView(blob);
+        view.setUint32(0, ecsSnapshot.byteLength, true);
+        new Uint8Array(blob, 4, ecsSnapshot.byteLength).set(new Uint8Array(ecsSnapshot));
+        new Uint8Array(blob, 4 + ecsSnapshot.byteLength).set(rapierSnapshot);
+        log.info(`exportStateForTransfer: ecs=${ecsSnapshot.byteLength} rapier=${rapierSnapshot.byteLength} total=${blob.byteLength}`);
+        return blob;
+    }
+    /**
+   * Apply combined ECS + Rapier state from network transfer.
+   * Splits the blob, applies ECS state, restores Rapier world, saves snapshot.
+   */ applyStateFromTransfer(blob, tick) {
+        const view = new DataView(blob);
+        const ecsLength = view.getUint32(0, true);
+        const ecsState = blob.slice(4, 4 + ecsLength);
+        const rapierBytes = new Uint8Array(blob, 4 + ecsLength);
+        log.info(`applyStateFromTransfer: tick=${tick} ecs=${ecsLength} rapier=${rapierBytes.byteLength}`);
+        // Apply ECS state (calls applyExternalState → saveSnapshot)
+        this.applyExternalState(ecsState, tick);
+        // Restore Rapier world from transferred snapshot
+        this._physicsWorldManager.restoreSnapshot(rapierBytes);
+        // Save rapier snapshot at this tick (overwrite the empty one saved by applyExternalState)
+        this._rapierSnapshotHistory = new SnapshotHistory(this._ECSConfig.snapshotHistorySize);
+        this._rapierSnapshotHistory.set(tick, this._physicsWorldManager.takeSnapshot());
+        this.notifyStateTransferHandlers(tick);
+    }
+    constructor(config, deps, inputProvider, _physicsWorldManager){
+        super(config, deps, inputProvider);
+        this._physicsWorldManager = _physicsWorldManager;
+        this._rapierSnapshotHistory = new SnapshotHistory(config.snapshotHistorySize);
+        this._initialRapierSnapshot = this._physicsWorldManager.takeSnapshot();
+    }
+}
+
+//# sourceMappingURL=physics-simulation-base.js.map

package/dist/lib/physics-simulation-base.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/physics-simulation-base.ts"],"sourcesContent":["import { ECSConfig, ECSSimulation, AbstractInputProvider, ECSDeps } from '@lagless/core';\nimport { SnapshotHistory, createLogger } from '@lagless/misc';\n\nconst log = createLogger('PhysicsSimulationBase');\n\n/** Minimal interface for a physics world manager that supports snapshot/restore. */\nexport interface IPhysicsWorldManagerBase {\n  takeSnapshot(): Uint8Array;\n  restoreSnapshot(data: Uint8Array): void;\n}\n\nexport class PhysicsSimulationBase extends ECSSimulation {\n  private _rapierSnapshotHistory: SnapshotHistory<Uint8Array>;\n  private readonly _initialRapierSnapshot: Uint8Array;\n\n  constructor(\n    config: ECSConfig,\n    deps: ECSDeps,\n    inputProvider: AbstractInputProvider,\n    private readonly _physicsWorldManager: IPhysicsWorldManagerBase,\n  ) {\n    super(config, deps, inputProvider);\n    this._rapierSnapshotHistory = new SnapshotHistory<Uint8Array>(config.snapshotHistorySize);\n    this._initialRapierSnapshot = this._physicsWorldManager.takeSnapshot();\n  }\n\n  protected override saveSnapshot(tick: number): void {\n    super.saveSnapshot(tick);\n    this._rapierSnapshotHistory.set(tick, this._physicsWorldManager.takeSnapshot());\n  }\n\n  protected override rollback(tick: number): void {\n    // Rollback ECS state first (calls super which restores ArrayBuffer)\n    super.rollback(tick);\n\n    // Rollback Rapier world\n    let rapierSnapshot: Uint8Array;\n    try {\n      rapierSnapshot = this._rapierSnapshotHistory.getNearest(tick);\n      log.warn(`Rapier rollback to tick ${tick} succeeded`);\n    } catch {\n      rapierSnapshot = this._initialRapierSnapshot;\n      log.warn(`Rapier rollback to tick ${tick} failed, using initial snapshot`);\n    }\n\n    this._physicsWorldManager.restoreSnapshot(rapierSnapshot);\n    this._rapierSnapshotHistory.rollback(this.mem.tickManager.tick);\n  }\n\n  public override applyExternalState(state: ArrayBuffer, tick: number): void {\n    // Reset rapier snapshot history BEFORE super call — super.applyExternalState()\n    // calls this.saveSnapshot(tick), which writes to _rapierSnapshotHistory.\n    // If we reset after, the old _lastTick causes \"Ticks must be non-decreasing\".\n    this._rapierSnapshotHistory = new SnapshotHistory<Uint8Array>(this._ECSConfig.snapshotHistorySize);\n    super.applyExternalState(state, tick);\n  }\n\n  /**\n   * Apply an external Rapier snapshot (e.g. from late-join state transfer).\n   */\n  public applyExternalPhysicsState(rapierSnapshot: Uint8Array, tick: number): void {\n    log.info(`Applying external physics state at tick ${tick} (${rapierSnapshot.byteLength} bytes)`);\n    this._physicsWorldManager.restoreSnapshot(rapierSnapshot);\n    this._rapierSnapshotHistory = new SnapshotHistory<Uint8Array>(this._ECSConfig.snapshotHistorySize);\n    this._rapierSnapshotHistory.set(tick, this._physicsWorldManager.takeSnapshot());\n  }\n\n  /**\n   * Export current Rapier world snapshot for state transfer.\n   */\n  public exportPhysicsSnapshot(): Uint8Array {\n    return this._physicsWorldManager.takeSnapshot();\n  }\n\n  /**\n   * Export combined ECS + Rapier state for network transfer.\n   * Format: [ecsLength:u32LE][ecsBytes][rapierBytes]\n   */\n  public override exportStateForTransfer(): ArrayBuffer {\n    const ecsSnapshot = this.mem.exportSnapshot();\n    const rapierSnapshot = this._physicsWorldManager.takeSnapshot();\n\n    const blob = new ArrayBuffer(4 + ecsSnapshot.byteLength + rapierSnapshot.byteLength);\n    const view = new DataView(blob);\n    view.setUint32(0, ecsSnapshot.byteLength, true);\n    new Uint8Array(blob, 4, ecsSnapshot.byteLength).set(new Uint8Array(ecsSnapshot));\n    new Uint8Array(blob, 4 + ecsSnapshot.byteLength).set(rapierSnapshot);\n\n    log.info(`exportStateForTransfer: ecs=${ecsSnapshot.byteLength} rapier=${rapierSnapshot.byteLength} total=${blob.byteLength}`);\n    return blob;\n  }\n\n  /**\n   * Apply combined ECS + Rapier state from network transfer.\n   * Splits the blob, applies ECS state, restores Rapier world, saves snapshot.\n   */\n  public override applyStateFromTransfer(blob: ArrayBuffer, tick: number): void {\n    const view = new DataView(blob);\n    const ecsLength = view.getUint32(0, true);\n    const ecsState = blob.slice(4, 4 + ecsLength);\n    const rapierBytes = new Uint8Array(blob, 4 + ecsLength);\n\n    log.info(`applyStateFromTransfer: tick=${tick} ecs=${ecsLength} rapier=${rapierBytes.byteLength}`);\n\n    // Apply ECS state (calls applyExternalState → saveSnapshot)\n    this.applyExternalState(ecsState, tick);\n\n    // Restore Rapier world from transferred snapshot\n    this._physicsWorldManager.restoreSnapshot(rapierBytes);\n\n    // Save rapier snapshot at this tick (overwrite the empty one saved by applyExternalState)\n    this._rapierSnapshotHistory = new SnapshotHistory<Uint8Array>(this._ECSConfig.snapshotHistorySize);\n    this._rapierSnapshotHistory.set(tick, this._physicsWorldManager.takeSnapshot());\n\n    this.notifyStateTransferHandlers(tick);\n  }\n}\n"],"names":["ECSSimulation","SnapshotHistory","createLogger","log","PhysicsSimulationBase","saveSnapshot","tick","_rapierSnapshotHistory","set","_physicsWorldManager","takeSnapshot","rollback","rapierSnapshot","getNearest","warn","_initialRapierSnapshot","restoreSnapshot","mem","tickManager","applyExternalState","state","_ECSConfig","snapshotHistorySize","applyExternalPhysicsState","info","byteLength","exportPhysicsSnapshot","exportStateForTransfer","ecsSnapshot","exportSnapshot","blob","ArrayBuffer","view","DataView","setUint32","Uint8Array","applyStateFromTransfer","ecsLength","getUint32","ecsState","slice","rapierBytes","notifyStateTransferHandlers","constructor","config","deps","inputProvider"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/lib/physics-sync-interfaces.d.ts

@@ -0,0 +1,23 @@
+export interface IPhysicsRefsComponent {
+    bodyHandle: {
+        get(entity: number): number;
+        set(entity: number, v: number): void;
+    };
+    bodyType: {
+        get(entity: number): number;
+        set(entity: number, v: number): void;
+    };
+    colliderHandle: {
+        get(entity: number): number;
+        set(entity: number, v: number): void;
+    };
+    collisionLayer: {
+        get(entity: number): number;
+        set(entity: number, v: number): void;
+    };
+}
+export interface IFilter {
+    readonly length: number;
+    entities(index: number): number;
+}
+//# sourceMappingURL=physics-sync-interfaces.d.ts.map

package/dist/lib/physics-sync-interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"physics-sync-interfaces.d.ts","sourceRoot":"","sources":["../../src/lib/physics-sync-interfaces.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE;QAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IAClF,QAAQ,EAAE;QAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IAChF,cAAc,EAAE;QAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACtF,cAAc,EAAE;QAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;CACvF;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC"}

package/dist/lib/physics-sync-interfaces.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=physics-sync-interfaces.js.map

package/dist/lib/physics-sync-interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/physics-sync-interfaces.ts"],"sourcesContent":["export interface IPhysicsRefsComponent {\n  bodyHandle: { get(entity: number): number; set(entity: number, v: number): void };\n  bodyType: { get(entity: number): number; set(entity: number, v: number): void };\n  colliderHandle: { get(entity: number): number; set(entity: number, v: number): void };\n  collisionLayer: { get(entity: number): number; set(entity: number, v: number): void };\n}\n\nexport interface IFilter {\n  readonly length: number;\n  entities(index: number): number;\n}\n"],"names":[],"rangeMappings":"","mappings":"AAOA,WAGC"}

package/dist/tsconfig.lib.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.9.3"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@lagless/physics-shared",
+  "version": "0.0.38",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GbGr/lagless",
+    "directory": "libs/physics-shared"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@lagless/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "nx": {
+    "sourceRoot": "libs/physics-shared/src",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:swc",
+        "outputs": [
+          "{options.outputPath}"
+        ],
+        "options": {
+          "outputPath": "libs/physics-shared/dist",
+          "main": "libs/physics-shared/src/index.ts",
+          "tsConfig": "libs/physics-shared/tsconfig.lib.json",
+          "stripLeadingPaths": true
+        }
+      }
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "~0.5.11",
+    "@lagless/core": "0.0.38",
+    "@lagless/misc": "0.0.38"
+  },
+  "devDependencies": {
+    "unplugin-swc": "^1.5.7"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}