bedrock-portal-nethernet 2.2.0 → 2.4.0

package/dist/nethernet/server.d.ts

@@ -1,29 +1,17 @@
 import { Connection } from './connection';
 import { Signal } from '../signaling/signal';
 import { SignalStructure } from '../signaling/struct';
-type PendingCandidate = {
-    signal: SignalStructure;
-    attempts: number;
-};
 export declare class Server {
     networkId: bigint;
     connectionId: bigint;
     signaling: Signal;
     connections: Map<bigint, Connection>;
-    pendingCandidates: Map<bigint, PendingCandidate[]>;
-    remoteDescriptionReady: Set<bigint>;
-    pendingCandidateTimers: Map<bigint, NodeJS.Timeout>;
     onOpenConnection: (conn: Connection) => void;
     onCloseConnection: (id: bigint, reason: string) => void;
     onEncapsulated: (packet: Buffer, id: bigint) => void;
     constructor(signaling: Signal, networkId?: bigint, connectionId?: bigint);
     handleCandidate(signal: SignalStructure): Promise<void>;
-    queueCandidate(signal: SignalStructure, reason?: string): void;
-    schedulePendingCandidateFlush(connectionId: bigint): void;
-    flushPendingCandidates(connectionId: bigint): void;
-    requeueCandidate(candidate: PendingCandidate, remaining: PendingCandidate[], reason: string): void;
     handleOffer(signal: SignalStructure): Promise<void>;
     listen(): Promise<void>;
     close(): void;
 }
-export {};

package/dist/nethernet/server.js

@@ -5,8 +5,6 @@ const node_datachannel_1 = require("node-datachannel");
 const connection_1 = require("./connection");
 const struct_1 = require("../signaling/struct");
 const debugFn = require('debug')('bedrock-portal-nethernet');
-const MAX_PENDING_CANDIDATE_ATTEMPTS = 50;
-const PENDING_CANDIDATE_RETRY_MS = 100;
 const getRandomUint64 = () => {
     const high = Math.floor(Math.random() * 0xFFFFFFFF);
     const low = Math.floor(Math.random() * 0xFFFFFFFF);
@@ -17,9 +15,6 @@ class Server {
     connectionId;
     signaling;
     connections;
-    pendingCandidates;
-    remoteDescriptionReady;
-    pendingCandidateTimers;
     onOpenConnection;
     onCloseConnection;
     onEncapsulated;
@@ -28,78 +23,18 @@ class Server {
         this.networkId = networkId;
         this.connectionId = connectionId;
         this.connections = new Map();
-        this.pendingCandidates = new Map();
-        this.remoteDescriptionReady = new Set();
-        this.pendingCandidateTimers = new Map();
         this.onOpenConnection = () => { };
         this.onCloseConnection = () => { };
         this.onEncapsulated = () => { };
     }
     async handleCandidate(signal) {
         const conn = this.connections.get(signal.connectionId);
-        if (!conn || !this.remoteDescriptionReady.has(signal.connectionId)) {
-            this.queueCandidate(signal);
-            return;
-        }
-        try {
+        if (conn) {
             conn.rtcConnection.addRemoteCandidate(signal.data, '0');
         }
-        catch (error) {
-            this.queueCandidate(signal, formatCandidateError(error));
-        }
-    }
-    queueCandidate(signal, reason = 'connection is not ready') {
-        const candidates = this.pendingCandidates.get(signal.connectionId) || [];
-        candidates.push({ signal, attempts: 0 });
-        this.pendingCandidates.set(signal.connectionId, candidates);
-        debugFn('Queued ICE candidate', signal.connectionId, reason);
-        this.schedulePendingCandidateFlush(signal.connectionId);
-    }
-    schedulePendingCandidateFlush(connectionId) {
-        if (this.pendingCandidateTimers.has(connectionId))
-            return;
-        const timer = setTimeout(() => {
-            this.pendingCandidateTimers.delete(connectionId);
-            this.flushPendingCandidates(connectionId);
-        }, PENDING_CANDIDATE_RETRY_MS);
-        timer.unref?.();
-        this.pendingCandidateTimers.set(connectionId, timer);
-    }
-    flushPendingCandidates(connectionId) {
-        const candidates = this.pendingCandidates.get(connectionId);
-        if (!candidates?.length)
-            return;
-        const conn = this.connections.get(connectionId);
-        const remaining = [];
-        for (const candidate of candidates) {
-            if (!conn || !this.remoteDescriptionReady.has(connectionId)) {
-                this.requeueCandidate(candidate, remaining, 'connection is not ready');
-                continue;
-            }
-            try {
-                conn.rtcConnection.addRemoteCandidate(candidate.signal.data, '0');
-            }
-            catch (error) {
-                this.requeueCandidate(candidate, remaining, formatCandidateError(error));
-            }
-        }
-        if (remaining.length) {
-            this.pendingCandidates.set(connectionId, remaining);
-            this.schedulePendingCandidateFlush(connectionId);
-        }
         else {
-            this.pendingCandidates.delete(connectionId);
-        }
-    }
-    requeueCandidate(candidate, remaining, reason) {
-        if (candidate.attempts >= MAX_PENDING_CANDIDATE_ATTEMPTS) {
-            debugFn('Dropping ICE candidate after retries', candidate.signal.connectionId, reason);
-            return;
+            debugFn('Received candidate for unknown connection', signal);
         }
-        remaining.push({
-            signal: candidate.signal,
-            attempts: candidate.attempts + 1,
-        });
     }
     async handleOffer(signal) {
         if (!this.signaling.credentials) {
@@ -109,7 +44,7 @@ class Server {
         const connection = new connection_1.Connection(this, signal.connectionId, rtcConnection);
         this.connections.set(signal.connectionId, connection);
         rtcConnection.onLocalCandidate(candidate => {
-            this.signaling.write(new struct_1.SignalStructure(struct_1.SignalType.CandidateAdd, signal.connectionId, candidate, signal.networkId));
+            this.signaling.write(new struct_1.SignalStructure(struct_1.SignalType.CandidateAdd, signal.connectionId, candidate, signal.networkId, signal.pmsgId));
         });
         rtcConnection.onDataChannel(channel => {
             if (channel.getLabel() === 'ReliableDataChannel')
@@ -120,34 +55,25 @@ class Server {
         rtcConnection.onIceStateChange(state => {
             if (state === 'connected')
                 this.onOpenConnection(connection);
-            if (state === 'disconnected') {
-                this.remoteDescriptionReady.delete(signal.connectionId);
-                this.pendingCandidates.delete(signal.connectionId);
+            if (state === 'disconnected')
                 this.onCloseConnection(signal.connectionId, 'disconnected');
-            }
         });
         rtcConnection.setRemoteDescription(signal.data, 'offer');
-        this.remoteDescriptionReady.add(signal.connectionId);
-        this.flushPendingCandidates(signal.connectionId);
         const answer = rtcConnection.localDescription();
         if (!answer) {
             throw new Error('No answer');
         }
-        this.signaling.write(new struct_1.SignalStructure(struct_1.SignalType.ConnectResponse, signal.connectionId, answer.sdp, signal.networkId));
+        this.signaling.write(new struct_1.SignalStructure(struct_1.SignalType.ConnectResponse, signal.connectionId, answer.sdp, signal.networkId, signal.pmsgId));
     }
     async listen() {
         await this.signaling.connect();
         this.signaling.on('signal', (signal) => {
             switch (signal.type) {
                 case struct_1.SignalType.ConnectRequest:
-                    this.handleOffer(signal).catch(error => {
-                        debugFn('Failed to handle connect offer', signal, error);
-                    });
+                    this.handleOffer(signal);
                     break;
                 case struct_1.SignalType.CandidateAdd:
-                    this.handleCandidate(signal).catch(error => {
-                        debugFn('Failed to handle ICE candidate', signal, error);
-                    });
+                    this.handleCandidate(signal);
                     break;
                 default:
                     debugFn('Received signal for unknown type', signal);
@@ -155,18 +81,9 @@ class Server {
         });
     }
     close() {
-        for (const timer of this.pendingCandidateTimers.values()) {
-            clearTimeout(timer);
-        }
-        this.pendingCandidateTimers.clear();
-        this.pendingCandidates.clear();
-        this.remoteDescriptionReady.clear();
         for (const conn of this.connections.values()) {
             conn.close();
         }
     }
 }
 exports.Server = Server;
-function formatCandidateError(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/options.d.ts

@@ -1,7 +1,6 @@
 import { CompressionAlgorithm } from './transforms/framer';
 export type Options = {
     version: string;
-    signalingMode: 'rpc' | 'legacy';
     autoInitPlayer: boolean;
     offline: boolean;
     connectTimeout: number;
@@ -10,5 +9,14 @@ export type Options = {
     compressionThreshold: number;
     protocolVersion: number;
 };
-export declare const CURRENT_VERSION = "1.26.20";
-export declare const defaultOptions: Options;
+export declare const CURRENT_VERSION = "1.26.30";
+export declare const defaultOptions: {
+    version: string;
+    autoInitPlayer: boolean;
+    offline: boolean;
+    connectTimeout: number;
+    compressionAlgorithm: CompressionAlgorithm;
+    compressionLevel: number;
+    compressionThreshold: number;
+    protocolVersion: number;
+};

package/dist/options.js

@@ -3,11 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultOptions = exports.CURRENT_VERSION = void 0;
 const framer_1 = require("./transforms/framer");
 // Currently supported verson. Note, clients with newer versions can still connect as long as data is in minecraft-data
-exports.CURRENT_VERSION = '1.26.20';
+exports.CURRENT_VERSION = '1.26.30';
 exports.defaultOptions = {
     // https://minecraft.wiki/w/Protocol_version#Bedrock_Edition_2
     version: exports.CURRENT_VERSION,
-    signalingMode: 'rpc',
     // client: If we should send SetPlayerInitialized to the server after getting play_status spawn.
     // if this is disabled, no 'spawn' event will be emitted, you should manually set
     // client.status to ClientStatus.Initialized after sending the init packet.
@@ -23,5 +22,5 @@ exports.defaultOptions = {
     // server: If true, only compress if a payload is larger than compressionThreshold
     compressionThreshold: 512,
     // server and client: The protocol version to use
-    protocolVersion: 975,
+    protocolVersion: 1001,
 };