@woosh/meep-engine 3.21.0 → 3.23.0

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

@@ -5,6 +5,12 @@
  * pre-upgrade behaviour.
  */
 export class RigidBodySerializationUpgrader_0_1 extends BinaryClassUpgrader {
+    /**
+     *
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     */
+    upgrade(source: BinaryBuffer, target: BinaryBuffer): void;
 }
 import { BinaryClassUpgrader } from "../../ecs/storage/binary/BinaryClassUpgrader.js";
 //# sourceMappingURL=RigidBodySerializationUpgrader_0_1.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"RigidBodySerializationUpgrader_0_1.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBodySerializationUpgrader_0_1.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;CA4BC;oCApCmC,iDAAiD"}
+{"version":3,"file":"RigidBodySerializationUpgrader_0_1.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/RigidBodySerializationUpgrader_0_1.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IAKI;;;;OAIG;IACH,0DAiBC;CACJ;oCApCmC,iDAAiD"}

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

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#380@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#383@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#380@#clear_field"(fluid: FluidComponent): void;
+    static "__#383@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#380@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#383@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#380@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#383@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];

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

@@ -58,34 +58,37 @@
  * 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`
  */
-export function compute_penetration(out_direction: Float64Array | number[], shape_a: AbstractShape3D, position_a: {
-    x: number;
-    y: number;
-    z: number;
-}, rotation_a: {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}, shape_b: AbstractShape3D, position_b: {
-    x: number;
-    y: number;
-    z: number;
-}, rotation_b: {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-}): number;
+export function compute_penetration(out_direction: Float64Array | number[], shape_a: AbstractShape3D, position_a: ArrayLike<number>, rotation_a: ArrayLike<number>, shape_b: AbstractShape3D, position_b: ArrayLike<number>, rotation_b: ArrayLike<number>): number;
 //# sourceMappingURL=compute_penetration.d.ts.map

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/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

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,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;4BAptD2B,oCAAoC"}
+{"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

@@ -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) {

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/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
@@ -73,10 +80,5 @@ export function shape_cast(system: PhysicsSystem, ray: Ray3 | {
     direction_y: number;
     direction_z: number;
     tMax: number;
-}, 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;
+}, 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,uDAxBW,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;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,wCAErC,CAAC,MAAM,EAAC,MAAM,EAAE,QAAQ,UAAS,EAAE,OAAO,EAAC,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

@@ -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/platform/EnginePlatform.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("../achievements/AchievementGateway.js").AchievementGateway} AchievementGateway
+ */
 export class EnginePlatform {
     /**
      * @returns {Storage}
@@ -21,4 +24,5 @@ export class EnginePlatform {
      */
     shutdown(): Promise<any>;
 }
+export type AchievementGateway = import("../achievements/AchievementGateway.js").AchievementGateway;
 //# sourceMappingURL=EnginePlatform.d.ts.map

package/src/engine/platform/EnginePlatform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnginePlatform.d.ts","sourceRoot":"","sources":["../../../../src/engine/platform/EnginePlatform.js"],"names":[],"mappings":"AAAA;IACI;;OAEG;IACH,cAFa,OAAO,CAInB;IAED;;OAEG;IACH,4CAEC;IAED;;;OAGG;IACH,2BAHW,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;OAEG;IACH,wBAEC;IAED;;OAEG;IACH,yBAEC;CAEJ"}
+{"version":3,"file":"EnginePlatform.d.ts","sourceRoot":"","sources":["../../../../src/engine/platform/EnginePlatform.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;IACI;;OAEG;IACH,cAFa,OAAO,CAInB;IAED;;OAEG;IACH,yBAFa,kBAAkB,CAI9B;IAED;;;OAGG;IACH,2BAHW,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;OAEG;IACH,wBAEC;IAED;;OAEG;IACH,yBAEC;CAEJ;iCAxCY,OAAO,uCAAuC,EAAE,kBAAkB"}

package/src/engine/platform/EnginePlatform.js

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import("../achievements/AchievementGateway.js").AchievementGateway} AchievementGateway
+ */
+
 export class EnginePlatform {
     /**
      * @returns {Storage}

package/src/engine/plugin/EnginePlugin.d.ts

@@ -1,3 +1,10 @@
+/**
+ * @template [T=any]
+ * @typedef {import("../../core/primitives/Class.js").Class<T>} Class
+ */
+/**
+ * @typedef {import("../Engine.js").default} Engine
+ */
 /**
  * Generally wired in via {@link Engine.plugins}
  */
@@ -35,5 +42,7 @@ export class EnginePlugin extends BaseProcess {
      */
     shutdown(): Promise<any>;
 }
+export type Class<T = any> = import("../../core/primitives/Class.js").Class<T>;
+export type Engine = import("../Engine.js").default;
 import { BaseProcess } from "../../core/process/BaseProcess.js";
 //# sourceMappingURL=EnginePlugin.d.ts.map

package/src/engine/plugin/EnginePlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnginePlugin.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePlugin.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAEI;;;;OAIG;IACH,uBAAoB;IAEpB;;;OAGG;IACH,QAFU,SAAO,IAAI,CAEP;IAEd,eAYC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,iCAQC;IAOD;;;OAGG;IACH,wBAIC;IAGD;;;OAGG;IACH,yBAIC;CACJ;4BAjF2B,mCAAmC"}
+{"version":3,"file":"EnginePlugin.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePlugin.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;GAEG;AAEH;;GAEG;AACH;IAEI;;;;OAIG;IACH,uBAAoB;IAEpB;;;OAGG;IACH,QAFU,MAAM,GAAC,IAAI,CAEP;IAEd,eAYC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAUhB;IAOD;;;OAGG;IACH,wBAIC;IAGD;;;OAGG;IACH,yBAIC;CACJ;6BAtFY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;qBAIjD,OAAO,cAAc,EAAE,OAAO;4BARf,mCAAmC"}

package/src/engine/plugin/EnginePlugin.js

@@ -1,6 +1,15 @@
 import { assert } from "../../core/assert.js";
 import { BaseProcess } from "../../core/process/BaseProcess.js";
 
+/**
+ * @template [T=any]
+ * @typedef {import("../../core/primitives/Class.js").Class<T>} Class
+ */
+
+/**
+ * @typedef {import("../Engine.js").default} Engine
+ */
+
 /**
  * Generally wired in via {@link Engine.plugins}
  */

package/src/engine/plugin/EnginePluginManager.d.ts

@@ -1,3 +1,11 @@
+/**
+ * @template [T=any]
+ * @typedef {import("../../core/primitives/Class.js").Class<T>} Class
+ */
+/**
+ * @typedef {import("../Engine.js").default} Engine
+ * @typedef {import("../reference/v2/Reference.js").Reference} Reference
+ */
 export class EnginePluginManager extends BaseProcess {
     /**
      * @private
@@ -60,13 +68,13 @@ export class EnginePluginManager extends BaseProcess {
      * @param {Class<T>} PluginClass
      * @returns {Promise<Reference<T>>}
      */
-    acquire<T>(PluginClass: Class<T>): Promise<Reference<T>>;
+    acquire<T>(PluginClass: Class<T>): Promise<any>;
     /**
      *
      * @param {Class[]} PluginClasses
      * @returns {Promise<Reference[]>}
      */
-    acquireMany(PluginClasses: Class[]): Promise<Reference[]>;
+    acquireMany(PluginClasses: Class[]): Promise<import("../reference/v2/Reference.js").Reference<any>[]>;
     /**
      * @template T
      * @param {Class<T>} PluginClass
@@ -80,6 +88,9 @@ export class EnginePluginManager extends BaseProcess {
      */
     getById<T_2>(id: string): EnginePlugin | T_2;
 }
+export type Class<T = any> = import("../../core/primitives/Class.js").Class<T>;
+export type Engine = import("../Engine.js").default;
+export type Reference = import("../reference/v2/Reference.js").Reference<any>;
 import { BaseProcess } from "../../core/process/BaseProcess.js";
 import { EnginePlugin } from "./EnginePlugin.js";
 //# sourceMappingURL=EnginePluginManager.d.ts.map

package/src/engine/plugin/EnginePluginManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnginePluginManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePluginManager.js"],"names":[],"mappings":"AAOA;IAEI;;;OAGG;IACH,kBAAsB;IAEtB;;;OAGG;IACH,eAAc;IAEd;;;;OAIG;IACH,kBAAc;IAEd;;;;OAIG;IACH,mCAYC;IAED;;;;OAIG;IACH,kCAYC;IAGD;;;;;;OAMG;IACH,qCA0BC;IAED;;;;;OAKG;IACH,uCA2BC;IAED;;;;OAIG;IACH,+CAaC;IAED;;;OAGG;IACH,iCAgBC;IAkBD,yBAIC;IAED,0BAIC;IAED;;;;OAIG;IACH,mCAFa,qBAAqB,CAyDjC;IAED;;;;OAIG;IACH,2BAHW,OAAO,GACL,QAAQ,WAAW,CAAC,CAQhC;IAED;;;;OAIG;IACH,6CAaC;IAED;;;;OAIG;IACH,iBAHW,MAAM,sBAahB;CACJ;4BA9T2B,mCAAmC;6BAElC,mBAAmB"}
+{"version":3,"file":"EnginePluginManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/plugin/EnginePluginManager.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;;;GAGG;AAEH;IAEI;;;OAGG;IACH,kBAAsB;IAEtB;;;OAGG;IACH,QAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,kBAAc;IAEd;;;;OAIG;IACH,mCAYC;IAED;;;;OAIG;IACH,kCAYC;IAGD;;;;;;OAMG;IACH,qCA0BC;IAED;;;;;OAKG;IACH,uCA2BC;IAED;;;;OAIG;IACH,+CAaC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAkBhB;IAkBD,yBAIC;IAED,0BAIC;IAED;;;;OAIG;IACH,gDAuDC;IAED;;;;OAIG;IACH,2BAHW,KAAK,EAAE,GACL,QAAQ,uDAAW,CAAC,CAQhC;IAED;;;;OAIG;IACH,6CAaC;IAED;;;;OAIG;IACH,iBAHW,MAAM,sBAahB;CACJ;6BA/TY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;qBAIjD,OAAO,cAAc,EAAE,OAAO;;4BAbf,mCAAmC;6BAElC,mBAAmB"}

package/src/engine/plugin/EnginePluginManager.js

@@ -5,6 +5,16 @@ import { PluginReferenceContext } from "./PluginReferenceContext.js";
 import { isSubclassOf } from "./isSubclassOf.js";
 import { assert } from "../../core/assert.js";
 
+/**
+ * @template [T=any]
+ * @typedef {import("../../core/primitives/Class.js").Class<T>} Class
+ */
+
+/**
+ * @typedef {import("../Engine.js").default} Engine
+ * @typedef {import("../reference/v2/Reference.js").Reference} Reference
+ */
+
 export class EnginePluginManager extends BaseProcess {
 
     /**

package/src/engine/save/StorageBackedList.d.ts

@@ -19,10 +19,14 @@ export class StorageBackedSet<T> {
     private lastPromise;
     /**
      *
-     * @param {string} key
-     * @param {Storage} storage
-     */
-    initialize({ key, storage }: string): void;
+     * @param {Object} options
+     * @param {string} options.key
+     * @param {Storage} options.storage
+     */
+    initialize({ key, storage }: {
+        key: string;
+        storage: Storage;
+    }): void;
     /**
      *
      * @return {Promise<T[]>}

package/src/engine/save/StorageBackedList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StorageBackedList.d.ts","sourceRoot":"","sources":["../../../../src/engine/save/StorageBackedList.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAEI;;;OAGG;IACH,KAFU,MAAM,CAEP;IACT;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,oBAAgC;IAGhC;;;;OAIG;IACH,6BAHW,MAAM,QAShB;IAED;;;OAGG;IACH,QAFY,QAAQ,CAAC,EAAE,CAAC,CAiCvB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACA,QAAQ,CAAC,EAAE,CAAC,CAoBvB;IAED;;;;OAIG;IACH,gBAHW,CAAC,GACA,QAAQ,OAAO,CAAC,CAU3B;IAGD;;;OAGG;IACH,cAHW,CAAC,GACC,QAAQ,OAAO,CAAC,CAqB5B;CACJ"}
+{"version":3,"file":"StorageBackedList.d.ts","sourceRoot":"","sources":["../../../../src/engine/save/StorageBackedList.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAEI;;;OAGG;IACH,KAFU,MAAM,CAEP;IACT;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,oBAAgC;IAGhC;;;;;OAKG;IACH;QAH2B,GAAG,EAAnB,MAAM;QACW,OAAO,EAAxB,OAAO;aAQjB;IAED;;;OAGG;IACH,QAFY,QAAQ,CAAC,EAAE,CAAC,CAiCvB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACA,QAAQ,CAAC,EAAE,CAAC,CAoBvB;IAED;;;;OAIG;IACH,gBAHW,CAAC,GACA,QAAQ,OAAO,CAAC,CAU3B;IAGD;;;OAGG;IACH,cAHW,CAAC,GACC,QAAQ,OAAO,CAAC,CAqB5B;CACJ"}

package/src/engine/save/StorageBackedList.js

@@ -27,8 +27,9 @@ export class StorageBackedSet {
 
     /**
      *
-     * @param {string} key
-     * @param {Storage} storage
+     * @param {Object} options
+     * @param {string} options.key
+     * @param {Storage} options.storage
      */
     initialize({ key, storage }) {
         assert.defined(storage, 'storage');

package/src/engine/scene/Scene.d.ts

@@ -1,4 +1,14 @@
 export default Scene;
+export type LinearModifier = import("../../core/model/stat/LinearModifier.js").default;
+export type Task = import("../../core/process/task/Task.js").Task;
+export type TaskGroup = import("../../core/process/task/TaskGroup.js").default;
+export type Engine = import("../Engine.js").default;
+/**
+ * @typedef {import("../../core/model/stat/LinearModifier.js").default} LinearModifier
+ * @typedef {import("../../core/process/task/Task.js").Task} Task
+ * @typedef {import("../../core/process/task/TaskGroup.js").default} TaskGroup
+ * @typedef {import("../Engine.js").default} Engine
+ */
 declare class Scene {
     /**
      *

package/src/engine/scene/Scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../../src/engine/scene/Scene.js"],"names":[],"mappings":";AAKA;IAyBI;;;;OAIG;IACH,mBAHW,MAAM,EAShB;IAnCD;;;OAGG;IACH,SAFU,sBAAsB,CAEO;IAEvC;;;OAGG;IACH,iBAFU,eAAe,CAEW;IAEpC;;;OAGG;IACH,WAFU,OAAO,CAEC;IAElB;;;OAGG;IACH,gBAFU,oBAAoB,CAEF;IAQxB;;;OAGG;IACH,MAFU,MAAM,CAEA;IAGpB;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;;;OAOG;IACH,2EAFa,gBAAc,CAQ1B;IAED,wDACC;IAED,cAEC;CACJ;uCA1FsC,kCAAkC;4BAF7C,qCAAqC;iBADhD,oCAAoC"}
+{"version":3,"file":"Scene.d.ts","sourceRoot":"","sources":["../../../../src/engine/scene/Scene.js"],"names":[],"mappings":";6BAMa,OAAO,yCAAyC,EAAE,OAAO;mBACzD,OAAO,iCAAiC,EAAE,IAAI;wBAC9C,OAAO,sCAAsC,EAAE,OAAO;qBACtD,OAAO,cAAc,EAAE,OAAO;AAJ3C;;;;;GAKG;AAEH;IAyBI;;;;OAIG;IACH,mBAHW,MAAM,EAShB;IAnCD;;;OAGG;IACH,SAFU,sBAAsB,CAEO;IAEvC;;;OAGG;IACH,iBAFU,eAAe,CAEW;IAEpC;;;OAGG;IACH,WAFU,OAAO,CAEC;IAElB;;;OAGG;IACH,gBAFU,KAAK,cAAc,CAAC,CAEF;IAQxB;;;OAGG;IACH,MAFU,MAAM,CAEA;IAGpB;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;;;OAOG;IACH,4BALW,MAAM,yCAGJ,IAAI,GAAC,SAAS,CAQ1B;IAED,wDACC;IAED,cAEC;CACJ;uCAjGsC,kCAAkC;4BAF7C,qCAAqC;iBADhD,oCAAoC"}

package/src/engine/scene/Scene.js

@@ -3,6 +3,13 @@ import ObservedBoolean from "../../core/model/ObservedBoolean.js";
 import { promiseTask } from "../../core/process/task/util/promiseTask.js";
 import { EntityComponentDataset } from "../ecs/EntityComponentDataset.js";
 
+/**
+ * @typedef {import("../../core/model/stat/LinearModifier.js").default} LinearModifier
+ * @typedef {import("../../core/process/task/Task.js").Task} Task
+ * @typedef {import("../../core/process/task/TaskGroup.js").default} TaskGroup
+ * @typedef {import("../Engine.js").default} Engine
+ */
+
 class Scene {
     /**
      *

package/src/engine/scene/SceneManager.d.ts

@@ -1,4 +1,8 @@
 export default SceneManager;
+export type Clock = import("../Clock.js").default;
+/**
+ * @typedef {import("../Clock.js").default} Clock
+ */
 declare class SceneManager {
     /**
      *

package/src/engine/scene/SceneManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/scene/SceneManager.js"],"names":[],"mappings":";AAKA;IA0CI;;;;;OAKG;IACH,2BAJW,aAAa,gBAgBvB;IArDD;;;OAGG;IACH,2BAEC;IAQD;;;OAGG;IACH,oCAEC;IAED;;OAEG;IACH,QAFU,KAAK,KAAK,CAAC,CAED;IAEpB;;;;;OAKG;IACH,uBAAW;IAeP;;;OAGG;IACH,aAAkB;IAGtB;;;;OAIG;IACH,aAHW,MAAM,GACJ,KAAK,CAQjB;IAED;;;OAGG;IACH,WAFW,KAAK,QAQf;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAalB;IAED;;;;OAIG;IACH,mBAHW,MAAM,aAOhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAqBnB;IAED;;;OAGG;IACH,SAFa,YAAY,CAcxB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,wBA+BC;IAED;;;OAGG;IACH,sBA2BC;IAED;;OAEG;IACH,+BAQC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;;OAGG;IACH,UAFW,MAAM,QAqBhB;IAED;;;OAGG;IACH,cAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,YAFa,MAAM,CAQlB;IAED;;OAEG;IACH,kBAEC;IAED,6BAEC;;CACJ;kBAzUiB,YAAY;8BADA,yBAAyB;iBADtC,oCAAoC"}
+{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/scene/SceneManager.js"],"names":[],"mappings":";oBAKa,OAAO,aAAa,EAAE,OAAO;AAD1C;;GAEG;AAGH;IA0CI;;;;;OAKG;IACH,2BAJW,aAAa,SACb,KAAK,EAef;IArDD;;;OAGG;IACH,2BAEC;IAQD;;;OAGG;IACH,oCAEC;IAED;;OAEG;IACH,QAFU,KAAK,KAAK,CAAC,CAED;IAEpB;;;;;OAKG;IACH,uBAAW;IAeP;;;OAGG;IACH,OAFU,KAAK,CAEG;IAGtB;;;;OAIG;IACH,aAHW,MAAM,GACJ,KAAK,CAQjB;IAED;;;OAGG;IACH,WAFW,KAAK,QAQf;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAalB;IAED;;;;OAIG;IACH,mBAHW,MAAM,aAOhB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAqBnB;IAED;;;OAGG;IACH,SAFa,YAAY,CAcxB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,wBA+BC;IAED;;;OAGG;IACH,sBA2BC;IAED;;OAEG;IACH,+BAQC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;;OAGG;IACH,UAFW,MAAM,QAqBhB;IAED;;;OAGG;IACH,cAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,YAFa,MAAM,CAQlB;IAED;;OAEG;IACH,kBAEC;IAED,6BAEC;;CACJ;kBA7UiB,YAAY;8BADA,yBAAyB;iBADtC,oCAAoC"}