@woosh/meep-engine 3.38.0 → 3.40.0

package/src/engine/interpolation/BinaryInterpolationAdapter.js

@@ -17,7 +17,7 @@ export const InterpolationKind = Object.freeze({
 
 /**
  * Per-component-type interpolator: reads two encoded snapshots of one
- * component from `source`, blends by `t`, writes the result to
+ * component from `source`, blends them, writes the result to
  * `out_buffer` in the SAME wire format so the receiver can deserialize
  * directly via the corresponding `BinaryClassSerializationAdapter`.
  *
@@ -42,15 +42,21 @@ export class BinaryInterpolationAdapter {
      *
      * `first_offset === second_offset` is the degenerate "snap to single
      * snapshot" case — implementations don't need to special-case it; the
-     * blend at any `t` reduces to the input.
+     * blend at any fraction reduces to the input.
+     *
+     * The blend fraction arrives in an array, `blend[blend_offset]`, not as a
+     * number: a caller blends every entity of a frame at the same fraction, and
+     * a number handed to a call V8 does not inline is boxed into a new heap
+     * object on every call, where an array is handed over as it is.
      *
      * @param {BinaryBuffer} out_buffer
      * @param {BinaryBuffer} source
      * @param {number} first_offset byte position of snapshot A
      * @param {number} second_offset byte position of snapshot B
-     * @param {number} t blend fraction in [0, 1]; 0 ⇒ A, 1 ⇒ B
+     * @param {Float64Array} blend holds the blend fraction, in [0, 1]; 0 ⇒ A, 1 ⇒ B
+     * @param {number} blend_offset index of the fraction in `blend`
      */
-    interpolate(out_buffer, source, first_offset, second_offset, t) {
-        throw new Error('BinaryInterpolationAdapter subclasses must override interpolate(out, src, off_a, off_b, t).');
+    interpolate(out_buffer, source, first_offset, second_offset, blend, blend_offset) {
+        throw new Error('BinaryInterpolationAdapter subclasses must override interpolate(out, src, off_a, off_b, blend, blend_offset).');
     }
 }

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

@@ -40,7 +40,8 @@
  *
  * Typical render-time use:
  * ```
- *   const ok = log.interpolate(out_buffer, network_id, type_id, tick_a, tick_b, t, adapter);
+ *   blend[0] = t; // a Float64Array the caller keeps
+ *   const ok = log.interpolate(out_buffer, network_id, type_id, tick_a, tick_b, blend, 0, adapter);
  *   if (ok) { /* deserialize from out_buffer into the live component }
  * ```
  *
@@ -129,21 +130,26 @@ export class InterpolationLog {
      * result to `out_buffer` at its current position.
      *
      * Outcome by available data:
-     *   - Both ticks carry the component → adapter blends them at `t`.
+     *   - Both ticks carry the component → adapter blends them at
+     *     `blend[blend_offset]`.
      *   - Only one carries it → adapter is called with the same offset twice
-     *     (snap to the surviving snapshot; `t` is irrelevant).
+     *     (snap to the surviving snapshot; the fraction is irrelevant).
      *   - Neither carries it → returns false; `out_buffer` is unchanged.
      *
+     * The fraction is passed in an array and handed on to the adapter as it
+     * is: see {@link BinaryInterpolationAdapter#interpolate} for why.
+     *
      * @param {BinaryBuffer} out_buffer
      * @param {number} network_id
      * @param {number} type_id
      * @param {number} tick_a
      * @param {number} tick_b
-     * @param {number} t
+     * @param {Float64Array} blend holds the blend fraction, in [0, 1]; 0 ⇒ `tick_a`, 1 ⇒ `tick_b`
+     * @param {number} blend_offset index of the fraction in `blend`
      * @param {BinaryInterpolationAdapter} adapter
      * @returns {boolean} true if a payload was written; false if neither tick has the component
      */
-    interpolate(out_buffer: BinaryBuffer, network_id: number, type_id: number, tick_a: number, tick_b: number, t: number, adapter: BinaryInterpolationAdapter): boolean;
+    interpolate(out_buffer: BinaryBuffer, network_id: number, type_id: number, tick_a: number, tick_b: number, blend: Float64Array, blend_offset: number, adapter: BinaryInterpolationAdapter): boolean;
     /**
      * Replace one closed record's payload in place, with a payload of the same length.
      *

package/src/engine/interpolation/InterpolationLog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InterpolationLog.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationLog.js"],"names":[],"mappings":"AAqFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IA+CI;;;;;OAKG;IACH,0DALW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EAkDvE;IA9BG,kFAAkF;IAClF,iBADwE,MAAM,CAClC;IAY5C,+EAA+E;IAC/E,kBADqE,MAAM,CACnC;IAkB5C;;;;;;;;OAQG;IACH,iBAFW,MAAM,QAkEhB;IAED;;;;;;;;;;;;;OAaG;IACH,yBAJW,MAAM,WACN,MAAM,GACJ,YAAY,CAmCxB;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;;;OAOG;IACH,iBAeC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,YAPW,MAAM,EAAE,GAAC,WAAW,cACpB,MAAM,QACN,MAAM,cACN,MAAM,WACN,MAAM,GACJ,OAAO,CA+BnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,wBATW,YAAY,cACZ,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,KACN,MAAM,wCAEJ,OAAO,CAuBnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cANW,MAAM,cACN,MAAM,WACN,MAAM,aACN,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAC5B,OAAO,CAyBnB;IAED;;;;;;;OAOG;IACH,+BAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBAHW,MAAM,GACJ,OAAO,CAqCnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,cASC;;CACJ;6BAprB4B,mCAAmC"}
+{"version":3,"file":"InterpolationLog.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationLog.js"],"names":[],"mappings":"AAqFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IA+CI;;;;;OAKG;IACH,0DALW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EAkDvE;IA9BG,kFAAkF;IAClF,iBADwE,MAAM,CAClC;IAY5C,+EAA+E;IAC/E,kBADqE,MAAM,CACnC;IAkB5C;;;;;;;;OAQG;IACH,iBAFW,MAAM,QAkEhB;IAED;;;;;;;;;;;;;OAaG;IACH,yBAJW,MAAM,WACN,MAAM,GACJ,YAAY,CAmCxB;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;;;OAOG;IACH,iBAeC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,YAPW,MAAM,EAAE,GAAC,WAAW,cACpB,MAAM,QACN,MAAM,cACN,MAAM,WACN,MAAM,GACJ,OAAO,CA+BnB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,wBAVW,YAAY,cACZ,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,SACN,YAAY,gBACZ,MAAM,wCAEJ,OAAO,CAuBnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cANW,MAAM,cACN,MAAM,WACN,MAAM,aACN,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAC5B,OAAO,CAyBnB;IAED;;;;;;;OAOG;IACH,+BAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBAHW,MAAM,GACJ,OAAO,CAqCnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,cASC;;CACJ;6BA1rB4B,mCAAmC"}

package/src/engine/interpolation/InterpolationLog.js

@@ -125,7 +125,8 @@ function bloom_contains(table, base, key) {
  *
  * Typical render-time use:
  * ```
- *   const ok = log.interpolate(out_buffer, network_id, type_id, tick_a, tick_b, t, adapter);
+ *   blend[0] = t; // a Float64Array the caller keeps
+ *   const ok = log.interpolate(out_buffer, network_id, type_id, tick_a, tick_b, blend, 0, adapter);
  *   if (ok) { /* deserialize from out_buffer into the live component }
  * ```
  *
@@ -502,21 +503,26 @@ export class InterpolationLog {
      * result to `out_buffer` at its current position.
      *
      * Outcome by available data:
-     *   - Both ticks carry the component → adapter blends them at `t`.
+     *   - Both ticks carry the component → adapter blends them at
+     *     `blend[blend_offset]`.
      *   - Only one carries it → adapter is called with the same offset twice
-     *     (snap to the surviving snapshot; `t` is irrelevant).
+     *     (snap to the surviving snapshot; the fraction is irrelevant).
      *   - Neither carries it → returns false; `out_buffer` is unchanged.
      *
+     * The fraction is passed in an array and handed on to the adapter as it
+     * is: see {@link BinaryInterpolationAdapter#interpolate} for why.
+     *
      * @param {BinaryBuffer} out_buffer
      * @param {number} network_id
      * @param {number} type_id
      * @param {number} tick_a
      * @param {number} tick_b
-     * @param {number} t
+     * @param {Float64Array} blend holds the blend fraction, in [0, 1]; 0 ⇒ `tick_a`, 1 ⇒ `tick_b`
+     * @param {number} blend_offset index of the fraction in `blend`
      * @param {BinaryInterpolationAdapter} adapter
      * @returns {boolean} true if a payload was written; false if neither tick has the component
      */
-    interpolate(out_buffer, network_id, type_id, tick_a, tick_b, t, adapter) {
+    interpolate(out_buffer, network_id, type_id, tick_a, tick_b, blend, blend_offset, adapter) {
         const a = this.locate(scratch_u32, 4, tick_a, network_id, type_id);
         const b = this.locate(scratch_u32, 6, tick_b, network_id, type_id);
 
@@ -533,7 +539,7 @@ export class InterpolationLog {
         // surprised by a moved cursor.
         const buffer = this.#buffer;
         const saved = buffer.position;
-        adapter.interpolate(out_buffer, buffer, first, second, t);
+        adapter.interpolate(out_buffer, buffer, first, second, blend, blend_offset);
         buffer.position = saved;
 
         return true;

package/src/engine/interpolation/InterpolationSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationSystem.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;GAWG;AACH,yCAHW,WAAW,4EACX,YAAY,QAgBtB;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IAoGI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EA2BvE;IA9HD,sCAA8B;IAC9B,wHAIE;IAEF;;;;OAIG;IACH,mBAAuB;IAEvB;;;;;;;OAOG;IACH,kBAAsB;IAEtB;;;;;OAKG;IACH,yBAA6B;IA0EzB;;;;OAIG;IACH,KAFU,gBAAgB,CAEkD;IAE5E;;;;OAIG;IACH,kBAAmC;IAGnC;;;;OAIG;IACH,gBAAiC;IAIrC;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,OACN,gBAAgB,UAChB,MAAM;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,QAc7D;IAED;;;OAGG;IACH,oBAFa,MAAM,CAOlB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qDAEC;IAED;;OAEG;IACH,sDAEC;IAED;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAchB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAUhB;IAED;;;;OAIG;IACH,gBAYC;IAED;;;;;;;;;OASG;IACH,eA6BC;IA2OD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAkCnB;IAuED,sBA0HC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;;CANlD;4BA11B2B,iCAAiC;uBADtC,kBAAkB;6BAIyC,mBAAmB;4CALzD,iDAAiD;iCAI5D,uBAAuB"}
+{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationSystem.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;GAWG;AACH,yCAHW,WAAW,4EACX,YAAY,QAgBtB;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IA4GI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EA2BvE;IAtID,sCAA8B;IAC9B,wHAIE;IAEF;;;;OAIG;IACH,mBAAuB;IAEvB;;;;;;;OAOG;IACH,kBAAsB;IAEtB;;;;;OAKG;IACH,yBAA6B;IAkFzB;;;;OAIG;IACH,KAFU,gBAAgB,CAEkD;IAE5E;;;;OAIG;IACH,kBAAmC;IAGnC;;;;OAIG;IACH,gBAAiC;IAIrC;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,OACN,gBAAgB,UAChB,MAAM;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,QAc7D;IAED;;;OAGG;IACH,oBAFa,MAAM,CAOlB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qDAEC;IAED;;OAEG;IACH,sDAEC;IAED;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAchB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAUhB;IAED;;;;OAIG;IACH,gBAcC;IAED;;;;;;;;;OASG;IACH,eAiCC;IAkPD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAkCnB;IAuED,sBA8HC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;;CANlD;4BAz3B2B,iCAAiC;uBADtC,kBAAkB;6BAIyC,mBAAmB;4CALzD,iDAAiD;iCAI5D,uBAAuB"}

package/src/engine/interpolation/InterpolationSystem.js

@@ -13,6 +13,12 @@ import { Interpolated, INTERPOLATION_KEY_UNSET, INTERPOLATION_SOURCE_LOCAL } fro
  */
 const LOCAL_HISTORY_TICKS = 8;
 
+/**
+ * A blend fraction of zero, `[0]`, for reading one tick back out of the log unblended. Never written.
+ * @type {Float64Array}
+ */
+const NO_BLEND = new Float64Array(1);
+
 /**
  * Move `t` by `(dx, dy, dz)` and turn it by the unit quaternion `(ex, ey, ez, ew)` in its own
  * frame — on the right, `q' = q * e`.
@@ -195,6 +201,14 @@ export class InterpolationSystem extends System {
     /** @type {Float64Array} */
     #quat_scratch = new Float64Array(4);
 
+    /**
+     * The blend fraction {@link update} hands the log, `[t]`: written before each blend and passed
+     * as an array, since a fraction passed as a number to the log and on to its adapter is boxed
+     * into a heap object on every call V8 does not inline.
+     * @type {Float64Array}
+     */
+    #blend = new Float64Array(1);
+
     /**
      * @param {{ buffer_capacity_bytes?: number, records_capacity?: number }} [options]
      */
@@ -330,8 +344,10 @@ export class InterpolationSystem extends System {
             return;
         }
 
-        for (const [entity, slots] of displaced) {
-            this.#restore_slots(entity, slots, this.__entities.get(entity));
+        // Keys, then a lookup, as every Map walk in this system: destructuring the Map's own entries
+        // builds a [key, value] array for each one, every frame and every step.
+        for (const entity of displaced.keys()) {
+            this.#restore_slots(entity, displaced.get(entity), this.__entities.get(entity));
         }
 
         displaced.clear();
@@ -365,7 +381,11 @@ export class InterpolationSystem extends System {
             this.#record(completed);
         } else if (completed >= 0) {
             // already recorded (by a render update since); a teleport raised after that is not in it
-            for (const [entity, interpolated] of this.__entities) {
+            const entities = this.__entities;
+
+            for (const entity of entities.keys()) {
+                const interpolated = entities.get(entity);
+
                 if (interpolated.snap && interpolated.sourceId === INTERPOLATION_SOURCE_LOCAL) {
                     this.#rewrite_with_live(entity, interpolated, completed);
                 }
@@ -429,9 +449,12 @@ export class InterpolationSystem extends System {
             }
 
             this.#release(slot);
+
+            slots[i] = null;
         }
 
-        slots.length = 0;
+        // Emptied slot by slot, not truncated: `slots.length = 0` drops the backing store, and the
+        // next entity to take this array from the pool allocated a new one on its first push.
         this.#slots_pool.push(slots);
     }
 
@@ -538,7 +561,11 @@ export class InterpolationSystem extends System {
 
         let open = false;
 
-        for (const [entity, interpolated] of this.__entities) {
+        const entities = this.__entities;
+
+        for (const entity of entities.keys()) {
+            const interpolated = entities.get(entity);
+
             if (interpolated.sourceId !== INTERPOLATION_SOURCE_LOCAL) {
                 continue;
             }
@@ -678,7 +705,7 @@ export class InterpolationSystem extends System {
         const scratch = this.__scratch;
 
         scratch.position = 0;
-        if (!log.interpolate(scratch, key, interpoland.type_id, tick, tick, 0, interpoland.interpolation_adapter)) {
+        if (!log.interpolate(scratch, key, interpoland.type_id, tick, tick, NO_BLEND, 0, interpoland.interpolation_adapter)) {
             return;
         }
 
@@ -753,6 +780,7 @@ export class InterpolationSystem extends System {
         this.#record(em.fixedStepTick);
 
         const scratch = this.__scratch;
+        const blend = this.#blend;
 
         // Default (local) timeline: blend the last two completed fixed steps at
         // the sub-step alpha, reading this system's own log.
@@ -767,7 +795,8 @@ export class InterpolationSystem extends System {
 
         this.#decay_offsets(dt);
 
-        for (const [entity, interpolated] of entities) {
+        for (const entity of entities.keys()) {
+            const interpolated = entities.get(entity);
             const key = interpolated.key;
             if (key === INTERPOLATION_KEY_UNSET) {
                 continue;
@@ -832,8 +861,10 @@ export class InterpolationSystem extends System {
                 const interpoland = interpolands[i];
 
                 scratch.position = 0;
+                blend[0] = t;
+
                 const ok = log.interpolate(
-                    scratch, key, interpoland.type_id, tick_a, tick_b, t, interpoland.interpolation_adapter
+                    scratch, key, interpoland.type_id, tick_a, tick_b, blend, 0, interpoland.interpolation_adapter
                 );
                 if (!ok) {
                     // Neither tick carries this interpoland — leave the live

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

@@ -11,7 +11,7 @@
  */
 export class PoseInterpolationAdapter extends BinaryInterpolationAdapter {
     /** @inheritdoc */
-    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, t: any): void;
+    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, blend: any, blend_offset: any): void;
 }
 import { BinaryInterpolationAdapter } from "./BinaryInterpolationAdapter.js";
 //# sourceMappingURL=PoseInterpolationAdapter.d.ts.map

package/src/engine/interpolation/PoseInterpolationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PoseInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/PoseInterpolationAdapter.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IAEI,kBAAkB;IAClB,+FA2CC;CACJ;2CA5D0C,iCAAiC"}
+{"version":3,"file":"PoseInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/PoseInterpolationAdapter.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;GAUG;AACH;IAEI,kBAAkB;IAClB,sHAuDC;CACJ;2CAzF0C,iCAAiC"}

package/src/engine/interpolation/PoseInterpolationAdapter.js

@@ -1,5 +1,22 @@
 import { BinaryInterpolationAdapter } from "./BinaryInterpolationAdapter.js";
 
+/**
+ * The two snapshots {@link PoseInterpolationAdapter#interpolate} blends, read out of the log as
+ * arrays: `[x, y, z, qx, qy, qz, qw]` of the first, then of the second. Read one number at a time,
+ * the fourteen reads took 574 of the 920 bytes of bytecode V8 will inline into one function, the
+ * last of the seven writes of the blend no longer fitted, and it was called out of line with its
+ * number boxed into a heap object.
+ * @type {Float64Array}
+ */
+const scratch_snapshots = new Float64Array(14);
+
+/**
+ * The blend {@link PoseInterpolationAdapter#interpolate} writes, `[x, y, z, qx, qy, qz, qw]`, handed to
+ * the buffer as one array rather than as seven numbers to seven calls.
+ * @type {Float64Array}
+ */
+const scratch_blend = new Float64Array(7);
+
 /**
  * Linear-blend interpolator matching {@link TransformPoseSerializationAdapter}'s
  * layout (7 × Float64: position xyz + rotation xyzw). Position lerps
@@ -14,24 +31,32 @@ import { BinaryInterpolationAdapter } from "./BinaryInterpolationAdapter.js";
 export class PoseInterpolationAdapter extends BinaryInterpolationAdapter {
 
     /** @inheritdoc */
-    interpolate(out_buffer, source, first_offset, second_offset, t) {
+    interpolate(out_buffer, source, first_offset, second_offset, blend, blend_offset) {
+        const t = blend[blend_offset];
+
+        const s = scratch_snapshots;
+
         source.position = first_offset;
-        const ax = source.readFloat64();
-        const ay = source.readFloat64();
-        const az = source.readFloat64();
-        const aqx = source.readFloat64();
-        const aqy = source.readFloat64();
-        const aqz = source.readFloat64();
-        const aqw = source.readFloat64();
+        source.readFloat64Array(s, 0, 7);
 
         source.position = second_offset;
-        const bx = source.readFloat64();
-        const by = source.readFloat64();
-        const bz = source.readFloat64();
-        let bqx = source.readFloat64();
-        let bqy = source.readFloat64();
-        let bqz = source.readFloat64();
-        let bqw = source.readFloat64();
+        source.readFloat64Array(s, 7, 7);
+
+        const ax = s[0];
+        const ay = s[1];
+        const az = s[2];
+        const aqx = s[3];
+        const aqy = s[4];
+        const aqz = s[5];
+        const aqw = s[6];
+
+        const bx = s[7];
+        const by = s[8];
+        const bz = s[9];
+        let bqx = s[10];
+        let bqy = s[11];
+        let bqz = s[12];
+        let bqw = s[13];
 
         // Position: componentwise lerp.
         const ox = ax + (bx - ax) * t;
@@ -50,12 +75,16 @@ export class PoseInterpolationAdapter extends BinaryInterpolationAdapter {
         const inv = len2 > 0 ? 1 / Math.sqrt(len2) : 1;
         qx *= inv; qy *= inv; qz *= inv; qw *= inv;
 
-        out_buffer.writeFloat64(ox);
-        out_buffer.writeFloat64(oy);
-        out_buffer.writeFloat64(oz);
-        out_buffer.writeFloat64(qx);
-        out_buffer.writeFloat64(qy);
-        out_buffer.writeFloat64(qz);
-        out_buffer.writeFloat64(qw);
+        const o = scratch_blend;
+
+        o[0] = ox;
+        o[1] = oy;
+        o[2] = oz;
+        o[3] = qx;
+        o[4] = qy;
+        o[5] = qz;
+        o[6] = qw;
+
+        out_buffer.writeFloat64Array(o, 0, 7);
     }
 }

package/src/engine/interpolation/TransformPoseSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformPoseSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/TransformPoseSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,0BAAoB;IAGpB;;;OAGG;IACH,2CAFW,WAAW,QAWrB;IAED;;;OAGG;IACH,6CAFW,WAAW,QAqBrB;CACJ;gDAlE+C,0DAA0D;4BAC9E,iCAAiC"}
+{"version":3,"file":"TransformPoseSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/TransformPoseSerializationAdapter.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,0BAAoB;IAGpB;;;OAGG;IACH,2CAFW,WAAW,QAOrB;IAED;;;OAGG;IACH,6CAFW,WAAW,QAgBrB;CACJ;gDA7D+C,0DAA0D;4BAKnG,iCAAiC"}

package/src/engine/interpolation/TransformPoseSerializationAdapter.js

@@ -1,5 +1,9 @@
 import { BinaryClassSerializationAdapter } from "../ecs/storage/binary/BinaryClassSerializationAdapter.js";
-import { Transform64 } from "../ecs/transform/Transform64.js";
+import {
+    Transform64,
+    TRANSFORM64_ROTATION_OFFSET,
+    TRANSFORM64_TRANSLATION_OFFSET
+} from "../ecs/transform/Transform64.js";
 
 /**
  * Full-precision (Float64) pose serializer for {@link Transform64}: position +
@@ -30,14 +34,10 @@ export class TransformPoseSerializationAdapter extends BinaryClassSerializationA
      * @param {Transform64} transform
      */
     serialize(buffer, transform) {
-        const r = transform.rotation;
-        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]);
+        // Straight from the lanes, as arrays: `transform.rotation` would build a view over them on
+        // every call, and seven writeFloat64 calls box their numbers wherever V8 leaves them out of line.
+        buffer.writeFloat64Array(transform, TRANSFORM64_TRANSLATION_OFFSET, 3);
+        buffer.writeFloat64Array(transform, TRANSFORM64_ROTATION_OFFSET, 4);
     }
 
     /**
@@ -45,22 +45,17 @@ export class TransformPoseSerializationAdapter extends BinaryClassSerializationA
      * @param {Transform64} transform
      */
     deserialize(buffer, transform) {
-        const px = buffer.readFloat64();
-        const py = buffer.readFloat64();
-        const pz = buffer.readFloat64();
-        const rx = buffer.readFloat64();
-        const ry = buffer.readFloat64();
-        const rz = buffer.readFloat64();
-        const rw = buffer.readFloat64();
-        transform.setTranslation(px, py, pz);
-        transform.setRotation(rx, ry, rz, rw);
+        // Straight into the lanes. Read into locals and handed to setTranslation / setRotation, the
+        // seven numbers were each boxed into a heap object wherever V8 did not inline the setter.
+        buffer.readFloat64Array(transform, TRANSFORM64_TRANSLATION_OFFSET, 3);
+        buffer.readFloat64Array(transform, TRANSFORM64_ROTATION_OFFSET, 4);
 
         /**
-         * `setRotation` does not touch the matrix — it says so — and the matrix is what render
-         * placement, culling and attachments read. Without this the rotation half of every
-         * interpolated pose was written into slots nothing looks at, and the object rendered at
-         * whatever pose was last composed. The translation half escaped only because the translation
-         * *is* the matrix's fourth column.
+         * Writing the rotation does not touch the matrix — `setRotation` says so — and the matrix
+         * is what render placement, culling and attachments read. Without this the rotation half of
+         * every interpolated pose was written into slots nothing looks at, and the object rendered
+         * at whatever pose was last composed. The translation half escaped only because the
+         * translation *is* the matrix's fourth column.
          */
         transform.updateMatrix();
     }

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

@@ -8,7 +8,7 @@
  */
 export class QuaternionInterpolationAdapter extends BinaryInterpolationAdapter {
     /** @inheritdoc */
-    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, t: any): void;
+    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, blend: any, blend_offset: any): void;
 }
 import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolationAdapter.js";
 //# sourceMappingURL=QuaternionInterpolationAdapter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"QuaternionInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/QuaternionInterpolationAdapter.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH;IAEI,kBAAkB;IAClB,+FAmBC;CACJ;2CAzC0C,mDAAmD"}
+{"version":3,"file":"QuaternionInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/QuaternionInterpolationAdapter.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH;IAEI,kBAAkB;IAClB,sHAqBC;CACJ;2CA3C0C,mDAAmD"}

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

@@ -20,7 +20,9 @@ const scratch = new Float64Array(4);
 export class QuaternionInterpolationAdapter extends BinaryInterpolationAdapter {
 
     /** @inheritdoc */
-    interpolate(out_buffer, source, first_offset, second_offset, t) {
+    interpolate(out_buffer, source, first_offset, second_offset, blend, blend_offset) {
+        const t = blend[blend_offset];
+
         source.position = first_offset;
         const ax = source.readFloat32();
         const ay = source.readFloat32();

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

@@ -12,7 +12,7 @@
  */
 export class TransformInterpolationAdapter extends BinaryInterpolationAdapter {
     /** @inheritdoc */
-    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, t: any): void;
+    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, blend: any, blend_offset: any): void;
 }
 import { BinaryInterpolationAdapter } from "../../interpolation/BinaryInterpolationAdapter.js";
 //# sourceMappingURL=TransformInterpolationAdapter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TransformInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformInterpolationAdapter.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;GAWG;AACH;IAEI,kBAAkB;IAClB,+FA6CC;CACJ;2CA9E0C,mDAAmD"}
+{"version":3,"file":"TransformInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/TransformInterpolationAdapter.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;GAWG;AACH;IAEI,kBAAkB;IAClB,sHA+CC;CACJ;2CAhF0C,mDAAmD"}

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

@@ -35,7 +35,9 @@ const rotation_scratch = new Float64Array(4);
 export class TransformInterpolationAdapter extends BinaryInterpolationAdapter {
 
     /** @inheritdoc */
-    interpolate(out_buffer, source, first_offset, second_offset, t) {
+    interpolate(out_buffer, source, first_offset, second_offset, blend, blend_offset) {
+        const t = blend[blend_offset];
+
         // ---- Decode sample A ----
         source.position = first_offset;
         const ax = source.readFloat32();

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

@@ -1 +1 @@
-{"version":3,"file":"Vector3InterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/Vector3InterpolationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH;CA4BC;2CA5C0C,mDAAmD"}
+{"version":3,"file":"Vector3InterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/adapters/Vector3InterpolationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH;CA+BC;2CA/C0C,mDAAmD"}

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

@@ -22,9 +22,12 @@ export class Vector3InterpolationAdapter extends BinaryInterpolationAdapter {
      * @param {BinaryBuffer} source
      * @param {number} first_offset
      * @param {number} second_offset
-     * @param {number} t
+     * @param {Float64Array} blend holds the blend fraction
+     * @param {number} blend_offset index of the fraction in `blend`
      */
-    interpolate(out_buffer, source, first_offset, second_offset, t) {
+    interpolate(out_buffer, source, first_offset, second_offset, blend, blend_offset) {
+        const t = blend[blend_offset];
+
         source.position = first_offset;
         const ax = source.readFloat32();
         const ay = source.readFloat32();

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":"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;IAWI,uCA0BC;IApCD,eAAe;IACf,yBAAqB;IAErB;;;;OAIG;IACH,cAAU;IAKN;;;OAGG;IACH,MAFU,YAAY,CAEwB;IAE9C;;;;;OAKG;IACH,gBAAkC;IAElC;;;;OAIG;IACH,mBAAsC;IAEtC,eAAe;IACf,mBAAqB;IAGzB;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,WAFW,MAAM,QAiBhB;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,+CA8DhB;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;IAWI,uCA0BC;IApCD,eAAe;IACf,yBAAqB;IAErB;;;;OAIG;IACH,cAAU;IAKN;;;OAGG;IACH,MAFU,YAAY,CAEwB;IAE9C;;;;;OAKG;IACH,gBAAkC;IAElC;;;;OAIG;IACH,mBAAsC;IAEtC,eAAe;IACf,mBAAqB;IAGzB;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,WAFW,MAAM,QAiBhB;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,+CA6DhB;IAED;;;;;;;OAOG;IACH,gBAFW,WAAW,QAoBrB;IAED;;;OAGG;IACH,eAeC;CACJ"}

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

@@ -202,11 +202,10 @@ export class SolverBodyState {
             d[base + SBS_INV_I_Z] = 0;
         }
 
-        const q = transform.rotation;
-        d[base + SBS_QX] = q[0];
-        d[base + SBS_QY] = q[1];
-        d[base + SBS_QZ] = q[2];
-        d[base + SBS_QW] = q[3];
+        d[base + SBS_QX] = transform.rotation_x;
+        d[base + SBS_QY] = transform.rotation_y;
+        d[base + SBS_QZ] = transform.rotation_z;
+        d[base + SBS_QW] = transform.rotation_w;
 
         const lv = rb.linearVelocity;
         d[base + SBS_LV_X] = lv[0];

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts

@@ -23,6 +23,18 @@ export function compute_world_aabb(result: number[] | Float32Array | Float64Arra
  * @param {number} dt step size
  */
 export function fatten_world_aabb(aabb: number[] | Float32Array | Float64Array, offset: number, vx: number, vy: number, vz: number, dt: number): void;
+/**
+ * {@link fatten_world_aabb} with the velocity read from `velocity[velocity_offset ..+2]`: the one place
+ * the arithmetic lives. For the per-collider refit, which cannot have the call inlined, and where the
+ * three numbers would each be boxed into a new heap object.
+ *
+ * @param {number[]|Float32Array|Float64Array} aabb inflated in place
+ * @param {number} offset
+ * @param {number[]|Float32Array|Float64Array} velocity world linear velocity
+ * @param {number} velocity_offset
+ * @param {number} dt step size
+ */
+export function fatten_world_aabb_array(aabb: number[] | Float32Array | Float64Array, offset: number, velocity: number[] | Float32Array | Float64Array, velocity_offset: number, dt: number): void;
 /**
  * Compute the inflated world AABB of a shape under a pose, padded by a
  * symmetric constant slack and a directional velocity-proportional swept

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_fat_world_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/compute_fat_world_aabb.js"],"names":[],"mappings":"AAuBA;;;;;;;;GAQG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,wDAiBhB;AAED;;;;;;;;;;;;;GAaG;AACH,wCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAchB;AAED;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,sDAGN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAShB"}
+{"version":3,"file":"compute_fat_world_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/compute_fat_world_aabb.js"],"names":[],"mappings":"AAuBA;;;;;;;;GAQG;AACH,2CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,wDAchB;AAED;;;;;;;;;;;;;GAaG;AACH,wCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAUhB;AAKD;;;;;;;;;;GAUG;AACH,8CANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,MACN,MAAM,QAkBhB;AAED;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,sDAGN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAShB"}

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

@@ -33,9 +33,6 @@ const FAT_VELOCITY_MULTIPLIER = 2;
 export function compute_world_aabb(result, result_offset, shape, transform) {
     shape.compute_bounding_box(scratch_local);
 
-    const p = transform.translation;
-    const q = transform.rotation;
-
     aabb3_transform_oriented(
         result, result_offset,
         scratch_local[0], scratch_local[1], scratch_local[2],
@@ -60,6 +57,34 @@ export function compute_world_aabb(result, result_offset, shape, transform) {
  * @param {number} dt step size
  */
 export function fatten_world_aabb(aabb, offset, vx, vy, vz, dt) {
+    const velocity = scratch_velocity;
+
+    velocity[0] = vx;
+    velocity[1] = vy;
+    velocity[2] = vz;
+
+    fatten_world_aabb_array(aabb, offset, velocity, 0, dt);
+}
+
+/** Where {@link fatten_world_aabb} packs its velocity. */
+const scratch_velocity = new Float64Array(3);
+
+/**
+ * {@link fatten_world_aabb} with the velocity read from `velocity[velocity_offset ..+2]`: the one place
+ * the arithmetic lives. For the per-collider refit, which cannot have the call inlined, and where the
+ * three numbers would each be boxed into a new heap object.
+ *
+ * @param {number[]|Float32Array|Float64Array} aabb inflated in place
+ * @param {number} offset
+ * @param {number[]|Float32Array|Float64Array} velocity world linear velocity
+ * @param {number} velocity_offset
+ * @param {number} dt step size
+ */
+export function fatten_world_aabb_array(aabb, offset, velocity, velocity_offset, dt) {
+    const vx = velocity[velocity_offset];
+    const vy = velocity[velocity_offset + 1];
+    const vz = velocity[velocity_offset + 2];
+
     const k = FAT_VELOCITY_MULTIPLIER * dt;
     const px = vx * k;
     const py = vy * k;