@driftengine/network 4.7.4 → 4.8.0

package/dist/lockstep.d.ts

@@ -106,6 +106,8 @@ export declare class LockstepSession<S> {
     /** Digests we published, by tick, so a peer's claim has something to be compared against. */
     private readonly ourDigests;
     private statusValue;
+    /** The tick of this session's first `submit`, or -1 before it. See `open`. */
+    private openedAt;
     private desyncValue;
     private haltReason;
     private confirmedValue;
@@ -136,6 +138,19 @@ export declare class LockstepSession<S> {
      * prediction is supposed to prevent.
      */
     submit(tick: number, payload: Uint8Array): void;
+    /**
+     * The ticks before anybody's first input, settled as neutral for every participant.
+     *
+     * **Nobody can publish an input for them**: the earliest a peer publishes is its first tick plus
+     * the input delay. So nothing will ever arrive to confirm or correct them, and whatever a peer
+     * guesses for them is final. A guess repeats the newest input the log holds, and for this peer's
+     * own participant that was the input just submitted for a *later* tick, which no other peer can
+     * know: a player holding a control on the first tick split the worlds there, and the first
+     * fingerprint halted the session. Neutral is the one answer every peer reaches alone, because
+     * nobody had pressed anything before the game began. Lockstep peers start on the same tick, so
+     * they all settle the same ticks.
+     */
+    private open;
     /**
      * Keep this input, and the few before it, for the next packet to carry.
      *

package/dist/lockstep.js

@@ -58,6 +58,8 @@ export class LockstepSession {
     /** Digests we published, by tick, so a peer's claim has something to be compared against. */
     ourDigests = new Map();
     statusValue = 'running';
+    /** The tick of this session's first `submit`, or -1 before it. See `open`. */
+    openedAt = -1;
     desyncValue = null;
     haltReason = '';
     confirmedValue = -1;
@@ -111,6 +113,8 @@ export class LockstepSession {
         if (this.statusValue !== 'running')
             return;
         const at = tick + this.inputDelay;
+        if (this.openedAt < 0)
+            this.open(tick);
         if (!this.inputs.holds(at)) {
             this.halt(`an input for tick ${at} is outside the log's window`);
             return;
@@ -124,6 +128,29 @@ export class LockstepSession {
         }
         this.transport.send(BROADCAST, this.outgoing.subarray(0, length));
     }
+    /**
+     * The ticks before anybody's first input, settled as neutral for every participant.
+     *
+     * **Nobody can publish an input for them**: the earliest a peer publishes is its first tick plus
+     * the input delay. So nothing will ever arrive to confirm or correct them, and whatever a peer
+     * guesses for them is final. A guess repeats the newest input the log holds, and for this peer's
+     * own participant that was the input just submitted for a *later* tick, which no other peer can
+     * know: a player holding a control on the first tick split the worlds there, and the first
+     * fingerprint halted the session. Neutral is the one answer every peer reaches alone, because
+     * nobody had pressed anything before the game began. Lockstep peers start on the same tick, so
+     * they all settle the same ticks.
+     */
+    open(tick) {
+        this.openedAt = tick;
+        const neutral = new Uint8Array(this.inputs.inputBytes);
+        for (let at = tick; at < tick + this.inputDelay; at++) {
+            if (!this.inputs.holds(at))
+                continue;
+            for (let participant = 0; participant < this.participants; participant++) {
+                this.inputs.set(participant, at, neutral);
+            }
+        }
+    }
     /**
      * Keep this input, and the few before it, for the next packet to carry.
      *

package/dist/transport.d.ts

@@ -61,3 +61,10 @@ export interface Transport {
     drain(into: MessageSink): void;
     close(): void;
 }
+/**
+ * The message as a view of an `ArrayBuffer`, which is what a socket or a channel will send.
+ *
+ * Everything this package sends is already one, so this is a check and no copy. A message on
+ * shared memory, which a browser refuses to send, is copied off it.
+ */
+export declare function sendable(message: Uint8Array): Uint8Array<ArrayBuffer>;

package/dist/transport.js

@@ -38,3 +38,14 @@
  */
 /** Send to everyone the transport can reach. */
 export const BROADCAST = -1;
+/**
+ * The message as a view of an `ArrayBuffer`, which is what a socket or a channel will send.
+ *
+ * Everything this package sends is already one, so this is a check and no copy. A message on
+ * shared memory, which a browser refuses to send, is copied off it.
+ */
+export function sendable(message) {
+    return message.buffer instanceof ArrayBuffer
+        ? message
+        : message.slice();
+}

package/dist/webrtc.d.ts

@@ -35,7 +35,8 @@ import { type MessageSink, type PeerId, type Transport, type TransportState } fr
 export interface DataChannelLike {
     readonly readyState: string;
     binaryType?: string;
-    send(data: ArrayBufferView | ArrayBuffer): void;
+    /** An `ArrayBuffer`'s view, as for a socket: see `SocketLike.send`. */
+    send(data: ArrayBufferView<ArrayBuffer> | ArrayBuffer): void;
     close(): void;
     addEventListener(type: string, listener: (event: unknown) => void): void;
 }

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, } from './transport.js';
+import { BROADCAST, sendable, } from './transport.js';
 /**
  * A channel configured the way a simulation wants one.
  *
@@ -83,7 +83,7 @@ export class WebRtcTransport {
     send(_to, message) {
         if (this.state !== 'open')
             return;
-        this.channel.send(message);
+        this.channel.send(sendable(message));
     }
     drain(into) {
         for (const message of this.arrived)

package/dist/websocket.d.ts

@@ -28,7 +28,12 @@ import { type MessageSink, type PeerId, type Transport, type TransportState } fr
 export interface SocketLike {
     readonly readyState: number;
     binaryType?: string;
-    send(data: ArrayBufferView | ArrayBuffer): void;
+    /**
+     * A view of an `ArrayBuffer`, never of shared memory: that is what a browser's `WebSocket.send`
+     * takes, and declaring any buffer here made a browser socket not fit its own transport, so
+     * `new WebSocketTransport({ socket: new WebSocket(url) })` did not typecheck.
+     */
+    send(data: ArrayBufferView<ArrayBuffer> | ArrayBuffer): void;
     close(): void;
     addEventListener(type: string, listener: (event: unknown) => void): void;
 }

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, } from './transport.js';
+import { BROADCAST, sendable, } from './transport.js';
 /** The `readyState` values, which are the same three numbers everywhere. */
 const OPEN = 1;
 const CLOSED = 3;
@@ -73,7 +73,7 @@ export class WebSocketTransport {
     send(_to, message) {
         if (this.state !== 'open')
             return;
-        this.socket.send(message);
+        this.socket.send(sendable(message));
     }
     drain(into) {
         for (const message of this.arrived)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/network",
-  "version": "4.7.4",
+  "version": "4.8.0",
   "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.7.4"
+    "@driftengine/entities": "4.8.0"
   },
   "devDependencies": {
-    "@driftengine/core": "4.7.4"
+    "@driftengine/core": "4.8.0"
   },
   "author": "Drift Technologies",
   "repository": {

package/src/lockstep.ts

@@ -122,6 +122,8 @@ export class LockstepSession<S> {
   private readonly ourDigests = new Map<number, string>();
 
   private statusValue: LockstepStatus = 'running';
+  /** The tick of this session's first `submit`, or -1 before it. See `open`. */
+  private openedAt = -1;
   private desyncValue: Desync | null = null;
   private haltReason = '';
   private confirmedValue = -1;
@@ -180,6 +182,7 @@ export class LockstepSession<S> {
   submit(tick: number, payload: Uint8Array): void {
     if (this.statusValue !== 'running') return;
     const at = tick + this.inputDelay;
+    if (this.openedAt < 0) this.open(tick);
 
     if (!this.inputs.holds(at)) {
       this.halt(`an input for tick ${at} is outside the log's window`);
@@ -203,6 +206,29 @@ export class LockstepSession<S> {
     this.transport.send(BROADCAST, this.outgoing.subarray(0, length));
   }
 
+  /**
+   * The ticks before anybody's first input, settled as neutral for every participant.
+   *
+   * **Nobody can publish an input for them**: the earliest a peer publishes is its first tick plus
+   * the input delay. So nothing will ever arrive to confirm or correct them, and whatever a peer
+   * guesses for them is final. A guess repeats the newest input the log holds, and for this peer's
+   * own participant that was the input just submitted for a *later* tick, which no other peer can
+   * know: a player holding a control on the first tick split the worlds there, and the first
+   * fingerprint halted the session. Neutral is the one answer every peer reaches alone, because
+   * nobody had pressed anything before the game began. Lockstep peers start on the same tick, so
+   * they all settle the same ticks.
+   */
+  private open(tick: number): void {
+    this.openedAt = tick;
+    const neutral = new Uint8Array(this.inputs.inputBytes);
+    for (let at = tick; at < tick + this.inputDelay; at++) {
+      if (!this.inputs.holds(at)) continue;
+      for (let participant = 0; participant < this.participants; participant++) {
+        this.inputs.set(participant, at, neutral);
+      }
+    }
+  }
+
   /**
    * Keep this input, and the few before it, for the next packet to carry.
    *

package/src/transport.ts

@@ -67,3 +67,15 @@ export interface Transport {
   drain(into: MessageSink): void;
   close(): void;
 }
+
+/**
+ * The message as a view of an `ArrayBuffer`, which is what a socket or a channel will send.
+ *
+ * Everything this package sends is already one, so this is a check and no copy. A message on
+ * shared memory, which a browser refuses to send, is copied off it.
+ */
+export function sendable(message: Uint8Array): Uint8Array<ArrayBuffer> {
+  return message.buffer instanceof ArrayBuffer
+    ? (message as Uint8Array<ArrayBuffer>)
+    : message.slice();
+}

package/src/webrtc.ts

@@ -36,13 +36,15 @@ import {
   type PeerId,
   type Transport,
   type TransportState,
+  sendable,
 } from './transport.ts';
 
 /** What an `RTCDataChannel` satisfies. Declared rather than imported; see `websocket.ts`. */
 export interface DataChannelLike {
   readonly readyState: string;
   binaryType?: string;
-  send(data: ArrayBufferView | ArrayBuffer): void;
+  /** An `ArrayBuffer`'s view, as for a socket: see `SocketLike.send`. */
+  send(data: ArrayBufferView<ArrayBuffer> | ArrayBuffer): void;
   close(): void;
   addEventListener(type: string, listener: (event: unknown) => void): void;
 }
@@ -116,7 +118,7 @@ export class WebRtcTransport implements Transport {
 
   send(_to: PeerId, message: Uint8Array): void {
     if (this.state !== 'open') return;
-    this.channel.send(message);
+    this.channel.send(sendable(message));
   }
 
   drain(into: MessageSink): void {

package/src/websocket.ts

@@ -29,13 +29,19 @@ import {
   type PeerId,
   type Transport,
   type TransportState,
+  sendable,
 } from './transport.ts';
 
 /** What a browser `WebSocket` and a Node `ws` both satisfy. Named here so neither is imported. */
 export interface SocketLike {
   readonly readyState: number;
   binaryType?: string;
-  send(data: ArrayBufferView | ArrayBuffer): void;
+  /**
+   * A view of an `ArrayBuffer`, never of shared memory: that is what a browser's `WebSocket.send`
+   * takes, and declaring any buffer here made a browser socket not fit its own transport, so
+   * `new WebSocketTransport({ socket: new WebSocket(url) })` did not typecheck.
+   */
+  send(data: ArrayBufferView<ArrayBuffer> | ArrayBuffer): void;
   close(): void;
   addEventListener(type: string, listener: (event: unknown) => void): void;
 }
@@ -108,7 +114,7 @@ export class WebSocketTransport implements Transport {
    */
   send(_to: PeerId, message: Uint8Array): void {
     if (this.state !== 'open') return;
-    this.socket.send(message);
+    this.socket.send(sendable(message));
   }
 
   drain(into: MessageSink): void {