@woosh/meep-engine 2.164.0 → 2.165.1

package/src/engine/graphics/sh3/prototypeLightProbeGrid.js

@@ -0,0 +1,170 @@
+import { GUI } from "dat.gui";
+import '../../../../../../../css/game.scss';
+import { Color } from "../../../core/color/Color.js";
+import { kelvin_to_rgb } from "../../../core/color/kelvin/kelvin_to_rgb.js";
+import { AABB3 } from "../../../core/geom/3d/aabb/AABB3.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { max2 } from "../../../core/math/max2.js";
+import { min2 } from "../../../core/math/min2.js";
+import { RAD_TO_DEG } from "../../../core/math/RAD_TO_DEG.js";
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
+import { GLTFAssetLoader } from "../../asset/loaders/GLTFAssetLoader.js";
+import GUIElementSystem from "../../ecs/gui/GUIElementSystem.js";
+import ViewportPositionSystem from "../../ecs/gui/position/ViewportPositionSystem.js";
+import { TransformAttachmentSystem } from "../../ecs/transform-attachment/TransformAttachmentSystem.js";
+import { EngineHarness } from "../../EngineHarness.js";
+import { Camera } from "../ecs/camera/Camera.js";
+import { focal_length_to_fov } from "../ecs/camera/focal_length_to_fov.js";
+import TopDownCameraController from "../ecs/camera/topdown/TopDownCameraController.js";
+import LightSystem from "../ecs/light/LightSystem.js";
+import { SGMeshSystem } from "../ecs/mesh-v2/aggregate/SGMeshSystem.js";
+import { ShadedGeometry } from "../ecs/mesh-v2/ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../ecs/mesh-v2/ShadedGeometryFlags.js";
+import { ShadedGeometrySystem } from "../ecs/mesh-v2/ShadedGeometrySystem.js";
+import { three_object_to_entity_composition } from "../ecs/mesh-v2/three_object_to_entity_composition.js";
+import { GizmoRenderingPlugin } from "../render/gizmo/GizmoRenderingPlugin.js";
+import { ProbeResolutionStage } from "./gi/material/ProbeResolutionStage.js";
+import { light_probe_grid_bake_via_task } from "./lpg/build_light_probe_grid_for_scene.js";
+import { LightProbeGrid } from "./lpg/LightProbeGrid.js";
+import { light_probe_grid_obtain_storage_cached } from "./lpg/light_probe_grid_obtain_storage_cached.js";
+import { LightProbeGridMaterialTransformer } from "./lpg/material/LightProbeGridMaterialTransformer.js";
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+async function main(engine) {
+    const grid = new LightProbeGrid();
+
+    const transformer = new LightProbeGridMaterialTransformer({
+        grid,
+        stage: ProbeResolutionStage.Fragment
+    });
+
+    engine.graphics.getMaterialManager().addCompileStep(transformer);
+
+    await EngineHarness.buildBasics({
+        engine,
+        showFps: false,
+        enableWater: false,
+        enableTerrain: false,
+        enableLights: false,
+        cameraFarDistance: 200,
+        cameraController: false,
+        focus: { x: 0, y: 0, z: 0 },
+        pitch: 1,
+        yaw: -1.54,
+        distance: 54,
+        cameraFieldOfView: focal_length_to_fov(50, 25) * RAD_TO_DEG
+    });
+
+    const sun_color = new Color();
+
+    kelvin_to_rgb(sun_color, 0, 5000);
+
+    await EngineHarness.buildLights({
+        engine,
+        shadowmapResolution: 4096,
+        ambientIntensity: 0.0,
+        sun: sun_color,
+        sunIntensity: 3,
+        sunDirection: new Vector3(1.2, -1, 0.2)
+    })
+
+    engine.graphics.getRenderer().setClearColor('#1e3441', 1);
+
+    const ecd = engine.entityManager.dataset;
+
+    const path = 'data/models/pica_pica/pica_pica.gltf';
+
+    const mesh_asset = await engine.assetManager.promise(path, 'model/gltf+json');
+    const gltf = mesh_asset.gltf;
+
+    const composition = three_object_to_entity_composition(gltf.scene);
+
+    composition.traverse(n => {
+
+        /**
+         * @type {ShadedGeometry}
+         */
+        const sg = n.entity.getComponent(ShadedGeometry);
+
+        if (sg === null) {
+            return;
+        }
+
+        sg.writeFlag(ShadedGeometryFlags.CastShadow | ShadedGeometryFlags.ReceiveShadow, true);
+
+        const material = sg.material;
+        if (material !== null) {
+            material.depthTest = true;
+            material.depthWrite = true;
+        }
+    });
+
+    composition.build(ecd);
+
+    /**
+     * @type {AABB3}
+     */
+    const mesh_bounds = mesh_asset.boundingBox;
+
+    const model_footprint = v3_length(mesh_bounds.getExtentsX(), mesh_bounds.getExtentsY(), mesh_bounds.getExtentsZ());
+
+    const camera = ecd.getAnyComponent(Camera);
+    camera.component.clip_far = max2(100, model_footprint * 3);
+    const camera_controller = ecd.getComponent(camera.entity, TopDownCameraController);
+    camera_controller.distanceMax = model_footprint * 2;
+    camera_controller.distanceMin = min2(camera_controller.distanceMin, model_footprint * 0.01);
+    mesh_bounds.getCenter(camera_controller.target)
+
+    const spacing = model_footprint * 0.1;
+
+    console.time('getGrid');
+    await light_probe_grid_obtain_storage_cached({ engine, path, grid, spacing });
+    console.timeEnd('getGrid');
+
+    console.log('LPG:', grid);
+
+    transformer.update();
+
+    const gui = new GUI();
+    gui.add(transformer, 'intensity').min(0).max(10);
+
+    gui.add({
+        async bake() {
+            const grid_bounds = new AABB3(0, 0, 0, 1, 1, 1);
+            grid_bounds.copy(mesh_bounds);
+            grid_bounds.grow(spacing * 1.05);
+
+            grid.build(
+                grid_bounds,
+                max2(2, Math.ceil(grid_bounds.getExtentsX() / spacing) + 1),
+                max2(2, Math.ceil(grid_bounds.getExtentsY() / spacing) + 1),
+                max2(2, Math.ceil(grid_bounds.getExtentsZ() / spacing) + 1)
+            );
+
+            await light_probe_grid_bake_via_task(grid, ecd, engine);
+
+            transformer.update();
+        }
+    }, "bake").name("Bake");
+}
+
+new EngineHarness().initialize({
+    configuration(config, engine) {
+        config.addSystem(new ShadedGeometrySystem(engine));
+        config.addSystem(new LightSystem(engine, {
+            shadowResolution: 8192
+        }));
+        config.addSystem(new SGMeshSystem(engine));
+        config.addSystem(new TransformAttachmentSystem());
+        config.addSystem(new GUIElementSystem(engine.gui.view, engine));
+        config.addSystem(new ViewportPositionSystem(engine.gui.view.size));
+
+        config.addLoader('model/gltf+json', new GLTFAssetLoader());
+
+        config.addPlugin(GizmoRenderingPlugin);
+    }
+}).then(main);

package/src/engine/graphics/sh3/sky/hosek/prototype_hosek.js

@@ -1,4 +1,4 @@
-import { vec3 } from "gl-matrix";
+import { v3_normalize_array } from "../../../../../core/geom/vec3/v3_normalize_array.js";
 import { CanvasView } from "../../../../../view/elements/CanvasView.js";
 import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
 import sampler2D2Canvas from "../../../texture/sampler/sampler2d_to_html_canvas.js";
@@ -52,7 +52,7 @@ for (let i = 0; i < sampler.width; i++) {
 
         const direction = [v_x, v_z, v_y];
 
-        vec3.normalize(direction, direction);
+        v3_normalize_array(direction, 0, direction, 0);
 
         sky(color, 0, direction, 0);
 

package/src/engine/graphics/texture/atlas/AtlasLookupTexture.js

@@ -77,7 +77,7 @@ export class AtlasLookupTexture {
             data[address] = position.x;
             data[address + 1] = position.y;
 
-            data[address + 2] = size.y;
+            data[address + 2] = size.x;
             data[address + 3] = size.y;
         }
 

package/src/engine/graphics/texture/atlas/CachingTextureAtlas.js

@@ -150,7 +150,7 @@ export class CachingTextureAtlas extends AbstractTextureAtlas {
      * @private
      */
     __evict_all() {
-        for (let i = this.__cached_patches.length - 1; i > 0; i--) {
+        for (let i = this.__cached_patches.length - 1; i >= 0; i--) {
             this.__evict(i);
         }
     }

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.js

@@ -90,7 +90,7 @@ export function sampler2d_scale_down_lanczos(source, destination, lobes = 2) {
     const ratio_x = source_width / d_w;
     const ratio_y = source_height / d_h;
 
-    const rcp_ratio_y = 2 / ratio_x;
+    const rcp_ratio_y = 2 / ratio_y;
     const rcp_ratio_x = 2 / ratio_x;
 
 

package/src/engine/graphics/texture/sampler/sampler2d_copy_with_margins.js

@@ -121,7 +121,7 @@ export function sampler2d_copy_with_margins(
 
     //Write Bottom-left margin
     sOffset = (sourceY + height - 1) * sRowSize + sourceX * dItemSize;
-    for (y = destinationY + width, yMax = Math.min(destination.height, y + marginBottom); y < yMax; y++) {
+    for (y = destinationY + height, yMax = Math.min(destination.height, y + marginBottom); y < yMax; y++) {
         dA = y * dRowSize;
 
         for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
@@ -135,7 +135,7 @@ export function sampler2d_copy_with_margins(
     }
     //Write Bottom margin
     sA = (sourceY + height - 1) * sRowSize;
-    for (y = destinationY + width, yMax = Math.min(destination.height, y + marginBottom); y < yMax; y++) {
+    for (y = destinationY + height, yMax = Math.min(destination.height, y + marginBottom); y < yMax; y++) {
         dA = y * dRowSize;
 
         for (x = 0; x < width; x++) {
@@ -149,7 +149,7 @@ export function sampler2d_copy_with_margins(
     }
     //Write Bottom-right margin
     sOffset = (sourceY + height - 1) * sRowSize + (sourceX + width - 1) * dItemSize;
-    for (y = destinationY + width, yMax = Math.min(destination.height, y + marginBottom); y < yMax; y++) {
+    for (y = destinationY + height, yMax = Math.min(destination.height, y + marginBottom); y < yMax; y++) {
         dA = y * dRowSize;
 
         for (x = destinationX + width, xMax = Math.min(destination.width, x + marginRight); x < xMax; x++) {

package/src/engine/graphics/util/build_max_height_pyramid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_max_height_pyramid.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/util/build_max_height_pyramid.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8DAFa,kBAAkB,CA2G9B;mCAxI4F,OAAO"}
+{"version":3,"file":"build_max_height_pyramid.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/util/build_max_height_pyramid.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8DAFa,kBAAkB,CA8G9B;mCA3I4F,OAAO"}

package/src/engine/graphics/util/build_max_height_pyramid.js

@@ -44,8 +44,11 @@ export function build_max_height_pyramid(sampler) {
         let prevData = sampler.data;
 
         while (prevW > 1 || prevH > 1) {
-            const curW = Math.max(1, prevW >> 1);
-            const curH = Math.max(1, prevH >> 1);
+            // round UP so an odd dimension's last row/column is still folded
+            // into a coarse texel (the sx1/sy1 clamps below cover the overhang);
+            // a floor here would drop it and make the Hi-Z pyramid under-report.
+            const curW = Math.max(1, (prevW + 1) >> 1);
+            const curH = Math.max(1, (prevH + 1) >> 1);
             const curData = new Float32Array(curW * curH);
 
             const lastSrcX = prevW - 1;

package/src/engine/grid/transform2grid/Transform2GridPositionSystem.js

@@ -53,7 +53,7 @@ class Synchronizer {
                 break;
 
             case Transform2GridPositionMode.Ceil:
-                v2.floor();
+                v2.ceil();
                 break;
 
             case Transform2GridPositionMode.Round:

package/src/engine/input/devices/KeyboardDevice.d.ts

@@ -1,14 +1,61 @@
-import {InputDeviceSwitch} from "./InputDeviceSwitch";
-import Signal from "../../../core/events/signal/Signal";
-
-export default class KeyboardDevice {
-    constructor(domElement:EventTarget|Element)
-
-    readonly on: {up:Signal,down:Signal}
-
-    readonly keys:{[key:string]:InputDeviceSwitch}
-
-    start():void
-
-    stop():void
-}
+export default KeyboardDevice;
+/**
+ * Provides keyboard input.
+ * Listens for key events on a DOM element and provides signals and state for key presses.
+ * NOTE: if the bound element loses focus within the page (e.g. you hold "A" and click on some other element),
+ * the key remains pressed and the eventual physical release is picked up at the window level.
+ * NOTE: when the window itself loses focus (e.g. switching to another application), key releases can no longer
+ * be observed at all, so any "pressed" keys are forcibly released with the appropriate signal.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+declare class KeyboardDevice {
+    /**
+     * @param {EventTarget|Element} domElement The DOM element to listen for keyboard events on.  This element *must* be focusable (e.g., have a `tabindex` attribute).
+     * @throws {TypeError} If the provided `domElement` is not focusable and doesn't have a `tabindex` attribute.
+     */
+    constructor(domElement: EventTarget | Element);
+    /**
+     * @readonly
+     */
+    readonly on: {
+        /**
+         * Fires when any key is pressed
+         * @type {Signal<KeyboardEvent>}
+         */
+        down: Signal<KeyboardEvent>;
+        /**
+         * Fires when any key is released
+         * @type {Signal<KeyboardEvent>}
+         */
+        up: Signal<KeyboardEvent>;
+    };
+    /**
+     * See {@link KeyCodes} for valid IDs
+     * @readonly
+     * @type {Object<InputDeviceSwitch>}
+     *
+     * @example
+     *   const is_enter_pressed = keyboard.keys.enter.is_down;
+     */
+    readonly keys: any;
+    /**
+     * The DOM element being listened to.
+     * @type {EventTarget}
+     */
+    domElement: EventTarget;
+    /**
+     * Starts listening for keyboard events on the associated DOM element.
+     * @returns {void}
+     */
+    start(): void;
+    /**
+     * Stops listening for keyboard events.
+     * @returns {void}
+     */
+    stop(): void;
+    #private;
+}
+import Signal from "../../../core/events/signal/Signal.js";
+//# sourceMappingURL=KeyboardDevice.d.ts.map

package/src/engine/input/devices/KeyboardDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KeyboardDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyboardDevice.js"],"names":[],"mappings":";AAYA;;;;;;;;GAQG;AACH;IA4BI;;;OAGG;IACH,wBAHW,WAAW,GAAC,OAAO,EAgC7B;IA3DD;;OAEG;IACH;QACI;;;WAGG;cADO,OAAO,aAAa,CAAC;QAG/B;;;WAGG;YADO,OAAO,aAAa,CAAC;MAGjC;IAEF;;;;;;;OAOG;IACH,mBAAU;IAkBN;;;OAGG;IACH,YAFU,WAAW,CAEO;IA8FhC;;;OAGG;IACH,SAFa,IAAI,CAahB;IAED;;;OAGG;IACH,QAFa,IAAI,CAahB;;CAEJ;mBArMkB,uCAAuC"}
+{"version":3,"file":"KeyboardDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyboardDevice.js"],"names":[],"mappings":";AAYA;;;;;;;;;;GAUG;AACH;IA4BI;;;OAGG;IACH,wBAHW,WAAW,GAAC,OAAO,EAgC7B;IA3DD;;OAEG;IACH;QACI;;;WAGG;cADO,OAAO,aAAa,CAAC;QAG/B;;;WAGG;YADO,OAAO,aAAa,CAAC;MAGjC;IAEF;;;;;;;OAOG;IACH,mBAAU;IAkBN;;;OAGG;IACH,YAFU,WAAW,CAEO;IA2HhC;;;OAGG;IACH,SAFa,IAAI,CAWhB;IAED;;;OAGG;IACH,QAFa,IAAI,CAUhB;;CAEJ;mBA/NkB,uCAAuC"}

package/src/engine/input/devices/KeyboardDevice.js

@@ -13,8 +13,10 @@ const codeToKeyNameMap = [];
 /**
  * Provides keyboard input.
  * Listens for key events on a DOM element and provides signals and state for key presses.
- * NOTE: when losing focus of the application, any "pressed" keys will be automatically released.
- * For example, if you hold "A" and click over into another application window - A will be forcibly released with appropriate signal.
+ * NOTE: if the bound element loses focus within the page (e.g. you hold "A" and click on some other element),
+ * the key remains pressed and the eventual physical release is picked up at the window level.
+ * NOTE: when the window itself loses focus (e.g. switching to another application), key releases can no longer
+ * be observed at all, so any "pressed" keys are forcibly released with the appropriate signal.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -60,7 +62,7 @@ class KeyboardDevice {
             !isHTMLElementFocusable(domElement)
             && domElement.getAttribute('tabindex') === null
         ) {
-            new TypeError('Supplied element is not inherently focusable and does not have tabindex attribute, so it must have a tabindex attribute in order to be able receive keyboard events. Something like tabindex=0 would suffice.');
+            throw new TypeError('Supplied element is not inherently focusable and does not have tabindex attribute, so it must have a tabindex attribute in order to be able receive keyboard events. Something like tabindex=0 would suffice.');
         }
 
         /**
@@ -149,12 +151,41 @@ class KeyboardDevice {
 
     }
 
+    /**
+     * Recovery handler for key releases that happen while the bound element does not have focus.
+     * Covers the scenario where a key is pressed on the element, focus is then lost to another
+     * element in the page (e.g. via a mouse click), and only then is the physical key released.
+     * Registered on window in the bubble phase, so for keys released while the element still has
+     * focus the element-scoped handler runs first and this one sees the key as already released.
+     *
+     * @param {KeyboardEvent} event
+     */
+    #handlerWindowKeyUp = (event) => {
+        const keyName = codeToKeyNameMap[event.keyCode];
+
+        if (keyName === undefined) {
+            return;
+        }
+
+        const button = this.keys[keyName];
+
+        if (button.is_up) {
+            // key is not tracked as pressed; either it was never pressed via this device,
+            // or the element-scoped handler has already processed this release
+            return;
+        }
+
+        this.on.up.send1(event);
+
+        button.release();
+    }
+
     /**
      *
      * @param {FocusEvent} event
      */
-    #handleGlobalBlurEvent = (event) => {
-        // Element lost focus, we won't be able to capture key-up events
+    #handleWindowBlurEvent = (event) => {
+        // Window lost focus, we won't be able to capture key-up events
         // release all keys
         for (let keyName in KeyCodes) {
             this.keys[keyName].release();
@@ -170,12 +201,10 @@ class KeyboardDevice {
         el.addEventListener(KeyboardEvents.KeyDown, this.#handlerKeyDown);
         el.addEventListener(KeyboardEvents.KeyUp, this.#handlerKeyUp);
 
-        el.addEventListener('blur', this.#handleGlobalBlurEvent);
+        // catch releases of tracked keys that happen after the element lost focus within the page
+        window.addEventListener(KeyboardEvents.KeyUp, this.#handlerWindowKeyUp);
 
-        //https://w3c.github.io/uievents/#event-type-focusout
-        el.addEventListener('focusout', this.#handleGlobalBlurEvent);
-
-        window.addEventListener('blur', this.#handleGlobalBlurEvent);
+        window.addEventListener('blur', this.#handleWindowBlurEvent);
     }
 
     /**
@@ -187,12 +216,9 @@ class KeyboardDevice {
         el.removeEventListener(KeyboardEvents.KeyDown, this.#handlerKeyDown);
         el.removeEventListener(KeyboardEvents.KeyUp, this.#handlerKeyUp);
 
-        el.removeEventListener('blur', this.#handleGlobalBlurEvent);
-
-        //https://w3c.github.io/uievents/#event-type-focusout
-        el.removeEventListener('focusout', this.#handleGlobalBlurEvent);
+        window.removeEventListener(KeyboardEvents.KeyUp, this.#handlerWindowKeyUp);
 
-        window.removeEventListener('blur', this.#handleGlobalBlurEvent);
+        window.removeEventListener('blur', this.#handleWindowBlurEvent);
     }
 
 }

package/src/engine/input/devices/isHTMLElementFocusable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isHTMLElementFocusable.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/isHTMLElementFocusable.js"],"names":[],"mappings":"AAsBA;;;GAGG;AACH,2CAFW,OAAO,WASjB"}
+{"version":3,"file":"isHTMLElementFocusable.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/isHTMLElementFocusable.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH,2CAFW,OAAO,WASjB"}

package/src/engine/input/devices/isHTMLElementFocusable.js

@@ -5,17 +5,10 @@
  * @returns {boolean}
  */
 function isInstanceOf(thing, klass) {
-    if (klass === undefined) {
+    // constructors are functions; the check also guards against the class being absent in the environment
+    if (typeof klass !== "function") {
         return false;
     }
-    if (klass === null) {
-        return false;
-    }
-
-    if (typeof klass !== "object") {
-        return false;
-    }
-
 
     return thing instanceof klass;
 }

package/src/engine/input/ecs/components/InputBinding.d.ts

@@ -4,8 +4,9 @@ export class InputBinding {
      * @param {string} path
      * @param {function} listener
      * @param {boolean} [exclusive=false]
+     * @param {number} [priority=0] higher priority bindings on the same path are dispatched first
      */
-    constructor({ path, listener, exclusive }: string);
+    constructor({ path, listener, exclusive, priority }: string);
     /**
      *
      * @type {string}
@@ -21,5 +22,10 @@ export class InputBinding {
      * @type {boolean}
      */
     exclusive: boolean;
+    /**
+     * Higher priority bindings on the same path are dispatched first.
+     * @type {number}
+     */
+    priority: number;
 }
 //# sourceMappingURL=InputBinding.d.ts.map

package/src/engine/input/ecs/components/InputBinding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InputBinding.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/components/InputBinding.js"],"names":[],"mappings":"AAEA;IACI;;;;;OAKG;IACH,2CAJW,MAAM,EAwBhB;IAfG;;;OAGG;IACH,MAFU,MAAM,CAEA;IAChB;;;OAGG;IACH,mBAAwB;IACxB;;;OAGG;IACH,WAFU,OAAO,CAES;CAEjC"}
+{"version":3,"file":"InputBinding.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/components/InputBinding.js"],"names":[],"mappings":"AAEA;IACI;;;;;;OAMG;IACH,qDALW,MAAM,EA+BhB;IApBG;;;OAGG;IACH,MAFU,MAAM,CAEA;IAChB;;;OAGG;IACH,mBAAwB;IACxB;;;OAGG;IACH,WAFU,OAAO,CAES;IAC1B;;;OAGG;IACH,UAFU,MAAM,CAEQ;CAE/B"}

package/src/engine/input/ecs/components/InputBinding.js

@@ -6,11 +6,13 @@ export class InputBinding {
      * @param {string} path
      * @param {function} listener
      * @param {boolean} [exclusive=false]
+     * @param {number} [priority=0] higher priority bindings on the same path are dispatched first
      */
-    constructor({ path, listener, exclusive = false }) {
+    constructor({ path, listener, exclusive = false, priority = 0 }) {
         assert.isString(path, 'path');
         assert.isFunction(listener, 'listener');
         assert.isBoolean(exclusive, 'exclusive');
+        assert.isNumber(priority, 'priority');
 
         /**
          *
@@ -27,5 +29,10 @@ export class InputBinding {
          * @type {boolean}
          */
         this.exclusive = exclusive;
+        /**
+         * Higher priority bindings on the same path are dispatched first.
+         * @type {number}
+         */
+        this.priority = priority;
     }
 }

package/src/engine/input/ecs/systems/InputControllerSystem.js

@@ -103,7 +103,7 @@ function getOrCreateProxy(proxies, path, signal) {
                 } else if (!a.exclusive && b.exclusive) {
                     return 1;
                 } else {
-                    return b.priotity - a.priority;
+                    return b.priority - a.priority;
                 }
             });
         }

package/src/engine/intelligence/behavior/decorator/OverrideContextBehavior.d.ts

@@ -5,9 +5,10 @@ export class OverrideContextBehavior extends AbstractDecoratorBehavior {
      * @param {Behavior} source
      * @return {OverrideContextBehavior}
      */
-    static from(context: any, source: Behavior): OverrideContextBehavior;
+    static from(context: any, source: Behavior<any>): OverrideContextBehavior;
     __override_context: {};
     tick(timeDelta: any): import("../BehaviorStatus.js").BehaviorStatus;
 }
 import { AbstractDecoratorBehavior } from "./AbstractDecoratorBehavior.js";
+import { Behavior } from "../Behavior.js";
 //# sourceMappingURL=OverrideContextBehavior.d.ts.map

package/src/engine/intelligence/behavior/decorator/OverrideContextBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OverrideContextBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/decorator/OverrideContextBehavior.js"],"names":[],"mappings":"AAEA;IAII;;;;;OAKG;IACH,6CAFY,uBAAuB,CASlC;IAfD,uBAAwB;IAiBxB,oEAIC;CASJ;0CAlCyC,gCAAgC"}
+{"version":3,"file":"OverrideContextBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/decorator/OverrideContextBehavior.js"],"names":[],"mappings":"AAGA;IAII;;;;;OAKG;IACH,kDAFY,uBAAuB,CASlC;IAfD,uBAAwB;IAiBxB,oEAIC;CAYJ;0CArCyC,gCAAgC;yBADjD,gBAAgB"}

package/src/engine/intelligence/behavior/decorator/OverrideContextBehavior.js

@@ -1,3 +1,4 @@
+import { Behavior } from "../Behavior.js";
 import { AbstractDecoratorBehavior } from "./AbstractDecoratorBehavior.js";
 
 export class OverrideContextBehavior extends AbstractDecoratorBehavior {
@@ -26,10 +27,13 @@ export class OverrideContextBehavior extends AbstractDecoratorBehavior {
     }
 
     initialize(context) {
-        super.initialize(context);
-
         const child_context = Object.assign({}, context, this.__override_context);
 
         this.__source.initialize(child_context);
+
+        // NOTE: deliberately not super.initialize() — AbstractDecoratorBehavior
+        // would re-initialize the source a second time with the un-overridden
+        // context. Do only the Behavior-level self-init.
+        Behavior.prototype.initialize.call(this, context);
     }
 }

package/src/engine/intelligence/behavior/selector/WeightedElement.js

@@ -58,7 +58,7 @@ export class WeightedElement {
      */
     equals(other) {
         return this.weight === other.weight
-            && invokeObjectEquals(this.data, other.element);
+            && invokeObjectEquals(this.data, other.data);
     }
 
     /**

package/src/engine/knowledge/database/StaticKnowledgeDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticKnowledgeDatabase.d.ts","sourceRoot":"","sources":["../../../../../src/engine/knowledge/database/StaticKnowledgeDatabase.js"],"names":[],"mappings":"mCAWU,MAAM;;;;;;;AAShB;IAEI;;;OAGG;IACH,SAFU,aAAa,oBAAoB,CAAC,CAEmC;IAG/E;;;;OAIG;IACH,gBAAa;IAQb;;;OAGG;IACH,qCAEC;IAGD;;OAEG;IACH,cAUC;IAED;;;;;OAKG;IACH,QAJW,MAAM,QACN,MAAM,yCAiChB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,0CAAmC,SAAS,CAkBxD;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,gCAA4B,SAAS,CAUjD;IAGD;;;OAGG;IACH,wBAcC;IAED;;;;OAIG;IACH,qDAiBC;IAGD;;;;;;OAMG;IACH,qBAQC;IAED;;;;;OAKG;IACH,mEAmBC;IAED;;;;;;;OAOG;IACH,qBAeC;IAED;;;;;;OAMG;IACH,mBAIC;IAED;;;;;OAKG;IACH,mEAmCC;IAGL,mCAA2D;;CAF1D;yBArTwB,qCAAqC;mDAIX,yCAAyC"}
+{"version":3,"file":"StaticKnowledgeDatabase.d.ts","sourceRoot":"","sources":["../../../../../src/engine/knowledge/database/StaticKnowledgeDatabase.js"],"names":[],"mappings":"mCAWU,MAAM;;;;;;;AAShB;IAEI;;;OAGG;IACH,SAFU,aAAa,oBAAoB,CAAC,CAEmC;IAG/E;;;;OAIG;IACH,gBAAa;IAQb;;;OAGG;IACH,qCAEC;IAGD;;OAEG;IACH,cAUC;IAED;;;;;OAKG;IACH,QAJW,MAAM,QACN,MAAM,yCAiChB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,0CAAmC,SAAS,CAkBxD;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,gCAA4B,SAAS,CAUjD;IAGD;;;OAGG;IACH,wBAcC;IAED;;;;OAIG;IACH,qDAiBC;IAGD;;;;;;OAMG;IACH,qBAQC;IAED;;;;;OAKG;IACH,mEAiBC;IAED;;;;;;;OAOG;IACH,qBAeC;IAED;;;;;;OAMG;IACH,mBAIC;IAED;;;;;OAKG;IACH,mEAmCC;IAGL,mCAA2D;;CAF1D;yBAnTwB,qCAAqC;mDAIX,yCAAyC"}

package/src/engine/knowledge/database/StaticKnowledgeDatabase.js

@@ -214,7 +214,7 @@ export class StaticKnowledgeDatabase {
 
             const promise = this.__link_table(d, am, executor);
 
-            promise.catch((e) => {
+            return promise.catch((e) => {
                 /**
                  *
                  * @type {StaticKnowledgeDataTable}
@@ -225,9 +225,7 @@ export class StaticKnowledgeDatabase {
             });
         });
 
-        return Promise.all([
-            promises
-        ]);
+        return Promise.all(promises);
     }
 
     /**

package/src/engine/logging/elastic/ElasticSearchLogger.d.ts

@@ -38,7 +38,7 @@ export class ElasticSearchLogger extends LoggerBackend {
      * @type {number}
      * @private
      */
-    private __timeout_ms;
+    private __timeout;
     /**
      *
      * @type {any}
@@ -46,7 +46,6 @@ export class ElasticSearchLogger extends LoggerBackend {
      */
     private __bound_flush;
     flush(): void;
-    __timeout: number | NodeJS.Timeout;
     __prod(): void;
     log(level: any, message: any): void;
 }

package/src/engine/logging/elastic/ElasticSearchLogger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ElasticSearchLogger.d.ts","sourceRoot":"","sources":["../../../../../src/engine/logging/elastic/ElasticSearchLogger.js"],"names":[],"mappings":"AAmCA;IACI;;;OAqDC;IA/CG;;;;OAIG;IACH,iBAA2B;IAE3B;;;;OAIG;IACH,qBAAuB;IACvB;;;;OAIG;IACH,wBAA2B;IAE3B;;;;OAIG;IACH,cAAgB;IAEhB;;;;OAIG;IACH,iBAAsB;IAEtB;;;;OAIG;IACH,qBAAsB;IAEtB;;;;OAIG;IACH,sBAA0C;IAG9C,cAuCC;IAlCO,mCAAmB;IAoC3B,eAOC;IAED,oCAUC;CACJ;8BAvJ6B,qBAAqB"}
+{"version":3,"file":"ElasticSearchLogger.d.ts","sourceRoot":"","sources":["../../../../../src/engine/logging/elastic/ElasticSearchLogger.js"],"names":[],"mappings":"AAmCA;IACI;;;OAqDC;IA/CG;;;;OAIG;IACH,iBAA2B;IAE3B;;;;OAIG;IACH,qBAAuB;IACvB;;;;OAIG;IACH,wBAA2B;IAE3B;;;;OAIG;IACH,cAAgB;IAEhB;;;;OAIG;IACH,iBAAsB;IAEtB;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,sBAA0C;IAG9C,cA2CC;IAED,eAOC;IAED,oCAUC;CACJ;8BA3J6B,qBAAqB"}