@woosh/meep-engine 3.20.0 → 3.22.0

package/src/engine/physics/narrowphase/compute_penetration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_penetration.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/compute_penetration.js"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,mDAXW,YAAY,GAAC,MAAM,EAAE,wCAGrB;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,cAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,wCAErC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,cAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,GACnC,MAAM,CAwClB"}
+{"version":3,"file":"compute_penetration.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/compute_penetration.js"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,mDAfW,YAAY,GAAC,MAAM,EAAE,wCAGrB,UAAU,MAAM,CAAC,cAEjB,UAAU,MAAM,CAAC,wCAGjB,UAAU,MAAM,CAAC,cAEjB,UAAU,MAAM,CAAC,GAEf,MAAM,CAwClB"}

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

@@ -121,14 +121,35 @@ const CONTACT_EPSILON = 1e-4;
  * Concave-vs-concave throws — the M×N triangle-pair cost is out of scope (and
  * is also refused by the narrowphase for dynamic pairs).
  *
+ * ## Poses are read BY INDEX
+ *
+ * Every pose component is consumed as `position[0..2]` / `rotation[0..3]` —
+ * here in the recovery path, and inside the {@link deepest_pair_penetration}
+ * dispatch this hands them to. A `Transform64`'s `translation` / `rotation`
+ * (`Float64Array` views — what the ECS callers pass), a `Vector3` /
+ * `Quaternion` (both `Float64Array` subclasses) and plain `[x, y, z]` /
+ * `[x, y, z, w]` arrays all satisfy that; an `{x, y, z}` / `{x, y, z, w}`
+ * object does NOT. Its components read as `undefined`, which trips
+ * `Transform64.setTranslation`'s `assert.isNumber` in development — but
+ * `assert.*` is stripped from production bundles, so a shipped build carries
+ * the NaN pose into the dispatch instead, finds no contact and returns 0: a
+ * clean separation reported for two interpenetrating bodies.
+ *
+ * The rotations are taken to be unit quaternions; nothing here normalises or
+ * validates one.
+ *
  * @param {Float64Array|number[]} out_direction length ≥ 3; receives the unit
  *   separation direction (B → A) on penetration
  * @param {AbstractShape3D} shape_a  in shape_a's local frame; may be concave
- * @param {{x:number,y:number,z:number}} position_a  world position of A
- * @param {{x:number,y:number,z:number,w:number}} rotation_a  world rotation of A
+ * @param {ArrayLike<number>} position_a  world position of A, indexed as
+ *   [x, y, z]
+ * @param {ArrayLike<number>} rotation_a  world rotation of A (unit quaternion),
+ *   indexed as [x, y, z, w]
  * @param {AbstractShape3D} shape_b  in shape_b's local frame; may be concave
- * @param {{x:number,y:number,z:number}} position_b  world position of B
- * @param {{x:number,y:number,z:number,w:number}} rotation_b  world rotation of B
+ * @param {ArrayLike<number>} position_b  world position of B, indexed as
+ *   [x, y, z]
+ * @param {ArrayLike<number>} rotation_b  world rotation of B (unit quaternion),
+ *   indexed as [x, y, z, w]
  * @returns {number} penetration depth (positive) on overlap, 0 otherwise
  * @throws {Error} if both shapes have `is_convex === false`
  */

package/src/engine/physics/narrowphase/convex_decomposition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convex_decomposition.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_decomposition.js"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH,4BALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;AAED;;;GAGG;AACH;YAFsB,MAAM;QAAC,QAAQ,EAAC,YAAY,CAAC;QAAC,YAAY,EAAC,WAAW,CAAC;QAAC,UAAU,EAAC,WAAW,CAAC;QAAC,IAAI,EAAC,YAAY,CAAA;KAAC,CAAC;SAAO,GAAG;EAmHlI;AAED;;;;;;;;;;;;;GAaG;AACH,gCAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAElC,IAAI,MAAM,EAAE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,CAAC;cAE9B,YAAY;kBAAgB,WAAW;gBAAc,WAAW;UAAQ,YAAY;EAgG3G;AAzPD,kCAAiF;oBAvC7D,gCAAgC"}
+{"version":3,"file":"convex_decomposition.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_decomposition.js"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH,4BALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;AAED;;;GAGG;AACH,oEAFa;IAAC,MAAM,EAAE,MAAM;QAAC,QAAQ,EAAC,YAAY,CAAC;QAAC,YAAY,EAAC,WAAW,CAAC;QAAC,UAAU,EAAC,WAAW,CAAC;QAAC,IAAI,EAAC,YAAY,CAAA;KAAC,CAAC,CAAC;IAAC,GAAG,EAAE,GAAG,CAAA;CAAC,CAmHnI;AAED;;;;;;;;;;;;;GAaG;AACH,gCAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAElC,IAAI,MAAM,EAAE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,CAAC,GAEzC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,YAAY,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,YAAY,CAAA;CAAC,CAgG5G;AAzPD,kCAAiF;oBAvC7D,gCAAgC"}

package/src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.d.ts

@@ -20,8 +20,7 @@
  * manifold cache uses it as the warm-start match key.
  *
  * Stride 10 (rather than 9) is the small cost we pay for clean warm-start
- * matching; see the discussion in PLAN.md's "Pair-key → slot map" section
- * for why ID-based matching beats position-distance matching when shapes
+ * matching; ID-based matching beats position-distance matching when shapes
  * slide along curved surfaces.
  *
  * @readonly

package/src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangle_buffer_layout.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,yCAFU,MAAM,CAE4B"}
+{"version":3,"file":"triangle_buffer_layout.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,yCAFU,MAAM,CAE4B"}

package/src/engine/physics/narrowphase/decomposition/triangle_buffer_layout.js

@@ -20,8 +20,7 @@
  * manifold cache uses it as the warm-start match key.
  *
  * Stride 10 (rather than 9) is the small cost we pay for clean warm-start
- * matching; see the discussion in PLAN.md's "Pair-key → slot map" section
- * for why ID-based matching beats position-distance matching when shapes
+ * matching; ID-based matching beats position-distance matching when shapes
  * slide along curved surfaces.
  *
  * @readonly

package/src/engine/physics/narrowphase/narrowphase_step.d.ts

@@ -21,35 +21,28 @@
  * {@link narrowphase_step}. Intended for main-thread queries run outside a
  * step (depenetration, overlap depth, tooling) — never from inside one.
  *
+ * Both poses are read BY INDEX on the way into the stand-in `Transform64`s —
+ * a `Transform64`'s own `translation` / `rotation` (`Float64Array` views), a
+ * `Vector3` / `Quaternion` (both `Float64Array` subclasses) and plain
+ * `[x, y, z]` / `[x, y, z, w]` arrays all work; an `{x, y, z, w}` object does
+ * not. Its components read as `undefined`, which trips `setTranslation`'s
+ * `assert.isNumber` in development and, with `assert.*` stripped from a
+ * production bundle, leaves a NaN pose that dispatches to no contact — 0, the
+ * same value a genuine separation returns.
+ *
  * @param {Float64Array|number[]} out_normal length ≥ 3; receives the unit B→A
  *   normal on penetration (untouched when the return value is 0)
  * @param {AbstractShape3D} shapeA
- * @param {{x:number,y:number,z:number}} posA
- * @param {{x:number,y:number,z:number,w:number}} rotA
+ * @param {ArrayLike<number>} posA  world position of A, indexed as [x, y, z]
+ * @param {ArrayLike<number>} rotA  world rotation of A (unit quaternion),
+ *   indexed as [x, y, z, w]
  * @param {AbstractShape3D} shapeB
- * @param {{x:number,y:number,z:number}} posB
- * @param {{x:number,y:number,z:number,w:number}} rotB
+ * @param {ArrayLike<number>} posB  world position of B, indexed as [x, y, z]
+ * @param {ArrayLike<number>} rotB  world rotation of B (unit quaternion),
+ *   indexed as [x, y, z, w]
  * @returns {number} deepest penetration depth (> 0) or 0 if separated
  */
-export function deepest_pair_penetration(out_normal: Float64Array | number[], shapeA: AbstractShape3D, posA: {
-    x: number;
-    y: number;
-    z: number;
-}, rotA: {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}, shapeB: AbstractShape3D, posB: {
-    x: number;
-    y: number;
-    z: number;
-}, rotB: {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}): number;
+export function deepest_pair_penetration(out_normal: Float64Array | number[], shapeA: AbstractShape3D, posA: ArrayLike<number>, rotA: ArrayLike<number>, shapeB: AbstractShape3D, posB: ArrayLike<number>, rotB: ArrayLike<number>): number;
 /**
  * For every pair in `pair_list`, do a cross-product over A's collider list ×
  * B's collider list, accumulate candidate contacts, reduce to ≤4, and write
@@ -57,14 +50,14 @@ export function deepest_pair_penetration(out_normal: Float64Array | number[], sh
  *
  * @param {PairList} pair_list
  * @param {ManifoldStore} manifolds
- * @param {Array<Array<{collider: Collider, transform: Transform}>>} lists
+ * @param {Array<Array<{collider: Collider, transform: Transform64}>>} lists
  *   per-body collider lists, indexed by body-storage slot index. Typically
  *   `system.__body_collider_lists` — passed in directly so this helper
  *   has no dependency on `PhysicsSystem`.
  */
 export function narrowphase_step(pair_list: PairList, manifolds: ManifoldStore, lists: Array<Array<{
     collider: Collider;
-    transform: Transform;
+    transform: Transform64;
 }>>): void;
 /**
  * Re-detect contact GEOMETRY for one existing manifold slot at the bodies'
@@ -89,14 +82,15 @@ export function narrowphase_step(pair_list: PairList, manifolds: ManifoldStore,
  *
  * @param {ManifoldStore} manifolds
  * @param {number} slot
- * @param {Array<{collider: Collider, transform: Transform}>} list_a
- * @param {Array<{collider: Collider, transform: Transform}>} list_b
+ * @param {Array<{collider: Collider, transform: Transform64}>} list_a
+ * @param {Array<{collider: Collider, transform: Transform64}>} list_b
  */
 export function redetect_pair_geometry(manifolds: ManifoldStore, slot: number, list_a: Array<{
     collider: Collider;
-    transform: Transform;
+    transform: Transform64;
 }>, list_b: Array<{
     collider: Collider;
-    transform: Transform;
+    transform: Transform64;
 }>): void;
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 //# sourceMappingURL=narrowphase_step.d.ts.map

package/src/engine/physics/narrowphase/narrowphase_step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AAk1CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,qDAVW,YAAY,GAAC,MAAM,EAAE,iCAGrB;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,QAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iCAErC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,QAC5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,GACnC,MAAM,CA2ClB;AAED;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,CAAC,QA4LlE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEAJW,MAAM,UACN,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,UACjD,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAW;CAAC,CAAC,QA2H3D"}
+{"version":3,"file":"narrowphase_step.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/narrowphase_step.js"],"names":[],"mappings":"AAk1CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,qDAZW,YAAY,GAAC,MAAM,EAAE,iCAGrB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,iCAGjB,UAAU,MAAM,CAAC,QACjB,UAAU,MAAM,CAAC,GAEf,MAAM,CA2ClB;AAED;;;;;;;;;;;GAWG;AACH,uFALW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,CAAC,QA4LpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uEAJW,MAAM,UACN,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,UACnD,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,EAAE,WAAW,CAAA;CAAC,CAAC,QA2H7D;4BA/tD2B,oCAAoC"}

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

@@ -97,7 +97,7 @@ const MAX_KEPT = MAX_CONTACTS_PER_MANIFOLD;
  * contact has no feature id (or none of the previous-frame contacts shares
  * its id), match by closest world_a within this 3-D distance.
  *
- * 2 cm matches the original PLAN.md spec for "Persistent manifold cache"
+ * 2 cm matches the original plan spec for "Persistent manifold cache"
  * — generous enough to follow small inter-frame contact migration on
  * curved surfaces, tight enough that distinct contacts on a single
  * manifold (typically >5 cm apart) don't get confused with each other.
@@ -378,9 +378,9 @@ function sphere_box_voronoi_fid(sx, sy, sz, bx, by, bz, bqx, bqy, bqz, bqw, hx,
  *
  * @param {number} count
  * @param {{vertices,face_offsets,face_loops,support}} hullA  in A's local frame
- * @param {Transform} trA
+ * @param {Transform64} trA
  * @param {{vertices,face_offsets,face_loops,support}} hullB  in B's local frame
- * @param {Transform} trB
+ * @param {Transform64} trB
  * @param {Function} append_contact
  * @returns {number}
  */
@@ -427,9 +427,9 @@ function hull_pair_contacts(count, hullA, trA, hullB, trB, append_contact) {
  *
  * @param {number} count
  * @param {Collider} colA
- * @param {Transform} trA
+ * @param {Transform64} trA
  * @param {Collider} colB
- * @param {Transform} trB
+ * @param {Transform64} trB
  * @returns {number}
  */
 function dispatch_pair(count, colA, trA, colB, trB) {
@@ -1383,14 +1383,25 @@ const _pp_trB = new Transform64();
  * {@link narrowphase_step}. Intended for main-thread queries run outside a
  * step (depenetration, overlap depth, tooling) — never from inside one.
  *
+ * Both poses are read BY INDEX on the way into the stand-in `Transform64`s —
+ * a `Transform64`'s own `translation` / `rotation` (`Float64Array` views), a
+ * `Vector3` / `Quaternion` (both `Float64Array` subclasses) and plain
+ * `[x, y, z]` / `[x, y, z, w]` arrays all work; an `{x, y, z, w}` object does
+ * not. Its components read as `undefined`, which trips `setTranslation`'s
+ * `assert.isNumber` in development and, with `assert.*` stripped from a
+ * production bundle, leaves a NaN pose that dispatches to no contact — 0, the
+ * same value a genuine separation returns.
+ *
  * @param {Float64Array|number[]} out_normal length ≥ 3; receives the unit B→A
  *   normal on penetration (untouched when the return value is 0)
  * @param {AbstractShape3D} shapeA
- * @param {{x:number,y:number,z:number}} posA
- * @param {{x:number,y:number,z:number,w:number}} rotA
+ * @param {ArrayLike<number>} posA  world position of A, indexed as [x, y, z]
+ * @param {ArrayLike<number>} rotA  world rotation of A (unit quaternion),
+ *   indexed as [x, y, z, w]
  * @param {AbstractShape3D} shapeB
- * @param {{x:number,y:number,z:number}} posB
- * @param {{x:number,y:number,z:number,w:number}} rotB
+ * @param {ArrayLike<number>} posB  world position of B, indexed as [x, y, z]
+ * @param {ArrayLike<number>} rotB  world rotation of B (unit quaternion),
+ *   indexed as [x, y, z, w]
  * @returns {number} deepest penetration depth (> 0) or 0 if separated
  */
 export function deepest_pair_penetration(out_normal, shapeA, posA, rotA, shapeB, posB, rotB) {
@@ -1443,7 +1454,7 @@ export function deepest_pair_penetration(out_normal, shapeA, posA, rotA, shapeB,
  *
  * @param {PairList} pair_list
  * @param {ManifoldStore} manifolds
- * @param {Array<Array<{collider: Collider, transform: Transform}>>} lists
+ * @param {Array<Array<{collider: Collider, transform: Transform64}>>} lists
  *   per-body collider lists, indexed by body-storage slot index. Typically
  *   `system.__body_collider_lists` — passed in directly so this helper
  *   has no dependency on `PhysicsSystem`.
@@ -1656,8 +1667,8 @@ export function narrowphase_step(pair_list, manifolds, lists) {
  *
  * @param {ManifoldStore} manifolds
  * @param {number} slot
- * @param {Array<{collider: Collider, transform: Transform}>} list_a
- * @param {Array<{collider: Collider, transform: Transform}>} list_b
+ * @param {Array<{collider: Collider, transform: Transform64}>} list_a
+ * @param {Array<{collider: Collider, transform: Transform64}>} list_b
  */
 export function redetect_pair_geometry(manifolds, slot, list_a, list_b) {
     if (list_a === undefined || list_b === undefined) return;

package/src/engine/physics/narrowphase/refine_ray_concave.d.ts

@@ -1,6 +1,8 @@
 /**
  * @param {AbstractShape3D} shape  a concave shape (`is_convex === false`)
- * @param {{x:number,y:number,z:number}} position
+ * @param {ArrayLike<number>} position  body world position, indexed as
+ *   [x, y, z] — read by index like `rotation`, so an `{x, y, z}` object
+ *   sends a NaN ray into the decomposition and returns NaN
  * @param {ArrayLike<number>} rotation  body rotation quaternion (x,y,z,w)
  * @param {number} ox  ray origin x (world)
  * @param {number} oy  ray origin y (world)
@@ -12,9 +14,5 @@
  * @param {Float64Array|Vector3} outNormal  world surface normal, written on hit
  * @returns {number} hit distance, or `Infinity` on miss
  */
-export function refine_ray_concave(shape: AbstractShape3D, position: {
-    x: number;
-    y: number;
-    z: number;
-}, rotation: ArrayLike<number>, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number, outNormal: Float64Array | Vector3): number;
+export function refine_ray_concave(shape: AbstractShape3D, position: ArrayLike<number>, rotation: ArrayLike<number>, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number, outNormal: Float64Array | Vector3): number;
 //# sourceMappingURL=refine_ray_concave.d.ts.map

package/src/engine/physics/narrowphase/refine_ray_concave.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refine_ray_concave.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_concave.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;;;;GAaG;AACH,qEAZW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAC5B,UAAU,MAAM,CAAC,MACjB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,YAAY,UAAQ,GAClB,MAAM,CAyGlB"}
+{"version":3,"file":"refine_ray_concave.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_concave.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;;;;;;GAeG;AACH,qEAdW,UAAU,MAAM,CAAC,YAGjB,UAAU,MAAM,CAAC,MACjB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,YAAY,UAAQ,GAClB,MAAM,CAyGlB"}

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

@@ -40,7 +40,9 @@ const AABB_FATTEN = 1e-5; // guards triangles whose AABB just abuts the segment
 
 /**
  * @param {AbstractShape3D} shape  a concave shape (`is_convex === false`)
- * @param {{x:number,y:number,z:number}} position
+ * @param {ArrayLike<number>} position  body world position, indexed as
+ *   [x, y, z] — read by index like `rotation`, so an `{x, y, z}` object
+ *   sends a NaN ray into the decomposition and returns NaN
  * @param {ArrayLike<number>} rotation  body rotation quaternion (x,y,z,w)
  * @param {number} ox  ray origin x (world)
  * @param {number} oy  ray origin y (world)

package/src/engine/physics/narrowphase/refine_ray_hit.d.ts

@@ -14,7 +14,11 @@
  * a phantom hit on the box, so it is a last resort and not a design.
  *
  * @param {AbstractShape3D} shape
- * @param {{x:number,y:number,z:number}} position  body world position
+ * @param {ArrayLike<number>} position  body world position, indexed as
+ *   [x, y, z] — a `Transform64`'s `translation` (what the raycast query
+ *   passes), a `Vector3`, or a plain array. Read by index like `rotation`, so an
+ *   `{x, y, z}` object yields `NaN` or `Infinity` depending on the shape
+ *   branch, and either way the body drops silently out of the cast
  * @param {ArrayLike<number>} rotation  body world rotation quaternion (x,y,z,w)
  * @param {number} ox  ray origin x (world)
  * @param {number} oy  ray origin y (world)
@@ -28,11 +32,7 @@
  * @returns {number} hit distance, `Infinity` on a refined miss, or
  *   {@link RAY_REFINE_UNSUPPORTED} when the shape has no exact ray test here
  */
-export function refine_ray_hit(shape: AbstractShape3D, position: {
-    x: number;
-    y: number;
-    z: number;
-}, rotation: ArrayLike<number>, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number, outNormal: Float64Array | Vector3): number;
+export function refine_ray_hit(shape: AbstractShape3D, position: ArrayLike<number>, rotation: ArrayLike<number>, ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, tMax: number, outNormal: Float64Array | Vector3): number;
 /**
  * Sentinel returned by {@link refine_ray_hit} for a shape it has no exact ray
  * test for. The caller should keep the broadphase AABB result for that leaf

package/src/engine/physics/narrowphase/refine_ray_hit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refine_ray_hit.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_hit.js"],"names":[],"mappings":"AA6NA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iEAdW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAC5B,UAAU,MAAM,CAAC,MACjB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,YAAY,UAAQ,GAElB,MAAM,CA4BlB;AAzQD;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB"}
+{"version":3,"file":"refine_ray_hit.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/refine_ray_hit.js"],"names":[],"mappings":"AA6NA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,iEAlBW,UAAU,MAAM,CAAC,YAKjB,UAAU,MAAM,CAAC,MACjB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,YAAY,UAAQ,GAElB,MAAM,CA4BlB;AA7QD;;;;;;GAMG;AACH,qCAFU,MAAM,CAEyB"}

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

@@ -235,7 +235,11 @@ function refine_ray_union(shape, ox, oy, oz, dx, dy, dz, tMax, outNormal) {
  * a phantom hit on the box, so it is a last resort and not a design.
  *
  * @param {AbstractShape3D} shape
- * @param {{x:number,y:number,z:number}} position  body world position
+ * @param {ArrayLike<number>} position  body world position, indexed as
+ *   [x, y, z] — a `Transform64`'s `translation` (what the raycast query
+ *   passes), a `Vector3`, or a plain array. Read by index like `rotation`, so an
+ *   `{x, y, z}` object yields `NaN` or `Infinity` depending on the shape
+ *   branch, and either way the body drops silently out of the cast
  * @param {ArrayLike<number>} rotation  body world rotation quaternion (x,y,z,w)
  * @param {number} ox  ray origin x (world)
  * @param {number} oy  ray origin y (world)

package/src/engine/physics/queries/PhysicsSurfacePoint.d.ts

@@ -13,6 +13,12 @@
  * GC per call. Reusing the same `PhysicsSurfacePoint` keeps that allocation
  * out of the hot path.
  *
+ * For the same reason `position` and `normal` are raw three-element
+ * `Float64Array`s indexed `[0] [1] [2]`, not `Vector3`: a change signal on a
+ * result the queries overwrite on every call is two allocations and a dispatch
+ * nobody subscribes to. Write them with {@link v3_set} — `array.set(x, y, z)`
+ * is `TypedArray.prototype.set`, which silently writes nothing.
+ *
  * Field layout chosen to match what gameplay code typically needs:
  *   - `position` — world-space point on the surface
  *   - `normal` — surface normal at that point (broadphase queries return
@@ -34,17 +40,17 @@ export class PhysicsSurfacePoint {
     /**
      * World-space point on the hit surface.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly position: Vector3;
+    readonly position: Float64Array;
     /**
      * Surface normal at {@link position}, unit length. For broadphase-only
      * queries this is the AABB face normal (axis-aligned), which is exact
      * for AABB-shaped colliders and a stable approximation otherwise.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    readonly normal: Vector3;
+    readonly normal: Float64Array;
     /**
      * Parametric distance from the query origin to {@link position}, in
      * the same units as the input direction's magnitude (so for a unit-
@@ -79,5 +85,4 @@ export class PhysicsSurfacePoint {
      */
     readonly isPhysicsSurfacePoint: boolean;
 }
-import Vector3 from "../../../core/geom/Vector3.js";
 //# sourceMappingURL=PhysicsSurfacePoint.d.ts.map

package/src/engine/physics/queries/PhysicsSurfacePoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PhysicsSurfacePoint.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/PhysicsSurfacePoint.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IAEI;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;;;OAMG;IACH,iBAFU,OAAO,CAEM;IAEvB;;;;;OAKG;IACH,GAFU,MAAM,CAEV;IAEN;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;;OAMG;IACH,cAQC;IAGL;;;;OAIG;IACH,gCAFU,OAAO,CAEkC;CAPlD;oBA1FmB,+BAA+B"}
+{"version":3,"file":"PhysicsSurfacePoint.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/PhysicsSurfacePoint.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;IAEI;;;;OAIG;IACH,mBAFU,YAAY,CAES;IAE/B;;;;;;OAMG;IACH,iBAFU,YAAY,CAEO;IAE7B;;;;;OAKG;IACH,GAFU,MAAM,CAEV;IAEN;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;;OAMG;IACH,cAQC;IAGL;;;;OAIG;IACH,gCAFU,OAAO,CAEkC;CAPlD"}

package/src/engine/physics/queries/PhysicsSurfacePoint.js

@@ -1,5 +1,3 @@
-import Vector3 from "../../../core/geom/Vector3.js";
-
 /**
  * Result of a {@link PhysicsSystem} query that resolves to a single surface
  * contact — raycast hit, sphere overlap nearest-point, shape-cast first
@@ -15,6 +13,12 @@ import Vector3 from "../../../core/geom/Vector3.js";
  * GC per call. Reusing the same `PhysicsSurfacePoint` keeps that allocation
  * out of the hot path.
  *
+ * For the same reason `position` and `normal` are raw three-element
+ * `Float64Array`s indexed `[0] [1] [2]`, not `Vector3`: a change signal on a
+ * result the queries overwrite on every call is two allocations and a dispatch
+ * nobody subscribes to. Write them with {@link v3_set} — `array.set(x, y, z)`
+ * is `TypedArray.prototype.set`, which silently writes nothing.
+ *
  * Field layout chosen to match what gameplay code typically needs:
  *   - `position` — world-space point on the surface
  *   - `normal` — surface normal at that point (broadphase queries return
@@ -37,18 +41,18 @@ export class PhysicsSurfacePoint {
     /**
      * World-space point on the hit surface.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    position = new Vector3();
+    position = new Float64Array(3);
 
     /**
      * Surface normal at {@link position}, unit length. For broadphase-only
      * queries this is the AABB face normal (axis-aligned), which is exact
      * for AABB-shaped colliders and a stable approximation otherwise.
      * @readonly
-     * @type {Vector3}
+     * @type {Float64Array}
      */
-    normal = new Vector3();
+    normal = new Float64Array(3);
 
     /**
      * Parametric distance from the query origin to {@link position}, in

package/src/engine/physics/queries/overlap_shape.d.ts

@@ -26,10 +26,10 @@
  * @param {PhysicsSystem} system
  * @param {AbstractShape3D} shape  query shape, convex; expressed in
  *   its own local frame
- * @param {{x:number,y:number,z:number}} position world position of the
- *   query shape
- * @param {{x:number,y:number,z:number,w:number}} rotation world rotation
- *   of the query shape (unit quaternion)
+ * @param {number[]|Float64Array} position world position of the query shape,
+ *   indexed as [x, y, z]
+ * @param {number[]|Float64Array} rotation world rotation of the query shape
+ *   (unit quaternion), indexed as [x, y, z, w]
  * @param {Uint32Array|number[]} output buffer to write body_ids into.
  *   Caller is responsible for sizing it; ids past its end are dropped.
  * @param {number} output_offset float-index in output to start writing at
@@ -38,14 +38,5 @@
  * @returns {number} number of overlapping bodies written
  * @throws {Error} if `shape.is_convex === false`
  */
-export function overlap_shape(system: PhysicsSystem, shape: AbstractShape3D, position: {
-    x: number;
-    y: number;
-    z: number;
-}, rotation: {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}, output: Uint32Array | number[], output_offset: number, filter?: (entity: number, collider: Collider) => boolean): number;
+export function overlap_shape(system: PhysicsSystem, shape: AbstractShape3D, position: number[] | Float64Array, rotation: number[] | Float64Array, output: Uint32Array | number[], output_offset: number, filter?: (entity: number, collider: Collider) => boolean): number;
 //# sourceMappingURL=overlap_shape.d.ts.map

package/src/engine/physics/queries/overlap_shape.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overlap_shape.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/overlap_shape.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,uFAZW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,YAE5B;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,UAErC,WAAW,GAAC,MAAM,EAAE,iBAEpB,MAAM,oBACE,MAAM,yBAAsB,OAAO,GAEzC,MAAM,CAmHlB"}
+{"version":3,"file":"overlap_shape.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/overlap_shape.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,uFAZW,MAAM,EAAE,GAAC,YAAY,YAErB,MAAM,EAAE,GAAC,YAAY,UAErB,WAAW,GAAC,MAAM,EAAE,iBAEpB,MAAM,WACN,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,UAAS,KAAG,OAAO,GAEzC,MAAM,CAmHlB"}

package/src/engine/physics/queries/overlap_shape.js

@@ -72,10 +72,10 @@ let scratch_candidates = new Uint32Array(64);
  * @param {PhysicsSystem} system
  * @param {AbstractShape3D} shape  query shape, convex; expressed in
  *   its own local frame
- * @param {{x:number,y:number,z:number}} position world position of the
- *   query shape
- * @param {{x:number,y:number,z:number,w:number}} rotation world rotation
- *   of the query shape (unit quaternion)
+ * @param {number[]|Float64Array} position world position of the query shape,
+ *   indexed as [x, y, z]
+ * @param {number[]|Float64Array} rotation world rotation of the query shape
+ *   (unit quaternion), indexed as [x, y, z, w]
  * @param {Uint32Array|number[]} output buffer to write body_ids into.
  *   Caller is responsible for sizing it; ids past its end are dropped.
  * @param {number} output_offset float-index in output to start writing at

package/src/engine/physics/queries/raycast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raycast.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/raycast.js"],"names":[],"mappings":"AAkLA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,yGAJmB,MAAM,yBAAsB,OAAO,GAEzC,OAAO,CAwCnB"}
+{"version":3,"file":"raycast.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/raycast.js"],"names":[],"mappings":"AAkLA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,gGAJW,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,UAAS,KAAG,OAAO,GAEzC,OAAO,CAwCnB"}

package/src/engine/physics/queries/shape_cast.d.ts

@@ -46,7 +46,14 @@
  *   plain double-precision ray-like works — `Ray3` is Float32Array-backed and
  *   quantises large-coordinate sweeps (the CCD pass passes a f64 ray-like)
  * @param {AbstractShape3D} shape  shape being swept, in its local frame
- * @param {{x:number,y:number,z:number,w:number}} rotation  fixed orientation
+ * @param {ArrayLike<number>} rotation  the orientation the shape is held at for
+ *   the whole sweep, read BY INDEX as `[x, y, z, w]` and taken to be a unit
+ *   quaternion (it is neither normalised nor validated here — a non-unit one
+ *   silently returns wrong answers). A `Transform64`'s `rotation` (a
+ *   `Float64Array` view — what the CCD pass hands in), a `Quaternion`
+ *   (`Float64Array`-backed) and a plain `[x, y, z, w]` array all satisfy that;
+ *   an `{x, y, z, w}` object does NOT — its components read as `undefined`,
+ *   the swept AABB comes out NaN, and every cast then misses silently
  * @param {PhysicsSurfacePoint} result  populated on hit; untouched on miss
  * @param {(entity:number, collider:Collider, body_id:number)=>boolean} [filter]
  *   mandatory in contract; defaults to {@link returnTrue}. Receives the
@@ -65,10 +72,13 @@
  *   sweep must never blind the cast to every other obstacle.
  * @returns {boolean}
  */
-export function shape_cast(system: PhysicsSystem, ray: any, shape: AbstractShape3D, rotation: {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}, result: PhysicsSurfacePoint, filter?: (entity: number, collider: Collider, body_id: number) => boolean, skip_initial_overlaps?: boolean): boolean;
+export function shape_cast(system: PhysicsSystem, ray: Ray3 | {
+    origin_x: number;
+    origin_y: number;
+    origin_z: number;
+    direction_x: number;
+    direction_y: number;
+    direction_z: number;
+    tMax: number;
+}, shape: AbstractShape3D, rotation: ArrayLike<number>, result: PhysicsSurfacePoint, filter?: (entity: number, collider: Collider, body_id: number) => boolean, skip_initial_overlaps?: boolean): boolean;
 //# sourceMappingURL=shape_cast.d.ts.map

package/src/engine/physics/queries/shape_cast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shape_cast.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/shape_cast.js"],"names":[],"mappings":"AAoPA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,8FAnBW;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iDAE7B,MAAM,+BAA6B,MAAM,KAAG,OAAO,0BAI3D,OAAO,GAWL,OAAO,CA8TnB"}
+{"version":3,"file":"shape_cast.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/shape_cast.js"],"names":[],"mappings":"AAoPA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyEG;AACH,uDA/BW,OAAK;IAAC,QAAQ,EAAC,MAAM,CAAC;IAAA,QAAQ,EAAC,MAAM,CAAC;IAAA,QAAQ,EAAC,MAAM,CAAC;IAAA,WAAW,EAAC,MAAM,CAAC;IAAA,WAAW,EAAC,MAAM,CAAC;IAAA,WAAW,EAAC,MAAM,CAAC;IAAA,IAAI,EAAC,MAAM,CAAA;CAAC,oCAK3H,UAAU,MAAM,CAAC,wCASjB,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,UAAS,EAAE,OAAO,EAAC,MAAM,KAAG,OAAO,0BAI3D,OAAO,GAWL,OAAO,CA8TnB"}

package/src/engine/physics/queries/shape_cast.js

@@ -129,7 +129,7 @@ const probe_normal = new Float64Array(3);
  * @param {number} px swept shape's probe centre
  * @param {number} py
  * @param {number} pz
- * @param {Transform} target_tr the target body's transform (centre for the
+ * @param {Transform64} target_tr the target body's transform (centre for the
  *   sign check)
  * @returns {boolean}
  */
@@ -211,7 +211,7 @@ function probe_contact_normal(out, px, py, pz, target_tr) {
  * @param {number} dx unit sweep direction
  * @param {number} dy
  * @param {number} dz
- * @param {Transform} target_tr the target body's transform
+ * @param {Transform64} target_tr the target body's transform
  * @returns {boolean} false when every probe degenerates — `out` is untouched
  */
 function recover_contact_normal(out, cx, cy, cz, dx, dy, dz, target_tr) {
@@ -290,7 +290,14 @@ function recover_contact_normal(out, cx, cy, cz, dx, dy, dz, target_tr) {
  *   plain double-precision ray-like works — `Ray3` is Float32Array-backed and
  *   quantises large-coordinate sweeps (the CCD pass passes a f64 ray-like)
  * @param {AbstractShape3D} shape  shape being swept, in its local frame
- * @param {{x:number,y:number,z:number,w:number}} rotation  fixed orientation
+ * @param {ArrayLike<number>} rotation  the orientation the shape is held at for
+ *   the whole sweep, read BY INDEX as `[x, y, z, w]` and taken to be a unit
+ *   quaternion (it is neither normalised nor validated here — a non-unit one
+ *   silently returns wrong answers). A `Transform64`'s `rotation` (a
+ *   `Float64Array` view — what the CCD pass hands in), a `Quaternion`
+ *   (`Float64Array`-backed) and a plain `[x, y, z, w]` array all satisfy that;
+ *   an `{x, y, z, w}` object does NOT — its components read as `undefined`,
+ *   the swept AABB comes out NaN, and every cast then misses silently
  * @param {PhysicsSurfacePoint} result  populated on hit; untouched on miss
  * @param {(entity:number, collider:Collider, body_id:number)=>boolean} [filter]
  *   mandatory in contract; defaults to {@link returnTrue}. Receives the

package/src/engine/physics/solver/solve_contacts.d.ts

@@ -48,9 +48,9 @@ export function warm_start_contacts(manifolds: ManifoldStore, system: PhysicsSys
  * for the small per-step rotation), so they are not recomputed here.
  *
  * @param {ManifoldStore} manifolds
- * @param {Transform[]} transforms
+ * @param {Transform64[]} transforms
  */
-export function refresh_contacts(manifolds: ManifoldStore, transforms: Transform[]): void;
+export function refresh_contacts(manifolds: ManifoldStore, transforms: Transform64[]): void;
 /**
  * Stage 2b (per substep) — the concave counterpart of {@link refresh_contacts}.
  *

package/src/engine/physics/solver/solve_contacts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solve_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/solve_contacts.js"],"names":[],"mappings":"AAkgBA;;;;;;;;;;;;;GAaG;AACH,0FAHW,MAAM,GACJ,MAAM,CAoNlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,2FA0CC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uEAFW,WAAW,QAmGrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iGA2GC;AAED;;;;;;;;GAQG;AACH,uFAFW,MAAM,4BAwJhB;AAED;;;;;;;;;;;GAWG;AACH,yFAuDC;AAED;;;;;;;;;;;;;;GAcG;AACH,2FAFW,MAAM,QA2EhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oFAJW,MAAM,UACN,MAAM,cACN,MAAM,QAkDhB;AAhwCD;;;mBAGmB;AACnB,oCAAmC;AA3FnC;;;;;GAKG;AACH,0CAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAEsB"}
+{"version":3,"file":"solve_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/solve_contacts.js"],"names":[],"mappings":"AAkgBA;;;;;;;;;;;;;GAaG;AACH,0FAHW,MAAM,GACJ,MAAM,CAoNlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,2FA0CC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,uEAFW,aAAa,QAmGvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iGA2GC;AAED;;;;;;;;GAQG;AACH,uFAFW,MAAM,4BAwJhB;AAED;;;;;;;;;;;GAWG;AACH,yFAuDC;AAED;;;;;;;;;;;;;;GAcG;AACH,2FAFW,MAAM,QA2EhB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oFAJW,MAAM,UACN,MAAM,cACN,MAAM,QAkDhB;AAhwCD;;;mBAGmB;AACnB,oCAAmC;AA3FnC;;;;;GAKG;AACH,0CAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAEsB"}

package/src/engine/physics/solver/solve_contacts.js

@@ -124,7 +124,7 @@ const CONTACT_RELAXATION = 4.75;
 
 /**
  * Maximum magnitude of the position-correction velocity bias, in m/s.
- * Belt-and-braces against inflated EPA depths (PLAN.md caveat) driving the
+ * Belt-and-braces against inflated EPA depths driving the
  * bias to tens of m/s. Removed once closed-form triangle solvers land.
  * @type {number}
  */
@@ -816,7 +816,7 @@ export function warm_start_contacts(manifolds, system) {
  * for the small per-step rotation), so they are not recomputed here.
  *
  * @param {ManifoldStore} manifolds
- * @param {Transform[]} transforms
+ * @param {Transform64[]} transforms
  */
 export function refresh_contacts(manifolds, transforms) {
     const count = g_contact_count;