@woosh/meep-engine 3.20.0 → 3.21.0

package/src/engine/control/first-person/abilities/Mantle.js

@@ -91,7 +91,7 @@ export class Mantle extends Ability {
         // Height check: the target surface must be within the reachable band.
         // A pull-up starts from a full hang (~maxHeight below the lip), so give
         // that path a slacker ceiling.
-        const surfaceTopY = sensors.ledgeAhead.point.y;
+        const surfaceTopY = sensors.ledgeAhead.point[1];
         const playerFootY = controller.pose.rootPosition.y;
         const heightDiff = surfaceTopY - playerFootY;
         const maxH = pullUp ? cfg.pullUpMaxHeight : cfg.maxHeight;
@@ -125,16 +125,16 @@ export class Mantle extends Ability {
         if (this._kind === "vault") {
             // Carry the body forward PAST the far edge; it crests an apex above
             // the lip then drops over, releasing airborne on the far side.
-            this._endX = ledge.x + fx * cfg.vaultDistance;
-            this._endY = ledge.y;
-            this._endZ = ledge.z + fz * cfg.vaultDistance;
-            this._apexY = ledge.y + cfg.vaultApexClearance;
+            this._endX = ledge[0] + fx * cfg.vaultDistance;
+            this._endY = ledge[1];
+            this._endZ = ledge[2] + fz * cfg.vaultDistance;
+            this._apexY = ledge[1] + cfg.vaultApexClearance;
         } else {
             // Land ON TOP, displaced slightly forward of the edge so the body
             // ends standing on the surface (not balancing on the lip).
-            this._endX = ledge.x + fx * cfg.forwardOffsetOnLand;
-            this._endY = ledge.y;
-            this._endZ = ledge.z + fz * cfg.forwardOffsetOnLand;
+            this._endX = ledge[0] + fx * cfg.forwardOffsetOnLand;
+            this._endY = ledge[1];
+            this._endZ = ledge[2] + fz * cfg.forwardOffsetOnLand;
         }
 
         // -- Preconditions (dev-only; compiled out of prod). The scripted path

package/src/engine/control/first-person/abilities/ScrambleUp.js

@@ -85,8 +85,8 @@ export class ScrambleUp extends Ability {
         const cfg = controller.config.scrambleUp;
         const sensors = runtime.sensors;
         this._elapsed = 0;
-        this._nx = sensors.wallFront.normal.x;
-        this._nz = sensors.wallFront.normal.z;
+        this._nx = sensors.wallFront.normal[0];
+        this._nz = sensors.wallFront.normal[2];
 
         // Reward forward momentum: the leg PUSH-OFF FORCE scales with the
         // horizontal approach speed at the jump — a standstill gives the base

package/src/engine/control/first-person/abilities/WallJump.js

@@ -90,8 +90,8 @@ export class WallJump extends Ability {
         // world up. Clamp upFactor positive to avoid pathological configs
         // that would push the player into the ground.
         const upFactor = clamp(cfg.upFactor, 0, 2);
-        runtime.velocityX += wallNormal.x * cfg.outwardImpulse * masteryMul;
-        runtime.velocityZ += wallNormal.z * cfg.outwardImpulse * masteryMul;
+        runtime.velocityX += wallNormal[0] * cfg.outwardImpulse * masteryMul;
+        runtime.velocityZ += wallNormal[2] * cfg.outwardImpulse * masteryMul;
         runtime.velocityY = runtime.jumpInitialVy * upFactor * masteryMul;
 
         // Mark this as a fresh jump (so the base jump FSM doesn't think

package/src/engine/control/first-person/abilities/WallRun.js

@@ -71,7 +71,7 @@ export class WallRun extends Ability {
         const hit = sensors.wallLeft.hit
             && (!sensors.wallRight.hit || sensors.wallLeft.distance <= sensors.wallRight.distance)
             ? sensors.wallLeft : sensors.wallRight;
-        const awaySpeed = runtime.velocityX * hit.normal.x + runtime.velocityZ * hit.normal.z;
+        const awaySpeed = runtime.velocityX * hit.normal[0] + runtime.velocityZ * hit.normal[2];
         if (awaySpeed > cfg.minSpeed * 0.5) return false;
 
         return true;
@@ -134,8 +134,8 @@ export class WallRun extends Ability {
         // The wall's normal is in the XZ plane (vertical wall). Zero the
         // component of velocity along that normal. Forward momentum
         // (along the wall's tangent direction) is preserved.
-        const nx = sensorHit.normal.x;
-        const nz = sensorHit.normal.z;
+        const nx = sensorHit.normal[0];
+        const nz = sensorHit.normal[2];
         const dotN = runtime.velocityX * nx + runtime.velocityZ * nz;
         runtime.velocityX -= dotN * nx;
         runtime.velocityZ -= dotN * nz;

package/src/engine/control/first-person/collision/KinematicMover.d.ts

@@ -2,7 +2,7 @@
  * Kinematic character collision solver. See DESIGN_COLLISION.md.
  *
  * **The mover is controller-agnostic, and the path it lives at says otherwise.** It imports
- * `Vector3`, `Ray3`, `Transform`, `Collider`, `compute_penetration` and `PhysicsSurfacePoint` —
+ * `Vector3`, `Ray3`, `Transform64`, `Collider`, `compute_penetration` and `PhysicsSurfacePoint` —
  * nothing from `FirstPersonPlayerController`. If you have your own movement model and have decided
  * that controller is not for you, **this class still is**: it carries the standoff (`skin`), the
  * start-solid depenetration pass, Quake's five-plane crease handling and `MIN_WALK_NORMAL`, and it

package/src/engine/control/first-person/collision/KinematicMover.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KinematicMover.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/collision/KinematicMover.js"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA0DI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,2BA9BW,OAAO,uCAAuC,EAAE,aAAa,OAC7D,OAAO,wCAAwC,EAAE,sBAAsB;QAKtD,IAAI,GAArB,MAAM;QAEW,kBAAkB,GAAnC,MAAM;QAEW,oBAAoB,GAArC,MAAM;QAEW,aAAa,GAA9B,MAAM;QAIW,UAAU,GAA3B,MAAM;OAuBhB;IAhGD,WAAkB;IAElB,0BAAiC;IACjC,yBAAkC;IAClC,sBAA8B;IAC9B,sBAAgD;IAChD,oBAA4B;IAC5B,uBAA+B;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAFU;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CAgBzJ;IAEF;;;;OAIG;IACH,qBAAqB;IAkCjB,6EAAkC;IAClC,6EAAc;IACd,aAA6D;IAC7D,2BAAmG;IACnG,6BAAyG;IACzG,sBAAsF;IACtF,mBAA6E;IAIjF;;;;;;;;;;;;;OAaG;IACH,eAVW,OAAO,YACP,UAAU,MAAM,CAAC,SAEjB,OAAO,mDAAmD,EAAE,eAAe,YAC3E,OAAO,MACP,MAAM,mBACE,MAAM,YAAW,QAAQ,KAAG,OAAO,GAEzC;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CA6E7J;IAED;;;;;;;;;;;;;;OAcG;IACH,mBAiGC;IAED;;;;OAIG;IACH,sBAQC;IAED;;;;OAIG;IACH,oBASC;IAED;;;;;;;;;OASG;IACH,iBAwCC;IAED;;;;;;;;OAQG;IACH,eAmIC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,0BAuFC;IAED;;;;;OAKG;IACH,cAKC;CACJ;qBApuBoB,sCAAsC;oCAIvB,iDAAiD;oBALjE,kCAAkC;yBAG7B,kCAAkC"}
+{"version":3,"file":"KinematicMover.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/collision/KinematicMover.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA0DI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,2BA9BW,OAAO,uCAAuC,EAAE,aAAa,OAC7D,OAAO,wCAAwC,EAAE,sBAAsB;QAKtD,IAAI,GAArB,MAAM;QAEW,kBAAkB,GAAnC,MAAM;QAEW,oBAAoB,GAArC,MAAM;QAEW,aAAa,GAA9B,MAAM;QAIW,UAAU,GAA3B,MAAM;OAuBhB;IAhGD,WAAkB;IAElB,0BAAiC;IACjC,yBAAkC;IAClC,sBAA8B;IAC9B,sBAAgD;IAChD,oBAA4B;IAC5B,uBAA+B;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAFU;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CAgBzJ;IAEF;;;;OAIG;IACH,qBAAqB;IAkCjB,6EAAkC;IAClC,6EAAc;IACd,aAA6D;IAC7D,2BAAmG;IACnG,6BAAyG;IACzG,sBAAsF;IACtF,mBAA6E;IAIjF;;;;;;;;;;;;;OAaG;IACH,eAVW,OAAO,YACP,UAAU,MAAM,CAAC,SAEjB,OAAO,mDAAmD,EAAE,eAAe,YAC3E,OAAO,MACP,MAAM,UACN,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,EAAC,QAAQ,KAAG,OAAO,GAEzC;QAAC,GAAG,EAAC,OAAO,CAAC;QAAC,QAAQ,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,OAAO,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,OAAO,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CA6E7J;IAED;;;;;;;;;;;;;;OAcG;IACH,mBAiGC;IAED;;;;OAIG;IACH,sBAQC;IAED;;;;OAIG;IACH,oBASC;IAED;;;;;;;;;OASG;IACH,iBAwCC;IAED;;;;;;;;OAQG;IACH,eAmIC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,0BAuFC;IAED;;;;;OAKG;IACH,cAKC;CACJ;qBAzsBoB,sCAAsC;oCAMvB,iDAAiD;oBAPjE,kCAAkC;yBAK7B,kCAAkC"}

package/src/engine/control/first-person/collision/KinematicMover.js

@@ -1,39 +1,12 @@
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
+import { v3_add } from "../../../../core/geom/vec3/v3_add.js";
+import { v3_set } from "../../../../core/geom/vec3/v3_set.js";
 import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { Collider } from "../../../physics/ecs/Collider.js";
 import { compute_penetration } from "../../../physics/narrowphase/compute_penetration.js";
 import { PhysicsSurfacePoint } from "../../../physics/queries/PhysicsSurfacePoint.js";
 
-/**
- * The mover writes through whatever it was handed, and it is handed a transform's own translation -
- * a `Float64Array` view with indices rather than `.x`/`.set`. These keep the call sites reading
- * the way they did.
- *
- * @param {number[]|Float64Array} out
- * @param {number} x
- * @param {number} y
- * @param {number} z
- */
-function v3_write(out, x, y, z) {
-    out[0] = x;
-    out[1] = y;
-    out[2] = z;
-}
-
-/**
- * @param {number[]|Float64Array} out
- * @param {number} x
- * @param {number} y
- * @param {number} z
- */
-function v3_add_in_place(out, x, y, z) {
-    out[0] += x;
-    out[1] += y;
-    out[2] += z;
-}
-
-
 /**
  * Maximum simultaneous clip planes tracked within a single slide,
  * matching Quake's `MAX_CLIP_PLANES`. A move that contacts more than
@@ -50,7 +23,7 @@ const MIN_MOVE = 1e-6;
  * Kinematic character collision solver. See DESIGN_COLLISION.md.
  *
  * **The mover is controller-agnostic, and the path it lives at says otherwise.** It imports
- * `Vector3`, `Ray3`, `Transform`, `Collider`, `compute_penetration` and `PhysicsSurfacePoint` —
+ * `Vector3`, `Ray3`, `Transform64`, `Collider`, `compute_penetration` and `PhysicsSurfacePoint` —
  * nothing from `FirstPersonPlayerController`. If you have your own movement model and have decided
  * that controller is not for you, **this class still is**: it carries the standoff (`skin`), the
  * start-solid depenetration pass, Quake's five-plane crease handling and `MIN_WALK_NORMAL`, and it
@@ -351,12 +324,12 @@ export class KinematicMover {
 
         // Confirmed climbable (nothing crosses the step-height plane ahead).
         // Up–forward–down places the capsule onto the step top.
-        v3_write(position, sx, sy, sz);
+        v3_set(position, 0, sx, sy, sz);
         const up = this._castDistance(position, rotation, shape, 0, 1, 0, this.stepHeight, filter);
-        v3_add_in_place(position, 0, up, 0);
-        v3_add_in_place(position, fnx * forwardLen, 0, fnz * forwardLen);
+        v3_add(position, 0, 0, up, 0);
+        v3_add(position, 0, fnx * forwardLen, 0, fnz * forwardLen);
         const down = this._castDistance(position, rotation, shape, 0, -1, 0, up + this.skin, filter);
-        v3_add_in_place(position, 0, -down, 0);
+        v3_add(position, 0, 0, -down, 0);
 
         // Reject a climb that ends INSIDE geometry. The thin step-height
         // probe is a single ray, so at a convex CORNER it can thread past
@@ -379,7 +352,7 @@ export class KinematicMover {
                 result.stepUp = heightGain > 0 ? heightGain : 0;
             }
         } else {
-            v3_write(position, px, py, pz);
+            v3_set(position, 0, px, py, pz);
             velocity.set(pvx, pvy, pvz);
         }
     }
@@ -411,7 +384,7 @@ export class KinematicMover {
         ray.setDirection(0, -1, 0);
         ray.tMax = lift + this.stepHeight + this.skin;
         if (!this.physicsSystem.raycast(ray, this._hit, filter)) return false;
-        if (this._hit.normal.y < this.minWalkNormal) return false;
+        if (this._hit.normal[1] < this.minWalkNormal) return false;
         return (y + lift - this._hit.t) <= y + this.skin;
     }
 
@@ -463,7 +436,7 @@ export class KinematicMover {
             if (bestDepth <= 0) return;
 
             const push = bestDepth + this.skin;
-            v3_add_in_place(position, bestX * push, bestY * push, bestZ * push);
+            v3_add(position, 0, bestX * push, bestY * push, bestZ * push);
         }
     }
 
@@ -509,7 +482,7 @@ export class KinematicMover {
 
             if (!didHit) {
                 // Clear path — consume the whole remaining move.
-                v3_add_in_place(position, ndx * len, ndy * len, ndz * len);
+                v3_add(position, 0, ndx * len, ndy * len, ndz * len);
                 break;
             }
 
@@ -522,9 +495,9 @@ export class KinematicMover {
             // remaining move rather than clipping the velocity into it
             // (which would cancel the jump). A genuine blocker is only
             // reachable by moving INTO it (dir·n < 0).
-            const dirDotN = ndx * hit.normal.x + ndy * hit.normal.y + ndz * hit.normal.z;
+            const dirDotN = ndx * hit.normal[0] + ndy * hit.normal[1] + ndz * hit.normal[2];
             if (dirDotN >= 0) {
-                v3_add_in_place(position, ndx * len, ndy * len, ndz * len);
+                v3_add(position, 0, ndx * len, ndy * len, ndz * len);
                 break;
             }
 
@@ -533,7 +506,7 @@ export class KinematicMover {
             // Advance up to the contact (less skin), and consume the
             // corresponding fraction of the remaining time.
             const advance = hit.t - skin > 0 ? hit.t - skin : 0;
-            if (advance > 0) v3_add_in_place(position, ndx * advance, ndy * advance, ndz * advance);
+            if (advance > 0) v3_add(position, 0, ndx * advance, ndy * advance, ndz * advance);
             const fraction = hit.t / len; // time uses the true TOI, not the skinned advance
             timeLeft -= timeLeft * (fraction > 1 ? 1 : fraction);
 
@@ -552,9 +525,9 @@ export class KinematicMover {
             // surface's real normal — flattening steep contacts to vertical
             // here would also rob a too-steep SLOPE of its downhill slide.
             const po = numPlanes * 3;
-            planes[po] = hit.normal.x;
-            planes[po + 1] = hit.normal.y;
-            planes[po + 2] = hit.normal.z;
+            planes[po] = hit.normal[0];
+            planes[po + 1] = hit.normal[1];
+            planes[po + 2] = hit.normal[2];
             numPlanes++;
 
             // Re-derive velocity: find a plane the ORIGINAL velocity can
@@ -660,7 +633,7 @@ export class KinematicMover {
         ray.setDirection(0, -1, 0);
         ray.tMax = reach;
         if (this.physicsSystem.raycast(ray, hit, filter)) {
-            nx = hit.normal.x; ny = hit.normal.y; nz = hit.normal.z;
+            nx = hit.normal[0]; ny = hit.normal[1]; nz = hit.normal[2];
             if (ny < this.minWalkNormal) {
                 result.groundNormal.set(nx, ny, nz);
                 return; // steep slope under the feet — slide, not grounded
@@ -690,7 +663,7 @@ export class KinematicMover {
             // flat gap-straddle / ledge edge, footprint normal ≈ up), not a
             // steep SLOPE the thin centre ray merely shot past (which must
             // still slide, not stick).
-            const ok = haveCentre || hit.normal.y >= this.minWalkNormal;
+            const ok = haveCentre || hit.normal[1] >= this.minWalkNormal;
             if (ok && stepY > surfaceY && stepY - base <= this.stepHeight + this.skin) {
                 surfaceY = stepY;
             }

package/src/engine/control/first-person/sensors/FirstPersonSensors.d.ts

@@ -3,15 +3,28 @@
  * otherwise. `surfaceTag` is optional — populated by future surface-tag
  * systems (grass/wood/metal/etc.) so abilities and audio can react to the
  * material.
+ *
+ * `point` and `normal` are raw three-element `Float64Array`s indexed `[0] [1] [2]`,
+ * matching {@link PhysicsSurfacePoint}, which is where their values come from. Every
+ * slot is rewritten each tick and nothing subscribes, so a change signal per vector
+ * would be ten of them per controller for nobody. Write them with {@link v3_set} —
+ * `array.set(x, y, z)` is `TypedArray.prototype.set`, which silently writes nothing.
  */
 export class SensorHit {
     hit: boolean;
     /** Distance from query origin to contact point (meters). */
     distance: number;
-    /** World-space contact point. */
-    point: Vector3;
-    /** Surface normal at contact (unit vector, points away from surface). */
-    normal: Vector3;
+    /**
+     * World-space contact point, indexed as [x, y, z].
+     * @type {Float64Array}
+     */
+    point: Float64Array;
+    /**
+     * Surface normal at contact (unit vector, points away from surface),
+     * indexed as [x, y, z].
+     * @type {Float64Array}
+     */
+    normal: Float64Array;
     /** Optional material/surface tag — e.g. "grass", "metal". */
     surfaceTag: any;
     /** Reset to "no hit" — call before re-using the slot each tick. */
@@ -63,5 +76,4 @@ export class FirstPersonSensors {
     /** Clear all sensor slots — call at the start of each tick. */
     clearAll(): void;
 }
-import Vector3 from "../../../../core/geom/Vector3.js";
 //# sourceMappingURL=FirstPersonSensors.d.ts.map

package/src/engine/control/first-person/sensors/FirstPersonSensors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonSensors.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensors.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IACI,aAAY;IAEZ,4DAA4D;IAC5D,iBAAa;IAEb,iCAAiC;IACjC,eAAsB;IAEtB,yEAAyE;IACzE,gBAA8B;IAE9B,6DAA6D;IAC7D,gBAAkB;IAElB,mEAAmE;IACnE,cAMC;CACJ;AAED;;;;;;;;;;;;;;GAcG;AACH;IACI,2DAA2D;IAC3D,oBAA2B;IAE3B,4DAA4D;IAC5D,qBAA4B;IAE5B,0CAA0C;IAC1C,qBAA4B;IAE5B;;;;OAIG;IACH,yBAAgC;IAEhC;;;;OAIG;IACH,sBAA6B;IAE7B;;;;;;;OAOG;IACH,wBAAuB;IAEvB,+DAA+D;IAC/D,iBAOC;CACJ;oBA3FmB,kCAAkC"}
+{"version":3,"file":"FirstPersonSensors.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensors.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACI,aAAY;IAEZ,4DAA4D;IAC5D,iBAAa;IAEb;;;OAGG;IACH,OAFU,YAAY,CAEM;IAE5B;;;;OAIG;IACH,QAFU,YAAY,CAEY;IAElC,6DAA6D;IAC7D,gBAAkB;IAElB,mEAAmE;IACnE,cAMC;CACJ;AAED;;;;;;;;;;;;;;GAcG;AACH;IACI,2DAA2D;IAC3D,oBAA2B;IAE3B,4DAA4D;IAC5D,qBAA4B;IAE5B,0CAA0C;IAC1C,qBAA4B;IAE5B;;;;OAIG;IACH,yBAAgC;IAEhC;;;;OAIG;IACH,sBAA6B;IAE7B;;;;;;;OAOG;IACH,wBAAuB;IAEvB,+DAA+D;IAC/D,iBAOC;CACJ"}

package/src/engine/control/first-person/sensors/FirstPersonSensors.js

@@ -1,10 +1,16 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
+import { v3_set } from "../../../../core/geom/vec3/v3_set.js";
 
 /**
  * Single spatial-query result. Set fields when `hit` is true; ignore them
  * otherwise. `surfaceTag` is optional — populated by future surface-tag
  * systems (grass/wood/metal/etc.) so abilities and audio can react to the
  * material.
+ *
+ * `point` and `normal` are raw three-element `Float64Array`s indexed `[0] [1] [2]`,
+ * matching {@link PhysicsSurfacePoint}, which is where their values come from. Every
+ * slot is rewritten each tick and nothing subscribes, so a change signal per vector
+ * would be ten of them per controller for nobody. Write them with {@link v3_set} —
+ * `array.set(x, y, z)` is `TypedArray.prototype.set`, which silently writes nothing.
  */
 export class SensorHit {
     hit = false;
@@ -12,11 +18,18 @@ export class SensorHit {
     /** Distance from query origin to contact point (meters). */
     distance = 0;
 
-    /** World-space contact point. */
-    point = new Vector3();
+    /**
+     * World-space contact point, indexed as [x, y, z].
+     * @type {Float64Array}
+     */
+    point = new Float64Array(3);
 
-    /** Surface normal at contact (unit vector, points away from surface). */
-    normal = new Vector3(0, 1, 0);
+    /**
+     * Surface normal at contact (unit vector, points away from surface),
+     * indexed as [x, y, z].
+     * @type {Float64Array}
+     */
+    normal = Float64Array.of(0, 1, 0);
 
     /** Optional material/surface tag — e.g. "grass", "metal". */
     surfaceTag = null;
@@ -25,8 +38,8 @@ export class SensorHit {
     clear() {
         this.hit = false;
         this.distance = 0;
-        this.point.set(0, 0, 0);
-        this.normal.set(0, 1, 0);
+        v3_set(this.point, 0, 0, 0, 0);
+        v3_set(this.normal, 0, 0, 1, 0);
         this.surfaceTag = null;
     }
 }

package/src/engine/control/first-person/sensors/FirstPersonSensorsSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonSensorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;IACI,0EAA0D;IAE1D;;;;;OAKG;IACH,kBAFU,iCAAiC,GAAC,IAAI,CAExB;IAExB;;;;;OAKG;IACH,eAFU,aAAa,GAAC,IAAI,CAEP;IAErB;;;;;;OAMG;IACH,mBAAwB;IAExB;;;;;;OAMG;IACH,mBAAuC;IAEvC,2CAaC;IAED,2BAIC;IAED;;OAEG;IACH,2BAsFC;IAED;;;;;;OAMG;IACH,wBASC;IAED;;;;;;;;;;;OAWG;IACH,kBAiBC;CACJ;uBA/NsB,wBAAwB;4BACnB,uCAAuC;4CACvB,mCAAmC;kDAC7B,yCAAyC;8BAL7D,uCAAuC"}
+{"version":3,"file":"FirstPersonSensorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;IACI,0EAA0D;IAE1D;;;;;OAKG;IACH,kBAFU,iCAAiC,GAAC,IAAI,CAExB;IAExB;;;;;OAKG;IACH,eAFU,aAAa,GAAC,IAAI,CAEP;IAErB;;;;;;OAMG;IACH,mBAAwB;IAExB;;;;;;OAMG;IACH,mBAAuC;IAEvC,2CAaC;IAED,2BAIC;IAED;;OAEG;IACH,2BAsFC;IAED;;;;;;OAMG;IACH,wBASC;IAED;;;;;;;;;;;OAWG;IACH,kBAiBC;CACJ;uBA/NsB,wBAAwB;4BACnB,uCAAuC;4CACvB,mCAAmC;kDAC7B,yCAAyC;8BAL7D,uCAAuC"}

package/src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
+import { v3_set } from "../../../../core/geom/vec3/v3_set.js";
 import { PhysicsSystem } from "../../../physics/ecs/PhysicsSystem.js";
 import { PhysicsSurfacePoint } from "../../../physics/queries/PhysicsSurfacePoint.js";
 import { System } from "../../../ecs/System.js";
@@ -150,8 +151,8 @@ export class FirstPersonSensorsSystem extends System {
         // obstacle, look for ground.
         if (sensors.obstacleAhead.hit) {
             const topY = transform.translation_y + cfg.body.height + 0.1;
-            const px = sensors.obstacleAhead.point.x + fx * 0.3;
-            const pz = sensors.obstacleAhead.point.z + fz * 0.3;
+            const px = sensors.obstacleAhead.point[0] + fx * 0.3;
+            const pz = sensors.obstacleAhead.point[2] + fz * 0.3;
             this._probeRay(
                 sensors.ledgeAhead,
                 px, topY, pz,
@@ -169,9 +170,9 @@ export class FirstPersonSensorsSystem extends System {
         if (sensors.ledgeAhead.hit) {
             const reach = cfg.body.radius * 2;
             sensors.ledgeStandable = this._probeStandable(
-                sensors.ledgeAhead.point.x + fx * reach,
-                sensors.ledgeAhead.point.y,
-                sensors.ledgeAhead.point.z + fz * reach,
+                sensors.ledgeAhead.point[0] + fx * reach,
+                sensors.ledgeAhead.point[1],
+                sensors.ledgeAhead.point[2] + fz * reach,
                 entity,
             );
         }
@@ -192,7 +193,7 @@ export class FirstPersonSensorsSystem extends System {
         const filter = (e) => e !== excludeEntity;
         const out = this._probe_hit;
         if (!this.physicsSystem.raycast(ray, out, filter)) return false;
-        return out.position.y > edgeY - 0.15; // surface still up near the edge height
+        return out.position[1] > edgeY - 0.15; // surface still up near the edge height
     }
 
     /**
@@ -221,8 +222,8 @@ export class FirstPersonSensorsSystem extends System {
 
         slot.hit = true;
         slot.distance = out.t;
-        slot.point.set(out.position.x, out.position.y, out.position.z);
-        slot.normal.set(out.normal.x, out.normal.y, out.normal.z);
+        v3_set(slot.point, 0, out.position[0], out.position[1], out.position[2]);
+        v3_set(slot.normal, 0, out.normal[0], out.normal[1], out.normal[2]);
         slot.surfaceTag = null; // future: surface-tag lookup
     }
 }

package/src/engine/control/first-person/test/buildTestPlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildTestPlayer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/test/buildTestPlayer.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AACH;eAF0B,SAAS;cAAY,QAAQ;EAkBtD;0BA/ByB,mCAAmC;yBADpC,kCAAkC"}
+{"version":3,"file":"buildTestPlayer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/test/buildTestPlayer.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AACH,uCAFa;IAAE,SAAS,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAA;CAAE,CAkBxD;0BA/ByB,mCAAmC;yBADpC,kCAAkC"}

package/src/engine/ecs/EntityComponentDataset.d.ts.map

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

package/src/engine/ecs/EntityManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAgBU,MAAM;;;;;;;;;AAiBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,aAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;;;MAGL;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IAuBf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BA2GC;IAED;;;;OAIG;IACH;iCAHqC,MAAM,KAAK,OAAO;aAatD;IAED;;;OAGG;IACH;iCAHqC,MAAM,KAAK,OAAO;QAC1C,OAAO,CAYnB;IAoBD;;;OAGG;IACH,uBAFa,OAAO,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,IAAI,aAAS,CAiBzB;IAGD;;;OAGG;IACH,2BAFW,MAAM,QAuFhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,6CA6DC;IAED;;;;OAIG;IACH,mCAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAmCC;IAED;;;;;OAKG;IACH,oBAqFC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,mCAFa,oBAAgB,CA0B5B;IAED;;;;OAIG;IACH,gDAHW,WAAW,GACT,oBAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAoFC;IAGL;;OAEG;IACH,yBA9tBe,sBAAsB,UA8tBA;IACrC;;OAEG;IACH,0BAAqC;IAErC;;OAEG;IACH,+BA7lBe,MAAM,UA6lBW;;CAd/B;uBAzkCmC,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B;4BAEhC,aAAa"}
+{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAgBU,MAAM;;;;;;;;;AAiBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,aAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;;;MAGL;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEqB;IAErC;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IAuBf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BA2GC;IAED;;;;OAIG;IACH,4BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,QAavD;IAED;;;OAGG;IACH,8BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,GAC3C,OAAO,CAYnB;IAoBD;;;OAGG;IACH,uBAFa,OAAO,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,IAAI,aAAS,CAiBzB;IAGD;;;OAGG;IACH,2BAFW,MAAM,QAuFhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,6CA6DC;IAED;;;;OAIG;IACH,mCAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAmCC;IAED;;;;;OAKG;IACH,oBAqFC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,mCAFa,oBAAgB,CA0B5B;IAED;;;;OAIG;IACH,gDAHW,WAAW,GACT,oBAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAoFC;IAGL;;OAEG;IACH,yBA9tBe,sBAAsB,UA8tBA;IACrC;;OAEG;IACH,0BAAqC;IAErC;;OAEG;IACH,+BA7lBe,MAAM,UA6lBW;;CAd/B;uBAzkCmC,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B;4BAEhC,aAAa"}

package/src/engine/ecs/EntityObserver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityObserver.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityObserver.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;IAoBI;;;;;;;OAOG;IACH,6EALkC,IAAI,yCACJ,IAAI,iBAgDrC;IAvED;;;OAGG;IACH,eAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,uBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,SAFU,yBAAuB,IAAI,CAEtB;IA0BX;;OAEG;IACH,oBAFU,MAAM,CAE2B;IAE3C;;;OAGG;IACH,uCAAyC;IAEzC;;;OAGG;IACH,qCAAoC;IAEpC;;;OAGG;IACH,sBAAoC;IAEpC;;;OAGG;IACH,aAAsB;IAG1B;;;OAGG;IACH,qCAqBC;IAED;;;OAGG;IACH,+CAMC;IAED;;;OAGG;IACH,2BAEC;IAED;;OAEG;IACH,mBAQC;CACJ;uBA/IsB,6BAA6B"}
+{"version":3,"file":"EntityObserver.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityObserver.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;IAoBI;;;;;;;OAOG;IACH,sDALW,CAAC,UAAU,OAAO,KAAK,IAAI,kBAC3B,CAAC,UAAU,OAAO,KAAK,IAAI,iBAgDrC;IAvED;;;OAGG;IACH,eAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,uBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,SAFU,yBAAuB,IAAI,CAEtB;IA0BX;;OAEG;IACH,oBAFU,MAAM,CAE2B;IAE3C;;;OAGG;IACH,uCAAyC;IAEzC;;;OAGG;IACH,qCAAoC;IAEpC;;;OAGG;IACH,sBAAoC;IAEpC;;;OAGG;IACH,aAAsB;IAG1B;;;OAGG;IACH,qCAqBC;IAED;;;OAGG;IACH,+CAMC;IAED;;;OAGG;IACH,2BAEC;IAED;;OAEG;IACH,mBAQC;CACJ;uBA/IsB,6BAA6B"}

package/src/engine/ecs/System.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,uCAAqB;IAErB;;;;OAIG;IACH,oBAA+C;IAE/C;;;;;;;;;OASG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,6BAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uCAHa,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wCAHa,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;;OAKG;IACH,wCAEC;IAED;;;;;OAKG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,kDAA4B;IAG5B;;;;;;OAMG;IACH,6CAAuB;CAvBtB;0BA2BS,MAAM"}
+{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,uCAAqB;IAErB;;;;OAIG;IACH,oBAA+C;IAE/C;;;;;;;;;OASG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,6BAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uCAHa,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wCAHa,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;;OAKG;IACH,wCAEC;IAED;;;;;OAKG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,aAFU,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAElB;IAG5B;;;;;;OAMG;IACH,QAFU,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAEvB;CAvBtB;0BA2BS,MAAM"}

package/src/engine/ecs/animation/Animation.d.ts

@@ -49,7 +49,7 @@ export class Animation {
      *
      * @param {boolean} v
      */
-    set isPlaying(arg: boolean);
+    set isPlaying(v: boolean);
     /**
      *
      * @return {boolean}

package/src/engine/ecs/animation/Animation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Animation.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/Animation.js"],"names":[],"mappings":"AAOA;;GAEG;AACH;IAyII;;;;OAIG;IACH,4BAFa,SAAS,CAMrB;IAzID;;;;;;;;;;;;;;;;;;;OAmBG;IACH,4BAqBC;IAjDD;;;OAGG;IACH,OAFU,KAAK,aAAa,CAAC,CAEV;IAEnB,iBAAa;IAgCT;;;OAGG;IACH,iBAFU,SAAO,IAAI,CAEJ;IAEjB;;;OAGG;IACH,OAFU,MAAM,CAEoD;IAWxE;;;OAGG;IACH,4BAEC;IAdD;;;OAGG;IACH,yBAEC;IAUD;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAanB;IAED;;;OAGG;IACH,QAFa,MAAM,CAOlB;IAaD,0BAYC;IAED;;;MAKC;IAIL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;;kBAUS,MAAM;;iBA3LC,uCAAuC;8BAE1B,oBAAoB;+BACnB,qBAAqB"}
+{"version":3,"file":"Animation.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/animation/Animation.js"],"names":[],"mappings":"AAOA;;GAEG;AACH;IAyII;;;;OAIG;IACH,4BAFa,SAAS,CAMrB;IAzID;;;;;;;;;;;;;;;;;;;OAmBG;IACH,4BAqBC;IAjDD;;;OAGG;IACH,OAFU,KAAK,aAAa,CAAC,CAEV;IAEnB,iBAAa;IAgCT;;;OAGG;IACH,iBAFU,SAAO,IAAI,CAEJ;IAEjB;;;OAGG;IACH,OAFU,MAAM,CAEoD;IAWxE;;;OAGG;IACH,0BAEC;IAdD;;;OAGG;IACH,yBAEC;IAUD;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAanB;IAED;;;OAGG;IACH,QAFa,MAAM,CAOlB;IAaD,0BAYC;IAED;;;MAKC;IAIL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;;kBAUS,MAAM;;iBA3LC,uCAAuC;8BAE1B,oBAAoB;+BACnB,qBAAqB"}

package/src/engine/ecs/async/SystemWorkerLoopback.d.ts

@@ -30,13 +30,13 @@ export class SystemWorkerLoopback {
      * Main-thread message handler, assigned by {@link WorkerSystem}.
      * @type {((event: {data: *}) => void)|null}
      */
-    onmessage: (event: {
+    onmessage: ((event: {
         data: any;
-    }) => void;
+    }) => void) | null;
     /**
      * @type {((event: *) => void)|null}
      */
-    onerror: (event: any) => void;
+    onerror: ((event: any) => void) | null;
     /**
      * @type {boolean}
      */

package/src/engine/ecs/async/SystemWorkerLoopback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SystemWorkerLoopback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/async/SystemWorkerLoopback.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAiCI;;OAEG;IACH,kBAFW,MAAM,EAYhB;IA5CD;;;OAGG;IACH,mBAFmB;QAAC,IAAI,MAAG;KAAC,KAAK,IAAI,CAEpB;IAEjB;;OAEG;IACH,yBAFyB,IAAI,CAEd;IAEf;;OAEG;IACH,YAFU,OAAO,CAEE;IAgCnB;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,mCAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,cAgBC;IAED;;;OAGG;IACH,kBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAMhB;;CACJ;iCA9IgC,uBAAuB"}
+{"version":3,"file":"SystemWorkerLoopback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/async/SystemWorkerLoopback.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAiCI;;OAEG;IACH,kBAFW,MAAM,EAYhB;IA5CD;;;OAGG;IACH,WAFU,CAAC,CAAC,KAAK,EAAE;QAAC,IAAI,MAAG;KAAC,KAAK,IAAI,CAAC,GAAC,IAAI,CAE1B;IAEjB;;OAEG;IACH,SAFU,CAAC,CAAC,KAAK,KAAG,KAAK,IAAI,CAAC,GAAC,IAAI,CAEpB;IAEf;;OAEG;IACH,YAFU,OAAO,CAEE;IAgCnB;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,mCAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,cAgBC;IAED;;;OAGG;IACH,kBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAMhB;;CACJ;iCA9IgC,uBAAuB"}

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicActorSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/dynamic_actions/DynamicActorSystem.js"],"names":[],"mappings":"AA6FA;IA4DI;;;OAGG;IACH,4BASC;IAxED,sCAA8B;IAE9B,kEAEE;IAEF;;;OAGG;IACH,sCAAgB;IAEhB;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;;OAIG;IACH,iCAOG;IAEH;;;;OAIG;IACH,gCAAoC;IAEpC;;;OAGG;IACH,mCAAiB;IAEjB;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,gBAAgB;IASZ;;;OAGG;IACH,eAAoB;IAIxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,uDAyBhB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAehB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,oDA4DhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,SACN,SAAS,QAsDnB;IAED;;;;OAIG;IACH,yBAFY,yBAAuB,SAAS,CA6E3C;IAED;;;;;;;;;OASG;IACH,kDALoB,MAAM,sCAAsC,IAAI,+BAEzD,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,yBAAwB;QAAC,KAAK,EAAE,SAAS,CAAA;KAAC,EAAE,CA4E3E;IAED;;;;;;OAMG;IACH,cALW,MAAM,SACN,MAAM,iBAEJ,yBAAuB,SAAS,CAiC5C;IAED,2CAQC;IAED;;;;;OAKG;IACH,mCAiBC;IAED,6BAYC;CACJ;sCAtkBqC,oCAAoC;6BAG7C,mBAAmB;2BATrB,6CAA6C;4CAP5B,oDAAoD;0BAetE,gBAAgB"}
+{"version":3,"file":"DynamicActorSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/dynamic_actions/DynamicActorSystem.js"],"names":[],"mappings":"AA6FA;IA4DI;;;OAGG;IACH,4BASC;IAxED,sCAA8B;IAE9B,kEAEE;IAEF;;;OAGG;IACH,sCAAgB;IAEhB;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;;OAIG;IACH,iCAOG;IAEH;;;;OAIG;IACH,gCAAoC;IAEpC;;;OAGG;IACH,mCAAiB;IAEjB;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,gBAAgB;IASZ;;;OAGG;IACH,eAAoB;IAIxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,uDAyBhB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAehB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,oDA4DhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,SACN,SAAS,QAsDnB;IAED;;;;OAIG;IACH,yBAFY,yBAAuB,SAAS,CA6E3C;IAED;;;;;;;;;OASG;IACH,yCALW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,wBAAwB,KAAK,IAAI,+BAEzD,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,yBAAwB;QAAC,KAAK,EAAE,SAAS,CAAA;KAAC,EAAE,CA4E3E;IAED;;;;;;OAMG;IACH,cALW,MAAM,SACN,MAAM,iBAEJ,yBAAuB,SAAS,CAiC5C;IAED,2CAQC;IAED;;;;;OAKG;IACH,mCAiBC;IAED,6BAYC;CACJ;sCAtkBqC,oCAAoC;6BAG7C,mBAAmB;2BATrB,6CAA6C;4CAP5B,oDAAoD;0BAetE,gBAAgB"}

package/src/engine/ecs/grid/pick.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/grid/pick.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,wBANW,MAAM,KACN,MAAM,6EAGS,OAAO,iBAAiB,OAAO,UAAU,OAAO,KAAK,IAAI,QAgClF;oBAxCmB,+BAA+B;oBAF/B,+BAA+B"}
+{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/grid/pick.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,wBANW,MAAM,KACN,MAAM,8DAGN,CAAC,YAAY,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,QAgClF;oBAxCmB,+BAA+B;oBAF/B,+BAA+B"}

package/src/engine/ecs/guid/UUID.d.ts

@@ -46,7 +46,7 @@ export class UUID {
      *
      * @param {number[]|Uint8Array|ArrayLike<number>} bytes
      */
-    set data(arg: Uint8Array);
+    set data(bytes: Uint8Array);
     /**
      *
      * @returns {Uint8Array}

package/src/engine/ecs/guid/UUID.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UUID.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/guid/UUID.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA2HI;;;OAGG;IACH,aAFY,IAAI,CAQf;IA2BD;;;OAGG;IACH,aAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,iBAFY,MAAM,CAIjB;IA6CD;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,CAQf;IAxOD;;;OAGG;IACH,0BAKC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,sBAKC;IAED;;;;OAIG;IACH,OAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,MAFa,IAAI,CAwEhB;IAcD;;;OAGG;IACH,MAFa,IAAI,CAqBhB;IAuBD;;;OAGG;IACH,cAFW,MAAM,QAuChB;IAeD;;;;;;OAMG;IACH,YAFa,MAAM,CA2BlB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED;;;OAGG;IACH,SAFY,IAAI,CAQf;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAcnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAYlB;IAIL;;OAEG;IACH,uBAzFiB,MAAM,CAyFF;IAErB;;OAEG;IACH,4BAzJe,MAAM,UAyJE;IAQvB;;;OAGG;IACH,iBAFU,OAAO,CAEI;;CAtBpB;;kBAcS,MAAM"}
+{"version":3,"file":"UUID.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/guid/UUID.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA2HI;;;OAGG;IACH,aAFY,IAAI,CAQf;IA2BD;;;OAGG;IACH,aAFa,IAAI,CAQhB;IAED;;;;OAIG;IACH,iBAFY,MAAM,CAIjB;IA6CD;;;;OAIG;IACH,qBAHW,MAAM,GACL,IAAI,CAQf;IAxOD;;;OAGG;IACH,4BAKC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,sBAKC;IAED;;;;OAIG;IACH,OAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,MAFa,IAAI,CAwEhB;IAcD;;;OAGG;IACH,MAFa,IAAI,CAqBhB;IAuBD;;;OAGG;IACH,cAFW,MAAM,QAuChB;IAeD;;;;;;OAMG;IACH,YAFa,MAAM,CA2BlB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED;;;OAGG;IACH,SAFY,IAAI,CAQf;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAcnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAYlB;IAIL;;OAEG;IACH,uBAzFiB,MAAM,CAyFF;IAErB;;OAEG;IACH,4BAzJe,MAAM,UAyJE;IAQvB;;;OAGG;IACH,iBAFU,OAAO,CAEI;;CAtBpB;;kBAcS,MAAM"}

package/src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OneBoneSurfaceAlignmentSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.js"],"names":[],"mappings":"AAmCA;;GAEG;AACH;IACI,0BA6FC;CACJ;yBA9HwB,eAAe"}
+{"version":3,"file":"OneBoneSurfaceAlignmentSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.js"],"names":[],"mappings":"AA4CA;;GAEG;AACH;IACI,0BAqGC;CACJ;yBA7IwB,eAAe"}

package/src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.js

@@ -3,14 +3,23 @@ import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { clamp } from "../../../core/math/clamp.js";
 import { inverseLerp } from "../../../core/math/inverseLerp.js";
+import { t64_read_rotation } from "../transform/t64_read_rotation.js";
+import { t64_read_translation } from "../transform/t64_read_translation.js";
 import { IKBone, ik_bone_chain } from "./ik_bone_chain.js";
 import { ik_probe_terrain_contact } from "./ik_probe_terrain_contact.js";
 import { IKSolver } from "./IKSolver.js";
+import { ik_write_local_rotation } from "./ik_write_local_rotation.js";
 
 const contact = new SurfacePoint3();
 
 const targetPosition = new Vector3();
 
+const bonePosition = new Vector3();
+const parentPosition = new Vector3();
+
+const boneWorldRotation = new Quaternion();
+const parentLocalRotation = new Quaternion();
+
 const v3 = new Vector3();
 
 const ONE_OVER_SQRT_3 = 0.57735026919;
@@ -51,21 +60,26 @@ export class OneBoneSurfaceAlignmentSolver extends IKSolver {
         /*
          Read straight off the components: `TransformAttachmentSystem` composes a world transform as
          soon as anything it depends on moves, so nothing has to be brought up to date first.
+
+         They are read OUT of the transforms rather than used in place, the same way the two-bone
+         solver reads its chain: what follows is vector and quaternion math, and a Transform64 is an
+         array carrying none of those methods.
         */
-        const boneWorldPosition = bone.world.position;
-        const boneWorldRotation = bone.world.rotation;
+        const world = bone.world;
 
-        const parentWorldPosition = boneParent.world.position;
+        t64_read_translation(bonePosition, world);
+        t64_read_translation(parentPosition, boneParent.world);
 
-        const bone_scale = bone.world.scale.length() * ONE_OVER_SQRT_3;
+        // the magnitude of a uniform scale, which is what the limb's lengths are expressed in
+        const bone_scale = Math.hypot(world.scale_x, world.scale_y, world.scale_z) * ONE_OVER_SQRT_3;
 
         //cast from the parent towards the bone to find the surface underneath it
         let influence = ik_probe_terrain_contact(
             targetPosition,
             contact,
             terrain,
-            parentWorldPosition,
-            boneWorldPosition,
+            parentPosition.x, parentPosition.y, parentPosition.z,
+            bonePosition.x, bonePosition.y, bonePosition.z,
             constraint,
             bone_scale
         );
@@ -77,7 +91,8 @@ export class OneBoneSurfaceAlignmentSolver extends IKSolver {
 
         const contactNormal = contact.normal;
 
-        r.copy(bone.local.rotation);
+        t64_read_rotation(r, bone.local);
+        t64_read_rotation(boneWorldRotation, world);
 
         //we want to make bone align orthogonally to surface contact normal
 
@@ -110,7 +125,9 @@ export class OneBoneSurfaceAlignmentSolver extends IKSolver {
         target.multiply(x);
 
         //compute angle between quaternions
-        const a = target.angleTo(boneParent.local.rotation);
+        t64_read_rotation(parentLocalRotation, boneParent.local);
+
+        const a = target.angleTo(parentLocalRotation);
 
         const a_abs = Math.abs(a);
         if (a_abs >= constraint.limit) {
@@ -129,6 +146,6 @@ export class OneBoneSurfaceAlignmentSolver extends IKSolver {
 
         r.lerp(target, constraint.strength * influence);
 
-        bone.local.rotation.copy(r);
+        ik_write_local_rotation(dataset, bone, r);
     }
 }