@driftengine/network 4.8.2 → 4.8.3

package/dist/transport.d.ts

@@ -68,3 +68,16 @@ export interface Transport {
  * shared memory, which a browser refuses to send, is copied off it.
  */
 export declare function sendable(message: Uint8Array): Uint8Array<ArrayBuffer>;
+/**
+ * A received message's bytes, whatever the socket or channel handed over, or null where nothing
+ * can be read out of it — which the transport counts as dropped.
+ *
+ * Browsers deliver an `ArrayBuffer` once `binaryType` is set, `ws` under Node delivers a `Buffer`,
+ * and a **text frame** arrives as a string. A text frame is lossless UTF-8 by the protocol, so its
+ * bytes are exactly what the sender wrote, and it is read as them. It was discarded until 4.8.3,
+ * on the ground that a payload through UTF-8 loses every byte above 0x7f — which is true of binary
+ * data somebody sent as text, and not of a server that speaks text, whose every message then
+ * vanished without a count. **What this gives up** is nothing a sender can still lose: binary bytes
+ * sent as text were mangled before they reached this, by the sender.
+ */
+export declare function receivedBytes(data: unknown): Uint8Array | null;

package/dist/transport.js

@@ -49,3 +49,27 @@ export function sendable(message) {
         ? message
         : message.slice();
 }
+const UTF8 = new TextEncoder();
+/**
+ * A received message's bytes, whatever the socket or channel handed over, or null where nothing
+ * can be read out of it — which the transport counts as dropped.
+ *
+ * Browsers deliver an `ArrayBuffer` once `binaryType` is set, `ws` under Node delivers a `Buffer`,
+ * and a **text frame** arrives as a string. A text frame is lossless UTF-8 by the protocol, so its
+ * bytes are exactly what the sender wrote, and it is read as them. It was discarded until 4.8.3,
+ * on the ground that a payload through UTF-8 loses every byte above 0x7f — which is true of binary
+ * data somebody sent as text, and not of a server that speaks text, whose every message then
+ * vanished without a count. **What this gives up** is nothing a sender can still lose: binary bytes
+ * sent as text were mangled before they reached this, by the sender.
+ */
+export function receivedBytes(data) {
+    if (data instanceof Uint8Array)
+        return data;
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (ArrayBuffer.isView(data))
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    if (typeof data === 'string')
+        return UTF8.encode(data);
+    return null;
+}

package/dist/webrtc.js

@@ -30,7 +30,7 @@
  * That is a weaker guarantee than the loopback transport has, and it is why WebSocket is the
  * default rather than this.
  */
-import { BROADCAST, sendable, } from './transport.js';
+import { BROADCAST, receivedBytes, sendable, } from './transport.js';
 /**
  * A channel configured the way a simulation wants one.
  *
@@ -57,9 +57,11 @@ export class WebRtcTransport {
             this.channel.binaryType = 'arraybuffer';
         this.channel.addEventListener('message', (event) => {
             const data = event.data;
-            const bytes = toBytes(data);
-            if (bytes === null)
+            const bytes = receivedBytes(data);
+            if (bytes === null) {
+                this.droppedCount += 1;
                 return;
+            }
             if (this.arrived.length >= this.maxQueued) {
                 this.arrived.shift();
                 this.droppedCount += 1;
@@ -96,13 +98,3 @@ export class WebRtcTransport {
         this.channel.close();
     }
 }
-function toBytes(data) {
-    if (data instanceof Uint8Array)
-        return data;
-    if (data instanceof ArrayBuffer)
-        return new Uint8Array(data);
-    if (ArrayBuffer.isView(data)) {
-        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    }
-    return null;
-}

package/dist/websocket.d.ts

@@ -60,7 +60,10 @@ export declare class WebSocketTransport implements Transport {
     private droppedCount;
     constructor(options: WebSocketTransportOptions);
     get state(): TransportState;
-    /** Messages dropped because nothing drained. A consumer watching for a stalled tab reads this. */
+    /**
+     * Messages dropped: because nothing drained, which a consumer watching for a stalled tab reads,
+     * or because nothing could be read out of them.
+     */
     get dropped(): number;
     /**
      * Send, or do nothing if the socket is not open yet.

package/dist/websocket.js

@@ -23,7 +23,7 @@
  * the credentials and the reconnection policy. A transport that opened its own connection would be
  * making four decisions that belong to whoever is paying for the server.
  */
-import { BROADCAST, sendable, } from './transport.js';
+import { BROADCAST, receivedBytes, sendable, } from './transport.js';
 /** The `readyState` values, which are the same three numbers everywhere. */
 const OPEN = 1;
 const CLOSED = 3;
@@ -44,9 +44,11 @@ export class WebSocketTransport {
             this.socket.binaryType = 'arraybuffer';
         this.socket.addEventListener('message', (event) => {
             const data = event.data;
-            const bytes = toBytes(data);
-            if (bytes === null)
+            const bytes = receivedBytes(data);
+            if (bytes === null) {
+                this.droppedCount += 1;
                 return;
+            }
             if (this.arrived.length >= this.maxQueued) {
                 this.arrived.shift();
                 this.droppedCount += 1;
@@ -59,7 +61,10 @@ export class WebSocketTransport {
             return 'closed';
         return this.socket.readyState === OPEN ? 'open' : 'connecting';
     }
-    /** Messages dropped because nothing drained. A consumer watching for a stalled tab reads this. */
+    /**
+     * Messages dropped: because nothing drained, which a consumer watching for a stalled tab reads,
+     * or because nothing could be read out of them.
+     */
     get dropped() {
         return this.droppedCount;
     }
@@ -86,20 +91,3 @@ export class WebSocketTransport {
         this.socket.close();
     }
 }
-/**
- * A message's bytes, whatever the socket handed over, or null.
- *
- * Browsers deliver an `ArrayBuffer` when `binaryType` is set, `ws` under Node delivers a `Buffer`,
- * and a socket left on its default delivers a string. The first two are usable and the third is
- * not: a payload that has been through UTF-8 has had every byte above 0x7f replaced.
- */
-function toBytes(data) {
-    if (data instanceof Uint8Array)
-        return data;
-    if (data instanceof ArrayBuffer)
-        return new Uint8Array(data);
-    if (ArrayBuffer.isView(data)) {
-        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    }
-    return null;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/network",
-  "version": "4.8.2",
+  "version": "4.8.3",
   "description": "A transport seam, rewind and replay, lockstep and an authoritative host, on the fixed-step loop",
   "license": "Apache-2.0",
   "type": "module",
@@ -27,10 +27,10 @@
   ],
   "sideEffects": false,
   "peerDependencies": {
-    "@driftengine/entities": "4.8.2"
+    "@driftengine/entities": "4.8.3"
   },
   "devDependencies": {
-    "@driftengine/core": "4.8.2"
+    "@driftengine/core": "4.8.3"
   },
   "author": "Drift Technologies",
   "repository": {

package/src/transport.ts

@@ -79,3 +79,26 @@ export function sendable(message: Uint8Array): Uint8Array<ArrayBuffer> {
     ? (message as Uint8Array<ArrayBuffer>)
     : message.slice();
 }
+
+const UTF8 = new TextEncoder();
+
+/**
+ * A received message's bytes, whatever the socket or channel handed over, or null where nothing
+ * can be read out of it — which the transport counts as dropped.
+ *
+ * Browsers deliver an `ArrayBuffer` once `binaryType` is set, `ws` under Node delivers a `Buffer`,
+ * and a **text frame** arrives as a string. A text frame is lossless UTF-8 by the protocol, so its
+ * bytes are exactly what the sender wrote, and it is read as them. It was discarded until 4.8.3,
+ * on the ground that a payload through UTF-8 loses every byte above 0x7f — which is true of binary
+ * data somebody sent as text, and not of a server that speaks text, whose every message then
+ * vanished without a count. **What this gives up** is nothing a sender can still lose: binary bytes
+ * sent as text were mangled before they reached this, by the sender.
+ */
+export function receivedBytes(data: unknown): Uint8Array | null {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data))
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  if (typeof data === 'string') return UTF8.encode(data);
+  return null;
+}

package/src/webrtc.ts

@@ -36,6 +36,7 @@ import {
   type PeerId,
   type Transport,
   type TransportState,
+  receivedBytes,
   sendable,
 } from './transport.ts';
 
@@ -94,8 +95,11 @@ export class WebRtcTransport implements Transport {
 
     this.channel.addEventListener('message', (event) => {
       const data = (event as { data?: unknown }).data;
-      const bytes = toBytes(data);
-      if (bytes === null) return;
+      const bytes = receivedBytes(data);
+      if (bytes === null) {
+        this.droppedCount += 1;
+        return;
+      }
       if (this.arrived.length >= this.maxQueued) {
         this.arrived.shift();
         this.droppedCount += 1;
@@ -132,12 +136,3 @@ export class WebRtcTransport implements Transport {
     this.channel.close();
   }
 }
-
-function toBytes(data: unknown): Uint8Array | null {
-  if (data instanceof Uint8Array) return data;
-  if (data instanceof ArrayBuffer) return new Uint8Array(data);
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-  }
-  return null;
-}

package/src/websocket.ts

@@ -29,6 +29,7 @@ import {
   type PeerId,
   type Transport,
   type TransportState,
+  receivedBytes,
   sendable,
 } from './transport.ts';
 
@@ -85,8 +86,11 @@ export class WebSocketTransport implements Transport {
 
     this.socket.addEventListener('message', (event) => {
       const data = (event as { data?: unknown }).data;
-      const bytes = toBytes(data);
-      if (bytes === null) return;
+      const bytes = receivedBytes(data);
+      if (bytes === null) {
+        this.droppedCount += 1;
+        return;
+      }
       if (this.arrived.length >= this.maxQueued) {
         this.arrived.shift();
         this.droppedCount += 1;
@@ -100,7 +104,10 @@ export class WebSocketTransport implements Transport {
     return this.socket.readyState === OPEN ? 'open' : 'connecting';
   }
 
-  /** Messages dropped because nothing drained. A consumer watching for a stalled tab reads this. */
+  /**
+   * Messages dropped: because nothing drained, which a consumer watching for a stalled tab reads,
+   * or because nothing could be read out of them.
+   */
   get dropped(): number {
     return this.droppedCount;
   }
@@ -128,19 +135,3 @@ export class WebSocketTransport implements Transport {
     this.socket.close();
   }
 }
-
-/**
- * A message's bytes, whatever the socket handed over, or null.
- *
- * Browsers deliver an `ArrayBuffer` when `binaryType` is set, `ws` under Node delivers a `Buffer`,
- * and a socket left on its default delivers a string. The first two are usable and the third is
- * not: a payload that has been through UTF-8 has had every byte above 0x7f replaced.
- */
-function toBytes(data: unknown): Uint8Array | null {
-  if (data instanceof Uint8Array) return data;
-  if (data instanceof ArrayBuffer) return new Uint8Array(data);
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-  }
-  return null;
-}