@fishjam-cloud/webrtc-client 0.14.0

package/dist/webrtc-client/tests/fixtures.js

@@ -0,0 +1,172 @@
+import { faker } from '@faker-js/faker';
+import { MediaEvent_Connected, MediaEvent_Endpoint, MediaEvent_EndpointAdded, MediaEvent_EndpointRemoved, MediaEvent_EndpointUpdated, MediaEvent_OfferData, MediaEvent_SdpAnswer, MediaEvent_TracksAdded, MediaEvent_TracksRemoved, MediaEvent_TrackUpdated, MediaEvent_TrackVariantSwitched, MediaEvent_VadNotification, } from '@fishjam-cloud/protobufs/server';
+import { FakeMediaStreamTrack } from 'fake-mediastreamtrack';
+import { vi } from 'vitest';
+import { Variant } from '../src';
+export const exampleEndpointId = 'exampleEndpointId';
+export const notExistingEndpointId = 'notExistingEndpointId';
+export const exampleTrackId = 'exampleTrackId';
+export const notExistingTrackId = 'notExistingTrackId';
+export const mockTrack = new FakeMediaStreamTrack({ kind: 'video' });
+const MediaStreamMock = vi.fn().mockImplementation(() => { });
+export const stream = new MediaStreamMock();
+export const createTrackWithSimulcast = (metadata = undefined) => ({
+    metadataJson: JSON.stringify(metadata),
+    simulcastConfig: {
+        enabled: true,
+        enabledVariants: [Variant.VARIANT_LOW, Variant.VARIANT_MEDIUM, Variant.VARIANT_HIGH],
+        disabledVariants: [],
+    },
+});
+export const createEmptyEndpoint = () => MediaEvent_Endpoint.create({ trackIdToTrack: {}, endpointType: 'webrtc' });
+export const createConnectedEvent = (endpointId = faker.string.uuid()) => {
+    return MediaEvent_Connected.create({ endpointId, endpointIdToEndpoint: { [endpointId]: createEmptyEndpoint() } });
+};
+export const createEncodingSwitchedEvent = (endpointId, trackId, variant) => MediaEvent_TrackVariantSwitched.create({
+    variant,
+    endpointId,
+    trackId,
+});
+// export const createBandwidthEstimationEvent = (): CustomBandwidthEstimationEvent =>
+//   CustomBandwidthEstimationEventSchema.parse({
+//     data: {
+//       data: {
+//         estimation: 261506.7264961106,
+//       },
+//       type: 'bandwidthEstimation',
+//     },
+//     type: 'custom',
+//   });
+export const createCustomVadNotificationEvent = (trackId, status) => MediaEvent_VadNotification.create({
+    trackId,
+    status,
+});
+export const createTrackUpdatedEvent = (trackId, endpointId, metadata) => MediaEvent_TrackUpdated.create({
+    endpointId: endpointId,
+    metadataJson: JSON.stringify(metadata),
+    trackId: trackId,
+});
+export const createEndpointAdded = (endpointId, metadata = undefined) => MediaEvent_EndpointAdded.create({
+    endpointId,
+    metadataJson: JSON.stringify(metadata),
+});
+export const createEndpointRemoved = (endpointId) => MediaEvent_EndpointRemoved.create({
+    endpointId,
+});
+export const createConnectedEventWithOneEndpoint = (endpointId = faker.string.uuid(), localEndpointId) => {
+    const connectedEvent = createConnectedEvent(localEndpointId);
+    const endpoint = createEmptyEndpoint();
+    connectedEvent.endpointIdToEndpoint = { ...connectedEvent.endpointIdToEndpoint, [endpointId]: endpoint };
+    return MediaEvent_Connected.create(connectedEvent);
+};
+export const createConnectedEventWithOneEndpointWithOneTrack = (remoteEndpointId, trackId, localEndpointId) => {
+    const connectedEvent = createConnectedEvent(localEndpointId);
+    const remoteEndpoint = createEmptyEndpoint();
+    remoteEndpoint.trackIdToTrack[trackId] = createTrackWithSimulcast();
+    connectedEvent.endpointIdToEndpoint = {
+        ...connectedEvent.endpointIdToEndpoint,
+        [remoteEndpointId]: remoteEndpoint,
+    };
+    return MediaEvent_Connected.create(connectedEvent);
+};
+export const createAddTrackMediaEvent = (endpointId, trackId, metadata = undefined) => MediaEvent_TracksAdded.create({
+    endpointId: endpointId,
+    trackIdToTrack: {
+        [trackId]: createTrackWithSimulcast(metadata),
+    },
+});
+export const createTracksRemovedEvent = (endpointId, trackIds) => MediaEvent_TracksRemoved.create({
+    endpointId: endpointId,
+    trackIds,
+});
+export const createCustomOfferDataEventWithOneVideoTrack = () => MediaEvent_OfferData.create({
+    tracksTypes: {
+        audio: 0,
+        video: 1,
+    },
+});
+export const createAddLocalTrackSDPOffer = () => MediaEvent_OfferData.create({
+    tracksTypes: {
+        audio: 0,
+        video: 0,
+    },
+});
+export const createAnswerData = (trackId) => MediaEvent_SdpAnswer.create({
+    sdp: `v=0\r
+    o=- 39483584182226872 0 IN IP4 127.0.0.1\r
+    s=-\r
+    t=0 0\r
+    a=group:BUNDLE 0\r
+    a=extmap-allow-mixed\r
+    a=ice-lite\r
+    m=video 9 UDP/TLS/RTP/SAVPF 102 103\r
+    c=IN IP4 0.0.0.0\r
+    a=sendonly\r
+    a=ice-ufrag:fXa4\r
+    a=ice-pwd:mC2wFgKGsN3cXnxadEhVaa\r
+    a=ice-options:trickle\r
+    a=fingerprint:sha-256 50:65:CB:9F:2B:B5:62:7F:20:59:79:C6:7B:49:D8:DF:C2:B5:59:1F:E2:7D:68:F8:C3:07:73:8B:16:70:FB:DD\r
+    a=setup:passive\r
+    a=mid:0\r
+    a=msid:60ff1fb2-6868-42be-8c92-311733034415 ea1339b9-54ce-445b-9cff-2568f9ac504b\r
+    a=rtcp-mux\r
+    a=rtpmap:102 H264/90000\r
+    a=fmtp:102 profile-level-id=42001f;level-asymmetry-allowed=1;packetization-mode=1\r
+    a=rtpmap:103 rtx/90000\r
+    a=fmtp:103 apt=102\r
+    a=extmap:4 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\r
+    a=rtcp-fb:102 transport-cc\r
+    a=extmap:9 urn:ietf:params:rtp-hdrext:sdes:mid\r
+    a=extmap:10 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id\r
+    a=extmap:11 urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id\r
+    a=rtcp-fb:102 ccm fir\r
+    a=rtcp-fb:102 nack\r
+    a=rtcp-fb:102 nack pli\r
+    a=rtcp-rsize\r
+    a=ssrc:663086196 cname:${trackId}-video-60ff1fb2-6868-42be-8c92-311733034415\r
+    `,
+    midToTrackId: {
+        '0': '9afe80ce-1964-4958-a386-d7a9e3097ca7:5c74b6b3-cb72-49f1-a76b-0df4895a3d32',
+    },
+});
+export const createAddLocalTrackAnswerData = (trackId) => MediaEvent_SdpAnswer.create({
+    midToTrackId: {
+        '0': trackId,
+    },
+    sdp: `v=0\r
+    o=- 63903156084304368 0 IN IP4 127.0.0.1\r
+    s=-\r
+    t=0 0\r
+    a=group:BUNDLE 0\r
+    a=extmap-allow-mixed\r
+    a=ice-lite\r
+    m=video 9 UDP/TLS/RTP/SAVPF 106 107\r
+    c=IN IP4 0.0.0.0\r
+    a=recvonly\r
+    a=ice-ufrag:dHiY\r
+    a=ice-pwd:IAPCE68QAQ8AxSF0OQIEZp\r
+    a=ice-options:trickle\r
+    a=fingerprint:sha-256 C1:50:4C:EC:98:1D:62:C8:DA:AE:F8:5B:44:4F:76:BB:4E:FF:5E:51:3E:A7:62:9B:58:38:A5:13:D0:B1:50:67\r
+    a=setup:passive\r
+    a=mid:0\r
+    a=msid:7bf8bef4-be67-456c-8635-ba58339c29e9 ad3deb09-60a6-4bfc-aa14-482ed4f60667\r
+    a=rtcp-mux\r
+    a=rtpmap:106 H264/90000\r
+    a=fmtp:106 profile-level-id=42e01f;level-asymmetry-allowed=1;packetization-mode=1\r
+    a=rtpmap:107 rtx/90000\r
+    a=fmtp:107 apt=106\r
+    a=extmap:4 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01\r
+    a=rtcp-fb:106 transport-cc\r
+    a=extmap:9 urn:ietf:params:rtp-hdrext:sdes:mid\r
+    a=extmap:10 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id\r
+    a=extmap:11 urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id\r
+    a=rtcp-fb:106 ccm fir\r
+    a=rtcp-fb:106 nack\r
+    a=rtcp-fb:106 nack pli\r
+    a=rtcp-rsize\r
+    `,
+});
+export const createEndpointUpdatedPeerMetadata = (endpointId, metadata) => MediaEvent_EndpointUpdated.create({
+    endpointId,
+    metadataJson: JSON.stringify(metadata),
+});

package/dist/webrtc-client/tests/methods/addTrackMethod.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/methods/addTrackMethod.test.js

@@ -0,0 +1,46 @@
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { deserializePeerMediaEvent, serializeServerMediaEvent } from '../../src/mediaEvent';
+import { createConnectedEventWithOneEndpoint, mockTrack } from '../fixtures';
+import { mockMediaStream, mockRTCPeerConnection } from '../mocks';
+it('Adding track invokes renegotiation', () => new Promise((done) => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    mockMediaStream();
+    const serializedEvent = serializeServerMediaEvent({ connected: createConnectedEventWithOneEndpoint() });
+    webRTCEndpoint.receiveMediaEvent(serializedEvent);
+    webRTCEndpoint.on('sendMediaEvent', (mediaEvent) => {
+        // Then
+        const event = deserializePeerMediaEvent(mediaEvent);
+        expect(event.renegotiateTracks).toBeTruthy();
+        done('');
+        // now it's time to create offer and answer
+        // webRTCEndpoint.receiveMediaEvent(JSON.stringify(createOfferData()))
+        // webRTCEndpoint.receiveMediaEvent(JSON.stringify(createAnswerData("9bf0cc85-c795-43b2-baf1-2c974cd770b9:1b6d99d1-3630-4e01-b386-15cbbfe5a41f")))
+    });
+    // When
+    webRTCEndpoint.addTrack(mockTrack);
+}));
+it('Adding track updates internal state', () => {
+    // Given
+    mockRTCPeerConnection();
+    mockMediaStream();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const serializedEvent = serializeServerMediaEvent({ connected: createConnectedEventWithOneEndpoint() });
+    webRTCEndpoint.receiveMediaEvent(serializedEvent);
+    // When
+    webRTCEndpoint.addTrack(mockTrack);
+    // Then
+    const localTrackIdToTrack = webRTCEndpoint['local'].getTrackIdToTrack();
+    expect(localTrackIdToTrack.size).toBe(1);
+    const localEndpoint = webRTCEndpoint['local'].getEndpoint();
+    expect(localEndpoint.tracks.size).toBe(1);
+});
+it('Adding track before being accepted by the server throws error', async () => {
+    // Given
+    mockRTCPeerConnection();
+    mockMediaStream();
+    const webRTCEndpoint = new WebRTCEndpoint();
+    // When
+    await expect(() => webRTCEndpoint.addTrack(mockTrack)).rejects.toThrow('Cannot add tracks before being accepted by the server');
+});

package/dist/webrtc-client/tests/methods/cleanUpMethod.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/methods/cleanUpMethod.test.js

@@ -0,0 +1,14 @@
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { exampleEndpointId, exampleTrackId } from '../fixtures';
+import { setupRoomWithMocks } from '../utils';
+it('CleanUp sets connection to undefined', async () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    await setupRoomWithMocks(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    // When
+    webRTCEndpoint.cleanUp();
+    // Then
+    const connection = webRTCEndpoint['connectionManager'];
+    expect(connection).toBe(undefined);
+});

package/dist/webrtc-client/tests/methods/connectMethod.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/methods/connectMethod.test.js

@@ -0,0 +1,40 @@
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { deserializePeerMediaEvent } from '../../src/mediaEvent';
+it('Method connect sends mediaEvent to backend', () => new Promise((done) => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const peerMetadata = {};
+    webRTCEndpoint.on('sendMediaEvent', (mediaEvent) => {
+        // Then
+        const event = deserializePeerMediaEvent(mediaEvent);
+        expect(event.connect).toBeTruthy();
+        done('');
+    });
+    // When
+    webRTCEndpoint.connect(peerMetadata);
+}));
+it("Method 'connect' sends metadata in event", () => new Promise((done) => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const peerMetadata = { exampleField: 'exampleValue' };
+    webRTCEndpoint.on('sendMediaEvent', (mediaEvent) => {
+        // Then
+        const event = deserializePeerMediaEvent(mediaEvent);
+        const metadataJson = event.connect?.metadataJson;
+        expect(metadataJson).toBeDefined();
+        expect(JSON.parse(metadataJson)).toMatchObject(peerMetadata);
+        done('');
+    });
+    // When
+    webRTCEndpoint.connect(peerMetadata);
+}));
+it("Method 'connect' sets metadata in local field", () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    const peerMetadata = { exampleField: 'exampleValue' };
+    // When
+    webRTCEndpoint.connect(peerMetadata);
+    // Then
+    expect(webRTCEndpoint['local'].getEndpoint().metadata).toMatchObject(peerMetadata);
+});

package/dist/webrtc-client/tests/methods/disconnectMethod.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webrtc-client/tests/methods/disconnectMethod.test.js

@@ -0,0 +1,29 @@
+import { expect, it } from 'vitest';
+import { WebRTCEndpoint } from '../../src';
+import { deserializePeerMediaEvent } from '../../src/mediaEvent';
+import { exampleEndpointId, exampleTrackId } from '../fixtures';
+import { setupRoomWithMocks } from '../utils';
+it('Disconnect sets connection to undefined', async () => {
+    // Given
+    const webRTCEndpoint = new WebRTCEndpoint();
+    await setupRoomWithMocks(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+    // When
+    webRTCEndpoint.disconnect();
+    // Then
+    const connection = webRTCEndpoint['connectionManager'];
+    expect(connection).toBe(undefined);
+});
+it('Disconnect invokes disconnected event', () => new Promise((done) => {
+    (async () => {
+        // Given
+        const webRTCEndpoint = new WebRTCEndpoint();
+        await setupRoomWithMocks(webRTCEndpoint, exampleEndpointId, exampleTrackId);
+        webRTCEndpoint.on('sendMediaEvent', (mediaEvent) => {
+            const event = deserializePeerMediaEvent(mediaEvent);
+            expect(event.disconnect).toBeTruthy();
+            done('');
+        });
+        // When
+        webRTCEndpoint.disconnect();
+    })();
+}));

package/dist/webrtc-client/tests/mocks.d.ts

@@ -0,0 +1,5 @@
+export declare const mockMediaStream: () => void;
+export declare const mockRTCPeerConnection: () => {
+    addTransceiverCallback: any;
+    runOnTrack: (ev: RTCTrackEvent) => void;
+};

package/dist/webrtc-client/tests/mocks.js

@@ -0,0 +1,80 @@
+import { vi } from 'vitest';
+import { undefined } from 'zod';
+export const mockMediaStream = () => {
+    global.MediaStream = vi.fn().mockImplementation(() => {
+        return {
+            addTrack: () => { },
+        };
+    });
+};
+export const mockRTCPeerConnection = () => {
+    const addTransceiverCallback = vi.fn((_trackOrKind, _init) => null);
+    global.RTCPeerConnection = vi.fn().mockImplementation(() => {
+        const transceivers = [];
+        const senders = [];
+        const newVar = {
+            getTransceivers: () => {
+                return transceivers;
+            },
+            addTransceiver: (trackOrKind, init) => {
+                addTransceiverCallback(trackOrKind, init);
+                const sender = {};
+                sender.getParameters = () => {
+                    // @ts-ignore
+                    const encodings = [{}];
+                    return { encodings: encodings };
+                };
+                if (init?.direction === 'sendonly') {
+                    sender.track = typeof trackOrKind !== 'string' ? trackOrKind : { id: 'someTrackId' };
+                }
+                senders.push(sender);
+                // maybe move to callback declaration
+                const transceiver = {
+                    currentDirection: null,
+                    direction: init?.direction ?? 'inactive',
+                    mid: 'someTransceiverMid',
+                    receiver: {},
+                    sender: sender,
+                    setCodecPreferences: (_codecs) => { },
+                    stop: () => { },
+                };
+                transceivers.push(transceiver);
+                return transceiver;
+            },
+            // @ts-ignore
+            createOffer: (_options) => {
+                // const sleep = async (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+                return new Promise((resolve, _reject) => {
+                    resolve({ sdp: '', type: 'offer' });
+                });
+            },
+            setLocalDescription: async (_description) => { },
+            setRemoteDescription: async (_description) => { },
+            getSenders: () => {
+                return senders;
+            },
+            close: () => { },
+            addEventListener: () => { },
+            removeEventListener: () => { },
+        };
+        return newVar;
+    });
+    global.RTCRtpTransceiver = vi.fn().mockImplementation(() => {
+        const newVar = {
+            currentDirection: null,
+            direction: 'stopped',
+            mid: '0',
+            // @ts-ignore
+            receiver: undefined,
+            // @ts-ignore
+            sender: undefined,
+            setCodecPreferences(_codecs) { },
+            stop() { },
+        };
+        return newVar;
+    });
+    const runOnTrack = (ev) => {
+        global.RTCPeerConnection.ontrack(ev);
+    };
+    return { addTransceiverCallback, runOnTrack };
+};

package/dist/webrtc-client/tests/utils.d.ts

@@ -0,0 +1,3 @@
+import type { WebRTCEndpoint } from '../src';
+export declare const setupRoom: (webRTCEndpoint: WebRTCEndpoint, endpointId: string, trackId: string) => void;
+export declare const setupRoomWithMocks: (webRTCEndpoint: WebRTCEndpoint, endpointId: string, trackId: string) => Promise<void>;

package/dist/webrtc-client/tests/utils.js

@@ -0,0 +1,56 @@
+import { MediaEvent } from '@fishjam-cloud/protobufs/server';
+import { createAddLocalTrackAnswerData, createAddLocalTrackSDPOffer, createAddTrackMediaEvent, createConnectedEventWithOneEndpointWithOneTrack, stream, } from './fixtures';
+import { mockRTCPeerConnection } from './mocks';
+export const setupRoom = (webRTCEndpoint, endpointId, trackId) => {
+    const connected = createConnectedEventWithOneEndpointWithOneTrack(endpointId, trackId);
+    const connectedEvent = MediaEvent.encode({ connected }).finish();
+    webRTCEndpoint.receiveMediaEvent(connectedEvent);
+    // Right now info about tracks from connectedEvent is ignored
+    // We need to fix it but not in this commit
+    // We need more tests (e2e) to introduce this change
+    const tracksAdded = createAddTrackMediaEvent(endpointId, trackId);
+    const tracksAddedEvent = MediaEvent.encode({ tracksAdded }).finish();
+    webRTCEndpoint.receiveMediaEvent(tracksAddedEvent);
+};
+// Fix proposal:
+//
+// "connected" handler
+//
+// const otherEndpoints: Endpoint[] = endpoints.map((endpoint) => {
+//   const endpointTracks: [string, any][] = Object.entries(endpoint.tracks || {});
+//   const tracks = this.mapMediaEventTracksToTrackContextImpl(endpointTracks, endpoint);
+//   return { ...endpoint, tracks };
+// });
+//
+// otherEndpoints.forEach((endpoint) => {
+//   this.addEndpoint(endpoint);
+// });
+// otherEndpoints.forEach((endpoint) => {
+//           endpoint.tracks.forEach((ctx, trackId) => {
+//
+// "endpointAdded"
+// this.addEndpoint({ ...endpoint, tracks: new Map() });
+//
+// remove todo if-else statement from addEndpoint function
+export const setupRoomWithMocks = async (webRTCEndpoint, endpointId, trackId) => {
+    mockRTCPeerConnection();
+    setupRoom(webRTCEndpoint, endpointId, trackId);
+    const offerData = createAddLocalTrackSDPOffer();
+    webRTCEndpoint.receiveMediaEvent(MediaEvent.encode({ offerData }).finish());
+    const sdpAnswer = createAddLocalTrackAnswerData(trackId);
+    webRTCEndpoint.receiveMediaEvent(MediaEvent.encode({ sdpAnswer }).finish());
+    const connection = webRTCEndpoint['connectionManager'];
+    const transciever = new RTCRtpTransceiver();
+    // @ts-ignore
+    const rtcTrackEvent = {
+        streams: [stream],
+        transceiver: transciever,
+        // @ts-expect-error
+        track: {
+            kind: 'video',
+        },
+    };
+    // @ts-ignore
+    connection.getConnection().ontrack(rtcTrackEvent);
+    return new Promise((resolve) => resolve());
+};

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@fishjam-cloud/webrtc-client",
+  "version": "0.14.0",
+  "description": "Typescript client library for ExWebRTC/WebRTC endpoint in Membrane RTC Engine",
+  "license": "Apache-2.0",
+  "author": "Fishjam Team",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fishjam-cloud/web-client-sdk.git",
+    "directory": "packages/webrtc-client"
+  },
+  "homepage": "https://github.com/fishjam-cloud/web-client-sdk#readme",
+  "bugs": "https://github.com/fishjam-cloud/web-client-sdk/issues",
+  "keywords": [
+    "webrtc",
+    "fishjam"
+  ],
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist/**"
+  ],
+  "tsup": {
+    "entry": [
+      "src/index.ts"
+    ],
+    "format": [
+      "esm"
+    ]
+  },
+  "scripts": {
+    "build": "yarn build:check && tsup --dts-resolve",
+    "build:check": "tsc --noEmit",
+    "format": "prettier --write . --ignore-path ./.eslintignore",
+    "format:check": "prettier --check . --ignore-path ./.eslintignore",
+    "lint": "eslint . --ext .ts,.tsx --fix",
+    "lint:check": "eslint . --ext .ts,.tsx",
+    "gen:proto": "sh scripts/protobuf.sh",
+    "test": "vitest run",
+    "test:e2e": "NODE_OPTIONS=--dns-result-order=ipv4first playwright test",
+    "test:coverage": "vitest run tests/** --coverage",
+    "prepare": "tsc",
+    "prepack": "yarn build"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "^2.2.3",
+    "events": "^3.3.0",
+    "typed-emitter": "^2.1.0",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@faker-js/faker": "^9.5.0",
+    "@fishjam-cloud/protobufs": "workspace:*",
+    "@playwright/test": "^1.50.1",
+    "@types/events": "^3.0.3",
+    "@types/node": "^22.13.4",
+    "@types/uuid": "^10.0.0",
+    "@vitest/coverage-v8": "^3.0.5",
+    "fake-mediastreamtrack": "^1.2.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.4.3",
+    "tsup": "^8.3.6",
+    "typed-emitter": "^2.1.0",
+    "typedoc": "^0.27.7",
+    "typedoc-plugin-external-resolver": "^1.0.3",
+    "typedoc-plugin-mdn-links": "^4.0.13",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.7",
+    "zod": "^3.24.1"
+  },
+  "lint-staged": {
+    "*": [
+      "yarn format:check"
+    ],
+    "*.(js|ts|tsx)": [
+      "yarn lint:check"
+    ]
+  },
+  "packageManager": "yarn@4.3.0"
+}