@woosh/meep-engine 3.46.0 → 3.49.0

package/src/engine/graphics3/ParticipatingMedia.js

@@ -1,4 +1,5 @@
 import { assert } from "../../core/assert.js";
+import { isArrayEqualStrict } from "../../core/collection/array/isArrayEqualStrict.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";
@@ -18,6 +19,36 @@ const DEFAULT_DENSITY = 3e7;
  */
 const DEFAULT_FADE_DISTANCE = 0.1;
 
+/**
+ * Uniform: the noise is off, and not evaluated.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_STRENGTH = 0;
+
+/**
+ * Metres per repeat of the tile.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_SCALE = 32;
+
+/**
+ * Tile units the warp may displace by.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_WARP = 0.1;
+
+/**
+ * All of the scene's wind.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_WIND_FACTOR = 1;
+
+/**
+ * The engine's tile.
+ * @type {number}
+ */
+export const DEFAULT_NOISE_TEXTURE = 0;
+
 /**
  * A box of fog, smoke, dust or cloud that an entity carries around.
  *
@@ -72,6 +103,52 @@ export class ParticipatingMedia {
      */
     fade_distance = DEFAULT_FADE_DISTANCE;
 
+    /**
+     * Noise on the density, [0, 1]: how far the medium goes from uniform toward the tile's value.
+     * 0 is a uniform medium and costs nothing; 1 is the tile as it is.
+     *
+     * The tile is a slot of the scene's noise atlas ({@link noise_texture}), sampled in world space
+     * and repeating every {@link noise_scale} metres, scrolled by the scene's wind and the medium's
+     * own {@link noise_velocity}, and warped by a second, slower tap of the same tile so the field
+     * changes shape as it moves. See `VOLUMETRIC_NOISE_PLAN_2026_10_15.md`.
+     *
+     * @type {number}
+     */
+    noise_strength = DEFAULT_NOISE_STRENGTH;
+
+    /**
+     * World size of one repeat of the tile, in metres. The engine's tile holds four base features
+     * an edge, so 32 puts them 8 m apart.
+     * @type {number}
+     */
+    noise_scale = DEFAULT_NOISE_SCALE;
+
+    /**
+     * How far the warp tap may displace the lookup, in tile units. 0 is one tap and a field that
+     * only slides.
+     * @type {number}
+     */
+    noise_warp = DEFAULT_NOISE_WARP;
+
+    /**
+     * The medium's own motion for the noise, metres a second along the world axes, added to the
+     * scene's wind — a draught in a corridor the wind does not reach.
+     * @type {number[]}
+     */
+    noise_velocity = [0, 0, 0];
+
+    /**
+     * How much of the scene's wind this medium feels. 1 is all of it, 0 is none.
+     * @type {number}
+     */
+    noise_wind_factor = DEFAULT_NOISE_WIND_FACTOR;
+
+    /**
+     * Which tile: a slot of the scene's noise atlas. 0 is the one the engine bakes.
+     * @type {number}
+     */
+    noise_texture = DEFAULT_NOISE_TEXTURE;
+
     /**
      * The medium's extinction per metre, which is {@link density} expressed in what it does rather
      * than in how many particles it took.
@@ -133,7 +210,13 @@ export class ParticipatingMedia {
                 extinction: spec.extinction.slice(),
                 radius: spec.radius,
                 g: spec.g
-            }
+            },
+            noise_strength: this.noise_strength,
+            noise_scale: this.noise_scale,
+            noise_warp: this.noise_warp,
+            noise_velocity: this.noise_velocity.slice(),
+            noise_wind_factor: this.noise_wind_factor,
+            noise_texture: this.noise_texture,
         };
     }
 
@@ -144,11 +227,23 @@ export class ParticipatingMedia {
      * @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
+     * @param {number} [options.noise_strength] every noise field omitted is its default, for the same reason
+     * @param {number} [options.noise_scale]
+     * @param {number} [options.noise_warp]
+     * @param {number[]} [options.noise_velocity]
+     * @param {number} [options.noise_wind_factor]
+     * @param {number} [options.noise_texture]
      */
     fromJSON({
                  density = DEFAULT_DENSITY,
                  fade_distance = DEFAULT_FADE_DISTANCE,
-                 particle_spec
+                 particle_spec,
+                 noise_strength = DEFAULT_NOISE_STRENGTH,
+                 noise_scale = DEFAULT_NOISE_SCALE,
+                 noise_warp = DEFAULT_NOISE_WARP,
+                 noise_velocity = [0, 0, 0],
+                 noise_wind_factor = DEFAULT_NOISE_WIND_FACTOR,
+                 noise_texture = DEFAULT_NOISE_TEXTURE,
              }) {
         assert.isNumber(density, 'density');
         assert.isFinite(density, 'density');
@@ -158,9 +253,30 @@ export class ParticipatingMedia {
         assert.isFinite(fade_distance, 'fade_distance');
         assert.greaterThanOrEqual(fade_distance, 0, 'fade_distance must not be negative');
 
+        assert.isNumber(noise_strength, 'noise_strength');
+        assert.ok(noise_strength >= 0 && noise_strength <= 1, 'noise_strength must be in [0, 1]');
+        assert.isNumber(noise_scale, 'noise_scale');
+        assert.isFinite(noise_scale, 'noise_scale');
+        assert.greaterThan(noise_scale, 0, 'noise_scale must be positive');
+        assert.isNumber(noise_warp, 'noise_warp');
+        assert.isFinite(noise_warp, 'noise_warp');
+        assert.greaterThanOrEqual(noise_warp, 0, 'noise_warp must not be negative');
+        assert.isArray(noise_velocity, 'noise_velocity');
+        assert.equal(noise_velocity.length, 3, 'noise_velocity must have three components');
+        assert.isNumber(noise_wind_factor, 'noise_wind_factor');
+        assert.isFinite(noise_wind_factor, 'noise_wind_factor');
+        assert.isNonNegativeInteger(noise_texture, 'noise_texture');
+
         this.density = density;
         this.fade_distance = fade_distance;
 
+        this.noise_strength = noise_strength;
+        this.noise_scale = noise_scale;
+        this.noise_warp = noise_warp;
+        this.noise_velocity = noise_velocity.slice();
+        this.noise_wind_factor = noise_wind_factor;
+        this.noise_texture = noise_texture;
+
         if (particle_spec === undefined) {
             this.particle_spec.copy(VOLUMETRIC_PARTICLE_SPEC_FOG);
         } else {
@@ -180,9 +296,21 @@ export class ParticipatingMedia {
         const spec = this.particle_spec;
 
         return hash_mix3(
-            computeHashFloat(this.density),
-            computeHashFloat(this.fade_distance),
-            computeHashFloat(spec.g)
+            hash_mix3(
+                computeHashFloat(this.density),
+                computeHashFloat(this.fade_distance),
+                computeHashFloat(spec.g)
+            ),
+            hash_mix3(
+                computeHashFloat(this.noise_strength),
+                computeHashFloat(this.noise_scale),
+                computeHashFloat(this.noise_warp)
+            ),
+            hash_mix3(
+                computeHashFloat(this.noise_velocity[0] + 3 * this.noise_velocity[1] + 7 * this.noise_velocity[2]),
+                computeHashFloat(this.noise_wind_factor),
+                this.noise_texture
+            )
         );
     }
 
@@ -193,6 +321,12 @@ export class ParticipatingMedia {
     equals(other) {
         return this.density === other.density
             && this.fade_distance === other.fade_distance
+            && this.noise_strength === other.noise_strength
+            && this.noise_scale === other.noise_scale
+            && this.noise_warp === other.noise_warp
+            && this.noise_wind_factor === other.noise_wind_factor
+            && this.noise_texture === other.noise_texture
+            && isArrayEqualStrict(this.noise_velocity, other.noise_velocity)
             && this.particle_spec.equals(other.particle_spec);
     }
 }

package/src/engine/graphics3/ParticipatingMediaSerializationAdapter.d.ts

@@ -1,5 +1,5 @@
 /**
- * Ten numbers, all of them `float64`.
+ * Eighteen numbers, all of them `float64`.
  *
  * **The width is the whole design decision here, and it is not the usual one.** Component adapters
  * around this one write `float32`, which is what the GPU reads anyway — but a participating medium
@@ -9,11 +9,15 @@
  * little. Nothing about the rendered picture would change. What would change is that
  * `ParticipatingMedia.equals` stops answering `true` across a save, and a level that reloads into
  * components which merely *look* like the ones that were saved is a level whose blueprints stop
- * matching. Ten doubles is eighty bytes; that is the price of the round trip being exact.
+ * matching. Eighteen doubles is 144 bytes; that is the price of the round trip being exact. The
+ * noise fields are doubles for the same reason even where an integer would do: one rule, one width.
  *
  * **`target_extinction` is not in the format** because it is not in the component — it is
  * {@link ParticipatingMedia.density} read through the particle spec, and both of its inputs are
  * here.
+ *
+ * Version 1 added the eight noise fields after the ten of version 0;
+ * {@link ParticipatingMediaSerializationUpgrader_0_1} fills them with the defaults on an old save.
  */
 export class ParticipatingMediaSerializationAdapter extends BinaryClassSerializationAdapter<any> {
     constructor();

package/src/engine/graphics3/ParticipatingMediaSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticipatingMediaSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH;;IAEI,iCAA2B;IAG3B;;;OAGG;IACH,uCAFW,kBAAkB,QAkB5B;IAED;;;OAGG;IACH,yCAFW,kBAAkB,QAsB5B;CACJ;gDAxE+C,0DAA0D;mCACvE,yBAAyB"}
+{"version":3,"file":"ParticipatingMediaSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;IACI,iCAA2B;IAG3B;;;OAGG;IACH,uCAFW,kBAAkB,QA6B5B;IAED;;;OAGG;IACH,yCAFW,kBAAkB,QAiC5B;CACJ;gDAjG+C,0DAA0D;mCACvE,yBAAyB"}

package/src/engine/graphics3/ParticipatingMediaSerializationAdapter.js

@@ -2,7 +2,7 @@ import { BinaryClassSerializationAdapter } from "../ecs/storage/binary/BinaryCla
 import { ParticipatingMedia } from "./ParticipatingMedia.js";
 
 /**
- * Ten numbers, all of them `float64`.
+ * Eighteen numbers, all of them `float64`.
  *
  * **The width is the whole design decision here, and it is not the usual one.** Component adapters
  * around this one write `float32`, which is what the GPU reads anyway — but a participating medium
@@ -12,16 +12,19 @@ import { ParticipatingMedia } from "./ParticipatingMedia.js";
  * little. Nothing about the rendered picture would change. What would change is that
  * `ParticipatingMedia.equals` stops answering `true` across a save, and a level that reloads into
  * components which merely *look* like the ones that were saved is a level whose blueprints stop
- * matching. Ten doubles is eighty bytes; that is the price of the round trip being exact.
+ * matching. Eighteen doubles is 144 bytes; that is the price of the round trip being exact. The
+ * noise fields are doubles for the same reason even where an integer would do: one rule, one width.
  *
  * **`target_extinction` is not in the format** because it is not in the component — it is
  * {@link ParticipatingMedia.density} read through the particle spec, and both of its inputs are
  * here.
+ *
+ * Version 1 added the eight noise fields after the ten of version 0;
+ * {@link ParticipatingMediaSerializationUpgrader_0_1} fills them with the defaults on an old save.
  */
 export class ParticipatingMediaSerializationAdapter extends BinaryClassSerializationAdapter {
-
     klass = ParticipatingMedia;
-    version = 0;
+    version = 1;
 
     /**
      * @param {BinaryBuffer} buffer
@@ -43,6 +46,17 @@ export class ParticipatingMediaSerializationAdapter extends BinaryClassSerializa
 
         buffer.writeFloat64(spec.radius);
         buffer.writeFloat64(spec.g);
+
+        buffer.writeFloat64(value.noise_strength);
+        buffer.writeFloat64(value.noise_scale);
+        buffer.writeFloat64(value.noise_warp);
+
+        for (let i = 0; i < 3; i++) {
+            buffer.writeFloat64(value.noise_velocity[i]);
+        }
+
+        buffer.writeFloat64(value.noise_wind_factor);
+        buffer.writeFloat64(value.noise_texture);
     }
 
     /**
@@ -69,5 +83,16 @@ export class ParticipatingMediaSerializationAdapter extends BinaryClassSerializa
 
         spec.radius = buffer.readFloat64();
         spec.g = buffer.readFloat64();
+
+        value.noise_strength = buffer.readFloat64();
+        value.noise_scale = buffer.readFloat64();
+        value.noise_warp = buffer.readFloat64();
+
+        for (let i = 0; i < 3; i++) {
+            value.noise_velocity[i] = buffer.readFloat64();
+        }
+
+        value.noise_wind_factor = buffer.readFloat64();
+        value.noise_texture = buffer.readFloat64();
     }
 }

package/src/engine/graphics3/ParticipatingMediaSerializationUpgrader_0_1.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Version 0 held the ten numbers of the medium; version 1 appends the eight of its noise. An old
+ * save is a medium with the noise it never had, which is the component's default: off.
+ *
+ * @see ParticipatingMediaSerializationAdapter
+ */
+export class ParticipatingMediaSerializationUpgrader_0_1 extends BinaryClassUpgrader {
+}
+import { BinaryClassUpgrader } from "../ecs/storage/binary/BinaryClassUpgrader.js";
+//# sourceMappingURL=ParticipatingMediaSerializationUpgrader_0_1.d.ts.map

package/src/engine/graphics3/ParticipatingMediaSerializationUpgrader_0_1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticipatingMediaSerializationUpgrader_0_1.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSerializationUpgrader_0_1.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;CA2BC;oCApCmC,8CAA8C"}

package/src/engine/graphics3/ParticipatingMediaSerializationUpgrader_0_1.js

@@ -0,0 +1,38 @@
+import { BinaryBuffer } from "../../core/binary/BinaryBuffer.js";
+import { BinaryClassUpgrader } from "../ecs/storage/binary/BinaryClassUpgrader.js";
+import { ParticipatingMedia } from "./ParticipatingMedia.js";
+
+/**
+ * Version 0 held the ten numbers of the medium; version 1 appends the eight of its noise. An old
+ * save is a medium with the noise it never had, which is the component's default: off.
+ *
+ * @see ParticipatingMediaSerializationAdapter
+ */
+export class ParticipatingMediaSerializationUpgrader_0_1 extends BinaryClassUpgrader {
+    __startVersion = 0;
+    __targetVersion = 1;
+
+    /**
+     * @param {BinaryBuffer} source
+     * @param {BinaryBuffer} target
+     */
+    upgrade(source, target) {
+        // density, fade distance, three of scattering, three of extinction, radius, g
+        for (let i = 0; i < 10; i++) {
+            BinaryBuffer.copyFloat64(source, target);
+        }
+
+        const defaults = new ParticipatingMedia();
+
+        target.writeFloat64(defaults.noise_strength);
+        target.writeFloat64(defaults.noise_scale);
+        target.writeFloat64(defaults.noise_warp);
+
+        for (let i = 0; i < 3; i++) {
+            target.writeFloat64(defaults.noise_velocity[i]);
+        }
+
+        target.writeFloat64(defaults.noise_wind_factor);
+        target.writeFloat64(defaults.noise_texture);
+    }
+}

package/src/engine/graphics3/ParticipatingMediaSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticipatingMediaSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSystem.js"],"names":[],"mappings":"AA6IA;;;;;;;;;;GAUG;AACH,yDAJW,wBAAwB,aACxB,kBAAkB,aAClB,WAAW,QAkBrB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8DALW,wBAAwB,aACxB,kBAAkB,aAClB,WAAW,GACT,OAAO,CAOnB;AA9LD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAmBI;;;OAGG;IACH,oDASC;IA9BD,iEAAiD;IAgCjD,2CAIC;IAED,4CAIC;IAED;;;;OAIG;IACH,gBAJW,kBAAkB,aAClB,WAAW,UACX,MAAM,QAUhB;IAED;;;;OAIG;IACH,kBAJW,kBAAkB,aAClB,WAAW,UACX,MAAM,QAIhB;;CAmCJ;yCAzIwC,8DAA8D;mCAGpE,yBAAyB;4BADhC,iCAAiC;uBADtC,kBAAkB"}
+{"version":3,"file":"ParticipatingMediaSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticipatingMediaSystem.js"],"names":[],"mappings":"AAwKA;;;;;;;;;;GAUG;AACH,yDAJW,wBAAwB,aACxB,kBAAkB,aAClB,WAAW,QAwBrB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8DALW,wBAAwB,aACxB,kBAAkB,aAClB,WAAW,GACT,OAAO,CAWnB;AAhOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAmBI;;;OAGG;IACH,oDASC;IA9BD,iEAAiD;IAgCjD,2CAIC;IAED,4CAIC;IAED;;;;OAIG;IACH,gBAJW,kBAAkB,aAClB,WAAW,UACX,MAAM,QAUhB;IAED;;;;OAIG;IACH,kBAJW,kBAAkB,aAClB,WAAW,UACX,MAAM,QAIhB;;CA2DJ;yCAjKM,8DAA8D;mCAGlC,yBAAyB;4BADhC,iCAAiC;uBADtC,kBAAkB"}

package/src/engine/graphics3/ParticipatingMediaSystem.js

@@ -1,6 +1,9 @@
 import { assert } from "../../core/assert.js";
 import { isArrayEqualStrict } from "../../core/collection/array/isArrayEqualStrict.js";
-import { ParticipatingMediaVolume } from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
+import {
+    participating_media_volume_advance_noise,
+    ParticipatingMediaVolume
+} from "../../shade/renderer/volumetrics/ParticipatingMediaVolume.js";
 import { System } from "../ecs/System.js";
 import { Transform64 } from "../ecs/transform/Transform64.js";
 import { ParticipatingMedia } from "./ParticipatingMedia.js";
@@ -105,19 +108,43 @@ export class ParticipatingMediaSystem extends System {
     }
 
     /**
+     * One frame: every volume's noise scrolls on by the wind it feels plus its own motion, and
+     * whatever changed — that, or anything the component or transform now says differently —
+     * reaches the renderer's volume and moves the volumetrics version.
+     *
+     * The wind is the scene's (`SceneVolumetrics.wind`), felt through each medium's
+     * `noise_wind_factor`; the fold to a scroll phase happens on the volume, in f64, wrapped, so a
+     * long session never grows a number and a change of wind never jumps the field. A medium with
+     * no noise, or none that moves, costs the comparison it always did.
+     *
      * @param {number} time_delta_seconds
      */
     update(time_delta_seconds) {
         const volumetrics = this.#scene.volumetrics;
+        const wind = volumetrics.wind;
 
         for (const entry of this.#entries.values()) {
             const volume = entry.volume;
+            const component = entry.component;
 
-            if (participating_media_volume_is_current(volume, entry.component, entry.transform)) {
+            let moved = false;
+
+            if (component.noise_strength > 0) {
+                const factor = component.noise_wind_factor;
+                const own = component.noise_velocity;
+
+                scratch_velocity[0] = wind[0] * factor + own[0];
+                scratch_velocity[1] = wind[1] * factor + own[1];
+                scratch_velocity[2] = wind[2] * factor + own[2];
+
+                moved = participating_media_volume_advance_noise(volume, scratch_velocity, time_delta_seconds);
+            }
+
+            if (!moved && participating_media_volume_is_current(volume, component, entry.transform)) {
                 continue;
             }
 
-            participating_media_volume_write(volume, entry.component, entry.transform);
+            participating_media_volume_write(volume, component, entry.transform);
 
             volumetrics.invalidate();
         }
@@ -154,6 +181,12 @@ export function participating_media_volume_write(volume, component, transform) {
     volume.density = component.density;
     volume.fade_distance = component.fade_distance;
 
+    // the settings; the scroll phases are the volume's own state and are not touched here
+    volume.noise_strength = component.noise_strength;
+    volume.noise_scale = component.noise_scale;
+    volume.noise_warp = component.noise_warp;
+    volume.noise_slot = component.noise_texture;
+
     volume.particle_spec.copy(component.particle_spec);
 
     // By the MATRIX, not by the components. The volume is defined by the matrix the GPU is
@@ -193,6 +226,16 @@ export function participating_media_volume_write(volume, component, transform) {
 export function participating_media_volume_is_current(volume, component, transform) {
     return volume.density === component.density
         && volume.fade_distance === component.fade_distance
+        && volume.noise_strength === component.noise_strength
+        && volume.noise_scale === component.noise_scale
+        && volume.noise_warp === component.noise_warp
+        && volume.noise_slot === component.noise_texture
         && isArrayEqualStrict(volume.transform.matrix, transform.matrix)
         && volume.particle_spec.equals(component.particle_spec);
 }
+
+/**
+ * The wind a medium feels plus its own motion, for one call of the advance; never kept.
+ * @type {Float64Array}
+ */
+const scratch_velocity = new Float64Array(3);

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/navigation/ecs/path_following/PathFollowingSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAiJA;;IACI,sCAA8B;IAC9B,mKAIE;IAEF;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,WAAW,QACX,IAAI,UACJ,MAAM,QAuBhB;CAgBJ;uBAvMsB,wBAAwB;yBAGtB,mBAAmB;4BAFhB,uCAAuC;4CAFvB,uDAAuD;iBAGlF,uBAAuB"}
+{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAyJA;;IACI,sCAA8B;IAC9B,mKAIE;IAEF;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,WAAW,QACX,IAAI,UACJ,MAAM,QA4BhB;CAgBJ;uBApNsB,wBAAwB;yBAItB,mBAAmB;4BAFhB,uCAAuC;4CAHvB,uDAAuD;iBAIlF,uBAAuB"}

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.js

@@ -4,6 +4,7 @@ import { min2 } from "../../../../core/math/min2.js";
 import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { System } from '../../../ecs/System.js';
+import { t64_announce_change } from "../../../ecs/transform/t64_announce_change.js";
 import { Transform64 } from '../../../ecs/transform/Transform64.js';
 import Path from '../components/Path.js';
 import PathFollower from './PathFollower.js';
@@ -25,11 +26,14 @@ const scratch_quaternion = new Quaternion();
  * @param {Path} path
  * @param {Transform64} transform
  * @param {number} timeDelta
+ * @returns {boolean} whether the transform was written, which its writer then has to announce
  */
 function performStep(pathFollower, path, transform, timeDelta) {
     let remainingDistance = pathFollower.speed.getValue() * timeDelta;
     const path_length = path.length;
 
+    let moved = false;
+
     while (remainingDistance > 0) {
 
         let stepLimit = pathFollower.maxMoveDistance;
@@ -138,9 +142,13 @@ function performStep(pathFollower, path, transform, timeDelta) {
             position[0] = nextPosition[0];
             position[1] = nextPosition[1];
             position[2] = nextPosition[2];
+
+            moved = true;
         }
 
     }
+
+    return moved;
 }
 
 class PathFollowingSystem extends System {
@@ -177,13 +185,18 @@ class PathFollowingSystem extends System {
             return;
         }
 
-        performStep(pathFollower, path, transform, this.__time_delta);
+        const dataset = this.entityManager.dataset;
+
+        if (performStep(pathFollower, path, transform, this.__time_delta)) {
+            // a Transform64 cannot say it was written, so the writer does: this is what moves the
+            // entity's rendered row, its sound, and whatever else follows it by its transform
+            t64_announce_change(dataset, entity);
+        }
 
         if (pathFollower.getFlag(PathFollowerFlags.Finished)) {
             //deactivate
             pathFollower.clearFlag(PathFollowerFlags.Active);
 
-            const dataset = this.entityManager.dataset
             dataset.sendEvent(entity, PathFollowerEventType.EndReached);
         }
     }

package/src/engine/network/CONGESTION_CONTROL.md

@@ -6,14 +6,14 @@ against Valve GameNetworkingSockets (GNS), 2026-06.
 
 ## The gap
 
-There is no congestion control or send pacing anywhere on the meep-owned send
-path. `NetworkPeer.flush_outbound` packs `[last_acked+1 .. current]` for every
-peer every tick and hands it straight to `Channel.send` / `send_fragmented` with
-no byte budget, no rate ceiling, and no loss→rate feedback. `onPacketLost` only
-drops the stale `seq→frame_end` mapping; it never reduces a send rate. So under a
-constrained link, output *rises* exactly when the path sheds load (the repacked
-unacked frames plus reliable/fragment retransmits stack on top) — classic
-self-inflicted bufferbloat with no AIMD backoff.
+There is no congestion control on the meep-owned send path. Each peer's `Connection`
+(`MESSAGE_TRANSPORT.md`) paces its reliable USER and BULK lanes with a token bucket at a fixed
+rate — a ceiling, but not one that learns: loss never reduces it. The action stream, AUTH_STATE and
+the CONTROL lane are not paced at all. `NetworkPeer.flush_outbound` packs
+`[last_acked+1 .. current]` for every peer every tick, so under a constrained link output *rises*
+exactly when the path sheds load (the repacked unacked frames plus reliable re-sends stack on top) —
+classic self-inflicted bufferbloat with no AIMD backoff. The token bucket is where a governor would
+set the rate.
 
 GNS, by contrast, paces every packet through `SNP_TokenBucket_Accumulate` at a
 `m_nCurrentSendRateEstimate` that is RFC3390-seeded, shrinks on loss, grows on
@@ -80,7 +80,7 @@ not the obstacle.
   which bytes go out this tick and defer the rest (`BandwidthMeter` can verify
   the achieved rate). These primitives already exist and are correct — they are
   intentionally unwired opt-in surface, **not** dead code.
-- Do NOT add a cipher/sliding-window or any of this to `Channel`; congestion
+- Do NOT add a cipher/sliding-window or any of this to `Connection`'s packet layer; congestion
   control belongs above the seq/ack layer, on the transport-facing send path.
 
 @author Alex Goldring