@woosh/meep-engine 3.47.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/network/NetworkSession.d.ts

@@ -212,6 +212,15 @@ export class NetworkSession {
      * @type {number}
      */
     correction_skipped_count: number;
+    /**
+     * Client: how many times it found itself more than the host's input window behind the frame the
+     * host last named, or was told by the host's depth feedback that its input lands below the
+     * host's window, and re-took the host's time. A tab in the background, a debugger, a laptop
+     * asleep — see {@link #retake_host_time_if_stalled}. Diagnostic: a game that sees these on a
+     * machine that never left the foreground has a client that cannot keep the step.
+     * @type {number}
+     */
+    stall_count: number;
     /**
      * Client, {@link NetworkSessionReconcile.Correct}: a component of an authoritative state
      * differed from the prediction, and the present was corrected. Once per component corrected.
@@ -610,9 +619,9 @@ export class NetworkSession {
      * frame 6,000; a client has to start tagging its inputs near 6,000 or the host discards every
      * one of them — `ServerAuthoritativeServer.tick` trims pending actions older than
      * `sim_frame - frame_capacity + 1`, and a client tagging frame 0 against a host at 6,000 has
-     * every input dropped **silently**. It moves on its own screen, never moves on the host's, and
-     * no signal fires: `onPendingActionDropped` covers the future-lead and capacity bounds, not
-     * this one.
+     * every input dropped. It moves on its own screen and never moves on the host's — and until
+     * 2026-10-15 no signal fired; the host's `onPendingActionDropped` now reports each such drop
+     * as `'window'`.
      *
      * Everything needed was already there except the setter. INITIAL_SYNC carries the host's frame,
      * `NetworkPeer` writes it, and `onInitialSync` dispatches it — and the handler named it
@@ -621,8 +630,10 @@ export class NetworkSession {
      * with the input sampler silenced until its counter caught up: 28,801 calls and 62 ms of wall
      * clock for an hour-old host. Reported as GAP-042.
      *
-     * A client now seeks automatically on INITIAL_SYNC. This is the manual door, for a caller that
-     * computes its own lead.
+     * A client now seeks automatically on INITIAL_SYNC, and again whenever it finds itself more than
+     * the host's input window behind the frame the host last named — a stall, see
+     * {@link #retake_host_time_if_stalled}. This is the manual door, for a caller that computes its
+     * own lead.
      *
      * A client sends the host nothing it predicted before its last sync, and knows it by frame: its
      * input starts at the frame the sync sought to. A caller whose own lead is shorter moves that

package/src/engine/network/NetworkSession.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NetworkSession.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/NetworkSession.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"NetworkSession.d.ts","sourceRoot":"","sources":["../../../../src/engine/network/NetworkSession.js"],"names":[],"mappings":"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"}