@woosh/meep-engine 3.64.1 → 3.65.0

package/src/engine/network/sim/SimActionExecutor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SimActionExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/SimActionExecutor.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,2BAFU,MAAM,CAEiB;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6BAFU,MAAM,CAEmB;AAEnC;;;;;;;;;;GAUG;AACH,8BAFU,MAAM,CAEoB;AAEpC;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAEqB;AAErC;;;;;;GAMG;AACH,0BAFU,MAAM,CAEgB;AAEhC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA2EI;;;;;;;;;OASG;IACH,sGATW;QACV,KAAS,yBAAyB;QAClC,UAAc,YAAY;QAC1B,eAAmB,oBAAoB;QACvC,kBAAsB,8BAA8B;QACpD,UAAc,uBAAuB;QACrC,gBAAoB,CAAC,mBAAmB;KACrC,EAyFH;IAjKD;;;;;;;;;OASG;IACH,gBAFU,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAEP;IAEtB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,KAAK,OAAO,CAAC,GAAG,IAAI,CAEtE;IAEjB;;;;;;;;;;;;;;;OAeG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;OAOG;IACH,sBAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,UAAU,KAAK,IAAI,CAAC,GAAG,IAAI,CAE7C;IAaxB;;OAEG;IACH,8BAAkB;IAElB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,gDAA4C;IAE5C;;;;OAIG;IACH,iCAA4B;IAE5B;;;;;;;;;;;OAWG;IACH,kBAFU,mBAAiB,IAAI,CAES;IA4BxC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;OAOG;IACH,kBAFU,MAAM,CAEoB;IAGxC;;;;;;;;;;;;;;OAcG;IACH,uCAPW,MAAM,GAGJ,OAAO,CA0KnB;IAkCD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAwCC;IAED;;;;;;;;;;;;;OAaG;IACH,4BAFW,MAAM,QAqChB;IAED;;;;;;;;OAQG;IACH,sBAJW,UAAU,UACV,MAAM,UACN,MAAM,QAchB;;CACJ;mBAjnBkB,uCAAuC"}
+{"version":3,"file":"SimActionExecutor.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/sim/SimActionExecutor.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,2BAFU,MAAM,CAEiB;AAEjC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6BAFU,MAAM,CAEmB;AAEnC;;;;;;;;;;GAUG;AACH,8BAFU,MAAM,CAEoB;AAEpC;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAEqB;AAErC;;;;;;GAMG;AACH,0BAFU,MAAM,CAEgB;AAEhC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA0FI;;;;;;;;;OASG;IACH,sGATW;QACV,KAAS,yBAAyB;QAClC,UAAc,YAAY;QAC1B,eAAmB,oBAAoB;QACvC,kBAAsB,8BAA8B;QACpD,UAAc,uBAAuB;QACrC,gBAAoB,CAAC,mBAAmB;KACrC,EA6FH;IArKD;;;;;;;;;OASG;IACH,gBAFU,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAEP;IAEtB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,WAAW,KAAK,OAAO,CAAC,GAAG,IAAI,CAEtE;IAEjB;;;;;;;;;;;;;;;OAeG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;OAOG;IACH,sBAFU,CAAC,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,UAAU,KAAK,IAAI,CAAC,GAAG,IAAI,CAE7C;IAaxB;;OAEG;IACH,8BAAkB;IAElB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,gDAA4C;IAE5C;;;;OAIG;IACH,iCAA4B;IAE5B;;;;;;;;;;;OAWG;IACH,kBAFU,mBAAiB,IAAI,CAES;IAgCxC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;OAOG;IACH,kBAFU,MAAM,CAEoB;IAGxC;;;;;;;;;;;;;;;;;OAiBG;IACH,uCAPW,MAAM,GAGJ,OAAO,CAcnB;IAgND;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gCAUC;IAgDD;;;;;;;;;;;;;OAaG;IACH,4BAFW,MAAM,QAqChB;IAED;;;;;;;;OAQG;IACH,sBAJW,UAAU,UACV,MAAM,UACN,MAAM,QAchB;;CACJ;mBAzqBkB,uCAAuC"}

package/src/engine/network/sim/SimActionExecutor.js

@@ -102,6 +102,21 @@ export class SimActionExecutor {
     #scratch_classes;
     #collect_cb;
 
+    /**
+     * How many of the scratch pairs belong to the action being executed. The arrays are never
+     * truncated: an array cut to length 0 gives up its storage, and the next action's first pair
+     * allocates it again.
+     * @type {number}
+     */
+    #scratch_count = 0;
+
+    /**
+     * Inside {@link execute} or {@link record}. The scratch pairs are the running action's, so a
+     * second action started before the first returns would take them over.
+     * @type {boolean}
+     */
+    #executing = false;
+
     /**
      * Between {@link begin_correction} and {@link end_correction}.
      * @type {boolean}
@@ -246,8 +261,12 @@ export class SimActionExecutor {
          * @private
          */
         this.#collect_cb = (entity_id, component_class) => {
-            this.#scratch_entities.push(entity_id);
-            this.#scratch_classes.push(component_class);
+            const index = this.#scratch_count;
+
+            this.#scratch_entities[index] = entity_id;
+            this.#scratch_classes[index] = component_class;
+
+            this.#scratch_count = index + 1;
         };
 
         /**
@@ -276,7 +295,10 @@ export class SimActionExecutor {
      *
      * Not re-entrant: calling `execute` or {@link record} from inside `affected_components`,
      * {@link authorize}, `apply`, `announce` or {@link on_component_written} is illegal (the
-     * executor is passed to actions for `slot_table` / `current_sender_id` reads only).
+     * executor is passed to actions for `slot_table` / `current_sender_id` reads only), and
+     * asserted. Unchecked, the inner action takes over the outer one's list of affected components:
+     * started from `affected_components`, the outer action's prior state is captured for the inner
+     * action's entity and a rewind no longer restores its own.
      *
      * @param {SimAction} action
      * @param {number} [sender_id] peer that originated this action.
@@ -287,6 +309,25 @@ export class SimActionExecutor {
      *   logged).
      */
     execute(action, sender_id = SENDER_LOCAL) {
+        assert.equal(this.#executing, false, 'execute: called from inside execute or record; the executor is not re-entrant');
+
+        this.#executing = true;
+
+        try {
+            return this.#execute(action, sender_id);
+        } finally {
+            this.#executing = false;
+        }
+    }
+
+    /**
+     * {@link execute}, once it is known that no other action is running.
+     *
+     * @param {SimAction} action
+     * @param {number} sender_id
+     * @returns {boolean}
+     */
+    #execute(action, sender_id) {
         assert.ok(action && action.isSimAction, 'execute: action must be a SimAction');
         // A class that was never registered still carries SimAction's default
         // type_id of -1, and step 5 writes that into the log as a uint8 the
@@ -324,11 +365,10 @@ export class SimActionExecutor {
         // 1. Collect affected (entity, component_class) pairs.
         // Pass the executor as context so actions can translate network_id → entity_id
         // via this.slot_table inside affected_components.
-        this.#scratch_entities.length = 0;
-        this.#scratch_classes.length = 0;
+        this.#scratch_count = 0;
         action.affected_components(this.#collect_cb, this);
 
-        const affected_count = this.#scratch_entities.length;
+        const affected_count = this.#scratch_count;
 
         // 1a. Authorization gate for remote-originated actions. A peer may only
         // mutate entities it is authorized for; reject the whole action before
@@ -510,16 +550,32 @@ export class SimActionExecutor {
      * @param {SimAction} action
      */
     record(action) {
+        assert.equal(this.#executing, false, 'record: called from inside execute or record; the executor is not re-entrant');
+
+        this.#executing = true;
+
+        try {
+            this.#record(action);
+        } finally {
+            this.#executing = false;
+        }
+    }
+
+    /**
+     * {@link record}, once it is known that no other action is running.
+     *
+     * @param {SimAction} action
+     */
+    #record(action) {
         assert.ok(action && action.isSimAction, 'record: action must be a SimAction');
         assert.ok(
             action.constructor.type_id >= 0,
             `record: action class '${action.constructor.action_type_name ?? action.constructor.name}' has no wire type_id — register it before recording it`,
         );
 
-        this.#scratch_entities.length = 0;
-        this.#scratch_classes.length = 0;
+        this.#scratch_count = 0;
         action.affected_components(this.#collect_cb, this);
-        const affected_count = this.#scratch_entities.length;
+        const affected_count = this.#scratch_count;
 
         for (let i = 0; i < affected_count; i++) {
             if (this.component_registry.type_id_of(this.#scratch_classes[i]) < 0) {

package/src/engine/network/state/PredictionHistory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PredictionHistory.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/state/PredictionHistory.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH;IAMI;;OAEG;IACH,uBAFW,MAAM,EAOhB;IAFG,+BAA+B;IAC/B,mBADqB,MAAM,CACH;IAkB5B;;;;;;;;;OASG;IACH,eANW,MAAM,SACN,MAAM,WACN,MAAM,UACN,UAAU,UACV,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,YALW,MAAM,SACN,MAAM,WACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,eALW,MAAM,SACN,MAAM,WACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;OASG;IACH,cALW,MAAM,SACN,MAAM,WACN,MAAM,GACJ,UAAU,GAAC,IAAI,CAK3B;IAED;;OAEG;IACH,eAFW,MAAM,QAIhB;IAED,cAEC;;CACJ"}
+{"version":3,"file":"PredictionHistory.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/state/PredictionHistory.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH;IAMI;;OAEG;IACH,uBAFW,MAAM,EAOhB;IAFG,+BAA+B;IAC/B,mBADqB,MAAM,CACH;IAkB5B;;;;;;;;;OASG;IACH,eANW,MAAM,SACN,MAAM,WACN,MAAM,UACN,UAAU,UACV,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,YALW,MAAM,SACN,MAAM,WACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,eALW,MAAM,SACN,MAAM,WACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;;;OASG;IACH,cALW,MAAM,SACN,MAAM,WACN,MAAM,GACJ,UAAU,GAAC,IAAI,CAK3B;IAED;;OAEG;IACH,eAFW,MAAM,QAIhB;IAED,cAEC;;CACJ"}

package/src/engine/network/state/PredictionHistory.js

@@ -87,7 +87,12 @@ export class PredictionHistory {
             target = new Uint8Array(Math.max(length, 32));
             slot.bytes[type_id] = target;
         }
-        target.set(source.subarray(0, length), 0);
+        // byte by byte: a view of the source would be an allocation per component per frame, and a
+        // component's wire state is a few tens of bytes
+        for (let i = 0; i < length; i++) {
+            target[i] = source[i];
+        }
+
         slot.lengths[type_id] = length;
     }
 

package/src/engine/network/time/AdaptiveRenderDelay.d.ts

@@ -19,11 +19,18 @@
  *   2. The rolling window holds the last N lateness samples; the recommended
  *      target delay (ms) = `(max(window) - min(window)) * safety_multiplier`.
  *   3. Output ramps UP to a higher target instantly (so a jitter spike is
- *      absorbed at the next sample), and DOWN at most `decay_per_sample_ms`
- *      ms per arrival (so we don't flap when one calm packet follows a spike).
+ *      absorbed at the next sample), and comes DOWN to a lower one by
+ *      `decay_rate` of the time that passes between arrivals. A delay that
+ *      comes down plays what is drawn from it that much faster than real time,
+ *      so the rate is also the most a calming link speeds the playout up.
  *   4. The output is clamped to `[min_delay_frames, max_delay_frames]` and
  *      converted to an integer frame count.
  *
+ * How long a spike is remembered: for as long as it is among the last N
+ * samples, and after that for as long as the decay takes to shed it — its
+ * height over `decay_rate`. A spike that comes again within that is covered
+ * when it does.
+ *
  * Why not inter-arrival time: in a tick-driven receiver (e.g. JS engine
  * polling a transport queue at 60 Hz), arrivals are quantized to tick
  * boundaries. Bursts of frames in one packet share the same arrival time;
@@ -55,7 +62,7 @@ export class AdaptiveRenderDelay {
      *   max_delay_frames?: number,
      *   history_size?: number,
      *   safety_multiplier?: number,
-     *   decay_per_sample_ms?: number,
+     *   decay_rate?: number,
      *   initial_delay_frames?: number,
      * }} options
      *
@@ -64,19 +71,22 @@ export class AdaptiveRenderDelay {
      * should cover 2× the observed jitter spread" and reproduces visibly
      * smooth motion in practice.
      *
-     * `decay_per_sample_ms`: how aggressively the recommendation drops once
-     * conditions improve. Smaller = stickier (the delay stays high even after
-     * a calm period), larger = snappier (the delay drops faster, possibly
-     * stuttering if jitter recurs). Default 1 ms / sample is a calm decay
-     * that takes ~1 s to drop by 60 ms at 60 Hz arrivals.
+     * `decay_rate`: how fast the recommendation drops once conditions improve,
+     * in milliseconds of delay per millisecond between arrivals — a ratio.
+     * Smaller = stickier (the delay stays high for longer after a calm
+     * period), larger = snappier (the delay drops faster, the playout speeds
+     * up by more while it does, and a spike that recurs is less likely to
+     * find the delay still up). The default 0.05 takes 20 s to shed a second
+     * of delay, at any tick rate and however many frames arrive in that time.
+     * 0 never comes down.
      */
-    constructor({ tick_period_ms, min_delay_frames, max_delay_frames, history_size, safety_multiplier, decay_per_sample_ms, initial_delay_frames, }: {
+    constructor({ tick_period_ms, min_delay_frames, max_delay_frames, history_size, safety_multiplier, decay_rate, initial_delay_frames, }: {
         tick_period_ms: number;
         min_delay_frames?: number;
         max_delay_frames?: number;
         history_size?: number;
         safety_multiplier?: number;
-        decay_per_sample_ms?: number;
+        decay_rate?: number;
         initial_delay_frames?: number;
     });
     /** @readonly @type {number} */
@@ -88,7 +98,7 @@ export class AdaptiveRenderDelay {
     /** @readonly @type {number} */
     readonly safety_multiplier: number;
     /** @readonly @type {number} */
-    readonly decay_per_sample_ms: number;
+    readonly decay_rate: number;
     /**
      * Record an arrival. Call this when a new frame from the sender has been
      * applied locally.
@@ -118,9 +128,10 @@ export class AdaptiveRenderDelay {
      */
     last_interval_ms(): number;
     /**
-     * Drop all observed history. Useful after a reconnect or a level transition.
-     * Leaves `current_delay_ms` as-is so the displayed delay doesn't snap; it
-     * will adjust to new conditions over the next few samples.
+     * Start over, as constructed: no history, and the initial delay. For a
+     * stream that begins again — a reconnect, a level transition, a receiver
+     * that was away — where what was observed before, or across the gap, says
+     * nothing of how late the frames to come will run.
      */
     reset(): void;
     #private;

package/src/engine/network/time/AdaptiveRenderDelay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AdaptiveRenderDelay.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/time/AdaptiveRenderDelay.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAqBI;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,iJArBW;QACV,cAAkB,EAAE,MAAM,CAAC;QAC3B,gBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,gBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,iBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,oBAAwB,CAAC,EAAE,MAAM,CAAC;KAC/B,EA4DH;IA1BG,+BAA+B;IAC/B,yBADqB,MAAM,CACS;IACpC,+BAA+B;IAC/B,2BADqB,MAAM,CACa;IACxC,+BAA+B;IAC/B,2BADqB,MAAM,CACa;IACxC,+BAA+B;IAC/B,4BADqB,MAAM,CACe;IAC1C,+BAA+B;IAC/B,8BADqB,MAAM,CACmB;IAmBlD;;;;;;OAMG;IACH,uBAHW,MAAM,gBACN,MAAM,QAkDhB;IAED;;;;;OAKG;IACH,gBAFa,MAAM,CAKlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAQlB;IAED;;;;;OAKG;IACH,oBAFa,MAAM,CAKlB;IAED;;;;OAIG;IACH,cAOC;;CACJ"}
+{"version":3,"file":"AdaptiveRenderDelay.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/time/AdaptiveRenderDelay.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH;IAuBI;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,wIAxBW;QACV,cAAkB,EAAE,MAAM,CAAC;QAC3B,gBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,gBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,iBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,UAAc,CAAC,EAAE,MAAM,CAAC;QACxB,oBAAwB,CAAC,EAAE,MAAM,CAAC;KAC/B,EAgEH;IA3BG,+BAA+B;IAC/B,yBADqB,MAAM,CACS;IACpC,+BAA+B;IAC/B,2BADqB,MAAM,CACa;IACxC,+BAA+B;IAC/B,2BADqB,MAAM,CACa;IACxC,+BAA+B;IAC/B,4BADqB,MAAM,CACe;IAC1C,+BAA+B;IAC/B,qBADqB,MAAM,CACC;IAoBhC;;;;;;OAMG;IACH,uBAHW,MAAM,gBACN,MAAM,QAqDhB;IAED;;;;;OAKG;IACH,gBAFa,MAAM,CAKlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAQlB;IAED;;;;;OAKG;IACH,oBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,cAQC;;CACJ"}

package/src/engine/network/time/AdaptiveRenderDelay.js

@@ -22,11 +22,18 @@ import { clamp } from "../../../core/math/clamp.js";
  *   2. The rolling window holds the last N lateness samples; the recommended
  *      target delay (ms) = `(max(window) - min(window)) * safety_multiplier`.
  *   3. Output ramps UP to a higher target instantly (so a jitter spike is
- *      absorbed at the next sample), and DOWN at most `decay_per_sample_ms`
- *      ms per arrival (so we don't flap when one calm packet follows a spike).
+ *      absorbed at the next sample), and comes DOWN to a lower one by
+ *      `decay_rate` of the time that passes between arrivals. A delay that
+ *      comes down plays what is drawn from it that much faster than real time,
+ *      so the rate is also the most a calming link speeds the playout up.
  *   4. The output is clamped to `[min_delay_frames, max_delay_frames]` and
  *      converted to an integer frame count.
  *
+ * How long a spike is remembered: for as long as it is among the last N
+ * samples, and after that for as long as the decay takes to shed it — its
+ * height over `decay_rate`. A spike that comes again within that is covered
+ * when it does.
+ *
  * Why not inter-arrival time: in a tick-driven receiver (e.g. JS engine
  * polling a transport queue at 60 Hz), arrivals are quantized to tick
  * boundaries. Bursts of frames in one packet share the same arrival time;
@@ -70,6 +77,8 @@ export class AdaptiveRenderDelay {
     /** @private @type {number} */
     #last_frame = -1;
     #current_delay_ms;
+    /** @private @type {number} */
+    #initial_delay_ms;
 
     /**
      * @param {{
@@ -78,7 +87,7 @@ export class AdaptiveRenderDelay {
      *   max_delay_frames?: number,
      *   history_size?: number,
      *   safety_multiplier?: number,
-     *   decay_per_sample_ms?: number,
+     *   decay_rate?: number,
      *   initial_delay_frames?: number,
      * }} options
      *
@@ -87,11 +96,14 @@ export class AdaptiveRenderDelay {
      * should cover 2× the observed jitter spread" and reproduces visibly
      * smooth motion in practice.
      *
-     * `decay_per_sample_ms`: how aggressively the recommendation drops once
-     * conditions improve. Smaller = stickier (the delay stays high even after
-     * a calm period), larger = snappier (the delay drops faster, possibly
-     * stuttering if jitter recurs). Default 1 ms / sample is a calm decay
-     * that takes ~1 s to drop by 60 ms at 60 Hz arrivals.
+     * `decay_rate`: how fast the recommendation drops once conditions improve,
+     * in milliseconds of delay per millisecond between arrivals — a ratio.
+     * Smaller = stickier (the delay stays high for longer after a calm
+     * period), larger = snappier (the delay drops faster, the playout speeds
+     * up by more while it does, and a spike that recurs is less likely to
+     * find the delay still up). The default 0.05 takes 20 s to shed a second
+     * of delay, at any tick rate and however many frames arrive in that time.
+     * 0 never comes down.
      */
     constructor({
         tick_period_ms,
@@ -99,7 +111,7 @@ export class AdaptiveRenderDelay {
         max_delay_frames = 30,
         history_size = 30,
         safety_multiplier = 2.0,
-        decay_per_sample_ms = 1.0,
+        decay_rate = 0.05,
         initial_delay_frames = 2,
     }) {
         assert.isNumber(tick_period_ms, 'tick_period_ms');
@@ -111,8 +123,8 @@ export class AdaptiveRenderDelay {
         assert.ok(history_size >= 1, 'history_size must be >= 1');
         assert.isNumber(safety_multiplier, 'safety_multiplier');
         assert.ok(safety_multiplier >= 1, 'safety_multiplier must be >= 1');
-        assert.isNumber(decay_per_sample_ms, 'decay_per_sample_ms');
-        assert.ok(decay_per_sample_ms >= 0, 'decay_per_sample_ms must be >= 0');
+        assert.isNumber(decay_rate, 'decay_rate');
+        assert.ok(decay_rate >= 0, 'decay_rate must be >= 0');
 
         /** @readonly @type {number} */
         this.tick_period_ms = tick_period_ms;
@@ -123,7 +135,7 @@ export class AdaptiveRenderDelay {
         /** @readonly @type {number} */
         this.safety_multiplier = safety_multiplier;
         /** @readonly @type {number} */
-        this.decay_per_sample_ms = decay_per_sample_ms;
+        this.decay_rate = decay_rate;
 
         /**
          * Rolling window of recent lateness samples in ms (`now - frame*tick`).
@@ -139,7 +151,8 @@ export class AdaptiveRenderDelay {
          * is cheap.
          * @private @type {number}
          */
-        this.#current_delay_ms = initial_delay_frames * tick_period_ms;
+        this.#initial_delay_ms = initial_delay_frames * tick_period_ms;
+        this.#current_delay_ms = this.#initial_delay_ms;
     }
 
     /**
@@ -161,6 +174,10 @@ export class AdaptiveRenderDelay {
         this.#index = (this.#index + 1) % cap;
         if (this.#filled < cap) this.#filled++;
 
+        // Time since the arrival before this one: what the delay may have come down by. Frames
+        // that arrive together are one moment.
+        const elapsed_ms = this.#last_arrival_ms < 0 ? 0 : Math.max(0, now_ms - this.#last_arrival_ms);
+
         this.#prev_arrival_ms = this.#last_arrival_ms;
         this.#last_arrival_ms = now_ms;
         this.#last_frame = frame_number;
@@ -186,16 +203,15 @@ export class AdaptiveRenderDelay {
         // this, a single huge lateness sample (a tab going to background for 30
         // seconds, a long GC pause, an OS suspend) pins `__current_delay_ms` to
         // an arbitrarily large value. The public delay() accessors clamp on
-        // read, but the internal state would then take `(stored - cap) /
-        // decay_per_sample_ms` more samples to decay back into range than the
-        // configuration nominally allows.
+        // read, but the internal state would then take that much longer to
+        // decay back into range than the configuration nominally allows.
         const cap_ms = this.max_delay_frames * this.tick_period_ms;
 
         // Snap up immediately, decay down.
         if (target_delay_ms > this.#current_delay_ms) {
             this.#current_delay_ms = Math.min(target_delay_ms, cap_ms);
         } else {
-            this.#current_delay_ms = Math.max(target_delay_ms, this.#current_delay_ms - this.decay_per_sample_ms);
+            this.#current_delay_ms = Math.max(target_delay_ms, this.#current_delay_ms - this.decay_rate * elapsed_ms);
         }
     }
 
@@ -235,9 +251,10 @@ export class AdaptiveRenderDelay {
     }
 
     /**
-     * Drop all observed history. Useful after a reconnect or a level transition.
-     * Leaves `current_delay_ms` as-is so the displayed delay doesn't snap; it
-     * will adjust to new conditions over the next few samples.
+     * Start over, as constructed: no history, and the initial delay. For a
+     * stream that begins again — a reconnect, a level transition, a receiver
+     * that was away — where what was observed before, or across the gap, says
+     * nothing of how late the frames to come will run.
      */
     reset() {
         this.#lateness.fill(0);
@@ -246,5 +263,6 @@ export class AdaptiveRenderDelay {
         this.#last_arrival_ms = -1;
         this.#prev_arrival_ms = -1;
         this.#last_frame = -1;
+        this.#current_delay_ms = this.#initial_delay_ms;
     }
 }

package/src/engine/network/time/RenderPlayout.d.ts

@@ -9,6 +9,16 @@
  * arrived. Extracted from `NetworkSession` so any fixed-period stream — a peer's netcode frames, a
  * remote editor's presence samples — plays out the same way.
  *
+ * The head, `latest_frame`, is the newest frame the sender is known to have reached. A sender that
+ * sends nothing for a frame in which nothing changed must still say where it is
+ * ({@link advance_head}): otherwise the head stops with the stream, and the first frame after the
+ * pause is as far ahead of the playhead as the pause was long.
+ *
+ * A playhead further behind its target than the delay's largest value has not fallen behind by
+ * anything a delay covers — the receiver drew nothing while the sender ran on — and starts again as
+ * it did at the first frame: the delay is reset, since the frames that landed across the gap say
+ * nothing of how late frames run, and the playhead is put at its target. Anything nearer is pulled.
+ *
  * No allocation per call: {@link window} fills and returns one reused object.
  *
  * @author Alex Goldring
@@ -33,17 +43,27 @@ export class RenderPlayout {
     readonly delay: AdaptiveRenderDelay;
     /** @readonly @type {number} */
     readonly pull_per_ms: number;
-    /** @type {number} highest frame number recorded; -1 before the first */
+    /** @type {number} newest frame the sender is known to have reached; -1 before the first */
     latest_frame: number;
     /**
-     * A frame from the sender has been applied locally. Frames at or below the latest are
-     * accepted data (a reordered or retransmitted frame) but do not move the head.
+     * A frame from the sender has been applied locally. Its lateness is a sample for the delay,
+     * whether or not the head has already passed it. A frame at or below the newest one recorded
+     * (a reordered or retransmitted frame) is accepted data, and is no sample.
      *
      * @param {number} now_ms wall clock
      * @param {number} frame_number the sender's frame index
      * @returns {boolean} true when this frame advanced the head
      */
     record_arrival(now_ms: number, frame_number: number): boolean;
+    /**
+     * The sender has reached `frame_number`, whatever it sent of it. Moves the head and nothing
+     * else: this is the sender's word of where it is, not a frame's arrival, and it is no sample
+     * for the delay.
+     *
+     * @param {number} frame_number the sender's frame index
+     * @returns {boolean} true when the head advanced
+     */
+    advance_head(frame_number: number): boolean;
     /**
      * @returns {boolean} whether anything has arrived yet
      */

package/src/engine/network/time/RenderPlayout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderPlayout.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/time/RenderPlayout.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;GAeG;AACH;IAsBI;;;;;;OAMG;IACH,oDANW;QACV,cAAkB,EAAE,MAAM,CAAC;QAC3B,KAAS,CAAC,EAAE,mBAAmB,CAAC;QAChC,WAAe,CAAC,EAAE,MAAM,CAAA;KACrB,EAWH;IArCD,+BAA+B;IAC/B,yBADqB,MAAM,CACZ;IAEf,4CAA4C;IAC5C,gBADqB,mBAAmB,CAClC;IAEN,+BAA+B;IAC/B,sBADqB,MAAM,CACf;IAEZ,wEAAwE;IACxE,cADW,MAAM,CACC;IA6BlB;;;;;;;OAOG;IACH,uBAJW,MAAM,gBACN,MAAM,GACJ,OAAO,CAWnB;IAED;;OAEG;IACH,0BAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,eAHW,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAA;KAAC,CAsDpD;IAED;;OAEG;IACH,cAKC;;CACJ;oCA5KmC,0BAA0B"}
+{"version":3,"file":"RenderPlayout.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/time/RenderPlayout.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAyBI;;;;;;OAMG;IACH,oDANW;QACV,cAAkB,EAAE,MAAM,CAAC;QAC3B,KAAS,CAAC,EAAE,mBAAmB,CAAC;QAChC,WAAe,CAAC,EAAE,MAAM,CAAA;KACrB,EAWH;IAxCD,+BAA+B;IAC/B,yBADqB,MAAM,CACZ;IAEf,4CAA4C;IAC5C,gBADqB,mBAAmB,CAClC;IAEN,+BAA+B;IAC/B,sBADqB,MAAM,CACf;IAEZ,2FAA2F;IAC3F,cADW,MAAM,CACC;IAgClB;;;;;;;;OAQG;IACH,uBAJW,MAAM,gBACN,MAAM,GACJ,OAAO,CASnB;IAED;;;;;;;OAOG;IACH,2BAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;OAEG;IACH,0BAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,eAHW,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,CAAC,EAAC,MAAM,CAAA;KAAC,CA2DpD;IAED;;OAEG;IACH,cAMC;;CACJ;oCAhNmC,0BAA0B"}

package/src/engine/network/time/RenderPlayout.js

@@ -20,6 +20,16 @@ const PULL_PER_MS = 0.0005;
  * arrived. Extracted from `NetworkSession` so any fixed-period stream — a peer's netcode frames, a
  * remote editor's presence samples — plays out the same way.
  *
+ * The head, `latest_frame`, is the newest frame the sender is known to have reached. A sender that
+ * sends nothing for a frame in which nothing changed must still say where it is
+ * ({@link advance_head}): otherwise the head stops with the stream, and the first frame after the
+ * pause is as far ahead of the playhead as the pause was long.
+ *
+ * A playhead further behind its target than the delay's largest value has not fallen behind by
+ * anything a delay covers — the receiver drew nothing while the sender ran on — and starts again as
+ * it did at the first frame: the delay is reset, since the frames that landed across the gap say
+ * nothing of how late frames run, and the playhead is put at its target. Anything nearer is pulled.
+ *
  * No allocation per call: {@link window} fills and returns one reused object.
  *
  * @author Alex Goldring
@@ -35,9 +45,12 @@ export class RenderPlayout {
     /** @readonly @type {number} */
     pull_per_ms;
 
-    /** @type {number} highest frame number recorded; -1 before the first */
+    /** @type {number} newest frame the sender is known to have reached; -1 before the first */
     latest_frame = -1;
 
+    /** @private @type {number} newest frame recorded as an arrival; -1 before the first */
+    #latest_arrival = -1;
+
     /** @private @type {number} smoothed playhead in frames; -1 until the first window */
     #smooth_frame = -1;
 
@@ -66,19 +79,36 @@ export class RenderPlayout {
     }
 
     /**
-     * A frame from the sender has been applied locally. Frames at or below the latest are
-     * accepted data (a reordered or retransmitted frame) but do not move the head.
+     * A frame from the sender has been applied locally. Its lateness is a sample for the delay,
+     * whether or not the head has already passed it. A frame at or below the newest one recorded
+     * (a reordered or retransmitted frame) is accepted data, and is no sample.
      *
      * @param {number} now_ms wall clock
      * @param {number} frame_number the sender's frame index
      * @returns {boolean} true when this frame advanced the head
      */
     record_arrival(now_ms, frame_number) {
+        if (frame_number > this.#latest_arrival) {
+            this.#latest_arrival = frame_number;
+            this.delay.record_arrival(now_ms, frame_number);
+        }
+
+        return this.advance_head(frame_number);
+    }
+
+    /**
+     * The sender has reached `frame_number`, whatever it sent of it. Moves the head and nothing
+     * else: this is the sender's word of where it is, not a frame's arrival, and it is no sample
+     * for the delay.
+     *
+     * @param {number} frame_number the sender's frame index
+     * @returns {boolean} true when the head advanced
+     */
+    advance_head(frame_number) {
         if (frame_number <= this.latest_frame) {
             return false;
         }
 
-        this.delay.record_arrival(now_ms, frame_number);
         this.latest_frame = frame_number;
 
         return true;
@@ -140,6 +170,11 @@ export class RenderPlayout {
             frame += dt_ms / period;
             const alpha = 1 - Math.exp(-this.pull_per_ms * dt_ms);
             frame += (target - frame) * alpha;
+
+            if (target - frame > this.delay.max_delay_frames) {
+                this.delay.reset();
+                frame = latest - this.delay.delay_ms() / period;
+            }
         }
 
         this.#last_wall_ms = now_ms;
@@ -167,6 +202,7 @@ export class RenderPlayout {
      */
     reset() {
         this.latest_frame = -1;
+        this.#latest_arrival = -1;
         this.#smooth_frame = -1;
         this.#last_wall_ms = -1;
         this.delay.reset();

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#490@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#497@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#490@#clear_field"(fluid: FluidComponent): void;
+    static "__#497@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -82,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#490@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#497@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -102,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#490@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#497@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidObstacle> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof FluidComponent>)[];

package/src/engine/physics/fluid/obstacle/chunk_fluid_obstacle_record.d.ts

@@ -4,7 +4,11 @@
  * - `fluid_obstacle_record_signed_distance(record, global, x) -> f32`: signed distance to its
  *   surface, negative inside; the point is solid when it is at most `record.inflation`;
  * - `fluid_obstacle_record_wall_velocity(record, global, x) -> vec3<f32>`: the wall's velocity there,
- *   `rigid_velocity_at_point(v, ω, t, x)` with `t` the node's translation.
+ *   `rigid_velocity_at_point(v, ω, t, x)` with `t` the node's translation;
+ * - `fluid_obstacle_record_line_span(record, global, origin, direction) -> vec2<f32>`: the part of the
+ *   world line `origin + t · direction` (`direction` unit) inside its surface, as the `t` it enters at
+ *   and the `t` it leaves at, the first greater than the second for a line that misses
+ *   (`shape_record_line_span`). The inflation is not part of it.
  *
  * The node poses the record rigidly: its translation, and its matrix's rotation with each column
  * normalised, scale ignored, as the physics narrowphase and the CPU fluid pose a collider; then the

package/src/engine/physics/fluid/obstacle/chunk_fluid_obstacle_record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_fluid_obstacle_record.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/obstacle/chunk_fluid_obstacle_record.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,0CAFU,SAAS,CAmCjB;0BAzDwB,yDAAyD"}
+{"version":3,"file":"chunk_fluid_obstacle_record.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/obstacle/chunk_fluid_obstacle_record.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,0CAFU,SAAS,CAwDjB;0BAlFwB,yDAAyD"}