@woosh/meep-engine 2.146.0 → 2.148.0

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

@@ -1,196 +1,229 @@
-import { assert } from "../../../../core/assert.js";
-import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
-import { PhysicsSystem } from "../../../physics/ecs/PhysicsSystem.js";
-import { PhysicsSurfacePoint } from "../../../physics/queries/PhysicsSurfacePoint.js";
-import { System } from "../../../ecs/System.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
-import { FirstPersonPlayerController } from "../FirstPersonPlayerController.js";
-import { FirstPersonPlayerControllerSystem } from "../FirstPersonPlayerControllerSystem.js";
-
-/**
- * Populates the {@link FirstPersonSensors} struct on each controller
- * entity, once per fixed step. Designed to run BEFORE the main
- * {@link FirstPersonPlayerControllerSystem} `fixedUpdate` so abilities
- * see fresh sensor data on the same tick.
- *
- * Raycasts go through {@link PhysicsSystem.raycast} — BVH-backed,
- * static + dynamic broadphase. The player's own body is excluded via a
- * per-call filter so downward probes don't collide with the player's
- * own capsule.
- *
- * BVH raycasts are cheap (~1000/frame at 60Hz is comfortable), so this
- * system doesn't aggressively optimize. NPC controllers that don't
- * need sensors can simply not have this system attached.
- *
- * Sensor data lives at `runtime.sensors` on the
- * {@link FirstPersonPlayerControllerSystem}'s per-entity runtime.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class FirstPersonSensorsSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [FirstPersonPlayerController, Transform];
-
-        /**
-         * Reference to the controller system — needed to look up each
-         * entity's per-controller runtime (which owns the sensors slot).
-         * Auto-acquired in startup; can be overridden by the caller.
-         * @type {FirstPersonPlayerControllerSystem|null}
-         */
-        this.controllerSystem = null;
-
-        /**
-         * Physics system used as the spatial-query backend. Auto-acquired
-         * in startup; can be overridden. Required — sensors are unusable
-         * without it.
-         * @type {PhysicsSystem|null}
-         */
-        this.physicsSystem = null;
-
-        /**
-         * Pre-allocated raycast query primitive. Refilled in place per
-         * {@link _probeRay} call so the system doesn't allocate a new
-         * `Ray3` every probe.
-         * @private
-         * @type {Ray3}
-         */
-        this._probe_ray = new Ray3();
-
-        /**
-         * Pre-allocated raycast result. Refilled in place per probe;
-         * gameplay-visible sensor fields are copied out before the next
-         * probe overwrites it.
-         * @private
-         * @type {PhysicsSurfacePoint}
-         */
-        this._probe_hit = new PhysicsSurfacePoint();
-    }
-
-    async startup(entityManager) {
-        this.entityManager = entityManager;
-
-        // Auto-acquire collaborators if they're already in the world.
-        // Caller can still override either field before fixedUpdate runs.
-        if (this.controllerSystem === null) {
-            const cs = entityManager.getSystem(FirstPersonPlayerControllerSystem);
-            if (cs !== null) this.controllerSystem = cs;
-        }
-        if (this.physicsSystem === null) {
-            const ps = entityManager.getSystem(PhysicsSystem);
-            if (ps !== null) this.physicsSystem = ps;
-        }
-    }
-
-    fixedUpdate(dt) {
-        const ecd = this.entityManager.dataset;
-        if (ecd === null) return;
-        ecd.traverseComponents(FirstPersonPlayerController, this._populateForEntity, this);
-    }
-
-    /**
-     * @private
-     */
-    _populateForEntity(controller, entity) {
-        // Sensors live on the per-entity runtime owned by the
-        // controller's own system. Look it up by entity — no leakage
-        // through the controller component itself.
-        if (this.controllerSystem === null) return; // not wired up
-        const runtime = this.controllerSystem.getRuntime(entity);
-        if (runtime === undefined) return;
-        const sensors = runtime.sensors;
-        if (sensors === undefined || sensors === null) return;
-
-        // Sensors are useless without physics. Assert at the first
-        // populate; the misconfiguration would otherwise show up as
-        // mysteriously inert abilities.
-        assert.notEqual(this.physicsSystem, null,
-            "FirstPersonSensorsSystem requires a PhysicsSystem to be in the world. "
-            + "Add it before this system, or set `sensorsSystem.physicsSystem` "
-            + "explicitly.");
-
-        const ecd = this.entityManager.dataset;
-        const transform = ecd.getComponent(entity, Transform);
-        if (transform === undefined) return;
-
-        sensors.clearAll();
-
-        // Probe origin: at chest height (approx body height × 0.65).
-        const cfg = controller.config;
-        const chestY = cfg.body.height * 0.65;
-        const ox = transform.position.x;
-        const oy = transform.position.y + chestY;
-        const oz = transform.position.z;
-
-        // Body-local forward + right (engine-local axes — see DESIGN.md
-        // §5.3 for the conventions). bodyYaw lives on the runtime.
-        const yaw = runtime.bodyYaw;
-        const fx = Math.sin(yaw);
-        const fz = Math.cos(yaw);
-        const rx = Math.cos(yaw);
-        const rz = -Math.sin(yaw);
-
-        const wallProbeDist = cfg.body.radius * 2 + 0.05; // just past the capsule
-        const obstacleProbeDist = 1.2; // ~one stride
-
-        // Wall left: probe along -right.
-        this._probeRay(sensors.wallLeft, ox, oy, oz, -rx, 0, -rz, wallProbeDist, entity);
-        // Wall right: probe along +right.
-        this._probeRay(sensors.wallRight, ox, oy, oz, rx, 0, rz, wallProbeDist, entity);
-        // Wall front: probe along +forward.
-        this._probeRay(sensors.wallFront, ox, oy, oz, fx, 0, fz, wallProbeDist, entity);
-        // Obstacle ahead: same direction as wallFront but longer reach.
-        // Used by mantle/vault; the consumer compares the hit altitude to
-        // the body height to decide vault vs. mantle vs. neither.
-        this._probeRay(sensors.obstacleAhead, ox, oy, oz, fx, 0, fz, obstacleProbeDist, entity);
-
-        // Ledge ahead — only meaningful if obstacleAhead hit something
-        // around chest height: probe down from just past the top of the
-        // obstacle, look for ground.
-        if (sensors.obstacleAhead.hit) {
-            const topY = transform.position.y + cfg.body.height + 0.1;
-            const px = sensors.obstacleAhead.point.x + fx * 0.3;
-            const pz = sensors.obstacleAhead.point.z + fz * 0.3;
-            this._probeRay(
-                sensors.ledgeAhead,
-                px, topY, pz,
-                0, -1, 0,
-                cfg.body.height * 0.5,
-                entity,
-            );
-        }
-    }
-
-    /**
-     * Raycast through {@link PhysicsSystem.raycast}, populating the slot
-     * if anything is hit. Direction is assumed unit (the controller's
-     * callers pass body-local unit axes).
-     *
-     * The raycast now writes the AABB face normal into `_probe_hit.normal`,
-     * which is exact for AABB-shaped colliders (the common case in our gym)
-     * and a stable approximation elsewhere. Future narrowphase refinement
-     * will replace this with the true shape normal at the same call site.
-     *
-     * @private
-     */
-    _probeRay(slot, ox, oy, oz, dx, dy, dz, maxDist, excludeEntity) {
-        // Exclude the player's own body from the result — downward
-        // probes from chest start inside the capsule, would otherwise
-        // hit the capsule's bottom hemisphere.
-        const ray = this._probe_ray;
-        ray.setOrigin(ox, oy, oz);
-        ray.setDirection(dx, dy, dz);
-        ray.tMax = maxDist;
-        const filter = (e) => e !== excludeEntity;
-        const out = this._probe_hit;
-        if (!this.physicsSystem.raycast(ray, out, filter)) return;
-
-        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);
-        slot.surfaceTag = null; // future: surface-tag lookup
-    }
-}
+import { assert } from "../../../../core/assert.js";
+import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
+import { PhysicsSystem } from "../../../physics/ecs/PhysicsSystem.js";
+import { PhysicsSurfacePoint } from "../../../physics/queries/PhysicsSurfacePoint.js";
+import { System } from "../../../ecs/System.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { FirstPersonPlayerController } from "../FirstPersonPlayerController.js";
+import { FirstPersonPlayerControllerSystem } from "../FirstPersonPlayerControllerSystem.js";
+
+/**
+ * Populates the {@link FirstPersonSensors} struct on each controller
+ * entity, once per fixed step. Designed to run BEFORE the main
+ * {@link FirstPersonPlayerControllerSystem} `fixedUpdate` so abilities
+ * see fresh sensor data on the same tick.
+ *
+ * Raycasts go through {@link PhysicsSystem.raycast} — BVH-backed,
+ * static + dynamic broadphase. The player's own body is excluded via a
+ * per-call filter so downward probes don't collide with the player's
+ * own capsule.
+ *
+ * BVH raycasts are cheap (~1000/frame at 60Hz is comfortable), so this
+ * system doesn't aggressively optimize. NPC controllers that don't
+ * need sensors can simply not have this system attached.
+ *
+ * Sensor data lives at `runtime.sensors` on the
+ * {@link FirstPersonPlayerControllerSystem}'s per-entity runtime.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class FirstPersonSensorsSystem extends System {
+    constructor() {
+        super();
+
+        this.dependencies = [FirstPersonPlayerController, Transform];
+
+        /**
+         * Reference to the controller system — needed to look up each
+         * entity's per-controller runtime (which owns the sensors slot).
+         * Auto-acquired in startup; can be overridden by the caller.
+         * @type {FirstPersonPlayerControllerSystem|null}
+         */
+        this.controllerSystem = null;
+
+        /**
+         * Physics system used as the spatial-query backend. Auto-acquired
+         * in startup; can be overridden. Required — sensors are unusable
+         * without it.
+         * @type {PhysicsSystem|null}
+         */
+        this.physicsSystem = null;
+
+        /**
+         * Pre-allocated raycast query primitive. Refilled in place per
+         * {@link _probeRay} call so the system doesn't allocate a new
+         * `Ray3` every probe.
+         * @private
+         * @type {Ray3}
+         */
+        this._probe_ray = new Ray3();
+
+        /**
+         * Pre-allocated raycast result. Refilled in place per probe;
+         * gameplay-visible sensor fields are copied out before the next
+         * probe overwrites it.
+         * @private
+         * @type {PhysicsSurfacePoint}
+         */
+        this._probe_hit = new PhysicsSurfacePoint();
+    }
+
+    async startup(entityManager) {
+        this.entityManager = entityManager;
+
+        // Auto-acquire collaborators if they're already in the world.
+        // Caller can still override either field before fixedUpdate runs.
+        if (this.controllerSystem === null) {
+            const cs = entityManager.getSystem(FirstPersonPlayerControllerSystem);
+            if (cs !== null) this.controllerSystem = cs;
+        }
+        if (this.physicsSystem === null) {
+            const ps = entityManager.getSystem(PhysicsSystem);
+            if (ps !== null) this.physicsSystem = ps;
+        }
+    }
+
+    fixedUpdate(dt) {
+        const ecd = this.entityManager.dataset;
+        if (ecd === null) return;
+        ecd.traverseComponents(FirstPersonPlayerController, this._populateForEntity, this);
+    }
+
+    /**
+     * @private
+     */
+    _populateForEntity(controller, entity) {
+        // Sensors live on the per-entity runtime owned by the
+        // controller's own system. Look it up by entity — no leakage
+        // through the controller component itself.
+        if (this.controllerSystem === null) return; // not wired up
+        const runtime = this.controllerSystem.getRuntime(entity);
+        if (runtime === undefined) return;
+        const sensors = runtime.sensors;
+        if (sensors === undefined || sensors === null) return;
+
+        // Sensors are useless without physics. Assert at the first
+        // populate; the misconfiguration would otherwise show up as
+        // mysteriously inert abilities.
+        assert.notEqual(this.physicsSystem, null,
+            "FirstPersonSensorsSystem requires a PhysicsSystem to be in the world. "
+            + "Add it before this system, or set `sensorsSystem.physicsSystem` "
+            + "explicitly.");
+
+        const ecd = this.entityManager.dataset;
+        const transform = ecd.getComponent(entity, Transform);
+        if (transform === undefined) return;
+
+        sensors.clearAll();
+
+        // Probe origin: at chest height (approx body height × 0.65).
+        const cfg = controller.config;
+        const chestY = cfg.body.height * 0.65;
+        const ox = transform.position.x;
+        const oy = transform.position.y + chestY;
+        const oz = transform.position.z;
+
+        // Body-local forward + right (engine-local axes — see DESIGN.md
+        // §5.3 for the conventions). bodyYaw lives on the runtime.
+        const yaw = runtime.bodyYaw;
+        const fx = Math.sin(yaw);
+        const fz = Math.cos(yaw);
+        const rx = Math.cos(yaw);
+        const rz = -Math.sin(yaw);
+
+        const wallProbeDist = cfg.body.radius * 2 + 0.05; // just past the capsule
+        const obstacleProbeDist = 1.2; // ~one stride
+
+        // Wall left: probe along -right.
+        this._probeRay(sensors.wallLeft, ox, oy, oz, -rx, 0, -rz, wallProbeDist, entity);
+        // Wall right: probe along +right.
+        this._probeRay(sensors.wallRight, ox, oy, oz, rx, 0, rz, wallProbeDist, entity);
+        // Wall front: probe along +forward.
+        this._probeRay(sensors.wallFront, ox, oy, oz, fx, 0, fz, wallProbeDist, entity);
+        // Obstacle ahead: same direction as wallFront but longer reach.
+        // Used by mantle/vault; the consumer compares the hit altitude to
+        // the body height to decide vault vs. mantle vs. neither.
+        this._probeRay(sensors.obstacleAhead, ox, oy, oz, fx, 0, fz, obstacleProbeDist, entity);
+
+        // Ledge ahead — only meaningful if obstacleAhead hit something
+        // around chest height: probe down from just past the top of the
+        // obstacle, look for ground.
+        if (sensors.obstacleAhead.hit) {
+            const topY = transform.position.y + cfg.body.height + 0.1;
+            const px = sensors.obstacleAhead.point.x + fx * 0.3;
+            const pz = sensors.obstacleAhead.point.z + fz * 0.3;
+            this._probeRay(
+                sensors.ledgeAhead,
+                px, topY, pz,
+                0, -1, 0,
+                cfg.body.height * 0.5,
+                entity,
+            );
+        }
+
+        // Can the player STAND on that ledge, or only HANG from it? Probe
+        // straight down a capsule-width forward of the grab edge: if the top
+        // surface is still there a standing capsule fits; if it has dropped
+        // away it's a thin wall / knife-edge you could only hang from. Mantle
+        // reads this to refuse vaulting onto a top it would fall right off.
+        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,
+                entity,
+            );
+        }
+    }
+
+    /**
+     * Down-probe a point on (or just past) a ledge top: returns true if a
+     * surface is still there near `edgeY` — i.e. the top is wide enough for a
+     * standing capsule. A miss (or a much-lower hit) means the surface dropped
+     * away: a thin wall / lip you can only hang from, not stand on.
+     * @private
+     */
+    _probeStandable(px, edgeY, pz, excludeEntity) {
+        const ray = this._probe_ray;
+        ray.setOrigin(px, edgeY + 0.2, pz);
+        ray.setDirection(0, -1, 0);
+        ray.tMax = 0.4;
+        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
+    }
+
+    /**
+     * Raycast through {@link PhysicsSystem.raycast}, populating the slot
+     * if anything is hit. Direction is assumed unit (the controller's
+     * callers pass body-local unit axes).
+     *
+     * The raycast now writes the AABB face normal into `_probe_hit.normal`,
+     * which is exact for AABB-shaped colliders (the common case in our gym)
+     * and a stable approximation elsewhere. Future narrowphase refinement
+     * will replace this with the true shape normal at the same call site.
+     *
+     * @private
+     */
+    _probeRay(slot, ox, oy, oz, dx, dy, dz, maxDist, excludeEntity) {
+        // Exclude the player's own body from the result — downward
+        // probes from chest start inside the capsule, would otherwise
+        // hit the capsule's bottom hemisphere.
+        const ray = this._probe_ray;
+        ray.setOrigin(ox, oy, oz);
+        ray.setDirection(dx, dy, dz);
+        ray.tMax = maxDist;
+        const filter = (e) => e !== excludeEntity;
+        const out = this._probe_hit;
+        if (!this.physicsSystem.raycast(ray, out, filter)) return;
+
+        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);
+        slot.surfaceTag = null; // future: surface-tag lookup
+    }
+}

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

@@ -75,14 +75,6 @@ export class EntityManager {
      * @type {EntityManagerState}
      */
     state: EntityManagerState;
-    /**
-     * Track remainders of simulation time for fixed step
-     * Needed for accurate time keeping
-     * @private
-     * @readonly
-     * @type {Map<System, number>}
-     */
-    private readonly systemAccumulatedFixedStepTime;
     /**
      * Value used to execute {@link System.fixedUpdate}
      * In seconds.
@@ -95,12 +87,32 @@ export class EntityManager {
      */
     fixedUpdateStepSize: number;
     /**
-     * How long can any given system run it's {@link System.fixedUpdate}, per simulation update
-     * This is value allows us to avoid cases where {@link System.fixedUpdate} takes longer that its time step and causes a runaway freeze
-     * In milliseconds.
+     * Wall-clock budget, in milliseconds, for the whole fixed-step catch-up loop
+     * within a single {@link simulate} call. Once a cycle's accumulated
+     * fixedUpdate work exceeds this, the loop stops early and the unconsumed time
+     * stays in the accumulator to be caught up later — this avoids a runaway
+     * freeze when {@link System.fixedUpdate} work outpaces its time step. (Now a
+     * per-cycle budget across all systems' lock-step steps; previously per-system.)
      * @type {number}
      */
     fixedUpdatePerSystemExecutionTimeLimit: number;
+    /**
+     * Monotonic **simulation tick id** — the count of fixed steps the simulation
+     * has executed. Advances once per {@link fixedUpdateStepSize} step inside
+     * {@link simulate}. This is the hub-owned identity that producers (physics,
+     * network) stamp per-tick state with, and that render-rate consumers
+     * (interpolation) read as "the latest completed step". Pairs with
+     * {@link getFixedStepAlpha}.
+     * @type {number}
+     */
+    fixedStepTick: number;
+    /**
+     * Canonical fixed-step time accumulator backing {@link fixedStepTick} and
+     * {@link getFixedStepAlpha}. Holds the sub-step remainder in `[0, step)`.
+     * @private
+     * @type {number}
+     */
+    private __fixedStepAccumulator;
     /**
      * Currently attached dataset.
      * Do not modify directly, instead use {@link attachDataset} and {@link detachDataset} respectively.
@@ -160,6 +172,17 @@ export class EntityManager {
      * @param {number} time_delta_seconds in seconds
      */
     simulate(time_delta_seconds: number): void;
+    /**
+     * Fractional progress through the current fixed step, in `[0, 1)` — the
+     * leftover sim time that hasn't yet formed a whole {@link fixedUpdateStepSize}
+     * step, normalized by the step size. This is the blend parameter the
+     * render-time interpolation system pairs with {@link fixedStepTick} to
+     * interpolate between the last two completed steps: `alpha = 0` sits on the
+     * previous tick, `alpha → 1` approaches the latest.
+     *
+     * @returns {number} alpha in `[0, 1)`
+     */
+    getFixedStepAlpha(): number;
     /**
      * If the {@link EntityManager} is already started, the system will be started automatically before being added
      * @param {System} system

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,iCAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;qBADO,uCAAc;;MAI1B;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;OAMG;IACH,gDAA2C;IAE3C;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IAEf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BAmFC;IAED;;;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,6BAFW,MAAM,QAyEhB;IAED;;;;;OAKG;IACH,iEA6DC;IAED;;;;OAIG;IACH,uDAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAmCC;IAED;;;;;OAKG;IACH,oBAqFC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,mCAFa,wCAAgB,CA0B5B;IAED;;;;OAIG;IACH,8DAFa,wCAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAoFC;IAGL;;OAEG;IACH,yBAjsBe,sBAAsB,UAisBA;IACrC;;OAEG;IACH,0BAAqC;CATpC;uBA/7BmC,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B"}
+{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAgBU,MAAM;;;;;;;;;AAiBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,iCAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;qBADO,uCAAc;;MAI1B;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;IAEf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BAmFC;IAED;;;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,6BAFW,MAAM,QA8EhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,iEA2DC;IAED;;;;OAIG;IACH,uDAFa,QAAQ,OAAO,CAAC,CAyC5B;IAED;;;;;OAKG;IACH,mBAmCC;IAED;;;;;OAKG;IACH,oBAqFC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,mCAFa,wCAAgB,CA0B5B;IAED;;;;OAIG;IACH,8DAFa,wCAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAoFC;IAGL;;OAEG;IACH,yBAjtBe,sBAAsB,UAitBA;IACrC;;OAEG;IACH,0BAAqC;CATpC;uBA59BmC,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B"}