@4players/odin-plugin-web 1.0.0-alpha.14 → 1.0.0-alpha.16

package/lib/plugin/medias/audio-capture.js

@@ -0,0 +1,206 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { success } from '@4players/odin-common';
+import { Silence } from '../../worker/common';
+import { logger } from '../index';
+import { createCaptureWorker } from '../../worker';
+import { openCaptureDevice, stopMediaStream, enumerateDevices, } from '../deviceManager';
+const defaultVad = {
+    voiceActivity: {
+        attackThreshold: 0.9,
+        releaseThreshold: 0.8,
+    },
+    volumeGate: {
+        attackThreshold: -30,
+        releaseThreshold: -40,
+    },
+};
+const defaultApm = {
+    echoCanceller: false,
+    highPassFilter: false,
+    preAmplifier: false,
+    captureLevelAdjustment: false,
+    noiseSuppression: 'None',
+    transientSuppressor: false,
+    gainController: false,
+};
+export class AudioCapture {
+    get vad() {
+        return this._Vad;
+    }
+    get apm() {
+        return this._Apm;
+    }
+    get volume() {
+        return this._Volume;
+    }
+    get activity() {
+        var _a, _b;
+        return (_b = (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.activity) !== null && _b !== void 0 ? _b : Silence;
+    }
+    get speechProbability() {
+        var _a, _b;
+        return (_b = (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.speechProbability) !== null && _b !== void 0 ? _b : 0;
+    }
+    get deviceId() {
+        var _a, _b;
+        return (_b = (_a = this._DeviceParameters) === null || _a === void 0 ? void 0 : _a.device) === null || _b === void 0 ? void 0 : _b.device.deviceId;
+    }
+    constructor(controller, parameters) {
+        this.controller = controller;
+        this._Medias = new Map();
+        this._Vad = defaultVad;
+        this._Apm = defaultApm;
+        this._Volume = 1;
+        this._DeviceCb = () => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const devices = yield enumerateDevices();
+            const isListed = devices.some((device) => {
+                var _a, _b;
+                return (device.device.deviceId ===
+                    ((_b = (_a = this._DeviceParameters) === null || _a === void 0 ? void 0 : _a.device) === null || _b === void 0 ? void 0 : _b.device.deviceId));
+            });
+            if (!isListed) {
+                (_b = (_a = this._DeviceParameters) === null || _a === void 0 ? void 0 : _a.onStatusChanged) === null || _b === void 0 ? void 0 : _b.call(_a, 'stopped');
+                navigator.mediaDevices.removeEventListener('devicechange', this._DeviceCb);
+            }
+        });
+        if (parameters.apm) {
+            this.setApm(parameters.apm);
+        }
+        if (parameters.vad) {
+            this.setVad(parameters.vad);
+        }
+        if (parameters.volume) {
+            this.setVolume(parameters.volume);
+        }
+    }
+    start(room, media, uid) {
+        var _a;
+        let entry = this._Medias.get(media.connectionId);
+        if (entry === undefined) {
+            this._Medias.set(media.connectionId, (entry = new Set()));
+        }
+        if (entry.has(media.mediaId))
+            return;
+        entry.add(media.mediaId);
+        if (((_a = room.mainConnection) === null || _a === void 0 ? void 0 : _a.id) === media.connectionId) {
+            room
+                .typedRequest('StartMedia', {
+                media_id: media.mediaId,
+                properties: { kind: 'audio', uid },
+            })
+                .catch((reason) => console.error(`StartMedia got rejected; ${reason}`));
+        }
+        this._UpdateMedias();
+    }
+    stop(room, media) {
+        var _a;
+        const entry = this._Medias.get(media.connectionId);
+        if (!(entry === null || entry === void 0 ? void 0 : entry.delete(media.mediaId)))
+            return;
+        if (((_a = room.mainConnection) === null || _a === void 0 ? void 0 : _a.id) === media.connectionId) {
+            room
+                .typedRequest('StopMedia', { media_id: media.mediaId })
+                .catch((reason) => console.error(`StopMedia got rejected; ${reason}`));
+        }
+        this._UpdateMedias();
+    }
+    setVad(value) {
+        this._Vad = value;
+        if (this._Capture) {
+            this._Capture.worker.setVad(value);
+        }
+    }
+    setApm(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._Apm = config;
+            if (this._DeviceParameters) {
+                yield this.setDevice(this._DeviceParameters);
+            }
+        });
+    }
+    setDevice(parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            logger.debug(['Device'], 'AudioCapture.setDevice() parameters: ', parameters);
+            const rollbackParams = this._DeviceParameters;
+            this._DeviceParameters = parameters;
+            if (this._Volume === 'muted') {
+                return;
+            }
+            const device = yield openCaptureDevice(this.controller, parameters, this._Apm);
+            if (device.type !== 'Success') {
+                logger.error([
+                    'Device',
+                    `AudioCapture.setDevice() Unable to open capture device; ${device.reason}`,
+                ]);
+                this._DeviceParameters = rollbackParams;
+                return;
+            }
+            if (this._DeviceParameters.onStatusChanged) {
+                navigator.mediaDevices.addEventListener('devicechange', this._DeviceCb);
+            }
+            if (this._Capture !== undefined) {
+                stopMediaStream(this._Capture.source.mediaStream);
+                this._Capture.source.disconnect(this._Capture.worker.worklet);
+            }
+            if (this._Capture === undefined ||
+                this._Capture.worker.worklet.context !== device.value.context) {
+                (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.close();
+                this._Capture = {
+                    worker: yield createCaptureWorker(device.value.context, this.controller.sink),
+                    source: device.value,
+                };
+                yield this._UpdateMedias();
+                this.setVolume(this.volume);
+                this.setVad(this.vad);
+            }
+            else {
+                this._Capture.source = device.value;
+            }
+            this._Capture.source.connect(this._Capture.worker.worklet);
+            return success();
+        });
+    }
+    setVolume(value) {
+        var _a;
+        this._Volume = value;
+        if (value === 'muted') {
+            this.close();
+        }
+        else {
+            if (!this._Capture && this._DeviceParameters) {
+                this.setDevice(this._DeviceParameters);
+            }
+            (_a = this._Capture) === null || _a === void 0 ? void 0 : _a.worker.setVolume(value);
+        }
+    }
+    close() {
+        if (this._Capture !== undefined) {
+            this._Capture.worker.close();
+            stopMediaStream(this._Capture.source.mediaStream);
+            this._Capture.source.disconnect(this._Capture.worker.worklet);
+            this.controller.audioContexts.release(this._Capture.source.context);
+        }
+        navigator.mediaDevices.removeEventListener('devicechange', this._DeviceCb);
+        this._Capture = undefined;
+    }
+    _UpdateMedias() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._Capture !== undefined) {
+                const connections = Array.from(this._Medias).map(([key, value]) => {
+                    return { id: key, mediaIds: Array.from(value) };
+                });
+                this._Capture.worker.setMedias(connections);
+            }
+        });
+    }
+}

package/lib/plugin/medias/audio-playback.d.ts

@@ -0,0 +1,13 @@
+import { Backend } from '@4players/odin-common';
+import { GlobalMediaId, MediaController } from '../mediaController';
+export declare class AudioPlayback implements Backend.AudioPlayback {
+    readonly controller: MediaController;
+    readonly uid: Backend.UID;
+    get volume(): Backend.Volume;
+    get activity(): Backend.Activity;
+    constructor(controller: MediaController, uid: Backend.UID);
+    start(id: GlobalMediaId): void;
+    stop(id: GlobalMediaId): void;
+    setVolume(value: Backend.Volume): void;
+    close(): void;
+}

package/lib/plugin/medias/audio-playback.js

@@ -0,0 +1,24 @@
+export class AudioPlayback {
+    get volume() {
+        return this.controller.playbackGetVolume(this.uid);
+    }
+    get activity() {
+        return this.controller.playbackGetActivity(this.uid);
+    }
+    constructor(controller, uid) {
+        this.controller = controller;
+        this.uid = uid;
+    }
+    start(id) {
+        this.controller.playbackStart(this.uid, id);
+    }
+    stop(id) {
+        this.controller.playbackStop(this.uid, id);
+    }
+    setVolume(value) {
+        this.controller.playbackSetVolume(this.uid, value);
+    }
+    close() {
+        this.controller.closePlayback(this.uid);
+    }
+}

package/lib/plugin/medias/video-capture.d.ts

@@ -0,0 +1,15 @@
+import { GlobalMediaId, MediaController } from '../mediaController';
+import { Backend } from '@4players/odin-common';
+import { RoomConnection } from '../roomConnection';
+export declare class VideoCapture implements Backend.VideoCapture {
+    readonly controller: MediaController;
+    readonly customType?: string | undefined;
+    private _mediaStream?;
+    private readonly _Medias;
+    constructor(controller: MediaController, customType?: string | undefined);
+    get mediaStream(): MediaStream | undefined;
+    setDevice(ms: MediaStream): Promise<void>;
+    start(room: RoomConnection, media: GlobalMediaId, uid: Backend.UID): void;
+    stop(room: RoomConnection, media: GlobalMediaId): void;
+    close(): void;
+}

package/lib/plugin/medias/video-capture.js

@@ -0,0 +1,70 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { stopMediaStream } from '../deviceManager';
+export class VideoCapture {
+    constructor(controller, customType) {
+        this.controller = controller;
+        this.customType = customType;
+        this._Medias = new Map();
+    }
+    get mediaStream() {
+        return this._mediaStream;
+    }
+    setDevice(ms) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // @TODO: Stop old ms before
+            this._mediaStream = ms;
+        });
+    }
+    start(room, media, uid) {
+        var _a;
+        console.log('Eyvor VideoCapture start()');
+        let entry = this._Medias.get(media.connectionId);
+        if (entry === undefined) {
+            this._Medias.set(media.connectionId, (entry = new Set()));
+        }
+        if (entry.has(media.mediaId))
+            return;
+        entry.add(media.mediaId);
+        if (((_a = room.mainConnection) === null || _a === void 0 ? void 0 : _a.id) === media.connectionId) {
+            const properties = {
+                kind: 'video',
+                codec: 'VP8',
+                uid,
+            };
+            if (this.customType) {
+                properties.customType = this.customType;
+            }
+            room
+                .typedRequest('StartMedia', {
+                media_id: media.mediaId,
+                properties,
+            })
+                .catch((reason) => console.error(`StartMedia got rejected; ${reason}`));
+        }
+    }
+    stop(room, media) {
+        var _a;
+        if (this._mediaStream) {
+            stopMediaStream(this._mediaStream);
+        }
+        const entry = this._Medias.get(media.connectionId);
+        if (!(entry === null || entry === void 0 ? void 0 : entry.delete(media.mediaId)))
+            return;
+        if (((_a = room.mainConnection) === null || _a === void 0 ? void 0 : _a.id) === media.connectionId) {
+            room
+                .typedRequest('StopMedia', { media_id: media.mediaId })
+                .catch((reason) => console.error(`StopMedia got rejected; ${reason}`));
+        }
+    }
+    close() {
+        throw new Error('Method not implemented.');
+    }
+}

package/lib/plugin/medias/video-playback.d.ts

@@ -0,0 +1,13 @@
+import { Backend } from '@4players/odin-common';
+export declare class VideoPlayback implements Backend.VideoPlayback {
+    readonly uid: Backend.UID;
+    readonly customType?: string | undefined;
+    private _mediaStream?;
+    constructor(uid: Backend.UID, customType?: string | undefined);
+    /**
+     * Sets the MediaStream once.
+     */
+    setMediaStream(ms?: MediaStream): void;
+    get mediaStream(): MediaStream | undefined;
+    close(): void;
+}

package/lib/plugin/medias/video-playback.js

@@ -0,0 +1,20 @@
+export class VideoPlayback {
+    constructor(uid, customType) {
+        this.uid = uid;
+        this.customType = customType;
+    }
+    /**
+     * Sets the MediaStream once.
+     */
+    setMediaStream(ms) {
+        if (this._mediaStream)
+            return;
+        this._mediaStream = ms;
+    }
+    get mediaStream() {
+        return this._mediaStream;
+    }
+    close() {
+        throw new Error('Method not implemented.');
+    }
+}

package/lib/plugin/roomConnection.d.ts

@@ -2,13 +2,16 @@ import { Backend, RoomCommands, Result, Infer } from '@4players/odin-common';
 import { ConnectionPool } from './connectionPool';
 import { MainConnection } from './mainConnection';
 import { Token } from './token';
-export declare class RoomConnection {
+import Transport = Backend.Transport;
+export declare class RoomConnection implements RoomConnection {
     readonly connectionPool: ConnectionPool;
+    readonly transport: Transport;
     readonly onEvent: Backend.OnEvent;
     readonly gateway: URL | undefined;
     readonly roomId: string;
     private _RoomConnection;
     private _MainConnection;
+    private _OwnPeerId;
     private readonly _Close;
     private _Token;
     private _UserData;
@@ -22,7 +25,7 @@ export declare class RoomConnection {
     get position(): [number, number, number];
     get closed(): boolean;
     get mainConnection(): MainConnection | undefined;
-    constructor(connectionPool: ConnectionPool, onEvent: Backend.OnEvent, gateway: URL | undefined, token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]);
+    constructor(connectionPool: ConnectionPool, transport: Transport, onEvent: Backend.OnEvent, gateway: URL | undefined, token: Token, roomId: string, userData: Uint8Array, position: [number, number, number]);
     request(name: string, properties: unknown): Promise<Result<unknown> | 'closed'>;
     typedRequest<Name extends Extract<keyof RoomCommands, string>>(name: Name, properties: Infer<RoomCommands[Name]['request']>): Promise<Result<Infer<RoomCommands[Name]['response']>> | 'closed'>;
     close(): void;

package/lib/plugin/roomConnection.js

@@ -7,10 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Selector, failure, sleep, success, RoomCommandsRpc, } from '@4players/odin-common';
-import { RpcConnection } from './rpcConnection';
+import { Selector, failure, sleep, success, RoomCommandsRpc, RoomNotificationsRpc, } from '@4players/odin-common';
 import { Token } from './token';
-import { ConnectTimeout, MinTokenLifetime, MinTokenRefreshInterval, } from './config';
+import { ConnectTimeout, logger, MinTokenLifetime, MinTokenRefreshInterval, } from './config';
 export class RoomConnection {
     get token() {
         return this._Token;
@@ -27,8 +26,9 @@ export class RoomConnection {
     get mainConnection() {
         return this._MainConnection;
     }
-    constructor(connectionPool, onEvent, gateway, token, roomId, userData, position) {
+    constructor(connectionPool, transport, onEvent, gateway, token, roomId, userData, position) {
         this.connectionPool = connectionPool;
+        this.transport = transport;
         this.onEvent = onEvent;
         this.gateway = gateway;
         this.roomId = roomId;
@@ -42,7 +42,7 @@ export class RoomConnection {
         this._Token = token;
         this._UserData = userData;
         this._Position = position;
-        this._Main().then(({ reason }) => console.debug(`room closed; ${reason}`));
+        this._Main().then(({ reason }) => logger.info(['Connection'], `RoomConnection: Main() resolved; ${reason}`));
     }
     request(name, properties) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -79,11 +79,12 @@ export class RoomConnection {
         return Math.max(earliest, latest);
     }
     _Main() {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             let closeReason = 'unable to establish connection';
             /// as long as we are asked to continue
             while (this._Close.signal.aborted === false) {
+                logger.debug(['Connection', 'RoomConnection._Main() loop']);
                 const result = yield this._ConnectToServer();
                 if (result.type === 'Failure') {
                     closeReason = result.reason;
@@ -92,6 +93,7 @@ export class RoomConnection {
                 (_a = this._RoomConnection) === null || _a === void 0 ? void 0 : _a.close();
                 this._RoomConnection = undefined;
                 this._MainConnection = undefined;
+                this._OwnPeerId = undefined;
                 // can the token be used to request a better token from a gateway?
                 if (this.gateway !== undefined && this._Token.hasAudience('gateway')) {
                     this._ChangeStatus('Joining', `requesting new token from ${this.gateway}`);
@@ -128,20 +130,20 @@ export class RoomConnection {
             while (token.upstream !== undefined) {
                 token = token.upstream;
             }
-            if (!token.hasAudience('sfu') || token.address === undefined) {
+            if (!token.hasAudience('sfu') || token.claims.adr === undefined) {
                 return success('continue');
             }
-            this._ChangeStatus('Joining', `connecting to ${token.address}`);
+            this._ChangeStatus('Joining', `connecting to ${token.claims.adr}`);
             // are we already connected to the server?
             if (this._MainConnection === undefined ||
                 this._MainConnection.closed ||
-                this._MainConnection.url !== token.address) {
+                this._MainConnection.address !== token.claims.adr) {
                 // no? release the not fitting connection
                 if (this._MainConnection) {
                     this.connectionPool.releaseConnection(this._MainConnection);
                 }
                 // connect to the right server
-                const mainConnection = yield this.connectionPool.acquireConnection(token.address, this._Close.signal);
+                const mainConnection = yield this.connectionPool.acquireConnection(this.transport, token.claims.adr, this._Close.signal);
                 if (mainConnection === 'closed')
                     return failure('connection pool closed'); // connection pool is closed
                 if (mainConnection.type === 'Failure') {
@@ -153,6 +155,7 @@ export class RoomConnection {
                     return success('continue');
                 }
                 this._MainConnection = mainConnection.value;
+                this._OwnPeerId = undefined;
             }
             // join room
             const result = yield Promise.race([
@@ -165,20 +168,22 @@ export class RoomConnection {
             if (result === 'closed')
                 return failure('room connection closed'); // room connection was closed
             if (result !== 'timeout') {
-                const [websocket] = result;
-                if (websocket === 'closed')
+                const [rpc] = result;
+                if (rpc === 'closed')
                     return success('continue'); // connection was lost, before joinRoom finished
-                if (websocket.type === 'Failure') {
+                if (rpc.type === 'Failure') {
                     // join was rejected by the server
-                    return failure(`unable to join room; ${websocket.reason}`);
+                    return failure(`unable to join room; ${rpc.reason}`);
                 }
                 // room connection is open, make it available
-                this._RoomConnection = new RpcConnection(websocket.value);
-                this._ChangeStatus('Joined', `joined room ${this.roomId} on ${websocket.value.url}`);
+                this._RoomConnection = rpc.value;
+                this._ChangeStatus('Joined', `joined ${this.roomId}`);
                 // TODO(sven): handle this
-                // await this._MainConnection.webRtcReady()
-                // process room events
-                yield this._HandleConnection(this._MainConnection, websocket.value);
+                this._MainConnection
+                    .waitForConnected()
+                    .catch((error) => console.error('main connection failed to connect', error));
+                // Handle the open connection until it gets closed
+                yield this._HandleConnection(this._MainConnection);
             }
             // try to reconnect
             return success('continue');
@@ -191,14 +196,15 @@ export class RoomConnection {
         };
         this.onEvent('RoomStatusChanged', properties);
     }
-    _HandleConnection(main, webSocket) {
+    _HandleConnection(main) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (this._RoomConnection === undefined)
                 return;
             const selector = new Selector([
                 () => sleep(this.renewTokenIn, 'renewToken'),
                 () => sleep(500, 'tick'),
-                () => __awaiter(this, void 0, void 0, function* () { var _a; return yield ((_a = this._RoomConnection) === null || _a === void 0 ? void 0 : _a.recv()); }),
+                () => __awaiter(this, void 0, void 0, function* () { var _b; return yield ((_b = this._RoomConnection) === null || _b === void 0 ? void 0 : _b.recv()); }),
                 () => this._Closed,
                 () => main.closePromise,
             ]);
@@ -207,10 +213,11 @@ export class RoomConnection {
                 switch (value) {
                     case undefined:
                     case 'closed':
-                        webSocket.close();
+                        logger.debug(['Connection'], 'RoomConnection._HandleConnection: closed');
+                        (_a = this._RoomConnection) === null || _a === void 0 ? void 0 : _a.close();
                         return;
                     case 'renewToken':
-                        this._RenewToken(main, webSocket);
+                        this._RenewToken();
                         break;
                     case 'tick':
                         break;
@@ -222,12 +229,23 @@ export class RoomConnection {
         });
     }
     _HandleEvent(event) {
+        if (event.name === 'RoomUpdated') {
+            const roomUpdated = RoomNotificationsRpc.RoomUpdated.safeParse(event.properties);
+            if (!roomUpdated.success)
+                return;
+            for (const update of roomUpdated.data.updates) {
+                switch (update.kind) {
+                    case 'Joined':
+                        this._OwnPeerId = update.own_peer_id;
+                        break;
+                }
+            }
+        }
         this.onEvent(event.name, event.properties);
     }
     _HandleRequests(name, properties, response) {
         switch (name) {
-            case 'SetPeerPosition':
-                // eslint-disable-next-line no-case-declarations
+            case 'SetPeerPosition': {
                 const setPeerPosition = RoomCommandsRpc.SetPeerPosition.request.safeParse(properties);
                 if (setPeerPosition.success) {
                     const value = setPeerPosition.data.position;
@@ -237,8 +255,8 @@ export class RoomConnection {
                     console.warn('unable to process SetPeerPosition command');
                 }
                 break;
-            case 'UpdatePeer':
-                // eslint-disable-next-line no-case-declarations
+            }
+            case 'UpdatePeer': {
                 const updatePeer = RoomCommandsRpc.UpdatePeer.request.safeParse(properties);
                 if (updatePeer.success) {
                     this._UserData = updatePeer.data.user_data;
@@ -247,28 +265,33 @@ export class RoomConnection {
                     console.warn('unable to process UpdatePeer command');
                 }
                 break;
+            }
         }
     }
-    _RenewToken(main, webSocket) {
+    _RenewToken() {
         return __awaiter(this, void 0, void 0, function* () {
             this._LastTokenRenew = performance.now();
             if (this.token.timeLeft > MinTokenLifetime)
                 return;
-            const response = yield main.getReconnectToken(webSocket);
+            if (this._MainConnection === undefined || this._OwnPeerId === undefined) {
+                return failure('connection is not established');
+            }
+            const response = yield this._MainConnection.getReconnectToken(this._OwnPeerId);
             if (response.type === 'Success') {
                 if (response.value.timeLeft > this._Token.timeLeft) {
                     this._Token = response.value;
                 }
+                return success();
             }
             else {
-                console.warn(`${main.url} rejected reconnect token request; ${response.reason}`);
+                return failure(`${this._MainConnection.address} rejected reconnect token request; ${response.reason}`);
             }
         });
     }
 }
 function contactGateway(gateway, token, signal) {
-    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
         try {
             const response = yield fetch(gateway, {
                 body: '{"jsonrpc":"2.0","id":1,"method":"Connect","params":{}}',

package/lib/plugin/rpcConnection.d.ts

@@ -8,15 +8,17 @@ export interface RpcRequest {
     timeoutId: ReturnType<typeof setTimeout> | undefined;
 }
 export declare class RpcConnection {
-    readonly webSocket: WebSocket;
+    private readonly stream;
     private readonly _SendQueue;
     private readonly _RecvQueue;
+    private readonly _EventQueue;
     private readonly _Requests;
     private readonly _Close;
+    private readonly _Writer;
     private _NextId;
     get closed(): boolean;
     get closeSignal(): AbortSignal;
-    constructor(webSocket: WebSocket);
+    constructor(stream: WebSocket | WebTransportBidirectionalStream);
     request(name: string, properties: unknown): Promise<Result<unknown> | 'closed'>;
     request(name: string, properties: unknown, timeout: number): Promise<Result<unknown> | 'closed' | 'timeout'>;
     notify(name: string, properties: unknown): void;
@@ -25,7 +27,7 @@ export declare class RpcConnection {
     private _TimeoutRequest;
     private _Send;
     private _OnWebSocketOpen;
-    private _OnWebSocketMessage;
+    private _OnRpcMessage;
     private _OnResponse;
     private _OnEvent;
     private _Cleanup;
@@ -37,14 +39,18 @@ export interface TypedRpcMessage<Name extends string, Properties> extends RpcMes
 export type RealizedEvents<E extends Notifications> = {
     [Name in Extract<keyof E, string>]: TypedRpcMessage<Name, Infer<E[Name]>>;
 }[Extract<keyof E, string>];
-export declare class TypedRpcConnection<C extends Commands, E extends Notifications> extends RpcConnection {
-    readonly _Commands: C;
-    readonly _Events: E;
-    constructor(webSocket: WebSocket, _Commands: C, _Events: E);
+export declare class TypedRpcConnection<C extends Commands, E extends Notifications> {
+    readonly rpcConnection: RpcConnection;
+    private readonly _Commands;
+    private readonly _Events;
+    get closed(): boolean;
+    get closeSignal(): AbortSignal;
+    constructor(rpcConnection: RpcConnection, _Commands: C, _Events: E);
     request<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>): Promise<Result<Infer<C[Name]['response']>> | 'closed'>;
     request<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>, timeout: number): Promise<Result<Infer<C[Name]['response']>> | 'closed' | 'timeout'>;
     notify<Name extends Extract<keyof C, string>>(name: Name, properties: Infer<C[Name]['request']>): void;
     recv(): Promise<RealizedEvents<E> | 'closed'>;
+    close(): void;
 }
 export declare function parseRpc(buffer: ArrayBuffer): Result<MessagePackRpc>;
 export declare function parseRpcMessage<E extends Notifications>(events: E, rpc: RpcMessage): RealizedEvents<E> | undefined;