@woosh/meep-engine 3.29.0 → 3.31.0

package/src/engine/graphics3/terrain/TerrainShadeMaterial.js

@@ -0,0 +1,130 @@
+import { ShadeMaterial } from "../../../shade/renderer/material/ShadeMaterial.js";
+import { TERRAIN_MATERIAL_TEMPLATE } from "./TERRAIN_MATERIAL_TEMPLATE.js";
+
+/**
+ * @typedef {{data: Uint8Array, width: number, height: number, depth: number, version: number}} TerrainImage
+ * @typedef {{data: Uint8Array, width: number, height: number, version: number}} TerrainImage2D
+ */
+
+/**
+ * @returns {TerrainImage}
+ */
+function empty_image() {
+    return { data: new Uint8Array(4), width: 1, height: 1, depth: 1, version: 0 };
+}
+
+/**
+ * A terrain's surface as a material: what {@link TERRAIN_MATERIAL_TEMPLATE} needs to draw one
+ * terrain's tiles. {@link TerrainSystem} keeps it current.
+ *
+ * **Two kinds of field, two ways of reaching the GPU.** The images and the per-layer scales carry
+ * versions of their own and are uploaded when those move, every frame the template compares them;
+ * they change while the game runs — the weight map is painted, the overlay is gameplay state — and
+ * moving the material's version for them would restage its metadata row and rebuild the resident
+ * material mirror each time. The uniform fields — {@link inv_world_size}, {@link grid_resolution},
+ * {@link grid_transform}, {@link layer_count} — change when the terrain is resized, regridded or
+ * given layers, and reach the GPU the way every material's fields do: set `needsUpdate`.
+ *
+ * **Identity is the material.** Two terrains with equal settings are still two terrains with their
+ * own textures, so this compares and hashes by identity — the value-keyed caches (the resident
+ * mirror, import dedupe) must not merge them.
+ *
+ * Transient: built from the terrain on load, never serialized or cloned.
+ */
+export class TerrainShadeMaterial extends ShadeMaterial {
+
+    /**
+     * The splat weight array, one r8 layer per terrain layer.
+     *
+     * @type {TerrainImage}
+     */
+    weights = empty_image();
+
+    /**
+     * The layers' diffuse, rgba8 sRGB, one array layer per terrain layer.
+     *
+     * @type {TerrainImage}
+     */
+    layers = empty_image();
+
+    /**
+     * The per-cell rgba map the game paints.
+     *
+     * @type {TerrainImage2D}
+     */
+    overlay = empty_image();
+
+    /**
+     * The sprite repeated in every cell the overlay colours, rgba.
+     *
+     * @type {TerrainImage2D}
+     */
+    sprite = empty_image();
+
+    /**
+     * Two floats per layer: how many times the layer tiles across the terrain on each axis.
+     *
+     * @type {Float32Array}
+     */
+    layer_scales = new Float32Array(0);
+
+    /**
+     * Moves when {@link layer_scales} changes.
+     *
+     * @type {number}
+     */
+    layer_scales_version = 0;
+
+    /**
+     * @type {number}
+     */
+    layer_count = 0;
+
+    /**
+     * `1 / (size × gridScale)` per axis.
+     *
+     * @type {Float32Array}
+     */
+    inv_world_size = new Float32Array(2);
+
+    /**
+     * The terrain's size in cells.
+     *
+     * @type {Float32Array}
+     */
+    grid_resolution = new Float32Array(2);
+
+    /**
+     * Scale in xy, offset in zw.
+     *
+     * @type {Float32Array}
+     */
+    grid_transform = new Float32Array(4);
+
+    /**
+     * @param {ShadeMaterial} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this === other;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        return this.id;
+    }
+}
+
+/**
+ * @readonly
+ * @type {ShadeMaterialTemplate}
+ */
+TerrainShadeMaterial.prototype.template = TERRAIN_MATERIAL_TEMPLATE;
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+TerrainShadeMaterial.prototype.isTerrainShadeMaterial = true;

package/src/engine/graphics3/terrain/chunk_terrain_material_surface.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The terrain's surface: the splat mix and the grid overlay, run where every other surface runs —
+ * in the G-buffer pass, on the pixels the visibility buffer attributes to a tile.
+ *
+ * **Terrain UV is planar, from geometry-space position**, exactly the division the splat pass did
+ * on the position it rebuilt from depth: tile vertices are in terrain space, where the field is
+ * axis-aligned at the origin. Not `uv0` — the tile builder relaxes interior UVs to even out texel
+ * density on slopes, which would bend the weights and the grid away from the planar grid painting
+ * and gameplay use.
+ *
+ * **The gradients are the position's own, unbiased** — the splat pass's were off the surface plane,
+ * which for a planar triangle are the same derivatives — so every layer keeps the mip level and
+ * anisotropy it had.
+ *
+ * **Only colour is the terrain's.** Roughness 1, metalness 0, full ambient, the vertex normal and
+ * no emission are what the flat material the tiles drew with before gave the G-buffer, and are the
+ * contract's defaults. The ground is forced opaque before the overlay goes on, as it always was.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_terrain_material_surface: CodeChunk;
+import { CodeChunk } from "../../../shade/renderer/shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_terrain_material_surface.d.ts.map

package/src/engine/graphics3/terrain/chunk_terrain_material_surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_terrain_material_surface.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/terrain/chunk_terrain_material_surface.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,6CAFU,SAAS,CA4CjB;0BAlEwB,sDAAsD"}

package/src/engine/graphics3/terrain/chunk_terrain_material_surface.js

@@ -0,0 +1,68 @@
+import { chunk_material_surface_contract } from "../../../shade/renderer/material/template/chunk_material_surface.js";
+import { CodeChunk } from "../../../shade/renderer/shader/compiler/CodeChunk.js";
+import { chunk_terrain_grid_overlay } from "./chunk_terrain_grid_overlay.js";
+import { chunk_terrain_splat_mix } from "./chunk_terrain_splat_mix.js";
+
+/**
+ * The terrain's surface: the splat mix and the grid overlay, run where every other surface runs —
+ * in the G-buffer pass, on the pixels the visibility buffer attributes to a tile.
+ *
+ * **Terrain UV is planar, from geometry-space position**, exactly the division the splat pass did
+ * on the position it rebuilt from depth: tile vertices are in terrain space, where the field is
+ * axis-aligned at the origin. Not `uv0` — the tile builder relaxes interior UVs to even out texel
+ * density on slopes, which would bend the weights and the grid away from the planar grid painting
+ * and gameplay use.
+ *
+ * **The gradients are the position's own, unbiased** — the splat pass's were off the surface plane,
+ * which for a planar triangle are the same derivatives — so every layer keeps the mip level and
+ * anisotropy it had.
+ *
+ * **Only colour is the terrain's.** Roughness 1, metalness 0, full ambient, the vertex normal and
+ * no emission are what the flat material the tiles drew with before gave the G-buffer, and are the
+ * contract's defaults. The ground is forced opaque before the overlay goes on, as it always was.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_terrain_material_surface = CodeChunk.from(
+    //language=WGSL
+    `
+fn material_surface(s: MaterialSurfaceInput) -> MaterialSurfaceOutput {
+
+    // the terrain is an axis-aligned field in its own space: uv is a division, not a mapping
+    let terrain_uv = s.position_os.xz * terrain.inv_world_size;
+
+    let duv_dx = s.position_os_ddx.xz * terrain.inv_world_size;
+    let duv_dy = s.position_os_ddy.xz * terrain.inv_world_size;
+
+    var ground = terrain_splat_mix(
+        layer_diffuse, layer_sampler,
+        splat_weights, splat_sampler,
+        &layer_scales, terrain.layer_count,
+        terrain_uv, duv_dx, duv_dy
+    );
+
+    // the ground is opaque before the overlay goes on, exactly as the legacy shader forces it
+    ground.a = 1.0;
+
+    let grid_position = (s.position_os.xz - terrain.grid_transform.zw) / terrain.grid_transform.xy;
+
+    let overlay = terrain_grid_overlay(
+        overlay_map, overlay_sprite, sprite_sampler,
+        grid_position, vec2<i32>(terrain.grid_resolution)
+    );
+
+    let textured = terrain_overlay_blend(ground, overlay);
+
+    var out = material_surface_default();
+
+    out.albedo = textured.rgb;
+
+    return out;
+}
+`,
+    [
+        chunk_material_surface_contract,
+        chunk_terrain_splat_mix,
+        chunk_terrain_grid_overlay,
+    ]
+);

package/src/engine/graphics3/trail/trail_tube_write_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trail_tube_write_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/trail/trail_tube_write_geometry.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4EAFa,IAAI,CAgEhB"}
+{"version":3,"file":"trail_tube_write_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/trail/trail_tube_write_geometry.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4EAFa,IAAI,CAgEhB"}

package/src/engine/graphics3/trail/trail_tube_write_geometry.js

@@ -1,5 +1,8 @@
 import { assert } from "../../../core/assert.js";
-import { Attribute } from "../../../shade/renderer/geometry/Attribute.js";
+import {
+    geometry_obtain_attribute,
+    geometry_obtain_index
+} from "../../../shade/renderer/geometry/geometry_obtain_attribute.js";
 import { StandardAttributes } from "../../../shade/renderer/geometry/StandardAttributes.js";
 import {
     TUBE_ATTRIBUTE_ADDRESS_ALPHA,
@@ -45,8 +48,8 @@ export function trail_tube_write_geometry(geometry, tube) {
 
     const vertex_count = tube.vertex_count;
 
-    const positions = obtain_attribute(geometry, StandardAttributes.Position, 3, vertex_count);
-    const colors = obtain_attribute(geometry, StandardAttributes.Color, 4, vertex_count);
+    const positions = geometry_obtain_attribute(geometry, StandardAttributes.Position, 3, vertex_count);
+    const colors = geometry_obtain_attribute(geometry, StandardAttributes.Color, 4, vertex_count);
 
     const table = tube.table;
 
@@ -96,63 +99,9 @@ export function trail_tube_write_geometry(geometry, tube) {
 
     const source_indices = tube.indices;
 
-    const indices = obtain_index(geometry, source_indices.length);
+    const indices = geometry_obtain_index(geometry, source_indices.length);
 
     indices.set(source_indices);
 
     geometry.needsUpdate = true;
-}
-
-/**
- * @param {Geometry} geometry
- * @param {string} name
- * @param {number} item_size
- * @param {number} count
- * @returns {Float32Array}
- */
-function obtain_attribute(geometry, name, item_size, count) {
-    const existing = geometry.getAttribute(name);
-
-    if (existing === undefined) {
-        const attribute = Attribute.from(new Float32Array(count * item_size), item_size, name);
-
-        geometry.addAttribute(attribute);
-
-        return attribute.data;
-    }
-
-    if (existing.count !== count) {
-        existing.data = new Float32Array(count * item_size);
-        existing.count = count;
-    }
-
-    existing.needsUpdate = true;
-
-    return existing.data;
-}
-
-/**
- * @param {Geometry} geometry
- * @param {number} count
- * @returns {Uint32Array}
- */
-function obtain_index(geometry, count) {
-    const existing = geometry.index;
-
-    if (existing === null) {
-        const attribute = Attribute.from(new Uint32Array(count), 1, StandardAttributes.Index);
-
-        geometry.index = attribute;
-
-        return attribute.data;
-    }
-
-    if (existing.count !== count) {
-        existing.data = new Uint32Array(count);
-        existing.count = count;
-    }
-
-    existing.needsUpdate = true;
-
-    return existing.data;
-}
+}

package/src/engine/grid/grid2transform/GridPosition2TransformSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridPosition2TransformSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/grid/grid2transform/GridPosition2TransformSystem.js"],"names":[],"mappings":"AAWA;IAOI,cASC;IAfD,2FAAmE;IACnE,mEAEE;IACF,YAAU;IAKN,4CAKC;IAGL;;;;;;OAMG;IACH,gBALW,sBAAsB,MACtB,YAAY,aACZ,WAAW,UACX,MAAM,QAgChB;IAED;;;;;;OAMG;IACH,kBALW,sBAAsB,MACtB,YAAY,aACZ,WAAW,UACX,MAAM,QAQhB;IAED,cAeC;CACJ;uBAhGsB,qBAAqB;4BAEhB,oCAAoC;uCAEzB,6BAA6B;yBAD3C,6BAA6B;4CAJV,oDAAoD"}
+{"version":3,"file":"GridPosition2TransformSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/grid/grid2transform/GridPosition2TransformSystem.js"],"names":[],"mappings":"AAYA;IAOI,cASC;IAfD,2FAAmE;IACnE,mEAEE;IACF,YAAU;IAKN,4CAKC;IAGL;;;;;;OAMG;IACH,gBALW,sBAAsB,MACtB,YAAY,aACZ,WAAW,UACX,MAAM,QAiChB;IAED;;;;;;OAMG;IACH,kBALW,sBAAsB,MACtB,YAAY,aACZ,WAAW,UACX,MAAM,QAQhB;IAED,cAeC;CACJ;uBAlGsB,qBAAqB;4BAEhB,oCAAoC;uCAGzB,6BAA6B;yBAD3C,6BAA6B;4CALV,oDAAoD"}

package/src/engine/grid/grid2transform/GridPosition2TransformSystem.js

@@ -4,6 +4,7 @@ import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessS
 import { System } from '../../ecs/System.js';
 import { obtainTerrain } from "../../ecs/terrain/util/obtainTerrain.js";
 import { Transform64 } from '../../ecs/transform/Transform64.js';
+import { t64_announce_change } from '../../ecs/transform/t64_announce_change.js';
 import GridPosition from '../position/GridPosition.js';
 import { GridPosition2Transform } from './GridPosition2Transform.js';
 import { GridPosition2TransformFlags } from "./GridPosition2TransformFlags.js";
@@ -36,6 +37,7 @@ export class GridPosition2TransformSystem extends System {
      */
     link(component, gp, transform, entity) {
         const mapPoint = this.mapPoint;
+        const em = this.entityManager;
 
         function sync() {
             const transformOffset = component.offset;
@@ -46,7 +48,7 @@ export class GridPosition2TransformSystem extends System {
             const centerX = x + transformOffset.x;
             const centerY = y + transformOffset.y;
 
-            setTransformFromGrid(mapPoint, centerX, centerY, transform);
+            setTransformFromGrid(mapPoint, centerX, centerY, transform, em.dataset, entity);
         }
 
         sync.clear = function () {
@@ -107,12 +109,29 @@ const v3 = new Vector3();
  * @param {number} x
  * @param {number} y
  * @param {Transform64} transform
+ * @param {EntityComponentDataset} ecd
+ * @param {number} entity
  */
-function setTransformFromGrid(mapPointGrid2world, x, y, transform) {
+function setTransformFromGrid(mapPointGrid2world, x, y, transform, ecd, entity) {
     mapPointGrid2world(x, y, v3);
-    const transformPosition = transform.translation;
+
     //check if positions are different
-    if (v3.x !== transformPosition[0] || v3.z !== transformPosition[2]) {
-        transformPosition.setXZ(v3.x, v3.z);
+    if (v3.x === transform.translation_x && v3.z === transform.translation_z) {
+        return;
     }
+
+    /**
+     * `setTranslation`, not `translation.setXZ`: `translation` is a Float64Array view over the
+     * transform's own buffer — freshly allocated on every access — and `setXZ` is a Vector3 method
+     * that exists nowhere else, so the write used to throw. The exception was swallowed by the
+     * signal dispatch on the `gp.onChanged` path, which left the transform silently never moving.
+     */
+    transform.setTranslation(v3.x, transform.translation_y, v3.z);
+
+    /**
+     * A Transform64 carries no signals, so the write is invisible until it is announced — without
+     * this the render placement, the parent/child sync and the spatial audio refit all keep the old
+     * position. Translation-only, so no `updateMatrix` is owed: it is a column of the matrix.
+     */
+    t64_announce_change(ecd, entity);
 }

package/src/engine/grid/transform2grid/Transform2GridPositionSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transform2GridPositionSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/grid/transform2grid/Transform2GridPositionSystem.js"],"names":[],"mappings":"AA+FA;;IACI,2FAAmE;IACnE,oEAEE;IAEF;;;OAGG;IACH,MAFU,YAAY,EAAE,CAEd;IAEV;;;;;;OAMG;IACH,gBALW,sBAAsB,aACtB,WAAW,MACX,YAAY,UACZ,MAAM,QAehB;IAED;;;;;;OAMG;IACH,kBALW,sBAAsB,aACtB,WAAW,MACX,YAAY,UACZ,MAAM,QAYhB;CACJ;uBAnJsB,qBAAqB;4BAGhB,oCAAoC;yBADvC,6BAA6B;uCADf,6BAA6B;4CAMxB,oDAAoD;AAMhG;IACI;;;OAGG;IACH,WAFU,WAAW,CAEJ;IAEjB;;;OAGG;IACH,UAFU,YAAY,CAEN;IAEhB;;;OAGG;IACH,WAFU,sBAAsB,CAEf;IAEjB;;;OAGG;IACH,4BAAW;IAEX,cAgCC;IAGD,aAOC;IALG,iCAA8C;IAOlD,eAUC;CACJ"}
+{"version":3,"file":"Transform2GridPositionSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/grid/transform2grid/Transform2GridPositionSystem.js"],"names":[],"mappings":"AAyGA;;IACI,2FAAmE;IACnE,oEAEE;IAEF;;;OAGG;IACH,MAFU,YAAY,EAAE,CAEd;IAEV;;;;;;OAMG;IACH,gBALW,sBAAsB,aACtB,WAAW,MACX,YAAY,UACZ,MAAM,QAehB;IAED;;;;;;OAMG;IACH,kBALW,sBAAsB,aACtB,WAAW,MACX,YAAY,UACZ,MAAM,QAYhB;CACJ;uBA7JsB,qBAAqB;4BAGhB,oCAAoC;yBADvC,6BAA6B;uCADf,6BAA6B;4CAMxB,oDAAoD;AAMhG;IACI;;;OAGG;IACH,WAFU,WAAW,CAEJ;IAEjB;;;OAGG;IACH,UAFU,YAAY,CAEN;IAEhB;;;OAGG;IACH,WAFU,sBAAsB,CAEf;IAEjB;;;OAGG;IACH,4BAAW;IAEX,cA0CC;IAGD,aAOC;IALG,iCAA8C;IAOlD,eAUC;CACJ"}

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

@@ -39,6 +39,16 @@ class Synchronizer {
     write() {
         const terrain = obtainTerrain(this.ecd);
 
+        if (terrain === null) {
+            // No terrain in the dataset yet. This is driven by TRANSFORM64_EVENT_CHANGE, which
+            // fires from spawners, physics and the attachment system alike, so it can run long
+            // before a level's terrain exists - `Terrain#build` is kicked off from
+            // `TerrainSystem.link`. Dereferencing it threw out of the dataset's event dispatch,
+            // an entity-order-dependent crash during load. The sibling
+            // `GridPosition2TransformSystem` guards the identical call.
+            return;
+        }
+
         // read the raw value
         const transform = this.transform;
 

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

@@ -1 +1 @@
-{"version":3,"file":"PointerDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/PointerDevice.js"],"names":[],"mappings":"AA8MA;;;;;GAKG;AACH,mDAJW,OAAO,SACP,UAAU,GAAC,KAAK,WAChB,OAAO,QAejB;AAED;;;;;GAKG;AACH;IAuFI;;;;OAIG;IACH,wBAHW,WAAW,EAsBrB;IA7GD;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH;;;QAGI;;;;;;WAMG;;;QAGH;;WAEG;;;;;;;;;MASL;IAeF;;;OAGG;IACH,kBAAkB;IAElB;;;;OAIG;IACH,kBAFU,iBAAiB,EAAE,CAEL;IAExB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,2CAEC;IA2GD;;;OAGG;IACH,oBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,4BAsBC;IAED,0BAEC;IAED;;;;OAIG;IACH,qCAHW,OAAO,SACP,UAAU,GAAC,KAAK,QAI1B;IAED,cA6BC;IAED,aAsBC;;CACJ;oBA9gBmB,+BAA+B;mBADhC,uCAAuC;kCAOxB,wBAAwB"}
+{"version":3,"file":"PointerDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/PointerDevice.js"],"names":[],"mappings":"AA2NA;;;;;GAKG;AACH,mDAJW,OAAO,SACP,UAAU,GAAC,KAAK,WAChB,OAAO,QAejB;AAED;;;;;GAKG;AACH;IAuFI;;;;OAIG;IACH,wBAHW,WAAW,EA+BrB;IAtHD;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;OAEG;IACH;;;QAGI;;;;;;WAMG;;;QAGH;;WAEG;;;;;;;;;MASL;IAeF;;;OAGG;IACH,kBAAkB;IAElB;;;;OAIG;IACH,kBAFU,iBAAiB,EAAE,CAEL;IAExB;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,0CAEC;IAED;;;OAGG;IACH,2CAEC;IAyID;;;OAGG;IACH,oBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,4BAsBC;IAED,0BAEC;IAED;;;;OAIG;IACH,qCAHW,OAAO,SACP,UAAU,GAAC,KAAK,QAI1B;IAED,cAiCC;IAED,aA4BC;;CACJ;oBAnkBmB,+BAA+B;mBADhC,uCAAuC;kCAOxB,wBAAwB"}

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

@@ -44,7 +44,12 @@ function observeTap({
         assert.isNonNegativeInteger(id, 'id');
 
         const deleted = active.delete(id);
-        if (deleted) {
+
+        // Only once the last candidate is gone. The subscription is shared - `handleUp` and
+        // `handleMove` are single function references - so tearing it down whenever ANY pointer
+        // resolved unsubscribed the machinery for every other pointer still in flight. A two-finger
+        // tap fired `on.tap` for the first finger only.
+        if (deleted && active.size === 0) {
             up.remove(handleUp);
             move.remove(handleMove);
         }
@@ -117,12 +122,20 @@ function observeTap({
         // make sure to cancel previous pending resolution
         reset(id);
 
+        const was_idle = active.size === 0;
+
         active.set(id, LocationalInteractionMetadata.from(position));
 
-        up.addOne(handleUp);
+        // Subscribed once, for as long as there is any candidate. `addOne` sets
+        // RemoveAfterExecution and `send2` walks the whole handler chain, so the first finger's
+        // `pointerup` executed and consumed EVERY registration - the second finger's release then
+        // arrived with nothing listening.
+        if (was_idle) {
+            up.add(handleUp);
 
-        //track move
-        move.add(handleMove);
+            //track move
+            move.add(handleMove);
+        }
     }
 
     down.add(handleDown);
@@ -339,7 +352,16 @@ export class PointerDevice {
 
 
         //constructed events
-        observeTap({ up: this.on.up, down: this.on.down, move: this.on.move, maxDistance: 10, signal: this.on.tap });
+        // `globalUp`, not `up`, for the same reason observeDrag below uses it: `up` only fires for
+        // a release over the element, so a press that lifted one pixel outside the canvas was
+        // never resolved and never reset - the candidate simply sat in the map.
+        observeTap({
+            up: this.on.globalUp,
+            down: this.on.down,
+            move: this.on.move,
+            maxDistance: 10,
+            signal: this.on.tap
+        });
         observeDrag(this.on.globalUp, this.on.down, this.on.move, this.on.dragStart, this.on.dragEnd, this.on.drag);
 
     }
@@ -388,6 +410,27 @@ export class PointerDevice {
         button?.release();
     }
 
+    /**
+     * Let go of every pressed button.
+     *
+     * A button is pressed on `pointerdown` and released only on a window-level `pointerup`, so a
+     * window that loses focus mid-drag - alt-tab - or a touch stolen by a system edge-swipe, which
+     * delivers `pointercancel` and no `pointerup`, left the button latched down for ever.
+     * `InputMapSystem` keeps the interned index in its held set, so any chord containing it stays
+     * satisfied; and because `press()` is idempotent, the first real click after coming back
+     * produced no rising edge and was swallowed entirely.
+     *
+     * `KeyboardDevice` handles exactly this case on `blur`, and `GamepadDevice.stop()` releases
+     * every button for the same reason. The pointer was the one device of the three that did not,
+     * with `PointerEvents.Cancel` sitting unused in the event table as the tell.
+     */
+    #releaseAllButtons = () => {
+        const buttons = this.buttons;
+
+        for (let i = 0; i < buttons.length; i++) {
+            buttons[i]?.release();
+        }
+    }
 
     /**
      *
@@ -493,6 +536,10 @@ export class PointerDevice {
 
         window.addEventListener(PointerEvents.Up, this.#eventHandlerGlobalPointerUp);
 
+        // the two ways a press ends without a pointerup ever arriving - see #releaseAllButtons
+        window.addEventListener('blur', this.#releaseAllButtons);
+        domElement.addEventListener(PointerEvents.Cancel, this.#releaseAllButtons);
+
         /*
         In some cases wheel event gets registered as "passive" by default. This interferes with "preventDefault()"
         see https://www.chromestatus.com/features/6662647093133312
@@ -521,9 +568,15 @@ export class PointerDevice {
 
         window.removeEventListener(PointerEvents.Up, this.#eventHandlerGlobalPointerUp);
 
+        window.removeEventListener('blur', this.#releaseAllButtons);
+        domElement.removeEventListener(PointerEvents.Cancel, this.#releaseAllButtons);
+
         domElement.removeEventListener(MouseEvents.Wheel, this.#eventHandlerWheel);
 
 
         domElement.removeEventListener("contextmenu", suppressContextMenu);
+
+        // a device that stops mid-drag must not leave the press behind, as GamepadDevice.stop does
+        this.#releaseAllButtons();
     }
 }

package/src/engine/input/ecs/ism/InputMapProgram.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InputMapProgram.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/ism/InputMapProgram.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH;IACI;;OAEG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;;OAIG;IACH,sBAAe;IAEf;;;OAGG;IACH,SAFU,MAAM,EAAE,CAEL;IAEb;;;;OAIG;IACH,kBAFU,MAAM,CAEK;CACxB;AAED;;GAEG;AACH;IACI;;OAEG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,UAFU,wBAAwB,CAEpB;IAEd;;OAEG;IACH,YAFU,MAAM,CAED;CAClB;AAED;;;;;;;;;;GAUG;AACH;IAEI;;OAEG;IACH,QAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,cAAW;IAEX;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;OAEG;IACH,OAFU,MAAM,CAEN;IAEV;;OAEG;IACH,WAFU,cAAc,CAEgB;IAExC;;;;;OAKG;IACH,YAFU,OAAO,CAEE;IAEnB;;OAEG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;OAEG;IACH,aAFU,kBAAkB,EAAE,CAEb;IAEjB;;;OAGG;IACH,UAFU,cAAc,CAEV;IAEd;;;OAGG;IACH,mBAFU,eAAe,EAAE,EAAE,CAEN;IAEvB;;;;OAIG;IACH,iBAFU,eAAe,EAAE,CAEN;IAErB;;;;OAIG;IACH,mBAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,aAAY;IAEZ;;;OAGG;IACH,iBAHW,MAAM,GACJ,OAAO,CAmBnB;IAED;;;;;;;OAOG;IACH,uBAJW,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,UACN,MAAM,QAoDhB;CACJ;+BA3O8B,qBAAqB"}
+{"version":3,"file":"InputMapProgram.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/ism/InputMapProgram.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH;IACI;;OAEG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;;OAIG;IACH,sBAAe;IAEf;;;OAGG;IACH,SAFU,MAAM,EAAE,CAEL;IAEb;;;;OAIG;IACH,kBAFU,MAAM,CAEK;CACxB;AAED;;GAEG;AACH;IACI;;OAEG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,UAFU,wBAAwB,CAEpB;IAEd;;OAEG;IACH,YAFU,MAAM,CAED;CAClB;AAED;;;;;;;;;;GAUG;AACH;IAEI;;OAEG;IACH,QAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,cAAW;IAEX;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;OAEG;IACH,OAFU,MAAM,CAEN;IAEV;;OAEG;IACH,WAFU,cAAc,CAEgB;IAExC;;;;;OAKG;IACH,YAFU,OAAO,CAEE;IAEnB;;OAEG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;OAEG;IACH,aAFU,kBAAkB,EAAE,CAEb;IAEjB;;;OAGG;IACH,UAFU,cAAc,CAEV;IAEd;;;OAGG;IACH,mBAFU,eAAe,EAAE,EAAE,CAEN;IAEvB;;;;OAIG;IACH,iBAFU,eAAe,EAAE,CAEN;IAErB;;;;OAIG;IACH,mBAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,aAAY;IAEZ;;;OAGG;IACH,iBAHW,MAAM,GACJ,OAAO,CAmBnB;IAED;;;;;;;OAOG;IACH,uBAJW,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,UACN,MAAM,QAiEhB;CACJ;+BAxP8B,qBAAqB"}

package/src/engine/input/ecs/ism/InputMapProgram.js

@@ -210,6 +210,19 @@ export class InputMapProgram {
             const held = this.held;
 
             for (let c = 0; c < channels.length; c++) {
+                // Cleared before each read. The scratch is module-level and a channel writes only
+                // its own component count, while the scan and the copy-out below both run over
+                // `entry.dimensions`, which is fixed from channels[0]. A channel of smaller
+                // dimensionality therefore left the tail holding whatever the previous channel -
+                // or a previous action, or a previous frame - put there, and `InputMap.axis3`
+                // faithfully copied it into the caller's vector. `InputCoordinateBinding.from`
+                // asserts that an action's channels agree on `dimensions`, but asserts are
+                // stripped by the consumer, so a mis-authored binding reaches this in a shipped
+                // build.
+                for (let k = 0; k < dimensions; k++) {
+                    SCRATCH[k] = 0;
+                }
+
                 channels[c].read(SCRATCH, 0, held);
 
                 let nonZero = false;

package/src/engine/input/ecs/systems/InputControllerSystem.d.ts

@@ -12,6 +12,7 @@ declare class InputControllerSystem extends System<any> {
     devices: any;
     startup(entityManager: any): Promise<void>;
     proxies: {};
+    shutdown(entityManager: any): Promise<void>;
     /**
      *
      * @param {InputController} component

package/src/engine/input/ecs/systems/InputControllerSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InputControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/systems/InputControllerSystem.js"],"names":[],"mappings":";AAkLA;;;;;GAKG;AACH;IACI,0BA+BC;IA7BG,gCAAsC;IAEtC,yCAAqC;IAErC,aAAsB;IA2B1B,2CAGC;IADG,YAAiB;IAGrB;;;;OAIG;IACH,gBAHW,eAAe,qBAUzB;IAED;;;;OAIG;IACH,kBAHW,eAAe,qBASzB;CACJ;uBAtPsB,wBAAwB;0BADrB,yCAAyC;4BAEvC,kCAAkC"}
+{"version":3,"file":"InputControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/systems/InputControllerSystem.js"],"names":[],"mappings":";AA0NA;;;;;GAKG;AACH;IACI,0BA+BC;IA7BG,gCAAsC;IAEtC,yCAAqC;IAErC,aAAsB;IA2B1B,2CASC;IADG,YAAiB;IAGrB,4CAEC;IAED;;;;OAIG;IACH,gBAHW,eAAe,qBAUzB;IAED;;;;OAIG;IACH,kBAHW,eAAe,qBASzB;CACJ;uBAxSsB,wBAAwB;0BADrB,yCAAyC;4BAEvC,kCAAkC"}

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

@@ -161,6 +161,28 @@ function applyBindings(mapping, devices, proxies) {
     });
 }
 
+/**
+ * Stop every live proxy and forget them.
+ *
+ * The devices outlive the ECS world — they are constructed once and handed in — so a proxy left
+ * subscribed is subscribed for the rest of the process, holding its whole bindings array and every
+ * listener closure in it. `startup` used to simply assign a fresh `proxies` object, which dropped
+ * the references while the handlers stayed registered, so each session added a full set.
+ *
+ * @param {Object} proxies
+ */
+function stopProxies(proxies) {
+    for (const path in proxies) {
+        if (!proxies.hasOwnProperty(path)) {
+            continue;
+        }
+
+        proxies[path].stop();
+
+        delete proxies[path];
+    }
+}
+
 /**
  *
  * @param {List.<InputControllerBinding>} mapping
@@ -170,9 +192,27 @@ function applyBindings(mapping, devices, proxies) {
 function removeBindings(mapping, devices, proxies) {
     mapping.forEach(function (binding) {
         const path = binding.path;
-        const signal = resolvePath(devices, path);
-        const proxy = getOrCreateProxy(proxies, path, signal);
+
+        // A LOOKUP, not getOrCreateProxy. Removing a binding for a path with no live proxy used to
+        // construct one and start it — subscribing to a device signal for the sake of a removal,
+        // and never unsubscribing, because nothing called stop().
+        const proxy = proxies[path];
+
+        if (proxy === undefined) {
+            return;
+        }
+
         proxy.remove(binding);
+
+        if (proxy.bindings.length === 0 && proxy.deferred.length === 0) {
+            // nothing is bound on this path any more, so come off the device signal. Staying on it
+            // costs more than a listener: KeyboardDevice calls preventDefault for any key whose
+            // `down` signal has handlers, so an empty proxy goes on swallowing the browser default
+            // for a key nothing is bound to.
+            proxy.stop();
+
+            delete proxies[path];
+        }
     });
 }
 
@@ -218,9 +258,19 @@ class InputControllerSystem extends System {
 
     async startup(entityManager) {
         this.entityManager = entityManager;
+
+        // a startup without a matching shutdown must not leave the previous set subscribed
+        if (this.proxies !== undefined) {
+            stopProxies(this.proxies);
+        }
+
         this.proxies = {};
     }
 
+    async shutdown(entityManager) {
+        stopProxies(this.proxies);
+    }
+
     /**
      *
      * @param {InputController} component

package/src/engine/intelligence/behavior/composite/ParallelBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParallelBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/composite/ParallelBehavior.js"],"names":[],"mappings":"qCAOU,MAAM;;;;;AAOhB;;;;;;;;;;;;GAYG;AACH;IAkNI;;;;;;OAMG;IACH,sBALW,UAAU,YACV,sBAAsB,YACtB,sBAAsB,GACpB,gBAAgB,CAY5B;IAtND;;;;OAIG;IACH,2BAHW,sBAAsB,iBACtB,sBAAsB,EA2BhC;IA1CD;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,qBAAiB;IAab;;;OAGG;IACH,sBAAkC;IAElC;;;OAGG;IACH,sBAAkC;IAElC;;;;;OAKG;IACH,2BAA6B;IAGjC;;;OAGG;IACH,oBAFY,sBAAsB,CAIjC;IAED;;;OAGG;IACH,yBAFW,sBAAsB,GAAC,MAAM,QAKvC;IAED;;;OAGG;IACH,oBAFY,sBAAsB,CAIjC;IAED;;;OAGG;IACH,yBAFW,sBAAsB,GAAC,MAAM,QAKvC;IA2GD;;;OAGG;IACH,iCAWC;IA+BL;;;OAGG;IACH,6BAFU,OAAO,CAE4B;CAN5C;;kBAUS,MAAM;;kCAtQkB,wBAAwB"}
+{"version":3,"file":"ParallelBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/composite/ParallelBehavior.js"],"names":[],"mappings":"qCAOU,MAAM;;;;;AAOhB;;;;;;;;;;;;GAYG;AACH;IA0NI;;;;;;OAMG;IACH,sBALW,UAAU,YACV,sBAAsB,YACtB,sBAAsB,GACpB,gBAAgB,CAY5B;IA9ND;;;;OAIG;IACH,2BAHW,sBAAsB,iBACtB,sBAAsB,EA2BhC;IA1CD;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,qBAAiB;IAab;;;OAGG;IACH,sBAAkC;IAElC;;;OAGG;IACH,sBAAkC;IAElC;;;;;OAKG;IACH,2BAA6B;IAGjC;;;OAGG;IACH,oBAFY,sBAAsB,CAIjC;IAED;;;OAGG;IACH,yBAFW,sBAAsB,GAAC,MAAM,QAKvC;IAED;;;OAGG;IACH,oBAFY,sBAAsB,CAIjC;IAED;;;OAGG;IACH,yBAFW,sBAAsB,GAAC,MAAM,QAKvC;IA2GD;;;OAGG;IACH,iCAmBC;IA+BL;;;OAGG;IACH,6BAFU,OAAO,CAE4B;CAN5C;;kBAUS,MAAM;;kCA9QkB,wBAAwB"}