bedrock-portal-nethernet 2.5.0 → 2.6.0

package/README.md

@@ -1,12 +1,12 @@
-# BedrockPortalNethernet
-[![NPM version](https://img.shields.io/npm/v/bedrock-portal-nethernet.svg)](http://npmjs.com/package/bedrock-portal-nethernet)
-[![Discord](https://img.shields.io/badge/chat-on%20discord-brightgreen.svg)](https://discord.gg/KTyd9HWuBD)
-
-A simple server implementation for the Bedrock Edition Nethernet protocol used by [BedrockPortal](https://github.com/LucienHH/bedrock-portal). Join our [Discord](https://discord.com/invite/KTyd9HWuBD) for support.
-
-Based on bedrock-protocol but stripped down to only the necessary components for the Nethernet protocol.
-
-## Installation
-```shell
-npm install bedrock-portal-nethernet
+# BedrockPortalNethernet
+[![NPM version](https://img.shields.io/npm/v/bedrock-portal-nethernet.svg)](http://npmjs.com/package/bedrock-portal-nethernet)
+[![Discord](https://img.shields.io/badge/chat-on%20discord-brightgreen.svg)](https://discord.gg/KTyd9HWuBD)
+
+A simple server implementation for the Bedrock Edition Nethernet protocol used by [BedrockPortal](https://github.com/LucienHH/bedrock-portal). Join our [Discord](https://discord.com/invite/KTyd9HWuBD) for support.
+
+Based on bedrock-protocol but stripped down to only the necessary components for the Nethernet protocol.
+
+## Installation
+```shell
+npm install bedrock-portal-nethernet
 ```

package/dist/nethernet/identity.d.ts

@@ -5,5 +5,5 @@ export type ServerIdentity = {
 };
 export declare function createServerIdentity(): ServerIdentity;
 export declare function signServerIdentity(sdp: string, identity: ServerIdentity): Promise<string>;
-export declare function verifyIdentity(sdp: string): Promise<Buffer<ArrayBufferLike>>;
+export declare function verifyIdentity(sdp: string): Promise<NonSharedBuffer>;
 export declare function publicKeysEqual(encodedKey: string, expectedKey: Buffer): boolean;

package/dist/options.d.ts

@@ -9,7 +9,7 @@ export type Options = {
     compressionThreshold: number;
     protocolVersion: number;
 };
-export declare const CURRENT_VERSION = "1.26.40";
+export declare const CURRENT_VERSION = "1.26.45";
 export declare const defaultOptions: {
     version: string;
     autoInitPlayer: boolean;

package/dist/options.js

@@ -3,7 +3,7 @@ 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.40';
+exports.CURRENT_VERSION = '1.26.45';
 exports.defaultOptions = {
     // https://minecraft.wiki/w/Protocol_version#Bedrock_Edition_2
     version: exports.CURRENT_VERSION,
@@ -22,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: 2168,
+    protocolVersion: 2169,
 };

package/dist/protocol.js

@@ -3020,7 +3020,10 @@ exports.default = {
                                                                     },
                                                                     {
                                                                         name: 'filtered_custom_name',
-                                                                        type: 'string',
+                                                                        type: [
+                                                                            'option',
+                                                                            'string',
+                                                                        ],
                                                                     },
                                                                     {
                                                                         name: 'durability_correction',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bedrock-portal-nethernet",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "A simple server implementation for the Bedrock Edition Nethernet protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/signaling/codec.d.ts

@@ -1,7 +0,0 @@
-import { SignalEnvelope } from './envelope';
-import type { SignalInboxMessage, SignalOutboxMessage } from './transport';
-export declare class SignalCodec {
-    decodeMessage(message: SignalInboxMessage): SignalEnvelope | null;
-    encodeMessage(envelope: SignalEnvelope, networkId: bigint): SignalOutboxMessage;
-    private parseInnerMessage;
-}

package/dist/signaling/codec.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignalCodec = void 0;
-const crypto_1 = require("crypto");
-const envelope_1 = require("./envelope");
-const WEB_RTC_METHOD = 'Signaling_WebRtc_v1_0';
-class SignalCodec {
-    decodeMessage(message) {
-        const payload = this.parseInnerMessage(message.Message);
-        if (!payload || payload.method !== WEB_RTC_METHOD) {
-            return null;
-        }
-        try {
-            return envelope_1.SignalEnvelope.parse(payload.params.message, {
-                networkId: BigInt(payload.params.netherNetId),
-                playerId: message.From,
-            });
-        }
-        catch {
-            return null;
-        }
-    }
-    encodeMessage(envelope, networkId) {
-        return {
-            toPlayerId: envelope.peer.playerId,
-            messageId: (0, crypto_1.randomUUID)(),
-            message: JSON.stringify({
-                jsonrpc: '2.0',
-                method: WEB_RTC_METHOD,
-                params: {
-                    netherNetId: networkId.toString(),
-                    message: envelope.serialize(),
-                },
-            }),
-        };
-    }
-    parseInnerMessage(message) {
-        let payload;
-        try {
-            payload = JSON.parse(message);
-        }
-        catch {
-            return null;
-        }
-        if (!isJsonRpcSignalPayload(payload)) {
-            return null;
-        }
-        return payload;
-    }
-}
-exports.SignalCodec = SignalCodec;
-function isJsonRpcSignalPayload(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const payload = value;
-    if (typeof payload.jsonrpc !== 'string' || typeof payload.method !== 'string') {
-        return false;
-    }
-    if (!payload.params || typeof payload.params !== 'object') {
-        return false;
-    }
-    const params = payload.params;
-    return typeof params.netherNetId === 'string' && typeof params.message === 'string';
-}

package/dist/signaling/envelope.d.ts

@@ -1,20 +0,0 @@
-export declare const SignalType: {
-    readonly ConnectRequest: "CONNECTREQUEST";
-    readonly ConnectResponse: "CONNECTRESPONSE";
-    readonly CandidateAdd: "CANDIDATEADD";
-    readonly ConnectError: "CONNECTERROR";
-};
-export type SignalPeer = {
-    networkId: bigint;
-    playerId: string;
-};
-export declare class SignalEnvelope {
-    readonly type: string;
-    readonly connectionId: bigint;
-    readonly payload: string;
-    readonly peer: Readonly<SignalPeer>;
-    constructor(type: string, connectionId: bigint, payload: string, peer: SignalPeer);
-    serialize(): string;
-    reply(type: string, payload: string): SignalEnvelope;
-    static parse(message: string, peer: SignalPeer): SignalEnvelope | null;
-}

package/dist/signaling/envelope.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignalEnvelope = exports.SignalType = void 0;
-exports.SignalType = {
-    ConnectRequest: 'CONNECTREQUEST',
-    ConnectResponse: 'CONNECTRESPONSE',
-    CandidateAdd: 'CANDIDATEADD',
-    ConnectError: 'CONNECTERROR',
-};
-class SignalEnvelope {
-    type;
-    connectionId;
-    payload;
-    peer;
-    constructor(type, connectionId, payload, peer) {
-        this.type = type;
-        this.connectionId = connectionId;
-        this.payload = payload;
-        this.peer = Object.freeze({ ...peer });
-    }
-    serialize() {
-        const prefix = `${this.type} ${this.connectionId}`;
-        return this.payload.length > 0 ? `${prefix} ${this.payload}` : prefix;
-    }
-    reply(type, payload) {
-        return new SignalEnvelope(type, this.connectionId, payload, this.peer);
-    }
-    static parse(message, peer) {
-        const [type, rawConnectionId, ...payload] = message.split(' ');
-        if (!type || !rawConnectionId) {
-            return null;
-        }
-        try {
-            return new SignalEnvelope(type, BigInt(rawConnectionId), payload.join(' '), peer);
-        }
-        catch {
-            return null;
-        }
-    }
-}
-exports.SignalEnvelope = SignalEnvelope;

package/dist/signaling/jsonRpcSignalingTransport.d.ts

@@ -1,44 +0,0 @@
-export type SignalingInboxEntry = {
-    From: string;
-    Message: string;
-    Id: string;
-};
-export type SignalingOutboxEntry = {
-    toPlayerId: string;
-    messageId: string;
-    message: string;
-};
-export type TurnAuthResponse = {
-    TurnAuthServers?: Array<{
-        Urls: string[];
-        Username: string;
-        Password: string;
-    }>;
-};
-export type JsonRpcSignalingConnection = {
-    url: string;
-    headers: Record<string, string>;
-};
-export type JsonRpcSignalingCloseEvent = {
-    code: number;
-    reason: string;
-};
-export declare class JsonRpcSignalingTransport {
-    onInboxEntries: (entries: SignalingInboxEntry[]) => void;
-    onClose: (event: JsonRpcSignalingCloseEvent) => void;
-    onError: (error: Error) => void;
-    private ws;
-    private pingInterval;
-    private readonly rpc;
-    constructor();
-    get connected(): boolean;
-    connect(connection: JsonRpcSignalingConnection): Promise<void>;
-    close(code?: number, reason?: string): Promise<void>;
-    requestTurnAuth(): Promise<any>;
-    sendMessage(entry: SignalingOutboxEntry): Promise<void>;
-    private handleJsonRpcMessage;
-    private handleClose;
-    private startPingLoop;
-    private stopPingLoop;
-    private normalizeError;
-}

package/dist/signaling/jsonRpcSignalingTransport.js

@@ -1,174 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonRpcSignalingTransport = void 0;
-const crypto_1 = require("crypto");
-const debug_1 = __importDefault(require("debug"));
-const JSONBig = require("json-bigint");
-const json_rpc_2_0_1 = require("json-rpc-2.0");
-const ws_1 = require("ws");
-const TURN_AUTH_METHOD = 'Signaling_TurnAuth_v1_0';
-const RECEIVE_MESSAGE_METHOD = 'Signaling_ReceiveMessage_v1_0';
-const DELIVERY_NOTIFICATION_METHOD = 'Signaling_DeliveryNotification_V1_0';
-const PING_METHOD = 'System_Ping_v1_0';
-const PONG_METHOD = 'System_Pong_v1_0';
-const SEND_CLIENT_MESSAGE_METHOD = 'Signaling_SendClientMessage_v1_0';
-const debug = (0, debug_1.default)('bedrock-portal-nethernet');
-const json = JSONBig({ useNativeBigInt: true });
-class JsonRpcSignalingTransport {
-    onInboxEntries;
-    onClose;
-    onError;
-    ws;
-    pingInterval;
-    rpc;
-    constructor() {
-        this.onInboxEntries = () => { };
-        this.onClose = () => { };
-        this.onError = () => { };
-        this.ws = null;
-        this.pingInterval = null;
-        const server = new json_rpc_2_0_1.JSONRPCServer({
-            errorListener: (message, payload) => {
-                debug('JSON-RPC server error', message, payload);
-            },
-        });
-        server.addMethod(RECEIVE_MESSAGE_METHOD, (params) => {
-            const entries = Array.isArray(params) ? params : [params];
-            this.onInboxEntries(entries);
-        });
-        server.addMethod(PING_METHOD, () => { });
-        server.addMethod(PONG_METHOD, () => { });
-        server.addMethod(DELIVERY_NOTIFICATION_METHOD, () => { });
-        const client = new json_rpc_2_0_1.JSONRPCClient(async (payload) => {
-            if (this.ws?.readyState !== ws_1.WebSocket.OPEN) {
-                throw new Error('WebSocket not connected');
-            }
-            this.ws.send(json.stringify(payload));
-        }, () => (0, crypto_1.randomUUID)());
-        this.rpc = new json_rpc_2_0_1.JSONRPCServerAndClient(server, client, {
-            errorListener: (message, payload) => {
-                debug('JSON-RPC transport error', message, payload);
-            },
-        });
-    }
-    get connected() {
-        return this.ws?.readyState === ws_1.WebSocket.OPEN;
-    }
-    async connect(connection) {
-        if (this.ws?.readyState === ws_1.WebSocket.OPEN || this.ws?.readyState === ws_1.WebSocket.CONNECTING) {
-            throw new Error('JSON-RPC signaling transport already connected');
-        }
-        const ws = new ws_1.WebSocket(connection.url, {
-            headers: connection.headers,
-        });
-        this.ws = ws;
-        let opened = false;
-        await new Promise((resolve, reject) => {
-            ws.onopen = () => {
-                opened = true;
-                debug('JSON-RPC signaling websocket connected');
-                this.startPingLoop();
-                resolve();
-            };
-            ws.onmessage = (event) => {
-                this.handleJsonRpcMessage(event.data);
-            };
-            ws.onerror = (event) => {
-                const error = this.normalizeError(event);
-                debug('JSON-RPC signaling websocket error', error);
-                this.onError(error);
-                if (!opened) {
-                    reject(error);
-                }
-            };
-            ws.onclose = (event) => {
-                this.handleClose(ws, event.code, event.reason);
-                if (!opened) {
-                    reject(new Error(`JSON-RPC signaling transport closed with code ${event.code} and reason ${event.reason}`));
-                }
-            };
-        });
-    }
-    async close(code = 1000, reason = 'Normal Closure') {
-        const ws = this.ws;
-        this.stopPingLoop();
-        this.rpc.rejectAllPendingRequests('JSON-RPC signaling transport closed');
-        this.ws = null;
-        if (!ws) {
-            return;
-        }
-        ws.onmessage = null;
-        ws.onerror = null;
-        if (ws.readyState === ws_1.WebSocket.CLOSED) {
-            ws.onclose = null;
-            return;
-        }
-        await new Promise((resolve) => {
-            ws.onclose = () => resolve();
-            ws.close(code, reason);
-        });
-    }
-    async requestTurnAuth() {
-        return this.rpc.timeout(15000).request(TURN_AUTH_METHOD, {}, undefined);
-    }
-    async sendMessage(entry) {
-        await this.rpc.timeout(15000).request(SEND_CLIENT_MESSAGE_METHOD, entry, undefined);
-    }
-    handleJsonRpcMessage(data) {
-        if (typeof data !== 'string') {
-            debug('Received non-string JSON-RPC message', data);
-            return;
-        }
-        let payload;
-        try {
-            payload = json.parse(data);
-        }
-        catch (err) {
-            debug('Received invalid JSON-RPC message', err);
-            return;
-        }
-        debug('Received JSON-RPC message', payload);
-        void this.rpc.receiveAndSend(payload, undefined, undefined).catch((err) => {
-            debug('Failed to handle JSON-RPC message', err);
-        });
-    }
-    handleClose(ws, code, reason) {
-        debug(`JSON-RPC signaling websocket closed with code ${code} and reason ${reason}`);
-        if (this.ws === ws) {
-            this.ws = null;
-        }
-        this.stopPingLoop();
-        this.rpc.rejectAllPendingRequests('JSON-RPC signaling transport closed');
-        this.onClose({ code, reason });
-    }
-    startPingLoop() {
-        this.stopPingLoop();
-        this.pingInterval = setInterval(() => {
-            if (!this.connected) {
-                return;
-            }
-            void Promise.resolve(this.rpc.timeout(15000).request(PING_METHOD, [], undefined)).catch((err) => {
-                debug('JSON-RPC signaling ping failed', err);
-            });
-        }, 5000);
-    }
-    stopPingLoop() {
-        if (this.pingInterval) {
-            clearInterval(this.pingInterval);
-            this.pingInterval = null;
-        }
-    }
-    normalizeError(event) {
-        if (event.error instanceof Error) {
-            return event.error;
-        }
-        if (typeof event.message === 'string' && event.message.length > 0) {
-            return new Error(event.message);
-        }
-        return new Error('JSON-RPC signaling websocket error');
-    }
-}
-exports.JsonRpcSignalingTransport = JsonRpcSignalingTransport;

package/dist/signaling/route.d.ts

@@ -1,15 +0,0 @@
-export type SignalRoute = {
-    remoteNetworkId: bigint;
-    remotePmsgId: string | null;
-};
-export type PartialSignalRoute = {
-    remoteNetworkId?: bigint | null;
-    remotePmsgId?: string | null;
-};
-export declare function createSignalRoute(remoteNetworkId?: bigint | null, remotePmsgId?: string | null): SignalRoute;
-export declare function mergeSignalRoute(primary: PartialSignalRoute, fallback?: PartialSignalRoute): SignalRoute;
-export declare function readSignalRoute(obj: Record<string, unknown>, networkIdKeys: string[], playerIdKeys: string[]): PartialSignalRoute;
-export declare function getStringValue(obj: Record<string, unknown>, keys: string[]): string | null;
-export declare function getBigIntValue(obj: Record<string, unknown>, keys: string[]): bigint | null;
-export declare function getRouteIdValue(obj: Record<string, unknown>, keys: string[]): string | null;
-export declare function parseJwtPayload(token: string): Record<string, unknown> | null;

package/dist/signaling/route.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSignalRoute = createSignalRoute;
-exports.mergeSignalRoute = mergeSignalRoute;
-exports.readSignalRoute = readSignalRoute;
-exports.getStringValue = getStringValue;
-exports.getBigIntValue = getBigIntValue;
-exports.getRouteIdValue = getRouteIdValue;
-exports.parseJwtPayload = parseJwtPayload;
-function createSignalRoute(remoteNetworkId = null, remotePmsgId = null) {
-    return {
-        remoteNetworkId: remoteNetworkId ?? 0n,
-        remotePmsgId,
-    };
-}
-function mergeSignalRoute(primary, fallback = {}) {
-    return createSignalRoute(primary.remoteNetworkId ?? fallback.remoteNetworkId ?? null, primary.remotePmsgId ?? fallback.remotePmsgId ?? null);
-}
-function readSignalRoute(obj, networkIdKeys, playerIdKeys) {
-    return {
-        remoteNetworkId: getBigIntValue(obj, networkIdKeys),
-        remotePmsgId: getRouteIdValue(obj, playerIdKeys),
-    };
-}
-function getStringValue(obj, keys) {
-    for (const key of keys) {
-        const value = obj[key];
-        if (typeof value === 'string') {
-            return value;
-        }
-    }
-    return null;
-}
-function getBigIntValue(obj, keys) {
-    for (const key of keys) {
-        const value = obj[key];
-        if (typeof value === 'bigint') {
-            return value;
-        }
-        if (typeof value === 'number' || typeof value === 'string') {
-            const bigIntValue = tryBigInt(value);
-            if (bigIntValue !== null) {
-                return bigIntValue;
-            }
-        }
-    }
-    return null;
-}
-function getRouteIdValue(obj, keys) {
-    for (const key of keys) {
-        const value = obj[key];
-        if (typeof value === 'string') {
-            return value;
-        }
-        if (typeof value === 'number' || typeof value === 'bigint') {
-            return String(value);
-        }
-    }
-    return null;
-}
-function parseJwtPayload(token) {
-    const [, payload] = token.split('.');
-    if (!payload) {
-        return null;
-    }
-    try {
-        return JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-function tryBigInt(value) {
-    try {
-        return BigInt(value);
-    }
-    catch {
-        return null;
-    }
-}

package/dist/signaling/signalingClient.d.ts

@@ -1,28 +0,0 @@
-import type { Authflow } from 'prismarine-auth';
-import type { IceServer } from 'node-datachannel';
-import { EventEmitter } from 'events';
-import { WebRtcSignal } from './webRtcSignal';
-export declare class SignalingClient extends EventEmitter {
-    readonly netherNetId: bigint;
-    localPlayerId: string | null;
-    iceServers: IceServer[] | null;
-    private readonly authflow;
-    private readonly version;
-    private readonly signalCodec;
-    private readonly transport;
-    private retryCount;
-    private closed;
-    private connectPromise;
-    private reconnectPromise;
-    constructor(authflow: Authflow, netherNetId: bigint, version: string);
-    connect(): Promise<void>;
-    close(): Promise<void>;
-    sendSignal(signal: WebRtcSignal): Promise<void>;
-    onSignal(listener: (signal: WebRtcSignal) => void): this;
-    onConnectionError(listener: (error: Error) => void): this;
-    private openSignalingSession;
-    private handleTransportClose;
-    private reconnect;
-    private assertOpen;
-    private emitConnectionError;
-}

package/dist/signaling/signalingClient.js

@@ -1,161 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignalingClient = void 0;
-const crypto_1 = require("crypto");
-const debug_1 = __importDefault(require("debug"));
-const events_1 = require("events");
-const webRtcSignalCodec_1 = require("./webRtcSignalCodec");
-const jsonRpcSignalingTransport_1 = require("./jsonRpcSignalingTransport");
-const turn_1 = require("./turn");
-const SIGNALING_SERVICE_URL = 'wss://signal.franchise.minecraft-services.net/ws/v1.0/messaging/connect';
-const SIGNAL_EVENT = 'signal';
-const CONNECTION_ERROR_EVENT = 'connectionError';
-const debug = (0, debug_1.default)('bedrock-portal-nethernet');
-class SignalingClient extends events_1.EventEmitter {
-    netherNetId;
-    localPlayerId;
-    iceServers;
-    authflow;
-    version;
-    signalCodec;
-    transport;
-    retryCount;
-    closed;
-    connectPromise;
-    reconnectPromise;
-    constructor(authflow, netherNetId, version) {
-        super();
-        this.authflow = authflow;
-        this.netherNetId = netherNetId;
-        this.version = version;
-        this.localPlayerId = null;
-        this.iceServers = null;
-        this.signalCodec = new webRtcSignalCodec_1.WebRtcSignalCodec();
-        this.transport = new jsonRpcSignalingTransport_1.JsonRpcSignalingTransport();
-        this.retryCount = 0;
-        this.closed = false;
-        this.connectPromise = null;
-        this.reconnectPromise = null;
-        this.transport.onInboxEntries = (entries) => {
-            for (const entry of entries) {
-                const signal = this.signalCodec.decodeSignal(entry);
-                if (!signal) {
-                    debug('Failed to decode WebRTC signaling message', entry);
-                    continue;
-                }
-                this.emit(SIGNAL_EVENT, signal);
-            }
-        };
-        this.transport.onClose = (event) => {
-            this.handleTransportClose(event);
-        };
-        this.transport.onError = (error) => {
-            debug('JSON-RPC signaling transport error', error);
-        };
-    }
-    async connect() {
-        if (this.transport.connected) {
-            throw new Error('Already connected to signaling service');
-        }
-        if (this.connectPromise) {
-            return this.connectPromise;
-        }
-        this.closed = false;
-        this.retryCount = 0;
-        const promise = this.openSignalingSession().finally(() => {
-            if (this.connectPromise === promise) {
-                this.connectPromise = null;
-            }
-        });
-        this.connectPromise = promise;
-        return promise;
-    }
-    async close() {
-        debug('Disconnecting from signaling service');
-        this.closed = true;
-        this.retryCount = 0;
-        this.iceServers = null;
-        this.localPlayerId = null;
-        await this.transport.close();
-    }
-    async sendSignal(signal) {
-        await this.transport.sendMessage(this.signalCodec.encodeSignal(signal, this.netherNetId));
-    }
-    onSignal(listener) {
-        this.on(SIGNAL_EVENT, listener);
-        return this;
-    }
-    onConnectionError(listener) {
-        this.on(CONNECTION_ERROR_EVENT, listener);
-        return this;
-    }
-    async openSignalingSession() {
-        this.assertOpen();
-        const xbl = await this.authflow.getMinecraftBedrockServicesToken({ version: this.version });
-        this.assertOpen();
-        this.localPlayerId = (0, turn_1.parseTokenSignalingPlayerId)(xbl.mcToken);
-        debug('Fetched XBL token for signaling service');
-        debug('Connecting to signaling service', SIGNALING_SERVICE_URL);
-        await this.transport.connect({
-            url: SIGNALING_SERVICE_URL,
-            headers: {
-                'Authorization': xbl.mcToken,
-                'session-id': this.localPlayerId ?? (0, crypto_1.randomUUID)(),
-                'request-id': (0, crypto_1.randomUUID)(),
-            },
-        });
-        this.assertOpen();
-        this.iceServers = (0, turn_1.parseIceServersFromTurnAuth)(await this.transport.requestTurnAuth());
-    }
-    handleTransportClose(event) {
-        debug(`Signaling service disconnected with code ${event.code} and reason ${event.reason}`);
-        this.iceServers = null;
-        if (this.closed) {
-            return;
-        }
-        if (event.code === 1006) {
-            if (this.retryCount >= 5) {
-                this.emitConnectionError(new Error('Signaling service connection closed unexpectedly'));
-                return;
-            }
-            this.retryCount += 1;
-            void this.reconnect().catch((err) => {
-                debug('Signaling service reconnect failed', err);
-                this.emitConnectionError(err);
-            });
-            return;
-        }
-        if (event.code !== 1000) {
-            this.emitConnectionError(new Error(`Signaling service connection closed with code ${event.code} and reason ${event.reason}`));
-        }
-    }
-    async reconnect() {
-        if (this.reconnectPromise) {
-            return this.reconnectPromise;
-        }
-        const promise = this.openSignalingSession().finally(() => {
-            if (this.reconnectPromise === promise) {
-                this.reconnectPromise = null;
-            }
-        });
-        this.reconnectPromise = promise;
-        return promise;
-    }
-    assertOpen() {
-        if (this.closed) {
-            throw new Error('Signaling client is closed');
-        }
-    }
-    emitConnectionError(err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        this.emit(CONNECTION_ERROR_EVENT, error);
-        if (this.listenerCount('error') > 0) {
-            this.emit('error', error);
-        }
-        return error;
-    }
-}
-exports.SignalingClient = SignalingClient;

package/dist/signaling/transport.d.ts

@@ -1,44 +0,0 @@
-export type SignalInboxMessage = {
-    From: string;
-    Message: string;
-    Id: string;
-};
-export type SignalOutboxMessage = {
-    toPlayerId: string;
-    messageId: string;
-    message: string;
-};
-export type TurnAuthResponse = {
-    TurnAuthServers?: Array<{
-        Urls: string[];
-        Username: string;
-        Password: string;
-    }>;
-};
-export type SignalTransportConnection = {
-    url: string;
-    headers: Record<string, string>;
-};
-export type SignalTransportCloseEvent = {
-    code: number;
-    reason: string;
-};
-export declare class SignalTransport {
-    onMessages: (messages: SignalInboxMessage[]) => void;
-    onClose: (event: SignalTransportCloseEvent) => void;
-    onError: (error: Error) => void;
-    private ws;
-    private pingInterval;
-    private readonly rpc;
-    constructor();
-    get connected(): boolean;
-    connect(connection: SignalTransportConnection): Promise<void>;
-    close(code?: number, reason?: string): Promise<void>;
-    requestTurnAuth(): Promise<any>;
-    sendClientMessage(message: SignalOutboxMessage): Promise<void>;
-    private handleMessage;
-    private handleClose;
-    private startPingLoop;
-    private stopPingLoop;
-    private normalizeError;
-}

package/dist/signaling/transport.js

@@ -1,174 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignalTransport = void 0;
-const crypto_1 = require("crypto");
-const debug_1 = __importDefault(require("debug"));
-const JSONBig = require("json-bigint");
-const json_rpc_2_0_1 = require("json-rpc-2.0");
-const ws_1 = require("ws");
-const TURN_AUTH_METHOD = 'Signaling_TurnAuth_v1_0';
-const RECEIVE_MESSAGE_METHOD = 'Signaling_ReceiveMessage_v1_0';
-const DELIVERY_NOTIFICATION_METHOD = 'Signaling_DeliveryNotification_V1_0';
-const PING_METHOD = 'System_Ping_v1_0';
-const PONG_METHOD = 'System_Pong_v1_0';
-const SEND_CLIENT_MESSAGE_METHOD = 'Signaling_SendClientMessage_v1_0';
-const debug = (0, debug_1.default)('bedrock-portal-nethernet');
-const json = JSONBig({ useNativeBigInt: true });
-class SignalTransport {
-    onMessages;
-    onClose;
-    onError;
-    ws;
-    pingInterval;
-    rpc;
-    constructor() {
-        this.onMessages = () => { };
-        this.onClose = () => { };
-        this.onError = () => { };
-        this.ws = null;
-        this.pingInterval = null;
-        const server = new json_rpc_2_0_1.JSONRPCServer({
-            errorListener: (message, payload) => {
-                debug('JSON-RPC server error', message, payload);
-            },
-        });
-        server.addMethod(RECEIVE_MESSAGE_METHOD, (params) => {
-            const messages = Array.isArray(params) ? params : [params];
-            this.onMessages(messages);
-        });
-        server.addMethod(PING_METHOD, () => { });
-        server.addMethod(PONG_METHOD, () => { });
-        server.addMethod(DELIVERY_NOTIFICATION_METHOD, () => { });
-        const client = new json_rpc_2_0_1.JSONRPCClient(async (payload) => {
-            if (this.ws?.readyState !== ws_1.WebSocket.OPEN) {
-                throw new Error('WebSocket not connected');
-            }
-            this.ws.send(json.stringify(payload));
-        }, () => (0, crypto_1.randomUUID)());
-        this.rpc = new json_rpc_2_0_1.JSONRPCServerAndClient(server, client, {
-            errorListener: (message, payload) => {
-                debug('JSON-RPC transport error', message, payload);
-            },
-        });
-    }
-    get connected() {
-        return this.ws?.readyState === ws_1.WebSocket.OPEN;
-    }
-    async connect(connection) {
-        if (this.ws?.readyState === ws_1.WebSocket.OPEN || this.ws?.readyState === ws_1.WebSocket.CONNECTING) {
-            throw new Error('Signal transport already connected');
-        }
-        const ws = new ws_1.WebSocket(connection.url, {
-            headers: connection.headers,
-        });
-        this.ws = ws;
-        let opened = false;
-        await new Promise((resolve, reject) => {
-            ws.onopen = () => {
-                opened = true;
-                debug('Signal websocket connected');
-                this.startPingLoop();
-                resolve();
-            };
-            ws.onmessage = (event) => {
-                this.handleMessage(event.data);
-            };
-            ws.onerror = (event) => {
-                const error = this.normalizeError(event);
-                debug('Signal websocket error', error);
-                this.onError(error);
-                if (!opened) {
-                    reject(error);
-                }
-            };
-            ws.onclose = (event) => {
-                this.handleClose(ws, event.code, event.reason);
-                if (!opened) {
-                    reject(new Error(`Signal transport closed with code ${event.code} and reason ${event.reason}`));
-                }
-            };
-        });
-    }
-    async close(code = 1000, reason = 'Normal Closure') {
-        const ws = this.ws;
-        this.stopPingLoop();
-        this.rpc.rejectAllPendingRequests('Signal transport closed');
-        this.ws = null;
-        if (!ws) {
-            return;
-        }
-        ws.onmessage = null;
-        ws.onerror = null;
-        if (ws.readyState === ws_1.WebSocket.CLOSED) {
-            ws.onclose = null;
-            return;
-        }
-        await new Promise((resolve) => {
-            ws.onclose = () => resolve();
-            ws.close(code, reason);
-        });
-    }
-    async requestTurnAuth() {
-        return this.rpc.timeout(15000).request(TURN_AUTH_METHOD, {}, undefined);
-    }
-    async sendClientMessage(message) {
-        await this.rpc.timeout(15000).request(SEND_CLIENT_MESSAGE_METHOD, message, undefined);
-    }
-    handleMessage(data) {
-        if (typeof data !== 'string') {
-            debug('Received non-string message', data);
-            return;
-        }
-        let payload;
-        try {
-            payload = json.parse(data);
-        }
-        catch (err) {
-            debug('Received invalid JSON-RPC message', err);
-            return;
-        }
-        debug('Received message', payload);
-        void this.rpc.receiveAndSend(payload, undefined, undefined).catch((err) => {
-            debug('Failed to handle JSON-RPC message', err);
-        });
-    }
-    handleClose(ws, code, reason) {
-        debug(`Signal websocket closed with code ${code} and reason ${reason}`);
-        if (this.ws === ws) {
-            this.ws = null;
-        }
-        this.stopPingLoop();
-        this.rpc.rejectAllPendingRequests('Signal transport closed');
-        this.onClose({ code, reason });
-    }
-    startPingLoop() {
-        this.stopPingLoop();
-        this.pingInterval = setInterval(() => {
-            if (!this.connected) {
-                return;
-            }
-            void Promise.resolve(this.rpc.timeout(15000).request(PING_METHOD, [], undefined)).catch((err) => {
-                debug('Signal ping failed', err);
-            });
-        }, 5000);
-    }
-    stopPingLoop() {
-        if (this.pingInterval) {
-            clearInterval(this.pingInterval);
-            this.pingInterval = null;
-        }
-    }
-    normalizeError(event) {
-        if (event.error instanceof Error) {
-            return event.error;
-        }
-        if (typeof event.message === 'string' && event.message.length > 0) {
-            return new Error(event.message);
-        }
-        return new Error('Signal websocket error');
-    }
-}
-exports.SignalTransport = SignalTransport;

package/dist/signaling/turn.d.ts

@@ -1,4 +0,0 @@
-import type { IceServer } from 'node-datachannel';
-import type { TurnAuthResponse } from './jsonRpcSignalingTransport';
-export declare function parseIceServersFromTurnAuth(data: TurnAuthResponse): IceServer[];
-export declare function parseTokenSignalingPlayerId(token: string): string | null;

package/dist/signaling/turn.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseIceServersFromTurnAuth = parseIceServersFromTurnAuth;
-exports.parseTokenSignalingPlayerId = parseTokenSignalingPlayerId;
-function parseIceServersFromTurnAuth(data) {
-    const servers = [];
-    for (const server of data.TurnAuthServers ?? []) {
-        for (const url of server.Urls ?? []) {
-            const parsed = parseIceServer(url);
-            if (!parsed) {
-                continue;
-            }
-            servers.push({
-                ...parsed,
-                username: server.Username,
-                password: server.Password,
-            });
-        }
-    }
-    return servers;
-}
-function parseTokenSignalingPlayerId(token) {
-    const jwt = token.split(' ')[1];
-    if (!jwt) {
-        return null;
-    }
-    const [, payload] = jwt.split('.');
-    if (!payload) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
-        return typeof parsed.pmid === 'string' ? parsed.pmid : null;
-    }
-    catch {
-        return null;
-    }
-}
-function parseIceServer(url) {
-    const normalizedUrl = normalizeIceServerUrl(url);
-    if (!normalizedUrl) {
-        return null;
-    }
-    try {
-        const parsed = new URL(normalizedUrl);
-        if (!parsed.hostname || !parsed.port) {
-            return null;
-        }
-        const port = Number.parseInt(parsed.port, 10);
-        if (Number.isNaN(port)) {
-            return null;
-        }
-        const relayType = resolveRelayType(parsed.protocol.slice(0, -1), parsed.searchParams.get('transport'));
-        return relayType
-            ? { hostname: parsed.hostname, port, relayType }
-            : { hostname: parsed.hostname, port };
-    }
-    catch {
-        return null;
-    }
-}
-function normalizeIceServerUrl(url) {
-    if (!/^(stun|turn|turns):/i.test(url)) {
-        return null;
-    }
-    return url.replace(/^([a-z]+):/i, '$1://');
-}
-function resolveRelayType(protocol, transport) {
-    if (protocol === 'stun') {
-        return undefined;
-    }
-    if (protocol === 'turns') {
-        return 'TurnTls';
-    }
-    const normalizedTransport = transport?.toLowerCase();
-    if (normalizedTransport === 'tcp') {
-        return 'TurnTcp';
-    }
-    if (normalizedTransport === 'tls') {
-        return 'TurnTls';
-    }
-    return 'TurnUdp';
-}

package/dist/signaling/webRtcSignal.d.ts

@@ -1,20 +0,0 @@
-export declare const WebRtcSignalType: {
-    readonly Offer: "CONNECTREQUEST";
-    readonly Answer: "CONNECTRESPONSE";
-    readonly IceCandidate: "CANDIDATEADD";
-    readonly Error: "CONNECTERROR";
-};
-export type SignalingPeer = {
-    netherNetId: bigint;
-    playerId: string;
-};
-export declare class WebRtcSignal {
-    readonly type: string;
-    readonly connectionId: bigint;
-    readonly payload: string;
-    readonly peer: Readonly<SignalingPeer>;
-    constructor(type: string, connectionId: bigint, payload: string, peer: SignalingPeer);
-    serialize(): string;
-    createReply(type: string, payload: string): WebRtcSignal;
-    static parse(message: string, peer: SignalingPeer): WebRtcSignal | null;
-}

package/dist/signaling/webRtcSignal.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebRtcSignal = exports.WebRtcSignalType = void 0;
-exports.WebRtcSignalType = {
-    Offer: 'CONNECTREQUEST',
-    Answer: 'CONNECTRESPONSE',
-    IceCandidate: 'CANDIDATEADD',
-    Error: 'CONNECTERROR',
-};
-class WebRtcSignal {
-    type;
-    connectionId;
-    payload;
-    peer;
-    constructor(type, connectionId, payload, peer) {
-        this.type = type;
-        this.connectionId = connectionId;
-        this.payload = payload;
-        this.peer = Object.freeze({ ...peer });
-    }
-    serialize() {
-        const prefix = `${this.type} ${this.connectionId}`;
-        return this.payload.length > 0 ? `${prefix} ${this.payload}` : prefix;
-    }
-    createReply(type, payload) {
-        return new WebRtcSignal(type, this.connectionId, payload, this.peer);
-    }
-    static parse(message, peer) {
-        const [type, rawConnectionId, ...payload] = message.split(' ');
-        if (!type || !rawConnectionId) {
-            return null;
-        }
-        try {
-            return new WebRtcSignal(type, BigInt(rawConnectionId), payload.join(' '), peer);
-        }
-        catch {
-            return null;
-        }
-    }
-}
-exports.WebRtcSignal = WebRtcSignal;

package/dist/signaling/webRtcSignalCodec.d.ts

@@ -1,7 +0,0 @@
-import { WebRtcSignal } from './webRtcSignal';
-import type { SignalingInboxEntry, SignalingOutboxEntry } from './jsonRpcSignalingTransport';
-export declare class WebRtcSignalCodec {
-    decodeSignal(entry: SignalingInboxEntry): WebRtcSignal | null;
-    encodeSignal(signal: WebRtcSignal, localNetherNetId: bigint): SignalingOutboxEntry;
-    private parseSignalPayload;
-}

package/dist/signaling/webRtcSignalCodec.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebRtcSignalCodec = void 0;
-const crypto_1 = require("crypto");
-const webRtcSignal_1 = require("./webRtcSignal");
-const WEB_RTC_SIGNAL_METHOD = 'Signaling_WebRtc_v1_0';
-class WebRtcSignalCodec {
-    decodeSignal(entry) {
-        const payload = this.parseSignalPayload(entry.Message);
-        if (!payload || payload.method !== WEB_RTC_SIGNAL_METHOD) {
-            return null;
-        }
-        try {
-            return webRtcSignal_1.WebRtcSignal.parse(payload.params.message, {
-                netherNetId: BigInt(payload.params.netherNetId),
-                playerId: entry.From,
-            });
-        }
-        catch {
-            return null;
-        }
-    }
-    encodeSignal(signal, localNetherNetId) {
-        return {
-            toPlayerId: signal.peer.playerId,
-            messageId: (0, crypto_1.randomUUID)(),
-            message: JSON.stringify({
-                jsonrpc: '2.0',
-                method: WEB_RTC_SIGNAL_METHOD,
-                params: {
-                    netherNetId: localNetherNetId.toString(),
-                    message: signal.serialize(),
-                },
-            }),
-        };
-    }
-    parseSignalPayload(message) {
-        let payload;
-        try {
-            payload = JSON.parse(message);
-        }
-        catch {
-            return null;
-        }
-        if (!isJsonRpcWebRtcSignalPayload(payload)) {
-            return null;
-        }
-        return payload;
-    }
-}
-exports.WebRtcSignalCodec = WebRtcSignalCodec;
-function isJsonRpcWebRtcSignalPayload(value) {
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    const payload = value;
-    if (typeof payload.jsonrpc !== 'string' || typeof payload.method !== 'string') {
-        return false;
-    }
-    if (!payload.params || typeof payload.params !== 'object') {
-        return false;
-    }
-    const params = payload.params;
-    return typeof params.netherNetId === 'string' && typeof params.message === 'string';
-}