@woosh/meep-engine 3.14.5 → 3.15.0

package/src/core/model/stat/Stat.d.ts

@@ -1,4 +1,8 @@
 export default Stat;
+export type Signal = import("../../events/signal/Signal.js").Signal;
+/**
+ * @typedef {import("../../events/signal/Signal.js").Signal} Signal
+ */
 /**
  * Modifiable statistic.
  * Allows non-destructive linear arithmetic.
@@ -54,12 +58,12 @@ declare class Stat extends Number {
      *
      * @returns {Signal<LinearModifier>}
      */
-    get onModifierAdded(): Signal<LinearModifier>;
+    get onModifierAdded(): any;
     /**
      *
      * @returns {Signal<LinearModifier>}
      */
-    get onModifierRemoved(): Signal<LinearModifier>;
+    get onModifierRemoved(): any;
     /**
      * Remove all modifiers from the stat
      */
@@ -142,7 +146,7 @@ declare class Stat extends Number {
      *
      * @returns {Signal}
      */
-    get onChanged(): Signal;
+    get onChanged(): import("../../events/signal/Signal.js").Signal;
     /**
      * @readonly
      * @type {boolean}

package/src/core/model/stat/Stat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Stat.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/stat/Stat.js"],"names":[],"mappings":";AAUA;;;;;;;GAOG;AACH;IA2PI;;;;;OAKG;IACH,6BAJW,MAAM,aACN,KAAK,cAAc,CAAC,GAClB,MAAM,CAoBlB;IA3PD;;;OAGG;IACH,oBAHW,MAAM,EAuBhB;IA/CD;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;;;;OAMG;IACH,6BAAyB;IAEzB;;;;;OAKG;IACH,oBAFmB,MAAM,KAAG,MAAM,CAEF;IAY5B;;;OAGG;IACH,MAFU,OAAO,CAEa;IAE9B;;;OAGG;IACH,OAFU,OAAO,CAEc;IAMnC;;;OAGG;IACH,8CAEC;IAED;;;OAGG;IACH,gDAEC;IAED;;OAEG;IACH,uBAEC;IAUD;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED,oBAUC;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFY,cAAc,EAAE,CAI3B;IAED;;;OAGG;IACH,iBAFW,cAAc,QAMxB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACb,OAAO,CAIlB;IAED;;;;OAIG;IACH,oBAHW,cAAc,GACZ,OAAO,CAQnB;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CASnB;IAED;;;OAGG;IACH,YAFW,IAAI,QAOd;IAED;;;OAGG;IACH,gBAFW,IAAI,QAId;IAED;;;;OAIG;IACH,wCAHoB,MAAM,KAAE,MAAM,KACvB,MAAM,QAKhB;IAED;;OAEG;IACH,wCAFW,IAAI,QAmBd;IAED;;;MAKC;IAED,0BAIC;IAED;;;OAGG;IACH,wBAEC;IAkEL;;;OAGG;IACH,iBAFU,OAAO,CAEI;CA3CpB;;;QAOe,8CAEX;QACK,kCAEL;QAMS,kEAIT;QAMS,kEAIT;;;;oBAnUe,uBAAuB;2BAKhB,qBAAqB;iBAP/B,+BAA+B;sBAC1B,yBAAyB"}
+{"version":3,"file":"Stat.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/stat/Stat.js"],"names":[],"mappings":";qBAYa,OAAO,+BAA+B,EAAE,MAAM;AAD3D;;GAEG;AACH;;;;;;;GAOG;AACH;IA2PI;;;;;OAKG;IACH,6BAJW,MAAM,aACN,KAAK,cAAc,CAAC,GAClB,MAAM,CAoBlB;IA3PD;;;OAGG;IACH,oBAHW,MAAM,EAuBhB;IA/CD;;;OAGG;IACH,IAFU,MAAM,CAET;IAEP;;;;;;OAMG;IACH,6BAAyB;IAEzB;;;;;OAKG;IACH,oBAFmB,MAAM,KAAG,MAAM,CAEF;IAY5B;;;OAGG;IACH,MAFU,OAAO,CAEa;IAE9B;;;OAGG;IACH,OAFU,OAAO,CAEc;IAMnC;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;OAEG;IACH,uBAEC;IAUD;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED,oBAUC;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFY,cAAc,EAAE,CAI3B;IAED;;;OAGG;IACH,iBAFW,cAAc,QAMxB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACb,OAAO,CAIlB;IAED;;;;OAIG;IACH,oBAHW,cAAc,GACZ,OAAO,CAQnB;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CASnB;IAED;;;OAGG;IACH,YAFW,IAAI,QAOd;IAED;;;OAGG;IACH,gBAFW,IAAI,QAId;IAED;;;;OAIG;IACH,wCAHoB,MAAM,KAAE,MAAM,KACvB,MAAM,QAKhB;IAED;;OAEG;IACH,wCAFW,IAAI,QAmBd;IAED;;;MAKC;IAED,0BAIC;IAED;;;OAGG;IACH,gEAEC;IAkEL;;;OAGG;IACH,iBAFU,OAAO,CAEI;CA3CpB;;;QAOe,8CAEX;QACK,kCAEL;QAMS,kEAIT;QAMS,kEAIT;;;;oBAvUe,uBAAuB;2BAKhB,qBAAqB;iBAP/B,+BAA+B;sBAC1B,yBAAyB"}

package/src/core/model/stat/Stat.js

@@ -8,6 +8,10 @@ import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
 import LinearModifier from "./LinearModifier.js";
 
+
+/**
+ * @typedef {import("../../events/signal/Signal.js").Signal} Signal
+ */
 /**
  * Modifiable statistic.
  * Allows non-destructive linear arithmetic.

package/src/engine/Engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";AAsDA;IAoEI;;;;;;;;OAQG;IACH,8FANW,aAAa,EA4NvB;IA7QD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAmBrC;;;OAGG;IACH,yBAAwB;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,mBAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IA4BF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;MAIC;IAWD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAgGhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BAgCC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eA6BC;IAED;;;OAGG;IACH,sBAkEC;IAqBD;;OAEG;IACH,sBAyCC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BA9rB8B,+BAA+B;wBAUtC,wBAAwB;0BApBtB,0CAA0C;wCAcN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BArBZ,gDAAgD;iCAO9C,+CAA+C;6BAFnD,yBAAyB;uCAIf,6DAA6D;4BASxE,0BAA0B;+BApBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAlC4B,sCAAsC;sBA2B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BADhC,kCAAkC;sBAZ1C,+BAA+B;+BAKtB,qCAAqC;8BAItC,wBAAwB;4BAX1B,kCAAkC;oBAH1C,yBAAyB"}
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";AA6DA;IAoEI;;;;;;;;OAQG;IACH,8FANW,aAAa,EA8OvB;IA/RD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAmBrC;;;OAGG;IACH,yBAAwB;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,mBAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IA4BF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;MAIC;IA6BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BAgCC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eA6BC;IAED;;;OAGG;IACH,sBAkEC;IAqBD;;OAEG;IACH,sBAyCC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BA/vB8B,+BAA+B;wBAUtC,wBAAwB;0BApBtB,0CAA0C;wCAcN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BArBZ,gDAAgD;iCAO9C,+CAA+C;6BAFnD,yBAAyB;uCAIf,6DAA6D;4BASxE,0BAA0B;+BApBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAlC4B,sCAAsC;sBA2B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BADhC,kCAAkC;sBAZ1C,+BAA+B;+BAKtB,qCAAqC;8BAItC,wBAAwB;4BAX1B,kCAAkC;oBAH1C,yBAAyB"}

package/src/engine/Engine.js

@@ -52,6 +52,13 @@ const METRIC_ID_SIMULATION = 'simulation_time';
  */
 const CONTEXT_LOSS_SIMULATION_PAUSE_DELAY = 2;
 
+/**
+ * Anything that can hold keyboard focus on its own account. A pointerdown that lands on one of
+ * these is not a click on the game, and the game must not take focus back from it.
+ * @type {string}
+ */
+const FOCUSABLE_SELECTOR = 'input, textarea, select, button, a[href], [contenteditable], [tabindex]:not([tabindex="-1"])';
+
 class Engine {
     #last_frame_timestamp = 0;
 
@@ -330,6 +337,24 @@ class Engine {
         this.devices.keyboard.start();
         this.devices.gamepad.start();
 
+        /*
+         Only the focused element receives keyboard events. `ViewStack` sets `tabindex` on its
+         element for exactly that reason — "focus is required to handle keyboard events", in its
+         own words — and `KeyboardDevice` throws if handed an element that cannot take focus. So
+         both halves understood the requirement and neither one met it: nothing focus*ed* the
+         element, `document.activeElement` stayed `<body>`, and every key went there instead.
+
+         The failure is silent and it is indistinguishable from an application with no input code
+         at all, which is the wrong place to start debugging. Reported from a port as GAP-017,
+         found by someone trying to play the thing.
+
+         Focus is taken on link rather than here, because focusing an element that is not in the
+         document does nothing, and it is re-taken on pointerdown so that clicking a DOM overlay
+         and clicking back restores the keyboard.
+        */
+        this.viewStack.on.linked.add(this.#focusInputElement, this);
+        this.viewStack.el.addEventListener('pointerdown', this.#focusInputElement);
+
         //process settings
         this.initializeSettings();
 
@@ -435,6 +460,46 @@ class Engine {
         }
     }
 
+    /**
+     * Give focus to the element the input devices listen on.
+     *
+     * An arrow property rather than a method, because it is used both as a signal handler and as a
+     * DOM listener, and the DOM would otherwise call it with the element as `this`.
+     *
+     * @private
+     */
+    #focusInputElement = (event) => {
+        const el = this.viewStack.el;
+
+        if (el === null || el === undefined || typeof el.focus !== "function") {
+            return;
+        }
+
+        /*
+         A pointerdown anywhere inside the stack bubbles to it, including one on a control the
+         application put there. Taking focus on the way past would make a text field in a UI
+         overlay impossible to type into -- the click focuses the input, this handler immediately
+         takes it back, and the caret never appears. So a target that can hold focus itself keeps
+         it, and the game only claims focus when the click landed on nothing that wanted it.
+        */
+        const target = event === undefined ? null : event.target;
+
+        if (target !== null && target !== el && typeof target.closest === "function") {
+            const focusable = target.closest(FOCUSABLE_SELECTOR);
+
+            /*
+             `el` matches FOCUSABLE_SELECTOR itself -- it is the element carrying the tabindex --
+             so the nearest match being `el` means nothing between the click and the stack wanted
+             focus, and the stack should take it.
+            */
+            if (focusable !== null && focusable !== el) {
+                return;
+            }
+        }
+
+        el.focus();
+    };
+
     initializeViews() {
 
         const gameView = new EmptyView();

package/src/engine/EngineHarness.d.ts

@@ -17,10 +17,16 @@ export class EngineHarness {
      */
     static shadeScene(engine: Engine): Scene;
     /**
+     * Add a frame-rate readout to the engine's view stack.
+     *
+     * Returns the view, so a settings screen can turn it off again — `cg_drawFPS`
+     * is on every graphics menu ever shipped, and this used to return nothing,
+     * leaving the panel it added unreachable (GAP-028).
      *
      * @param {Engine} engine
+     * @returns {FrameRateView} the view that was added
      */
-    static addFpsCounter(engine: Engine): void;
+    static addFpsCounter(engine: Engine): FrameRateView;
     /**
      * @param {Object} param
      * @param {Engine} param.engine
@@ -179,6 +185,7 @@ export namespace EngineHarness {
 import Engine from "./Engine.js";
 import { EngineConfiguration } from "./EngineConfiguration.js";
 import { Scene } from "../shade/renderer/scene/Scene.js";
+import { FrameRateView } from "../view/elements/FrameRateView.js";
 import Vector3 from "../core/geom/Vector3.js";
 import Entity from "./ecs/Entity.js";
 import { Color } from "../core/color/Color.js";

package/src/engine/EngineHarness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EngineHarness.d.ts","sourceRoot":"","sources":["../../../src/engine/EngineHarness.js"],"names":[],"mappings":"AA2EA;IAmBI;;;;OAIG;IACH,8CAHmB,mBAAmB,UAAQ,MAAM,WACxC,QAAQ,MAAM,CAAC,CAM1B;IAED;;;;;;;;;OASG;IACH,0BAHW,MAAM,GACJ,KAAK,CAYjB;IAED;;;OAGG;IACH,6BAFW,MAAM,QAiBhB;IAkED;;;;;;;;;;;;;OAaG;IACH;QAZyB,MAAM,EAApB,MAAM;QACyB,GAAG;QAClB,MAAM,GAAtB,OAAO;QACQ,QAAQ,GAAvB,MAAM;QACS,KAAK,GAApB,MAAM;QACS,GAAG,GAAlB,MAAM;QACU,QAAQ,GAAxB,OAAO;QACQ,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACJ,MAAM,CA+DlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH;QApB0B,MAAM,EAArB,MAAM;QACgC,KAAK,GAA3C;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACrB,SAAS;QACT,WAAW;QACF,KAAK,GAArB,MAAM;QACU,GAAG,GAAnB,MAAM;QACU,QAAQ,GAAxB,MAAM;QACwB,WAAW,GAAzC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAC,CAAC,EAAC,MAAM,CAAA;SAAC;QACJ,iBAAiB,GAAjC,MAAM;QACW,WAAW,GAA5B,OAAO;QACU,aAAa,GAA9B,OAAO;QACU,YAAY,GAA7B,OAAO;QACU,aAAa,GAA9B,OAAO;QACS,iBAAiB,GAAjC,MAAM;QACU,iBAAiB,GAAjC,MAAM;QACW,gBAAgB,GAAjC,OAAO;QACU,cAAc,GAA/B,OAAO;QACS,mBAAmB,GAAnC,MAAM;QACW,OAAO,GAAxB,OAAO;sBA0EjB;IAGD;;;;;;;;;;;;OAYG;IACH;QAXyB,MAAM,EAApB,MAAM;QACyB,GAAG;QACnB,mBAAmB,GAAlC,MAAM;QACU,UAAU,GAA1B,OAAO;QACO,GAAG,GAAjB,KAAK;QACU,YAAY,GAA3B,MAAM;QACU,YAAY,GAA5B,OAAO;QACO,OAAO,GAArB,KAAK;QACU,gBAAgB,GAA/B,MAAM;QACS,iBAAiB,GAAhC,MAAM;sBAqDhB;IAED;;;;;;;OAOG;IACH;QAN0B,YAAY,GAA3B,MAAM;QACQ,MAAM,EAApB,MAAM;QACS,WAAW,GAA1B,MAAM;QACyB,GAAG;QAChC,QAAQ,MAAM,CAAC,CA6C3B;IAGD;;;;;;;;;;OAUG;IACH,sFATW,MAAM,GAOJ,OAAO,CA0DnB;IAjfD;;;OAGG;IACH,YAFU,eAAQ,IAAI,CAEb;IAGL;;;OAGG;IACH,QAFU,MAAM,CAEiC;IA6DrD;;;;;OAKG;IACH;iCAJmB,mBAAmB,UAAQ,MAAM;8BACzC,OAAO;QACL,QAAQ,MAAM,CAAC,CA0D3B;CA4WJ;;IAID;;;OAGG;IACH,uCAMC;;mBA7jBkB,aAAa;oCACI,0BAA0B;sBAOxC,kCAAkC;oBAjBpC,yBAAyB;mBAK1B,iBAAiB;sBATd,wBAAwB;oBAW1B,8BAA8B"}
+{"version":3,"file":"EngineHarness.d.ts","sourceRoot":"","sources":["../../../src/engine/EngineHarness.js"],"names":[],"mappings":"AA0EA;IAmBI;;;;OAIG;IACH,8CAHmB,mBAAmB,UAAQ,MAAM,WACxC,QAAQ,MAAM,CAAC,CAM1B;IAED;;;;;;;;;OASG;IACH,0BAHW,MAAM,GACJ,KAAK,CAYjB;IAED;;;;;;;;;OASG;IACH,6BAHW,MAAM,GACJ,aAAa,CAQzB;IAkED;;;;;;;;;;;;;OAaG;IACH;QAZyB,MAAM,EAApB,MAAM;QACyB,GAAG;QAClB,MAAM,GAAtB,OAAO;QACQ,QAAQ,GAAvB,MAAM;QACS,KAAK,GAApB,MAAM;QACS,GAAG,GAAlB,MAAM;QACU,QAAQ,GAAxB,OAAO;QACQ,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACS,WAAW,GAA1B,MAAM;QACJ,MAAM,CA+DlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH;QApB0B,MAAM,EAArB,MAAM;QACgC,KAAK,GAA3C;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACrB,SAAS;QACT,WAAW;QACF,KAAK,GAArB,MAAM;QACU,GAAG,GAAnB,MAAM;QACU,QAAQ,GAAxB,MAAM;QACwB,WAAW,GAAzC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAC,CAAC,EAAC,MAAM,CAAA;SAAC;QACJ,iBAAiB,GAAjC,MAAM;QACW,WAAW,GAA5B,OAAO;QACU,aAAa,GAA9B,OAAO;QACU,YAAY,GAA7B,OAAO;QACU,aAAa,GAA9B,OAAO;QACS,iBAAiB,GAAjC,MAAM;QACU,iBAAiB,GAAjC,MAAM;QACW,gBAAgB,GAAjC,OAAO;QACU,cAAc,GAA/B,OAAO;QACS,mBAAmB,GAAnC,MAAM;QACW,OAAO,GAAxB,OAAO;sBA0EjB;IAGD;;;;;;;;;;;;OAYG;IACH;QAXyB,MAAM,EAApB,MAAM;QACyB,GAAG;QACnB,mBAAmB,GAAlC,MAAM;QACU,UAAU,GAA1B,OAAO;QACO,GAAG,GAAjB,KAAK;QACU,YAAY,GAA3B,MAAM;QACU,YAAY,GAA5B,OAAO;QACO,OAAO,GAArB,KAAK;QACU,gBAAgB,GAA/B,MAAM;QACS,iBAAiB,GAAhC,MAAM;sBAqDhB;IAED;;;;;;;OAOG;IACH;QAN0B,YAAY,GAA3B,MAAM;QACQ,MAAM,EAApB,MAAM;QACS,WAAW,GAA1B,MAAM;QACyB,GAAG;QAChC,QAAQ,MAAM,CAAC,CA6C3B;IAGD;;;;;;;;;;OAUG;IACH,sFATW,MAAM,GAOJ,OAAO,CA0DnB;IA9eD;;;OAGG;IACH,YAFU,eAAQ,IAAI,CAEb;IAGL;;;OAGG;IACH,QAFU,MAAM,CAEiC;IA0DrD;;;;;OAKG;IACH;iCAJmB,mBAAmB,UAAQ,MAAM;8BACzC,OAAO;QACL,QAAQ,MAAM,CAAC,CA0D3B;CA4WJ;;IAID;;;OAGG;IACH,uCAMC;;mBA1jBkB,aAAa;oCACI,0BAA0B;sBAOxC,kCAAkC;8BAhB1B,mCAAmC;oBAD7C,yBAAyB;mBAK1B,iBAAiB;sBATd,wBAAwB;oBAW1B,8BAA8B"}

package/src/engine/EngineHarness.js

@@ -1,11 +1,10 @@
-import Stats from "stats.js";
 import { assert } from "../core/assert.js";
 import { Color } from "../core/color/Color.js";
 
 import { noop } from "../core/function/noop.js";
 import Vector2 from "../core/geom/Vector2.js";
 import Vector3 from "../core/geom/Vector3.js";
-import EmptyView from "../view/elements/EmptyView.js";
+import { FrameRateView } from "../view/elements/FrameRateView.js";
 import { JsonAssetLoader } from "./asset/loaders/JsonAssetLoader.js";
 import { SerializationMetadata } from "./ecs/components/SerializationMetadata.js";
 import Tag from "./ecs/components/Tag.js";
@@ -126,24 +125,21 @@ export class EngineHarness {
     }
 
     /**
+     * Add a frame-rate readout to the engine's view stack.
+     *
+     * Returns the view, so a settings screen can turn it off again — `cg_drawFPS`
+     * is on every graphics menu ever shipped, and this used to return nothing,
+     * leaving the panel it added unreachable (GAP-028).
      *
      * @param {Engine} engine
+     * @returns {FrameRateView} the view that was added
      */
     static addFpsCounter(engine) {
-        /*
-         `stats.js` by its own name. three shipped a copy of it as
-         `examples/jsm/libs/stats.module.js`, which is what this used to import; moh already declares
-         the package, so this is the same code under the name its author gives it (D64).
-        */
-        const stats = new Stats();
-
-        engine.graphics.on.postRender.add(stats.update, stats);
-
-        const view = new EmptyView({
-            el: stats.domElement
-        });
+        const view = new FrameRateView({ frame_signal: engine.graphics.on.postRender });
 
         engine.viewStack.addChild(view);
+
+        return view;
     }
 
     /**

package/src/engine/animation/clip/ecd_bind_animation_curve.d.ts

@@ -1,8 +1,8 @@
 /**
  * Three.js clip to internal representation
  * @param {EntityNode} node
- * @param {THREE.AnimationClip} clip
+ * @param {*} clip
  */
-export function convert_three_clip(node: EntityNode, clip: THREE.AnimationClip): AnimationClipBinding;
+export function convert_three_clip(node: EntityNode, clip: any): AnimationClipBinding;
 import { AnimationClipBinding } from "./AnimationClipBinding.js";
 //# sourceMappingURL=ecd_bind_animation_curve.d.ts.map

package/src/engine/animation/clip/ecd_bind_animation_curve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ecd_bind_animation_curve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/ecd_bind_animation_curve.js"],"names":[],"mappings":"AA6GA;;;;GAIG;AACH,sGA8BC;qCA7IoC,2BAA2B"}
+{"version":3,"file":"ecd_bind_animation_curve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/ecd_bind_animation_curve.js"],"names":[],"mappings":"AA6GA;;;;GAIG;AACH,sFA8BC;qCA7IoC,2BAA2B"}

package/src/engine/animation/clip/ecd_bind_animation_curve.js

@@ -12,7 +12,7 @@ import { hemisphere_align_quaternion_values } from "./hemisphere_align_quaternio
 
 /**
  *
- * @param {THREE.KeyframeTrack} track
+ * @param {*} track
  */
 function track_to_interpolation(track) {
     const name = track.createInterpolant.name;
@@ -40,7 +40,7 @@ function track_to_interpolation(track) {
 
 /**
  *
- * @param {THREE.KeyframeTrack} track
+ * @param {*} track
  * @returns {AnimationCurve[]}
  */
 function convert_three_track_to_curves(track) {
@@ -93,7 +93,7 @@ function convert_three_track_to_curves(track) {
 
 /**
  *
- * @param {THREE.KeyframeTrack} track
+ * @param {*} track
  * @returns {AnimationTrack}
  */
 function convert_three_track(track) {
@@ -110,7 +110,7 @@ function convert_three_track(track) {
 /**
  * Three.js clip to internal representation
  * @param {EntityNode} node
- * @param {THREE.AnimationClip} clip
+ * @param {*} clip
  */
 export function convert_three_clip(node, clip) {
     const three_tracks = clip.tracks;

package/src/engine/asset/loaders/async_traverse_three_object.d.ts

@@ -1,9 +1,9 @@
 /**
  *
- * @param {THREE.Object3D} object
+ * @param {*} object
  * @param {function} callback
  * @param {*} [thisArg]
  * @param {*} [ctx]
  */
-export function async_traverse_three_object(object: THREE.Object3D, callback: Function, thisArg?: any, ctx?: any): Promise<void>;
+export function async_traverse_three_object(object: any, callback: Function, thisArg?: any, ctx?: any): Promise<void>;
 //# sourceMappingURL=async_traverse_three_object.d.ts.map

package/src/engine/asset/loaders/async_traverse_three_object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async_traverse_three_object.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/async_traverse_three_object.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,iIAgBC"}
+{"version":3,"file":"async_traverse_three_object.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/async_traverse_three_object.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,sHAgBC"}

package/src/engine/asset/loaders/async_traverse_three_object.js

@@ -1,6 +1,6 @@
 /**
  *
- * @param {THREE.Object3D} object
+ * @param {*} object
  * @param {function} callback
  * @param {*} [thisArg]
  * @param {*} [ctx]

package/src/engine/asset/loaders/image/codec/ThreadedImageDecoder.d.ts

@@ -20,10 +20,14 @@
  */
 export class ThreadedImageDecoder extends Codec<DecodedImage> {
     /**
-     *
-     * @param {string} [worker_path]
+     * @param {Object} [options]
+     * @param {string} [options.worker_path] where the decoder bundle lives. Defaults to this
+     * package's own copy, resolved against this module rather than against the document — see
+     * {@link WORKER_BUNDLE_URL}.
      */
-    constructor({ worker_path }?: string);
+    constructor({ worker_path }?: {
+        worker_path?: string;
+    });
     /**
      *
      * @type {OnDemandWorkerManager}

package/src/engine/asset/loaders/image/codec/ThreadedImageDecoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ThreadedImageDecoder.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/codec/ThreadedImageDecoder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACI;;;OAGG;IACH,8BAFW,MAAM,EAwBhB;IARG;;;OAGG;IACH,QAFU,qBAAqB,CAE+B;IAMlE,kCAaC;IAED,gCAEC;CACJ;sBArEqB,yBAAyB;sCAHT,6DAA6D"}
+{"version":3,"file":"ThreadedImageDecoder.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/codec/ThreadedImageDecoder.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACI;;;;;OAKG;IACH;QAJ4B,WAAW,GAA5B,MAAM;OA0BhB;IARG;;;OAGG;IACH,QAFU,qBAAqB,CAE+B;IAMlE,kCAaC;IAED,gCAEC;CACJ;sBAnGqB,yBAAyB;sCAHT,6DAA6D"}

package/src/engine/asset/loaders/image/codec/ThreadedImageDecoder.js

@@ -4,6 +4,34 @@ import WorkerBuilder from "../../../../../core/process/worker/WorkerBuilder.js";
 import { PNG_HEADER_BYTES } from "../../../../../format/image/png/PNG_HEADER_BYTES.js";
 import { Codec } from "../../../codec/Codec.js";
 
+/**
+ * Where the decoder's worker bundle actually is.
+ *
+ * This used to be the bare string `'bundle-worker-image-decoder.js'`, which
+ * `WorkerBuilder` resolves against the **document** origin — so out of the box it
+ * asked for `http://your-app/bundle-worker-image-decoder.js`, a path that is the
+ * web root of no application that has ever installed this package. The bundle
+ * ships in `@woosh/meep-engine/build/`, which is where this points.
+ *
+ * Resolving against `import.meta.url` is what every modern bundler understands
+ * and what needs no configuration from a consumer. The failure it replaces was
+ * the worse kind: `ImageRGBADataLoader` wraps this codec in a
+ * `CodecWithFallback` over the main-thread decoder, so the output stayed correct
+ * and only the speed changed, with nothing reported to anyone. Reported from a
+ * port as GAP-004, where the load path decodes several thousand textures.
+ *
+ * One thing a consumer may still have to do: a blob worker inherits the page's
+ * COEP, so under `Cross-Origin-Embedder-Policy: require-corp` — which WebGPU
+ * pushes you toward — the `importScripts` of this file is blocked unless the
+ * response carries `Cross-Origin-Resource-Policy`.
+ *
+ * @type {string}
+ */
+const WORKER_BUNDLE_URL = new URL(
+    "../../../../../../build/bundle-worker-image-decoder.js",
+    import.meta.url
+).href;
+
 /**
  * PNG, decoded off the main thread by the rollup-built worker bundle.
  *
@@ -26,11 +54,13 @@ import { Codec } from "../../../codec/Codec.js";
  */
 export class ThreadedImageDecoder extends Codec {
     /**
-     *
-     * @param {string} [worker_path]
+     * @param {Object} [options]
+     * @param {string} [options.worker_path] where the decoder bundle lives. Defaults to this
+     * package's own copy, resolved against this module rather than against the document — see
+     * {@link WORKER_BUNDLE_URL}.
      */
     constructor({
-                    worker_path = 'bundle-worker-image-decoder.js'
+                    worker_path = WORKER_BUNDLE_URL
                 } = {}) {
 
         super();

package/src/engine/control/first-person/DESIGN.md

@@ -1,8 +1,26 @@
 # FirstPersonPlayerController — Design
 
-> Status: **Draft** — design doc. No implementation yet.
+> **Status: shipped.** `FirstPersonPlayerController.js`, its system, its serialization adapter and
+> its specs all exist; this document is the design they were built from, kept as the rationale
+> rather than as a plan. The line that used to sit here said "No implementation yet" and was still
+> saying it above ~3,700 lines of working code.
+>
+> **What this controller is FOR, which is the thing to read before adopting it.** It is an
+> opinionated, feel-first, tunable controller: §1's two goals are "feel alive" and "be
+> configurable", and it cites Mirror's Edge Catalyst, Star Citizen stance/breathing and
+> critically-damped spring cameras. **If you arrive with a movement model of your own — a
+> Quake-lineage `pmove`, a physics-driven platformer, a rollback netcode design with its own step
+> function — this is not a substrate for it and is not trying to be.** Configurability cannot
+> express "this specific set of floating-point operations, exactly", and a fixed movement model is
+> usually about exactly that. Bring your own controller and use {@link KinematicMover} underneath
+> it, which is controller-agnostic and is what the collision half of this directory actually is.
+>
+> A port that pointed a Quake III movement model at this concluded the same thing correctly, then
+> treated the whole directory as decided and re-implemented the mover's standoff and depenetration
+> from the raw query layer — about six hours and two wrong fixes (GAP-009, GAP-021). Hence this
+> paragraph, and hence the note at the top of DESIGN_COLLISION.md.
+>
 > Scope: one entity, one body, one camera. No skeleton, no avatar mesh, no sound, no input wiring.
-> Companion files (planned): `FirstPersonPlayerController.js` (component), `FirstPersonPlayerControllerSystem.js` (system), serialization adapter, spec.
 
 ---
 

package/src/engine/control/first-person/DESIGN_COLLISION.md

@@ -1,5 +1,22 @@
 # Collision handling — ground-up construction plan
 
+> **Status, because this reads as a plan and a reader has to know how much of it is real.**
+> Steps 1–4 of §4's sequence are **shipped** in `collision/KinematicMover.js`: recover (`_recover`,
+> `compute_penetration`), slide (`_slide`, `MAX_CLIP_PLANES` crease handling), stairs
+> (`_tryStepUp`), and ground categorise + stick + slope clip (`_categorizeGround`). The mover's own
+> docblock still says "Phase 1" in places; the phase numbering here is the order things were built
+> in, not what exists. **Not shipped:** a moving-platform step — nothing carries a character on a
+> lift, and `MoveResult` reports `groundBody`/`groundEntity` so a consumer can write the carry
+> themselves until there is one.
+>
+> **This solver is controller-agnostic and the path lies about that.** `KinematicMover` imports
+> `Vector3`, `Ray3`, `Transform`, `Collider`, `compute_penetration` and `PhysicsSurfacePoint` —
+> nothing from the controller — and it is the right thing to use even if you have decided
+> `FirstPersonPlayerController` is not for you. It lives here because this is where it was built,
+> and a consumer who ruled out the controller has been given a path saying these files are not for
+> them either. A port did exactly that and spent about six hours re-implementing the standoff
+> (`skin`) and the depenetration pass it already has (GAP-021).
+
 Companion to DESIGN.md (base controller) and TODO.md.
 
 **Premise.** The control layer is excellent and stays. The collision

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

@@ -1,16 +1,22 @@
 /**
- * Kinematic character collision solver — Phase 1 (recover +
- * unified sweep-and-slide). See DESIGN_COLLISION.md.
+ * Kinematic character collision solver. See DESIGN_COLLISION.md.
  *
- * The mover is controller-agnostic: it knows about a capsule pose, a
- * desired velocity, and the physics world. Its job is to take the
- * velocity the control layer wants and return the position it actually
- * reaches plus the velocity corrected for whatever it hit. It invents
- * no motion — gravity / jump impulses live in the control layer and
- * arrive folded into `velocity`.
+ * **The mover is controller-agnostic, and the path it lives at says otherwise.** It imports
+ * `Vector3`, `Ray3`, `Transform`, `Collider`, `compute_penetration` and `PhysicsSurfacePoint` —
+ * nothing from `FirstPersonPlayerController`. If you have your own movement model and have decided
+ * that controller is not for you, **this class still is**: it carries the standoff (`skin`), the
+ * start-solid depenetration pass, Quake's five-plane crease handling and `MIN_WALK_NORMAL`, and it
+ * is the thing to build a character on. It sits under `control/first-person/` because that is where
+ * it was built, which cost one consumer about six hours of re-implementing it from the raw query
+ * layer (GAP-021).
  *
- * One move is a sequence (Phase 1 implements steps 1-2; ground
- * categorize / stairs / settle land in later phases):
+ * It knows about a capsule pose, a desired velocity, and the physics world. Its job is to take the
+ * velocity the control layer wants and return the position it actually reaches plus the velocity
+ * corrected for whatever it hit. It invents no motion — gravity / jump impulses live in the control
+ * layer and arrive folded into `velocity`.
+ *
+ * One move is the sequence below. Steps 1–4 are implemented here; a moving-platform step is not,
+ * which is why {@link _result} reports `groundBody` — see DESIGN_COLLISION.md's status header:
  *
  *   1. RECOVER  — depenetration via `overlap()` + `compute_penetration`,
  *      run unconditionally so the move starts clear even from a
@@ -71,11 +77,47 @@ export class KinematicMover {
     _planes: Float64Array;
     _cand: Float64Array;
     _support: Float64Array;
+    /**
+     * Reused result.
+     *
+     * **Four of these fields exist because dropping a value the solver already computed is what
+     * forces a consumer into a heuristic.** Reported from a port as GAP-022 and GAP-035:
+     *
+     *  - `groundBody` / `groundEntity` — `_categorizeGround` knows what it landed on and used to
+     *    throw it away, so a consumer was told THAT they are on a walkable surface and never WHAT
+     *    they are on. Every ingredient for writing a moving platform yourself was inside that
+     *    method and none of it came back out. Jolt's `CharacterVirtual` exposes `GetGroundBodyID`
+     *    and Source's `CategorizePosition` records `m_hGroundEntity` for the same reason.
+     *  - `stepUp` — `_tryStepUp` computed `heightGain`, committed on it, and discarded it. Q3's
+     *    `EV_STEP_4..16` drives `CG_StepOffset`, which leaves the eye behind the riser and slides
+     *    it up over 200 ms; it is the difference between walking up a flight of stairs and being
+     *    teleported up one four times a second. Reconstructing it from the pose is not free,
+     *    because the thing a step has to be told apart from is a RAMP and both are "the origin
+     *    went up while grounded" — the port's stand-in was a slope-ratio guard that is wrong at
+     *    the top of a ramp meeting a flat.
+     *  - `landed` / `landingSpeed` — the same argument. A controller wanting Q3's fall events had
+     *    to diff `grounded` across calls, which every consumer would write identically.
+     *
+     * `grounded` / `groundNormal` come from `_categorizeGround`.
+     *
+     * @type {{hit:boolean, grounded:boolean, groundNormal:Vector3, groundBody:number, groundEntity:number, stepUp:number, landed:boolean, landingSpeed:number}}
+     */
     _result: {
         hit: boolean;
         grounded: boolean;
         groundNormal: Vector3;
+        groundBody: number;
+        groundEntity: number;
+        stepUp: number;
+        landed: boolean;
+        landingSpeed: number;
     };
+    /**
+     * Whether the previous {@link move} ended grounded, so this one can report the transition.
+     * @private
+     * @type {boolean}
+     */
+    private _wasGrounded;
     physicsSystem: import("../../../physics/ecs/PhysicsSystem.js").PhysicsSystem;
     ecd: import("../../../ecs/EntityComponentDataset.js").EntityComponentDataset;
     skin: number;
@@ -94,7 +136,7 @@ export class KinematicMover {
      * @param {number} dt
      * @param {(entity:number, collider:Collider)=>boolean} filter excludes
      *   the player's own body in integration; accept-all in isolation
-     * @returns {{hit:boolean, grounded:boolean, groundNormal:Vector3}} reused result
+     * @returns {{hit:boolean, grounded:boolean, groundNormal:Vector3, groundBody:number, groundEntity:number, stepUp:number, landed:boolean, landingSpeed:number}} reused result — see {@link _result} for what each field is for
      */
     move(position: Vector3, rotation: {
         x: number;
@@ -105,6 +147,11 @@ export class KinematicMover {
         hit: boolean;
         grounded: boolean;
         groundNormal: Vector3;
+        groundBody: number;
+        groundEntity: number;
+        stepUp: number;
+        landed: boolean;
+        landingSpeed: number;
     };
     /**
      * Stair step-up. Called after a slide that hit something while the

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

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