@woosh/meep-engine 3.46.0 → 3.47.0

package/src/engine/network/orchestrator/ServerAuthoritativeClient.js

@@ -5,17 +5,18 @@ import Signal from "../../../core/events/signal/Signal.js";
 import { AlwaysRelevantScope } from "../replication/ScopeFilter.js";
 import { ActionRecordCursor } from "../sim/ActionRecordCursor.js";
 import { RewindEngine } from "../sim/RewindEngine.js";
+import { SENDER_CORRECTED } from "../sim/SimActionExecutor.js";
 import { InputRing } from "../state/InputRing.js";
 import { TimeDilation } from "../time/TimeDilation.js";
 import { NetworkPeer } from "./NetworkPeer.js";
 
 /**
  * Ints per harvested record in {@link ServerAuthoritativeClient}'s replay index:
- * action type id, sender id, and the offset of its payload.
+ * action type id, sender id, and the offset and length of its payload.
  *
  * @type {number}
  */
-const HARVEST_STRIDE = 3;
+const HARVEST_STRIDE = 4;
 
 /**
  * Client-side orchestrator for the predict-reconcile model.
@@ -29,14 +30,37 @@ const HARVEST_STRIDE = 3;
  *    action_log via the executor (capturing prior-state for later rewind),
  *    and goes out over the action stream when `peer.end_tick` flushes it.
  *
- *  - On AUTH_STATE arrival: rewind the world to end-of-(server_frame - 1)
- *    via the {@link RewindEngine}, deserialize the server's authoritative
- *    state bytes via {@link onApplyAuthState}, then replay forward by
- *    firing {@link onReplay} for every frame in the InputRing between
- *    `server_frame + 1` and the client's current frame. The user's
+ *  - On AUTH_STATE arrival: rewind the world to the end of `server_frame`
+ *    via the {@link RewindEngine}, overwrite it there with the server's
+ *    authoritative state bytes via {@link onApplyAuthState}, then replay
+ *    forward by firing {@link onReplay} for every frame in the InputRing
+ *    between `server_frame + 1` and the client's current frame. The user's
  *    {@link onReplay} handler re-executes the same SimActions the original
  *    predict path produced.
  *
+ *    An AUTH_STATE is the server's state at the END of `server_frame`, and it
+ *    is put back at exactly that point. It covers one `network_id`; the rest of
+ *    the world at that point is this client's own prediction of it, which
+ *    already holds the frame's input — so frame `server_frame` itself is never
+ *    undone, and nothing in it is lost or applied twice. (Undoing it and then
+ *    skipping it, which this did, took the frame's input back off every
+ *    predicted entity the bytes do not describe.)
+ *
+ *  - An applied AUTH_STATE stays on the timeline as a correction: a
+ *    `SENDER_CORRECTED` record at the end of `server_frame` in the action log,
+ *    holding the entity's state from before it and the bytes
+ *    {@link onApplyAuthState} read. A rewind across the frame undoes it like any
+ *    record, and the replay applies it again, last in its frame. Both halves
+ *    matter when one entity's AUTH_STATE arrives after another's newer one,
+ *    which a lossy link does routinely. Without the replay half the older
+ *    rewind replayed the prediction underneath the newer correction and left
+ *    that entity on its misprediction until its next AUTH_STATE. Without the
+ *    undo half the newer correction stayed in the world while the older frames
+ *    replayed, so an action there that read the entity read the server's value
+ *    from a later frame. The record is never packed for a peer — this log is
+ *    also the outbound stream, and the host would take a client-owned entity's
+ *    old state from it.
+ *
  *  - A replay also reapplies the records in the rewound window that ARRIVED
  *    from a peer, which {@link onReplay} cannot: it re-executes this client's
  *    own input, and the AUTH_STATE that precedes it carries one `network_id`.
@@ -79,10 +103,11 @@ export class ServerAuthoritativeClient {
     #measured_scratch;
 
     /**
-     * Records of one log frame that arrived from a peer, indexed
-     * {@link HARVEST_STRIDE} ints apiece into {@link #harvest_payloads}. Filled
-     * by {@link #harvest_arrived} before the frame is reopened and drained by
-     * {@link #execute_harvested} once it is.
+     * Records of one log frame that a replay puts back — arrived from a peer,
+     * or corrections — indexed {@link HARVEST_STRIDE} ints apiece into
+     * {@link #harvest_payloads}. Filled by {@link #harvest} before the frame is
+     * reopened and drained by {@link #execute_harvested} and
+     * {@link #reapply_corrections} once it is.
      * @type {Int32Array}
      */
     #harvest_index = new Int32Array(HARVEST_STRIDE * 32);
@@ -102,6 +127,17 @@ export class ServerAuthoritativeClient {
     /** @type {ActionRecordCursor} */
     #harvest_cursor = new ActionRecordCursor();
 
+    /**
+     * A correction record's payload, composed before it is logged: the network
+     * id, its slot generation, and the bytes {@link onApplyAuthState} read.
+     *
+     * Each is about one entity, not one id: a correction whose id has since been
+     * freed, or freed and handed to another entity, is dropped by the replay
+     * rather than written onto that one.
+     * @type {BinaryBuffer}
+     */
+    #correction_payload = new BinaryBuffer();
+
     // Counters
     /** @type {number} */
     reconcile_count = 0;
@@ -140,8 +176,16 @@ export class ServerAuthoritativeClient {
      *   time_dilation?: TimeDilation,
      *   max_packets_per_tick?: number,
      *   auto_reconcile?: boolean,
+     *   clock: function(): number,
+     *   tick_period_ms: number,
+     *   send_rate_bytes_per_second?: number,
+     *   max_message_bytes?: number,
+     *   receive_window_bytes?: number,
+     *   max_queued_bytes?: number,
      * }} options
      *
+     * `clock`, `tick_period_ms` and the connection options: forwarded to {@link NetworkPeer}.
+     *
      * `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.
@@ -171,6 +215,12 @@ export class ServerAuthoritativeClient {
         time_dilation = new TimeDilation(),
         max_packets_per_tick,
         auto_reconcile = true,
+        clock,
+        tick_period_ms,
+        send_rate_bytes_per_second,
+        max_message_bytes,
+        receive_window_bytes,
+        max_queued_bytes,
     }) {
         /** @type {NetworkPeer} */
         this.peer = new NetworkPeer({
@@ -182,6 +232,12 @@ export class ServerAuthoritativeClient {
             frame_capacity,
             initial_buffer_size,
             max_packets_per_tick,
+            clock,
+            tick_period_ms,
+            send_rate_bytes_per_second,
+            max_message_bytes,
+            receive_window_bytes,
+            max_queued_bytes,
         });
 
         /** @type {EntityComponentDataset} */
@@ -321,6 +377,14 @@ export class ServerAuthoritativeClient {
          * payload bytes. The handler should deserialize the bytes into
          * the world (the rewind has already happened; the buffer's bytes
          * ARE the new authoritative state at server_frame).
+         *
+         * The handler must leave `buffer.position` past what it read: those
+         * bytes are what this client keeps as the correction, and a later
+         * replay that crosses `server_frame` fires this again, at the end of
+         * that frame, with a buffer positioned at them.
+         *
+         * Write only the entity's replicated components: the correction's
+         * prior state, which a rewind puts back, is captured for those.
          * @type {Signal}
          */
         this.onApplyAuthState = new Signal();
@@ -381,10 +445,12 @@ export class ServerAuthoritativeClient {
         this.peer.disconnect_peer(peer_id);
     }
 
-    /** Channel accessor for manual packet plumbing.
-     * @param {number} peer_id */
-    channel_for(peer_id) {
-        return this.peer.channel_for(peer_id);
+    /**
+     * The server's connection, for diagnostics. See {@link NetworkPeer#connection_for}.
+     * @param {number} peer_id
+     */
+    connection_for(peer_id) {
+        return this.peer.connection_for(peer_id);
     }
 
     /**
@@ -422,7 +488,8 @@ export class ServerAuthoritativeClient {
     }
 
     /**
-     * Second half of a tick: close the frame and flush the action stream to the server.
+     * Second half of a tick: close the frame and send the action stream, with everything else
+     * queued, to the server.
      */
     end_tick() {
         this.peer.end_tick();
@@ -472,6 +539,30 @@ export class ServerAuthoritativeClient {
         this.#handle_auth_state(server_frame, network_id, buffer);
     }
 
+    /**
+     * Forget everything this client holds about the frames it has run: the
+     * action log's records — the kept corrections among them — the sampled
+     * input, and the newest reconciled frame per network id.
+     *
+     * For when the frame numbering they were kept under is replaced — a resync
+     * that brings a new world and seeks the clock, possibly backwards. Kept, a
+     * correction from the old numbering would be written into the new one by
+     * the first replay that crosses its frame number, and the old watermark
+     * would refuse the new AUTH_STATEs that should overwrite it. The log and the
+     * input matter where the seek leaves frames the new world never runs: a
+     * sync at host frame F seeks past F by the input lead, and a rewind to F
+     * crosses the frames in between — it would put back the old world's prior
+     * state from the records there, and the replay would hand the old input
+     * to {@link onReplay}.
+     *
+     * Must be called with no frame open.
+     */
+    forget_timeline() {
+        this.#last_reconciled_frame.clear();
+        this.action_log.empty_frames();
+        this.input_ring.clear();
+    }
+
     /** @private */
     #handle_auth_state(server_frame, network_id, buffer) {
         // Out-of-order safety: never reconcile to an older frame than the
@@ -512,16 +603,25 @@ export class ServerAuthoritativeClient {
 
         this.onBeforeReconcile.send2(server_frame, network_id);
 
-        // Real divergence: rewind, apply server's bytes, replay forward.
-        const rewind_target = server_frame - 1;
-        let rewound = false;
-        if (this.#current_frame > rewind_target) {
+        /*
+         Real divergence: rewind to the END of `server_frame`, overwrite there,
+         replay what came after.
+
+         The AUTH_STATE describes the end of `server_frame`, so that is where it
+         goes. Everything it does not describe stays as this client predicted it
+         at that point — the frame's input included, which the server's state
+         holds too. Undoing frame `server_frame` instead and skipping it on the
+         way back took its input off every predicted entity but `network_id`; a
+         client predicting two entities lost a frame of the other one's input on
+         every reconciliation, and compounding, since the next entity's rewind
+         to the same frame undid the first one's correction again.
+        */
+        if (this.#current_frame > server_frame) {
             try {
-                this.rewind_engine.rewind_to(this.#current_frame, rewind_target);
-                rewound = true;
+                this.rewind_engine.rewind_to(this.#current_frame, server_frame);
             } catch (e) {
                 /*
-                 The action_log rolled past server_frame, so the window this
+                 The action_log rolled past `server_frame + 1`, so the window this
                  reconciliation needs no longer exists and skipping it is the
                  only option left. Counted and announced rather than swallowed:
                  what the window carried for every entity other than this one is
@@ -534,41 +634,17 @@ export class ServerAuthoritativeClient {
             }
         }
 
-        /*
-         Frame `server_frame` was just undone and is NOT replayed below: the
-         AUTH_STATE is the server's state at the END of it, so re-running this
-         client's own input for that frame would apply that input twice.
-
-         Its ARRIVED records are the other half of the frame, and the half that
-         was being dropped. The bytes below repair one `network_id`; every other
-         entity the frame touched has nothing else to restore it. They go back in
-         BEFORE those bytes, so the authoritative value still wins wherever the
-         two describe the same component.
-
-         In the ordinary owner-scoped arrangement this is the frame that matters
-         most: the owner's records for a frame land in the log at the owner's
-         frame number, which is at or below `server_frame`, so they sit at the
-         very bottom of the rewound window rather than inside the replay range.
-        */
-        if (rewound && this.#harvest_arrived(server_frame) > 0) {
-            this.action_log.begin_frame(server_frame);
-            try {
-                this.#execute_harvested();
-            } finally {
-                this.action_log.end_frame();
-            }
-        }
-
-        // Apply the server's authoritative state bytes. The handler does the
-        // adapter-specific deserialize.
-        this.onApplyAuthState.send3(server_frame, network_id, buffer);
+        // Apply the server's authoritative state bytes, logged as a correction
+        // at the end of `server_frame`. The handler does the adapter-specific
+        // deserialize, and what it read is the correction.
+        this.#apply_correction(server_frame, network_id, local, buffer);
 
         // Replay forward from (server_frame + 1) through current_frame.
         let replay_count = 0;
         for (let f = server_frame + 1; f <= this.#current_frame; f++) {
             // Harvested before `begin_frame`, which rewinds the frame's buffer
-            // over the bytes being read. Nothing to harvest if nothing was undone.
-            const arrived = rewound ? this.#harvest_arrived(f) : 0;
+            // over the bytes being read.
+            const harvested = this.#harvest(f);
 
             this.action_log.begin_frame(f);
             try {
@@ -586,7 +662,12 @@ export class ServerAuthoritativeClient {
                  arrived later. It also leaves the owner's value last, which is
                  the one that should win where both touch a component.
                 */
-                if (arrived > 0) this.#execute_harvested();
+                if (harvested > 0) {
+                    this.#execute_harvested();
+
+                    // Last of all: a correction is the server's word on the END of its frame.
+                    this.#reapply_corrections(f);
+                }
             } finally {
                 this.action_log.end_frame();
             }
@@ -599,8 +680,97 @@ export class ServerAuthoritativeClient {
     }
 
     /**
-     * Copy the records of `frame` that arrived from a peer out of the action
-     * log, ready for {@link #execute_harvested} to put back.
+     * Overwrite `local` with the server's state at the end of `frame` through
+     * {@link onApplyAuthState}, logged as a `SENDER_CORRECTED` record appended
+     * to that frame: the entity's prior state, so a rewind across the frame
+     * undoes it, and the bytes the handler read, so a replay applies it again.
+     *
+     * A frame the log does not hold — not reached yet, the client running behind
+     * the server — or a frame open for writing leaves nothing to log into; the
+     * correction is then applied as it stands and a rewind will not undo it.
+     *
+     * @param {number} frame
+     * @param {number} network_id
+     * @param {number} local
+     * @param {BinaryBuffer} buffer positioned at the server's bytes
+     * @private
+     */
+    #apply_correction(frame, network_id, local, buffer) {
+        const log = this.action_log;
+
+        if (frame > this.#current_frame || log.has_open_frame() || !log.has_frame(frame)) {
+            this.onApplyAuthState.send3(frame, network_id, buffer);
+            return;
+        }
+
+        const payload_start = buffer.position;
+
+        log.resume_frame(frame);
+        try {
+            this.executor.begin_correction(local);
+            try {
+                this.onApplyAuthState.send3(frame, network_id, buffer);
+            } finally {
+                const length = buffer.position - payload_start;
+                assert.greaterThanOrEqual(length, 0, 'onApplyAuthState moved the buffer backwards');
+
+                const payload = this.#correction_payload;
+                payload.position = 0;
+                payload.writeUintVar(network_id);
+                payload.writeUintVar(this.slot_table.generation_of(network_id));
+                payload.writeBytes(buffer.raw_bytes, payload_start, length);
+
+                this.executor.end_correction(payload.raw_bytes, 0, payload.position);
+            }
+        } finally {
+            log.end_frame();
+        }
+    }
+
+    /**
+     * Apply again, through {@link onApplyAuthState}, every correction
+     * {@link #harvest} took from the frame now open — the replay has just
+     * rebuilt it from input and arrived records, and the server's state is what
+     * its end actually was. Each is logged again as it was the first time, prior
+     * state captured from what the replay rebuilt, so the next rewind across the
+     * frame undoes it in turn.
+     *
+     * A correction whose entity is gone — its id freed, or freed and handed to
+     * another entity since — is dropped: it describes nothing here any more.
+     *
+     * @param {number} frame
+     * @private
+     */
+    #reapply_corrections(frame) {
+        const payloads = this.#harvest_payloads;
+        const slot_table = this.slot_table;
+
+        for (let record = 0; record < this.#harvest_count; record++) {
+            const i = record * HARVEST_STRIDE;
+            if (this.#harvest_index[i + 1] !== SENDER_CORRECTED) continue;
+
+            const payload_start = this.#harvest_index[i + 2];
+            const payload_length = this.#harvest_index[i + 3];
+
+            payloads.position = payload_start;
+            const network_id = payloads.readUintVar();
+            const generation = payloads.readUintVar();
+
+            const local = slot_table.entity_for(network_id);
+            if (local < 0 || slot_table.generation_of(network_id) !== generation) continue;
+
+            this.executor.begin_correction(local);
+            try {
+                this.onApplyAuthState.send3(frame, network_id, payloads);
+            } finally {
+                this.executor.end_correction(payloads.raw_bytes, payload_start, payload_length);
+            }
+        }
+    }
+
+    /**
+     * Copy the records of `frame` that a replay puts back out of the action
+     * log, ready for {@link #execute_harvested} and {@link #reapply_corrections}.
      *
      * MUST be called before `action_log.begin_frame(frame)`. Opening a frame
      * rewinds its buffer to zero without clearing it, and the re-execution
@@ -613,6 +783,8 @@ export class ServerAuthoritativeClient {
      *  - a CONNECTED peer's id — it arrived from that peer, and nothing else
      *    here reproduces it. `onApplyAuthState` covers one `network_id` and
      *    {@link onReplay} covers this client's own input. Kept.
+     *  - `SENDER_CORRECTED` — a server's correction, applied again at the end
+     *    of the frame. Kept.
      *  - `SENDER_DERIVED` — output a replay recomputes. Skipped, same as
      *    `ServerAuthoritativeServer.#read_historical` skips it.
      *  - `SENDER_LOCAL`, and this client's own peer id — its own input, which
@@ -628,7 +800,7 @@ export class ServerAuthoritativeClient {
      * @returns {number} how many records were harvested
      * @private
      */
-    #harvest_arrived(frame) {
+    #harvest(frame) {
         this.#harvest_count = 0;
         this.#harvest_payloads.position = 0;
 
@@ -639,7 +811,8 @@ export class ServerAuthoritativeClient {
         const bytes = cursor.buffer.raw_bytes;
 
         while (cursor.next()) {
-            if (!this.peer.is_connected(cursor.sender_id)) continue;
+            const sender_id = cursor.sender_id;
+            if (sender_id !== SENDER_CORRECTED && !this.peer.is_connected(sender_id)) continue;
 
             if ((this.#harvest_count + 1) * HARVEST_STRIDE > this.#harvest_index.length) {
                 this.#grow_harvest_index();
@@ -647,8 +820,9 @@ export class ServerAuthoritativeClient {
 
             const i = this.#harvest_count * HARVEST_STRIDE;
             this.#harvest_index[i] = cursor.action_type_id;
-            this.#harvest_index[i + 1] = cursor.sender_id;
+            this.#harvest_index[i + 1] = sender_id;
             this.#harvest_index[i + 2] = this.#harvest_payloads.position;
+            this.#harvest_index[i + 3] = cursor.payload_len;
             this.#harvest_count++;
 
             this.#harvest_payloads.writeBytes(bytes, cursor.payload_start, cursor.payload_len);
@@ -658,8 +832,8 @@ export class ServerAuthoritativeClient {
     }
 
     /**
-     * Re-execute what {@link #harvest_arrived} took, in log order, into the
-     * currently-open frame.
+     * Re-execute the arrived records {@link #harvest} took, in log order, into
+     * the currently-open frame.
      *
      * Going back through the executor is the point rather than an implementation
      * detail: it captures each record's prior bytes again as it applies, so the
@@ -676,6 +850,7 @@ export class ServerAuthoritativeClient {
             const i = record * HARVEST_STRIDE;
             const type_id = this.#harvest_index[i];
             const sender_id = this.#harvest_index[i + 1];
+            if (sender_id === SENDER_CORRECTED) continue;
             const payload_start = this.#harvest_index[i + 2];
 
             const klass = this.action_registry.klass_for(type_id);

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

@@ -102,11 +102,19 @@ export class ServerAuthoritativeServer {
      *   simulation_delay_ticks?: number,
      *   max_packets_per_tick?: number,
      *   late_input?: LateInput|string,
+     *   clock: function(): number,
+     *   tick_period_ms: number,
+     *   send_rate_bytes_per_second?: number,
+     *   max_message_bytes?: number,
+     *   receive_window_bytes?: number,
+     *   max_queued_bytes?: number,
      * }} options
      *
      * `max_packets_per_tick`: forwarded to {@link NetworkPeer}; how many
      * action-stream packets a tick may send one peer.
      *
+     * `clock`, `tick_period_ms` and the connection options: forwarded to {@link NetworkPeer}.
+     *
      * `late_input`: see {@link LateInput}. Default {@link LateInput.Rollback}.
      *
      * `simulation_delay_ticks`: server-side input buffer (Overwatch-style).
@@ -118,7 +126,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, }: {
+    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, }: {
         world: EntityComponentDataset;
         binary_registry: BinarySerializationRegistry;
         replicated_components: Function[];
@@ -129,6 +137,12 @@ export class ServerAuthoritativeServer {
         simulation_delay_ticks?: number;
         max_packets_per_tick?: number;
         late_input?: LateInput | string;
+        clock: () => number;
+        tick_period_ms: number;
+        send_rate_bytes_per_second?: number;
+        max_message_bytes?: number;
+        receive_window_bytes?: number;
+        max_queued_bytes?: number;
     });
     /**
      * Most recently simulated frame. `-1` during warmup
@@ -304,11 +318,10 @@ export class ServerAuthoritativeServer {
      */
     send_auth_state(peer_id: number, frame_number: number, network_id: number, write_fn: (buf: BinaryBuffer) => void): void;
     /**
-     * Channel accessor for the user's manual packet plumbing (e.g. sending
-     * empty ACK packets in the prototype). Most callers won't need this.
+     * A peer's connection, for diagnostics. See {@link NetworkPeer#connection_for}.
      * @param {number} peer_id
      */
-    channel_for(peer_id: number): import("../transport/Channel.js").Channel;
+    connection_for(peer_id: number): import("../transport/connection/Connection.js").Connection;
     /**
      * Send the current buffer-depth observation for one peer to that peer.
      * Convenience wrapper around {@link NetworkPeer#send_time_dilation_feedback}
@@ -378,8 +391,9 @@ export class ServerAuthoritativeServer {
     begin_tick(current_frame: number): void;
     /**
      * Second half of a tick: run {@link onLocalSim} for the open frame, close it, publish the new
-     * {@link current_sim_frame}, flush the action stream and fire {@link onTickComplete}. A no-op
-     * after a warmup {@link begin_tick}.
+     * {@link current_sim_frame}, queue the action stream, fire {@link onTickComplete}, and send
+     * everything queued — what the handlers queued included, so the tick leaves together. After a
+     * warmup {@link begin_tick} it only sends what is queued.
      */
     end_tick(): void;
     /**

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":";;;wBAmBU,MAAM;AAJhB;;;;;GAKG;AACH;IACI;;;;OAIG;;IAEH;;;;OAIG;;GAEJ;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH;IA2DI;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,yQA3BW;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,sBAA0B,CAAC,EAAE,MAAM,CAAC;QACpC,oBAAwB,CAAC,EAAE,MAAM,CAAC;QAClC,UAAc,CAAC,EAAE,SAAS,GAAC,MAAM,CAAC;KAC/B,EAkQH;IAtRD;;;;;OAKG;IACH,mBAFU,MAAM,CAEO;IAqDnB;;;;OAIG;IACH,qBAFU,SAAS,GAAC,MAAM,CAEE;IAC5B,0BAA0B;IAC1B,MADW,WAAW,CAUpB;IAEF,qCAAqC;IACrC,8BAAkB;IAClB,gCAAgC;IAChC,4BAAkC;IAclC,mCAAmC;IACnC,iCAAsC;IACtC,wBAAwB;IACxB,sBAAsC;IACtC,gCAAgC;IAChC,mCAAgD;IAChD,0CAA0C;IAC1C,gDAAsD;IAEtD,2BAA2B;IAC3B,eADW,YAAY,CAKrB;IAEF;;;;;;OAMG;IACH,6BAFU,MAAM,CAEqB;IAErC;;;;OAIG;IACH,wBAFU,MAAM,CAEoC;IAEpD;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEoB;IAEpC;;;;;;;;;OASG;IACH,yBAFU,MAAM,CAEsC;IAEtD;;;;;;;;;OASG;IACH,mBAFU,MAAM,CAE0B;IAyC1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,YAFU,MAAM,CAEc;IAE9B;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEkB;IAElC;;;;;;;OAOG;IACH,mBAFU,MAAM,CAEqB;IAErC;;;;;;;;;;;OAWG;IACH,UAFU,MAAM,CAEY;IAE5B;;;;;;;OAOG;IACH,wBAFU,MAAM,CAE0B;IAG9C;;;;;;;OAOG;IACH,sBAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAIhB;IAED;;;;;;;;OAQG;IACH,yBALW,MAAM,gBACN,MAAM,cACN,MAAM,YACN,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,QAIrC;IAED;;;;OAIG;IACH,qBAFW,MAAM,6CAIhB;IAED;;;;;;;;OAQG;IACH,qCAFW,MAAM,QAIhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,wCA8BC;IAED;;;OAGG;IACH,6BAFa,MAAM,CAIlB;IAED;;;;;;;;;;;;;OAaG;IACH,oBAFW,MAAM,QAKhB;IAED;;;;;;;;;OASG;IACH,0BAFW,MAAM,QAqEhB;IAED;;;;OAIG;IACH,iBAiBC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;;;OAQG;IACH,+BAHW,MAAM,GACJ,MAAM,CAOlB;IAoQD;;;;OAIG;IACH,yBAFa,MAAM,CAIlB;;CA6MJ;4BAroC2B,kBAAkB;6BAFjB,wBAAwB;mBAPlC,uCAAuC;6BAH7B,sCAAsC"}
+{"version":3,"file":"ServerAuthoritativeServer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeServer.js"],"names":[],"mappings":"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"}

package/src/engine/network/orchestrator/ServerAuthoritativeServer.js

@@ -172,11 +172,19 @@ export class ServerAuthoritativeServer {
      *   simulation_delay_ticks?: number,
      *   max_packets_per_tick?: number,
      *   late_input?: LateInput|string,
+     *   clock: function(): number,
+     *   tick_period_ms: number,
+     *   send_rate_bytes_per_second?: number,
+     *   max_message_bytes?: number,
+     *   receive_window_bytes?: number,
+     *   max_queued_bytes?: number,
      * }} options
      *
      * `max_packets_per_tick`: forwarded to {@link NetworkPeer}; how many
      * action-stream packets a tick may send one peer.
      *
+     * `clock`, `tick_period_ms` and the connection options: forwarded to {@link NetworkPeer}.
+     *
      * `late_input`: see {@link LateInput}. Default {@link LateInput.Rollback}.
      *
      * `simulation_delay_ticks`: server-side input buffer (Overwatch-style).
@@ -203,6 +211,12 @@ export class ServerAuthoritativeServer {
         server_peer_id = -1,
         max_packets_per_tick,
         late_input = LateInput.Rollback,
+        clock,
+        tick_period_ms,
+        send_rate_bytes_per_second,
+        max_message_bytes,
+        receive_window_bytes,
+        max_queued_bytes,
     }) {
         assert.isNonNegativeInteger(simulation_delay_ticks, 'simulation_delay_ticks');
         assert.isPositiveInteger(max_pending_future_lead, 'max_pending_future_lead');
@@ -227,6 +241,12 @@ export class ServerAuthoritativeServer {
             frame_capacity,
             initial_buffer_size,
             max_packets_per_tick,
+            clock,
+            tick_period_ms,
+            send_rate_bytes_per_second,
+            max_message_bytes,
+            receive_window_bytes,
+            max_queued_bytes,
         });
 
         /** @type {EntityComponentDataset} */
@@ -466,12 +486,11 @@ export class ServerAuthoritativeServer {
     }
 
     /**
-     * Channel accessor for the user's manual packet plumbing (e.g. sending
-     * empty ACK packets in the prototype). Most callers won't need this.
+     * A peer's connection, for diagnostics. See {@link NetworkPeer#connection_for}.
      * @param {number} peer_id
      */
-    channel_for(peer_id) {
-        return this.peer.channel_for(peer_id);
+    connection_for(peer_id) {
+        return this.peer.connection_for(peer_id);
     }
 
     /**
@@ -484,7 +503,7 @@ export class ServerAuthoritativeServer {
      * @param {number} peer_id
      */
     send_time_dilation_feedback(peer_id) {
-        this.peer.send_time_dilation_feedback(peer_id, this.buffer_depth_for_peer(peer_id));
+        this.peer.send_time_dilation_feedback(peer_id, this.buffer_depth_for_peer(peer_id), Math.max(0, this.current_sim_frame));
     }
 
     /**
@@ -652,13 +671,18 @@ export class ServerAuthoritativeServer {
 
     /**
      * Second half of a tick: run {@link onLocalSim} for the open frame, close it, publish the new
-     * {@link current_sim_frame}, flush the action stream and fire {@link onTickComplete}. A no-op
-     * after a warmup {@link begin_tick}.
+     * {@link current_sim_frame}, queue the action stream, fire {@link onTickComplete}, and send
+     * everything queued — what the handlers queued included, so the tick leaves together. After a
+     * warmup {@link begin_tick} it only sends what is queued.
      */
     end_tick() {
         const sim_frame = this.#open_sim_frame;
 
-        if (sim_frame === -1) return; // warmup, or no begin_tick
+        if (sim_frame === -1) {
+            // warmup, or no begin_tick: nothing simulated, but answers and acknowledgements go
+            this.peer.send_queued();
+            return;
+        }
 
         this.#open_sim_frame = -1;
 
@@ -672,6 +696,7 @@ export class ServerAuthoritativeServer {
         this.current_sim_frame = sim_frame;
         this.peer.flush_outbound(sim_frame);
         this.onTickComplete.send1(sim_frame);
+        this.peer.send_queued();
     }
 
     /**

package/src/engine/network/replication/Replicator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Replicator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/replication/Replicator.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IAiLI;;;;;;;;OAQG;IACH,iFARW;QACV,UAAc,YAAY;QAC1B,eAAmB,oBAAoB;QACvC,QAAY,oBAAoB;QAChC,UAAc,uBAAuB;QACrC,YAAgB,EAAE;YAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;SAAE,CAAC;KACpF,EA6BH;IA5ID;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,wBAHW,MAAM,GACJ;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC,CAc1F;IA2BD;;;;;;;;;;;;;OAaG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;;;;;;;;;;;;;;;OAiBG;IACH,mBAFU,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,CAEvI;IAmBrB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,4BAAwB;IAExB;;OAEG;IACH,iCAA4B;IAE5B;;;;OAIG;IACH,cAFU;QAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAE9C;IAGpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAVW,MAAM,eACN,MAAM,aACN,MAAM,cACN,YAAY,cACZ,MAAM,GACJ,MAAM,CAiFlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,0BALW,MAAM,aACN,YAAY,iBACZ,MAAM,UACN;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI,QAoEtE;IAmRD;;;;;;;OAOG;IACH,qBAFW,MAAM,QAKhB;;CA8CJ;mBAvxBkB,uCAAuC;6BAD7B,sCAAsC"}
+{"version":3,"file":"Replicator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/replication/Replicator.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IAiLI;;;;;;;;OAQG;IACH,iFARW;QACV,UAAc,YAAY;QAC1B,eAAmB,oBAAoB;QACvC,QAAY,oBAAoB;QAChC,UAAc,uBAAuB;QACrC,YAAgB,EAAE;YAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;SAAE,CAAC;KACpF,EA6BH;IA5ID;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,wBAHW,MAAM,GACJ;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC,CAc1F;IA2BD;;;;;;;;;;;;;OAaG;IACH,gBAFU,MAAM,CAEc;IAE9B;;;;;;;;;;;;;;;;;OAiBG;IACH,mBAFU,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,CAEvI;IAmBrB;;OAEG;IACH,sBAA4B;IAE5B;;OAEG;IACH,mCAAsC;IAEtC;;OAEG;IACH,4BAAwB;IAExB;;OAEG;IACH,iCAA4B;IAE5B;;;;OAIG;IACH,cAFU;QAAE,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAE9C;IAGpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAVW,MAAM,eACN,MAAM,aACN,MAAM,cACN,YAAY,cACZ,MAAM,GACJ,MAAM,CAoFlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,0BALW,MAAM,aACN,YAAY,iBACZ,MAAM,UACN;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI,QAoEtE;IAqRD;;;;;;;OAOG;IACH,qBAFW,MAAM,QAKhB;;CA8CJ;mBA7xBkB,uCAAuC;6BAD7B,sCAAsC"}