@woosh/meep-engine 3.60.9 → 3.61.1

package/src/engine/network/NetworkSession.js

@@ -1,6 +1,7 @@
 import { assert } from "../../core/assert.js";
 import { BinaryBuffer } from "../../core/binary/BinaryBuffer.js";
 import Signal from "../../core/events/signal/Signal.js";
+import { clamp } from "../../core/math/clamp.js";
 import { EntityObserver } from "../ecs/EntityObserver.js";
 import { UUID } from "../ecs/guid/UUID.js";
 import { BinarySerializationRegistry, } from "../ecs/storage/binary/BinarySerializationRegistry.js";
@@ -677,6 +678,14 @@ export class NetworkSession {
      */
     #host_frame_seen = -1;
 
+    /**
+     * Client: the newest host frame this client's world holds — the frame the last join's snapshot
+     * was taken at, or a frame applied from the host's action stream since, whichever is newer — or
+     * -1 before the first join. It is what a RESUME_HELLO claims, and a resumed stream starts after it.
+     * @private @type {number}
+     */
+    #host_frame_applied = -1;
+
     /**
      * Client: the host's newest depth feedback — its latest sight of this client's frame minus its
      * own sim frame, measured where this client's input lands — and that latest sight itself (the
@@ -841,6 +850,9 @@ export class NetworkSession {
      * - `frame_capacity` sizes the action-log ring (rollback depth + back-fill
      *   range + retransmit window — see {@link DEFAULT_ACTION_LOG_FRAME_CAPACITY}).
      *   Default 32. Raise it for high-RTT / lossy links.
+     * - `time_dilation` (client role): defaults to one built for round trips up to
+     *   `frame_capacity` frames. One of your own should be too: its
+     *   `max_round_trip_frames` is what keeps it from overshooting.
      * - `scope_filter` defaults to {@link OwnerAwareScope} on the host.
      * - `server_resume_grace_ms` (host role): how long peer state is
      *   retained after a transport drop before being freed. Default 30s.
@@ -956,8 +968,7 @@ export class NetworkSession {
 
         this.#time_dilation = time_dilation || new TimeDilation({
             target_buffer_depth: this.simulation_delay_ticks > 0 ? this.simulation_delay_ticks : 2,
-            max_dilation: 0.05,
-            gain: 0.05,
+            max_round_trip_frames: this.frame_capacity,
         });
         this.#adaptive_render_delay = adaptive_render_delay || new AdaptiveRenderDelay({
             tick_period_ms: this.tick_period_ms,
@@ -1263,10 +1274,12 @@ export class NetworkSession {
             // and "spectator" (no sampler — sampler-driven onPredict
             // returns no actions, so the predict-reconcile machinery
             // exists but stays idle).
+            // Only Replay rewinds, so only Replay needs a late host record put back in its frame.
             this.#client = new ServerAuthoritativeClient({
                 ...orchestrator_opts,
                 time_dilation: this.#time_dilation,
                 auto_reconcile: this.#reconcile === NetworkSessionReconcile.Replay,
+                rebase_on_arrival: this.#reconcile === NetworkSessionReconcile.Replay,
             });
             if (this.#reconcile === NetworkSessionReconcile.Correct) {
                 this.#client.peer.onAuthState.add((_peer_id, server_frame, network_id, buffer) => {
@@ -1496,7 +1509,14 @@ export class NetworkSession {
                 // Resume candidate. Wait for RESUME_HELLO; restore
                 // baseline + add to connected_peers on validation.
                 // Don't queue INITIAL_SYNC — it'll only fire if we
-                // RESUME_REJECT.
+                // RESUME_REJECT. Its action stream waits for the claim too:
+                // until the host has read it, neither the peer's token nor
+                // the frame its world is held through is known. A stream
+                // packed meanwhile starts at the ring floor, under frames
+                // the client has already applied, and the client's apply
+                // watermark starts afresh with the connection: it would
+                // apply them again.
+                this.#peer.hold_outbound(remote_peer_id);
             } else {
                 // Fresh peer. Queue initial-sync for the next host tick.
                 this.#queue_initial_sync(remote_peer_id);
@@ -1554,7 +1574,7 @@ export class NetworkSession {
             // we don't speak is one the host has to time out.
             const token = this.session_token;
             if (token !== null || this.#has_ever_connected) {
-                const last_acked = Math.max(0, this.#playout.latest_frame);
+                const last_acked = Math.max(0, this.#host_frame_applied);
                 this.#peer.send_resume_hello(
                     remote_peer_id, this.local_peer_id, last_acked,
                     token !== null, token !== null ? token.data : NO_SESSION_TOKEN,
@@ -1893,10 +1913,11 @@ export class NetworkSession {
             // Client: drive the reconnect timer.
             this.#tick_reconnect(dt_ms);
 
-            // Time dilation: run the whole local simulation a few percent fast or slow, as the
-            // host asks, by stretching the wall time each step consumes. The step itself — and so
-            // every system's dt — is unchanged, and the render alpha stays a true fraction of it.
-            this.entity_manager.fixedStepTimeScale = 1 / this.#client.dilation_factor;
+            // Time dilation: run the whole local simulation fast or slow, as the host asks, by
+            // stretching the wall time each step consumes — a few percent to steer, slower in
+            // proportion to a lead it has to repay. The step itself — and so every system's dt — is
+            // unchanged, and the render alpha stays a true fraction of it.
+            this.entity_manager.fixedStepTimeScale = 1 / this.#dilation_in_force();
         }
 
         // Idle reaping: a connected peer that has gone silent past the timeout
@@ -2427,6 +2448,9 @@ export class NetworkSession {
         this.#align_to_host(frame_number);
         this.#forget_predicted_world();
         this.#binding_answer = BindingAnswer.Synced;
+        // The world is the host's as of this frame, whatever the one it replaced held: a resume
+        // claiming less would be sent frames the snapshot already holds.
+        this.#host_frame_applied = frame_number;
 
         // Input from here on is predicted on the host's world. What was predicted before —
         // held since this binding was made, or still in the log from before it — was
@@ -2489,6 +2513,34 @@ export class NetworkSession {
         this.#client.forget_timeline();
     }
 
+    /**
+     * Client: the dilation factor to run at — the host's, as far as the report it came from still
+     * holds. A report names the newest frame of this client's the host has seen, which the host keeps
+     * as a running maximum and never lowers.
+     *
+     * - About a frame the clock has since gone back past, the report is about frames the client has
+     *   left: nominal rate.
+     * - With no report on this binding, or none for longer than the longest round trip the dilation is
+     *   built for, the last one is stale: it may steer, within `max_dilation`, but repays nothing — the
+     *   lead it described may be gone, and repaying it again would put the client behind.
+     *
+     * @returns {number}
+     */
+    #dilation_in_force() {
+        const time_dilation = this.#time_dilation;
+        const factor = this.#client.dilation_factor;
+        const seen = this.#host_marker_seen;
+        const age = this.#local_frame - seen;
+
+        if (seen >= 0 && age <= 0) return 1;
+
+        if (seen < 0 || age > time_dilation.max_round_trip_frames) {
+            return clamp(factor, 1 - time_dilation.max_dilation, 1 + time_dilation.max_dilation);
+        }
+
+        return factor;
+    }
+
     /**
      * Client, as a step opens: more than the host's input window behind, the client re-takes the
      * host's time.
@@ -2942,8 +2994,11 @@ export class NetworkSession {
         }
 
         // Valid resume. Restore the action-stream baseline so the
-        // replicator packs from `last_acked + 1`, then accept.
+        // replicator packs from `last_acked + 1`, release the stream
+        // `connect()` held from that frame on — nothing the client
+        // already holds is sent on this connection — then accept.
         this.#peer.baseline.set_acked(claimed_peer_id, last_acked_frame);
+        this.#peer.release_outbound(transport_peer_id, last_acked_frame + 1);
         this.#peer_grace_state.delete(claimed_peer_id);
         this.#connected_peers.add(transport_peer_id);
         this.#peer.send_resume_accept(transport_peer_id);
@@ -3680,12 +3735,15 @@ export class NetworkSession {
     /**
      * Record post-apply state for every remote-owned entity into the
      * network timeline. Locally-owned entities are predicted, not
-     * interpolated from the network, so they're skipped.
+     * interpolated from the network, so they're skipped. The frame is
+     * one the world now holds, which a resume claims.
      *
      * Doesn't fire on the host — the replicator's deferral path doesn't
      * emit `onFrameApplied`, so the host gets no recording naturally.
      */
     #on_frame_applied(_peer_id, frame_number) {
+        if (frame_number > this.#host_frame_applied) this.#host_frame_applied = frame_number;
+
         const log = this.#interp_log;
         const interpolands = this.#interpolands;
 

package/src/engine/network/README.md

@@ -59,8 +59,8 @@ nothing else to set up. What that takes, and where it lives:
   the step closes (`closeFixedStep`), so physics, controllers and game code all simulate inside the
   frame. There is no `session.tick()` to call (it is deprecated and inert);
   `entity_manager.update(dt)` — the engine loop — drives everything. Client time dilation is the
-  engine's `fixedStepTimeScale`: the step cadence stretches by a few percent, no step is dropped or
-  doubled. The session's timers — render playout, idle reaping, grace window — run on the same
+  engine's `fixedStepTimeScale`: the step cadence stretches — by a few percent to steer, by more to
+  repay a lead the host's lost time left — and no step is dropped or doubled. The session's timers — render playout, idle reaping, grace window — run on the same
   frame time.
 - **The network writes where the simulation writes.** Every transport the session is given is held
   (`DeferredTransport`): what arrives is applied as the next step opens, after the interpolation
@@ -128,7 +128,10 @@ connection:
 
 - **`RESUME_ACCEPT`**: the host kept the client's session, so the world the client has been
   predicting on goes on. Everything predicted meanwhile is sent, input predicted while cut off
-  included, and the host applies it late.
+  included, and the host applies it late. The host sends the new connection none of its own action
+  stream until it has read the client's `RESUME_HELLO`, and then the frames after the one the client
+  claims to hold the world through: the frame its last join's snapshot was taken at, or the newest
+  frame it has applied since.
 - **`INITIAL_SYNC`**: the host's snapshot replaces the client's world. Nothing predicted before it
   is ever sent, on this connection or a later one that resumes it: that input was predicted on a
   world that is gone. The client's input starts at the frame the snapshot sets its counter to.

package/src/engine/network/orchestrator/ServerAuthoritativeClient.d.ts

@@ -54,6 +54,27 @@
  *    third. Here the authored half is `onReplay`'s job and the arrived half is
  *    this one's.
  *
+ *  - Records that arrive from a peer for a frame this client has already
+ *    predicted past belong in that frame, under the prediction since, and
+ *    before the frame's corrections, which already hold what they did. The
+ *    frames after it were predicted without them and hold the prior state they
+ *    captured then, so a rewind across those frames would put back what the
+ *    records changed — a rewind about any other entity included. Where the
+ *    records write something a frame after theirs, or a correction of their
+ *    own frame, holds prior state of, the client takes them back off the
+ *    world, rewinds to the end of their frame and back past its corrections,
+ *    applies them there, the corrections after them, and replays what came
+ *    after, as a reconciliation replays. Records about nothing written since
+ *    stay where they landed: for everything they write, the present still holds
+ *    what the end of their frame held. The test is on what records write, not
+ *    what they read: one that only reads state written since — copying a
+ *    predicted value into an entity nothing else writes — keeps what it read at
+ *    the present until a replay crosses its frame. The replay is a
+ *    reconciliation's, so a local record {@link onReplay} does not produce is
+ *    lost from the frames it rebuilds. Records for a frame the action log has
+ *    moved past have no frame to go in: they are applied where they land, and
+ *    not logged.
+ *
  *  - A no-op short-circuit is built in: before doing the rewind+replay, the
  *    orchestrator gives the user a chance to compute what the replay WOULD
  *    produce via {@link onComputeExpected}; if that matches the current
@@ -83,6 +104,7 @@ export class ServerAuthoritativeClient {
      *   time_dilation?: TimeDilation,
      *   max_packets_per_tick?: number,
      *   auto_reconcile?: boolean,
+     *   rebase_on_arrival?: boolean,
      *   clock: function(): number,
      *   tick_period_ms: number,
      *   send_rate_bytes_per_second?: number,
@@ -96,8 +118,8 @@ export class ServerAuthoritativeClient {
      * `time_dilation`: optional pre-configured {@link TimeDilation}.
      * On TIME_DILATION feedback the client recomputes
      * {@link dilation_factor} for the caller to scale its tick cadence.
-     * Defaults to a stock instance; `dilation_factor` is 1.0 until the
-     * first feedback arrives.
+     * Defaults to one built for round trips up to `frame_capacity` frames;
+     * `dilation_factor` is 1.0 until the first feedback arrives.
      *
      * `max_packets_per_tick`: forwarded to {@link NetworkPeer}; how many
      * action-stream packets a tick may send the server.
@@ -107,8 +129,15 @@ export class ServerAuthoritativeClient {
      * own reconciliation — `NetworkSession` corrects by comparison instead —
      * turns it off and listens to `peer.onAuthState` itself; {@link reconcile}
      * remains available to it.
+     *
+     * `rebase_on_arrival` (default true): put the records a peer sends for a
+     * frame this client has already predicted past in that frame, under what it
+     * predicted since, by rewind and replay — see the class notes. It keeps the
+     * log true for the rewinds this client reconciles by. A caller that never
+     * rewinds — `NetworkSession` correcting by comparison — turns it off, and
+     * the records are applied to the world as it is when they arrive.
      */
-    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, input_ring_capacity, input_byte_size, reconcile_epsilon, time_dilation, max_packets_per_tick, auto_reconcile, clock, tick_period_ms, send_rate_bytes_per_second, max_message_bytes, receive_window_bytes, max_queued_bytes, }: {
+    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, input_ring_capacity, input_byte_size, reconcile_epsilon, time_dilation, max_packets_per_tick, auto_reconcile, rebase_on_arrival, clock, tick_period_ms, send_rate_bytes_per_second, max_message_bytes, receive_window_bytes, max_queued_bytes, }: {
         world: EntityComponentDataset;
         binary_registry: BinarySerializationRegistry;
         replicated_components: Function[];
@@ -122,6 +151,7 @@ export class ServerAuthoritativeClient {
         time_dilation?: TimeDilation;
         max_packets_per_tick?: number;
         auto_reconcile?: boolean;
+        rebase_on_arrival?: boolean;
         clock: () => number;
         tick_period_ms: number;
         send_rate_bytes_per_second?: number;
@@ -131,7 +161,10 @@ export class ServerAuthoritativeClient {
     });
     /** @type {number} */
     reconcile_count: number;
-    /** @type {number} */
+    /**
+     * Frames replayed, by reconciliations and by records put back in their frame.
+     * @type {number}
+     */
     replay_frame_count: number;
     /**
      * Records that arrived from a peer and were reapplied by a replay, over the
@@ -147,6 +180,13 @@ export class ServerAuthoritativeClient {
      * @type {number}
      */
     reconcile_abandoned_count: number;
+    /**
+     * Frames of records from a peer that arrived after this client had predicted past them, wrote
+     * something written later — in a frame after theirs, or by a correction of their own — and so
+     * were put back in their frame by a rewind and a replay. See {@link #land_arrived}.
+     * @type {number}
+     */
+    rebase_count: number;
     /** @type {NetworkPeer} */
     peer: NetworkPeer;
     /** @type {EntityComponentDataset} */
@@ -190,7 +230,10 @@ export class ServerAuthoritativeClient {
     /**
      * Tick-period multiplier from the latest TIME_DILATION feedback.
      * `< 1.0` ⇒ caller should run faster, `> 1.0` ⇒ slower. 1.0 until
-     * the first feedback arrives.
+     * the first feedback arrives. It follows every report, and holds while
+     * none come: a caller that seeks its frames back, or loses the host,
+     * judges whether the latest report still holds before running at it, as
+     * `NetworkSession` does.
      *
      *   scheduled_tick_period_ms = TICK_PERIOD_MS * client.dilation_factor;
      *
@@ -284,6 +327,9 @@ export class ServerAuthoritativeClient {
      * longer holds the frames its rewind needed. Args:
      * `(server_frame, network_id)`.
      *
+     * Nothing of it is done: the world stays at the present, and the
+     * server's state is not applied.
+     *
      * This is a real loss of replicated state and not a hiccup: state a peer
      * does not own reaches it on the action stream, and an owner that
      * publishes on change never sends it again — so whatever that window

package/src/engine/network/orchestrator/ServerAuthoritativeClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ServerAuthoritativeClient.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeClient.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"ServerAuthoritativeClient.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeClient.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AACH;IAgGI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACH,kXA/CW;QACV,KAAS,yBAAyB;QAClC,eAAmB,8BAA8B;QACjD,qBAAyB,EAAE,UAAU,CAAC;QACtC,cAAkB,EAAE,UAAU,CAAC;QAC/B,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,cAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,mBAAuB,CAAC,EAAE,MAAM,CAAC;QACjC,eAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,iBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,aAAiB,CAAC,EAAE,YAAY,CAAC;QACjC,oBAAwB,CAAC,EAAE,MAAM,CAAC;QAClC,cAAkB,CAAC,EAAE,OAAO,CAAC;QAC7B,iBAAqB,CAAC,EAAE,OAAO,CAAC;QAChC,KAAS,QAAc,MAAM,CAAC;QAC9B,cAAkB,EAAE,MAAM,CAAC;QAC3B,0BAA8B,CAAC,EAAE,MAAM,CAAC;QACxC,iBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,oBAAwB,CAAC,EAAE,MAAM,CAAC;QAClC,gBAAoB,CAAC,EAAE,MAAM,CAAC;KAC3B,EAwQH;IA/TD,qBAAqB;IACrB,iBADW,MAAM,CACG;IAEpB;;;OAGG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;;OAMG;IACH,wBAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,2BAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,cAFU,MAAM,CAEC;IAwEb,0BAA0B;IAC1B,MADW,WAAW,CAgBpB;IAEF,qCAAqC;IACrC,8BAAkB;IAClB,gCAAgC;IAChC,4BAAkC;IAClC,mCAAmC;IACnC,iCAAsC;IACtC,wBAAwB;IACxB,sBAAsC;IACtC,gCAAgC;IAChC,mCAAgD;IAEhD;;;;OAIG;IACH,YAFU,SAAS,CAKjB;IAEF,2BAA2B;IAC3B,eADW,YAAY,CAKrB;IAEF;;;;;OAKG;IACH,mBAFU,MAAM,CAE0B;IAE1C;;;;;OAKG;IACH,eAFU,YAAY,CAEY;IAElC;;;;OAIG;IACH,mBAFU,MAAM,CAEW;IAE3B;;;;;;;;;;;OAWG;IACH,iBAFU,MAAM,CAEU;IAO1B;;;;;;;;;OASG;IACH,WAFU,MAAM,CAEa;IAE7B;;;;;;;;;OASG;IACH,UAFU,MAAM,CAEY;IAE5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;;;;;;;;;;OAgBG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;OAIG;IACH,qBAFU,MAAM,CAEuB;IAEvC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,sBAFU,MAAM,CAEwB;IAmB5C;;;;OAIG;IACH,2BAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,8DAIhB;IAED;;;;;;;;;;;OAWG;IACH,oBAFW,MAAM,QAKhB;IAED;;;;;;OAMG;IACH,0BAFW,MAAM,QAUhB;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,iBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;;;;;;OAQG;IACH,wBAJW,MAAM,cACN,MAAM,UACN,YAAY,QAItB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,wBAIC;IAkhBD;;;;;OAKG;IACH,oBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAIhB;;CACJ;4BA7oC2B,kBAAkB;0BAFpB,uBAAuB;6BAFpB,wBAAwB;6BAGxB,yBAAyB;mBANnC,uCAAuC;6BAH7B,sCAAsC"}