@woosh/meep-engine 2.138.20 → 2.139.0

package/src/engine/physics/ecs/RigidBody.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Sentinel value for {@link RigidBody#_bodyId} prior to allocation by a
+ * {@link PhysicsSystem}. After {@link PhysicsSystem#link}, the id is a packed
+ * `(index << 8) | generation` integer.
+ *
+ * @type {number}
+ */
+export const RIGID_BODY_UNALLOCATED: number;
+/**
+ * Rigid-body component.
+ *
+ * Pose lives on {@link Transform}; this component owns the dynamic state that is not
+ * part of TRS: velocity, mass, inertia, damping, gravity scale, layer / mask
+ * filtering and a small set of bit-flags ({@link RigidBodyFlags}).
+ *
+ * Defaults are conservative: the body translates under forces but cannot rotate
+ * unless the user explicitly sets {@link inverseInertiaLocal} — forgetting to
+ * configure inertia results in a locked-rotation body, never a NaN tumble.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class RigidBody {
+    /**
+     * @type {BodyKind|number}
+     */
+    kind: BodyKind | number;
+    /**
+     * Linear velocity in world space, m/s.
+     * @readonly
+     * @type {Vector3}
+     */
+    readonly linearVelocity: Vector3;
+    /**
+     * Angular velocity in world space, rad/s.
+     * @readonly
+     * @type {Vector3}
+     */
+    readonly angularVelocity: Vector3;
+    /**
+     * Accumulator for forces applied between fixed-update steps. Consumed and
+     * zeroed by the integrator. User code applies via
+     * {@link PhysicsSystem#applyForce}; do not write directly.
+     * @readonly
+     * @type {Vector3}
+     */
+    readonly accumulatedForce: Vector3;
+    /**
+     * Accumulator for torques applied between fixed-update steps. Consumed and
+     * zeroed by the integrator.
+     * @readonly
+     * @type {Vector3}
+     */
+    readonly accumulatedTorque: Vector3;
+    /**
+     * Total mass, kg. Must be positive for Dynamic bodies; Static / Kinematic
+     * bodies behave as if mass were infinite regardless of this value.
+     * @type {number}
+     */
+    mass: number;
+    /**
+     * Inverse principal-frame inertia, diagonal. Components of zero lock the
+     * corresponding rotational degree of freedom. The default of (0,0,0) means
+     * rotation is locked until the user sets a value.
+     * @readonly
+     * @type {Vector3}
+     */
+    readonly inverseInertiaLocal: Vector3;
+    /**
+     * @type {number}
+     */
+    linearDamping: number;
+    /**
+     * @type {number}
+     */
+    angularDamping: number;
+    /**
+     * Multiplier for the world gravity on this body. 1 = normal gravity,
+     * 0 = floating, negative values invert.
+     * @type {number}
+     */
+    gravityScale: number;
+    /**
+     * Layer bitmask identifying this body's category.
+     * @type {number}
+     */
+    layer: number;
+    /**
+     * Mask of layers this body collides with.
+     * @type {number}
+     */
+    mask: number;
+    /**
+     * @type {RigidBodyFlags|number}
+     */
+    flags: RigidBodyFlags | number;
+    /**
+     * Owned by the {@link PhysicsSystem}; user code must not write.
+     * @type {SleepState|number}
+     */
+    sleepState: SleepState | number;
+    /**
+     * Seconds spent below the sleep-threshold velocity. The system increments
+     * this each step the body is essentially at rest; once it crosses
+     * {@link PhysicsSystem}'s sleep threshold, the body is moved out of the
+     * active set. Reset to 0 whenever the body moves above threshold.
+     *
+     * Transient runtime state — not serialised, not user-writable.
+     * @type {number}
+     */
+    sleep_timer: number;
+    /**
+     * Next body in this body's atomic-sleep group, expressed as a body
+     * **index** (NOT a packed id). Sleep groups are circular doubly-linked
+     * lists threaded through every member when an island goes to sleep
+     * atomically; on wake, the physics system walks the chain to wake every
+     * member in the same step.
+     *
+     * `-1` when the body is awake or asleep as a singleton.
+     *
+     * Transient runtime state — not serialised, not user-writable.
+     * @type {number}
+     */
+    sleep_group_next: number;
+    /**
+     * Previous body in this body's atomic-sleep group. See {@link sleep_group_next}.
+     * @type {number}
+     */
+    sleep_group_prev: number;
+    /**
+     * Packed `(index << 8) | generation` body handle. {@link RIGID_BODY_UNALLOCATED}
+     * before the body is linked into a {@link PhysicsSystem}. System-private.
+     * @type {number}
+     */
+    _bodyId: number;
+    /**
+     *
+     * @param {number|RigidBodyFlags} flag
+     */
+    setFlag(flag: number | RigidBodyFlags): void;
+    /**
+     *
+     * @param {number|RigidBodyFlags} flag
+     */
+    clearFlag(flag: number | RigidBodyFlags): void;
+    /**
+     *
+     * @param {number|RigidBodyFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag: number | RigidBodyFlags): boolean;
+    /**
+     *
+     * @param {number|RigidBodyFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag: number | RigidBodyFlags, value: boolean): void;
+    toJSON(): {
+        kind: number;
+        linearVelocity: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        angularVelocity: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        mass: number;
+        inverseInertiaLocal: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        linearDamping: number;
+        angularDamping: number;
+        gravityScale: number;
+        layer: number;
+        mask: number;
+        flags: number;
+    };
+    fromJSON(json: any): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isRigidBody: boolean;
+}
+export namespace RigidBody {
+    let typeName: string;
+}
+import { BodyKind } from "./BodyKind.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { RigidBodyFlags } from "./RigidBodyFlags.js";
+import { SleepState } from "./SleepState.js";
+//# sourceMappingURL=RigidBody.d.ts.map

package/src/engine/physics/ecs/RigidBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RigidBody.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBody.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB;AAEzC;;;;;;;;;;;;;GAaG;AACH;IAEI;;OAEG;IACH,MAFU,QAAQ,GAAC,MAAM,CAED;IAExB;;;;OAIG;IACH,yBAFU,OAAO,CAEqB;IAEtC;;;;OAIG;IACH,0BAFU,OAAO,CAEsB;IAEvC;;;;;;OAMG;IACH,2BAFU,OAAO,CAEuB;IAExC;;;;;OAKG;IACH,4BAFU,OAAO,CAEwB;IAEzC;;;;OAIG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,8BAFU,OAAO,CAE0B;IAE3C;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;OAEG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEM;IAEtB;;OAEG;IACH,OAFU,cAAc,GAAC,MAAM,CAEH;IAE5B;;;OAGG;IACH,YAFU,UAAU,GAAC,MAAM,CAEG;IAE9B;;;;;;;;OAQG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;;;;;;;OAWG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,SAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,cAFW,MAAM,GAAC,cAAc,QAI/B;IAED;;;OAGG;IACH,gBAFW,MAAM,GAAC,cAAc,QAI/B;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;;;;;;;;;;;;;;;;;;;;;MAcC;IAED,0BAYC;IASL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAZ9B;;kBAIS,MAAM;;yBAtOS,eAAe;oBADpB,+BAA+B;+BAEpB,qBAAqB;2BACzB,iBAAiB"}

package/src/engine/physics/ecs/RigidBody.js

@@ -0,0 +1,240 @@
+import Vector3 from "../../../core/geom/Vector3.js";
+import { BodyKind } from "./BodyKind.js";
+import { RigidBodyFlags } from "./RigidBodyFlags.js";
+import { SleepState } from "./SleepState.js";
+
+/**
+ * Sentinel value for {@link RigidBody#_bodyId} prior to allocation by a
+ * {@link PhysicsSystem}. After {@link PhysicsSystem#link}, the id is a packed
+ * `(index << 8) | generation` integer.
+ *
+ * @type {number}
+ */
+export const RIGID_BODY_UNALLOCATED = -1;
+
+/**
+ * Rigid-body component.
+ *
+ * Pose lives on {@link Transform}; this component owns the dynamic state that is not
+ * part of TRS: velocity, mass, inertia, damping, gravity scale, layer / mask
+ * filtering and a small set of bit-flags ({@link RigidBodyFlags}).
+ *
+ * Defaults are conservative: the body translates under forces but cannot rotate
+ * unless the user explicitly sets {@link inverseInertiaLocal} — forgetting to
+ * configure inertia results in a locked-rotation body, never a NaN tumble.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class RigidBody {
+
+    /**
+     * @type {BodyKind|number}
+     */
+    kind = BodyKind.Dynamic;
+
+    /**
+     * Linear velocity in world space, m/s.
+     * @readonly
+     * @type {Vector3}
+     */
+    linearVelocity = new Vector3(0, 0, 0);
+
+    /**
+     * Angular velocity in world space, rad/s.
+     * @readonly
+     * @type {Vector3}
+     */
+    angularVelocity = new Vector3(0, 0, 0);
+
+    /**
+     * Accumulator for forces applied between fixed-update steps. Consumed and
+     * zeroed by the integrator. User code applies via
+     * {@link PhysicsSystem#applyForce}; do not write directly.
+     * @readonly
+     * @type {Vector3}
+     */
+    accumulatedForce = new Vector3(0, 0, 0);
+
+    /**
+     * Accumulator for torques applied between fixed-update steps. Consumed and
+     * zeroed by the integrator.
+     * @readonly
+     * @type {Vector3}
+     */
+    accumulatedTorque = new Vector3(0, 0, 0);
+
+    /**
+     * Total mass, kg. Must be positive for Dynamic bodies; Static / Kinematic
+     * bodies behave as if mass were infinite regardless of this value.
+     * @type {number}
+     */
+    mass = 1;
+
+    /**
+     * Inverse principal-frame inertia, diagonal. Components of zero lock the
+     * corresponding rotational degree of freedom. The default of (0,0,0) means
+     * rotation is locked until the user sets a value.
+     * @readonly
+     * @type {Vector3}
+     */
+    inverseInertiaLocal = new Vector3(0, 0, 0);
+
+    /**
+     * @type {number}
+     */
+    linearDamping = 0;
+
+    /**
+     * @type {number}
+     */
+    angularDamping = 0;
+
+    /**
+     * Multiplier for the world gravity on this body. 1 = normal gravity,
+     * 0 = floating, negative values invert.
+     * @type {number}
+     */
+    gravityScale = 1;
+
+    /**
+     * Layer bitmask identifying this body's category.
+     * @type {number}
+     */
+    layer = 1;
+
+    /**
+     * Mask of layers this body collides with.
+     * @type {number}
+     */
+    mask = 0xFFFFFFFF | 0;
+
+    /**
+     * @type {RigidBodyFlags|number}
+     */
+    flags = RigidBodyFlags.None;
+
+    /**
+     * Owned by the {@link PhysicsSystem}; user code must not write.
+     * @type {SleepState|number}
+     */
+    sleepState = SleepState.Awake;
+
+    /**
+     * Seconds spent below the sleep-threshold velocity. The system increments
+     * this each step the body is essentially at rest; once it crosses
+     * {@link PhysicsSystem}'s sleep threshold, the body is moved out of the
+     * active set. Reset to 0 whenever the body moves above threshold.
+     *
+     * Transient runtime state — not serialised, not user-writable.
+     * @type {number}
+     */
+    sleep_timer = 0;
+
+    /**
+     * Next body in this body's atomic-sleep group, expressed as a body
+     * **index** (NOT a packed id). Sleep groups are circular doubly-linked
+     * lists threaded through every member when an island goes to sleep
+     * atomically; on wake, the physics system walks the chain to wake every
+     * member in the same step.
+     *
+     * `-1` when the body is awake or asleep as a singleton.
+     *
+     * Transient runtime state — not serialised, not user-writable.
+     * @type {number}
+     */
+    sleep_group_next = -1;
+
+    /**
+     * Previous body in this body's atomic-sleep group. See {@link sleep_group_next}.
+     * @type {number}
+     */
+    sleep_group_prev = -1;
+
+    /**
+     * Packed `(index << 8) | generation` body handle. {@link RIGID_BODY_UNALLOCATED}
+     * before the body is linked into a {@link PhysicsSystem}. System-private.
+     * @type {number}
+     */
+    _bodyId = RIGID_BODY_UNALLOCATED;
+
+    /**
+     *
+     * @param {number|RigidBodyFlags} flag
+     */
+    setFlag(flag) {
+        this.flags |= flag;
+    }
+
+    /**
+     *
+     * @param {number|RigidBodyFlags} flag
+     */
+    clearFlag(flag) {
+        this.flags &= ~flag;
+    }
+
+    /**
+     *
+     * @param {number|RigidBodyFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag) {
+        return (this.flags & flag) === flag;
+    }
+
+    /**
+     *
+     * @param {number|RigidBodyFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag, value) {
+        if (value) {
+            this.setFlag(flag);
+        } else {
+            this.clearFlag(flag);
+        }
+    }
+
+    toJSON() {
+        return {
+            kind: this.kind,
+            linearVelocity: this.linearVelocity.toJSON(),
+            angularVelocity: this.angularVelocity.toJSON(),
+            mass: this.mass,
+            inverseInertiaLocal: this.inverseInertiaLocal.toJSON(),
+            linearDamping: this.linearDamping,
+            angularDamping: this.angularDamping,
+            gravityScale: this.gravityScale,
+            layer: this.layer,
+            mask: this.mask,
+            flags: this.flags,
+        };
+    }
+
+    fromJSON(json) {
+        if (json.kind !== undefined) this.kind = json.kind;
+        if (json.linearVelocity !== undefined) this.linearVelocity.fromJSON(json.linearVelocity);
+        if (json.angularVelocity !== undefined) this.angularVelocity.fromJSON(json.angularVelocity);
+        if (json.mass !== undefined) this.mass = json.mass;
+        if (json.inverseInertiaLocal !== undefined) this.inverseInertiaLocal.fromJSON(json.inverseInertiaLocal);
+        if (json.linearDamping !== undefined) this.linearDamping = json.linearDamping;
+        if (json.angularDamping !== undefined) this.angularDamping = json.angularDamping;
+        if (json.gravityScale !== undefined) this.gravityScale = json.gravityScale;
+        if (json.layer !== undefined) this.layer = json.layer;
+        if (json.mask !== undefined) this.mask = json.mask;
+        if (json.flags !== undefined) this.flags = json.flags;
+    }
+}
+
+/**
+ * @readonly
+ * @type {string}
+ */
+RigidBody.typeName = "RigidBody";
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+RigidBody.prototype.isRigidBody = true;

package/src/engine/physics/ecs/RigidBodyFlags.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Bit-flags carried on {@link RigidBody }.
+ *
+ * - {@link IsSensor }: contacts are detected and events fired, but no impulses are
+ *   applied. Useful for triggers.
+ * - {@link LockRotX }/{@link LockRotY }/{@link LockRotZ }: the corresponding angular
+ *   degree of freedom is fixed. Implemented by zeroing the matching inverse-inertia
+ *   component during solve.
+ * - {@link DisableSleep }: this body never enters the sleeping set. Bodies near it
+ *   may still sleep when stable.
+ */
+export type RigidBodyFlags = number;
+export namespace RigidBodyFlags {
+    let None: number;
+    let IsSensor: number;
+    let LockRotX: number;
+    let LockRotY: number;
+    let LockRotZ: number;
+    let DisableSleep: number;
+}
+//# sourceMappingURL=RigidBodyFlags.d.ts.map

package/src/engine/physics/ecs/RigidBodyFlags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RigidBodyFlags.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBodyFlags.js"],"names":[],"mappings":";;;;;;;;;;;6BAYU,MAAM"}

package/src/engine/physics/ecs/RigidBodyFlags.js

@@ -0,0 +1,22 @@
+/**
+ * Bit-flags carried on {@link RigidBody}.
+ *
+ * - {@link IsSensor}: contacts are detected and events fired, but no impulses are
+ *   applied. Useful for triggers.
+ * - {@link LockRotX}/{@link LockRotY}/{@link LockRotZ}: the corresponding angular
+ *   degree of freedom is fixed. Implemented by zeroing the matching inverse-inertia
+ *   component during solve.
+ * - {@link DisableSleep}: this body never enters the sleeping set. Bodies near it
+ *   may still sleep when stable.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const RigidBodyFlags = {
+    None: 0,
+    IsSensor: 1,
+    LockRotX: 2,
+    LockRotY: 4,
+    LockRotZ: 8,
+    DisableSleep: 16,
+};

package/src/engine/physics/ecs/RigidBodySerializationAdapter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Binary serialization for {@link RigidBody}.
+ *
+ * Only the configurable / persistent fields are written. Transient runtime state
+ * (`_bodyId`, `sleepState`, accumulated force/torque) is owned by the
+ * {@link PhysicsSystem} and recomputed on link — serialising it would tie the
+ * stream to a particular world instance.
+ */
+export class RigidBodySerializationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof RigidBody;
+    version: number;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {RigidBody} value
+     */
+    serialize(buffer: BinaryBuffer, value: RigidBody): void;
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {RigidBody} value
+     */
+    deserialize(buffer: BinaryBuffer, value: RigidBody): void;
+}
+import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { RigidBody } from "./RigidBody.js";
+//# sourceMappingURL=RigidBodySerializationAdapter.d.ts.map

package/src/engine/physics/ecs/RigidBodySerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RigidBodySerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBodySerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;;IAEI,wBAAkB;IAClB,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,SAAS,QA0BnB;IAED;;;;OAIG;IACH,yCAFW,SAAS,QA6BnB;CACJ;gDAhF+C,6DAA6D;0BACnF,gBAAgB"}

package/src/engine/physics/ecs/RigidBodySerializationAdapter.js

@@ -0,0 +1,81 @@
+import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { RigidBody } from "./RigidBody.js";
+
+/**
+ * Binary serialization for {@link RigidBody}.
+ *
+ * Only the configurable / persistent fields are written. Transient runtime state
+ * (`_bodyId`, `sleepState`, accumulated force/torque) is owned by the
+ * {@link PhysicsSystem} and recomputed on link — serialising it would tie the
+ * stream to a particular world instance.
+ */
+export class RigidBodySerializationAdapter extends BinaryClassSerializationAdapter {
+
+    klass = RigidBody;
+    version = 0;
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {RigidBody} value
+     */
+    serialize(buffer, value) {
+        buffer.writeUint8(value.kind);
+
+        buffer.writeFloat64(value.linearVelocity.x);
+        buffer.writeFloat64(value.linearVelocity.y);
+        buffer.writeFloat64(value.linearVelocity.z);
+
+        buffer.writeFloat64(value.angularVelocity.x);
+        buffer.writeFloat64(value.angularVelocity.y);
+        buffer.writeFloat64(value.angularVelocity.z);
+
+        buffer.writeFloat64(value.mass);
+
+        buffer.writeFloat64(value.inverseInertiaLocal.x);
+        buffer.writeFloat64(value.inverseInertiaLocal.y);
+        buffer.writeFloat64(value.inverseInertiaLocal.z);
+
+        buffer.writeFloat64(value.linearDamping);
+        buffer.writeFloat64(value.angularDamping);
+        buffer.writeFloat64(value.gravityScale);
+
+        buffer.writeUint32(value.layer >>> 0);
+        buffer.writeUint32(value.mask >>> 0);
+        buffer.writeUint32(value.flags >>> 0);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {RigidBody} value
+     */
+    deserialize(buffer, value) {
+        value.kind = buffer.readUint8();
+
+        const lvx = buffer.readFloat64();
+        const lvy = buffer.readFloat64();
+        const lvz = buffer.readFloat64();
+        value.linearVelocity.set(lvx, lvy, lvz);
+
+        const avx = buffer.readFloat64();
+        const avy = buffer.readFloat64();
+        const avz = buffer.readFloat64();
+        value.angularVelocity.set(avx, avy, avz);
+
+        value.mass = buffer.readFloat64();
+
+        const iix = buffer.readFloat64();
+        const iiy = buffer.readFloat64();
+        const iiz = buffer.readFloat64();
+        value.inverseInertiaLocal.set(iix, iiy, iiz);
+
+        value.linearDamping = buffer.readFloat64();
+        value.angularDamping = buffer.readFloat64();
+        value.gravityScale = buffer.readFloat64();
+
+        value.layer = buffer.readUint32();
+        value.mask = buffer.readUint32();
+        value.flags = buffer.readUint32();
+    }
+}

package/src/engine/physics/ecs/SleepState.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Sleep state of a {@link RigidBody }. Owned by the {@link PhysicsSystem }; user code
+ * must not write this field directly — use {@link PhysicsSystemwake } /
+ * {@link PhysicsSystemsleep }.
+ */
+export type SleepState = number;
+export namespace SleepState {
+    let Awake: number;
+    let Sleeping: number;
+}
+//# sourceMappingURL=SleepState.d.ts.map

package/src/engine/physics/ecs/SleepState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SleepState.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/SleepState.js"],"names":[],"mappings":";;;;;yBAMU,MAAM"}

package/src/engine/physics/ecs/SleepState.js

@@ -0,0 +1,12 @@
+/**
+ * Sleep state of a {@link RigidBody}. Owned by the {@link PhysicsSystem}; user code
+ * must not write this field directly — use {@link PhysicsSystem#wake} /
+ * {@link PhysicsSystem#sleep}.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const SleepState = {
+    Awake: 0,
+    Sleeping: 1,
+};

package/src/engine/physics/events/ContactEventBuffer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Event kinds emitted by the manifold diff pass.
+ */
+export type ContactEventKind = number;
+export namespace ContactEventKind {
+    let Begin: number;
+    let Stay: number;
+    let End: number;
+}
+/**
+ * Append-only buffer of contact events produced during one fixedUpdate, ready
+ * to be dispatched (and then cleared) at end-of-step.
+ *
+ * Storage is flat Uint32Array — keeping the metadata side allocation-free; the
+ * actual contact payload (normal, depth, world point) is read on demand from
+ * the {@link ManifoldStore} by the dispatch code.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ContactEventBuffer {
+    /**
+     * @param {number} [initial_capacity] events
+     */
+    constructor(initial_capacity?: number);
+    __capacity: number;
+    __count: number;
+    __data: Int32Array;
+    /**
+     * @returns {number}
+     */
+    get count(): number;
+    clear(): void;
+    /**
+     * @param {ContactEventKind|number} kind
+     * @param {number} entityA
+     * @param {number} entityB
+     * @param {number} slot manifold slot id
+     */
+    push(kind: ContactEventKind | number, entityA: number, entityB: number, slot: number): void;
+    kind_at(i: any): number;
+    entityA_at(i: any): number;
+    entityB_at(i: any): number;
+    slot_at(i: any): number;
+}
+//# sourceMappingURL=ContactEventBuffer.d.ts.map

package/src/engine/physics/events/ContactEventBuffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContactEventBuffer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/events/ContactEventBuffer.js"],"names":[],"mappings":";;;+BAGU,MAAM;;;;;;AAoBhB;;;;;;;;;;GAUG;AACH;IACI;;OAEG;IACH,+BAFW,MAAM,EAOhB;IAJG,mBAA+C;IAC/C,gBAAgB;IAEhB,mBAA4D;IAGhE;;OAEG;IACH,oBAEC;IAED,cAEC;IAED;;;;;OAKG;IACH,WALW,gBAAgB,GAAC,MAAM,WACvB,MAAM,WACN,MAAM,QACN,MAAM,QAgBhB;IAED,wBAAoD;IACpD,2BAA2D;IAC3D,2BAA2D;IAC3D,wBAAwD;CAC3D"}