@woosh/meep-engine 3.20.0 → 3.21.0

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

@@ -1 +1 @@
-{"version":3,"file":"RigidBodySerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBodySerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH;;IAEI,wBAAkB;IAGlB;;;;OAIG;IACH,uCAFW,SAAS,QA6BnB;IAED;;;;OAIG;IACH,yCAFW,SAAS,QAoCnB;CACJ;gDAlG+C,6DAA6D;0BACnF,gBAAgB"}
+{"version":3,"file":"RigidBodySerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBodySerializationAdapter.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH;;IAEI,wBAAkB;IAGlB;;;;OAIG;IACH,uCAFW,SAAS,QA6BnB;IAED;;;;OAIG;IACH,yCAFW,SAAS,QAoCnB;CACJ;gDAlG+C,6DAA6D;0BACnF,gBAAgB"}

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

@@ -1,3 +1,4 @@
+import { v3_set } from "../../../core/geom/vec3/v3_set.js";
 import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { RigidBody } from "./RigidBody.js";
 
@@ -30,19 +31,19 @@ export class RigidBodySerializationAdapter extends BinaryClassSerializationAdapt
     serialize(buffer, value) {
         buffer.writeUint8(value.kind);
 
-        buffer.writeFloat64(value.linearVelocity.x);
-        buffer.writeFloat64(value.linearVelocity.y);
-        buffer.writeFloat64(value.linearVelocity.z);
+        buffer.writeFloat64(value.linearVelocity[0]);
+        buffer.writeFloat64(value.linearVelocity[1]);
+        buffer.writeFloat64(value.linearVelocity[2]);
 
-        buffer.writeFloat64(value.angularVelocity.x);
-        buffer.writeFloat64(value.angularVelocity.y);
-        buffer.writeFloat64(value.angularVelocity.z);
+        buffer.writeFloat64(value.angularVelocity[0]);
+        buffer.writeFloat64(value.angularVelocity[1]);
+        buffer.writeFloat64(value.angularVelocity[2]);
 
         buffer.writeFloat64(value.mass);
 
-        buffer.writeFloat64(value.inverseInertiaLocal.x);
-        buffer.writeFloat64(value.inverseInertiaLocal.y);
-        buffer.writeFloat64(value.inverseInertiaLocal.z);
+        buffer.writeFloat64(value.inverseInertiaLocal[0]);
+        buffer.writeFloat64(value.inverseInertiaLocal[1]);
+        buffer.writeFloat64(value.inverseInertiaLocal[2]);
 
         buffer.writeFloat64(value.linearDamping);
         buffer.writeFloat64(value.angularDamping);
@@ -67,19 +68,19 @@ export class RigidBodySerializationAdapter extends BinaryClassSerializationAdapt
         const lvx = buffer.readFloat64();
         const lvy = buffer.readFloat64();
         const lvz = buffer.readFloat64();
-        value.linearVelocity.set(lvx, lvy, lvz);
+        v3_set(value.linearVelocity, 0, lvx, lvy, lvz);
 
         const avx = buffer.readFloat64();
         const avy = buffer.readFloat64();
         const avz = buffer.readFloat64();
-        value.angularVelocity.set(avx, avy, avz);
+        v3_set(value.angularVelocity, 0, avx, avy, avz);
 
         value.mass = buffer.readFloat64();
 
         const iix = buffer.readFloat64();
         const iiy = buffer.readFloat64();
         const iiz = buffer.readFloat64();
-        value.inverseInertiaLocal.set(iix, iiy, iiz);
+        v3_set(value.inverseInertiaLocal, 0, iix, iiy, iiz);
 
         value.linearDamping = buffer.readFloat64();
         value.angularDamping = buffer.readFloat64();

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

@@ -11,7 +11,7 @@
  * failing loudly at the source.
  *
  * Coverage:
- *   - every AWAKE body's linear/angular velocity and Transform pose. Sleeping
+ *   - every AWAKE body's linear/angular velocity and Transform64 pose. Sleeping
  *     bodies froze with state this sweep already validated (a non-finite
  *     velocity can never pass the sleep threshold comparison), so awake-only
  *     is exhaustive across steps.

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

@@ -13,7 +13,7 @@ import { CONTACT_STRIDE } from "../contact/ManifoldStore.js";
  * failing loudly at the source.
  *
  * Coverage:
- *   - every AWAKE body's linear/angular velocity and Transform pose. Sleeping
+ *   - every AWAKE body's linear/angular velocity and Transform64 pose. Sleeping
  *     bodies froze with state this sweep already validated (a non-finite
  *     velocity can never pass the sleep threshold comparison), so awake-only
  *     is exhaustive across steps.

package/src/engine/physics/fluid/FluidField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidField.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidField.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"FluidField.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidField.js"],"names":[],"mappings":"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"}

package/src/engine/physics/fluid/REVIEW_02_PLAN.md

@@ -154,10 +154,10 @@ SLOWER in V8 — do not do it.
 ## Phase B — FluidObstacleSystem. DONE.
 
 - `FluidObstacle` component (inflation knob) + `FluidObstacleSystem`:
-  voxelizes each (FluidObstacle, Collider, Transform) entity's shape into
+  voxelizes each (FluidObstacle, Collider, Transform64) entity's shape into
   every overlapping FluidComponent's solid mask per tick, via
   `PosedShape3D.signed_distance_at_point` (new posed point queries on
-  PosedShape3D, spec'd). Rigid pose — Transform.scale ignored, matching the
+  PosedShape3D, spec'd). Rigid pose — Transform64.scale ignored, matching the
   physics collider convention. Cell solid iff sdf(centre) <= inflation;
   iteration clipped to the shape AABB.
 - Ownership contract: with >= 1 obstacle the system clears + rebuilds EVERY
@@ -183,12 +183,12 @@ SLOWER in V8 — do not do it.
     quality 8).
 - `FluidObstacleSystem` second pass: per obstacle, the wall velocity is
   **`RigidBody.linearVelocity`** (world m/s — the obstacle tuple is the full
-  physics tuple FluidObstacle+Collider+RigidBody+Transform); cells it
+  physics tuple FluidObstacle+Collider+RigidBody+Transform64); cells it
   voxelized get all six face slots stamped with the grid-units velocity.
   The system refreshes each field's masks BEFORE stamping so the transition
   zeroing is consumed there and the stamped values stick through the
   simulator's own per-step refresh.
-- **Velocity source rationale** (replaced the initial Transform-delta
+- **Velocity source rationale** (replaced the initial Transform64-delta
   finite difference in the same session): pose differencing turns teleports
   (spawn snaps, network corrections) into one-tick air detonations — the
   exact failure mode BodyKind.KinematicPosition was deferred over in the

package/src/engine/physics/fluid/SliceVisualiser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SliceVisualiser.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/SliceVisualiser.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH;IAqCI,cAKC;IAED;;;;;OAKG;IACH,wBAFiB,iBAAiB,cAAc,MAAM,UAAU,YAAY,iBAAiB,MAAM,KAAK,IAAI,QAI3G;IAED;;;;;;OAMG;IACH,sBAHW,YAAY,EAAE,cACd,MAAM,EAAE,QAsDlB;IAED;;;OAGG;IACH,aA6BC;IAED;;;OAGG;IACH,eAmBC;;CACJ;sBAzLqB,qCAAqC"}
+{"version":3,"file":"SliceVisualiser.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/SliceVisualiser.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH;IAqCI,cAKC;IAED;;;;;OAKG;IACH,kBAFW,CAAC,GAAG,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,KAAK,IAAI,QAI3G;IAED;;;;;;OAMG;IACH,sBAHW,YAAY,EAAE,cACd,MAAM,EAAE,QAsDlB;IAED;;;OAGG;IACH,aA6BC;IAED;;;OAGG;IACH,eAmBC;;CACJ;sBAzLqB,qCAAqC"}

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

@@ -2,17 +2,17 @@
  * ECS component representing a fluid volume — one {@link FluidField} plus its placement
  * in world space.
  *
- * Behaviour (stepping the simulation, dispatching effectors, re-anchoring on Transform
+ * Behaviour (stepping the simulation, dispatching effectors, re-anchoring on Transform64
  * motion) lives on {@link FluidSystem}, not here. This component is pure data.
  *
  * World ↔ grid mapping is uniform and axis-aligned: cell `(0,0,0)`'s center sits at
  * {@link origin}, and cells are spaced {@link cell_size} world-units apart along each
  * axis. For non-uniform or oriented volumes, use multiple components.
  *
- * **Static placement**: leave the entity without a `Transform`. Set {@link origin}
+ * **Static placement**: leave the entity without a `Transform64`. Set {@link origin}
  * directly and the system never touches it.
  *
- * **Moving placement**: pair the entity with a `Transform`. The system re-anchors the
+ * **Moving placement**: pair the entity with a `Transform64`. The system re-anchors the
  * grid on every fixedUpdate to `quantize(transform.position, cell_size) + offset`, and
  * when the quantization changes shifts the field by the integer cell delta (carrying
  * fluid data along with the grid so the fluid appears to stay put in world space) and
@@ -31,19 +31,19 @@ export class FluidComponent {
     field: FluidField;
     /**
      * World position of grid cell `(0,0,0)`'s center. For static placement (no
-     * `Transform` on the entity) the user sets this directly. For moving placement
-     * (with `Transform`) {@link FluidSystem} owns it — every fixedUpdate it computes
+     * `Transform64` on the entity) the user sets this directly. For moving placement
+     * (with `Transform64`) {@link FluidSystem} owns it — every fixedUpdate it computes
      * the desired origin from the transform and either snaps on first sync or shifts
      * the field by the integer cell delta.
      * @type {[number, number, number]}
      */
     origin: [number, number, number];
     /**
-     * World-space offset added to the quantized `Transform.position` when computing
+     * World-space offset added to the quantized `Transform64` translation when computing
      * the grid centre. Use to place the grid asymmetrically relative to the entity —
      * e.g. `[-2, 0, 0]` puts the centre 2 world units behind the entity.
      *
-     * Only consulted when a `Transform` is present (otherwise `origin` is fully
+     * Only consulted when a `Transform64` is present (otherwise `origin` is fully
      * user-controlled).
      * @type {[number, number, number]}
      */
@@ -54,8 +54,8 @@ export class FluidComponent {
      */
     cell_size: number;
     /**
-     * Half-cell extra margin (in cells) the Transform must cross before the field
-     * re-quantizes to the next cell. Without it, a Transform jittering right on the
+     * Half-cell extra margin (in cells) the Transform64 must cross before the field
+     * re-quantizes to the next cell. Without it, a Transform64 jittering right on the
      * boundary between two cells would re-shift every frame, sloshing every buffer
      * back and forth and re-extrapolating the exposed edges each time — visible as
      * flicker in the fluid and thrashing in any solid-voxelizer downstream of the
@@ -70,7 +70,7 @@ export class FluidComponent {
      * gives a ~10%-of-a-cell deadband on each side, killing jitter while staying
      * imperceptible at typical cell sizes.
      *
-     * Only consulted when a `Transform` is present.
+     * Only consulted when a `Transform64` is present.
      * @type {number}
      */
     hysteresis: number;

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

@@ -6,17 +6,17 @@ import { FluidField } from "../FluidField.js";
  * ECS component representing a fluid volume — one {@link FluidField} plus its placement
  * in world space.
  *
- * Behaviour (stepping the simulation, dispatching effectors, re-anchoring on Transform
+ * Behaviour (stepping the simulation, dispatching effectors, re-anchoring on Transform64
  * motion) lives on {@link FluidSystem}, not here. This component is pure data.
  *
  * World ↔ grid mapping is uniform and axis-aligned: cell `(0,0,0)`'s center sits at
  * {@link origin}, and cells are spaced {@link cell_size} world-units apart along each
  * axis. For non-uniform or oriented volumes, use multiple components.
  *
- * **Static placement**: leave the entity without a `Transform`. Set {@link origin}
+ * **Static placement**: leave the entity without a `Transform64`. Set {@link origin}
  * directly and the system never touches it.
  *
- * **Moving placement**: pair the entity with a `Transform`. The system re-anchors the
+ * **Moving placement**: pair the entity with a `Transform64`. The system re-anchors the
  * grid on every fixedUpdate to `quantize(transform.position, cell_size) + offset`, and
  * when the quantization changes shifts the field by the integer cell delta (carrying
  * fluid data along with the grid so the fluid appears to stay put in world space) and
@@ -37,8 +37,8 @@ export class FluidComponent {
 
     /**
      * World position of grid cell `(0,0,0)`'s center. For static placement (no
-     * `Transform` on the entity) the user sets this directly. For moving placement
-     * (with `Transform`) {@link FluidSystem} owns it — every fixedUpdate it computes
+     * `Transform64` on the entity) the user sets this directly. For moving placement
+     * (with `Transform64`) {@link FluidSystem} owns it — every fixedUpdate it computes
      * the desired origin from the transform and either snaps on first sync or shifts
      * the field by the integer cell delta.
      * @type {[number, number, number]}
@@ -46,11 +46,11 @@ export class FluidComponent {
     origin = [0, 0, 0];
 
     /**
-     * World-space offset added to the quantized `Transform.position` when computing
+     * World-space offset added to the quantized `Transform64` translation when computing
      * the grid centre. Use to place the grid asymmetrically relative to the entity —
      * e.g. `[-2, 0, 0]` puts the centre 2 world units behind the entity.
      *
-     * Only consulted when a `Transform` is present (otherwise `origin` is fully
+     * Only consulted when a `Transform64` is present (otherwise `origin` is fully
      * user-controlled).
      * @type {[number, number, number]}
      */
@@ -63,8 +63,8 @@ export class FluidComponent {
     cell_size = 1;
 
     /**
-     * Half-cell extra margin (in cells) the Transform must cross before the field
-     * re-quantizes to the next cell. Without it, a Transform jittering right on the
+     * Half-cell extra margin (in cells) the Transform64 must cross before the field
+     * re-quantizes to the next cell. Without it, a Transform64 jittering right on the
      * boundary between two cells would re-shift every frame, sloshing every buffer
      * back and forth and re-extrapolating the exposed edges each time — visible as
      * flicker in the fluid and thrashing in any solid-voxelizer downstream of the
@@ -79,7 +79,7 @@ export class FluidComponent {
      * gives a ~10%-of-a-cell deadband on each side, killing jitter while staying
      * imperceptible at typical cell sizes.
      *
-     * Only consulted when a `Transform` is present.
+     * Only consulted when a `Transform64` is present.
      * @type {number}
      */
     hysteresis = 0.1;

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

@@ -6,10 +6,10 @@
  * step. Effectors that don't overlap a given field self-cull via their radius / position
  * checks, so attachment is implicit rather than configured.
  *
- * Pair this component with a `Transform` on the same entity to let position-bearing
+ * Pair this component with a `Transform64` on the same entity to let position-bearing
  * effectors ({@link WakeFluidEffector}, {@link ImpulseFluidEffector}, ...) follow the
  * entity. The system calls each effector's {@link AbstractFluidEffector.syncFromTransform}
- * with the entity's Transform before stepping the simulator.
+ * with the entity's Transform64 before stepping the simulator.
  */
 export class FluidEffectorsComponent {
     /**

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

@@ -8,10 +8,10 @@ import { assert } from "../../../../core/assert.js";
  * step. Effectors that don't overlap a given field self-cull via their radius / position
  * checks, so attachment is implicit rather than configured.
  *
- * Pair this component with a `Transform` on the same entity to let position-bearing
+ * Pair this component with a `Transform64` on the same entity to let position-bearing
  * effectors ({@link WakeFluidEffector}, {@link ImpulseFluidEffector}, ...) follow the
  * entity. The system calls each effector's {@link AbstractFluidEffector.syncFromTransform}
- * with the entity's Transform before stepping the simulator.
+ * with the entity's Transform64 before stepping the simulator.
  */
 export class FluidEffectorsComponent {
 

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

@@ -1,7 +1,7 @@
 /**
  * Marks an entity's {@link Collider} as a fluid obstacle: each fixed update,
  * {@link FluidObstacleSystem} voxelizes the collider's shape (via its signed
- * distance function, under the entity's rigid `Transform` pose) into the solid
+ * distance function, under the entity's rigid `Transform64` pose) into the solid
  * mask of every overlapping {@link FluidComponent}, and stamps the entity's
  * {@link RigidBody} velocity onto the wall faces as the moving-wall boundary
  * condition. Wind stops at — and is pushed by — the bodies the physics
@@ -14,8 +14,8 @@
  *     primitives do; mesh-ish shapes that don't will throw at voxelization),
  *   - a `RigidBody` — the wall-velocity source (see the system doc for the
  *     exact semantics). Static walls use `BodyKind.Static` as usual.
- *   - a `Transform` for the world pose. Following the collider convention,
- *     the pose is RIGID — `Transform.scale` is ignored, exactly as the
+ *   - a `Transform64` for the world pose. Following the collider convention,
+ *     the pose is RIGID — `Transform64.scale` is ignored, exactly as the
  *     physics narrowphase ignores it.
  *
  * Entities missing any part of the tuple are not obstacles and are skipped —

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

@@ -3,7 +3,7 @@ import { computeHashFloat } from "../../../../core/primitives/numbers/computeHas
 /**
  * Marks an entity's {@link Collider} as a fluid obstacle: each fixed update,
  * {@link FluidObstacleSystem} voxelizes the collider's shape (via its signed
- * distance function, under the entity's rigid `Transform` pose) into the solid
+ * distance function, under the entity's rigid `Transform64` pose) into the solid
  * mask of every overlapping {@link FluidComponent}, and stamps the entity's
  * {@link RigidBody} velocity onto the wall faces as the moving-wall boundary
  * condition. Wind stops at — and is pushed by — the bodies the physics
@@ -16,8 +16,8 @@ import { computeHashFloat } from "../../../../core/primitives/numbers/computeHas
  *     primitives do; mesh-ish shapes that don't will throw at voxelization),
  *   - a `RigidBody` — the wall-velocity source (see the system doc for the
  *     exact semantics). Static walls use `BodyKind.Static` as usual.
- *   - a `Transform` for the world pose. Following the collider convention,
- *     the pose is RIGID — `Transform.scale` is ignored, exactly as the
+ *   - a `Transform64` for the world pose. Following the collider convention,
+ *     the pose is RIGID — `Transform64.scale` is ignored, exactly as the
  *     physics narrowphase ignores it.
  *
  * Entities missing any part of the tuple are not obstacles and are skipped —

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

@@ -29,7 +29,7 @@
  *     of every cell the obstacle voxelized (converted to grid units per
  *     field); the projection's divergence reads pinned faces at face value,
  *     so a moving collider genuinely pushes and drags the air around it.
- *   - Pose is still read from `Transform`; velocity is NOT derived from
+ *   - Pose is still read from `Transform64`; velocity is NOT derived from
  *     pose deltas. A teleported body (spawn snap, network correction)
  *     relocates its walls but stamps no velocity — no one-tick air blast.
  *     This mirrors the engine's own contact-solver rule: see

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

@@ -39,7 +39,7 @@ import { FluidObstacle } from "./FluidObstacle.js";
  *     of every cell the obstacle voxelized (converted to grid units per
  *     field); the projection's divergence reads pinned faces at face value,
  *     so a moving collider genuinely pushes and drags the air around it.
- *   - Pose is still read from `Transform`; velocity is NOT derived from
+ *   - Pose is still read from `Transform64`; velocity is NOT derived from
  *     pose deltas. A teleported body (spawn snap, network correction)
  *     relocates its walls but stamps no velocity — no one-tick air blast.
  *     This mirrors the engine's own contact-solver rule: see
@@ -160,9 +160,9 @@ export class FluidObstacleSystem extends System {
         // linearVelocity, NOT a pose delta — teleports stamp nothing.
         ecd.traverseEntities([FluidObstacle, Collider, RigidBody, Transform64], function (obstacle, collider, body, transform) {
             const lv = body.linearVelocity;
-            const vx = lv.x;
-            const vy = lv.y;
-            const vz = lv.z;
+            const vx = lv[0];
+            const vy = lv[1];
+            const vz = lv[2];
 
             const moving = vx !== 0 || vy !== 0 || vz !== 0;
 

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

@@ -39,8 +39,8 @@ export class FluidSystem extends System<any> {
      * tuple. Lets the engine validate registration order and schedule reads.
      *
      *   - `FluidEffectorsComponent` — read every step to gather effectors and to
-     *     deliver Transform sync hooks.
-     *   - `Transform` — read every step (paired with FluidEffectorsComponent) so
+     *     deliver Transform64 sync hooks.
+     *   - `Transform64` — read every step (paired with FluidEffectorsComponent) so
      *     position-bearing effectors can follow their entity.
      */
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidEffectorsComponent>)[];

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

@@ -53,8 +53,8 @@ export class FluidSystem extends System {
      * tuple. Lets the engine validate registration order and schedule reads.
      *
      *   - `FluidEffectorsComponent` — read every step to gather effectors and to
-     *     deliver Transform sync hooks.
-     *   - `Transform` — read every step (paired with FluidEffectorsComponent) so
+     *     deliver Transform64 sync hooks.
+     *   - `Transform64` — read every step (paired with FluidEffectorsComponent) so
      *     position-bearing effectors can follow their entity.
      */
     components_used = [
@@ -116,7 +116,7 @@ export class FluidSystem extends System {
         //    when the quantization changes, the field is shifted to follow the world.
         ecd.traverseEntities([FluidComponent, Transform64], fluid_reanchor_field);
 
-        // 2. Sync every effector that wants to follow its entity's Transform.
+        // 2. Sync every effector that wants to follow its entity's Transform64.
         ecd.traverseEntities([FluidEffectorsComponent, Transform64], fluid_sync_effectors_from_transform);
 
         // 2. Step each fluid field, with broad-phase effector filtering per field.

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

@@ -8,7 +8,7 @@
  * projection, transport, scalars), and the solve — pressure above all — is the
  * expensive part. So the split is:
  *
- *   - **main thread**: re-anchoring, effector Transform sync, the AABB
+ *   - **main thread**: re-anchoring, effector Transform64 sync, the AABB
  *     broad-phase, and `effector.apply(...)`. Effectors stay here because they
  *     are arbitrary user-authored classes; keeping them on this side is what
  *     makes the swap transparent rather than a porting exercise.

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

@@ -33,7 +33,7 @@ const DEFAULT_MAX_FIELD_COUNT = 64;
  * projection, transport, scalars), and the solve — pressure above all — is the
  * expensive part. So the split is:
  *
- *   - **main thread**: re-anchoring, effector Transform sync, the AABB
+ *   - **main thread**: re-anchoring, effector Transform64 sync, the AABB
  *     broad-phase, and `effector.apply(...)`. Effectors stay here because they
  *     are arbitrary user-authored classes; keeping them on this side is what
  *     makes the swap transparent rather than a porting exercise.
@@ -287,7 +287,7 @@ export class WorkerFluidSystem extends WorkerSystem {
         //    already correct by the time they start stepping.
         ecd.traverseEntities([FluidComponent, Transform64], fluid_reanchor_field);
 
-        // 2. Sync every effector that wants to follow its entity's Transform.
+        // 2. Sync every effector that wants to follow its entity's Transform64.
         ecd.traverseEntities([FluidEffectorsComponent, Transform64], fluid_sync_effectors_from_transform);
 
         // 3. Apply effectors per field, and nominate the field for stepping.

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

@@ -8,7 +8,7 @@
  * lands at the geometric middle of the grid.
  *
  * Hysteresis: instead of recomputing `q` from the raw position every frame
- * (which would re-shift on every boundary crossing for a Transform jittering on
+ * (which would re-shift on every boundary crossing for a Transform64 jittering on
  * a cell edge), the current `q` is recovered from the existing origin and only
  * advances to a new cell when the raw position has drifted more than
  * `0.5 + hysteresis` cells from it. Crossing the threshold snaps to the new
@@ -22,7 +22,7 @@
  * identically, and the two must not be allowed to drift apart.
  *
  * @param {FluidComponent} component
- * @param {Transform} transform
+ * @param {Transform64} transform
  */
-export function fluid_reanchor_field(component: FluidComponent, transform: Transform): void;
+export function fluid_reanchor_field(component: FluidComponent, transform: Transform64): void;
 //# sourceMappingURL=fluid_reanchor_field.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fluid_reanchor_field.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_reanchor_field.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4FA0DC"}
+{"version":3,"file":"fluid_reanchor_field.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_reanchor_field.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8FA0DC"}

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

@@ -8,7 +8,7 @@
  * lands at the geometric middle of the grid.
  *
  * Hysteresis: instead of recomputing `q` from the raw position every frame
- * (which would re-shift on every boundary crossing for a Transform jittering on
+ * (which would re-shift on every boundary crossing for a Transform64 jittering on
  * a cell edge), the current `q` is recovered from the existing origin and only
  * advances to a new cell when the raw position has drifted more than
  * `0.5 + hysteresis` cells from it. Crossing the threshold snaps to the new
@@ -22,7 +22,7 @@
  * identically, and the two must not be allowed to drift apart.
  *
  * @param {FluidComponent} component
- * @param {Transform} transform
+ * @param {Transform64} transform
  */
 export function fluid_reanchor_field(component, transform) {
     const cs = component.cell_size;
@@ -58,7 +58,7 @@ export function fluid_reanchor_field(component, transform) {
     const q_curr_y = Math.round((origin[1] + half_extent_y - offset[1]) / cs);
     const q_curr_z = Math.round((origin[2] + half_extent_z - offset[2]) / cs);
 
-    // Raw (fractional) cell coordinate the Transform sits at right now.
+    // Raw (fractional) cell coordinate the Transform64 sits at right now.
     const raw_x = p[0] / cs;
     const raw_y = p[1] / cs;
     const raw_z = p[2] / cs;

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

@@ -1,11 +1,11 @@
 /**
- * Visitor for the (FluidEffectorsComponent, Transform) traversal — lets every
+ * Visitor for the (FluidEffectorsComponent, Transform64) traversal — lets every
  * position-bearing effector (wakes, splats) follow its owning entity.
  *
  * Shared by {@link FluidSystem} and {@link WorkerFluidSystem}.
  *
  * @param {FluidEffectorsComponent} effectors_component
- * @param {Transform} transform
+ * @param {Transform64} transform
  */
-export function fluid_sync_effectors_from_transform(effectors_component: FluidEffectorsComponent, transform: Transform): void;
+export function fluid_sync_effectors_from_transform(effectors_component: FluidEffectorsComponent, transform: Transform64): void;
 //# sourceMappingURL=fluid_sync_effectors_from_transform.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fluid_sync_effectors_from_transform.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_sync_effectors_from_transform.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,8HAMC"}
+{"version":3,"file":"fluid_sync_effectors_from_transform.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/ecs/fluid_sync_effectors_from_transform.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,gIAMC"}

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

@@ -1,11 +1,11 @@
 /**
- * Visitor for the (FluidEffectorsComponent, Transform) traversal — lets every
+ * Visitor for the (FluidEffectorsComponent, Transform64) traversal — lets every
  * position-bearing effector (wakes, splats) follow its owning entity.
  *
  * Shared by {@link FluidSystem} and {@link WorkerFluidSystem}.
  *
  * @param {FluidEffectorsComponent} effectors_component
- * @param {Transform} transform
+ * @param {Transform64} transform
  */
 export function fluid_sync_effectors_from_transform(effectors_component, transform) {
     const effectors = effectors_component.effectors;

package/src/engine/physics/fluid/effector/AbstractFluidEffector.d.ts

@@ -28,13 +28,13 @@ export class AbstractFluidEffector {
     apply(field: FluidField, dt: number, world_to_grid: Float32Array | number[]): void;
     /**
      * Optional hook called by {@link FluidSystem} once per step on each effector whose
-     * entity also has a `Transform` component. Default: no-op. Effectors that should
+     * entity also has a `Transform64` component. Default: no-op. Effectors that should
      * follow an entity override this to pull world-space position / orientation /
      * velocity off the transform.
      *
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
-    syncFromTransform(transform: Transform): void;
+    syncFromTransform(transform: Transform64): void;
     /**
      * Strict value equality. The base implementation collapses to reference equality
      * — every concrete effector class overrides this to compare its own configured

package/src/engine/physics/fluid/effector/AbstractFluidEffector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/AbstractFluidEffector.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;;;OAMG;IACH,6BALW,MAAM,iBACN,YAAY,GAAC,MAAM,EAAE,QAO/B;IAED;;;;;;;OAOG;IACH,8CAEC;IAED;;;;;;OAMG;IACH,cAHW,qBAAqB,GACpB,OAAO,CAIlB;IAED;;;;;OAKG;IACH,QAFY,MAAM,CAIjB;IAED;;;;;;;;;;;OAWG;IACH,iCAEC;CACJ"}
+{"version":3,"file":"AbstractFluidEffector.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/effector/AbstractFluidEffector.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;;;OAMG;IACH,6BALW,MAAM,iBACN,YAAY,GAAC,MAAM,EAAE,QAO/B;IAED;;;;;;;OAOG;IACH,gDAEC;IAED;;;;;;OAMG;IACH,cAHW,qBAAqB,GACpB,OAAO,CAIlB;IAED;;;;;OAKG;IACH,QAFY,MAAM,CAIjB;IAED;;;;;;;;;;;OAWG;IACH,iCAEC;CACJ"}

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

@@ -32,11 +32,11 @@ export class AbstractFluidEffector {
 
     /**
      * Optional hook called by {@link FluidSystem} once per step on each effector whose
-     * entity also has a `Transform` component. Default: no-op. Effectors that should
+     * entity also has a `Transform64` component. Default: no-op. Effectors that should
      * follow an entity override this to pull world-space position / orientation /
      * velocity off the transform.
      *
-     * @param {Transform} transform
+     * @param {Transform64} transform
      */
     syncFromTransform(transform) {
         // override as needed

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

@@ -192,8 +192,8 @@ export class ImpulseFluidEffector extends AbstractFluidEffector {
     }
 
     /**
-     * Pull world-space position off the entity Transform.
-     * @param {Transform} transform
+     * Pull world-space position off the entity Transform64.
+     * @param {Transform64} transform
      */
     syncFromTransform(transform) {
         const p = transform.translation;

package/src/engine/physics/fluid/effector/WakeFluidEffector.d.ts

@@ -12,7 +12,7 @@
  * Trail advancement (copying `position` into `previous_position`) depends on who
  * drives the effector:
  *
- *   - **Transform-managed** (entity has a `Transform`; {@link FluidSystem} calls
+ *   - **Transform64-managed** (entity has a `Transform64`; {@link FluidSystem} calls
  *     {@link syncFromTransform} once per fixed update): the trail advances inside
  *     the sync, NOT inside {@link apply}. The segment is "movement since the last
  *     tick", and `apply` is a pure read — the same instance can be applied to any
@@ -34,20 +34,20 @@
  * effector picks the smallest physically meaningful footprint when the converted
  * radius is below one cell.
  *
- * When the entity carrying a {@link FluidEffectorsComponent} also has a Transform,
+ * When the entity carrying a {@link FluidEffectorsComponent} also has a Transform64,
  * {@link FluidSystem} calls {@link syncFromTransform} on this effector each step —
  * which pulls the latest world-space position off the transform. On the very first
  * sync `previous_position` is seeded equal to `position` to suppress the spurious
  * wake from `[0, 0, 0]`.
  *
- * For sources you position manually (no Transform on the entity, or no entity at
+ * For sources you position manually (no Transform64 on the entity, or no entity at
  * all), call {@link reset_trail} once after the initial placement and after any
  * teleport so the next apply doesn't splat a wake across the jump.
  */
 export class WakeFluidEffector extends AbstractFluidEffector {
     /**
      * Current world-space position of the source. Updated each step from the entity
-     * Transform (via {@link syncFromTransform}) when one is available, otherwise set
+     * Transform64 (via {@link syncFromTransform}) when one is available, otherwise set
      * by user code before each step.
      * @type {[number, number, number]}
      */