@woosh/meep-engine 3.46.0 → 3.49.0

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

@@ -93,6 +93,49 @@ export function snapshotter_emit({ buffer, world, slot_table, component_registry
     }
 }
 
+/**
+ * Write one entity's record — network id, then each replicated component it has — in the format
+ * {@link snapshotter_emit} writes per entity. Allocates nothing: a page builder calls it once per
+ * entity it fits.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {EntityComponentDataset} world
+ * @param {ReplicationSlotTable} slot_table
+ * @param {ReplicatedComponentRegistry} component_registry
+ * @param {number} entity_id must be registered in the slot table
+ */
+export function snapshotter_write_entity(buffer, world, slot_table, component_registry, entity_id) {
+    const network_id = slot_table.network_for(entity_id);
+    if (network_id < 0) {
+        throw new Error(`snapshotter_write_entity: entity ${entity_id} is not registered in the slot table`);
+    }
+
+    const type_count = component_registry.type_count();
+    let present = 0;
+    for (let type_id = 0; type_id < type_count; type_id++) {
+        if (world.hasComponent(entity_id, component_registry.class_of(type_id))) present++;
+    }
+
+    buffer.writeUintVar(network_id);
+    buffer.writeUint8(present);
+
+    for (let type_id = 0; type_id < type_count; type_id++) {
+        const klass = component_registry.class_of(type_id);
+        const component = world.getComponent(entity_id, klass);
+        if (component === undefined) continue;
+
+        buffer.writeUint8(type_id);
+        const len_position = buffer.position;
+        buffer.writeUint32(0);
+        const payload_start = buffer.position;
+        component_registry.adapter_for_id(type_id).serialize(buffer, component);
+        const payload_end = buffer.position;
+        buffer.position = len_position;
+        buffer.writeUint32(payload_end - payload_start);
+        buffer.position = payload_end;
+    }
+}
+
 /**
  * Apply a snapshot stream to a (typically empty) world, creating each entity
  * and attaching components.

package/src/engine/network/state/Baseline.d.ts

@@ -2,7 +2,7 @@
  * Per-peer "last acknowledged frame" tracker.
  *
  * The replicator sends actions for frames `[Baseline.last_acked(peer) + 1, current]`
- * to each peer. When the peer's ack arrives (via the {@link Channel}), it
+ * to each peer. When the peer's ack arrives (via its {@link Connection}), it
  * advances the baseline.
  *
  * Frame numbers are absolute uint32. At 60 Hz, 2^32 frames = 2.27 years —

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

@@ -4,7 +4,7 @@ import { assert } from "../../../core/assert.js";
  * Per-peer "last acknowledged frame" tracker.
  *
  * The replicator sends actions for frames `[Baseline.last_acked(peer) + 1, current]`
- * to each peer. When the peer's ack arrives (via the {@link Channel}), it
+ * to each peer. When the peer's ack arrives (via its {@link Connection}), it
  * advances the baseline.
  *
  * Frame numbers are absolute uint32. At 60 Hz, 2^32 frames = 2.27 years —

package/src/engine/network/state/FrameBufferRing.d.ts

@@ -15,12 +15,13 @@
  * owns storage and addressing and nothing else — it has no opinion about when a
  * frame may be opened or whether two may be open at once.
  *
- * Writers go through {@link open} then {@link commit}. Readers go through
- * {@link has}, {@link buffer_for} and {@link write_end_for}. A slot is claimed
- * by `open`, so it reads as present from that moment; its recorded length only
- * becomes meaningful at `commit`, which is why reading a frame that is still
- * being written yields the previous occupant's length. Owners that allow a
- * frame to stay open across calls are responsible for saying so.
+ * Writers go through {@link open} (or {@link resume}, to add to a frame) then
+ * {@link commit}. Readers go through {@link has}, {@link buffer_for} and
+ * {@link write_end_for}. A slot is claimed by `open`, so it reads as present
+ * from that moment; its recorded length is what was last committed — 0 for a
+ * slot `open` claimed, the old end for a frame `resume` reopened — so a reader
+ * sees none of what is still being written. Owners that allow a frame to stay
+ * open across calls are responsible for saying so.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -49,6 +50,24 @@ export class FrameBufferRing {
      * @returns {BinaryBuffer} positioned at 0, ready to be written
      */
     open(frame: number): BinaryBuffer;
+    /**
+     * Claim the slot for `frame` to write AFTER what it already holds: a slot holding `frame`
+     * hands back its buffer positioned at its committed end, and any other slot is claimed as
+     * {@link open} claims it. {@link commit} then fixes the longer length.
+     *
+     * @param {number} frame absolute frame number
+     * @returns {BinaryBuffer} positioned at the frame's committed end, ready to be written
+     */
+    resume(frame: number): BinaryBuffer;
+    /**
+     * Drop every slot's bytes and keep its frame: each frame the ring holds still reads as present,
+     * and as holding nothing.
+     */
+    empty(): void;
+    /**
+     * Release every slot: no frame reads as present until it is written again.
+     */
+    clear(): void;
     /**
      * Record how far the writer got, fixing the frame's length for readers.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"FrameBufferRing.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/state/FrameBufferRing.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAoCI;;OAEG;IACH,4DAFW;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAC,EAmB9E;IA5BD;;;;;OAKG;IACH,yBAFU,MAAM,CAED;IAwBf;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,YAAY,CAcxB;IAED;;;;OAIG;IACH,cAFW,MAAM,QAQhB;IAED;;;;;OAKG;IACH,WAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;;;OAMG;IACH,kBAHW,MAAM,GACJ,YAAY,CAYxB;IAED;;;;;;OAMG;IACH,qBAHW,MAAM,GACJ,MAAM,CAQlB;;CACJ;6BAtK4B,sCAAsC"}
+{"version":3,"file":"FrameBufferRing.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/state/FrameBufferRing.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAoCI;;OAEG;IACH,4DAFW;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAC,EAmB9E;IA5BD;;;;;OAKG;IACH,yBAFU,MAAM,CAED;IAwBf;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,YAAY,CAkBxB;IAED;;;;;;;OAOG;IACH,cAHW,MAAM,GACJ,YAAY,CAgBxB;IAED;;;OAGG;IACH,cAEC;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,cAFW,MAAM,QAQhB;IAED;;;;;OAKG;IACH,WAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;;;;OAMG;IACH,kBAHW,MAAM,GACJ,YAAY,CAYxB;IAED;;;;;;OAMG;IACH,qBAHW,MAAM,GACJ,MAAM,CAQlB;;CACJ;6BAnN4B,sCAAsC"}

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

@@ -18,12 +18,13 @@ import { BinaryBuffer } from "../../../core/binary/BinaryBuffer.js";
  * owns storage and addressing and nothing else — it has no opinion about when a
  * frame may be opened or whether two may be open at once.
  *
- * Writers go through {@link open} then {@link commit}. Readers go through
- * {@link has}, {@link buffer_for} and {@link write_end_for}. A slot is claimed
- * by `open`, so it reads as present from that moment; its recorded length only
- * becomes meaningful at `commit`, which is why reading a frame that is still
- * being written yields the previous occupant's length. Owners that allow a
- * frame to stay open across calls are responsible for saying so.
+ * Writers go through {@link open} (or {@link resume}, to add to a frame) then
+ * {@link commit}. Readers go through {@link has}, {@link buffer_for} and
+ * {@link write_end_for}. A slot is claimed by `open`, so it reads as present
+ * from that moment; its recorded length is what was last committed — 0 for a
+ * slot `open` claimed, the old end for a frame `resume` reopened — so a reader
+ * sees none of what is still being written. Owners that allow a frame to stay
+ * open across calls are responsible for saying so.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
@@ -104,9 +105,53 @@ export class FrameBufferRing {
 
         this.#frame_numbers[slot] = frame;
 
+        // Nothing of the new occupant is committed yet. Left alone, a slot claimed and never
+        // committed would report the previous occupant's length, and `resume` would write after it.
+        this.#write_ends[slot] = 0;
+
         return buffer;
     }
 
+    /**
+     * Claim the slot for `frame` to write AFTER what it already holds: a slot holding `frame`
+     * hands back its buffer positioned at its committed end, and any other slot is claimed as
+     * {@link open} claims it. {@link commit} then fixes the longer length.
+     *
+     * @param {number} frame absolute frame number
+     * @returns {BinaryBuffer} positioned at the frame's committed end, ready to be written
+     */
+    resume(frame) {
+        assert.isNonNegativeInteger(frame, 'frame');
+
+        const slot = frame % this.frame_capacity;
+
+        if (this.#frame_numbers[slot] !== frame) {
+            return this.open(frame);
+        }
+
+        const buffer = this.#buffers[slot];
+
+        buffer.position = this.#write_ends[slot];
+
+        return buffer;
+    }
+
+    /**
+     * Drop every slot's bytes and keep its frame: each frame the ring holds still reads as present,
+     * and as holding nothing.
+     */
+    empty() {
+        this.#write_ends.fill(0);
+    }
+
+    /**
+     * Release every slot: no frame reads as present until it is written again.
+     */
+    clear() {
+        this.#frame_numbers.fill(-1);
+        this.#write_ends.fill(0);
+    }
+
     /**
      * Record how far the writer got, fixing the frame's length for readers.
      *

package/src/engine/network/state/InputRing.d.ts

@@ -59,6 +59,10 @@ export class InputRing {
      * @param {function(BinaryBuffer): void} writer
      */
     write(frame: number, writer: (arg0: BinaryBuffer) => void): void;
+    /**
+     * Forget every frame's input: none reads as present until it is written again.
+     */
+    clear(): void;
     /**
      * @param {number} frame
      * @returns {boolean}

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

@@ -1 +1 @@
-{"version":3,"file":"InputRing.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/state/InputRing.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAMI;;OAEG;IACH,qDAFW;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;KAAE,EAIlE;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,aAHW,MAAM,kCACkB,IAAI,QAQtC;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,kBAHW,MAAM,gBAKhB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,aACN,MAAM,aACG,MAAM,4BAAgB,MAAM,KAAG,IAAI,QAmBtD;;CACJ"}
+{"version":3,"file":"InputRing.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/state/InputRing.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAMI;;OAEG;IACH,qDAFW;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;KAAE,EAIlE;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,aAHW,MAAM,kCACkB,IAAI,QAQtC;IAED;;OAEG;IACH,cAEC;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,kBAHW,MAAM,gBAKhB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,aACN,MAAM,aACG,MAAM,4BAAgB,MAAM,KAAG,IAAI,QAmBtD;;CACJ"}

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

@@ -77,6 +77,13 @@ export class InputRing {
         this.#ring.commit(frame);
     }
 
+    /**
+     * Forget every frame's input: none reads as present until it is written again.
+     */
+    clear() {
+        this.#ring.clear();
+    }
+
     /**
      * @param {number} frame
      * @returns {boolean}

package/src/engine/network/state/RecordArrivalRing.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Which records of a sender's frames have arrived, over a window of consecutive frames.
+ *
+ * A record's identity on the action stream is the frame its sender tagged it for and its ordinal in
+ * that frame — the index of the record in the sender's log frame, counting every record there. The
+ * stream re-sends every unconfirmed frame each tick, so a receiver sees a record several times before
+ * its acknowledgement round-trips; this is how it tells the copies from new records. Nothing about the
+ * record's bytes takes part: two inputs with identical payloads tagged for different frames, or for
+ * the same frame at different ordinals, are two inputs. (Until 2026-10-15 the host compared bytes
+ * instead, and a held key — the same payload every frame — collapsed whenever its input arrived late
+ * and was folded into one frame: 56% of it applied, measured.)
+ *
+ * Slot `frame % frame_span` holds that frame's marks and remembers which frame it holds, so a frame
+ * that wrapped over reads as empty rather than as its predecessor. The caller keeps the frames it
+ * marks within `frame_span` of each other — the host accepts a record only between the oldest frame it
+ * can still rewind to and its future horizon, and that range sizes the ring — so no two live frames
+ * share a slot. Ordinals are bits in `words_per_frame` words per slot; a frame with more records than
+ * that grows every slot, once — so the caller bounds the ordinal before marking it (the host:
+ * `max_records_per_frame`), since an ordinal from the wire is whatever the peer wrote.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class RecordArrivalRing {
+    /**
+     * @param {{ frame_span: number }} options how many consecutive frames the ring tells apart
+     */
+    constructor({ frame_span }: {
+        frame_span: number;
+    });
+    /**
+     * @returns {number}
+     */
+    get frame_span(): number;
+    /**
+     * Mark the record at `ordinal` of `frame` as arrived.
+     *
+     * @param {number} frame
+     * @param {number} ordinal
+     * @returns {boolean} `true` if it had not arrived before; `false` for a copy
+     */
+    mark(frame: number, ordinal: number): boolean;
+    /**
+     * Whether the record at `ordinal` of `frame` has arrived.
+     *
+     * @param {number} frame
+     * @param {number} ordinal
+     * @returns {boolean}
+     */
+    has(frame: number, ordinal: number): boolean;
+    /**
+     * Forget every frame.
+     */
+    clear(): void;
+    #private;
+}
+//# sourceMappingURL=RecordArrivalRing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RecordArrivalRing.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/state/RecordArrivalRing.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAmBI;;OAEG;IACH,4BAFW;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,EAQhC;IAED;;OAEG;IACH,yBAEC;IAED;;;;;;OAMG;IACH,YAJW,MAAM,WACN,MAAM,GACJ,OAAO,CA4BnB;IAED;;;;;;OAMG;IACH,WAJW,MAAM,WACN,MAAM,GACJ,OAAO,CAanB;IAED;;OAEG;IACH,cAGC;;CAoBJ"}

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

@@ -0,0 +1,144 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * Which records of a sender's frames have arrived, over a window of consecutive frames.
+ *
+ * A record's identity on the action stream is the frame its sender tagged it for and its ordinal in
+ * that frame — the index of the record in the sender's log frame, counting every record there. The
+ * stream re-sends every unconfirmed frame each tick, so a receiver sees a record several times before
+ * its acknowledgement round-trips; this is how it tells the copies from new records. Nothing about the
+ * record's bytes takes part: two inputs with identical payloads tagged for different frames, or for
+ * the same frame at different ordinals, are two inputs. (Until 2026-10-15 the host compared bytes
+ * instead, and a held key — the same payload every frame — collapsed whenever its input arrived late
+ * and was folded into one frame: 56% of it applied, measured.)
+ *
+ * Slot `frame % frame_span` holds that frame's marks and remembers which frame it holds, so a frame
+ * that wrapped over reads as empty rather than as its predecessor. The caller keeps the frames it
+ * marks within `frame_span` of each other — the host accepts a record only between the oldest frame it
+ * can still rewind to and its future horizon, and that range sizes the ring — so no two live frames
+ * share a slot. Ordinals are bits in `words_per_frame` words per slot; a frame with more records than
+ * that grows every slot, once — so the caller bounds the ordinal before marking it (the host:
+ * `max_records_per_frame`), since an ordinal from the wire is whatever the peer wrote.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class RecordArrivalRing {
+    /** @type {number} */
+    #frame_span;
+
+    /**
+     * The frame each slot holds, -1 for none.
+     * @type {Int32Array}
+     */
+    #frames;
+
+    /** @type {number} */
+    #words_per_frame = 1;
+
+    /**
+     * `frame_span × words_per_frame` words; slot `s` owns `[s × words_per_frame, (s + 1) × words_per_frame)`.
+     * @type {Uint32Array}
+     */
+    #bits;
+
+    /**
+     * @param {{ frame_span: number }} options how many consecutive frames the ring tells apart
+     */
+    constructor({ frame_span }) {
+        assert.isPositiveInteger(frame_span, 'frame_span');
+
+        this.#frame_span = frame_span;
+        this.#frames = new Int32Array(frame_span).fill(-1);
+        this.#bits = new Uint32Array(frame_span);
+    }
+
+    /**
+     * @returns {number}
+     */
+    get frame_span() {
+        return this.#frame_span;
+    }
+
+    /**
+     * Mark the record at `ordinal` of `frame` as arrived.
+     *
+     * @param {number} frame
+     * @param {number} ordinal
+     * @returns {boolean} `true` if it had not arrived before; `false` for a copy
+     */
+    mark(frame, ordinal) {
+        assert.isNonNegativeInteger(frame, 'frame');
+        assert.isNonNegativeInteger(ordinal, 'ordinal');
+
+        const slot = frame % this.#frame_span;
+        const word = ordinal >>> 5;
+
+        if (word >= this.#words_per_frame) {
+            this.#grow(word + 1);
+        }
+
+        const words_per_frame = this.#words_per_frame;
+        const bits = this.#bits;
+        const base = slot * words_per_frame;
+
+        if (this.#frames[slot] !== frame) {
+            // a frame that wrapped over, or an empty slot: nothing of `frame` has arrived
+            this.#frames[slot] = frame;
+            bits.fill(0, base, base + words_per_frame);
+        }
+
+        const mask = 1 << (ordinal & 31);
+        const index = base + word;
+        if ((bits[index] & mask) !== 0) return false;
+        bits[index] |= mask;
+        return true;
+    }
+
+    /**
+     * Whether the record at `ordinal` of `frame` has arrived.
+     *
+     * @param {number} frame
+     * @param {number} ordinal
+     * @returns {boolean}
+     */
+    has(frame, ordinal) {
+        assert.isNonNegativeInteger(frame, 'frame');
+        assert.isNonNegativeInteger(ordinal, 'ordinal');
+
+        const slot = frame % this.#frame_span;
+        if (this.#frames[slot] !== frame) return false;
+
+        const word = ordinal >>> 5;
+        if (word >= this.#words_per_frame) return false;
+
+        return (this.#bits[slot * this.#words_per_frame + word] & (1 << (ordinal & 31))) !== 0;
+    }
+
+    /**
+     * Forget every frame.
+     */
+    clear() {
+        this.#frames.fill(-1);
+        this.#bits.fill(0);
+    }
+
+    /**
+     * Give every slot room for `min_words` words, keeping what is marked.
+     * @param {number} min_words
+     */
+    #grow(min_words) {
+        let words_per_frame = this.#words_per_frame;
+        while (words_per_frame < min_words) words_per_frame *= 2;
+
+        const old_words = this.#words_per_frame;
+        const old_bits = this.#bits;
+        const bits = new Uint32Array(this.#frame_span * words_per_frame);
+        for (let slot = 0; slot < this.#frame_span; slot++) {
+            bits.set(old_bits.subarray(slot * old_words, (slot + 1) * old_words), slot * words_per_frame);
+        }
+
+        this.#bits = bits;
+        this.#words_per_frame = words_per_frame;
+    }
+}

package/src/engine/network/transport/DeferredTransport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeferredTransport.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/DeferredTransport.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA6BI;;OAEG;IACH,mBAFW,SAAS,EA4BnB;IApCD;;;;OAIG;IACH,gBAFU,MAAM,CAEG;IAiCnB;;OAEG;IACH,uBAEC;IAED;;;;;;;;;;OAUG;IACH,cAWC;IAED;;;OAGG;IACH,gBAIC;IAED,oCAEC;;CAgBJ;0BA7IyB,gBAAgB"}
+{"version":3,"file":"DeferredTransport.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/DeferredTransport.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA6BI;;OAEG;IACH,mBAFW,SAAS,EA6BnB;IArCD;;;;OAIG;IACH,gBAFU,MAAM,CAEG;IAkCnB;;OAEG;IACH,uBAEC;IAED;;;;;;;;;;OAUG;IACH,cAWC;IAED;;;OAGG;IACH,gBAIC;IAED,oCAEC;;CAgBJ;0BA9IyB,gBAAgB"}

package/src/engine/network/transport/DeferredTransport.js

@@ -60,6 +60,7 @@ export class DeferredTransport extends Transport {
 
         this.reliable = inner.reliable;
         this.ordered = inner.ordered;
+        this.max_datagram_bytes = inner.max_datagram_bytes;
 
         this.#on_inner_receive = (bytes, length) => {
             if (this.#lost) {

package/src/engine/network/transport/LoopbackTransport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LoopbackTransport.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/LoopbackTransport.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAqBI;;;;;OAKG;IACH,oBAHW,iBAAiB,KACjB,iBAAiB,QAO3B;IAyBD;;;;;OAKG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;;OAMG;IACH,aAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;OAKG;IACH,WAHW,MAAM,KACN,MAAM,QAWhB;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;;CA8BJ;0BA9KyB,gBAAgB"}
+{"version":3,"file":"LoopbackTransport.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/LoopbackTransport.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAuBI;;;;;OAKG;IACH,oBAHW,iBAAiB,KACjB,iBAAiB,QAO3B;IAyBD;;;;;OAKG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;;OAMG;IACH,aAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;OAKG;IACH,WAHW,MAAM,KACN,MAAM,QAWhB;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;;CA8BJ;0BAhLyB,gBAAgB"}

package/src/engine/network/transport/LoopbackTransport.js

@@ -37,8 +37,10 @@ export class LoopbackTransport extends Transport {
     #in_queue = [];
 
     // `deliver_all()` empties the queue front-to-back, so packets
-    // arrive in send order, and the queue never drops them.
-    reliable = true;
+    // arrive in send order. Not reliable: `drop_next()` loses packets on
+    // purpose, so a connection over a loopback must recover what is lost
+    // exactly as it would over UDP.
+    reliable = false;
 
     ordered = true;
 

package/src/engine/network/transport/Transport.d.ts

@@ -47,6 +47,13 @@ export class Transport {
      * @type {boolean}
      */
     ordered: boolean;
+    /**
+     * Largest datagram {@link send} may be handed, header included. The connection layer packs to
+     * it. 1,200 bytes stays under the path MTU almost everywhere once IP/UDP (or DTLS/QUIC) headers
+     * are added; adapters with a better-known limit override it.
+     * @type {number}
+     */
+    max_datagram_bytes: number;
     /**
      * Fired when a packet arrives. Handlers receive `(bytes, length)` where
      * `bytes` is a `Uint8Array` valid for the duration of the call only;

package/src/engine/network/transport/Transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transport.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/Transport.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAsBI;;;;;;;;;;OAUG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;OAKG;IACH,WAFU,MAAM,CAES;IAEzB;;;;;;;;;;;OAWG;IACH,cAFU,MAAM,CAEY;IAE5B;;;;;;;;OAQG;IACH,YAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,WAFa,QAAQ,IAAI,CAAC,GAAC,IAAI,CAG9B;IAED;;OAEG;IACH,mBACC;IAED;;;;;;OAMG;IACH,+BAHW,MAAM,QAMhB;IAED;;;;;;OAMG;IACH,gCAHW,MAAM,QAMhB;IAED;;;;;OAKG;IACH,YAFa;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAS1F;IAED;;;;;;;;;;;OAWG;IACH,uCAHW,MAAM,QAWhB;IAED;;;;;;;OAOG;IACH,mCAEC;IAGL;;;;OAIG;IACH,sBAFU,OAAO,CAEc;;CAP9B;mBAnMkB,uCAAuC"}
+{"version":3,"file":"Transport.d.ts","sourceRoot":"","sources":["../../../../../src/engine/network/transport/Transport.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAsBI;;;;;;;;;;OAUG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;OAKG;IACH,oBAFU,MAAM,CAEU;IAE1B;;;;;OAKG;IACH,WAFU,MAAM,CAES;IAEzB;;;;;;;;;;;OAWG;IACH,cAFU,MAAM,CAEY;IAE5B;;;;;;;;OAQG;IACH,YAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAIhB;IAED;;;;OAIG;IACH,WAFa,QAAQ,IAAI,CAAC,GAAC,IAAI,CAG9B;IAED;;OAEG;IACH,mBACC;IAED;;;;;;OAMG;IACH,+BAHW,MAAM,QAMhB;IAED;;;;;;OAMG;IACH,gCAHW,MAAM,QAMhB;IAED;;;;;OAKG;IACH,YAFa;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAS1F;IAED;;;;;;;;;;;OAWG;IACH,uCAHW,MAAM,QAWhB;IAED;;;;;;;OAOG;IACH,mCAEC;IAGL;;;;OAIG;IACH,sBAFU,OAAO,CAEc;;CAP9B;mBA3MkB,uCAAuC"}

package/src/engine/network/transport/Transport.js

@@ -72,6 +72,14 @@ export class Transport {
      */
     ordered = false;
 
+    /**
+     * Largest datagram {@link send} may be handed, header included. The connection layer packs to
+     * it. 1,200 bytes stays under the path MTU almost everywhere once IP/UDP (or DTLS/QUIC) headers
+     * are added; adapters with a better-known limit override it.
+     * @type {number}
+     */
+    max_datagram_bytes = 1200;
+
     /**
      * Fired when a packet arrives. Handlers receive `(bytes, length)` where
      * `bytes` is a `Uint8Array` valid for the duration of the call only;

package/src/engine/network/transport/adapters/NodeUDPTransport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeUDPTransport.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/adapters/NodeUDPTransport.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH;IAOI;;;;;;OAMG;IACH,kDANW;QACV,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,SAAa,CAAC,EAAE,MAAM,CAAC;QACvB,MAAU,CAAC,EAAE;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC;KAC5C,EAuDH;IAhDG,0CAA0C;IAC1C,YAAkC;IAiDtC;;;;OAIG;IACH,oBAHW,MAAM,QACN,MAAM,QAMhB;IAED;;;;OAIG;IACH,qBAFa;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GAAC,IAAI,CAQhD;IA2BD;;;;;OAKG;IACH,WAFa,QAAQ,IAAI,CAAC,CA0BzB;;CA0BJ;0BAhMyB,iBAAiB"}
+{"version":3,"file":"NodeUDPTransport.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/adapters/NodeUDPTransport.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH;IAOI;;;;;;OAMG;IACH,kDANW;QACV,YAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,SAAa,CAAC,EAAE,MAAM,CAAC;QACvB,MAAU,CAAC,EAAE;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC;KAC5C,EAyDH;IAlDG,0CAA0C;IAC1C,YAAkC;IAmDtC;;;;OAIG;IACH,oBAHW,MAAM,QACN,MAAM,QAMhB;IAED;;;;OAIG;IACH,qBAFa;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GAAC,IAAI,CAQhD;IA2BD;;;;;OAKG;IACH,WAFa,QAAQ,IAAI,CAAC,CA0BzB;;CAsCJ;0BA9MyB,iBAAiB"}

package/src/engine/network/transport/adapters/NodeUDPTransport.js

@@ -1,4 +1,5 @@
 import { createSocket } from "node:dgram";
+import { isIP } from "node:net";
 import { assert } from "../../../../core/assert.js";
 import { Transport } from "../Transport.js";
 
@@ -56,11 +57,13 @@ export class NodeUDPTransport extends Transport {
             // pattern). This binds the adapter to exactly ONE peer — a single
             // instance must never be shared across clients. A server with many
             // clients demultiplexes by source address:port at a higher layer and
-            // owns one NodeUDPTransport per client (see the class doc); packets
-            // from any other source would otherwise be misattributed to the
-            // latched remote.
+            // owns one NodeUDPTransport per client (see the class doc).
             if (this.#remote === null) {
                 this.#remote = { address: rinfo.address, port: rinfo.port };
+            } else if (!this.#is_remote(rinfo)) {
+                // Anyone else's datagram, taken in as the remote's, would break the connection
+                // above: it does not authenticate (see Connection.onProtocolError).
+                return;
             }
             this.count_in(msg.length);
             // Buffer extends Uint8Array; safe to pass directly.
@@ -123,9 +126,9 @@ export class NodeUDPTransport extends Transport {
         if (length === 0) return;
         // A COPY, not a subarray view.
         //
-        // `Channel.send` hands over its long-lived reusable send buffer, and `dgram.send` is
+        // `Connection.flush` hands over its long-lived reusable datagram buffer, and `dgram.send` is
         // asynchronous - it documents that the buffer must not be modified before completion. With
-        // `max_packets_per_tick` above 1, `flush_outbound` calls `Channel.send` several times in a
+        // several datagrams to send, `Connection.flush` calls `send` several times in a
         // row, each rewriting that buffer from offset 0, so a queued view for one slice read the
         // next slice's header and payload: the receiver saw a packet whose seq and frame range
         // belonged to a different slice, accepted as well-formed and applied at the wrong frame.
@@ -187,6 +190,18 @@ export class NodeUDPTransport extends Transport {
         }
     }
 
+    /**
+     * Whether a datagram came from the remote. A remote named by host name rather than address is
+     * matched by port alone: the socket reports the address it resolved to.
+     * @param {{address: string, port: number}} rinfo
+     * @returns {boolean}
+     */
+    #is_remote(rinfo) {
+        const remote = this.#remote;
+        if (rinfo.port !== remote.port) return false;
+        return isIP(remote.address) === 0 || rinfo.address === remote.address;
+    }
+
     /** @private */
     #try_bound() {
         try { this.socket.address(); return true; }

package/src/engine/network/transport/adapters/WebRTCDataChannelTransport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebRTCDataChannelTransport.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/adapters/WebRTCDataChannelTransport.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAMI;;OAEG;IACH,8BAFW;QAAE,YAAY,EAAE,cAAc,CAAA;KAAE,EAqC1C;IA/BG,6BAA6B;IAC7B,cADW,cAAc,CACO;;CAmEvC;0BAvGyB,iBAAiB"}
+{"version":3,"file":"WebRTCDataChannelTransport.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/adapters/WebRTCDataChannelTransport.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAMI;;OAEG;IACH,8BAFW;QAAE,YAAY,EAAE,cAAc,CAAA;KAAE,EA6C1C;IAvCG,6BAA6B;IAC7B,cADW,cAAc,CACO;;CA2EvC;0BA/GyB,iBAAiB"}

package/src/engine/network/transport/adapters/WebRTCDataChannelTransport.js

@@ -36,6 +36,14 @@ export class WebRTCDataChannelTransport extends Transport {
 
         /** @type {RTCDataChannel} */
         this.data_channel = data_channel;
+
+        /*
+         Chrome's SCTP association sends packets of at most 1,191 bytes (kSctpMtu); after the SCTP
+         common header and the DATA chunk header a message that rides one packet is about 1,160. A
+         larger message is split across two SCTP packets on an unreliable channel, doubling its odds
+         of being lost. Quoted from Chrome's source as remembered, not measured on a device.
+        */
+        this.max_datagram_bytes = 1150;
         this.data_channel.binaryType = 'arraybuffer';
 
         // RTCDataChannel may fire 'close' and 'error' separately for the same

package/src/engine/network/transport/adapters/WebTransportTransport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebTransportTransport.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/adapters/WebTransportTransport.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAkBI;;OAEG;IACH,mCAFW;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,EAmCzD;IA3BG;;;;;OAKG;IACH,IAFU,MAAM,CAEgD;IAKhE;;;;;;;;;;;;;;OAcG;IACH,eAFU,MAAM,CAEiB;IAGrC;;;;;OAKG;IACH,WAFa,QAAQ,IAAI,CAAC,CASzB;;CAmGJ;0BAvMyB,iBAAiB;mBADxB,0CAA0C"}
+{"version":3,"file":"WebTransportTransport.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/adapters/WebTransportTransport.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAkBI;;OAEG;IACH,mCAFW;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,EAyCzD;IAjCG;;;;;OAKG;IACH,IAFU,MAAM,CAEgD;IAWhE;;;;;;;;;;;;;;OAcG;IACH,eAFU,MAAM,CAEiB;IAGrC;;;;;OAKG;IACH,WAFa,QAAQ,IAAI,CAAC,CASzB;;CAmGJ;0BA7MyB,iBAAiB;mBADxB,0CAA0C"}

package/src/engine/network/transport/adapters/WebTransportTransport.js

@@ -69,6 +69,12 @@ export class WebTransportTransport extends Transport {
         assert.ok(this.wt.datagrams !== undefined,
             'WebTransport instance must expose .datagrams (browser support / version)');
 
+        // the session states its own datagram limit; trust it when it does, never past 16,383
+        const max_datagram = this.wt.datagrams.maxDatagramSize;
+        if (typeof max_datagram === 'number' && max_datagram >= 256) {
+            this.max_datagram_bytes = Math.min(max_datagram, 16383);
+        }
+
         /**
          * Fires when `writer.write()` rejects but the underlying
          * connection is still open — typically transient backpressure