@woosh/meep-engine 3.45.0 → 3.47.0

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/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

package/src/engine/network/transport/connection/Connection.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Reliable lanes. Each is an ordered stream of messages; the lanes are independent of each other.
+ */
+export type Lane = number;
+/**
+ * Reliable lanes. Each is an ordered stream of messages; the lanes are independent of each other.
+ * @readonly
+ * @enum {number}
+ */
+export const Lane: Readonly<{
+    /** Engine control messages, one datagram each: resume answers, DISCONNECT. Not paced. */
+    CONTROL: 0;
+    /**
+     * Action-stream frames too large for a datagram. Not paced: the stream to the peer waits on
+     * them, and it cannot wait longer than its action log's ring.
+     */
+    FRAMES: 1;
+    /** Application messages that must arrive. Paced. */
+    USER: 2;
+    /** Large transfers: snapshot pages, state bursts. Paced, last. */
+    BULK: 3;
+}>;
+/**
+ * One connection to one peer over a datagram {@link Transport}: numbered packets acknowledged by
+ * ranges, unreliable messages of up to a datagram with a delivery notice each, and reliable lanes
+ * that carry messages of any size up to `max_message_bytes`, paced by a token bucket.
+ *
+ * Everything queued goes out on {@link flush}, packed into as few datagrams as fit. Everything
+ * received is handled inside the transport's receive callback. Time is whatever `clock` says; the
+ * connection never reads a clock of its own.
+ *
+ * The design is in `network/MESSAGE_TRANSPORT.md`. Loss detection, RTT and the probe timeout follow
+ * QUIC (RFC 9002), packet numbers and ACK ranges RFC 9000.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Connection {
+    /**
+     * @param {{
+     *   transport: { send(bytes: Uint8Array, length: number): void, onReceive: Signal, max_datagram_bytes?: number },
+     *   clock: function(): number,
+     *   send_rate_bytes_per_second: number,
+     *   max_message_bytes: number,
+     *   receive_window_bytes: number,
+     *   max_queued_bytes: number,
+     *   max_ack_delay_ms: number,
+     *   max_ack_ranges?: number,
+     * }} options
+     *   `clock` returns milliseconds and never runs backwards. `send_rate_bytes_per_second` paces
+     *   the BULK lane. `max_message_bytes` is the largest reliable message either side may send;
+     *   both ends must agree. `receive_window_bytes` bounds what each reliable lane may have in
+     *   flight past its acknowledged prefix, and so what a receiver holds out of order. Both ends
+     *   must agree on these two; a peer that exceeds them is a protocol error.
+     *   `max_queued_bytes` caps what one lane may hold unacknowledged: past it,
+     *   {@link send_reliable} throws rather than grow without bound.
+     *   `max_ack_delay_ms` is how long this side may sit on an ACK and the resolution of its
+     *   clock: its tick period. `max_ack_ranges` is how many ranges this side's ACKs report, at
+     *   most 64.
+     *
+     *   A transport that is itself reliable (`transport.reliable`, e.g. a WebSocket) delivers
+     *   every packet: nothing is declared lost and nothing is probed, or a stalled TCP stream
+     *   would be fed duplicates behind the originals.
+     */
+    constructor({ transport, clock, send_rate_bytes_per_second, max_message_bytes, receive_window_bytes, max_queued_bytes, max_ack_delay_ms, max_ack_ranges, }: {
+        transport: {
+            send(bytes: Uint8Array, length: number): void;
+            onReceive: Signal;
+            max_datagram_bytes?: number;
+        };
+        clock: () => number;
+        send_rate_bytes_per_second: number;
+        max_message_bytes: number;
+        receive_window_bytes: number;
+        max_queued_bytes: number;
+        max_ack_delay_ms: number;
+        max_ack_ranges?: number;
+    });
+    /** @type {number} @readonly */
+    readonly max_message_bytes: number;
+    /**
+     * Largest unreliable message: what fits one datagram after the packet and frame headers.
+     * @type {number} @readonly
+     */
+    readonly max_unreliable_message_bytes: number;
+    /**
+     * A message arrived: `(bytes, offset, length)`. `bytes` is the connection's or the
+     * transport's buffer, valid for the duration of the call only.
+     * @type {Signal}
+     */
+    onMessage: Signal;
+    /**
+     * An unreliable message sent with a token arrived: `(token)`.
+     * @type {Signal}
+     */
+    onMessageAcked: Signal;
+    /**
+     * An unreliable message sent with a token was lost: `(token)`. Lost means not confirmed:
+     * a message whose packet arrived but whose acknowledgement never got through — every ACK
+     * that could report it lost, or crowded out by newer ranges — is reported lost, as QUIC
+     * does.
+     * @type {Signal}
+     */
+    onMessageLost: Signal;
+    /**
+     * A datagram that does not parse, or is of another protocol version, was dropped whole and
+     * unacknowledged: `(reason)`. The connection carries on; anyone can send a stray datagram.
+     * @type {Signal}
+     */
+    onMalformedDatagram: Signal;
+    /**
+     * The connection is no longer whole: `(reason)`. The peer broke the protocol on a reliable
+     * lane — a message longer than `max_message_bytes`, bytes past the receive window, more
+     * holes than a sender keeping to its window makes — and the lane has stopped, so nothing
+     * more will arrive on it; or the peer acknowledged a packet this side never sent, so it
+     * took in a datagram that was not this side's and nothing it acknowledges can be trusted.
+     * The datagram carrying that ACK is dropped, as is every later one that repeats it.
+     *
+     * The connection does not authenticate datagrams: its transport must deliver only the
+     * peer's (DTLS and TLS do; a UDP socket filters by source address). The cure is a new
+     * connection.
+     * @type {Signal}
+     */
+    onProtocolError: Signal;
+    /**
+     * Queue an unreliable message for the next {@link flush}. With `token >= 0` the connection
+     * reports its fate: {@link onMessageAcked} once the packet carrying it is acknowledged, or
+     * {@link onMessageLost} once it is declared lost — exactly one of them.
+     *
+     * @param {Uint8Array} bytes
+     * @param {number} offset
+     * @param {number} length at most {@link max_unreliable_message_bytes}
+     * @param {number} token caller's id for the notice, or -1 for none
+     */
+    send_unreliable(bytes: Uint8Array, offset: number, length: number, token: number): void;
+    /**
+     * Queue a reliable message on `lane`. It arrives, whole and in order with the lane's other
+     * messages, unless the connection ends first.
+     *
+     * @param {number} lane one of {@link Lane}
+     * @param {Uint8Array} bytes
+     * @param {number} offset
+     * @param {number} length at most {@link max_message_bytes}
+     * @returns {number} delivery mark: see {@link is_delivered}
+     */
+    send_reliable(lane: number, bytes: Uint8Array, offset: number, length: number): number;
+    /**
+     * Whether every message on `lane` up to the one whose mark this is has been acknowledged.
+     * @param {number} lane
+     * @param {number} mark from {@link send_reliable}
+     * @returns {boolean}
+     */
+    is_delivered(lane: number, mark: number): boolean;
+    /**
+     * Bytes queued on `lane` the peer has not acknowledged.
+     * @param {number} lane
+     * @returns {number}
+     */
+    unacked_bytes(lane: number): number;
+    /**
+     * Send everything queued that may go now, packed into as few datagrams as fit: the ACK, the
+     * CONTROL lane, unreliable messages, then the BULK lane while the token bucket allows. Also
+     * runs the loss and probe timers.
+     */
+    flush(): void;
+    /** Smoothed round-trip time, ms; RFC 9002's initial 333 ms until the first sample. */
+    get smoothed_rtt(): number;
+    /** Packets sent and not yet acknowledged or declared lost that asked for an ACK. */
+    get in_flight_count(): number;
+    /** Most bytes one reliable lane may hold unacknowledged; {@link send_reliable} throws past it. */
+    get max_queued_bytes(): number;
+    /**
+     * @returns {{packets_sent: number, packets_received: number, packets_lost: number, packets_dropped: number, bytes_sent: number, bytes_received: number}}
+     */
+    getStats(): {
+        packets_sent: number;
+        packets_received: number;
+        packets_lost: number;
+        packets_dropped: number;
+        bytes_sent: number;
+        bytes_received: number;
+    };
+    /**
+     * Stop: no more receiving, and nothing queued will be sent. Call {@link flush} first for a
+     * last send.
+     */
+    dispose(): void;
+    #private;
+}
+import Signal from "../../../../core/events/signal/Signal.js";
+//# sourceMappingURL=Connection.d.ts.map

package/src/engine/network/transport/connection/Connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Connection.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/network/transport/connection/Connection.js"],"names":[],"mappings":";;;mBAWU,MAAM;AAHhB;;;;GAIG;AACH;IACI,yFAAyF;;IAEzF;;;OAGG;;IAEH,oDAAoD;;IAEpD,kEAAkE;;GAEnE;AA+DH;;;;;;;;;;;;;;GAcG;AACH;IA+HI;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,4JAzBW;QACV,SAAa,EAAE;YAAE,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QACjH,KAAS,QAAc,MAAM,CAAC;QAC9B,0BAA8B,EAAE,MAAM,CAAC;QACvC,iBAAqB,EAAE,MAAM,CAAC;QAC9B,oBAAwB,EAAE,MAAM,CAAC;QACjC,gBAAoB,EAAE,MAAM,CAAC;QAC7B,gBAAoB,EAAE,MAAM,CAAC;QAC7B,cAAkB,CAAC,EAAE,MAAM,CAAC;KACzB,EAuHH;IA7DG,+BAA+B;IAC/B,4BADW,MAAM,CACyB;IAE1C;;;OAGG;IACH,uCAFU,MAAM,CAE+E;IAS/F;;;;OAIG;IACH,WAFU,MAAM,CAEa;IAE7B;;;OAGG;IACH,gBAFU,MAAM,CAEkB;IAElC;;;;;;OAMG;IACH,eAFU,MAAM,CAEiB;IAEjC;;;;OAIG;IACH,qBAFU,MAAM,CAEuB;IAEvC;;;;;;;;;;;;OAYG;IACH,iBAFU,MAAM,CAEmB;IAOvC;;;;;;;;;OASG;IACH,uBALW,UAAU,UACV,MAAM,UACN,MAAM,SACN,MAAM,QAqBhB;IAED;;;;;;;;;OASG;IACH,oBANW,MAAM,SACN,UAAU,UACV,MAAM,UACN,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,QACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,cAuCC;IAID,sFAAsF;IACtF,2BAEC;IAED,oFAAoF;IACpF,8BAEC;IAED,kGAAkG;IAClG,+BAEC;IAED;;OAEG;IACH,YAFa;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC,CAIvJ;IAED;;;OAGG;IACH,gBAYC;;CAouBJ;mBA5uCkB,0CAA0C"}