@woosh/meep-engine 3.14.6 → 3.16.0

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

@@ -46,13 +46,13 @@ export function find_non_finite_physics_state(system) {
             return `body[${idx}].angularVelocity = (${av[0]}, ${av[1]}, ${av[2]})`;
         }
 
-        const p = tr.position;
-        if (!Number.isFinite(p.x + p.y + p.z)) {
-            return `body[${idx}].position = (${p.x}, ${p.y}, ${p.z})`;
+        const px = tr.translation_x, py = tr.translation_y, pz = tr.translation_z;
+        if (!Number.isFinite(px + py + pz)) {
+            return `body[${idx}].position = (${px}, ${py}, ${pz})`;
         }
-        const q = tr.rotation;
-        if (!Number.isFinite(q.x + q.y + q.z + q.w)) {
-            return `body[${idx}].rotation = (${q.x}, ${q.y}, ${q.z}, ${q.w})`;
+        const qx = tr.rotation_x, qy = tr.rotation_y, qz = tr.rotation_z, qw = tr.rotation_w;
+        if (!Number.isFinite(qx + qy + qz + qw)) {
+            return `body[${idx}].rotation = (${qx}, ${qy}, ${qz}, ${qw})`;
         }
     }
 

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -4,7 +4,7 @@
  * conditions.
  *
  * Every fixed update, each entity carrying ({@link FluidObstacle},
- * {@link Collider}, {@link RigidBody}, {@link Transform}) — the same tuple
+ * {@link Collider}, {@link RigidBody}, {@link Transform64}) — the same tuple
  * {@link PhysicsSystem} simulates, plus the marker — is swept against every
  * {@link FluidComponent}: the collider's shape — posed rigidly at the
  * transform's position/rotation via {@link PosedShape3D} — is sampled at the
@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#372@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#377@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#372@#clear_field"(fluid: FluidComponent): void;
+    static "__#377@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#372@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#377@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,15 +100,15 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#372@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#377@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
-    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];
     #private;
 }
 import { System } from "../../../ecs/System.js";
 import { FluidObstacle } from "./FluidObstacle.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { RigidBody } from "../../ecs/RigidBody.js";
 import { Collider } from "../../ecs/Collider.js";

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidObstacleSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidObstacleSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH;IA+GI;;OAEG;IACH,sCAFW,cAAc,QAIxB;IAED;;OAEG;IACH,oCAFW,cAAc,QAOxB;IAED;;;;;;;;;;OAUG;IACH,iCANW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,QAiDtB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,4CATW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,OACZ,MAAM,OACN,MAAM,OACN,MAAM,QAqEhB;;IAhRD,uCAA+B;IAE/B,2QAOE;;CAwQL;uBAxVsB,wBAAwB;8BAKjB,oBAAoB;0BAJxB,qCAAqC;4CAFnB,uDAAuD;0BAIzE,wBAAwB;yBADzB,uBAAuB;+BAEjB,qBAAqB;6BAPvB,gDAAgD"}
+{"version":3,"file":"FluidObstacleSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidObstacleSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH;IAuHI;;OAEG;IACH,sCAFW,cAAc,QAIxB;IAED;;OAEG;IACH,oCAFW,cAAc,QAOxB;IAED;;;;;;;;;;OAUG;IACH,iCANW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,QAiDtB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,4CATW,cAAc,SACd,YAAY,QACZ,YAAY,aACZ,MAAM,SACN,YAAY,OACZ,MAAM,OACN,MAAM,OACN,MAAM,QAqEhB;;IAxRD,uCAA+B;IAE/B,6QAOE;;CAgRL;uBAhWsB,wBAAwB;8BAKjB,oBAAoB;4BAJtB,uCAAuC;4CAFvB,uDAAuD;0BAIzE,wBAAwB;yBADzB,uBAAuB;+BAEjB,qBAAqB;6BAPvB,gDAAgD"}

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.js

@@ -2,7 +2,7 @@ import { PosedShape3D } from "../../../../core/geom/3d/shape/PosedShape3D.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 "../../ecs/Collider.js";
 import { RigidBody } from "../../ecs/RigidBody.js";
 import { FluidComponent } from "./FluidComponent.js";
@@ -14,7 +14,7 @@ import { FluidObstacle } from "./FluidObstacle.js";
  * conditions.
  *
  * Every fixed update, each entity carrying ({@link FluidObstacle},
- * {@link Collider}, {@link RigidBody}, {@link Transform}) — the same tuple
+ * {@link Collider}, {@link RigidBody}, {@link Transform64}) — the same tuple
  * {@link PhysicsSystem} simulates, plus the marker — is swept against every
  * {@link FluidComponent}: the collider's shape — posed rigidly at the
  * transform's position/rotation via {@link PosedShape3D} — is sampled at the
@@ -78,7 +78,7 @@ export class FluidObstacleSystem extends System {
         ResourceAccessSpecification.from(FluidObstacle, ResourceAccessKind.Read),
         ResourceAccessSpecification.from(Collider, ResourceAccessKind.Read),
         ResourceAccessSpecification.from(RigidBody, ResourceAccessKind.Read),
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read),
         // Solid masks are rewritten each tick.
         ResourceAccessSpecification.from(FluidComponent, ResourceAccessKind.Read | ResourceAccessKind.Write),
     ];
@@ -117,7 +117,7 @@ export class FluidObstacleSystem extends System {
         // With no obstacles the system must not touch any mask — fields with
         // hand-authored solids keep them.
         let obstacle_count = 0;
-        ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform], function () {
+        ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform64], function () {
             obstacle_count++;
         });
         if (obstacle_count === 0) {
@@ -133,8 +133,12 @@ export class FluidObstacleSystem extends System {
         const aabb = this.#aabb;
         const point = this.#point;
 
-        ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform], function (obstacle, collider, body, transform) {
-            posed.setup(collider.shape, transform.position, transform.rotation);
+        ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform64], function (obstacle, collider, body, transform) {
+            posed.setup_components(
+        collider.shape,
+        transform.translation_x, transform.translation_y, transform.translation_z,
+        transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w
+    );
             posed.compute_bounding_box(aabb);
 
             ecd.traverseComponents(FluidComponent, function (fluid) {
@@ -154,7 +158,7 @@ export class FluidObstacleSystem extends System {
         // The divergence reads these values, so the wall genuinely pushes
         // (and pulls) the surrounding fluid. The source is the solver's own
         // linearVelocity, NOT a pose delta — teleports stamp nothing.
-        ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform], function (obstacle, collider, body, transform) {
+        ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform64], function (obstacle, collider, body, transform) {
             const lv = body.linearVelocity;
             const vx = lv.x;
             const vy = lv.y;
@@ -169,7 +173,11 @@ export class FluidObstacleSystem extends System {
             // BC with zeros or the projection keeps seeing phantom inflow.
             // Bodies that never move never pay for this pass.
             if (moving || obstacle._was_moving) {
-                posed.setup(collider.shape, transform.position, transform.rotation);
+                posed.setup_components(
+        collider.shape,
+        transform.translation_x, transform.translation_y, transform.translation_z,
+        transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w
+    );
                 posed.compute_bounding_box(aabb);
                 ecd.traverseComponents(FluidComponent, function (fluid) {
                     FluidObstacleSystem.#stamp_wall_velocity(

package/src/engine/physics/fluid/ecs/FluidSystem.d.ts

@@ -4,14 +4,14 @@
  * Effectors live on a separate {@link FluidEffectorsComponent}, decoupled from any
  * specific fluid field. Each step the system:
  *
- *   1. **Re-anchor moving fields.** For every (FluidComponent, Transform) tuple,
+ *   1. **Re-anchor moving fields.** For every (FluidComponent, Transform64) tuple,
  *      compute the desired grid origin as
  *          `quantize(transform.position, cell_size) + offset`
  *      where the grid is then centred at that point. On the first sync this is just
  *      snapped (no shift), on subsequent syncs the integer cell delta is computed and
  *      the field is shifted to follow — fluid data moves with the world so the volume
  *      appears stationary while the grid hops between cells.
- *   2. Walks every (FluidEffectorsComponent, Transform) entity and calls
+ *   2. Walks every (FluidEffectorsComponent, Transform64) entity and calls
  *      {@link AbstractFluidEffector.syncFromTransform} on each effector so position-
  *      bearing effectors (wakes, splats) follow their owning entity.
  *   3. For each enabled {@link FluidComponent}:
@@ -43,7 +43,7 @@ export class FluidSystem extends System<any> {
      *   - `Transform` — read every step (paired with FluidEffectorsComponent) so
      *     position-bearing effectors can follow their entity.
      */
-    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidEffectorsComponent>)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidEffectorsComponent>)[];
     /**
      * Single simulator drives every fluid field — it carries only transient scratch,
      * which {@link FluidSimulator.#ensure_scratch} grows to fit the largest field
@@ -55,7 +55,7 @@ export class FluidSystem extends System<any> {
 }
 import { System } from "../../../ecs/System.js";
 import { FluidComponent } from "./FluidComponent.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { FluidEffectorsComponent } from "./FluidEffectorsComponent.js";
 import { FluidSimulator } from "../FluidSimulator.js";

package/src/engine/physics/fluid/ecs/FluidSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidSystem.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;;IAEI,wCAAgC;IAEhC;;;;;;;;OAQG;IACH,sLAME;IAEF;;;;;OAKG;IACH,WAFU,cAAc,CAES;;CAoEpC;uBA1IsB,wBAAwB;+BAEhB,qBAAqB;0BAD1B,qCAAqC;4CAFnB,uDAAuD;wCAI3D,8BAA8B;+BACvC,sBAAsB"}
+{"version":3,"file":"FluidSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/FluidSystem.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;;IAEI,wCAAgC;IAEhC;;;;;;;;OAQG;IACH,wLAME;IAEF;;;;;OAKG;IACH,WAFU,cAAc,CAES;;CAoEpC;uBA1IsB,wBAAwB;+BAEhB,qBAAqB;4BADxB,uCAAuC;4CAFvB,uDAAuD;wCAI3D,8BAA8B;+BACvC,sBAAsB"}

package/src/engine/physics/fluid/ecs/FluidSystem.js

@@ -2,7 +2,7 @@ import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.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 { FluidComponent } from "./FluidComponent.js";
 import { FluidEffectorsComponent } from "./FluidEffectorsComponent.js";
 import { FluidSimulator } from "../FluidSimulator.js";
@@ -17,14 +17,14 @@ import { fluid_sync_effectors_from_transform } from "./fluid_sync_effectors_from
  * Effectors live on a separate {@link FluidEffectorsComponent}, decoupled from any
  * specific fluid field. Each step the system:
  *
- *   1. **Re-anchor moving fields.** For every (FluidComponent, Transform) tuple,
+ *   1. **Re-anchor moving fields.** For every (FluidComponent, Transform64) tuple,
  *      compute the desired grid origin as
  *          `quantize(transform.position, cell_size) + offset`
  *      where the grid is then centred at that point. On the first sync this is just
  *      snapped (no shift), on subsequent syncs the integer cell delta is computed and
  *      the field is shifted to follow — fluid data moves with the world so the volume
  *      appears stationary while the grid hops between cells.
- *   2. Walks every (FluidEffectorsComponent, Transform) entity and calls
+ *   2. Walks every (FluidEffectorsComponent, Transform64) entity and calls
  *      {@link AbstractFluidEffector.syncFromTransform} on each effector so position-
  *      bearing effectors (wakes, splats) follow their owning entity.
  *   3. For each enabled {@link FluidComponent}:
@@ -62,7 +62,7 @@ export class FluidSystem extends System {
         // (origin, anchored, field buffers). Declared again with explicit Write.
         ResourceAccessSpecification.from(FluidComponent, ResourceAccessKind.Read | ResourceAccessKind.Write),
         ResourceAccessSpecification.from(FluidEffectorsComponent, ResourceAccessKind.Read),
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read),
     ];
 
     /**
@@ -114,10 +114,10 @@ export class FluidSystem extends System {
 
         // 1. Re-anchor moving fields. Field origin tracks quantize(transform) + offset;
         //    when the quantization changes, the field is shifted to follow the world.
-        ecd.traverseEntities([FluidComponent, Transform], fluid_reanchor_field);
+        ecd.traverseEntities([FluidComponent, Transform64], fluid_reanchor_field);
 
         // 2. Sync every effector that wants to follow its entity's Transform.
-        ecd.traverseEntities([FluidEffectorsComponent, Transform], fluid_sync_effectors_from_transform);
+        ecd.traverseEntities([FluidEffectorsComponent, Transform64], fluid_sync_effectors_from_transform);
 
         // 2. Step each fluid field, with broad-phase effector filtering per field.
         const sim = this.simulator;

package/src/engine/physics/fluid/ecs/WorkerFluidSystem.d.ts

@@ -84,7 +84,7 @@ export class WorkerFluidSystem extends WorkerSystem {
         max_field_count?: number;
     });
     dependencies: (typeof FluidComponent)[];
-    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidEffectorsComponent>)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidEffectorsComponent>)[];
     /**
      * Tuning knobs, mirrored to the worker in full on every dispatch. Its
      * scratch buffers are never used on this side — the solve happens over
@@ -112,7 +112,7 @@ export class WorkerFluidSystem extends WorkerSystem {
 }
 import { WorkerSystem } from "../../../ecs/async/WorkerSystem.js";
 import { FluidComponent } from "./FluidComponent.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { FluidEffectorsComponent } from "./FluidEffectorsComponent.js";
 import { FluidSimulator } from "../FluidSimulator.js";

package/src/engine/physics/fluid/ecs/WorkerFluidSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WorkerFluidSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/WorkerFluidSystem.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IA0EI;;;;;;;;OAQG;IACH;QAPiC,cAAc,EAApC,MAAM,MAAM;QAIK,eAAe,GAAhC,MAAM;OAUhB;IAxFD,wCAAgC;IAEhC,sLAME;IAEF;;;;;;OAMG;IACH,WAFU,cAAc,CAES;IAyEjC;;;OAGG;IACH,iCAEC;IAgBD;;;OAGG;IACH,gBAHW,cAAc,UACd,MAAM,QA0BhB;IAED;;;OAGG;IACH,kBAHW,cAAc,UACd,MAAM,QAqBhB;;CAmIJ;6BAvY4B,oCAAoC;+BAGlC,qBAAqB;0BAF1B,qCAAqC;4CAFnB,uDAAuD;wCAK3D,8BAA8B;+BAFvC,sBAAsB"}
+{"version":3,"file":"WorkerFluidSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/WorkerFluidSystem.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IA0EI;;;;;;;;OAQG;IACH;QAPiC,cAAc,EAApC,MAAM,MAAM;QAIK,eAAe,GAAhC,MAAM;OAUhB;IAxFD,wCAAgC;IAEhC,wLAME;IAEF;;;;;;OAMG;IACH,WAFU,cAAc,CAES;IAyEjC;;;OAGG;IACH,iCAEC;IAgBD;;;OAGG;IACH,gBAHW,cAAc,UACd,MAAM,QA0BhB;IAED;;;OAGG;IACH,kBAHW,cAAc,UACd,MAAM,QAqBhB;;CAmIJ;6BAvY4B,oCAAoC;+BAGlC,qBAAqB;4BAFxB,uCAAuC;4CAFvB,uDAAuD;wCAK3D,8BAA8B;+BAFvC,sBAAsB"}

package/src/engine/physics/fluid/ecs/WorkerFluidSystem.js

@@ -2,7 +2,7 @@ import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { WorkerSystem } from "../../../ecs/async/WorkerSystem.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { FluidSimulator } from "../FluidSimulator.js";
 import { FluidComponent } from "./FluidComponent.js";
 import { FluidEffectorsComponent } from "./FluidEffectorsComponent.js";
@@ -103,7 +103,7 @@ export class WorkerFluidSystem extends WorkerSystem {
         // anchored, buffers).
         ResourceAccessSpecification.from(FluidComponent, ResourceAccessKind.Read | ResourceAccessKind.Write),
         ResourceAccessSpecification.from(FluidEffectorsComponent, ResourceAccessKind.Read),
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read),
     ];
 
     /**
@@ -285,10 +285,10 @@ export class WorkerFluidSystem extends WorkerSystem {
         // 1. Re-anchor moving fields, exactly as FluidSystem does — including
         //    fields still awaiting acknowledgement, so their placement is
         //    already correct by the time they start stepping.
-        ecd.traverseEntities([FluidComponent, Transform], fluid_reanchor_field);
+        ecd.traverseEntities([FluidComponent, Transform64], fluid_reanchor_field);
 
         // 2. Sync every effector that wants to follow its entity's Transform.
-        ecd.traverseEntities([FluidEffectorsComponent, Transform], fluid_sync_effectors_from_transform);
+        ecd.traverseEntities([FluidEffectorsComponent, Transform64], fluid_sync_effectors_from_transform);
 
         // 3. Apply effectors per field, and nominate the field for stepping.
         //    This is phase 1 of FluidSimulator.step; the worker runs the rest.

package/src/engine/physics/fluid/ecs/fluid_reanchor_field.js

@@ -26,7 +26,7 @@
  */
 export function fluid_reanchor_field(component, transform) {
     const cs = component.cell_size;
-    const p = transform.position;
+    const p = transform.translation;
     const offset = component.offset;
     const hyst = component.hysteresis;
 
@@ -40,9 +40,9 @@ export function fluid_reanchor_field(component, transform) {
     if (!component.anchored) {
         // First sync — adopt the freshly-quantized origin without shifting.
         // Subsequent frames will see integer-cs differences and shift instead.
-        const q_x = Math.round(p.x / cs);
-        const q_y = Math.round(p.y / cs);
-        const q_z = Math.round(p.z / cs);
+        const q_x = Math.round(p[0] / cs);
+        const q_y = Math.round(p[1] / cs);
+        const q_z = Math.round(p[2] / cs);
         origin[0] = q_x * cs + offset[0] - half_extent_x;
         origin[1] = q_y * cs + offset[1] - half_extent_y;
         origin[2] = q_z * cs + offset[2] - half_extent_z;
@@ -59,9 +59,9 @@ export function fluid_reanchor_field(component, transform) {
     const q_curr_z = Math.round((origin[2] + half_extent_z - offset[2]) / cs);
 
     // Raw (fractional) cell coordinate the Transform sits at right now.
-    const raw_x = p.x / cs;
-    const raw_y = p.y / cs;
-    const raw_z = p.z / cs;
+    const raw_x = p[0] / cs;
+    const raw_y = p[1] / cs;
+    const raw_z = p[2] / cs;
 
     // Hysteretic re-quantize: only adopt a new cell when raw has drifted past
     // 0.5 + hyst from the current one. Snap to the new nearest, not the threshold.

package/src/engine/physics/fluid/effector/ImpulseFluidEffector.js

@@ -196,10 +196,10 @@ export class ImpulseFluidEffector extends AbstractFluidEffector {
      * @param {Transform} transform
      */
     syncFromTransform(transform) {
-        const p = transform.position;
-        this.position[0] = p.x;
-        this.position[1] = p.y;
-        this.position[2] = p.z;
+        const p = transform.translation;
+        this.position[0] = p[0];
+        this.position[1] = p[1];
+        this.position[2] = p[2];
     }
 
     /**

package/src/engine/physics/fluid/effector/WakeFluidEffector.js

@@ -132,20 +132,20 @@ export class WakeFluidEffector extends AbstractFluidEffector {
      * @param {Transform} transform
      */
     syncFromTransform(transform) {
-        const p = transform.position;
+        const p = transform.translation;
         this.#transform_managed = true;
         if (this.#initialized) {
             this.previous_position[0] = this.position[0];
             this.previous_position[1] = this.position[1];
             this.previous_position[2] = this.position[2];
         }
-        this.position[0] = p.x;
-        this.position[1] = p.y;
-        this.position[2] = p.z;
+        this.position[0] = p[0];
+        this.position[1] = p[1];
+        this.position[2] = p[2];
         if (!this.#initialized) {
-            this.previous_position[0] = p.x;
-            this.previous_position[1] = p.y;
-            this.previous_position[2] = p.z;
+            this.previous_position[0] = p[0];
+            this.previous_position[1] = p[1];
+            this.previous_position[2] = p[2];
             this.#initialized = true;
         }
     }

package/src/engine/physics/inertia/world_inverse_inertia.js

@@ -44,7 +44,7 @@ export function world_inverse_inertia_apply(
     world_inverse_inertia_apply_raw(
         result, result_offset,
         inv_inertia_local.x, inv_inertia_local.y, inv_inertia_local.z,
-        rotation.x, rotation.y, rotation.z, rotation.w,
+        rotation[0], rotation[1], rotation[2], rotation[3],
         vx, vy, vz
     );
 }

package/src/engine/physics/integration/integrate_position.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integrate_position.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/integrate_position.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,uCAZW,YAAY,QACZ,MAAM,2CAGN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,QA8ChB"}
+{"version":3,"file":"integrate_position.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/integrate_position.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,uCAZW,YAAY,QACZ,MAAM,2CAGN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,QA+ChB"}

package/src/engine/physics/integration/integrate_position.js

@@ -59,35 +59,36 @@ export function integrate_position(
         return;
     }
 
-    const p = transform.position;
-
     // Combined integration velocity: persistent + pseudo. The pseudo
     // contribution exists only for this step and never lands in the velocity.
     const vx = ss[base + SBS_LV_X] + ps_lin_x;
     const vy = ss[base + SBS_LV_Y] + ps_lin_y;
     const vz = ss[base + SBS_LV_Z] + ps_lin_z;
 
-    // The write goes through .set() so Transform's onChanged subscribers
-    // (matrix recompose, parent/child sync, viewport position, fog-of-war
-    // reveal) fire — pose stays authoritative on the Transform.
-    p.set(
-        p[0] + vx * dt,
-        p[1] + vy * dt,
-        p[2] + vz * dt
+    // The translation IS the matrix translation column, so this write lands in the matrix as it is
+    // made and owes no updateMatrix. Announcing the move is the caller’s job: it happens once per
+    // body per step rather than once per substep write, which is fewer wake-ups than the onChanged
+    // signals this replaces delivered.
+    transform.setTranslation(
+        transform.translation_x + vx * dt,
+        transform.translation_y + vy * dt,
+        transform.translation_z + vz * dt
     );
 
     const wx = ss[base + SBS_AV_X] + ps_ang_x;
     const wy = ss[base + SBS_AV_Y] + ps_ang_y;
     const wz = ss[base + SBS_AV_Z] + ps_ang_z;
     if (wx !== 0 || wy !== 0 || wz !== 0) {
-        const q = transform.rotation;
         quat3_integrate(
             scratch_q,
-            q[0], q[1], q[2], q[3],
+            transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w,
             wx, wy, wz,
             dt
         );
-        q.set(scratch_q[0], scratch_q[1], scratch_q[2], scratch_q[3]);
+        transform.setRotation(scratch_q[0], scratch_q[1], scratch_q[2], scratch_q[3]);
+
+        // the orientation moved, so the matrix is now behind the components
+        transform.updateMatrix();
         // Mirror the moved orientation into the solver state.
         ss[base + SBS_QX] = scratch_q[0];
         ss[base + SBS_QY] = scratch_q[1];

package/src/engine/physics/inverse_kinematics/fabrik/fabrik_solve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fabrik_solve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/inverse_kinematics/fabrik/fabrik_solve.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AACH,qCAPW,WAAW,WACX,MAAM,EAAE,UACR,OAAO,UACP,OAAO,mBACP,MAAM,uBACN,MAAM,QAgFhB;oBAlGmB,kCAAkC"}
+{"version":3,"file":"fabrik_solve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/inverse_kinematics/fabrik/fabrik_solve.js"],"names":[],"mappings":"AAaA;;;;;;;;;GASG;AACH,qCAPW,WAAW,WACX,MAAM,EAAE,UACR,OAAO,UACP,OAAO,mBACP,MAAM,uBACN,MAAM,QAgGhB;oBApHmB,kCAAkC"}

package/src/engine/physics/inverse_kinematics/fabrik/fabrik_solve.js

@@ -2,6 +2,8 @@ import Quaternion from "../../../../core/geom/Quaternion.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { fabrik3d_solve_primitive } from "./fabrik3d_solve_primitive.js";
 
+const scratch_joint_rotation = new Quaternion();
+
 const scratch_positions_count = 64;
 const scratch_positions = new Float32Array(scratch_positions_count * 3);
 
@@ -41,7 +43,9 @@ export function fabrik_solve(
         const offset = i * 3;
         const joint = joints[i];
 
-        joint.position.toArray(positions, offset);
+        positions[offset] = joint.translation_x;
+        positions[offset + 1] = joint.translation_y;
+        positions[offset + 2] = joint.translation_z;
     }
 
     fabrik3d_solve_primitive(
@@ -68,8 +72,11 @@ export function fabrik_solve(
         const current_y = positions[i3 + 1];
         const current_z = positions[i3 + 2];
 
-        scratch_v3_0.copy(current_joint.position);
-        scratch_v3_0.sub(previous_joint.position);
+        scratch_v3_0.set(
+            current_joint.translation_x - previous_joint.translation_x,
+            current_joint.translation_y - previous_joint.translation_y,
+            current_joint.translation_z - previous_joint.translation_z
+        );
 
         if (scratch_v3_0.lengthSqr() === 0) {
             continue;
@@ -90,12 +97,23 @@ export function fabrik_solve(
 
         scratch_quat.fromUnitVectors(scratch_v3_0, scratch_v3_1);
 
-        previous_joint.rotation.multiplyQuaternions(scratch_quat, previous_joint.rotation);
+        scratch_joint_rotation.set(
+            previous_joint.rotation_x, previous_joint.rotation_y,
+            previous_joint.rotation_z, previous_joint.rotation_w
+        );
+        scratch_joint_rotation.multiplyQuaternions(scratch_quat, scratch_joint_rotation);
+
+        previous_joint.setRotation(
+            scratch_joint_rotation.x, scratch_joint_rotation.y,
+            scratch_joint_rotation.z, scratch_joint_rotation.w
+        );
+
+        previous_joint.updateMatrix();
     }
 
     // apply positions
     for (let i = 0; i < joint_count; i++) {
-        joints[i].position.fromArray(positions, i * 3);
+        joints[i].setTranslation(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]);
     }
 }
 

package/src/engine/physics/narrowphase/compute_penetration.js

@@ -210,16 +210,16 @@ function concave_recovery_penetration(
         world_aabb, 0,
         local_aabb[0], local_aabb[1], local_aabb[2],
         local_aabb[3], local_aabb[4], local_aabb[5],
-        convex_pos.x, convex_pos.y, convex_pos.z,
-        convex_rot.x, convex_rot.y, convex_rot.z, convex_rot.w
+        convex_pos[0], convex_pos[1], convex_pos[2],
+        convex_rot[0], convex_rot[1], convex_rot[2], convex_rot[3]
     );
 
     // ── 2. Project into concave's body-local frame ─────────────────
     aabb3_transform_oriented_inverse(
         concave_query_aabb, 0,
         world_aabb,
-        concave_pos.x, concave_pos.y, concave_pos.z,
-        concave_rot.x, concave_rot.y, concave_rot.z, concave_rot.w
+        concave_pos[0], concave_pos[1], concave_pos[2],
+        concave_rot[0], concave_rot[1], concave_rot[2], concave_rot[3]
     );
 
     // ── 3. Decompose to triangles (clamp: TRUE count may exceed the buffer) ─
@@ -232,15 +232,19 @@ function concave_recovery_penetration(
     if (tri_count === 0) return 0;
 
     // ── 4. Setup convex PosedShape3D (we'll call support on it per tri) ─
-    posed_b.setup(convex_shape, convex_pos, convex_rot);
+    posed_b.setup_components(
+        convex_shape,
+        convex_pos[0], convex_pos[1], convex_pos[2],
+        convex_rot[0], convex_rot[1], convex_rot[2], convex_rot[3]
+    );
 
-    const cqx = concave_rot.x;
-    const cqy = concave_rot.y;
-    const cqz = concave_rot.z;
-    const cqw = concave_rot.w;
-    const c_pos_x = concave_pos.x;
-    const c_pos_y = concave_pos.y;
-    const c_pos_z = concave_pos.z;
+    const cqx = concave_rot[0];
+    const cqy = concave_rot[1];
+    const cqz = concave_rot[2];
+    const cqw = concave_rot[3];
+    const c_pos_x = concave_pos[0];
+    const c_pos_y = concave_pos[1];
+    const c_pos_z = concave_pos[2];
 
     // ── 5. Per-triangle half-space test, deepest-wins ──────────────
     let best_depth = 0;
@@ -323,7 +327,7 @@ function concave_recovery_penetration(
         const wcx = scratch_rot[0] + c_pos_x, wcy = scratch_rot[1] + c_pos_y, wcz = scratch_rot[2] + c_pos_z;
         tri3_closest_point_barycentric(
             scratch_bary, 0,
-            convex_pos.x, convex_pos.y, convex_pos.z,
+            convex_pos[0], convex_pos[1], convex_pos[2],
             wax, way, waz,
             wbx, wby, wbz,
             wcx, wcy, wcz
@@ -333,7 +337,7 @@ function concave_recovery_penetration(
         const qx = al * wax + be * wbx + (1 - al - be) * wcx;
         const qy = al * way + be * wby + (1 - al - be) * wcy;
         const qz = al * waz + be * wbz + (1 - al - be) * wcz;
-        const tdx = convex_pos.x - qx, tdy = convex_pos.y - qy, tdz = convex_pos.z - qz;
+        const tdx = convex_pos[0] - qx, tdy = convex_pos[1] - qy, tdz = convex_pos[2] - qz;
         const closest_sqr = tdx * tdx + tdy * tdy + tdz * tdz;
         const plane_d = tdx * fnx_w + tdy * fny_w + tdz * fnz_w;
         const lateral_sqr = closest_sqr - plane_d * plane_d;

package/src/engine/physics/narrowphase/convex_convex_manifold.js

@@ -109,8 +109,8 @@ function set_geom(A, B) {
 
 function load_world(out, verts, n, p, q) {
     for (let i = 0; i < n; i++) {
-        v3_quaternion_apply(out, i * 3, verts[i * 3], verts[i * 3 + 1], verts[i * 3 + 2], q.x, q.y, q.z, q.w);
-        out[i * 3] += p.x; out[i * 3 + 1] += p.y; out[i * 3 + 2] += p.z;
+        v3_quaternion_apply(out, i * 3, verts[i * 3], verts[i * 3 + 1], verts[i * 3 + 2], q[0], q[1], q[2], q[3]);
+        out[i * 3] += p[0]; out[i * 3 + 1] += p[1]; out[i * 3 + 2] += p[2];
     }
 }