@woosh/meep-engine 3.47.0 → 3.50.0

package/src/engine/network/NetworkSession.js

@@ -520,6 +520,16 @@ export class NetworkSession {
      */
     correction_skipped_count = 0;
 
+    /**
+     * 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 = 0;
+
     /**
      * Client, {@link NetworkSessionReconcile.Correct}: a component of an authoritative state
      * differed from the prediction, and the present was corrected. Once per component corrected.
@@ -667,6 +677,17 @@ export class NetworkSession {
      */
     #host_frame_seen = -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
+     * frame the host named plus the depth). The dilation steers by the depth; the stall rule reads
+     * it for what the host's window makes of our input, latency included. 0 and -1 on a new binding.
+     * @private @type {number}
+     */
+    #host_depth_seen = 0;
+    /** @private @type {number} */
+    #host_marker_seen = -1;
+
     /**
      * Client: the peer whose held inbound — action stream and AUTH_STATE, held from `connect()`
      * until the binding's answer is whole — is to be released as the step's inbound is done, or -1.
@@ -1347,8 +1368,10 @@ export class NetworkSession {
                     this.#finish_sync(peer_id, frame_number);
                 }
             });
-            this.#peer.onTimeDilationFeedback.add((_peer_id, _depth, frame_number) => {
+            this.#peer.onTimeDilationFeedback.add((_peer_id, depth, frame_number) => {
                 if (frame_number > this.#host_frame_seen) this.#host_frame_seen = frame_number;
+                this.#host_depth_seen = depth;
+                this.#host_marker_seen = frame_number + depth;
             });
             // Host's response to our RESUME_HELLO during reconnect.
             this.#peer.onResumeAccept.add((peer_id) => {
@@ -1508,6 +1531,8 @@ export class NetworkSession {
             // held: sent on an accept, dropped on a sync.
             this.#binding_answer = BindingAnswer.Pending;
             this.#host_frame_seen = -1;
+            this.#host_depth_seen = 0;
+            this.#host_marker_seen = -1;
             this.#peer.hold_outbound(remote_peer_id);
             // Inbound too, until the answer is whole: an action stream that arrives ahead of it —
             // a join's stream can, when the pages are lost on the way — is about the world the
@@ -1753,6 +1778,10 @@ export class NetworkSession {
         this.#flush_inbound();
         this.#release_held_inbound();
 
+        if (this.#client !== null) {
+            this.#retake_host_time_if_stalled();
+        }
+
         this.#apply_pending_interpolation();
 
         if (this.#client !== null && this.#pending_auth.size > 0) {
@@ -2034,9 +2063,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
@@ -2045,8 +2074,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
@@ -2458,6 +2489,61 @@ export class NetworkSession {
         this.#client.forget_timeline();
     }
 
+    /**
+     * Client, as a step opens: more than the host's input window behind, the client re-takes the
+     * host's time.
+     *
+     * A client stops stepping when its tab goes to the background (`Ticker` suspends, and discards
+     * the gap when the tab returns), under a debugger, or with the lid shut; the host runs on, and
+     * what it sent meanwhile is waiting in the held transport. Nothing told the session. Behind by N
+     * frames, the time dilation closed the gap at 5% — 20 × N frames, 190 s for a 10 s stall — and
+     * until the gap was inside the window `ServerAuthoritativeServer.begin_tick` trimmed every input
+     * the client sent, silently: the client's own entities ran off on its screen, and were yanked
+     * back by the corrections once its input landed again. Measured 2026-10-15; the spec is
+     * `NetworkSession.stall.spec.js`.
+     *
+     * The host names its frame in every TIME_DILATION packet (`#host_frame_seen`), so the gap is
+     * known the moment the held packets are applied. Past the window — where the host drops input
+     * rather than applying it late — it is a discontinuity, not something to steer: the counter is
+     * re-taken as INITIAL_SYNC takes it, and what was predicted on the old numbering is dropped.
+     * Inside the window the dilation is left to it, with the input applied late meanwhile (a 31-frame
+     * stall costs 9.8 s of that). The window is the host's; the client's own `frame_capacity` stands
+     * for it here, the host never names it, and the two default alike.
+     *
+     * The gap is exact only at zero latency: the frame the host named is a one-way trip old, and
+     * input tagged now lands a one-way trip later, so a client behind by a little less than the
+     * window as it sees it is behind by more than the window as the host does — every input
+     * dropped, and the gap never says so, for the 20 × 2 × latency frames the dilation takes to
+     * close the band (2 s at 50 ms one way). The host's depth feedback says so exactly: it is its
+     * latest sight of our frame minus its sim frame, measured where our input lands, latency
+     * included. At or past the window's depth the host is dropping our input, and the client
+     * re-takes its time — once the host has seen input from the time last taken, since the reports
+     * in flight after a re-align still carry the old depth.
+     *
+     * Keyed on the gap and on the host's word, never on the page's visibility: a debugger pause, a
+     * GC stall and a sleeping laptop look the same from here, and the session never sees the ticker.
+     */
+    #retake_host_time_if_stalled() {
+        if (this.#binding_answer !== BindingAnswer.Synced && this.#binding_answer !== BindingAnswer.Resumed) return;
+
+        const behind = this.#host_frame_seen - this.#local_frame;
+        const trimmed = this.#host_depth_seen <= -this.frame_capacity
+            && this.#host_marker_seen >= this.#world_start_frame;
+        if (behind < this.frame_capacity && !trimmed) return;
+
+        this.stall_count++;
+
+        this.#align_to_host(this.#host_frame_seen);
+        this.#forget_predicted_world();
+
+        // Input from here on is predicted on the host's time. What was predicted before it is below
+        // the host's window and would be trimmed on arrival, so it is not sent.
+        this.#world_start_frame = this.#local_frame;
+        if (this.#peer.is_connected(this.#remote_peer_id)) {
+            this.#peer.release_outbound(this.#remote_peer_id, this.#world_start_frame);
+        }
+    }
+
     /**
      * Apply an inbound INITIAL_SYNC payload. Walks the wire format
      * directly instead of using `snapshotter_apply` so we can:
@@ -2895,6 +2981,13 @@ export class NetworkSession {
      * pinned forever (host) or never noticed (client). The per-tick keepalive
      * traffic the facade sends both directions keeps a live connection well
      * clear of the budget. Called from `tick()` only when the budget is > 0.
+     *
+     * The host closes a reaped peer's transport as well. A silent peer is not always a gone one: a
+     * client whose tab went to the background stops stepping and keeps its socket, and when it steps
+     * again the close is waiting behind the packets it was sent, so it learns of the reap then — not
+     * a whole silence budget later, on a clock that stood still with it (its budget runs on frame
+     * time). A transport with no close of its own (`NodeUDP`) leaves it to that budget.
+     * `NetworkSession.stall.spec.js`.
      * @private
      */
     #reap_silent_peers() {
@@ -2906,7 +2999,11 @@ export class NetworkSession {
             }
             if (to_reap !== null) {
                 for (let i = 0; i < to_reap.length; i++) {
-                    this.#on_peer_transport_disconnected(to_reap[i], 'timeout');
+                    const peer_id = to_reap[i];
+                    // unwired by the reap before it is closed, so the close is not taken for a second loss
+                    const entry = this.#peer_transport_listeners.get(peer_id);
+                    this.#on_peer_transport_disconnected(peer_id, 'timeout');
+                    if (entry !== undefined) close_transport(entry.transport);
                 }
             }
         } else if (this.#reconnect_state === ReconnectState.Connected && this.#remote_peer_id >= 0) {

package/src/engine/network/README.md

@@ -95,7 +95,13 @@ nothing else to set up. What that takes, and where it lives:
   the action-log rewind + replay, exact for simulations made only of deterministic actions.
 - **Late input is applied, not rolled back** (`late_input: 'apply'`, host default). Input
   buffering (`simulation_delay_ticks`) and time dilation keep input on time; the client's per-tick
-  `FRAME_MARKER` keeps the dilation honest when it sends no input.
+  `FRAME_MARKER` keeps the dilation honest when it sends no input. Input older than the host's
+  window (`frame_capacity`) is dropped and reported (`onPendingActionDropped`, `'window'`).
+- **A record is known by its frame and its place in it, never by its bytes.** The action stream
+  re-sends every unconfirmed frame each tick; the host tells the copies from new input by
+  `(sender, frame, ordinal)`, the ordinal being the record's index in the sender's frame, carried
+  on the wire. Two inputs alike in every byte — a held key, frame after frame, or two identical
+  actions in one frame — are two inputs, late and folded into one host frame or not.
 
 Things the session cannot fix for the game:
 
@@ -159,6 +165,26 @@ the partial world, applies what it held, releases its own input and fires `onSyn
 per joining peer is the lane's window and 12 bytes per entity; client memory is a page and what it
 holds, at most `max_queued_bytes`.
 
+### A client that stalls
+
+A client in a background tab takes no steps (`Ticker` suspends, and discards the gap when the tab
+returns), and neither does one under a debugger or with the lid shut; the host runs on, and what it
+sent is waiting in the client's held transport. Two things happen on the first steps back, keyed on
+what the session sees and never on the page's visibility:
+
+- **More than the host's input window behind** (`frame_capacity`, 32 frames), the client re-takes the
+  host's time — the host names its frame in every TIME_DILATION packet — exactly as a snapshot sets
+  it: the counter moves to the host's frame plus the lead, what was predicted on the old numbering is
+  dropped, and input starts again from there. `stall_count` counts these. Inside the window the time
+  dilation closes the gap on its own, at 5% of a frame per frame, with the input applied late
+  meanwhile. Measured before the rule: 20 × the stall to recover, and every input trimmed until the
+  gap was inside the window.
+- **Silent past `connection_timeout_ms`**, the client has been reaped into the host's grace window and
+  its transport closed, so the close is waiting behind the held packets: the reconnect ladder runs on
+  the first step back, and the host, whose log no longer reaches the client's last ack, sends its
+  world again. A transport with no close of its own (`NodeUDP`) leaves the client to find out through
+  its own silence budget, which runs on frame time and so starts again when the client does.
+
 ### A connection that breaks
 
 A connection does not authenticate datagrams; its transport delivers only the peer's (DTLS, TLS, and

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

@@ -31,10 +31,12 @@ export const LateInput: Readonly<{
  *   1. Inbound action packets do NOT execute on arrival. Instead, a deferral
  *      hook on the {@link Replicator} drops them into a per-tick pending log
  *      tagged with `(client_frame, sender_id, type_id, payload_bytes)` —
- *      unless the action log already holds that record. The action stream
- *      re-sends every unconfirmed frame each tick, so most arrivals at any
- *      real latency are copies of applied records; those are dropped where
- *      they arrive, and pending holds only input the log does not.
+ *      unless the record has arrived before. A record is known by
+ *      `(sender, frame, ordinal)`, never by its bytes; a per-sender
+ *      {@link RecordArrivalRing} answers that. The action stream re-sends
+ *      every unconfirmed frame each tick, so most arrivals at any real latency
+ *      are copies of applied records; those are dropped where they arrive, and
+ *      pending holds only input that is new.
  *   2. Once per server tick, `tick(current_frame)` consumes the pending log:
  *      - Rejects entries older than the action_log's rewindable window.
  *      - Determines `replay_start`: the oldest pending frame, which by the
@@ -126,7 +128,7 @@ export class ServerAuthoritativeServer {
      * input-to-feedback latency (client prediction hides it). Default 0
      * reproduces pre-feature behavior.
      */
-    constructor({ world, binary_registry, replicated_components, action_classes, scope_filter, frame_capacity, initial_buffer_size, simulation_delay_ticks, max_pending_future_lead, max_pending_total, identity_class, server_peer_id, max_packets_per_tick, late_input, 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, simulation_delay_ticks, max_pending_future_lead, max_pending_total, max_records_per_frame, identity_class, server_peer_id, max_packets_per_tick, late_input, 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[];
@@ -209,15 +211,25 @@ export class ServerAuthoritativeServer {
     max_pending_future_lead: number;
     /**
      * Absolute backstop on the number of buffered pending entries. Even
-     * within the future window a peer can vary an action's payload to
-     * defeat the per-frame dedup and pile up many distinct entries; this
-     * caps total memory (and the dedup scan cost) regardless. Legitimate
-     * pending depth is tiny (≈ delay × actions/frame × peers), so this only
-     * ever trips under abuse. Raise it for very high concurrent-player
-     * counts.
+     * within the future window a peer can claim as many ordinals per frame
+     * as it likes and pile up distinct entries; this caps total memory
+     * regardless. Legitimate pending depth is tiny (≈ delay × actions/frame
+     * × peers), so this only ever trips under abuse. Raise it for very high
+     * concurrent-player counts.
      * @type {number}
      */
     max_pending_total: number;
+    /**
+     * Upper bound on a record's ordinal — its index in the sender's frame.
+     * The ordinal is an attacker-controlled varint and the arrival ring
+     * sizes its per-frame bitsets to the ordinals it is asked to mark, so
+     * without a ceiling one record claiming to be its frame's 2^30th is a
+     * request for gigabytes. A frame is one step of a sender's input;
+     * thousands of records in one is not input. Dropped records are
+     * reported `'ordinal'` on {@link onPendingActionDropped}.
+     * @type {number}
+     */
+    max_records_per_frame: number;
     /**
      * Fires once per execution of a frame, AFTER all input for that frame
      * has been applied and BEFORE the action_log frame is closed. Use it
@@ -285,11 +297,21 @@ export class ServerAuthoritativeServer {
      */
     onRewind: Signal;
     /**
-     * Fired when an inbound pending action is dropped by the future-lead or
-     * total-capacity bound (i.e. a far-future frame tag or a flood). Args:
-     * `(sender_id, frame_number, reason)` where `reason` is `'future'` or
-     * `'capacity'`. Observable so an abusive peer can be logged / kicked;
-     * the dropped action is simply not buffered.
+     * Fired when an inbound pending action is dropped. Args:
+     * `(sender_id, frame_number, reason)` where `reason` is `'future'` (tagged
+     * past the future horizon), `'capacity'` (the total cap: a flood),
+     * `'ordinal'` (a record claiming an index in its frame past
+     * `max_records_per_frame`: not input) or `'window'` (tagged for a frame
+     * older than the log can rewind to, so it can never be applied where it
+     * was tagged — a client that stalled, or one far behind the host's
+     * time). A copy of a record that was accepted is recognised before any
+     * of these and never reported, however old its frame has become. A
+     * record that was never accepted is reported once per copy that
+     * arrives: a stalled client's frame is re-sent until its
+     * acknowledgement round-trips, so one lost input shows as a few of
+     * these. Observable so an abusive peer can be logged / kicked, and so a
+     * game can see input that vanished; until 2026-10-15 the `'window'`
+     * case was silent. The dropped action is simply not buffered.
      * @type {Signal}
      */
     onPendingActionDropped: Signal;
@@ -412,8 +434,8 @@ export class ServerAuthoritativeServer {
      */
     buffer_depth_for_peer(peer_id: number): number;
     /**
-     * Number of inbound pending actions dropped by the future-lead / total
-     * bounds so far. See {@link onPendingActionDropped}.
+     * Number of inbound pending actions dropped so far — tagged past the future horizon, below the
+     * rewindable window, or over the total cap. See {@link onPendingActionDropped}.
      * @returns {number}
      */
     pending_dropped_count(): number;

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

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