@woosh/meep-engine 3.14.4 → 3.14.6

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

@@ -27,6 +27,19 @@ import { ReliableCommandPipeline } from "../transport/ReliableCommandPipeline.js
 const DISCONNECT_TEXT_ENCODER = new TextEncoder();
 const DISCONNECT_TEXT_DECODER = new TextDecoder();
 
+// ACTION_STREAM slice header, after the packet-type byte: uint32 frame_start,
+// uint32 frame_end, uint8 head. See NetworkPacketType.ACTION_STREAM.
+const ACTION_STREAM_SLICE_HEADER_BYTES = 9;
+
+// Widest slice a header may claim. A slice covers frames from the pack start
+// to the last frame packed, so it never spans more than the sender's action
+// log holds — a ring of tens or hundreds of frames. The receiver raises its
+// apply watermark to a head's frame_end, so a header claiming 2^32 frames
+// would have it skip every frame the sender ever sends after; that is a
+// sender bug or a sender lying about its own stream, and either is dropped as
+// malformed rather than obeyed.
+const MAX_ACTION_STREAM_SLICE_FRAMES = 65536;
+
 /**
  * Wire packet types. The first byte of every NetworkPeer-routed payload picks
  * the dispatch path. New types can be added without breaking the action stream
@@ -36,6 +49,20 @@ const DISCONNECT_TEXT_DECODER = new TextDecoder();
  * @enum {number}
  */
 export const NetworkPacketType = {
+    /**
+     * A slice of the action stream. Wire layout (after this type byte):
+     *
+     *   uint32  frame_start   first frame the slice covers
+     *   uint32  frame_end     last frame the slice covers
+     *   uint8   head          1 if this is the first slice of the sender's tick
+     *   bytes   groups        {@link Replicator} wire format
+     *
+     * A tick may send several slices, and the receiver applies them in frame
+     * order: a slice that is not a head and starts past what the receiver has
+     * applied is held until the slices before it land. A head's start is the
+     * earliest frame the sender will send again, so it is applied at once.
+     * A packet of just the type byte carries nothing and is ignored.
+     */
     ACTION_STREAM: 0,
     RECOVERY_REQUEST: 1,
     STATE_BURST: 2,
@@ -177,10 +204,20 @@ export const ResumeRejectReason = Object.freeze({
  * range is confirmed only when `unacked` reaches zero without `abandoned`
  * having been set by a loss along the way.
  *
- * @typedef {{frame_end: number, unacked: number, abandoned: boolean}} PendingAck
- * @property {number} frame_end  last frame in the packed range `[start, frame_end]`
- * @property {number} unacked    seqs of this send not yet acked or declared lost
- * @property {boolean} abandoned at least one seq was declared lost, so the
+ * A tick may make several sends to one peer, each carrying the next slice of
+ * the owed range (see {@link NetworkPeer#flush_outbound}). They confirm
+ * independently, and the baseline advances only through slices confirmed in
+ * order — a later slice landing says nothing about an earlier one still in
+ * flight. `head` marks the first slice of a tick, whose start is the pack
+ * start itself; see {@link NetworkPeer#__credit_confirmed}.
+ *
+ * @typedef {{frame_start: number, frame_end: number, head: boolean, unacked: number, abandoned: boolean}} PendingAck
+ * @property {number} frame_start first frame in the packed range
+ * @property {number} frame_end   last frame in the packed range
+ * @property {boolean} head       this send began at the pack start, so nothing
+ *   sendable lies before it and its confirmation credits outright
+ * @property {number} unacked     seqs of this send not yet acked or declared lost
+ * @property {boolean} abandoned  at least one seq was declared lost, so the
  *   message is forfeit and must never advance the baseline
  */
 
@@ -248,6 +285,15 @@ export class NetworkPeer {
      */
     #sent_seqs = [];
 
+    /**
+     * Scratch for the slice header of the ACTION_STREAM packet being
+     * dispatched, handed to `Replicator.unpack_from_peer`, which copies what
+     * it keeps. Only valid for the duration of that call.
+     * @type {{frame_start: number, frame_end: number, head: boolean}}
+     * @private
+     */
+    #slice = { frame_start: 0, frame_end: 0, head: false };
+
     /**
      * @param {{
      *   world: EntityComponentDataset,
@@ -259,6 +305,7 @@ export class NetworkPeer {
      *   initial_buffer_size?: number,
      *   mutation_ledger?: MutationLedger|null,
      *   changed_set_capacity?: number,
+     *   max_packets_per_tick?: number,
      * }} options
      */
     constructor({
@@ -271,11 +318,13 @@ export class NetworkPeer {
         initial_buffer_size = 1024,
         mutation_ledger = null,
         changed_set_capacity = 256,
+        max_packets_per_tick = 8,
     }) {
         assert.ok(world && typeof world.createEntity === 'function', 'world must be an EntityComponentDataset');
         assert.ok(binary_registry, 'binary_registry required');
         assert.isFunction(replicated_components.forEach, 'replicated_components must be iterable');
         assert.isFunction(action_classes.forEach, 'action_classes must be iterable');
+        assert.isPositiveInteger(max_packets_per_tick, 'max_packets_per_tick');
 
         /** @type {EntityComponentDataset} */
         this.world = world;
@@ -298,6 +347,33 @@ export class NetworkPeer {
         /** @type {ActionLog} */
         this.action_log = new ActionLog({ frame_capacity, initial_buffer_size });
 
+        /**
+         * Most action-stream packets {@link flush_outbound} may send one peer
+         * in a tick. Each carries the next slice of what the peer is owed and
+         * is confirmed on its own, so this caps how fast a peer that has
+         * fallen behind catches up: a slice is re-sent every tick until its ack
+         * returns, so a peer is confirmed at most this many packets of frames
+         * per round trip, against the one frame per tick the simulation
+         * produces. One packet a tick keeps up only while a round trip's frames
+         * fit one packet; past that the owed range grows until it meets the
+         * ring floor and frames are lost.
+         *
+         * It is also the bandwidth ceiling under catch-up — this many MTUs per
+         * tick per peer — and it has to stay inside the channel's ack window.
+         * A peer's ack header covers its latest 33 seqs, so with a peer that
+         * replies once a tick, `33 / max_packets_per_tick` consecutive lost
+         * replies leave a delivered packet outside the window and it is
+         * declared lost: a wasted re-send rather than a defect, since the
+         * receiver skips frames it has already applied. Eight tolerates three
+         * such losses in a row (one tick in sixteen at 50% loss, one in ten
+         * thousand at 10%), and lets a 60 Hz stream at 100 ms RTT carry a full
+         * packet of actions per frame. Lower it for peers that reply less often
+         * than every tick.
+         *
+         * @type {number}
+         */
+        this.max_packets_per_tick = max_packets_per_tick;
+
         /**
          * Optional per-tick mutation tracker. When a `MutationLedger` is supplied,
          * this peer records each tick's affected network IDs into a fresh
@@ -343,8 +419,8 @@ export class NetworkPeer {
         this.baseline = new Baseline();
 
         /**
-         * peer_id → { channel, transport, seq_to_pending, on_payload, on_acked }
-         * @type {Map<number, { channel: Channel, transport: Object, seq_to_pending: Map<number, PendingAck>, on_payload: Function, on_acked: Function }>}
+         * peer_id → { channel, transport, seq_to_pending, confirmed, on_payload, on_acked }
+         * @type {Map<number, { channel: Channel, transport: Object, seq_to_pending: Map<number, PendingAck>, confirmed: Int32Array, on_payload: Function, on_acked: Function }>}
          * @private
          */
         this.#peers = new Map();
@@ -504,7 +580,23 @@ export class NetworkPeer {
 
         const channel = new Channel({ transport });
         const seq_to_pending = new Map();
-        const fragment_assembler = new FragmentAssembler();
+        // Frames this peer has confirmed that the baseline has not reached yet,
+        // because a slice before them is still in flight. A ring indexed by
+        // frame modulo capacity holding the frame number — see
+        // __credit_confirmed.
+        const confirmed = new Int32Array(this.action_log.frame_capacity).fill(-1);
+        // The reassembly window is sized from the burst. A frame too big for
+        // one packet goes out as a fragmented slice, and a tick may send
+        // `max_packets_per_tick` of them; jitter that holds a message's later
+        // fragments behind the next ticks' first fragments leaves that many
+        // partial messages per tick in flight at once. The assembler evicts
+        // the oldest partial when its window is full, both fragments of the
+        // evicted message are still acked, and the sender credits the slice —
+        // a silent loss. Four ticks of burst keeps the window ahead of any
+        // jitter the NACK timer would not already have caught.
+        const fragment_assembler = new FragmentAssembler({
+            max_pending_messages: Math.max(8, 4 * this.max_packets_per_tick),
+        });
         const fragment_retention = new FragmentRetention();
         const reliable_pipeline = new ReliableCommandPipeline({
             channel,
@@ -548,11 +640,25 @@ export class NetworkPeer {
             const packet_type = this.#recv_buffer.readUint8();
 
             switch (packet_type) {
-                case NetworkPacketType.ACTION_STREAM:
-                    // The Replicator opens a frame on the action log per packet
-                    // (one per sender frame).
-                    this.replicator.unpack_from_peer(peer_id, this.#recv_buffer, length);
+                case NetworkPacketType.ACTION_STREAM: {
+                    // Just the type byte: an empty stream, nothing to apply.
+                    if (length === 1) break;
+                    if (length < 1 + ACTION_STREAM_SLICE_HEADER_BYTES) {
+                        throw new MalformedPacketError(`NetworkPeer.dispatch: ACTION_STREAM truncated before its slice header`);
+                    }
+                    const slice = this.#slice;
+                    slice.frame_start = this.#recv_buffer.readUint32();
+                    slice.frame_end = this.#recv_buffer.readUint32();
+                    slice.head = this.#recv_buffer.readUint8() !== 0;
+                    if (slice.frame_end < slice.frame_start
+                        || slice.frame_end - slice.frame_start >= MAX_ACTION_STREAM_SLICE_FRAMES) {
+                        throw new MalformedPacketError(`NetworkPeer.dispatch: ACTION_STREAM slice [${slice.frame_start}, ${slice.frame_end}] is inverted or wider than any action log`);
+                    }
+                    // The Replicator opens a frame on the action log per group
+                    // (one per sender frame), applying slices in frame order.
+                    this.replicator.unpack_from_peer(peer_id, this.#recv_buffer, length, slice);
                     break;
+                }
                 case NetworkPacketType.RECOVERY_REQUEST: {
                     const start_tick = this.#recv_buffer.readUintVar();
                     const end_tick = this.#recv_buffer.readUintVar();
@@ -674,20 +780,21 @@ export class NetworkPeer {
             }
         };
 
-        // Ack: advance Baseline to the record's frame_end — but only once every
-        // seq that send went out under has been acked. For a single-packet send
-        // that is the one seq. For a fragmented send it is all N fragments,
-        // because the receiver applies nothing until it has reassembled the
-        // whole message; advancing on the first fragment's ack would retire a
-        // frame range the receiver never saw, from the only mechanism that
-        // could still re-send it.
+        // Ack: a send is confirmed once every seq it went out under has been
+        // acked. For a single-packet send that is the one seq. For a
+        // fragmented send it is all N fragments, because the receiver applies
+        // nothing until it has reassembled the whole message; advancing on the
+        // first fragment's ack would retire a frame range the receiver never
+        // saw, from the only mechanism that could still re-send it. What a
+        // confirmed send credits to the baseline is decided in order, by
+        // __credit_confirmed.
         const on_acked = (seq) => {
             const pending = seq_to_pending.get(seq);
             if (pending === undefined) return;
             seq_to_pending.delete(seq);
             pending.unacked--;
             if (pending.unacked === 0 && !pending.abandoned) {
-                this.baseline.set_acked(peer_id, pending.frame_end);
+                this.#credit_confirmed(peer_id, confirmed, pending);
             }
         };
 
@@ -743,7 +850,7 @@ export class NetworkPeer {
         channel.onPacketLost.add(on_lost);
 
         this.#peers.set(peer_id, {
-            channel, transport, seq_to_pending,
+            channel, transport, seq_to_pending, confirmed,
             on_payload: payload_handler, on_acked, on_lost, on_nack,
             fragment_assembler, fragment_retention,
             reliable_pipeline,
@@ -905,9 +1012,10 @@ export class NetworkPeer {
      * by the caller. Records the tick's accumulated mutations into the
      * MutationLedger (if configured), then packs frames
      * `[last_acked+1, current_frame]` for each peer via
-     * `Replicator.pack_for_peer`, bounded to one channel packet. Empty packs
-     * (no in-scope actions) are not sent. Clears the per-tick changed-entity
-     * set after recording.
+     * `Replicator.pack_for_peer` into up to {@link max_packets_per_tick}
+     * channel packets, each the next slice of that range. Empty packs (no
+     * in-scope actions) are not sent. Clears the per-tick changed-entity set
+     * after recording.
      *
      * @param {number} current_frame
      */
@@ -973,54 +1081,93 @@ export class NetworkPeer {
             );
             if (start > current_frame) continue;
 
-            this.#send_buffer.position = 0;
-            // Packet-type prefix.
-            this.#send_buffer.writeUint8(NetworkPacketType.ACTION_STREAM);
-            // Bound the pack to a single channel packet.
+            // Up to `max_packets_per_tick` sends, each bounded to one channel
+            // packet and each taking the next slice of the owed range.
             //
-            // A fragmented action stream is confirmed only if EVERY fragment
-            // survives, so letting the pack grow with the owed range is
-            // self-defeating under loss: one lost fragment pins the baseline,
-            // which widens the next pack, which raises the fragment count N,
-            // which drops P(all arrive) = (1-p)^N geometrically — the range
-            // then widens faster than it drains and delivery collapses.
+            // Bounding a send to one packet is load-bearing. A fragmented
+            // action stream is confirmed only if EVERY fragment survives, so a
+            // send that grows with the owed range is self-defeating under
+            // loss: one lost fragment pins the baseline, which widens the next
+            // pack, which raises the fragment count N, which drops
+            // P(all arrive) = (1-p)^N geometrically — the range then widens
+            // faster than it drains and delivery collapses. Split into whole
+            // packets instead, each slice is confirmed on its own and a loss
+            // forfeits one slice, not the tick.
             //
-            // Bounded, the back-fill degrades into "catch up by a packet each
-            // tick": every send occupies one seq, so any packet that lands
-            // advances the baseline, and a peer behind by more than one packet
-            // converges instead of spiralling. The pack is oldest-owed-first,
-            // which is what the range order already gives.
+            // Sending more than one is what keeps the stream up with the
+            // simulation. A slice is re-sent every tick until its ack returns,
+            // so the baseline moves by at most a tick's worth of slices per
+            // round trip, while the sim produces a frame per tick. One packet
+            // a tick therefore keeps up only while a round trip's frames fit
+            // one packet; past that the owed range grows until it meets the
+            // ring floor, a ring of frames is lost crossing it, and everything
+            // after arrives a ring late — on a link that loses nothing. The
+            // pack is oldest-owed-first, which is what the range order already
+            // gives.
             //
-            // The budget is what is left of one payload after the prefix
-            // above, read from the buffer rather than written as a constant:
-            // `pack_for_peer` measures its budget from the current position,
-            // so a hard-coded allowance would have to be edited in step with
-            // every byte added here, and getting that wrong puts each full
-            // pack one byte over the limit and quietly fragments it again.
-            const packed_through = this.replicator.pack_for_peer(
-                peer_id, start, current_frame, this.#send_buffer,
-                MAX_CHANNEL_PAYLOAD_BYTES - this.#send_buffer.position,
-            );
-            const length = this.#send_buffer.position;
-            // Just the prefix → no in-scope actions to send.
-            if (length === 1) continue;
-
-            this.#send_to_peer(conn, this.#send_buffer.raw_bytes, length, this.#sent_seqs);
+            // The budget is what is left of one payload after the prefix and
+            // the slice header, read from the buffer rather than written as a
+            // constant: `pack_for_peer` measures its budget from the current
+            // position, so a hard-coded allowance would have to be edited in
+            // step with every byte added here, and getting that wrong puts
+            // each full pack one byte over the limit and quietly fragments it
+            // again.
+            let from = start;
+            for (let n = 0; n < this.max_packets_per_tick && from <= current_frame; n++) {
+                this.#send_buffer.position = 0;
+                // Packet-type prefix, then the slice header: the range this
+                // packet covers and whether it is the tick's first, which is
+                // what lets the receiver apply slices in frame order (see
+                // Replicator.unpack_from_peer). frame_end is back-patched once
+                // the pack has decided how far it got.
+                this.#send_buffer.writeUint8(NetworkPacketType.ACTION_STREAM);
+                this.#send_buffer.writeUint32(from);
+                const frame_end_position = this.#send_buffer.position;
+                this.#send_buffer.writeUint32(0);
+                this.#send_buffer.writeUint8(n === 0 ? 1 : 0);
+                const packed_through = this.replicator.pack_for_peer(
+                    peer_id, from, current_frame, this.#send_buffer,
+                    MAX_CHANNEL_PAYLOAD_BYTES - this.#send_buffer.position,
+                );
+                const length = this.#send_buffer.position;
+                // Just the prefix and header → nothing in scope left to send
+                // this peer.
+                if (length === 1 + ACTION_STREAM_SLICE_HEADER_BYTES) break;
+                this.#send_buffer.position = frame_end_position;
+                this.#send_buffer.writeUint32(packed_through);
+                this.#send_buffer.position = length;
+
+                this.#send_to_peer(conn, this.#send_buffer.raw_bytes, length, this.#sent_seqs);
+
+                // One record shared by every seq the send produced. Frames
+                // [from, packed_through] are confirmed only when all of those
+                // seqs ack; a loss on any of them abandons the record and
+                // leaves the range owed, so a later tick's pack picks it up
+                // again.
+                //
+                // frame_end is what the pack actually held, NOT current_frame:
+                // the budget may have stopped it short, and crediting frames
+                // that were left out of the packet would retire them from the
+                // back-fill unsent — the same defect as crediting a whole
+                // message to its first fragment, one layer up.
+                //
+                // Only the first slice starts at the pack start. The rest start
+                // where the previous slice stopped, and their confirmation is
+                // held until everything before them is confirmed too — see
+                // __credit_confirmed.
+                const seq_count = this.#sent_seqs.length;
+                const pending = {
+                    frame_start: from,
+                    frame_end: packed_through,
+                    head: n === 0,
+                    unacked: seq_count,
+                    abandoned: false,
+                };
+                for (let i = 0; i < seq_count; i++) {
+                    conn.seq_to_pending.set(this.#sent_seqs[i], pending);
+                }
 
-            // One record shared by every seq the send produced. Frames
-            // [start, packed_through] are confirmed only when all of those seqs
-            // ack; a loss on any of them abandons the record and leaves the
-            // range owed, so the next tick's pack picks it up again.
-            //
-            // frame_end is what the pack actually held, NOT current_frame: the
-            // budget may have stopped it short, and crediting frames that were
-            // left out of the packet would retire them from the back-fill
-            // unsent — the same defect as crediting a whole message to its
-            // first fragment, one layer up.
-            const seq_count = this.#sent_seqs.length;
-            const pending = { frame_end: packed_through, unacked: seq_count, abandoned: false };
-            for (let i = 0; i < seq_count; i++) {
-                conn.seq_to_pending.set(this.#sent_seqs[i], pending);
+                from = packed_through + 1;
             }
         }
 
@@ -1029,6 +1176,55 @@ export class NetworkPeer {
         if (this.#changed_entities !== null) this.#changed_entities.clear();
     }
 
+    /**
+     * A send has been confirmed in full — every seq it went out under acked,
+     * none lost — so the receiver has applied every frame it carried. Record
+     * those frames, then advance the peer's baseline as far as the frames
+     * confirmed so far run contiguously.
+     *
+     * The order matters because a tick may send several slices and they
+     * confirm independently. A later slice landing while an earlier one is
+     * still in flight must not credit the earlier one's frames: they are
+     * still owed, and crediting them would retire them from the back-fill
+     * unsent. So a slice is credited only once the baseline has reached the
+     * frame before it. The exception is the head of a tick's burst. Its start
+     * IS the pack start — `last_acked + 1` or the ring floor, whichever is
+     * newer — so nothing sendable lies before it and its confirmation credits
+     * outright. That is also how the baseline gets past frames the ring has
+     * already retired, which no ack could ever confirm.
+     *
+     * `confirmed` is a ring indexed by frame modulo capacity that stores the
+     * frame number, so a slot whose frame has since been overwritten reads as
+     * unconfirmed rather than as its successor (the {@link FrameBufferRing}
+     * trick). A mark can only be overwritten by a frame a full ring later,
+     * and a frame that far behind is below the ring floor — no longer owed,
+     * and no longer needed to advance the baseline, which a head crosses it
+     * with.
+     *
+     * @param {number} peer_id
+     * @param {Int32Array} confirmed the peer's confirmed-frame ring
+     * @param {PendingAck} pending the record that just drained
+     * @private
+     */
+    #credit_confirmed(peer_id, confirmed, pending) {
+        const capacity = confirmed.length;
+        for (let f = pending.frame_start; f <= pending.frame_end; f++) {
+            confirmed[f % capacity] = f;
+        }
+
+        const before = this.baseline.last_acked(peer_id);
+        let last_acked = before;
+        if (pending.head && pending.frame_end > last_acked) {
+            last_acked = pending.frame_end;
+        }
+        while (confirmed[(last_acked + 1) % capacity] === last_acked + 1) {
+            last_acked++;
+        }
+        if (last_acked > before) {
+            this.baseline.set_acked(peer_id, last_acked);
+        }
+    }
+
     /**
      * Send a logical payload to a connected peer, fragmenting transparently
      * if it exceeds the channel's single-packet capacity.

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

@@ -45,6 +45,7 @@ export class ServerAuthoritativeClient {
      *   input_byte_size?: number,
      *   reconcile_epsilon?: number,
      *   time_dilation?: TimeDilation,
+     *   max_packets_per_tick?: number,
      * }} options
      *
      * `time_dilation`: optional pre-configured {@link TimeDilation}.
@@ -52,8 +53,11 @@ export class ServerAuthoritativeClient {
      * {@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.
+     *
+     * `max_packets_per_tick`: forwarded to {@link NetworkPeer}; how many
+     * action-stream packets a tick may send the server.
      */
-    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, }: {
+    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, }: {
         world: EntityComponentDataset;
         binary_registry: BinarySerializationRegistry;
         replicated_components: Function[];
@@ -65,6 +69,7 @@ export class ServerAuthoritativeClient {
         input_byte_size?: number;
         reconcile_epsilon?: number;
         time_dilation?: TimeDilation;
+        max_packets_per_tick?: number;
     });
     /** @type {number} */
     reconcile_count: number;

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":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAsBI;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,2MApBW;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;KAC9B,EAwLH;IA3MD,qBAAqB;IACrB,iBADW,MAAM,CACG;IAEpB,qBAAqB;IACrB,oBADW,MAAM,CACM;IAoCnB,0BAA0B;IAC1B,MADW,WAAW,CASpB;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;;;;;;;;OAQG;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;;;;;;;;OAQG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;OAIG;IACH,qBAFU,MAAM,CAEuB;IAQ3C;;;;OAIG;IACH,2BAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAIhB;IAED;iCAC6B;IAC7B,qBADW,MAAM,6CAGhB;IAED;;;;;;;;;;OAUG;IACH,oBAFW,MAAM,QAahB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,iBAHW,MAAM,gBAKhB;IAiFD;;;;;OAKG;IACH,oBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAIhB;;CACJ;4BAva2B,kBAAkB;0BAFpB,uBAAuB;6BADpB,wBAAwB;6BAExB,yBAAyB;mBAJnC,uCAAuC"}
+{"version":3,"file":"ServerAuthoritativeClient.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeClient.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAsBI;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,iOAxBW;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;KAC/B,EA6LH;IAjND,qBAAqB;IACrB,iBADW,MAAM,CACG;IAEpB,qBAAqB;IACrB,oBADW,MAAM,CACM;IAyCnB,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;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;;;;;;;;OAQG;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;;;;;;;;OAQG;IACH,kBAFU,MAAM,CAEoB;IAEpC;;;;OAIG;IACH,qBAFU,MAAM,CAEuB;IAQ3C;;;;OAIG;IACH,2BAHW,MAAM,aACN,MAAM,QAIhB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAIhB;IAED;iCAC6B;IAC7B,qBADW,MAAM,6CAGhB;IAED;;;;;;;;;;OAUG;IACH,oBAFW,MAAM,QAahB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,iBAHW,MAAM,gBAKhB;IAiFD;;;;;OAKG;IACH,oBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAIhB;;CACJ;4BA7a2B,kBAAkB;0BAFpB,uBAAuB;6BADpB,wBAAwB;6BAExB,yBAAyB;mBAJnC,uCAAuC"}

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

@@ -75,6 +75,7 @@ export class ServerAuthoritativeClient {
      *   input_byte_size?: number,
      *   reconcile_epsilon?: number,
      *   time_dilation?: TimeDilation,
+     *   max_packets_per_tick?: number,
      * }} options
      *
      * `time_dilation`: optional pre-configured {@link TimeDilation}.
@@ -82,6 +83,9 @@ export class ServerAuthoritativeClient {
      * {@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.
+     *
+     * `max_packets_per_tick`: forwarded to {@link NetworkPeer}; how many
+     * action-stream packets a tick may send the server.
      */
     constructor({
         world,
@@ -95,6 +99,7 @@ export class ServerAuthoritativeClient {
         input_byte_size = 4,
         reconcile_epsilon = 1e-4,
         time_dilation = new TimeDilation(),
+        max_packets_per_tick,
     }) {
         /** @type {NetworkPeer} */
         this.peer = new NetworkPeer({
@@ -105,6 +110,7 @@ export class ServerAuthoritativeClient {
             scope_filter,
             frame_capacity,
             initial_buffer_size,
+            max_packets_per_tick,
         });
 
         /** @type {EntityComponentDataset} */

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

@@ -6,14 +6,15 @@
  *
  *   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)`.
+ *      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.
  *   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 carrying an
- *        action the log does not already hold. The action stream re-sends
- *        every unacked frame each tick, so most of pending is copies of
- *        already-applied records; rewinding for those would replay the
- *        world into the state it was already in.
+ *      - Determines `replay_start`: the oldest pending frame, which by the
+ *        above is the oldest frame whose outcome can change.
  *      - Rewinds the server world back to end-of-(replay_start - 1) via the
  *        action_log's prior-state captures (see {@link RewindEngine}).
  *      - Replays forward `[replay_start, current_frame]`. For each frame `f`:
@@ -75,8 +76,12 @@ export class ServerAuthoritativeServer {
      *   frame_capacity?: number,
      *   initial_buffer_size?: number,
      *   simulation_delay_ticks?: number,
+     *   max_packets_per_tick?: number,
      * }} options
      *
+     * `max_packets_per_tick`: forwarded to {@link NetworkPeer}; how many
+     * action-stream packets a tick may send one peer.
+     *
      * `simulation_delay_ticks`: server-side input buffer (Overwatch-style).
      * When > 0, {@link tick}(wall_frame) simulates
      * `sim_frame = wall_frame - simulation_delay_ticks`. Pending actions
@@ -86,7 +91,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, }: {
+    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, }: {
         world: EntityComponentDataset;
         binary_registry: BinarySerializationRegistry;
         replicated_components: Function[];
@@ -95,6 +100,7 @@ export class ServerAuthoritativeServer {
         frame_capacity?: number;
         initial_buffer_size?: number;
         simulation_delay_ticks?: number;
+        max_packets_per_tick?: number;
     });
     /**
      * Most recently simulated frame. `-1` during warmup

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":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH;IAwCI;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uOApBW;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;KACjC,EA4NH;IA9OD;;;;;OAKG;IACH,mBAFU,MAAM,CAEO;IAwCnB,0BAA0B;IAC1B,MADW,WAAW,CASpB;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;IA+B1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,YAFU,MAAM,CAEc;IAE9B;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEkB;IAElC;;;;;;;;;;;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,kBACA,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;;;;;;;;;;;;OAYG;IACH,oBAFW,MAAM,QAiEhB;IAED;;;;;;;;OAQG;IACH,+BAHW,MAAM,GACJ,MAAM,CAOlB;IAuOD;;;;OAIG;IACH,yBAFa,MAAM,CAIlB;;CA0HJ;4BAh5B2B,kBAAkB;6BAFjB,wBAAwB;mBANlC,uCAAuC;6BAH7B,sCAAsC"}
+{"version":3,"file":"ServerAuthoritativeServer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/orchestrator/ServerAuthoritativeServer.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH;IAsCI;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,6PAxBW;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;KAC/B,EAiOH;IApPD;;;;;OAKG;IACH,mBAFU,MAAM,CAEO;IA6CnB,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;IA+B1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,YAFU,MAAM,CAEc;IAE9B;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEkB;IAElC;;;;;;;;;;;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,kBACA,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;;;;;;;;;;;;OAYG;IACH,oBAFW,MAAM,QAkDhB;IAED;;;;;;;;OAQG;IACH,+BAHW,MAAM,GACJ,MAAM,CAOlB;IAyLD;;;;OAIG;IACH,yBAFa,MAAM,CAIlB;;CA8IJ;4BA52B2B,kBAAkB;6BAFjB,wBAAwB;mBAPlC,uCAAuC;6BAH7B,sCAAsC"}