@woosh/meep-engine 2.165.6 → 2.165.7

package/src/engine/navigation/ecs/components/Path.d.ts

@@ -1,47 +1,167 @@
-import Vector3 from "../../../../core/geom/Vector3";
-import {InterpolationType} from "./InterpolationType";
-
-export default class Path {
-    public interpolation: InterpolationType
-    /**
-     * Absolute length of the path
-     */
-    public readonly length: number
-
-    public isEmpty(): boolean
-
-    public reverse(): void
-
-    public clear(): void
-
-    /**
-     * Number of points that make up this path
-     */
-    public getPointCount(): number
-
-    public setPointCount(v: number): void
-
-    public removePoint(index: number): boolean
-
-    public getPosition(index: number, result: Vector3): void;
-
-    public setPosition(index: number, x: number, y: number, z: number): void
-
-    public insertPoint(index: number, x: number, y: number, z: number): void
-
-    public computeLength(): number
-
-    public sample(result: Vector3, offset: number, interpolation?: InterpolationType): boolean
-
-    find_index_and_normalized_distance(result:ArrayLike<number>, absolute_distance:number):boolean
-
-    public copy(other: Path): void
-
-    public clone(): Path
-
-    public toJSON(): any
-
-    public fromJSON(json: any): void
-
-    getLowIndexOfNearestPoint(reference: Vector3): number
-}
+export default Path;
+declare class Path {
+    static fromJSON(j: any): Path;
+    /**
+     *
+     * @type {AttributeGroupSpec}
+     * @private
+     */
+    private __spec;
+    /**
+     * @readonly
+     * @type {RowFirstTable}
+     * @private
+     */
+    private readonly __data;
+    /**
+     * Now to get in-between values
+     * @type {InterpolationType|number}
+     */
+    interpolation: InterpolationType | number;
+    /**
+     * Absolute length of the path, measured as straight-line distance sum of point pairs
+     * @type {number}
+     * @private
+     */
+    private __length;
+    /**
+     *
+     * @return {boolean}
+     */
+    isEmpty(): boolean;
+    clear(): void;
+    /**
+     *
+     * @return {number}
+     */
+    getPointCount(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    get count(): number;
+    /**
+     *
+     * @param {number} v
+     */
+    setPointCount(v: number): void;
+    /**
+     *
+     * @param {number} index
+     * @returns {boolean}
+     */
+    removePoint(index: number): boolean;
+    /**
+     * Insert an point
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    insertPoint(index: number, x: number, y: number, z: number): void;
+    /**
+     *
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setPosition(index: number, x: number, y: number, z: number): void;
+    /**
+     *
+     * @param {number} index
+     * @param {Vector3} result
+     */
+    getPosition(index: number, result: Vector3): void;
+    /**
+     *
+     * @param {number} index
+     * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} result
+     * @param {number} result_offset
+     */
+    readPositionToArray(index: number, result: ArrayLike<number> | number[] | Float32Array | Float64Array, result_offset: number): void;
+    /**
+     *
+     * @param {number} index
+     * @param {Vector3} v
+     */
+    setPositionFromVector(index: number, v: Vector3): void;
+    /**
+     *
+     * @param {Vector3[]} array
+     */
+    setPositionsFromVectorArray(array: Vector3[]): void;
+    /**
+     * Reverse order of points
+     */
+    reverse(): void;
+    /**
+     *
+     * @param {Path} other
+     */
+    copy(other: Path): void;
+    /**
+     *
+     * @return {Path}
+     */
+    clone(): Path;
+    /**
+     * Get low index of a point that makes up a line segment closest to the reference point
+     * @param {Vector3} reference
+     * @returns {number}
+     */
+    getLowIndexOfNearestPoint(reference: Vector3): number;
+    /**
+     * Read position along the path at a given 1D offset
+     * @param {Vector3} result
+     * @param {number} offset
+     * @returns {boolean}
+     */
+    sample_linear(result: Vector3, offset: number): boolean;
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} absolute_distance absolute distance along the path
+     * @returns {boolean}
+     */
+    find_index_and_normalized_distance(result: number[], absolute_distance: number): boolean;
+    /**
+     *
+     * @param {Vector3} result
+     * @param {number} offset
+     * @returns {boolean}
+     */
+    sample_catmull_rom(result: Vector3, offset: number): boolean;
+    /**
+     *
+     * @param {Vector3} result
+     * @param {number} offset absolute distance offset along the path
+     * @param {InterpolationType} [interpolation=this.interpolation]
+     * @returns {boolean}
+     */
+    sample(result: Vector3, offset: number, interpolation?: InterpolationType): boolean;
+    toString(): string;
+    toJSON(): {
+        points: any[];
+        rowSize: number;
+    };
+    fromJSON({ points, rowSize }: {
+        points?: any[];
+        rowSize?: number;
+    }): void;
+    /**
+     *
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     *
+     * @returns {number}
+     */
+    computeLength(): number;
+}
+declare namespace Path {
+    let typeName: string;
+}
+import { InterpolationType } from "./InterpolationType.js";
+//# sourceMappingURL=Path.d.ts.map

package/src/engine/navigation/ecs/components/PathEvents.d.ts

@@ -1,6 +1,8 @@
-export enum PathEvents {
-    Changed = '@ecd-component-Path/changed',
-    PointAdded = "@ecd-component-Path/point-added",
-    PointRemoved = "@ecd-component-Path/point-removed",
-    PointChanged = "@ecd-component-Path/point-changes"
-}
+export type PathEvents = string;
+export namespace PathEvents {
+    let Changed: string;
+    let PointAdded: string;
+    let PointRemoved: string;
+    let PointChanged: string;
+}
+//# sourceMappingURL=PathEvents.d.ts.map

package/src/engine/navigation/ecs/components/PathSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class PathSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof Path;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/navigation/ecs/components/PathSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/components/PathSerializationAdapter.js"],"names":[],"mappings":"AAOA;;IAEI,mBAAa;IACb,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,IAAI,QAkBd;IAED;;;;OAIG;IACH,yCAFW,IAAI,QAkBd;CACJ;gDAxD+C,gEAAgE;iBAC/F,WAAW"}
+{"version":3,"file":"PathSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/components/PathSerializationAdapter.js"],"names":[],"mappings":"AAOA;;IAEI,mBAAa;IAGb;;;;OAIG;IACH,uCAFW,IAAI,QAkBd;IAED;;;;OAIG;IACH,yCAFW,IAAI,QAkBd;CACJ;gDAxD+C,gEAAgE;iBAC/F,WAAW"}

package/src/engine/navigation/ecs/path_following/PathFollower.d.ts

@@ -1,45 +1,85 @@
-import Vector1 from "../../../../core/geom/Vector1";
-import {PathFollowerFlags} from "./PathFollowerFlags";
-
-export default class PathFollower {
-    /**
-     * Movement speed along the path in world units per second
-     */
-    readonly speed: Vector1
-
-    /**
-     *
-     * Speed at which path follower can adjust rotation in Rad/s
-     */
-    readonly rotationSpeed: Vector1
-
-    /**
-     *
-     * Absolute position along the path
-     */
-    position: number
-
-    flags: number
-
-    /**
-     *
-     * Maximum distance that the follower can move along the path in a single step
-     */
-    maxMoveDistance: number
-
-    public setFlag(flag: PathFollowerFlags | number): void
-
-    public clearFlag(flag: PathFollowerFlags | number): void
-
-    public writeFlag(flag: PathFollowerFlags | number, value: boolean): void
-
-    public getFlag(flag: PathFollowerFlags | number): boolean
-
-    public toJSON(): any
-
-    public fromJSON(json: any): void
-
-    static typeName: string
-
-    static fromJSON(json: any): PathFollower
-}
+export default PathFollower;
+declare class PathFollower {
+    /**
+     *
+     * @param json
+     * @returns {PathFollower}
+     */
+    static fromJSON(json: any): PathFollower;
+    /**
+     * Movement speed along the path in world units per second
+     * @type {Vector1}
+     */
+    speed: Vector1;
+    /**
+     * Speed at which path follower can adjust rotation in Rad/s
+     * @type {Vector1}
+     */
+    rotationSpeed: Vector1;
+    /**
+     *
+     * @type {number}
+     */
+    flags: number;
+    /**
+     * Maximum distance that the follower can move along the path in a single step
+     * @type {number}
+     */
+    maxMoveDistance: number;
+    /**
+     * Absolute position along the path
+     * @type {number}
+     */
+    position: number;
+    get rotationAlignment(): void;
+    get positionWriting(): void;
+    set active(arg: boolean);
+    get active(): boolean;
+    set lock(arg: boolean);
+    get lock(): boolean;
+    /**
+     *
+     * @param {number|PathFollowerFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag: number | PathFollowerFlags): void;
+    /**
+     *
+     * @param {number|PathFollowerFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag: number | PathFollowerFlags): void;
+    /**
+     *
+     * @param {number|PathFollowerFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag: number | PathFollowerFlags, value: boolean): void;
+    /**
+     *
+     * @param {number|PathFollowerFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag: number | PathFollowerFlags): boolean;
+    toJSON(): {
+        active: boolean;
+        loop: boolean;
+        writePositionX: boolean;
+        writePositionY: boolean;
+        writePositionZ: boolean;
+        writeRotationX: boolean;
+        writeRotationY: boolean;
+        writeRotationZ: boolean;
+        speed: number;
+        rotationSpeed: number;
+        position: number;
+        maxMoveDistance: number;
+    };
+    fromJSON(json: any): void;
+}
+declare namespace PathFollower {
+    let typeName: string;
+}
+import Vector1 from "../../../../core/geom/Vector1.js";
+import { PathFollowerFlags } from "./PathFollowerFlags.js";
+//# sourceMappingURL=PathFollower.d.ts.map

package/src/engine/navigation/ecs/path_following/PathFollowerEventType.d.ts

@@ -1,3 +1,5 @@
-export enum PathFollowerEventType {
-    EndReached = "path-end-reached"
-}
+export type PathFollowerEventType = string;
+export namespace PathFollowerEventType {
+    let EndReached: string;
+}
+//# sourceMappingURL=PathFollowerEventType.d.ts.map

package/src/engine/navigation/ecs/path_following/PathFollowerFlags.d.ts

@@ -1,20 +1,14 @@
-export enum PathFollowerFlags {
-    Active = 1,
-    Locked = 2,
-    Loop = 4,
-    Finished = 8,
-
-    /**
-     * On which axis to write position
-     */
-    WritePositionX = 16,
-    WritePositionY = 32,
-    WritePositionZ = 64,
-
-    /**
-     * On which axis to write rotation
-     */
-    WriteRotationX = 128,
-    WriteRotationY = 256,
-    WriteRotationZ = 512,
-}
+export type PathFollowerFlags = any;
+export namespace PathFollowerFlags {
+    let Active: number;
+    let Locked: number;
+    let Loop: number;
+    let Finished: number;
+    let WritePositionX: number;
+    let WritePositionY: number;
+    let WritePositionZ: number;
+    let WriteRotationX: number;
+    let WriteRotationY: number;
+    let WriteRotationZ: number;
+}
+//# sourceMappingURL=PathFollowerFlags.d.ts.map

package/src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.d.ts

@@ -1,7 +1,6 @@
 export class PathFollowerSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof PathFollower;
-    version: number;
     /**
      *
      * @param {BinaryBuffer} buffer

package/src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathFollowerSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,2BAAqB;IACrB,gBAAY;IAEZ;;;;OAIG;IACH,uCAFW,YAAY,QAUtB;IAED;;;;OAIG;IACH,yCAFW,YAAY,QAUtB;CACJ;gDArC+C,gEAAgE;yBACvF,mBAAmB"}
+{"version":3,"file":"PathFollowerSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IAEI,2BAAqB;IAGrB;;;;OAIG;IACH,uCAFW,YAAY,QAUtB;IAED;;;;OAIG;IACH,yCAFW,YAAY,QAUtB;CACJ;gDArC+C,gEAAgE;yBACvF,mBAAmB"}

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.d.ts

@@ -1,6 +1,31 @@
-import {System} from "../../../ecs/System";
-import PathFollower from "./PathFollower";
-
-export default class PathFollowingSystem extends System<PathFollower> {
-
-}
+export default PathFollowingSystem;
+declare class PathFollowingSystem extends System<any> {
+    constructor();
+    dependencies: (typeof PathFollower)[];
+    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof PathFollower> | ResourceAccessSpecification<typeof Path>)[];
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    private __time_delta;
+    /**
+     *
+     * @param {PathFollower} pathFollower
+     * @param {Transform} transform
+     * @param {Path} path
+     * @param {number} entity Entity ID
+     */
+    __visit_entity(pathFollower: PathFollower, transform: Transform, path: Path, entity: number): void;
+    /**
+     *
+     * @param {number} timeDelta Time in seconds
+     */
+    update(timeDelta: number): void;
+}
+import { System } from '../../../ecs/System.js';
+import PathFollower from './PathFollower.js';
+import { Transform } from '../../../ecs/transform/Transform.js';
+import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
+import Path from '../components/Path.js';
+//# sourceMappingURL=PathFollowingSystem.d.ts.map

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAwHA;IACI,cAiBC;IAdG,sCAAkC;IAElC,iKAIC;IAED;;;;OAIG;IACH,qBAAqB;IAGzB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,SAAS,QACT,IAAI,UACJ,MAAM,QAuBhB;CAgBJ;uBAnLsB,wBAAwB;yBAGtB,mBAAmB;0BAFlB,qCAAqC;4CAFnB,uDAAuD;iBAGlF,uBAAuB"}
+{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAwHA;IACI,cAiBC;IAdG,sCAAkC;IAElC,iKAIC;IAED;;;;OAIG;IACH,qBAAqB;IAGzB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,SAAS,QACT,IAAI,UACJ,MAAM,QAuBhB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAWhB;CACJ;uBAnLsB,wBAAwB;yBAGtB,mBAAmB;0BAFlB,qCAAqC;4CAFnB,uDAAuD;iBAGlF,uBAAuB"}

package/src/engine/network/adapters/TransformReplicationAdapter.d.ts

@@ -20,7 +20,6 @@
 export class TransformReplicationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof Transform;
-    version: number;
     /**
      * @param {BinaryBuffer} buffer
      * @param {Transform} value

package/src/engine/network/adapters/TransformReplicationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformReplicationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformReplicationAdapter.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,wBAAkB;IAClB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,SAAS,QAoBnB;IAED;;;OAGG;IACH,yCAFW,SAAS,QAmBnB;CACJ;gDAlF+C,6DAA6D;0BACnF,kCAAkC"}
+{"version":3,"file":"TransformReplicationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformReplicationAdapter.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,wBAAkB;IAGlB;;;OAGG;IACH,uCAFW,SAAS,QAoBnB;IAED;;;OAGG;IACH,yCAFW,SAAS,QAmBnB;CACJ;gDAlF+C,6DAA6D;0BACnF,kCAAkC"}

package/src/engine/network/ecs/NetworkSystem.d.ts

@@ -29,7 +29,7 @@
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export class NetworkSystem extends System<any, any, any, any, any> {
+export class NetworkSystem extends System<any> {
     /**
      * @param {NetworkPeer} peer
      */

package/src/engine/network/ecs/serialization/NetworkIdentitySerializationAdapter.d.ts

@@ -23,7 +23,6 @@ export const MAX_OWNER_PEER_ID: number;
 export class NetworkIdentitySerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
     klass: typeof NetworkIdentity;
-    version: number;
     /**
      * @param {BinaryBuffer} buffer
      * @param {NetworkIdentity} value

package/src/engine/network/ecs/serialization/NetworkIdentitySerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkIdentitySerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/ecs/serialization/NetworkIdentitySerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,gCAFU,MAAM,CAEwB;AAExC;;;;;;;;;;;;GAYG;AACH;;IAEI,8BAAwB;IACxB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,eAAe,QAmBzB;IAED;;;OAGG;IACH,yCAFW,eAAe,QAMzB;CACJ;gDA/D+C,gEAAgE;gCAChF,kCAAkC"}
+{"version":3,"file":"NetworkIdentitySerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/ecs/serialization/NetworkIdentitySerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,gCAFU,MAAM,CAEwB;AAExC;;;;;;;;;;;;GAYG;AACH;;IAEI,8BAAwB;IAGxB;;;OAGG;IACH,uCAFW,eAAe,QAmBzB;IAED;;;OAGG;IACH,yCAFW,eAAe,QAMzB;CACJ;gDA/D+C,gEAAgE;gCAChF,kCAAkC"}

package/src/engine/options/Option.d.ts

@@ -9,9 +9,9 @@ export class Option extends OptionAbstract {
      */
     constructor(id: string, read: Function, write?: Function, settings?: object);
     on: {
-        written: Signal<any, any, any, any, any, any, any, any>;
-        writeFailed: Signal<any, any, any, any, any, any, any, any>;
-        settingsUpdated: Signal<any, any, any, any, any, any, any, any>;
+        written: Signal;
+        writeFailed: Signal;
+        settingsUpdated: Signal;
     };
     read: Function;
     write: (v: any) => any;

package/src/engine/options/OptionsView.d.ts

@@ -1,5 +1,5 @@
 export default OptionsView;
-declare class OptionsView extends View<HTMLElement> {
+declare class OptionsView extends View {
     /**
      *
      * @constructor
@@ -8,7 +8,6 @@ declare class OptionsView extends View<HTMLElement> {
      * @param {string[][]} [inclusions]
      */
     constructor({ options, localization, inclusions }: OptionGroup);
-    el: any;
 }
 import View from "../../view/View.js";
 import { OptionGroup } from "./OptionGroup.js";

package/src/engine/options/OptionsView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OptionsView.d.ts","sourceRoot":"","sources":["../../../../src/engine/options/OptionsView.js"],"names":[],"mappings":";AAuCA;IACI;;;;;;OAMG;IACH,mDAJW,WAAW,EAoLrB;IATG,QAAwB;CAU/B;iBA/NgB,oBAAoB;4BACT,kBAAkB"}
+{"version":3,"file":"OptionsView.d.ts","sourceRoot":"","sources":["../../../../src/engine/options/OptionsView.js"],"names":[],"mappings":";AAuCA;IACI;;;;;;OAMG;IACH,mDAJW,WAAW,EAoLrB;CACJ;iBA/NgB,oBAAoB;4BACT,kBAAkB"}

package/src/engine/physics/body/SolverBodyState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SolverBodyState.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/body/SolverBodyState.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,+CAA+C;AAC/C,6BAA8B;AAC9B,oFAAoF;AACpF,4BAA6B;AAC7B,4BAA6B;AAC7B,4BAA6B;AAC7B,oFAAoF;AACpF,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,kCAAkC;AAClC,yBAA0B;AAC1B,yBAA0B;AAC1B,0BAA2B;AAC3B,mCAAmC;AACnC,0BAA2B;AAC3B,0BAA2B;AAC3B,0BAA2B;AAE3B,wBAAwB;AACxB,4BAA6B;AAE7B;IACI,uCAoCC;IAjCG;;;OAGG;IACH,MAFU,YAAY,CAEwB;IAE9C;;;;;OAKG;IACH,gBAAkC;IAElC;;;;OAIG;IACH,mBAAsC;IAEtC,eAAe;IACf,yBAAyB;IAEzB;;;;OAIG;IACH,cAAc;IAEd,eAAe;IACf,mBAAqB;IAGzB;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,WAFW,MAAM,QAiBhB;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,6CAsDhB;IAED;;;;;;;OAOG;IACH,gBAFW,WAAW,QAoBrB;IAED;;;OAGG;IACH,eAeC;CACJ"}
+{"version":3,"file":"SolverBodyState.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/body/SolverBodyState.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,+CAA+C;AAC/C,6BAA8B;AAC9B,oFAAoF;AACpF,4BAA6B;AAC7B,4BAA6B;AAC7B,4BAA6B;AAC7B,oFAAoF;AACpF,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,kCAAkC;AAClC,yBAA0B;AAC1B,yBAA0B;AAC1B,0BAA2B;AAC3B,mCAAmC;AACnC,0BAA2B;AAC3B,0BAA2B;AAC3B,0BAA2B;AAE3B,wBAAwB;AACxB,4BAA6B;AAE7B;IACI,uCAoCC;IAjCG;;;OAGG;IACH,MAFU,YAAY,CAEwB;IAE9C;;;;;OAKG;IACH,gBAAkC;IAElC;;;;OAIG;IACH,mBAAsC;IAEtC,eAAe;IACf,yBAAyB;IAEzB;;;;OAIG;IACH,cAAc;IAEd,eAAe;IACf,mBAAqB;IAGzB;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,WAFW,MAAM,QAiBhB;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,6CA8DhB;IAED;;;;;;;OAOG;IACH,gBAFW,WAAW,QAoBrB;IAED;;;OAGG;IACH,eAeC;CACJ"}

package/src/engine/physics/body/SolverBodyState.js

@@ -1,6 +1,7 @@
 import { ceilPowerOfTwo } from "../../../core/binary/operations/ceilPowerOfTwo.js";
 import { BodyKind } from "../ecs/BodyKind.js";
 import { RigidBodyFlags } from "../ecs/RigidBodyFlags.js";
+import { SleepState } from "../ecs/SleepState.js";
 
 /**
  * # SolverBodyState — data-oriented mirror of the per-body solver hot state
@@ -169,7 +170,15 @@ export class SolverBodyState {
         const d = this.data;
         const base = idx * SBS_STRIDE;
 
-        const dynamic = rb.kind === BodyKind.Dynamic;
+        // Only an AWAKE Dynamic body is movable to the solver. A SLEEPING Dynamic body is
+        // never integrated (integrate_position runs over the awake set only), yet it can still
+        // be gathered as a contact endpoint — IslandBuilder deliberately emits contacts whose
+        // other side is a freshly-slept neighbour. Giving it a non-zero inverse mass would let
+        // it take a share of an impulse it can never move under, and scatter would persist that
+        // phantom velocity onto the RigidBody (discharged as a lurch when it later wakes,
+        // violating the zero-velocity-at-sleep invariant). Treat it as an anchor, like Static /
+        // Kinematic — its velocity is zero by that invariant, so the rows read and write zero.
+        const dynamic = rb.kind === BodyKind.Dynamic && rb.sleepState === SleepState.Awake;
         if (dynamic) {
             d[base + SBS_INV_MASS] = rb.mass > 0 ? 1 / rb.mass : 0;
             // LockRot*: a locked BODY-LOCAL angular DOF gathers zero inverse

package/src/engine/physics/constraint/solve_constraints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solve_constraints.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/constraint/solve_constraints.js"],"names":[],"mappings":"AA0TA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAHW,MAAM,MAAa,MAAM,MAAa,MAAM,MAAa,MAAM,OAC/D,YAAY,QAkCtB;AA0JD;;;;;;;;;;;;;;;;GAgBG;AACH,qCATW,OAAO,iCAEP,MAAM,SAEN,MAAM,YACN,OAAO,QAuSjB"}
+{"version":3,"file":"solve_constraints.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/constraint/solve_constraints.js"],"names":[],"mappings":"AA0TA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAHW,MAAM,MAAa,MAAM,MAAa,MAAM,MAAa,MAAM,OAC/D,YAAY,QAkCtB;AAoKD;;;;;;;;;;;;;;;;GAgBG;AACH,qCATW,OAAO,iCAEP,MAAM,SAEN,MAAM,YACN,OAAO,QAuSjB"}