@woosh/meep-engine 3.15.0 → 3.16.0

package/src/engine/interpolation/TransformPoseSerializationAdapter.js

@@ -1,8 +1,8 @@
 import { BinaryClassSerializationAdapter } from "../ecs/storage/binary/BinaryClassSerializationAdapter.js";
-import { Transform } from "../ecs/transform/Transform.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
 
 /**
- * Full-precision (Float64) pose serializer for {@link Transform}: position +
+ * Full-precision (Float64) pose serializer for {@link Transform64}: position +
  * rotation only (the physics integrator never changes scale, so it's left to
  * the live component). 7 × Float64 = 56 bytes.
  *
@@ -20,28 +20,27 @@ import { Transform } from "../ecs/transform/Transform.js";
  */
 export class TransformPoseSerializationAdapter extends BinaryClassSerializationAdapter {
 
-    klass = Transform;
+    klass = Transform64;
     version = 0;
 
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
     serialize(buffer, transform) {
-        const p = transform.position;
         const r = transform.rotation;
-        buffer.writeFloat64(p.x);
-        buffer.writeFloat64(p.y);
-        buffer.writeFloat64(p.z);
-        buffer.writeFloat64(r.x);
-        buffer.writeFloat64(r.y);
-        buffer.writeFloat64(r.z);
-        buffer.writeFloat64(r.w);
+        buffer.writeFloat64(transform.translation_x);
+        buffer.writeFloat64(transform.translation_y);
+        buffer.writeFloat64(transform.translation_z);
+        buffer.writeFloat64(r[0]);
+        buffer.writeFloat64(r[1]);
+        buffer.writeFloat64(r[2]);
+        buffer.writeFloat64(r[3]);
     }
 
     /**
      * @param {BinaryBuffer} buffer
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
     deserialize(buffer, transform) {
         const px = buffer.readFloat64();
@@ -51,7 +50,7 @@ export class TransformPoseSerializationAdapter extends BinaryClassSerializationA
         const ry = buffer.readFloat64();
         const rz = buffer.readFloat64();
         const rw = buffer.readFloat64();
-        transform.position.set(px, py, pz);
-        transform.rotation.set(rx, ry, rz, rw);
+        transform.setTranslation(px, py, pz);
+        transform.setRotation(rx, ry, rz, rw);
     }
 }

package/src/engine/interpolation/pose_interpoland.d.ts

@@ -1,5 +1,5 @@
 /**
- * Interpolation-log type id for the {@link Transform} pose interpoland. Type ids
+ * Interpolation-log type id for the {@link Transform64} pose interpoland. Type ids
  * distinguish interpoland kinds under one entity key; pose is the first (0).
  * When more kinds land, an interpolation registry should assign these so they
  * can't collide. (For replicated entities this must eventually align with the
@@ -8,7 +8,7 @@
  */
 export const POSE_TYPE_ID: number;
 /**
- * Shared, stateless pose interpoland: blend a body's {@link Transform} position
+ * Shared, stateless pose interpoland: blend a body's {@link Transform64} position
  * + rotation. Reused across every entity that interpolates its pose — a body
  * opting in carries an `Interpolated` whose `interpolands` is `[POSE_INTERPOLAND]`.
  * @type {Interpoland}

package/src/engine/interpolation/pose_interpoland.js

@@ -1,10 +1,10 @@
-import { Transform } from "../ecs/transform/Transform.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
 import { Interpoland } from "./Interpoland.js";
 import { PoseInterpolationAdapter } from "./PoseInterpolationAdapter.js";
 import { TransformPoseSerializationAdapter } from "./TransformPoseSerializationAdapter.js";
 
 /**
- * Interpolation-log type id for the {@link Transform} pose interpoland. Type ids
+ * Interpolation-log type id for the {@link Transform64} pose interpoland. Type ids
  * distinguish interpoland kinds under one entity key; pose is the first (0).
  * When more kinds land, an interpolation registry should assign these so they
  * can't collide. (For replicated entities this must eventually align with the
@@ -14,14 +14,14 @@ import { TransformPoseSerializationAdapter } from "./TransformPoseSerializationA
 export const POSE_TYPE_ID = 0;
 
 /**
- * Shared, stateless pose interpoland: blend a body's {@link Transform} position
+ * Shared, stateless pose interpoland: blend a body's {@link Transform64} position
  * + rotation. Reused across every entity that interpolates its pose — a body
  * opting in carries an `Interpolated` whose `interpolands` is `[POSE_INTERPOLAND]`.
  * @type {Interpoland}
  */
 export const POSE_INTERPOLAND = new Interpoland(
     POSE_TYPE_ID,
-    Transform,
+    Transform64,
     new TransformPoseSerializationAdapter(),
     new PoseInterpolationAdapter(),
 );

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

@@ -2,7 +2,7 @@ export default PathFollowingSystem;
 declare class PathFollowingSystem extends System<any> {
     constructor();
     dependencies: (typeof PathFollower)[];
-    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof PathFollower> | ResourceAccessSpecification<typeof Path>)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof PathFollower> | ResourceAccessSpecification<typeof Path>)[];
     /**
      *
      * @type {number}
@@ -12,15 +12,15 @@ declare class PathFollowingSystem extends System<any> {
     /**
      *
      * @param {PathFollower} pathFollower
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {Path} path
      * @param {number} entity Entity ID
      */
-    __visit_entity(pathFollower: PathFollower, transform: Transform, path: Path, entity: number): void;
+    __visit_entity(pathFollower: PathFollower, transform: Transform64, path: Path, entity: number): void;
 }
 import { System } from '../../../ecs/System.js';
 import PathFollower from './PathFollower.js';
-import { Transform } from '../../../ecs/transform/Transform.js';
+import { Transform64 } from '../../../ecs/transform/Transform64.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,sCAA8B;IAC9B,iKAIE;IAEF;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,SAAS,QACT,IAAI,UACJ,MAAM,QAuBhB;CAgBJ;uBA9KsB,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":";AAiJA;;IACI,sCAA8B;IAC9B,mKAIE;IAEF;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,WAAW,QACX,IAAI,UACJ,MAAM,QAuBhB;CAgBJ;uBAvMsB,wBAAwB;yBAGtB,mBAAmB;4BAFhB,uCAAuC;4CAFvB,uDAAuD;iBAGlF,uBAAuB"}

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