@woosh/meep-engine 3.45.0 → 3.47.0

package/src/engine/graphics3/GPUParticleEmitterSystem.js

@@ -833,6 +833,12 @@ export class GPUParticleEmitterSystem extends System {
  * to. Layout and program are shared by reference, never copied — two entities of one effect belong
  * on one program id in the heap.
  *
+ * Every field is compared by name, and that is load-bearing rather than style. Through a shared
+ * `assign(target, field, value)` the one `target[field]` access saw all thirteen names, went
+ * megamorphic, and read numbers back boxed, while the call boxed the value it was handed: 228 B and
+ * ~120 ns per emitter per call, against nothing and ~9 ns written out like this
+ * (`GPUParticleEmitterSystem.allocation.spec.js`). This runs for every live emitter twice a frame.
+ *
  * @param {ParticleEmitter} emitter
  * @param {ParticleEffect} effect
  * @returns {boolean} whether the emitter differs from what it held before
@@ -840,45 +846,82 @@ export class GPUParticleEmitterSystem extends System {
 export function apply_particle_effect(emitter, effect) {
     let changed = false;
 
-    changed = assign(emitter, "layout", effect.layout) || changed;
-    changed = assign(emitter, "program", effect.program) || changed;
-    changed = assign(emitter, "texture", effect.texture) || changed;
-    changed = assign(emitter, "seed", effect.seed) || changed;
-    changed = assign(emitter, "spawn_rate", effect.effective_spawn_rate) || changed;
-    changed = assign(emitter, "prewarm", effect.prewarm) || changed;
-    changed = assign(emitter, "flags", effect.flags) || changed;
-    changed = assign(emitter, "render_position", effect.render_position) || changed;
-    changed = assign(emitter, "render_size", effect.render_size) || changed;
-    changed = assign(emitter, "render_color", effect.render_color) || changed;
-    changed = assign(emitter, "render_rotation", effect.render_rotation) || changed;
-    changed = assign(emitter, "render_frame", effect.render_frame) || changed;
-    changed = assign(emitter, "render_velocity", effect.render_velocity) || changed;
+    if (emitter.layout !== effect.layout) {
+        emitter.layout = effect.layout;
+        changed = true;
+    }
 
-    const flipbook = emitter.flipbook;
+    if (emitter.program !== effect.program) {
+        emitter.program = effect.program;
+        changed = true;
+    }
 
-    if (flipbook[0] !== effect.flipbook[0] || flipbook[1] !== effect.flipbook[1]) {
-        flipbook.set(effect.flipbook);
+    if (emitter.texture !== effect.texture) {
+        emitter.texture = effect.texture;
+        changed = true;
+    }
 
+    if (emitter.seed !== effect.seed) {
+        emitter.seed = effect.seed;
         changed = true;
     }
 
-    return changed;
-}
+    const spawn_rate = effect.effective_spawn_rate;
 
-/**
- * @param {object} target
- * @param {string} field
- * @param {*} value
- * @returns {boolean} whether the field held something else
- */
-function assign(target, field, value) {
-    if (target[field] === value) {
-        return false;
+    if (emitter.spawn_rate !== spawn_rate) {
+        emitter.spawn_rate = spawn_rate;
+        changed = true;
+    }
+
+    if (emitter.prewarm !== effect.prewarm) {
+        emitter.prewarm = effect.prewarm;
+        changed = true;
     }
 
-    target[field] = value;
+    if (emitter.flags !== effect.flags) {
+        emitter.flags = effect.flags;
+        changed = true;
+    }
+
+    if (emitter.render_position !== effect.render_position) {
+        emitter.render_position = effect.render_position;
+        changed = true;
+    }
 
-    return true;
+    if (emitter.render_size !== effect.render_size) {
+        emitter.render_size = effect.render_size;
+        changed = true;
+    }
+
+    if (emitter.render_color !== effect.render_color) {
+        emitter.render_color = effect.render_color;
+        changed = true;
+    }
+
+    if (emitter.render_rotation !== effect.render_rotation) {
+        emitter.render_rotation = effect.render_rotation;
+        changed = true;
+    }
+
+    if (emitter.render_frame !== effect.render_frame) {
+        emitter.render_frame = effect.render_frame;
+        changed = true;
+    }
+
+    if (emitter.render_velocity !== effect.render_velocity) {
+        emitter.render_velocity = effect.render_velocity;
+        changed = true;
+    }
+
+    const flipbook = emitter.flipbook;
+
+    if (flipbook[0] !== effect.flipbook[0] || flipbook[1] !== effect.flipbook[1]) {
+        flipbook.set(effect.flipbook);
+
+        changed = true;
+    }
+
+    return changed;
 }
 
 class GPUParticleAtlasExtension extends RenderExtension {

package/src/engine/graphics3/ParticipatingMedia.js

@@ -1,204 +1,204 @@
-import { assert } from "../../core/assert.js";
-import { combine_hash } from "../../core/collection/array/combine_hash.js";
-import { rgb_to_luminance } from "../../core/color/rgb_to_luminance.js";
-import { computeHashFloat } from "../../core/primitives/numbers/computeHashFloat.js";
-import {
-    VOLUMETRIC_PARTICLE_SPEC_FOG,
-    VolumetricsParticleSpec
-} from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
-
-/**
- * Particles per cubic metre of dense fog, which is what a medium is until it is told otherwise.
- * @type {number}
- */
-const DEFAULT_DENSITY = 3e7;
-
-/**
- * @type {number}
- */
-const DEFAULT_FADE_DISTANCE = 0.1;
-
-/**
- * A box of fog, smoke, dust or cloud that an entity carries around.
- *
- * **What is in here is the medium; the {@link Transform} beside it is the box.** Shade's
- * {@link ParticipatingMediaVolume} is a unit cube centred on the origin, posed by a transform — so
- * position, size and orientation are already an ECS concept and there is nothing to restate. Which
- * is also why this component does nothing on its own: {@link ParticipatingMediaSystem} links it
- * against a `Transform` and only that pair becomes a volume.
- *
- * **Three numbers, in two different currencies.** {@link particle_spec} is what a single particle
- * does to light — a Mie solution, physical and reusable — and {@link density} is how many of them
- * there are per cubic metre. The pair is what makes smoke and fog different things rather than the
- * same fog at two strengths. Authoring in raw density means knowing the cross-sections, so
- * {@link target_extinction} exists to author the other way round: say how much light the medium
- * should swallow and let the particle decide the count.
- *
- * @see ParticipatingMediaSystem what turns this into something the renderer draws
- * @see ParticipatingMediaVolume the renderer's own object
- */
-export class ParticipatingMedia {
-
-    /**
-     * Particles per cubic metre.
-     *
-     * Physically a count, so the numbers are large — the default is dense fog — and the useful range
-     * depends entirely on {@link particle_spec}: a cloud droplet blocks far more light than a haze
-     * particle, so the same count of them is a very different medium.
-     *
-     * @type {number}
-     */
-    density = DEFAULT_DENSITY;
-
-    /**
-     * What one particle of this medium does to light.
-     *
-     * Defaults to fog. The generated `MIE_PARTICLES_STANDARD_PRECOMPUTED` library is where the
-     * physically meaningful values live — `VolumetricsParticleSpec.fromMeep` converts an entry of it
-     * into one of these.
-     *
-     * @type {VolumetricsParticleSpec}
-     */
-    particle_spec = VolumetricsParticleSpec.fromJSON(VOLUMETRIC_PARTICLE_SPEC_FOG);
-
-    /**
-     * How far in from the box's faces the medium fades out, in metres.
-     *
-     * **World-space, and deliberately not scaled by the transform**, so a 0.5 here is half a metre
-     * of softness whether the volume is a metre across or a hundred. Zero gives the box hard edges,
-     * which is visible as a straight line across the screen wherever the box crosses the view.
-     *
-     * @type {number}
-     */
-    fade_distance = DEFAULT_FADE_DISTANCE;
-
-    /**
-     * The medium's extinction per metre, which is {@link density} expressed in what it does rather
-     * than in how many particles it took.
-     *
-     * The point of it is that it is comparable across particles: a smoke volume and a fog volume set
-     * to the same target extinction swallow the same amount of light, while the same *density* in
-     * both would differ by orders of magnitude.
-     *
-     * **Derived, not stored** — writing it sets {@link density}, and changing `particle_spec`
-     * afterwards therefore changes what reading it back gives. The density is what survives a save.
-     *
-     * @returns {number}
-     */
-    get target_extinction() {
-        return this.density * rgb_to_luminance(...this.particle_spec.extinction);
-    }
-
-    /**
-     * @param {number} value
-     */
-    set target_extinction(value) {
-        assert.isNumber(value, 'target_extinction');
-        assert.isFinite(value, 'target_extinction');
-
-        const density = value / rgb_to_luminance(...this.particle_spec.extinction);
-
-        /*
-         Catches the one way this goes wrong: a particle spec that extinguishes nothing. A default-
-         constructed `VolumetricsParticleSpec` has zero cross-sections, and asking such a medium to
-         reach any extinction at all needs infinitely many of its particles. Rejecting it here names
-         the mistake; letting it through puts an `Infinity` in the GPU table, where it becomes a
-         screenful of NaN several passes later.
-        */
-        assert.isFinite(density, 'the density this target_extinction implies (the particle spec extinguishes nothing)');
-
-        this.density = density;
-    }
-
-    /**
-     * @param {*} json
-     * @returns {ParticipatingMedia}
-     */
-    static fromJSON(json) {
-        const r = new ParticipatingMedia();
-
-        r.fromJSON(json);
-
-        return r;
-    }
-
-    toJSON() {
-        const spec = this.particle_spec;
-
-        return {
-            density: this.density,
-            fade_distance: this.fade_distance,
-            particle_spec: {
-                scattering: spec.scattering.slice(),
-                extinction: spec.extinction.slice(),
-                radius: spec.radius,
-                g: spec.g
-            }
-        };
-    }
-
-    /**
-     * @param {Object} options
-     * @param {number} [options.density]
-     * @param {number} [options.fade_distance]
-     * @param {object} [options.particle_spec] omitted resets the medium to fog rather than leaving whatever
-     * the component already held — a load has to determine the whole component, or an instance being
-     * reused would carry the previous level's particle into the next one
-     */
-    fromJSON({
-                 density = DEFAULT_DENSITY,
-                 fade_distance = DEFAULT_FADE_DISTANCE,
-                 particle_spec
-             }) {
-        assert.isNumber(density, 'density');
-        assert.isFinite(density, 'density');
-        assert.greaterThanOrEqual(density, 0, 'density must not be negative');
-
-        assert.isNumber(fade_distance, 'fade_distance');
-        assert.isFinite(fade_distance, 'fade_distance');
-        assert.greaterThanOrEqual(fade_distance, 0, 'fade_distance must not be negative');
-
-        this.density = density;
-        this.fade_distance = fade_distance;
-
-        if (particle_spec === undefined) {
-            this.particle_spec.copy(VOLUMETRIC_PARTICLE_SPEC_FOG);
-        } else {
-            this.particle_spec.fromJSON(particle_spec);
-        }
-    }
-
-    /**
-     * **The cross-sections and the radius are left out of this on purpose.** They run to 1e-16 and
-     * 1e-6, and {@link computeHashFloat} collapses anything that small to zero, so mixing them in
-     * would cost a multiply and buy no dispersion at all. A hash is allowed to collide;
-     * {@link equals} is the exact one.
-     *
-     * @returns {number}
-     */
-    hash() {
-        const spec = this.particle_spec;
-
-        return combine_hash(
-            computeHashFloat(this.density),
-            computeHashFloat(this.fade_distance),
-            computeHashFloat(spec.g)
-        );
-    }
-
-    /**
-     * @param {ParticipatingMedia} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.density === other.density
-            && this.fade_distance === other.fade_distance
-            && this.particle_spec.equals(other.particle_spec);
-    }
-}
-
-/**
- * @readonly
- * @type {string}
- */
-ParticipatingMedia.typeName = "ParticipatingMedia";
+import { assert } from "../../core/assert.js";
+import { hash_mix3 } from "../../core/math/hash/hash_mix3.js";
+import { rgb_to_luminance } from "../../core/color/rgb_to_luminance.js";
+import { computeHashFloat } from "../../core/primitives/numbers/computeHashFloat.js";
+import {
+    VOLUMETRIC_PARTICLE_SPEC_FOG,
+    VolumetricsParticleSpec
+} from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
+
+/**
+ * Particles per cubic metre of dense fog, which is what a medium is until it is told otherwise.
+ * @type {number}
+ */
+const DEFAULT_DENSITY = 3e7;
+
+/**
+ * @type {number}
+ */
+const DEFAULT_FADE_DISTANCE = 0.1;
+
+/**
+ * A box of fog, smoke, dust or cloud that an entity carries around.
+ *
+ * **What is in here is the medium; the {@link Transform} beside it is the box.** Shade's
+ * {@link ParticipatingMediaVolume} is a unit cube centred on the origin, posed by a transform — so
+ * position, size and orientation are already an ECS concept and there is nothing to restate. Which
+ * is also why this component does nothing on its own: {@link ParticipatingMediaSystem} links it
+ * against a `Transform` and only that pair becomes a volume.
+ *
+ * **Three numbers, in two different currencies.** {@link particle_spec} is what a single particle
+ * does to light — a Mie solution, physical and reusable — and {@link density} is how many of them
+ * there are per cubic metre. The pair is what makes smoke and fog different things rather than the
+ * same fog at two strengths. Authoring in raw density means knowing the cross-sections, so
+ * {@link target_extinction} exists to author the other way round: say how much light the medium
+ * should swallow and let the particle decide the count.
+ *
+ * @see ParticipatingMediaSystem what turns this into something the renderer draws
+ * @see ParticipatingMediaVolume the renderer's own object
+ */
+export class ParticipatingMedia {
+
+    /**
+     * Particles per cubic metre.
+     *
+     * Physically a count, so the numbers are large — the default is dense fog — and the useful range
+     * depends entirely on {@link particle_spec}: a cloud droplet blocks far more light than a haze
+     * particle, so the same count of them is a very different medium.
+     *
+     * @type {number}
+     */
+    density = DEFAULT_DENSITY;
+
+    /**
+     * What one particle of this medium does to light.
+     *
+     * Defaults to fog. The generated `MIE_PARTICLES_STANDARD_PRECOMPUTED` library is where the
+     * physically meaningful values live — `VolumetricsParticleSpec.fromMeep` converts an entry of it
+     * into one of these.
+     *
+     * @type {VolumetricsParticleSpec}
+     */
+    particle_spec = VolumetricsParticleSpec.fromJSON(VOLUMETRIC_PARTICLE_SPEC_FOG);
+
+    /**
+     * How far in from the box's faces the medium fades out, in metres.
+     *
+     * **World-space, and deliberately not scaled by the transform**, so a 0.5 here is half a metre
+     * of softness whether the volume is a metre across or a hundred. Zero gives the box hard edges,
+     * which is visible as a straight line across the screen wherever the box crosses the view.
+     *
+     * @type {number}
+     */
+    fade_distance = DEFAULT_FADE_DISTANCE;
+
+    /**
+     * The medium's extinction per metre, which is {@link density} expressed in what it does rather
+     * than in how many particles it took.
+     *
+     * The point of it is that it is comparable across particles: a smoke volume and a fog volume set
+     * to the same target extinction swallow the same amount of light, while the same *density* in
+     * both would differ by orders of magnitude.
+     *
+     * **Derived, not stored** — writing it sets {@link density}, and changing `particle_spec`
+     * afterwards therefore changes what reading it back gives. The density is what survives a save.
+     *
+     * @returns {number}
+     */
+    get target_extinction() {
+        return this.density * rgb_to_luminance(...this.particle_spec.extinction);
+    }
+
+    /**
+     * @param {number} value
+     */
+    set target_extinction(value) {
+        assert.isNumber(value, 'target_extinction');
+        assert.isFinite(value, 'target_extinction');
+
+        const density = value / rgb_to_luminance(...this.particle_spec.extinction);
+
+        /*
+         Catches the one way this goes wrong: a particle spec that extinguishes nothing. A default-
+         constructed `VolumetricsParticleSpec` has zero cross-sections, and asking such a medium to
+         reach any extinction at all needs infinitely many of its particles. Rejecting it here names
+         the mistake; letting it through puts an `Infinity` in the GPU table, where it becomes a
+         screenful of NaN several passes later.
+        */
+        assert.isFinite(density, 'the density this target_extinction implies (the particle spec extinguishes nothing)');
+
+        this.density = density;
+    }
+
+    /**
+     * @param {*} json
+     * @returns {ParticipatingMedia}
+     */
+    static fromJSON(json) {
+        const r = new ParticipatingMedia();
+
+        r.fromJSON(json);
+
+        return r;
+    }
+
+    toJSON() {
+        const spec = this.particle_spec;
+
+        return {
+            density: this.density,
+            fade_distance: this.fade_distance,
+            particle_spec: {
+                scattering: spec.scattering.slice(),
+                extinction: spec.extinction.slice(),
+                radius: spec.radius,
+                g: spec.g
+            }
+        };
+    }
+
+    /**
+     * @param {Object} options
+     * @param {number} [options.density]
+     * @param {number} [options.fade_distance]
+     * @param {object} [options.particle_spec] omitted resets the medium to fog rather than leaving whatever
+     * the component already held — a load has to determine the whole component, or an instance being
+     * reused would carry the previous level's particle into the next one
+     */
+    fromJSON({
+                 density = DEFAULT_DENSITY,
+                 fade_distance = DEFAULT_FADE_DISTANCE,
+                 particle_spec
+             }) {
+        assert.isNumber(density, 'density');
+        assert.isFinite(density, 'density');
+        assert.greaterThanOrEqual(density, 0, 'density must not be negative');
+
+        assert.isNumber(fade_distance, 'fade_distance');
+        assert.isFinite(fade_distance, 'fade_distance');
+        assert.greaterThanOrEqual(fade_distance, 0, 'fade_distance must not be negative');
+
+        this.density = density;
+        this.fade_distance = fade_distance;
+
+        if (particle_spec === undefined) {
+            this.particle_spec.copy(VOLUMETRIC_PARTICLE_SPEC_FOG);
+        } else {
+            this.particle_spec.fromJSON(particle_spec);
+        }
+    }
+
+    /**
+     * **The cross-sections and the radius are left out of this on purpose.** They run to 1e-16 and
+     * 1e-6, and {@link computeHashFloat} collapses anything that small to zero, so mixing them in
+     * would cost a multiply and buy no dispersion at all. A hash is allowed to collide;
+     * {@link equals} is the exact one.
+     *
+     * @returns {number}
+     */
+    hash() {
+        const spec = this.particle_spec;
+
+        return hash_mix3(
+            computeHashFloat(this.density),
+            computeHashFloat(this.fade_distance),
+            computeHashFloat(spec.g)
+        );
+    }
+
+    /**
+     * @param {ParticipatingMedia} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.density === other.density
+            && this.fade_distance === other.fade_distance
+            && this.particle_spec.equals(other.particle_spec);
+    }
+}
+
+/**
+ * @readonly
+ * @type {string}
+ */
+ParticipatingMedia.typeName = "ParticipatingMedia";

package/src/engine/graphics3/animation/AnimationClips.d.ts

@@ -23,6 +23,11 @@
  * clip, take the component off and put another on, which the drivers see as their entity leaving
  * and coming back.
  *
+ * **The entities it keys go no sooner than it does.** While it is on, the drivers hold a row for
+ * every entity a channel keys, as a skin holds its joints'. Removing one of them means taking this
+ * off before the next frame — `prefab_instance_destroy` removes the entities and then the clips, in
+ * one step — or the scene is left holding the row of an entity that is gone.
+ *
  * **Not saved**, for the reason `MeshSkin` is not: the channels key entities that whatever builds
  * the rig creates, and the curves are asset data. A load rebuilds them the way it rebuilds the rig.
  *

package/src/engine/graphics3/animation/AnimationClips.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationClips.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/AnimationClips.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IASI;;;OAGG;IACH,mBAHW,kBAAkB,EAAE,GAClB,cAAc,CAc1B;IAxBD;;;;;OAKG;IACH,OAFU,kBAAkB,EAAE,CAEnB;IAqBf;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC;;kBAUS,MAAM;sBAMN,OAAO;;iCAzEJ,OAAO,yDAAyD,EAAE,kBAAkB"}
+{"version":3,"file":"AnimationClips.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/AnimationClips.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IASI;;;OAGG;IACH,mBAHW,kBAAkB,EAAE,GAClB,cAAc,CAc1B;IAxBD;;;;;OAKG;IACH,OAFU,kBAAkB,EAAE,CAEnB;IAqBf;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC;;kBAUS,MAAM;sBAMN,OAAO;;iCA9EJ,OAAO,yDAAyD,EAAE,kBAAkB"}

package/src/engine/graphics3/animation/AnimationClips.js

@@ -26,6 +26,11 @@ import { assert } from "../../../core/assert.js";
  * clip, take the component off and put another on, which the drivers see as their entity leaving
  * and coming back.
  *
+ * **The entities it keys go no sooner than it does.** While it is on, the drivers hold a row for
+ * every entity a channel keys, as a skin holds its joints'. Removing one of them means taking this
+ * off before the next frame — `prefab_instance_destroy` removes the entities and then the clips, in
+ * one step — or the scene is left holding the row of an entity that is gone.
+ *
  * **Not saved**, for the reason `MeshSkin` is not: the channels key entities that whatever builds
  * the rig creates, and the curves are asset data. A load rebuilds them the way it rebuilds the rig.
  *

package/src/engine/grid/obstacle/GridObstacle.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
 import { computeIntegerArrayHash } from "../../../core/collection/array/computeIntegerArrayHash.js";
 import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
 import Vector2 from '../../../core/geom/Vector2.js';
@@ -235,7 +235,7 @@ class GridObstacle {
      * @returns {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             this.size.hash(),
             computeIntegerArrayHash(this.data, 0, this.data.length)
         );

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

@@ -6,6 +6,7 @@ export default KeyboardDevice;
  * 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.
+ * A key still held when focus returns is pressed again by its next automatic repetition.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

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;;;;;;;;;;GAUG;AACH;IA4BI;;;OAGG;IACH,wBAHW,WAAW,GAAC,OAAO,EAgC7B;IA3DD;;OAEG;IACH;QACI;;;WAGG;;QAEH;;;WAGG;;MAEL;IAEF;;;;;;;OAOG;IACH,mBAAU;IAkBN;;;OAGG;IACH,YAFU,WAAW,CAEO;IA2HhC;;;OAGG;IACH,SAFa,IAAI,CAWhB;IAED;;;OAGG;IACH,QAFa,IAAI,CAUhB;;CAEJ"}
+{"version":3,"file":"KeyboardDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/KeyboardDevice.js"],"names":[],"mappings":";AAYA;;;;;;;;;;;GAWG;AACH;IA4BI;;;OAGG;IACH,wBAHW,WAAW,GAAC,OAAO,EAgC7B;IA3DD;;OAEG;IACH;QACI;;;WAGG;;QAEH;;;WAGG;;MAEL;IAEF;;;;;;;OAOG;IACH,mBAAU;IAkBN;;;OAGG;IACH,YAFU,WAAW,CAEO;IA2HhC;;;OAGG;IACH,SAFa,IAAI,CAWhB;IAED;;;OAGG;IACH,QAFa,IAAI,CAUhB;;CAEJ"}

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

@@ -17,6 +17,7 @@ const codeToKeyNameMap = [];
  * 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.
+ * A key still held when focus returns is pressed again by its next automatic repetition.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -90,14 +91,14 @@ class KeyboardDevice {
      * @private
      */
     #handlerKeyDown = (event) => {
-        if (event.repeat) {
-            // ignore automatic repetition
-            // see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat
-            return;
+        // Automatic repetition is not a new press, so the raw signal skips it,
+        // see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/repeat
+        // It is still proof the key is held: a key released by a window blur, or whose original key-down
+        // never reached the element, is pressed again here. Pressing is idempotent, so a key already held is unaffected.
+        if (!event.repeat) {
+            this.on.down.send1(event);
         }
 
-        this.on.down.send1(event);
-
         let should_prevent_default = false;
 
         //hook up dispatch handler for individual keys

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

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import { invokeObjectEquals } from "../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
@@ -66,7 +66,7 @@ export class WeightedElement {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeHashFloat(this.weight),
             invokeObjectHash(this.data)
         );

package/src/engine/interpolation/Interpolated.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../core/math/hash/hash_mix2.js";
 
 /**
  * Sentinel for {@link Interpolated#key} before assignment. The
@@ -114,7 +114,7 @@ export class Interpolated {
         let h = this.sourceId | 0;
         const ips = this.interpolands;
         for (let i = 0; i < ips.length; i++) {
-            h = combine_hash(h, ips[i].type_id | 0);
+            h = hash_mix2(h, ips[i].type_id | 0);
         }
         return h;
     }