@4players/odin-plugin-web 1.0.0-alpha.11 → 1.0.0-alpha.13

package/lib/plugin/audioController.d.ts

@@ -1,9 +1,7 @@
 import { Backend, Strand } from '@4players/odin-common';
-import { DeviceParameters } from '.';
+import { DeviceParameters } from './index';
 import { RoomConnection } from './roomConnection';
 import { CaptureSink, PlaybackId, PlaybackWorker } from '../worker/common';
-export type Volume = Backend.Volume;
-export type Activity = Backend.Activity;
 export type CreateAudioPlaybackParameters = Backend.CreateAudioPlaybackParameters;
 export type CreateAudioCaptureParameters = Backend.CreateAudioCaptureParameters & {
     readonly device?: Device;
@@ -38,7 +36,7 @@ export declare class AudioController {
     globalVolume: number;
     playbacks: Map<string, {
         id: GlobalMediaId | undefined;
-        volume: Volume;
+        volume: Backend.Volume;
         playback: AudioPlayback;
     }>;
     setPlaybackStrand: Strand;
@@ -58,9 +56,9 @@ export declare class AudioController {
     playbackSetGlobalVolume(value: Backend.Volume): void;
     playbackStart(uid: string, id: GlobalMediaId): void;
     playbackStop(uid: string, id: GlobalMediaId): void;
-    playbackGetActivity(uid: string): Activity;
-    playbackSetVolume(uid: string, volume: Volume): void;
-    playbackGetVolume(uid: string): Volume;
+    playbackGetActivity(uid: string): Backend.Activity;
+    playbackSetVolume(uid: string, volume: Backend.Volume): void;
+    playbackGetVolume(uid: string): Backend.Volume;
     closePlayback(uid: string): void;
     close(): void;
 }
@@ -95,6 +93,7 @@ export declare class AudioCapture implements Backend.AudioCapture {
     get volume(): Backend.Volume;
     get activity(): import("../worker/common").Activity;
     get speechProbability(): number;
+    get deviceId(): string | undefined;
     constructor(controller: AudioController, parameters: CreateAudioCaptureParameters);
     start(room: RoomConnection, media: GlobalMediaId, uid: Backend.UID): void;
     stop(room: RoomConnection, media: GlobalMediaId): void;

package/lib/plugin/audioController.js

@@ -8,8 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Strand, assert, failure, sleep, success, } from '@4players/odin-common';
-import { Silence, } from '../worker/common';
 import { createCaptureWorker, createPlaybackWorker } from '../worker';
+import { Silence, } from '../worker/common';
 const defaultVad = {
     voiceActivity: {
         attackThreshold: 0.9,
@@ -337,6 +337,10 @@ export class AudioCapture {
         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();
@@ -401,13 +405,19 @@ export class AudioCapture {
     setDevice(parameters) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            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') {
                 console.error(`unable to open capture device; ${device.reason}`);
+                this._deviceParameters = rollbackParams;
                 return;
             }
-            this._deviceParameters = parameters;
             if (this._Capture !== undefined) {
+                stopMediaStream(this._Capture.source.mediaStream);
                 this._Capture.source.disconnect(this._Capture.worker.worklet);
             }
             if (this._Capture === undefined ||
@@ -462,7 +472,7 @@ export class AudioCapture {
     }
 }
 function stopMediaStream(ms) {
-    ms.getTracks().forEach(track => {
+    ms.getTracks().forEach((track) => {
         track.stop();
         ms.removeTrack(track);
     });

package/lib/plugin/connectionPool.d.ts

@@ -1,5 +1,5 @@
-import { DatagramHandler, MainConnection } from './mainConnection';
 import { Result } from '@4players/odin-common';
+import { DatagramHandler, MainConnection } from './mainConnection';
 export declare class ConnectionPool {
     readonly onDatagram: DatagramHandler;
     private _LastConnectionId;

package/lib/plugin/connectionPool.js

@@ -7,9 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { failure, nextTick, success } from '@4players/odin-common';
 import { ClockJumpCheckInterval, ClockJumpThreshold } from './config';
 import { MainConnection } from './mainConnection';
-import { failure, nextTick, success } from '@4players/odin-common';
 export class ConnectionPool {
     get closed() {
         return this._Close.signal.aborted;

package/lib/plugin/index.d.ts

@@ -1,9 +1,7 @@
-import { ConnectionPool } from './connectionPool';
 import { Backend } from '@4players/odin-common';
-import { AudioCapture, AudioContextFactory, AudioPlayback, CreateAudioCaptureParameters, CreateAudioPlaybackParameters, Device, Volume } from './audioController';
+import { AudioCapture, AudioContextFactory, AudioPlayback, CreateAudioCaptureParameters, CreateAudioPlaybackParameters, Device } from './audioController';
+import { ConnectionPool } from './connectionPool';
 import { MainConnection } from './mainConnection';
-export type Media = Backend.Media;
-export type JoinRoomParameters = Backend.JoinRoomParameters;
 export interface DeviceParameters {
     readonly device?: Device;
     onStatusChanged?: Backend.OnStatusChanged;
@@ -17,11 +15,11 @@ export declare class WebPlugin implements Backend.Plugin {
     get playbackVolume(): Backend.Volume;
     static create(audioContextFactory: AudioContextFactory): Promise<WebPlugin>;
     private constructor();
-    joinRoom(parameters: JoinRoomParameters): Room;
+    joinRoom(parameters: Backend.JoinRoomParameters): Room;
     createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
     createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
     enumerateDevices(): Promise<Device[]>;
-    setOutputVolume(volume: Volume): void;
+    setOutputVolume(volume: Backend.Volume): void;
     setOutputDevice(device: DeviceParameters): Promise<void>;
     close(): void;
 }
@@ -34,10 +32,10 @@ export declare class Room implements Backend.Room {
     private readonly _Peers;
     private readonly _AvailableMediaIds;
     get mainConnection(): MainConnection | undefined;
-    constructor(id: number, connectionPool: ConnectionPool, parameters: JoinRoomParameters);
+    constructor(id: number, connectionPool: ConnectionPool, parameters: Backend.JoinRoomParameters);
     request(method: string, properties: unknown): Promise<unknown>;
-    link(media: Media): void;
-    unlink(media: Media): void;
+    link(media: Backend.Media): void;
+    unlink(media: Backend.Media): void;
     close(): void;
     private _HandleEvent;
     private _HandleKnownEvent;

package/lib/plugin/index.js

@@ -7,12 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { assert, unwrap, RoomNotificationsRpc, generateUUID, } from '@4players/odin-common';
+import { AudioCapture, AudioContextCollection, AudioController, AudioPlayback, } from './audioController';
 import { ConnectionPool } from './connectionPool';
 import { RoomConnection } from './roomConnection';
-import { assert, unwrap, parseRpcMessage, RoomNotificationsRpc, } from '@4players/odin-common';
+import { parseRpcMessage } from './rpcConnection';
 import { Token } from './token';
-import { AudioCapture, AudioContextCollection, AudioController, AudioPlayback, } from './audioController';
-import * as uuid from 'uuid';
 export class WebPlugin {
     get playbackVolume() {
         return this._PlaybackVolume;
@@ -115,7 +115,7 @@ export class Room {
                         mediaId,
                     }
                     : undefined,
-                uid: uuid.v4(),
+                uid: generateUUID(),
             };
             this._Captures.set(media, entry);
             if (entry.media !== undefined) {
@@ -256,7 +256,7 @@ export class Room {
         const peer = this._Peers.get(peerId);
         if (peer === undefined || media.properties.kind !== 'audio')
             return;
-        const uid = String((_a = media.properties.uid) !== null && _a !== void 0 ? _a : uuid.v4());
+        const uid = String((_a = media.properties.uid) !== null && _a !== void 0 ? _a : generateUUID());
         console.log(`uuid ${media.properties.uid} ${uid}`);
         media.properties.uid = uid; // feed the uid back, so it can be seen be seen down the chain.
         const entry = (_b = this._Playbacks.get(uid)) !== null && _b !== void 0 ? _b : {

package/lib/plugin/mainConnection.d.ts

@@ -1,13 +1,12 @@
-import { TypedRpcConnection } from './rpcConnection';
-import { Token } from './token';
 import { MainCommands, MainNotifications, Result } from '@4players/odin-common';
-type RpcConnection = TypedRpcConnection<MainCommands, MainNotifications>;
+import { Token } from './token';
+import { TypedRpcConnection } from './rpcConnection';
 export type DatagramHandler = (connectionId: number, datagram: Uint8Array) => void;
 export declare class MainConnection {
     readonly id: number;
     readonly url: URL;
     readonly onDatagram: DatagramHandler;
-    readonly connection: RpcConnection;
+    readonly connection: TypedRpcConnection<MainCommands, MainNotifications>;
     readonly webRtc: RTCPeerConnection;
     static create(id: number, url: URL, onDatagram: DatagramHandler, signal: AbortSignal): Promise<Result<MainConnection>>;
     private readonly _AudioChannel;
@@ -36,4 +35,3 @@ export declare class MainConnection {
     private _OnIceCandidate;
     private _CleanUp;
 }
-export {};

package/lib/plugin/mainConnection.js

@@ -8,10 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { HealthCheckTimeout, MainConnectionPingInterval, WebRTCIceTimeout as WebRtcIceTimeout, WebRTCTimeout as WebRtcTimeout, } from './config';
-import { TypedRpcConnection, connect } from './rpcConnection';
-import { Token } from './token';
 import { MainCommandsRpc, MainNotificationsRpc, assert, extendUrl, failure, success, } from '@4players/odin-common';
+import { Token } from './token';
+import { TypedRpcConnection } from './rpcConnection';
+import { connect } from './websocket';
+import { HealthCheckTimeout, MainConnectionPingInterval, WebRTCIceTimeout as WebRtcIceTimeout, WebRTCTimeout as WebRtcTimeout, } from './config';
 export class MainConnection {
     static create(id, url, onDatagram, signal) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/plugin/roomConnection.d.ts

@@ -1,8 +1,7 @@
+import { Backend, RoomCommands, Result, Infer } from '@4players/odin-common';
 import { ConnectionPool } from './connectionPool';
 import { MainConnection } from './mainConnection';
 import { Token } from './token';
-import { Backend, RoomCommands, Result } from '@4players/odin-common';
-import * as z from 'zod';
 export declare class RoomConnection {
     readonly connectionPool: ConnectionPool;
     readonly onEvent: Backend.OnEvent;
@@ -14,6 +13,8 @@ export declare class RoomConnection {
     private _Token;
     private _UserData;
     private _Position;
+    private _ConnectionFailures;
+    private _FailureLimit;
     private _LastTokenRenew;
     private readonly _Closed;
     get token(): Token;
@@ -23,7 +24,7 @@ export declare class RoomConnection {
     get mainConnection(): MainConnection | undefined;
     constructor(connectionPool: ConnectionPool, 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: z.infer<RoomCommands[Name]['request']>): Promise<Result<z.infer<RoomCommands[Name]['response']>> | 'closed'>;
+    typedRequest<Name extends Extract<keyof RoomCommands, string>>(name: Name, properties: Infer<RoomCommands[Name]['request']>): Promise<Result<Infer<RoomCommands[Name]['response']>> | 'closed'>;
     close(): void;
     get renewTokenIn(): number;
     private _Main;

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 { Token } from './token';
-import { Selector, failure, sleep, success, RoomCommandsRpc, } from '@4players/odin-common';
-import * as z from 'zod';
 import { ConnectTimeout, MinTokenLifetime, MinTokenRefreshInterval, } from './config';
 export class RoomConnection {
     get token() {
@@ -34,6 +33,8 @@ export class RoomConnection {
         this.gateway = gateway;
         this.roomId = roomId;
         this._Close = new AbortController();
+        this._ConnectionFailures = 0;
+        this._FailureLimit = 5;
         this._LastTokenRenew = performance.now();
         this._Closed = new Promise((accept) => this._Close.signal.addEventListener('abort', () => accept('closed'), {
             once: true,
@@ -144,6 +145,10 @@ export class RoomConnection {
                 if (mainConnection === 'closed')
                     return failure('connection pool closed'); // connection pool is closed
                 if (mainConnection.type === 'Failure') {
+                    if (this._ConnectionFailures < this._FailureLimit) {
+                        this._ConnectionFailures++;
+                        return failure(`Connection failed; ${mainConnection.reason}`);
+                    }
                     this._ChangeStatus('Joining', `connection failed; ${mainConnection.reason}`);
                     return success('continue');
                 }
@@ -180,13 +185,11 @@ export class RoomConnection {
         });
     }
     _ChangeStatus(status, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const properties = {
-                status,
-                message,
-            };
-            this.onEvent('RoomStatusChanged', properties);
-        });
+        const properties = {
+            status,
+            message,
+        };
+        this.onEvent('RoomStatusChanged', properties);
     }
     _HandleConnection(main, webSocket) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -264,6 +267,7 @@ export class RoomConnection {
     }
 }
 function contactGateway(gateway, token, signal) {
+    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const response = yield fetch(gateway, {
@@ -275,24 +279,13 @@ function contactGateway(gateway, token, signal) {
                 },
                 signal,
             });
-            const schema = z.union([
-                z.object({
-                    result: z.object({
-                        token: z.string(),
-                    }),
-                }),
-                z.object({
-                    error: z.object({
-                        message: z.string(),
-                    }),
-                }),
-            ]);
-            const body = schema.parse(yield response.json());
+            // TODO: re-add validation once schemas are available in common
+            const body = yield response.json();
             if ('result' in body) {
                 return Token.parse(body.result.token);
             }
             else {
-                console.error(`gateway rejected token; ${body.error.message}`);
+                console.error(`gateway rejected token; ${(_b = (_a = body.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : 'malformed response'}`);
                 return success('rejected');
             }
         }

package/lib/plugin/rpcConnection.d.ts

@@ -1,7 +1,12 @@
-import * as z from 'zod';
-import { Result, RpcMessage } from '@4players/odin-common';
-export declare function connect(url: URL, signal: AbortSignal): Promise<Result<WebSocket>>;
-export declare function connectOnce(url: URL, signal: AbortSignal): Promise<Result<WebSocket>>;
+import { Result, Accept, MessagePackRpc, Notifications, Infer, Commands } from '@4players/odin-common';
+export interface RpcMessage {
+    name: string;
+    properties: unknown;
+}
+export interface RpcRequest {
+    accept: Accept<Result<unknown> | 'closed' | 'timeout'>;
+    timeoutId: ReturnType<typeof setTimeout> | undefined;
+}
 export declare class RpcConnection {
     readonly webSocket: WebSocket;
     private readonly _SendQueue;
@@ -25,24 +30,22 @@ export declare class RpcConnection {
     private _OnEvent;
     private _Cleanup;
 }
-export type Commands = Record<string, {
-    request: z.ZodTypeAny;
-    response: z.ZodTypeAny;
-}>;
-export type Events = Record<string, z.ZodTypeAny>;
 export interface TypedRpcMessage<Name extends string, Properties> extends RpcMessage {
     name: Name;
     properties: Properties;
 }
-export type RealizedEvents<E extends Events> = {
-    [Name in Extract<keyof E, string>]: TypedRpcMessage<Name, z.infer<E[Name]>>;
+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 Events> extends RpcConnection {
+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);
-    request<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): Promise<Result<z.infer<C[Name]['response']>> | 'closed'>;
-    request<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>, timeout: number): Promise<Result<z.infer<C[Name]['response']>> | 'closed' | 'timeout'>;
-    notify<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): void;
+    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'>;
 }
+export declare function parseRpc(buffer: ArrayBuffer): Result<MessagePackRpc>;
+export declare function parseRpcMessage<E extends Notifications>(events: E, rpc: RpcMessage): RealizedEvents<E> | undefined;
+export declare function isKnownRpcMessage<E extends Notifications>(events: E, name: string): name is Extract<keyof E, string>;

package/lib/plugin/rpcConnection.js

@@ -8,55 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import * as msgpack from '@msgpack/msgpack';
-import { failure, success, isKnownRpcMessage, parseRpc, parseRpcMessage, abortableSleep, } from '@4players/odin-common';
-import { ConnectInterval } from './config';
-export function connect(url, signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        console.debug(`connecting to ${url}`);
-        const start = performance.now();
-        let connection = failure('no connection was attempted');
-        for (let failures = 0; failures < ConnectInterval.length && signal.aborted === false; failures++) {
-            const nextReconnectAt = start + whenToConnect(failures);
-            if ((yield abortableSleep(nextReconnectAt - performance.now(), signal)) ===
-                'aborted') {
-                return failure('aborted');
-            }
-            connection = yield connectOnce(url, signal);
-            if (connection.type === 'Success') {
-                return connection;
-            }
-        }
-        return connection;
-    });
-}
-export function connectOnce(url, signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let webSocket;
-        try {
-            webSocket = new WebSocket(url);
-        }
-        catch (reason) {
-            return failure(`unable to create websocket; ${reason}`);
-        }
-        const abort = new AbortController();
-        const onOpen = new Promise((accept) => webSocket.addEventListener('open', () => accept(success(webSocket)), {
-            signal: abort.signal,
-        }));
-        const onClose = new Promise((accept) => webSocket.addEventListener('close', (event) => accept(failure(event.reason)), { signal: abort.signal }));
-        const onAbort = new Promise((accept) => signal.addEventListener('abort', () => accept(failure('aborted')), {
-            signal: abort.signal,
-        }));
-        const result = yield Promise.race([onOpen, onClose, onAbort]);
-        abort.abort();
-        return result;
-    });
-}
-function whenToConnect(failures) {
-    const past_connects = ConnectInterval.slice(0, failures).reduce((a, b) => a + b, 0);
-    const interval = ConnectInterval[failures] * Math.random();
-    return past_connects + interval;
-}
+import { failure, success, msgpackEncode, msgpackDecode, MessagePackRpcSchema, } from '@4players/odin-common';
 export class RpcConnection {
     get closed() {
         return this._Close.signal.aborted;
@@ -120,7 +72,7 @@ export class RpcConnection {
         request.accept('timeout');
     }
     _Send(message) {
-        this.webSocket.send(msgpack.encode(message));
+        this.webSocket.send(msgpackEncode(message));
     }
     _OnWebSocketOpen(ev) {
         for (const data in this._SendQueue) {
@@ -232,3 +184,26 @@ export class TypedRpcConnection extends RpcConnection {
         });
     }
 }
+export function parseRpc(buffer) {
+    try {
+        return success(MessagePackRpcSchema.parse(msgpackDecode(buffer)));
+    }
+    catch (error) {
+        return failure(String(error));
+    }
+}
+export function parseRpcMessage(events, rpc) {
+    if (!isKnownRpcMessage(events, rpc.name))
+        return undefined;
+    const parsed = events[rpc.name].safeParse(rpc.properties);
+    if (!parsed.success) {
+        return undefined;
+    }
+    return {
+        name: rpc.name,
+        properties: parsed.data,
+    };
+}
+export function isKnownRpcMessage(events, name) {
+    return name in events;
+}

package/lib/plugin/token.d.ts

@@ -1,6 +1,4 @@
-import * as z from 'zod';
-import { TokenAudienceSchema, TokenClaimsSchema, Result } from '@4players/odin-common';
-export type TokenClaims = z.infer<typeof TokenClaimsSchema>;
+import { TokenAudienceSchema, TokenClaims, Result, Infer } from '@4players/odin-common';
 export declare class Token {
     readonly text: string;
     readonly claims: TokenClaims;
@@ -12,6 +10,6 @@ export declare class Token {
     get address(): URL | undefined;
     get upstream(): Token | undefined;
     get defaultRoomId(): string | undefined;
-    hasAudience(audience: z.infer<typeof TokenAudienceSchema>): boolean;
+    hasAudience(audience: Infer<typeof TokenAudienceSchema>): boolean;
     toString(): string;
 }

package/lib/plugin/token.js

@@ -24,13 +24,12 @@ export class Token {
     constructor(text, claims) {
         this.text = text;
         this.claims = claims;
-        const address = claims.adr;
-        if (address !== undefined) {
+        if (claims.adr !== undefined) {
             try {
-                this._Address = new URL(`wss://${address}`);
+                this._Address = new URL(`wss://${claims.adr}`);
             }
             catch (error) {
-                console.error(`address in token(${address}) can not be parsed; ${error}`);
+                console.error(`address in token(${claims.adr}) can not be parsed; ${error}`);
             }
         }
         if (claims.ups !== undefined) {

package/lib/plugin/websocket.d.ts

@@ -0,0 +1,3 @@
+import { Result } from '@4players/odin-common';
+export declare function connect(url: URL, signal: AbortSignal): Promise<Result<WebSocket>>;
+export declare function connectOnce(url: URL, signal: AbortSignal): Promise<Result<WebSocket>>;

package/lib/plugin/websocket.js

@@ -0,0 +1,56 @@
+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 { ConnectInterval } from './config';
+import { abortableSleep, failure, success, } from '@4players/odin-common';
+export function connect(url, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const start = performance.now();
+        let connection = failure('no connection was attempted');
+        for (let failures = 0; failures < ConnectInterval.length && signal.aborted === false; failures++) {
+            const nextReconnectAt = start + whenToConnect(failures);
+            if ((yield abortableSleep(nextReconnectAt - performance.now(), signal)) ===
+                'aborted') {
+                return failure('aborted');
+            }
+            connection = yield connectOnce(url, signal);
+            if (connection.type === 'Success') {
+                return connection;
+            }
+        }
+        return connection;
+    });
+}
+export function connectOnce(url, signal) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let webSocket;
+        try {
+            webSocket = new WebSocket(url);
+        }
+        catch (reason) {
+            return failure(`unable to create websocket; ${reason}`);
+        }
+        const abort = new AbortController();
+        const onOpen = new Promise((accept) => webSocket.addEventListener('open', () => accept(success(webSocket)), {
+            signal: abort.signal,
+        }));
+        const onClose = new Promise((accept) => webSocket.addEventListener('close', (event) => accept(failure(event.reason)), { signal: abort.signal }));
+        const onAbort = new Promise((accept) => signal.addEventListener('abort', () => accept(failure('aborted')), {
+            signal: abort.signal,
+        }));
+        const result = yield Promise.race([onOpen, onClose, onAbort]);
+        abort.abort();
+        return result;
+    });
+}
+function whenToConnect(failures) {
+    const past_connects = ConnectInterval.slice(0, failures).reduce((a, b) => a + b, 0);
+    const interval = ConnectInterval[failures] * Math.random();
+    return past_connects + interval;
+}