@woosh/meep-engine 3.15.0 → 3.17.0

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.js

@@ -4,11 +4,16 @@ import { min2 } from "../../../../core/math/min2.js";
 import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { System } from '../../../ecs/System.js';
-import { Transform } from '../../../ecs/transform/Transform.js';
+import { Transform64 } from '../../../ecs/transform/Transform64.js';
 import Path from '../components/Path.js';
 import PathFollower from './PathFollower.js';
 import { PathFollowerEventType } from "./PathFollowerEventType.js";
 import { PathFollowerFlags } from "./PathFollowerFlags.js";
+import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+
+const scratch_towards = new Quaternion();
+
+const scratch_forward = new Float64Array(3);
 
 const v3_forward = new Vector3();
 const v3_temp1 = new Vector3();
@@ -18,7 +23,7 @@ const scratch_quaternion = new Quaternion();
  *
  * @param {PathFollower} pathFollower
  * @param {Path} path
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @param {number} timeDelta
  */
 function performStep(pathFollower, path, transform, timeDelta) {
@@ -60,16 +65,16 @@ function performStep(pathFollower, path, transform, timeDelta) {
             pathFollower.position = next_offset_truncated;
         }
 
-        const position = transform.position;
+        const position = transform.translation;
 
         if (!pathFollower.getFlag(PathFollowerFlags.WritePositionX)) {
-            nextPosition.setX(position.x);
+            nextPosition.setX(position[0]);
         }
         if (!pathFollower.getFlag(PathFollowerFlags.WritePositionY)) {
-            nextPosition.setY(position.y);
+            nextPosition.setY(position[1]);
         }
         if (!pathFollower.getFlag(PathFollowerFlags.WritePositionZ)) {
-            nextPosition.setZ(position.z);
+            nextPosition.setZ(position[2]);
         }
 
         if (!nextPosition.equals(position)) {
@@ -84,13 +89,21 @@ function performStep(pathFollower, path, transform, timeDelta) {
                 // TODO we can extract tangent and normal from the path itself, no need to do euler approximation
 
                 //compute old facing direction vector
-                v3_forward.copy(Vector3.forward);
+                v3_quaternion_apply(
+                    scratch_forward, 0,
+                    Vector3.forward.x, Vector3.forward.y, Vector3.forward.z,
+                    transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w
+                );
 
-                v3_forward.applyQuaternion(transform.rotation);
+                v3_forward.set(scratch_forward[0], scratch_forward[1], scratch_forward[2]);
 
                 const positionDelta = v3_temp2;
 
-                positionDelta.subVectors(nextPosition, oldPosition);
+                positionDelta.set(
+                    nextPosition[0] - oldPosition[0],
+                    nextPosition[1] - oldPosition[1],
+                    nextPosition[2] - oldPosition[2]
+                );
 
                 if (!alignment_x) {
                     positionDelta.x = v3_forward.x;
@@ -109,10 +122,22 @@ function performStep(pathFollower, path, transform, timeDelta) {
                 // console.log("Angular limit:", angularLimit, positionDelta.toJSON());
 
                 scratch_quaternion.lookRotation(positionDelta);
-                transform.rotation.rotateTowards(scratch_quaternion,angularLimit);
+                scratch_towards.set(
+                    transform.rotation_x, transform.rotation_y,
+                    transform.rotation_z, transform.rotation_w
+                );
+                scratch_towards.rotateTowards(scratch_quaternion, angularLimit);
+
+                transform.setRotation(
+                    scratch_towards.x, scratch_towards.y, scratch_towards.z, scratch_towards.w
+                );
+
+                transform.updateMatrix();
             }
 
-            position.copy(nextPosition);
+            position[0] = nextPosition[0];
+            position[1] = nextPosition[1];
+            position[2] = nextPosition[2];
         }
 
     }
@@ -122,7 +147,7 @@ class PathFollowingSystem extends System {
     dependencies = [PathFollower];
     components_used = [
         ResourceAccessSpecification.from(PathFollower, ResourceAccessKind.Read | ResourceAccessKind.Write),
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read | ResourceAccessKind.Write),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read | ResourceAccessKind.Write),
         ResourceAccessSpecification.from(Path, ResourceAccessKind.Read),
     ];
 
@@ -136,7 +161,7 @@ class PathFollowingSystem extends System {
     /**
      *
      * @param {PathFollower} pathFollower
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {Path} path
      * @param {number} entity Entity ID
      */
@@ -174,7 +199,7 @@ class PathFollowingSystem extends System {
         const dataset = entityManager.dataset;
 
         if (dataset !== null) {
-            dataset.traverseEntities([PathFollower, Transform, Path], this.__visit_entity, this);
+            dataset.traverseEntities([PathFollower, Transform64, Path], this.__visit_entity, this);
         }
     }
 }

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

@@ -1,5 +1,5 @@
 /**
- * Network-replication adapter for {@link Transform}. Mirrors
+ * Network-replication adapter for {@link Transform64}. Mirrors
  * {@link TransformSerializationAdapter} but uses Float32 for position instead
  * of Float64, halving the per-component cost (12 B vs 24 B) for a precision
  * loss that is below visible threshold for typical action-game scales.
@@ -19,18 +19,18 @@
  */
 export class TransformReplicationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();
-    klass: typeof Transform;
+    klass: typeof Transform64;
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} value
+     * @param {Transform64} value
      */
-    serialize(buffer: BinaryBuffer, value: Transform): void;
+    serialize(buffer: BinaryBuffer, value: Transform64): void;
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} value
+     * @param {Transform64} value
      */
-    deserialize(buffer: BinaryBuffer, value: Transform): void;
+    deserialize(buffer: BinaryBuffer, value: Transform64): void;
 }
 import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
-import { Transform } from "../../ecs/transform/Transform.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 //# sourceMappingURL=TransformReplicationAdapter.d.ts.map

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;IAGlB;;;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,0BAAoB;IAGpB;;;OAGG;IACH,uCAFW,WAAW,QAgBrB;IAED;;;OAGG;IACH,yCAFW,WAAW,QAsBrB;CACJ;gDAjF+C,6DAA6D;4BACjF,oCAAoC"}

package/src/engine/network/adapters/TransformReplicationAdapter.js

@@ -3,7 +3,7 @@ import { quat3_encode_to_uint32 } from "../../../core/geom/3d/quaternion/quat3_e
 import { v3_binary_equality_decode } from "../../../core/geom/vec3/serialization/v3_binary_equality_decode.js";
 import { v3_binary_equality_encode } from "../../../core/geom/vec3/serialization/v3_binary_equality_encode.js";
 import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
-import { Transform } from "../../ecs/transform/Transform.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 
 /**
  * Decode scratch for {@link TransformReplicationAdapter#deserialize}. Decoders
@@ -15,7 +15,7 @@ import { Transform } from "../../ecs/transform/Transform.js";
 const decode_scratch = new Float32Array(4);
 
 /**
- * Network-replication adapter for {@link Transform}. Mirrors
+ * Network-replication adapter for {@link Transform64}. Mirrors
  * {@link TransformSerializationAdapter} but uses Float32 for position instead
  * of Float64, halving the per-component cost (12 B vs 24 B) for a precision
  * loss that is below visible threshold for typical action-game scales.
@@ -35,36 +35,32 @@ const decode_scratch = new Float32Array(4);
  */
 export class TransformReplicationAdapter extends BinaryClassSerializationAdapter {
 
-    klass = Transform;
+    klass = Transform64;
     version = 1;
 
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} value
+     * @param {Transform64} value
      */
     serialize(buffer, value) {
 
-        const position = value.position;
-        const rotation = value.rotation;
-        const scale = value.scale;
-
-        buffer.writeFloat32(position.x);
-        buffer.writeFloat32(position.y);
-        buffer.writeFloat32(position.z);
+        buffer.writeFloat32(value.translation_x);
+        buffer.writeFloat32(value.translation_y);
+        buffer.writeFloat32(value.translation_z);
 
         buffer.writeUint32(quat3_encode_to_uint32(
-            rotation.x,
-            rotation.y,
-            rotation.z,
-            rotation.w
+            value.rotation_x,
+            value.rotation_y,
+            value.rotation_z,
+            value.rotation_w
         ));
 
-        v3_binary_equality_encode(buffer, scale.x, scale.y, scale.z);
+        v3_binary_equality_encode(buffer, value.scale_x, value.scale_y, value.scale_z);
     }
 
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} value
+     * @param {Transform64} value
      */
     deserialize(buffer, value) {
 
@@ -77,11 +73,14 @@ export class TransformReplicationAdapter extends BinaryClassSerializationAdapter
         const s = decode_scratch;
 
         v3_binary_equality_decode(buffer, s, 0);
-        value.scale.set(s[0], s[1], s[2]);
+        value.setScale(s[0], s[1], s[2]);
 
         quat3_decode_from_uint32(s, 0, encoded_rotation);
-        value.rotation.set(s[0], s[1], s[2], s[3]);
+        value.setRotation(s[0], s[1], s[2], s[3]);
+
+        value.setTranslation(positionX, positionY, positionZ);
 
-        value.position.set(positionX, positionY, positionZ);
+        // rotation and scale both moved, so the matrix owes an update before anyone reads it
+        value.updateMatrix();
     }
 }

package/src/engine/network/replication/Replicator.d.ts

@@ -55,9 +55,11 @@ export class Replicator {
     /**
      * Per-peer delivery accounting. Read it, log it, put it on a HUD, fail a test on it.
      *
-     * `skipped_unapplied` is the one that matters: frames that reached this receiver and were
-     * dropped below the watermark without ever being applied. It should be zero. It is not zero
-     * when slices reorder on a sender pinned to the ring floor, which is what
+     * `skipped_unapplied` is the one that matters: frames that reached this receiver and will
+     * never run — dropped below the watermark without ever being applied, or held for a gap that
+     * the cap on held slices outlived. It should be zero, on every configuration, however the link
+     * reorders; a slice held and applied late is not counted, because nothing was lost. It is not
+     * zero when slices reorder on a sender pinned to the ring floor, which is what
      * `max_packets_per_tick: 1` produces under jitter.
      *
      * `skipped_duplicate` is the healthy counterpart — the action stream's own redundancy arriving

package/src/engine/network/replication/Replicator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Replicator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/replication/Replicator.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IA4JI;;;;;;;;OAQG;IACH;;;;;;wCAHiD,MAAM,cAAc,MAAM,GAAG,OAAO;;OA8BpF;IA/HD;;;;;;;;;;;;;OAaG;IACH,wBAHW,MAAM,GACJ;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,CAUlE;IA0BD;;;;;;;;;;;;;OAaG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFqB,MAAM,gBAAgB,MAAM,kBAAkB,MAAM,aAAa,YAAY,kBAAkB,MAAM,eAAe,MAAM,KAAK,IAAI,CAE/H;IAmBrB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,4BAAwB;IAExB;;OAEG;IACH,iCAA4B;IAE5B;;;;OAIG;IACH;oCAFwC,MAAM,cAAc,MAAM,GAAG,OAAO;MAE5C;IAGpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAVW,MAAM,eACN,MAAM,aACN,MAAM,cACN,YAAY,cACZ,MAAM,GACJ,MAAM,CA4ElB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,0BALW,MAAM,aACN,YAAY,iBACZ,MAAM,UACN;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI,QAmEtE;IAiND;;;;;;;OAOG;IACH,qBAFW,MAAM,QAKhB;;CA8CJ;mBA1rBkB,uCAAuC;6BAD7B,sCAAsC"}
+{"version":3,"file":"Replicator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/replication/Replicator.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IAsKI;;;;;;;;OAQG;IACH;;;;;;wCAHiD,MAAM,cAAc,MAAM,GAAG,OAAO;;OA8BpF;IAjID;;;;;;;;;;;;;;;OAeG;IACH,wBAHW,MAAM,GACJ;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,CAUlE;IA0BD;;;;;;;;;;;;;OAaG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFqB,MAAM,gBAAgB,MAAM,kBAAkB,MAAM,aAAa,YAAY,kBAAkB,MAAM,eAAe,MAAM,KAAK,IAAI,CAE/H;IAmBrB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,4BAAwB;IAExB;;OAEG;IACH,iCAA4B;IAE5B;;;;OAIG;IACH;oCAFwC,MAAM,cAAc,MAAM,GAAG,OAAO;MAE5C;IAGpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAVW,MAAM,eACN,MAAM,aACN,MAAM,cACN,YAAY,cACZ,MAAM,GACJ,MAAM,CA4ElB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,0BALW,MAAM,aACN,YAAY,iBACZ,MAAM,UACN;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI,QAoEtE;IAuPD;;;;;;;OAOG;IACH,qBAFW,MAAM,QAKhB;;CA8CJ;mBA3uBkB,uCAAuC;6BAD7B,sCAAsC"}

package/src/engine/network/replication/Replicator.js

@@ -114,6 +114,14 @@ export class Replicator {
      * skipped frame can ask "was I ever applied?" in constant time and constant memory. A frame
      * older than the window answers "no", which is right: it is beyond recovery either way.
      *
+     * There is a third kind of skip and it is neither: a frame walked past on the validation walk
+     * that precedes a hold. Nothing has happened to it — the bytes are kept and it runs a few
+     * packets later — so it is not booked at all, and the frames of a held slice are booked when
+     * the slice is applied, or when it is thrown away, whichever comes. `count_skipped` in
+     * {@link #apply_groups} is that distinction. It has to be a distinction: on a jittery link
+     * holding is the common case, and counting a held frame as lost buries the real losses under
+     * a number twenty times larger that grows with the length of the session.
+     *
      * @type {Map<number, {applied: Int32Array, skipped_unapplied: number, skipped_duplicate: number}>}
      * @private
      */
@@ -122,9 +130,11 @@ export class Replicator {
     /**
      * Per-peer delivery accounting. Read it, log it, put it on a HUD, fail a test on it.
      *
-     * `skipped_unapplied` is the one that matters: frames that reached this receiver and were
-     * dropped below the watermark without ever being applied. It should be zero. It is not zero
-     * when slices reorder on a sender pinned to the ring floor, which is what
+     * `skipped_unapplied` is the one that matters: frames that reached this receiver and will
+     * never run — dropped below the watermark without ever being applied, or held for a gap that
+     * the cap on held slices outlived. It should be zero, on every configuration, however the link
+     * reorders; a slice held and applied late is not counted, because nothing was lost. It is not
+     * zero when slices reorder on a sender pinned to the ring floor, which is what
      * `max_packets_per_tick: 1` produces under jitter.
      *
      * `skipped_duplicate` is the healthy counterpart — the action stream's own redundancy arriving
@@ -426,6 +436,7 @@ export class Replicator {
             peer_id, in_buffer, in_buffer_end, state.next_frame,
             slice !== null ? slice.frame_start : 0,
             slice !== null ? slice.frame_end : Infinity,
+            true,
         );
         const covered_through = slice !== null ? slice.frame_end : last_frame;
         if (covered_through + 1 > state.next_frame) {
@@ -444,16 +455,24 @@ export class Replicator {
      * the header's end, so a frame beyond it would be applied again by the
      * slice that genuinely carries it.
      *
+     * `count_skipped` is the other half, and it is not the same question:
+     * `min_frame` says which frames this walk applies, `count_skipped` says
+     * whether the walk decides the skipped ones' fate. A validation walk before
+     * a hold decides nothing — the bytes are kept and every frame in them still
+     * runs, a few packets later — so it books nothing. The walks that do decide
+     * are the ones that apply, and the walk over a held slice being discarded.
+     *
      * @param {number} peer_id
      * @param {BinaryBuffer} in_buffer
      * @param {number} in_buffer_end
      * @param {number} min_frame
      * @param {number} frame_start
      * @param {number} frame_end
+     * @param {boolean} count_skipped book each skipped frame on the delivery counters
      * @returns {number} the highest frame number the packet carries, or -1 if none
      * @private
      */
-    #apply_groups(peer_id, in_buffer, in_buffer_end, min_frame, frame_start, frame_end) {
+    #apply_groups(peer_id, in_buffer, in_buffer_end, min_frame, frame_start, frame_end, count_skipped) {
         const registry = this.action_registry;
         let last_frame = -1;
 
@@ -479,14 +498,19 @@ export class Replicator {
                  this is the action stream's own redundancy doing its job; anything else means the
                  watermark moved past a frame that never ran, and nothing will re-send it because
                  its channel-level ack already told the sender it arrived.
-                */
-                const delivery = this.#delivery_state(peer_id);
-                const slot = frame_number % delivery.applied.length;
 
-                if (delivery.applied[slot] === frame_number) {
-                    delivery.skipped_duplicate++;
-                } else {
-                    delivery.skipped_unapplied++;
+                 Asked only where the answer is final. A frame walked past by a validation walk is
+                 not being lost and is not a duplicate: it is about to be copied aside and run.
+                */
+                if (count_skipped) {
+                    const delivery = this.#delivery_state(peer_id);
+                    const slot = frame_number % delivery.applied.length;
+
+                    if (delivery.applied[slot] === frame_number) {
+                        delivery.skipped_duplicate++;
+                    } else {
+                        delivery.skipped_unapplied++;
+                    }
                 }
 
                 for (let i = 0; i < action_count; i++) {
@@ -565,7 +589,7 @@ export class Replicator {
      */
     #hold_slice(peer_id, state, slice, in_buffer, in_buffer_end) {
         const start = in_buffer.position;
-        this.#apply_groups(peer_id, in_buffer, in_buffer_end, Infinity, slice.frame_start, slice.frame_end);
+        this.#apply_groups(peer_id, in_buffer, in_buffer_end, Infinity, slice.frame_start, slice.frame_end, false);
 
         const held = state.held;
         let i = 0;
@@ -579,13 +603,21 @@ export class Replicator {
         // copy covered, so a frame only one copy covers is never sent again:
         // keep the copy that reaches further, and between equals the newer,
         // which carries the sender's latest content for those frames.
+        // Either way round, the copy that loses covers no frame the winner does
+        // not, so nothing is dropped here and nothing is booked.
         const same_start = i < held.length && held[i].frame_start === slice.frame_start;
         if (same_start && held[i].frame_end > slice.frame_end) return;
         if (!same_start && held.length >= MAX_HELD_SLICES) {
             // Keep the slices nearest the gap — the ones the next head is most
-            // likely to release — and drop the farthest.
-            if (i === held.length) return;
-            held.pop();
+            // likely to release — and drop the farthest. Those frames are gone:
+            // acked at the channel level, so the sender credits them and never
+            // sends them again. Book them, or the cap loses frames in silence.
+            if (i === held.length) {
+                in_buffer.position = start;
+                this.#apply_groups(peer_id, in_buffer, in_buffer_end, Infinity, slice.frame_start, slice.frame_end, true);
+                return;
+            }
+            this.#discard_held(peer_id, held.pop());
         }
 
         const length = in_buffer_end - start;
@@ -610,6 +642,7 @@ export class Replicator {
         while (held.length > 0 && held[0].frame_start < frame) {
             const h = held.shift();
             if (h.frame_end >= state.next_frame) this.#apply_held(peer_id, state, h);
+            else this.#discard_held(peer_id, h);
         }
     }
 
@@ -624,6 +657,7 @@ export class Replicator {
             const h = held[0];
             if (h.frame_end < state.next_frame) {
                 held.shift();
+                this.#discard_held(peer_id, h);
                 continue;
             }
             if (h.frame_start > state.next_frame) break;
@@ -635,12 +669,27 @@ export class Replicator {
     /** @private */
     #apply_held(peer_id, state, h) {
         h.buffer.position = 0;
-        this.#apply_groups(peer_id, h.buffer, h.length, state.next_frame, h.frame_start, h.frame_end);
+        this.#apply_groups(peer_id, h.buffer, h.length, state.next_frame, h.frame_start, h.frame_end, true);
         if (h.frame_end + 1 > state.next_frame) {
             state.next_frame = h.frame_end + 1;
         }
     }
 
+    /**
+     * A held slice that will never be applied — overtaken by the watermark, or
+     * dropped at the cap. This walk is the last thing that happens to those
+     * frames, so it is the one that books them: the ring separates the copy
+     * whose frames ran from the slice that carried the only copy there was.
+     *
+     * The bytes were validated when they were held, so this cannot throw.
+     *
+     * @private
+     */
+    #discard_held(peer_id, h) {
+        h.buffer.position = 0;
+        this.#apply_groups(peer_id, h.buffer, h.length, Infinity, h.frame_start, h.frame_end, true);
+    }
+
     /**
      * Forget a peer's inbound state — its apply watermark and any slices held
      * for it. Call when a peer disconnects so a later peer reusing the same id

package/src/engine/physics/broadphase/compute_fat_world_aabb.js

@@ -33,15 +33,15 @@ const FAT_VELOCITY_MULTIPLIER = 2;
 export function compute_world_aabb(result, result_offset, shape, transform) {
     shape.compute_bounding_box(scratch_local);
 
-    const p = transform.position;
+    const p = transform.translation;
     const q = transform.rotation;
 
     aabb3_transform_oriented(
         result, result_offset,
         scratch_local[0], scratch_local[1], scratch_local[2],
         scratch_local[3], scratch_local[4], scratch_local[5],
-        p.x, p.y, p.z,
-        q.x, q.y, q.z, q.w
+        transform.translation_x, transform.translation_y, transform.translation_z,
+        transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w
     );
 }
 

package/src/engine/physics/ccd/linear_sweep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linear_sweep.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ccd/linear_sweep.js"],"names":[],"mappings":"AAgKA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAdW,OAAO,yBAAyB,EAAE,aAAa,SAC/C,OAAO,gDAAgD,EAAE,eAAe,YACxE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,MACrC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,UAEN,mBAAmB,GACjB,MAAM,CA2ClB;AAuID;;;;;;;;;;;;GAYG;AACH,6CAFW,OAAO,yBAAyB,EAAE,aAAa,QAezD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAFW,OAAO,yBAAyB,EAAE,aAAa,QAoHzD;AArgBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAE2B;oCAtDP,mCAAmC"}
+{"version":3,"file":"linear_sweep.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ccd/linear_sweep.js"],"names":[],"mappings":"AAgKA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,0CAdW,OAAO,yBAAyB,EAAE,aAAa,SAC/C,OAAO,gDAAgD,EAAE,eAAe,YACxE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,MACrC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,UAEN,mBAAmB,GACjB,MAAM,CA2ClB;AA2ID;;;;;;;;;;;;GAYG;AACH,6CAFW,OAAO,yBAAyB,EAAE,aAAa,QAezD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAFW,OAAO,yBAAyB,EAAE,aAAa,QAsHzD;AA3gBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAE2B;oCAtDP,mCAAmC"}

package/src/engine/physics/ccd/linear_sweep.js

@@ -320,7 +320,11 @@ function record_ccd_contact(system, body_idx, collider, tr, hit) {
     // near the actual contact patch — a large blocker's support along a face
     // axis is a corner metres away, which is why the narrowphase's EPA fallback
     // refuses support witnesses and falls back to body centres.
-    _clamped.setup(collider.shape, tr.position, tr.rotation);
+    _clamped.setup_components(
+        collider.shape,
+        tr.translation_x, tr.translation_y, tr.translation_z,
+        tr.rotation_x, tr.rotation_y, tr.rotation_z, tr.rotation_w
+    );
     _clamped.support(_witness, 0, -n[0], -n[1], -n[2]);
 
     const wx = _witness[0], wy = _witness[1], wz = _witness[2];
@@ -463,7 +467,7 @@ export function ccd_resolve(system) {
         const list = lists[idx];
         const primary = list[0];
         const tr = primary.transform;
-        const p = tr.position;
+        const p = tr.translation;
 
         const base = idx * 3;
         const sx = start[base];
@@ -502,7 +506,9 @@ export function ccd_resolve(system) {
         // Clamp the body to the first-contact pose (swept-shape centre at the
         // TOI), so it cannot end the step on the far side of the blocker.
         const hp = _hit.position;
-        p.set(hp[0], hp[1], hp[2]);
+        p[0] = hp[0];
+            p[1] = hp[1];
+            p[2] = hp[2];
 
         // Remove the inbound normal component of velocity (inelastic stop).
         // `_hit.normal` is the blocker's outward surface normal; the body is

package/src/engine/physics/constraint/solve_constraints.js

@@ -596,11 +596,11 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
         // World anchor A and its lever arm rA = R_A · localAnchorA.
         const la = joint.localAnchorA;
         v3_quaternion_apply(scratch_anchor, 0, la.x, la.y, la.z,
-            trA.rotation[0], trA.rotation[1], trA.rotation[2], trA.rotation[3]);
+            trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w);
         const rAx = scratch_anchor[0], rAy = scratch_anchor[1], rAz = scratch_anchor[2];
-        const anchorAx = trA.position.x + rAx;
-        const anchorAy = trA.position.y + rAy;
-        const anchorAz = trA.position.z + rAz;
+        const anchorAx = trA.translation_x + rAx;
+        const anchorAy = trA.translation_y + rAy;
+        const anchorAz = trA.translation_z + rAz;
 
         // World anchor B + lever arm rB. For a world anchor, localAnchorB is a
         // fixed world point and there is no body B lever.
@@ -611,11 +611,11 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
             anchorBx = lb.x; anchorBy = lb.y; anchorBz = lb.z;
         } else {
             v3_quaternion_apply(scratch_anchor, 0, lb.x, lb.y, lb.z,
-                trB.rotation[0], trB.rotation[1], trB.rotation[2], trB.rotation[3]);
+                trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w);
             rBx = scratch_anchor[0]; rBy = scratch_anchor[1]; rBz = scratch_anchor[2];
-            anchorBx = trB.position.x + rBx;
-            anchorBy = trB.position.y + rBy;
-            anchorBz = trB.position.z + rBz;
+            anchorBx = trB.translation_x + rBx;
+            anchorBy = trB.translation_y + rBy;
+            anchorBz = trB.translation_z + rBz;
         }
 
         // Position error C = anchorA − anchorB (its projection on a frame axis
@@ -632,7 +632,7 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
         // body-A rotation ⊗ localBasisA; the rows of its matrix are the frame
         // axes in world (see quat3_to_matrix3).
         const lba = joint.localBasisA;
-        quat3_multiply(scratch_q, 0, trA.rotation[0], trA.rotation[1], trA.rotation[2], trA.rotation[3], lba[0], lba[1], lba[2], lba[3]);
+        quat3_multiply(scratch_q, 0, trA.rotation_x, trA.rotation_y, trA.rotation_z, trA.rotation_w, lba[0], lba[1], lba[2], lba[3]);
         const qAx = scratch_q[0], qAy = scratch_q[1], qAz = scratch_q[2], qAw = scratch_q[3];
         quat3_to_matrix3(scratch_frame_a, 0, qAx, qAy, qAz, qAw);
         const fa = scratch_frame_a;
@@ -693,7 +693,7 @@ export function solve_joints(joints, system, dt_sub, iters, reverse) {
             let qBx = 0, qBy = 0, qBz = 0, qBw = 1;
             if (!to_world) {
                 const lbb = joint.localBasisB;
-                quat3_multiply(scratch_q, 0, trB.rotation[0], trB.rotation[1], trB.rotation[2], trB.rotation[3], lbb[0], lbb[1], lbb[2], lbb[3]);
+                quat3_multiply(scratch_q, 0, trB.rotation_x, trB.rotation_y, trB.rotation_z, trB.rotation_w, lbb[0], lbb[1], lbb[2], lbb[3]);
                 qBx = scratch_q[0]; qBy = scratch_q[1]; qBz = scratch_q[2]; qBw = scratch_q[3];
             }
             // qD = conj(qA) ⊗ qB → the per-axis angular position in frame-A

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

@@ -1,5 +1,5 @@
 /**
- * Observes every entity that gains a `(Collider, Transform)` tuple and
+ * Observes every entity that gains a `(Collider, Transform64)` tuple and
  * attaches the collider to the appropriate {@link PhysicsSystem} body:
  *
  *  - If the same entity also carries a {@link RigidBody}, the collider is
@@ -22,22 +22,22 @@ export class ColliderObserverSystem extends System<any> {
      * @param {PhysicsSystem} physicsSystem
      */
     constructor(physicsSystem: PhysicsSystem);
-    dependencies: (typeof Transform | typeof Collider)[];
-    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof ParentEntity>)[];
+    dependencies: (typeof Transform64 | typeof Collider)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof ParentEntity>)[];
     /** @type {PhysicsSystem} */
     __physics: PhysicsSystem;
     /**
      * @param {Collider} collider
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    link(collider: Collider, transform: Transform, entity: number): void;
+    link(collider: Collider, transform: Transform64, entity: number): void;
     /**
      * @param {Collider} collider
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    unlink(collider: Collider, transform: Transform, entity: number): void;
+    unlink(collider: Collider, transform: Transform64, entity: number): void;
     /**
      * Walk RigidBody-on-self → ParentEntity → orphan, returning the entity
      * that owns the body this collider belongs to.
@@ -50,7 +50,7 @@ export class ColliderObserverSystem extends System<any> {
     private __resolve_body_entity;
 }
 import { System } from "../../ecs/System.js";
-import { Transform } from "../../ecs/transform/Transform.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 import { Collider } from "./Collider.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { RigidBody } from "./RigidBody.js";

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

@@ -1 +1 @@
-{"version":3,"file":"ColliderObserverSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/ColliderObserverSystem.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAUI;;OAEG;IACH,0CAKC;IAhBD,qDAAqC;IACrC,qNAKE;IAQE,4BAA4B;IAC5B,yBAA8B;IAGlC;;;;OAIG;IACH,eAJW,QAAQ,aACR,SAAS,UACT,MAAM,QAYhB;IAED;;;;OAIG;IACH,iBAJW,QAAQ,aACR,SAAS,UACT,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,8BAUC;CACJ;uBAlGsB,qBAAqB;0BAClB,kCAAkC;yBACnC,eAAe;4CAHI,oDAAoD;0BAItE,gBAAgB;6BANb,kCAAkC"}
+{"version":3,"file":"ColliderObserverSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/ColliderObserverSystem.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAUI;;OAEG;IACH,0CAKC;IAhBD,uDAAuC;IACvC,uNAKE;IAQE,4BAA4B;IAC5B,yBAA8B;IAGlC;;;;OAIG;IACH,eAJW,QAAQ,aACR,WAAW,UACX,MAAM,QAYhB;IAED;;;;OAIG;IACH,iBAJW,QAAQ,aACR,WAAW,UACX,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,8BAUC;CACJ;uBAlGsB,qBAAqB;4BAChB,oCAAoC;yBACvC,eAAe;4CAHI,oDAAoD;0BAItE,gBAAgB;6BANb,kCAAkC"}

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

@@ -2,12 +2,12 @@ import { ParentEntity } from "../../ecs/parent/ParentEntity.js";
 import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { System } from "../../ecs/System.js";
-import { Transform } from "../../ecs/transform/Transform.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 import { Collider } from "./Collider.js";
 import { RigidBody } from "./RigidBody.js";
 
 /**
- * Observes every entity that gains a `(Collider, Transform)` tuple and
+ * Observes every entity that gains a `(Collider, Transform64)` tuple and
  * attaches the collider to the appropriate {@link PhysicsSystem} body:
  *
  *  - If the same entity also carries a {@link RigidBody}, the collider is
@@ -27,10 +27,10 @@ import { RigidBody } from "./RigidBody.js";
  */
 export class ColliderObserverSystem extends System {
 
-    dependencies = [Collider, Transform];
+    dependencies = [Collider, Transform64];
     components_used = [
         ResourceAccessSpecification.from(Collider, ResourceAccessKind.Read | ResourceAccessKind.Write),
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read),
         ResourceAccessSpecification.from(RigidBody, ResourceAccessKind.Read),
         ResourceAccessSpecification.from(ParentEntity, ResourceAccessKind.Read),
     ];
@@ -47,7 +47,7 @@ export class ColliderObserverSystem extends System {
 
     /**
      * @param {Collider} collider
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     link(collider, transform, entity) {
@@ -64,7 +64,7 @@ export class ColliderObserverSystem extends System {
 
     /**
      * @param {Collider} collider
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     unlink(collider, transform, entity) {