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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4players/odin-plugin-web",
-  "version": "1.0.0-alpha.8",
+  "version": "1.0.0",
   "description": "A backend plugin providing the custom WebAssembly audio processing module for ODIN web clients",
   "homepage": "https://www.4players.io",
   "repository": {
@@ -8,40 +8,49 @@
     "url": "https://github.com/4Players/odin-sdk-web.git"
   },
   "license": "UNLICENSED",
-  "main": "lib/plugin/index.js",
-  "types": "lib/plugin/index.d.ts",
+  "main": "./lib/plugin/index.js",
+  "types": "./lib/plugin/index.d.ts",
   "scripts": {
-    "clean": "rm -rf build lib",
-    "configure": "emcmake cmake -B build -S .",
-    "build": "npm-run-all -s configure build:wasm build:plugin build:worker",
-    "build:plugin": "tsc",
-    "build:wasm": "emmake make -C build",
-    "build:worker": "ts-node src/build.ts && tsc -b ./tsconfig.worker.json",
-    "lint": "eslint . --ext .ts",
-    "test": "npm --prefix test run serve"
+    "clean": "rimraf .cache build lib dist",
+    "configure": "npm-run-all configure:*",
+    "configure:shared": "emcmake cmake -B build/shared -DCMAKE_BUILD_TYPE=Release -DSHARED_MEMORY=1 -S .",
+    "configure:unshared": "emcmake cmake -B build/unshared -DCMAKE_BUILD_TYPE=Release -S .",
+    "build": "npm-run-all -s configure build:genversion build:wasm build:bundle build:types",
+    "bundle": "npm run build && tsx ./esbuild.config.ts",
+    "build:genversion": "genversion -se src/common/version.ts",
+    "build:wasm": "npm-run-all -pl build:wasm:*",
+    "build:wasm:shared": "emmake cmake --build build/shared -j 8",
+    "build:wasm:unshared": "emmake cmake --build build/unshared -j 8",
+    "build:bundle": "ts-node src/bundle.ts",
+    "build:types": "dts-bundle-generator --fail-on-class --no-banner -o lib/plugin/index.d.ts src/plugin/index.ts",
+    "test": "npm-run-all -s test:*",
+    "test:install": "npm --prefix test install",
+    "test:start": "npm --prefix test start",
+    "format": "prettier 'src/**/*.ts' --write",
+    "lint": "eslint . --ext .ts"
   },
   "dependencies": {
-    "@4players/odin-common": "~1.3.0",
-    "@msgpack/msgpack": "~3.0.0-beta2",
-    "uuid": "~9.0.0",
-    "zod": "~3.22.0"
+    "@4players/odin-common": "~7.3.0",
+    "@4players/voice-filter": "~1.2.0",
+    "@msgpack/msgpack": "~3.1.0"
   },
   "devDependencies": {
-    "@types/node": "~20.10.0",
-    "@types/uuid": "~9.0.0",
-    "@typescript-eslint/eslint-plugin": "~6.18.0",
-    "@typescript-eslint/parser": "~6.18.0",
-    "esbuild": "~0.19.0",
-    "eslint": "~8.56.0",
+    "@types/node": "~22.16.0",
+    "@typescript-eslint/eslint-plugin": "~8.36.0",
+    "@typescript-eslint/parser": "~8.36.0",
+    "dts-bundle-generator": "~9.5.0",
+    "esbuild": "~0.25.0",
+    "eslint": "~8.57.0",
     "eslint-config-semistandard": "~17.0.0",
-    "eslint-plugin-import": "~2.29.0",
+    "eslint-plugin-import": "~2.32.0",
     "eslint-plugin-node": "~11.1.0",
-    "eslint-plugin-promise": "~6.1.0",
-    "npm-run-all2": "~6.1.0",
+    "eslint-plugin-promise": "~6.6.0",
+    "genversion": "~3.2.0",
+    "npm-run-all2": "~8.0.0",
+    "prettier": "~3.6.0",
+    "rimraf": "~6.0.0",
     "ts-node": "~10.9.0",
-    "typescript": "~5.3.0"
-  },
-  "workspaces": [
-    "test"
-  ]
+    "tsx": "^4.19.4",
+    "typescript": "~5.6.0"
+  }
 }

package/lib/plugin/audioController.d.ts

@@ -1,102 +0,0 @@
-import { Backend, Strand } from '@4players/odin-common';
-import { DeviceParameters } from '.';
-import { CaptureSink, PlaybackId, PlaybackWorker } from '../worker';
-import { RoomConnection } from './roomConnection';
-export type Volume = Backend.Volume;
-export type Activity = Backend.Activity;
-export type CreateAudioPlaybackParameters = Backend.CreateAudioPlaybackParameters;
-export type CreateAudioCaptureParameters = Backend.CreateAudioCaptureParameters & {
-    readonly device?: Device;
-};
-export type AudioContextFactory = (sampleRate: number | undefined) => Promise<AudioContext>;
-export interface GlobalMediaId extends PlaybackId {
-}
-declare global {
-    interface AudioSinkOptions {
-        type: 'none';
-    }
-    interface AudioContext {
-        setSinkId?: (sinkId: string | undefined | AudioSinkOptions) => Promise<undefined>;
-    }
-}
-export declare class AudioContextCollection {
-    readonly audioContextFactory: AudioContextFactory;
-    readonly entries: Array<{
-        sampleRate: undefined | number;
-        audioContext: AudioContext;
-        references: number;
-    }>;
-    constructor(audioContextFactory: AudioContextFactory);
-    acquire(sampleRate: number | undefined): Promise<AudioContext>;
-    release(audioContext: BaseAudioContext): Promise<void>;
-    close(): void;
-}
-export declare class AudioController {
-    readonly audioContexts: AudioContextCollection;
-    readonly sink: CaptureSink;
-    playbackWorker: PlaybackWorker | undefined;
-    globalVolume: number;
-    playbacks: Map<string, {
-        id: GlobalMediaId | undefined;
-        volume: Volume;
-        playback: AudioPlayback;
-    }>;
-    setPlaybackStrand: Strand;
-    create(audioContexts: AudioContextCollection, sink: CaptureSink): Promise<AudioController>;
-    constructor(audioContexts: AudioContextCollection, sink: CaptureSink);
-    receivePacket(connectionId: number, packet: Uint8Array): void;
-    createAudioPlayback(parameters: CreateAudioPlaybackParameters): Promise<AudioPlayback>;
-    createAudioCapture(parameters: CreateAudioCaptureParameters): Promise<AudioCapture>;
-    enumerateDevices(): Promise<Device[]>;
-    playbackSetDevice(device?: Device): Promise<void>;
-    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;
-    closePlayback(uid: string): void;
-    close(): void;
-}
-export declare class Device implements Backend.Device {
-    readonly device: MediaDeviceInfo;
-    readonly isDefault: boolean;
-    constructor(device: MediaDeviceInfo, isDefault?: boolean);
-    get type(): "AudioPlayback" | "AudioCapture";
-    get name(): string;
-}
-export declare class AudioPlayback implements Backend.AudioPlayback {
-    readonly controller: AudioController;
-    readonly uid: Backend.UID;
-    get volume(): Backend.Volume;
-    get activity(): Backend.Activity;
-    constructor(controller: AudioController, uid: Backend.UID);
-    start(id: GlobalMediaId): void;
-    stop(id: GlobalMediaId): void;
-    setVolume(value: Backend.Volume): void;
-    close(): void;
-}
-export declare class AudioCapture implements Backend.AudioCapture {
-    readonly controller: AudioController;
-    private _Capture;
-    private readonly _Medias;
-    private _Vad;
-    private _Apm;
-    private _Volume;
-    private _deviceParameters?;
-    get vad(): Backend.VadConfig;
-    get apm(): Backend.ApmConfig;
-    get volume(): Backend.Volume;
-    get activity(): import("../worker").Activity;
-    get speechProbability(): number;
-    constructor(controller: AudioController, parameters: CreateAudioCaptureParameters);
-    start(room: RoomConnection, media: GlobalMediaId, uid: Backend.UID): void;
-    stop(room: RoomConnection, media: GlobalMediaId): void;
-    setVad(value: Backend.VadConfig): void;
-    setApm(config: Backend.ApmConfig): Promise<void>;
-    setDevice(parameters: DeviceParameters): Promise<import("@4players/odin-common").Success<void> | undefined>;
-    setVolume(value: Backend.Volume): void;
-    close(): void;
-    _UpdateMedias(): Promise<void>;
-}
-//# sourceMappingURL=audioController.d.ts.map

package/lib/plugin/audioController.js

@@ -1,442 +0,0 @@
-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 { Strand, assert, failure, sleep, success, } from '@4players/odin-common';
-import { createCaptureWorker, createPlaybackWorker, silence, } from '../worker';
-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 AudioContextCollection {
-    constructor(audioContextFactory) {
-        this.audioContextFactory = audioContextFactory;
-        this.entries = [];
-    }
-    acquire(sampleRate) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const entry of this.entries) {
-                if (entry.sampleRate === sampleRate) {
-                    entry.references += 1;
-                    return entry.audioContext;
-                }
-                else if (entry.sampleRate === undefined) {
-                    const audioContext = entry.audioContext;
-                    if (audioContext.sampleRate === sampleRate) {
-                        entry.references += 1;
-                        return entry.audioContext;
-                    }
-                }
-            }
-            const entry = {
-                sampleRate,
-                audioContext: yield this.audioContextFactory(sampleRate),
-                references: 1,
-            };
-            this.entries.push(entry);
-            return entry.audioContext;
-        });
-    }
-    release(audioContext) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const index = this.entries.findIndex((entry) => entry.audioContext === audioContext);
-            if (index < 0)
-                return;
-            this.entries[index].references -= 1;
-            if (this.entries[index].references <= 0) {
-                const context = this.entries[index].audioContext;
-                this.entries.splice(index, 1);
-                yield context.close();
-            }
-        });
-    }
-    close() {
-        for (const entry of this.entries) {
-            entry.audioContext.close();
-        }
-    }
-}
-export class AudioController {
-    create(audioContexts, sink) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new AudioController(audioContexts, sink);
-        });
-    }
-    constructor(audioContexts, sink) {
-        this.audioContexts = audioContexts;
-        this.sink = sink;
-        this.globalVolume = 1;
-        this.playbacks = new Map();
-        this.setPlaybackStrand = new Strand();
-    }
-    receivePacket(connectionId, packet) {
-        var _a;
-        (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.receivePacket(connectionId, packet);
-    }
-    createAudioPlayback(parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let entry = this.playbacks.get(parameters.uid);
-            let volume = parameters.volume;
-            if (entry === undefined) {
-                volume = volume !== null && volume !== void 0 ? volume : 1;
-                const playback = new AudioPlayback(this, parameters.uid);
-                entry = { id: undefined, volume, playback };
-                this.playbacks.set(parameters.uid, entry);
-            }
-            if (volume !== undefined) {
-                entry.playback.setVolume(volume);
-            }
-            return entry.playback;
-        });
-    }
-    createAudioCapture(parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const capture = new AudioCapture(this, parameters);
-            yield capture.setDevice(parameters);
-            return capture;
-        });
-    }
-    enumerateDevices() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mediaDeviceInfos = yield navigator.mediaDevices.enumerateDevices();
-            const devices = [];
-            let outputDeviceIndex = 0;
-            let inputDeviceIndex = 0;
-            for (const mediaDeviceInfo of mediaDeviceInfos) {
-                if (mediaDeviceInfo.kind === 'audioinput') {
-                    if (inputDeviceIndex === 0) {
-                        devices.push(new Device(mediaDeviceInfo, true));
-                    }
-                    else {
-                        devices.push(new Device(mediaDeviceInfo, false));
-                    }
-                    inputDeviceIndex++;
-                }
-                if (mediaDeviceInfo.kind === 'audiooutput') {
-                    if (outputDeviceIndex === 0) {
-                        devices.push(new Device(mediaDeviceInfo, true));
-                    }
-                    else {
-                        devices.push(new Device(mediaDeviceInfo, false));
-                    }
-                    outputDeviceIndex++;
-                }
-            }
-            return devices;
-        });
-    }
-    playbackSetDevice(device) {
-        return this.setPlaybackStrand.enqueue(() => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            let deviceId = (_a = device === null || device === void 0 ? void 0 : device.device.deviceId) !== null && _a !== void 0 ? _a : '';
-            if (deviceId === 'default') {
-                deviceId = '';
-            }
-            let audioContext;
-            if (this.playbackWorker === undefined) {
-                audioContext = yield this.audioContexts.acquire(48000);
-                this.playbackWorker = yield createPlaybackWorker(audioContext);
-                this.playbackWorker.setGlobalVolume(this.globalVolume);
-            }
-            else {
-                audioContext = this.playbackWorker.audioContext;
-            }
-            if (audioContext.setSinkId !== undefined && device && audioContext.state === 'running') {
-                yield audioContext.setSinkId(deviceId);
-            }
-        }));
-    }
-    playbackSetGlobalVolume(value) {
-        var _a;
-        this.globalVolume = value === 'muted' ? 0 : value;
-        (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.setGlobalVolume(this.globalVolume);
-    }
-    playbackStart(uid, id) {
-        var _a;
-        const entry = this.playbacks.get(uid);
-        if (entry === undefined)
-            return;
-        if (entry.id !== undefined) {
-            this.playbackStop(uid, entry.id);
-        }
-        entry.id = id;
-        (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.addMedias(id.connectionId, [id.mediaId]);
-        this.playbackSetVolume(uid, entry.volume);
-    }
-    playbackStop(uid, id) {
-        var _a;
-        const entry = this.playbacks.get(uid);
-        if (entry === undefined)
-            return;
-        if (entry.id !== id)
-            console.error('playback mediaId out of sync!');
-        entry.id = undefined;
-        (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.removeMedias(id.connectionId, [id.mediaId]);
-    }
-    playbackGetActivity(uid) {
-        var _a, _b;
-        const entry = this.playbacks.get(uid);
-        if ((entry === null || entry === void 0 ? void 0 : entry.id) === undefined)
-            return silence;
-        return (_b = (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.getActivity(entry.id)) !== null && _b !== void 0 ? _b : silence;
-    }
-    playbackSetVolume(uid, volume) {
-        var _a;
-        const entry = this.playbacks.get(uid);
-        if (entry === undefined)
-            return;
-        entry.volume = volume === 'muted' ? 0 : volume;
-        if (entry.id !== undefined) {
-            (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.setVolume(entry.id, entry.volume);
-        }
-    }
-    playbackGetVolume(uid) {
-        var _a;
-        const entry = this.playbacks.get(uid);
-        return (_a = entry === null || entry === void 0 ? void 0 : entry.volume) !== null && _a !== void 0 ? _a : 1;
-    }
-    closePlayback(uid) {
-        const entry = this.playbacks.get(uid);
-        if (entry === undefined)
-            return;
-        if (entry.id !== undefined)
-            this.playbackStop(uid, entry.id);
-        this.playbacks.delete(uid);
-    }
-    close() {
-        var _a;
-        (_a = this.playbackWorker) === null || _a === void 0 ? void 0 : _a.close();
-        this.audioContexts.close();
-    }
-}
-export class Device {
-    constructor(device, isDefault = false) {
-        this.device = device;
-        this.isDefault = isDefault;
-    }
-    get type() {
-        switch (this.device.kind) {
-            case 'audioinput':
-                return 'AudioCapture';
-            case 'audiooutput':
-                return 'AudioPlayback';
-            default:
-                assert(false, 'not supported device');
-        }
-    }
-    get name() {
-        return this.device.label;
-    }
-}
-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);
-    }
-}
-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;
-    }
-    constructor(controller, parameters) {
-        this.controller = controller;
-        this._Medias = new Map();
-        this._Vad = defaultVad;
-        this._Apm = defaultApm;
-        this._Volume = 1;
-        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) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const device = yield openCaptureDevice(this.controller, parameters, this._Apm);
-            if (device.type !== 'Success') {
-                console.error(`unable to open capture device; ${device.reason}`);
-                return;
-            }
-            this._deviceParameters = parameters;
-            if (this._Capture !== undefined) {
-                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) {
-        this._Volume = value;
-        if (this._Capture) {
-            this._Capture.worker.setVolume(value === 'muted' ? 0 : value);
-        }
-    }
-    close() {
-        if (this._Capture !== undefined) {
-            this._Capture.worker.close();
-            this._Capture.source.disconnect(this._Capture.worker.worklet);
-            this.controller.audioContexts.release(this._Capture.source.context);
-        }
-        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);
-            }
-        });
-    }
-}
-function openCaptureDevice(controller, parameters, apm) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const deviceId = parameters.device
-            ? { exact: parameters.device.device.deviceId }
-            : undefined;
-        let stream;
-        try {
-            const result = yield Promise.race([
-                navigator.mediaDevices.getUserMedia({
-                    audio: {
-                        echoCancellation: apm.echoCanceller,
-                        noiseSuppression: apm.noiseSuppression !== 'None',
-                        autoGainControl: apm.gainController,
-                        // @ts-ignore chrome fix
-                        echoCancellationType: 'system',
-                        // sampleRate: 48000,
-                        deviceId,
-                    },
-                }),
-                sleep(30000, 'timeout'),
-            ]);
-            if (result === 'timeout')
-                return failure('getUserMedia; timeout');
-            stream = result;
-        }
-        catch (reason) {
-            return failure(`getUserMedia; ${reason}`);
-        }
-        const sampleRate = stream.getAudioTracks()[0].getSettings().sampleRate;
-        const context = yield controller.audioContexts.acquire(sampleRate);
-        return success(context.createMediaStreamSource(stream));
-    });
-}
-//# sourceMappingURL=audioController.js.map

package/lib/plugin/config.d.ts

@@ -1,11 +0,0 @@
-export declare const HealthCheckTimeout = 1000;
-export declare const ClockJumpCheckInterval = 1000;
-export declare const ClockJumpThreshold = 10000;
-export declare const MainConnectionPingInterval = 10000;
-export declare const WebRTCIceTimeout = 3000;
-export declare const WebRTCTimeout = 10000;
-export declare const ConnectTimeout = 5000;
-export declare const MinTokenLifetime = 60000;
-export declare const MinTokenRefreshInterval = 5000;
-export declare const ConnectInterval: number[];
-//# sourceMappingURL=config.d.ts.map

package/lib/plugin/config.js

@@ -1,11 +0,0 @@
-export const HealthCheckTimeout = 1000; /* ms */
-export const ClockJumpCheckInterval = 1000; /* ms */
-export const ClockJumpThreshold = 10000; /* ms */
-export const MainConnectionPingInterval = 10000; /* ms */
-export const WebRTCIceTimeout = 3000; /* ms */
-export const WebRTCTimeout = 10000; /* ms */
-export const ConnectTimeout = 5000; /* ms */
-export const MinTokenLifetime = 60000; /* 1min */
-export const MinTokenRefreshInterval = 5000; /* 5sec */
-export const ConnectInterval = [0, 100, 200, 200, 500, 1000, 2000]; /* ms */
-//# sourceMappingURL=config.js.map

package/lib/plugin/connectionPool.d.ts

@@ -1,17 +0,0 @@
-import { DatagramHandler, MainConnection } from './mainConnection';
-import { Result } from '@4players/odin-common';
-export declare class ConnectionPool {
-    readonly onDatagram: DatagramHandler;
-    private _LastConnectionId;
-    private readonly _ConnectionsByUrl;
-    private readonly _ConnectionsById;
-    private readonly _Close;
-    get closed(): boolean;
-    constructor(onDatagram: DatagramHandler);
-    sendDatagram(connectionId: number, packet: Uint8Array): void;
-    acquireConnection(url: URL, signal: AbortSignal): Promise<Result<MainConnection> | 'closed'>;
-    releaseConnection(connection: MainConnection): void;
-    checkHealth(): Promise<void>;
-    close(): void;
-}
-//# sourceMappingURL=connectionPool.d.ts.map