diff --git a/e2e-tests/ts-client/app/playwright.config.ts b/e2e-tests/ts-client/app/playwright.config.ts
index ba6defc6..70533a27 100644
--- a/e2e-tests/ts-client/app/playwright.config.ts
+++ b/e2e-tests/ts-client/app/playwright.config.ts
@@ -1,4 +1,4 @@
-import { defineConfig, devices } from '@playwright/test';
+import { defineConfig, devices } from "@playwright/test";
 
 /**
  * Read environment variables from file.
@@ -10,7 +10,7 @@ import { defineConfig, devices } from '@playwright/test';
  * See https://playwright.dev/docs/test-configuration.
  */
 export default defineConfig({
-  testDir: '../.',
+  testDir: "../.",
   /* Run tests in files in parallel */
   fullyParallel: true,
   /* Fail the build on CI if you accidentally left test.only in the source code. */
@@ -21,32 +21,38 @@ export default defineConfig({
   workers: process.env.CI ? 1 : undefined,
   /* Reporter to use. See https://playwright.dev/docs/test-reporters */
   reporter: [
-    ['list'],
-    ['html', { outputFolder: '../../../playwright-report/ts-client-e2e', open: "never" }]
+    ["list"],
+    [
+      "html",
+      {
+        outputFolder: "../../../playwright-report/ts-client-e2e",
+        open: "never",
+      },
+    ],
   ],
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
   use: {
     /* Base URL to use in actions like `await page.goto('/')`. */
-    baseURL: 'http://localhost:5173',
+    baseURL: "http://localhost:5173",
 
     /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-    trace: 'on-first-retry',
+    trace: "on-first-retry",
 
     extraHTTPHeaders: {
-      Authorization: 'Bearer development',
+      Authorization: "Bearer development",
     },
   },
 
   /* Configure projects for major browsers */
   projects: [
     {
-      name: 'chromium',
+      name: "chromium",
       use: {
-        ...devices['Desktop Chrome'],
+        ...devices["Desktop Chrome"],
         launchOptions: {
           args: [
-            '--use-fake-ui-for-media-stream',
-            '--use-fake-device-for-media-stream',
+            "--use-fake-ui-for-media-stream",
+            "--use-fake-device-for-media-stream",
           ],
           // default Google Chrome path on MacOS
           // executablePath: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
@@ -57,11 +63,11 @@ export default defineConfig({
 
   /* Run your local dev server before starting the tests */
   webServer: {
-    command: 'yarn run dev',
-    url: 'http://localhost:5173',
+    command: "yarn run dev",
+    url: "http://localhost:5173",
     reuseExistingServer: !process.env.CI,
   },
 
-  globalSetup: '../setup/setupFishjam',
-  globalTeardown: '../setup/teardownFishjam',
+  globalSetup: "../setup/setupFishjam",
+  globalTeardown: "../setup/teardownFishjam",
 });
diff --git a/e2e-tests/ts-client/app/src/App.tsx b/e2e-tests/ts-client/app/src/App.tsx
index ce111b00..1fec1c7c 100644
--- a/e2e-tests/ts-client/app/src/App.tsx
+++ b/e2e-tests/ts-client/app/src/App.tsx
@@ -6,15 +6,13 @@ import type {
   WebRTCEndpointEvents,
   TrackContextEvents,
   BandwidthLimit,
-  SimulcastConfig
-} from '@fishjam-dev/ts-client';
-import {
-  WebRTCEndpoint
-} from '@fishjam-dev/ts-client';
-import { PeerMessage } from '@fishjam-dev/ts-client/protos';
-import { useEffect, useState, useSyncExternalStore } from 'react';
-import { MockComponent } from './MockComponent';
-import { VideoPlayerWithDetector } from './VideoPlayerWithDetector';
+  SimulcastConfig,
+} from "@fishjam-dev/ts-client";
+import { WebRTCEndpoint } from "@fishjam-dev/ts-client";
+import { PeerMessage } from "@fishjam-dev/ts-client/protos";
+import { useEffect, useState, useSyncExternalStore } from "react";
+import { MockComponent } from "./MockComponent";
+import { VideoPlayerWithDetector } from "./VideoPlayerWithDetector";
 
 /* eslint-disable no-console */
 
@@ -28,23 +26,23 @@ export type TrackMetadata = {
 
 function endpointMetadataParser(a: unknown): EndpointMetadata {
   if (
-    typeof a !== 'object' ||
+    typeof a !== "object" ||
     a === null ||
-    !('goodStuff' in a) ||
-    typeof a.goodStuff !== 'string'
+    !("goodStuff" in a) ||
+    typeof a.goodStuff !== "string"
   )
-    throw 'Invalid metadata!!!';
+    throw "Invalid metadata!!!";
   return { goodStuff: a.goodStuff };
 }
 
 function trackMetadataParser(a: unknown): TrackMetadata {
   if (
-    typeof a !== 'object' ||
+    typeof a !== "object" ||
     a === null ||
-    !('goodTrack' in a) ||
-    typeof a.goodTrack !== 'string'
+    !("goodTrack" in a) ||
+    typeof a.goodTrack !== "string"
   )
-    throw 'Invalid track metadata!!!';
+    throw "Invalid track metadata!!!";
   return { goodTrack: a.goodTrack };
 }
 
@@ -60,8 +58,7 @@ class RemoteStore {
 
   constructor(
     private webrtc: WebRTCEndpoint<EndpointMetadata, TrackMetadata>,
-  ) {
-  }
+  ) {}
 
   subscribe(callback: () => void) {
     const cb = () => {
@@ -72,14 +69,14 @@ class RemoteStore {
     const trackCb: TrackContextEvents<
       EndpointMetadata,
       TrackMetadata
-    >['encodingChanged'] = () => cb();
+    >["encodingChanged"] = () => cb();
 
     const trackAddedCb: WebRTCEndpointEvents<
       EndpointMetadata,
       TrackMetadata
-    >['trackAdded'] = (context) => {
-      context.on('encodingChanged', () => trackCb);
-      context.on('voiceActivityChanged', () => trackCb);
+    >["trackAdded"] = (context) => {
+      context.on("encodingChanged", () => trackCb);
+      context.on("voiceActivityChanged", () => trackCb);
 
       callback();
     };
@@ -87,29 +84,29 @@ class RemoteStore {
     const removeCb: WebRTCEndpointEvents<
       EndpointMetadata,
       TrackMetadata
-    >['trackRemoved'] = (context) => {
-      context.removeListener('encodingChanged', () => trackCb);
-      context.removeListener('voiceActivityChanged', () => trackCb);
+    >["trackRemoved"] = (context) => {
+      context.removeListener("encodingChanged", () => trackCb);
+      context.removeListener("voiceActivityChanged", () => trackCb);
 
       callback();
     };
 
-    this.webrtc.on('trackAdded', trackAddedCb);
-    this.webrtc.on('trackReady', cb);
-    this.webrtc.on('trackUpdated', cb);
-    this.webrtc.on('trackRemoved', removeCb);
-    this.webrtc.on('endpointAdded', cb);
-    this.webrtc.on('endpointRemoved', cb);
-    this.webrtc.on('endpointUpdated', cb);
+    this.webrtc.on("trackAdded", trackAddedCb);
+    this.webrtc.on("trackReady", cb);
+    this.webrtc.on("trackUpdated", cb);
+    this.webrtc.on("trackRemoved", removeCb);
+    this.webrtc.on("endpointAdded", cb);
+    this.webrtc.on("endpointRemoved", cb);
+    this.webrtc.on("endpointUpdated", cb);
 
     return () => {
-      this.webrtc.removeListener('trackAdded', trackAddedCb);
-      this.webrtc.removeListener('trackReady', cb);
-      this.webrtc.removeListener('trackUpdated', cb);
-      this.webrtc.removeListener('trackRemoved', removeCb);
-      this.webrtc.removeListener('endpointAdded', cb);
-      this.webrtc.removeListener('endpointRemoved', cb);
-      this.webrtc.removeListener('endpointUpdated', cb);
+      this.webrtc.removeListener("trackAdded", trackAddedCb);
+      this.webrtc.removeListener("trackReady", cb);
+      this.webrtc.removeListener("trackUpdated", cb);
+      this.webrtc.removeListener("trackRemoved", removeCb);
+      this.webrtc.removeListener("endpointAdded", cb);
+      this.webrtc.removeListener("endpointRemoved", cb);
+      this.webrtc.removeListener("endpointUpdated", cb);
     };
   }
 
@@ -117,8 +114,8 @@ class RemoteStore {
     const newTracks = webrtc.getRemoteTracks();
     const newEndpoints = webrtc.getRemoteEndpoints();
     const ids =
-      Object.keys(newTracks).sort().join(':') +
-      Object.keys(newEndpoints).sort().join(':');
+      Object.keys(newTracks).sort().join(":") +
+      Object.keys(newEndpoints).sort().join(":");
     if (!(ids in this.cache) || this.invalidateCache) {
       this.cache[ids] = [newEndpoints, newTracks];
       this.invalidateCache = false;
@@ -138,26 +135,27 @@ const webrtc = new WebRTCEndpoint({
 const remoteTracksStore = new RemoteStore(webrtc);
 
 function connect(token: string, metadata: EndpointMetadata) {
-  const websocketUrl = 'ws://localhost:5002/socket/peer/websocket';
+  const websocketUrl = "ws://localhost:5002/socket/peer/websocket";
   const websocket = new WebSocket(websocketUrl);
-  websocket.binaryType = 'arraybuffer';
+  websocket.binaryType = "arraybuffer";
 
   function socketOpenHandler(_event: Event) {
     const message = PeerMessage.encode({ authRequest: { token } }).finish();
     websocket.send(message);
   }
 
-  websocket.addEventListener('open', socketOpenHandler);
+  websocket.addEventListener("open", socketOpenHandler);
 
-  webrtc.on('sendMediaEvent', (mediaEvent: SerializedMediaEvent) => {
-    console.log(`%c(${clientId}) - Send: ${mediaEvent}`, 'color:blue');
+  webrtc.on("sendMediaEvent", (mediaEvent: SerializedMediaEvent) => {
+    console.log(`%c(${clientId}) - Send: ${mediaEvent}`, "color:blue");
     const message = PeerMessage.encode({
       mediaEvent: { data: mediaEvent },
     }).finish();
     websocket.send(message);
   });
 
-  const messageHandler = (event: MessageEvent<any>) => { /* eslint-disable-line @typescript-eslint/no-explicit-any */
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  const messageHandler = (event: MessageEvent<any>) => {
     const uint8Array = new Uint8Array(event.data);
     try {
       const data = PeerMessage.decode(uint8Array);
@@ -166,19 +164,19 @@ function connect(token: string, metadata: EndpointMetadata) {
         const mediaEvent = JSON.parse(data?.mediaEvent?.data);
         console.log(
           `%c(${clientId}) - Received: ${JSON.stringify(mediaEvent)}`,
-          'color:green',
+          "color:green",
         );
       } else {
         console.log(
           `%c(${clientId}) - Received: ${JSON.stringify(data)}`,
-          'color:green',
+          "color:green",
         );
       }
 
       if (data.authenticated !== undefined) {
         webrtc.connect(metadata);
       } else if (data.authRequest !== undefined) {
-        console.warn('Received unexpected control message: authRequest');
+        console.warn("Received unexpected control message: authRequest");
       } else if (data.mediaEvent !== undefined) {
         webrtc.receiveMediaEvent(data.mediaEvent.data);
       }
@@ -187,32 +185,32 @@ function connect(token: string, metadata: EndpointMetadata) {
     }
   };
 
-  websocket.addEventListener('message', messageHandler);
+  websocket.addEventListener("message", messageHandler);
 
   const closeHandler = (event: unknown) => {
-    console.log({ name: 'Close handler!', event });
+    console.log({ name: "Close handler!", event });
   };
 
-  websocket.addEventListener('close', closeHandler);
+  websocket.addEventListener("close", closeHandler);
 
   const errorHandler = (event: unknown) => {
-    console.log({ name: 'Error handler!', event });
+    console.log({ name: "Error handler!", event });
   };
 
-  websocket.addEventListener('error', errorHandler);
+  websocket.addEventListener("error", errorHandler);
 
   const trackReady = (event: unknown) => {
-    console.log({ name: 'trackReady', event });
+    console.log({ name: "trackReady", event });
   };
 
-  websocket.addEventListener('trackReady', trackReady);
+  websocket.addEventListener("trackReady", trackReady);
 }
 
 async function addScreenshareTrack(): Promise<string> {
   const stream = await window.navigator.mediaDevices.getDisplayMedia();
   const track = stream.getVideoTracks()[0];
 
-  const trackMetadata: TrackMetadata = { goodTrack: 'screenshare' };
+  const trackMetadata: TrackMetadata = { goodTrack: "screenshare" };
   const simulcastConfig: SimulcastConfig = {
     enabled: false,
     activeEncodings: [],
@@ -225,21 +223,21 @@ async function addScreenshareTrack(): Promise<string> {
 
 export function App() {
   const [tokenInput, setTokenInput] = useState(
-    localStorage.getItem('token') ?? '',
+    localStorage.getItem("token") ?? "",
   );
   const [endpointMetadataInput, setEndpointMetadataInput] = useState(
-    JSON.stringify({ goodStuff: 'ye' }),
+    JSON.stringify({ goodStuff: "ye" }),
   );
   const [connected, setConnected] = useState(false);
 
   useEffect(() => {
-    localStorage.setItem('token', tokenInput);
+    localStorage.setItem("token", tokenInput);
   }, [tokenInput]);
 
   const handleConnect = () =>
     connect(
       tokenInput,
-      endpointMetadataInput !== ''
+      endpointMetadataInput !== ""
         ? JSON.parse(endpointMetadataInput)
         : undefined,
     );
@@ -259,15 +257,15 @@ export function App() {
   useEffect(() => {
     const callback = () => setConnected(true);
 
-    webrtc.on('connected', callback);
+    webrtc.on("connected", callback);
 
     return () => {
-      webrtc.removeListener('connected', callback);
+      webrtc.removeListener("connected", callback);
     };
   }, []);
 
   return (
-    <div style={{ display: 'flex' }}>
+    <div style={{ display: "flex" }}>
       <div>
         <div>
           <input
@@ -286,37 +284,38 @@ export function App() {
             Update metadata
           </button>
         </div>
-        <div id="connection-status">{connected ? 'true' : 'false'}</div>
+        <div id="connection-status">{connected ? "true" : "false"}</div>
         <hr />
         <MockComponent webrtc={webrtc} />
-        <div style={{ width: '100%' }}>
+        <div style={{ width: "100%" }}>
           {Object.values(remoteTracks).map(
             ({
-               stream,
-               trackId,
-               endpoint,
-               metadata,
-               rawMetadata,
-               metadataParsingError,
-             }) => (
+              stream,
+              trackId,
+              endpoint,
+              metadata,
+              rawMetadata,
+              metadataParsingError,
+            }) => (
               <div
                 key={trackId}
                 data-endpoint-id={endpoint.id}
-                data-stream-id={stream?.id}>
+                data-stream-id={stream?.id}
+              >
                 <div>Endpoint id: {endpoint.id}</div>
-                Metadata:{' '}
+                Metadata:{" "}
                 <code className="metadata">{JSON.stringify(metadata)}</code>
                 <br />
-                Raw:{' '}
+                Raw:{" "}
                 <code className="raw-metadata">
                   {JSON.stringify(rawMetadata)}
                 </code>
                 <br />
-                Error:{' '}
+                Error:{" "}
                 <code className="metadata-parsing-error">
                   {metadataParsingError}
                 </code>
-                <div style={{ display: 'flex', flexDirection: 'column' }}>
+                <div style={{ display: "flex", flexDirection: "column" }}>
                   <VideoPlayerWithDetector
                     id={endpoint.id}
                     stream={stream ?? undefined}
@@ -325,20 +324,21 @@ export function App() {
                 </div>
                 <div data-name="stream-id">{stream?.id}</div>
                 <div>
-                  <button onClick={() => setEncoding(trackId, 'l')}>l</button>
-                  <button onClick={() => setEncoding(trackId, 'm')}>m</button>
-                  <button onClick={() => setEncoding(trackId, 'h')}>h</button>
+                  <button onClick={() => setEncoding(trackId, "l")}>l</button>
+                  <button onClick={() => setEncoding(trackId, "m")}>m</button>
+                  <button onClick={() => setEncoding(trackId, "h")}>h</button>
                 </div>
               </div>
             ),
           )}
         </div>
       </div>
-      <div style={{ borderLeft: '1px solid gray' }}>
+      <div style={{ borderLeft: "1px solid gray" }}>
         Our metadata:
         <input
           value={endpointMetadataInput}
-          onChange={(e) => setEndpointMetadataInput(e.target.value)}></input>
+          onChange={(e) => setEndpointMetadataInput(e.target.value)}
+        ></input>
         <hr />
         <div id="endpoints-container">
           Endpoints:
@@ -346,15 +346,15 @@ export function App() {
             ({ id, metadata, rawMetadata, metadataParsingError }) => (
               <details key={id} open>
                 <summary>{id}</summary>
-                metadata:{' '}
+                metadata:{" "}
                 <code id={`metadata-${id}`}>{JSON.stringify(metadata)}</code>
                 <br />
-                raw metadata:{' '}
+                raw metadata:{" "}
                 <code id={`raw-metadata-${id}`}>
                   {JSON.stringify(rawMetadata)}
                 </code>
                 <br />
-                metadata parsing error:{' '}
+                metadata parsing error:{" "}
                 <code id={`metadata-parsing-error-${id}`}>
                   {metadataParsingError?.toString?.() ?? metadataParsingError}
                 </code>
diff --git a/e2e-tests/ts-client/app/src/MockComponent.tsx b/e2e-tests/ts-client/app/src/MockComponent.tsx
index 2e973faf..045913c5 100644
--- a/e2e-tests/ts-client/app/src/MockComponent.tsx
+++ b/e2e-tests/ts-client/app/src/MockComponent.tsx
@@ -1,25 +1,25 @@
-import { createStream } from './mocks';
-import { VideoPlayer } from './VideoPlayer';
-import { useRef, useState } from 'react';
-import type { EndpointMetadata, TrackMetadata } from './App';
+import { createStream } from "./mocks";
+import { VideoPlayer } from "./VideoPlayer";
+import { useRef, useState } from "react";
+import type { EndpointMetadata, TrackMetadata } from "./App";
 import type {
   BandwidthLimit,
   SimulcastConfig,
   WebRTCEndpoint,
-} from '@fishjam-dev/ts-client';
-import { MuteTrackTest } from './MuteTrackTest';
+} from "@fishjam-dev/ts-client";
+import { MuteTrackTest } from "./MuteTrackTest";
 
 // eslint-disable-next-line react-refresh/only-export-components
-export const brainMock = createStream('🧠', 'white', 'low', 24);
+export const brainMock = createStream("🧠", "white", "low", 24);
 
 // eslint-disable-next-line react-refresh/only-export-components
-export const brain2Mock = createStream('🤯', '#00ff00', 'low', 24);
+export const brain2Mock = createStream("🤯", "#00ff00", "low", 24);
 
 // eslint-disable-next-line react-refresh/only-export-components
-export const heartMock = createStream('🫀', 'white', 'low', 24);
+export const heartMock = createStream("🫀", "white", "low", 24);
 
 // eslint-disable-next-line react-refresh/only-export-components
-export const heart2Mock = createStream('💝', '#FF0000', 'low', 24);
+export const heart2Mock = createStream("💝", "#FF0000", "low", 24);
 
 type Props = {
   webrtc: WebRTCEndpoint<EndpointMetadata, TrackMetadata>;
@@ -29,10 +29,10 @@ export const MockComponent = ({ webrtc }: Props) => {
   const heartId = useRef<Promise<string> | null>(null);
   const brainId = useRef<Promise<string> | null>(null);
   const [replaceStatus, setReplaceStatus] = useState<
-    'unknown' | 'success' | 'failure'
-  >('unknown');
+    "unknown" | "success" | "failure"
+  >("unknown");
   const [trackMetadataInput, setTrackMetadataInput] = useState(
-    JSON.stringify({ goodTrack: 'ye' }),
+    JSON.stringify({ goodTrack: "ye" }),
   );
 
   const addHeart = async () => {
@@ -43,19 +43,19 @@ export const MockComponent = ({ webrtc }: Props) => {
   };
 
   const removeHeart = async () => {
-    if (!heartId.current) throw Error('Heart id is undefined');
+    if (!heartId.current) throw Error("Heart id is undefined");
 
     webrtc.removeTrack(await heartId.current);
   };
 
   const removeBrain = async () => {
-    if (!brainId.current) throw Error('Brain id is undefined');
+    if (!brainId.current) throw Error("Brain id is undefined");
 
     webrtc.removeTrack(await brainId.current);
   };
 
   const replaceHeart = async () => {
-    if (!heartId.current) throw Error('Track Id is not set');
+    if (!heartId.current) throw Error("Track Id is not set");
 
     const stream = heart2Mock.stream;
     const track = stream.getVideoTracks()[0];
@@ -65,11 +65,11 @@ export const MockComponent = ({ webrtc }: Props) => {
       track,
       JSON.parse(trackMetadataInput),
     );
-    setReplaceStatus('success');
+    setReplaceStatus("success");
   };
 
   const replaceBrain = async () => {
-    if (!brainId.current) throw Error('Track Id is not set');
+    if (!brainId.current) throw Error("Track Id is not set");
 
     const stream = brain2Mock.stream;
     const track = stream.getVideoTracks()[0];
diff --git a/e2e-tests/ts-client/app/src/MuteTrackTest.tsx b/e2e-tests/ts-client/app/src/MuteTrackTest.tsx
index d65c54ce..54f5c2d6 100644
--- a/e2e-tests/ts-client/app/src/MuteTrackTest.tsx
+++ b/e2e-tests/ts-client/app/src/MuteTrackTest.tsx
@@ -1,9 +1,9 @@
-import type { WebRTCEndpoint } from '@fishjam-dev/ts-client';
-import { brain2Mock, heart2Mock } from './MockComponent';
-import { useEffect, useState } from 'react';
-import { VideoPlayer } from './VideoPlayer';
-import type { WebRTCEndpointEvents } from '@fishjam-dev/ts-client/webrtc';
-import type { EndpointMetadata, TrackMetadata } from './App';
+import type { WebRTCEndpoint } from "@fishjam-dev/ts-client";
+import { brain2Mock, heart2Mock } from "./MockComponent";
+import { useEffect, useState } from "react";
+import { VideoPlayer } from "./VideoPlayer";
+import type { WebRTCEndpointEvents } from "@fishjam-dev/ts-client/webrtc";
+import type { EndpointMetadata, TrackMetadata } from "./App";
 
 type Props = {
   webrtc: WebRTCEndpoint;
@@ -18,7 +18,7 @@ export const MuteTrackTest = ({ webrtc }: Props) => {
     const localTrackAdded: WebRTCEndpointEvents<
       EndpointMetadata,
       TrackMetadata
-    >['localTrackAdded'] = (event) => {
+    >["localTrackAdded"] = (event) => {
       setCurrentStream(event.stream);
       setCurrentTrack(event.track);
       setTrackId(event.trackId);
@@ -27,16 +27,16 @@ export const MuteTrackTest = ({ webrtc }: Props) => {
     const localTrackReplaced: WebRTCEndpointEvents<
       EndpointMetadata,
       TrackMetadata
-    >['localTrackReplaced'] = (event) => {
+    >["localTrackReplaced"] = (event) => {
       setCurrentTrack(event.track);
     };
 
-    webrtc.on('localTrackAdded', localTrackAdded);
-    webrtc.on('localTrackReplaced', localTrackReplaced);
+    webrtc.on("localTrackAdded", localTrackAdded);
+    webrtc.on("localTrackReplaced", localTrackReplaced);
 
     return () => {
-      webrtc.removeListener('localTrackAdded', localTrackAdded);
-      webrtc.removeListener('localTrackReplaced', localTrackReplaced);
+      webrtc.removeListener("localTrackAdded", localTrackAdded);
+      webrtc.removeListener("localTrackReplaced", localTrackReplaced);
     };
   }, [webrtc]);
 
@@ -47,10 +47,10 @@ export const MuteTrackTest = ({ webrtc }: Props) => {
 
     await webrtc.addTrack(
       track,
-      { goodTrack: 'camera' },
+      { goodTrack: "camera" },
       {
         enabled: true,
-        activeEncodings: ['l', 'm', 'h'],
+        activeEncodings: ["l", "m", "h"],
         disabledEncodings: [],
       },
     );
@@ -61,7 +61,7 @@ export const MuteTrackTest = ({ webrtc }: Props) => {
     stream: MediaStream | null,
     track: MediaStreamTrack | null,
   ) => {
-    if (!trackId) throw Error('Track id is null');
+    if (!trackId) throw Error("Track id is null");
 
     await webrtc.replaceTrack(trackId, track);
   };
@@ -69,25 +69,28 @@ export const MuteTrackTest = ({ webrtc }: Props) => {
   return (
     <div
       style={{
-        display: 'flex',
-        flexDirection: 'column',
-        padding: '8px',
-        borderStyle: 'dotted',
-        borderWidth: '1px',
-        borderColor: 'black',
-      }}>
+        display: "flex",
+        flexDirection: "column",
+        padding: "8px",
+        borderStyle: "dotted",
+        borderWidth: "1px",
+        borderColor: "black",
+      }}
+    >
       <div>
-        <span>track: {currentTrack?.id ?? 'null'}</span>
+        <span>track: {currentTrack?.id ?? "null"}</span>
       </div>
       <div>
         <button
           disabled={!!currentStream || !!trackId}
-          onClick={() => addTrack(heart2Mock.stream)}>
+          onClick={() => addTrack(heart2Mock.stream)}
+        >
           Add heart
         </button>
         <button
           disabled={!!currentStream || !!trackId}
-          onClick={() => addTrack(brain2Mock.stream)}>
+          onClick={() => addTrack(brain2Mock.stream)}
+        >
           Add brain
         </button>
         <button
@@ -97,7 +100,8 @@ export const MuteTrackTest = ({ webrtc }: Props) => {
               heart2Mock.stream,
               heart2Mock.stream.getVideoTracks()[0],
             )
-          }>
+          }
+        >
           Replace with heart
         </button>
         <button
@@ -107,7 +111,8 @@ export const MuteTrackTest = ({ webrtc }: Props) => {
               brain2Mock.stream,
               brain2Mock.stream.getVideoTracks()[0],
             )
-          }>
+          }
+        >
           Replace with brain
         </button>
         <button onClick={() => replaceTrack(trackId, null, null)}>
diff --git a/e2e-tests/ts-client/app/src/VideoPlayer.tsx b/e2e-tests/ts-client/app/src/VideoPlayer.tsx
index 58d46d2e..03a3bc80 100644
--- a/e2e-tests/ts-client/app/src/VideoPlayer.tsx
+++ b/e2e-tests/ts-client/app/src/VideoPlayer.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useRef } from 'react';
+import { useEffect, useRef } from "react";
 
 type Props = {
   stream?: MediaStream;
@@ -16,7 +16,7 @@ export const VideoPlayer = ({ stream, id }: Props) => {
   return (
     <video
       id={id}
-      style={{ maxHeight: '90px' }}
+      style={{ maxHeight: "90px" }}
       autoPlay
       playsInline
       controls={false}
diff --git a/e2e-tests/ts-client/app/src/VideoPlayerWithDetector.tsx b/e2e-tests/ts-client/app/src/VideoPlayerWithDetector.tsx
index 3759e70a..97de14a6 100644
--- a/e2e-tests/ts-client/app/src/VideoPlayerWithDetector.tsx
+++ b/e2e-tests/ts-client/app/src/VideoPlayerWithDetector.tsx
@@ -1,7 +1,7 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
-import type { Pixel } from './mocks';
-import { getPixel } from './mocks';
-import type { WebRTCEndpoint } from '@fishjam-dev/ts-client';
+import { useCallback, useEffect, useRef, useState } from "react";
+import type { Pixel } from "./mocks";
+import { getPixel } from "./mocks";
+import type { WebRTCEndpoint } from "@fishjam-dev/ts-client";
 
 type Props = {
   stream?: MediaStream;
@@ -11,22 +11,23 @@ type Props = {
 
 const rgbToText = (pixel: Pixel): string => {
   const { red, green, blue } = pixel;
-  if (red > 200 && green > 200 && blue > 200) return 'white';
-  if (red < 55 && green < 55 && blue < 55) return 'black';
-  if (red > 200 && green < 55 && blue < 55) return 'red';
-  if (red < 55 && green > 200 && blue < 55) return 'green';
-  if (red < 55 && green < 55 && blue > 200) return 'blue';
+  if (red > 200 && green > 200 && blue > 200) return "white";
+  if (red < 55 && green < 55 && blue < 55) return "black";
+  if (red > 200 && green < 55 && blue < 55) return "red";
+  if (red < 55 && green > 200 && blue < 55) return "green";
+  if (red < 55 && green < 55 && blue > 200) return "blue";
 
-  return 'unknown';
+  return "unknown";
 };
 
 const getTrackIdentifierToInboundRtp = (
   stats: RTCStatsReport,
-): Record<string, any> => { /* eslint-disable-line @typescript-eslint/no-explicit-any */
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+): Record<string, any> => {
   const result: Record<string, object> = {};
 
   stats.forEach((report) => {
-    if (report.type === 'inbound-rtp') {
+    if (report.type === "inbound-rtp") {
       result[report.trackIdentifier] = report;
     }
   });
@@ -36,8 +37,8 @@ const getTrackIdentifierToInboundRtp = (
 
 export const VideoPlayerWithDetector = ({ stream, id, webrtc }: Props) => {
   const videoElementRef = useRef<HTMLVideoElement>(null);
-  const [color, setColor] = useState<string>('');
-  const [decodedFrames, setDecodedFrames] = useState<string>('');
+  const [color, setColor] = useState<string>("");
+  const [decodedFrames, setDecodedFrames] = useState<string>("");
 
   useEffect(() => {
     if (!videoElementRef.current) return;
@@ -45,12 +46,12 @@ export const VideoPlayerWithDetector = ({ stream, id, webrtc }: Props) => {
   }, [stream]);
 
   const getDecodedFrames = useCallback(async () => {
-    const connection = webrtc['connection'];
+    const connection = webrtc["connection"];
     if (!connection) return 0;
 
     const inbound = getTrackIdentifierToInboundRtp(await connection.getStats());
 
-    const trackId = stream?.getVideoTracks()?.[0]?.id ?? '';
+    const trackId = stream?.getVideoTracks()?.[0]?.id ?? "";
 
     return inbound[trackId]?.framesDecoded ?? 0;
   }, [stream, webrtc]);
@@ -70,8 +71,8 @@ export const VideoPlayerWithDetector = ({ stream, id, webrtc }: Props) => {
       const videoElement = videoElementRef.current;
       if (!videoElement || videoElement.videoWidth === 0) return;
 
-      const canvas = document.createElement('canvas');
-      const ctx = canvas.getContext('2d')!;
+      const canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d")!;
 
       canvas.width = videoElement.videoWidth;
       canvas.height = videoElement.videoHeight;
@@ -96,7 +97,7 @@ export const VideoPlayerWithDetector = ({ stream, id, webrtc }: Props) => {
       </div>
       <video
         id={id}
-        style={{ maxHeight: '90px' }}
+        style={{ maxHeight: "90px" }}
         autoPlay
         playsInline
         controls={false}
diff --git a/e2e-tests/ts-client/app/src/main.tsx b/e2e-tests/ts-client/app/src/main.tsx
index de059655..cadecced 100644
--- a/e2e-tests/ts-client/app/src/main.tsx
+++ b/e2e-tests/ts-client/app/src/main.tsx
@@ -1,8 +1,8 @@
-import React from 'react';
-import ReactDOM from 'react-dom/client';
-import { App } from './App';
+import React from "react";
+import ReactDOM from "react-dom/client";
+import { App } from "./App";
 
-ReactDOM.createRoot(document.getElementById('root')!).render(
+ReactDOM.createRoot(document.getElementById("root")!).render(
   <React.StrictMode>
     <App />
   </React.StrictMode>,
diff --git a/e2e-tests/ts-client/app/src/mocks.ts b/e2e-tests/ts-client/app/src/mocks.ts
index 5fbf916c..f545b02a 100644
--- a/e2e-tests/ts-client/app/src/mocks.ts
+++ b/e2e-tests/ts-client/app/src/mocks.ts
@@ -1,7 +1,7 @@
 export const canvasWidth = 320;
 export const canvasHeight = 180;
 
-export type Quality = 'low' | 'medium' | 'high';
+export type Quality = "low" | "medium" | "high";
 type QualityMultiplier = 1 | 2 | 4;
 
 const QUALITY_MULTIPLIER: Record<Quality, QualityMultiplier> = {
@@ -52,14 +52,14 @@ export const createStream: (
   framerate: number,
 ) => {
   const multiplier = QUALITY_MULTIPLIER[quality];
-  const canvasElement = document.createElement('canvas');
+  const canvasElement = document.createElement("canvas");
   const currentCanvasWidth = canvasWidth * multiplier;
   const currentCanvasHeight = canvasHeight * multiplier;
 
   canvasElement.width = currentCanvasWidth;
   canvasElement.height = currentCanvasHeight;
-  const ctx = canvasElement.getContext('2d');
-  if (!ctx) throw 'ctx is null';
+  const ctx = canvasElement.getContext("2d");
+  if (!ctx) throw "ctx is null";
   const fontSize = 120 * multiplier;
 
   let degree = 0;
@@ -78,7 +78,7 @@ export const createStream: (
     ctx.font = `${fontSize}px Calibri`;
     ctx.translate(translateX, translateY);
     ctx.rotate(radian);
-    ctx.fillStyle = '#FFFFFF';
+    ctx.fillStyle = "#FFFFFF";
     ctx.fillText(emoji, -fontSize / 2, +fontSize / 2);
     ctx.rotate(-radian);
     ctx.translate(-translateX, -translateY);
diff --git a/e2e-tests/ts-client/app/tsconfig.json b/e2e-tests/ts-client/app/tsconfig.json
index f31856b9..df9af620 100644
--- a/e2e-tests/ts-client/app/tsconfig.json
+++ b/e2e-tests/ts-client/app/tsconfig.json
@@ -1,10 +1,6 @@
 {
   "compilerOptions": {
-    "lib": [
-      "dom",
-      "dom.iterable",
-      "es2022"
-    ],
+    "lib": ["dom", "dom.iterable", "es2022"],
     "module": "esnext",
     "moduleResolution": "bundler",
     "target": "es2022",
@@ -18,7 +14,5 @@
     "noFallthroughCasesInSwitch": true,
     "outDir": "dist"
   },
-  "include": [
-    "src/**/*"
-  ]
+  "include": ["src/**/*"]
 }
diff --git a/e2e-tests/ts-client/app/vite.config.ts b/e2e-tests/ts-client/app/vite.config.ts
index 627a3196..9cc50ead 100644
--- a/e2e-tests/ts-client/app/vite.config.ts
+++ b/e2e-tests/ts-client/app/vite.config.ts
@@ -1,5 +1,5 @@
-import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
 
 // https://vitejs.dev/config/
 export default defineConfig({
diff --git a/examples/ts-client/simple-app/src/main.ts b/examples/ts-client/simple-app/src/main.ts
index 16edc39e..131a6d2a 100644
--- a/examples/ts-client/simple-app/src/main.ts
+++ b/examples/ts-client/simple-app/src/main.ts
@@ -12,7 +12,6 @@ const SCREEN_SHARING_MEDIA_CONSTRAINTS = {
   },
 };
 
-
 /* eslint-disable no-console */
 
 const peerTokenInput =
@@ -209,8 +208,7 @@ client.on("peerJoined", (peer: Peer<PeerMetadata, TrackMetadata>) => {
   toastInfo(`New peer joined`);
 });
 
-client.on("peerUpdated", (_peer) => {
-});
+client.on("peerUpdated", (_peer) => {});
 
 client.on("peerLeft", (peer) => {
   const peerComponent = document.querySelector(
@@ -339,8 +337,7 @@ client.on("trackAdded", (ctx) => {
     )!;
     activeEncodingElement.innerHTML = ctx.encoding ?? "";
   });
-  ctx.on("voiceActivityChanged", () => {
-  });
+  ctx.on("voiceActivityChanged", () => {});
 });
 
 client.on("trackRemoved", (ctx) => {
@@ -350,14 +347,11 @@ client.on("trackRemoved", (ctx) => {
   tracksContainer?.remove();
 });
 
-client.on("trackUpdated", (_ctx) => {
-});
+client.on("trackUpdated", (_ctx) => {});
 
-client.on("bandwidthEstimationChanged", (_estimation) => {
-});
+client.on("bandwidthEstimationChanged", (_estimation) => {});
 
-client.on("tracksPriorityChanged", (_enabledTracks, _disabledTracks) => {
-});
+client.on("tracksPriorityChanged", (_enabledTracks, _disabledTracks) => {});
 
 connectButton.addEventListener("click", () => {
   console.log("Connect");
@@ -440,11 +434,13 @@ enumerateDevicesButton.addEventListener("click", async () => {
         .querySelector(".start-template-btn")
         .addEventListener("click", () => {
           console.log("Start");
-          navigator.mediaDevices.getUserMedia({ video: true }).then((stream) => {
-            console.log("Connecting stream");
-            videoPlayer.srcObject = stream;
-            videoPlayer.play();
-          });
+          navigator.mediaDevices
+            .getUserMedia({ video: true })
+            .then((stream) => {
+              console.log("Connecting stream");
+              videoPlayer.srcObject = stream;
+              videoPlayer.play();
+            });
         });
       clone
         .querySelector(".stop-template-btn")
diff --git a/packages/ts-client/src/webrtc/bitrate.ts b/packages/ts-client/src/webrtc/bitrate.ts
index 82ea6951..448eea61 100644
--- a/packages/ts-client/src/webrtc/bitrate.ts
+++ b/packages/ts-client/src/webrtc/bitrate.ts
@@ -1,4 +1,9 @@
-import type { RemoteTrackId, TrackContext, TrackEncoding, TrackKind } from './types';
+import type {
+  RemoteTrackId,
+  TrackContext,
+  TrackEncoding,
+  TrackKind,
+} from './types';
 import { type BandwidthLimit } from './types';
 import type { TrackContextImpl } from './internal';
 import { findSender } from './RTCPeerConnectionUtils';
diff --git a/packages/ts-client/src/webrtc/index.ts b/packages/ts-client/src/webrtc/index.ts
index bf0d9c71..3c0f5638 100644
--- a/packages/ts-client/src/webrtc/index.ts
+++ b/packages/ts-client/src/webrtc/index.ts
@@ -12,7 +12,7 @@ export type {
   EncodingReason,
   Config,
   MetadataParser,
-  TrackKind
+  TrackKind,
 } from './types';
 
 export { WebRTCEndpoint } from './webRTCEndpoint';
diff --git a/packages/ts-client/src/webrtc/transceivers.ts b/packages/ts-client/src/webrtc/transceivers.ts
index abdcdb80..351ee9d4 100644
--- a/packages/ts-client/src/webrtc/transceivers.ts
+++ b/packages/ts-client/src/webrtc/transceivers.ts
@@ -1,13 +1,16 @@
-import type { EndpointWithTrackContext, TrackContextImpl } from "./internal";
-import type { RemoteTrackId } from "./types";
+import type { EndpointWithTrackContext, TrackContextImpl } from './internal';
+import type { RemoteTrackId } from './types';
 
-type Mid = string
+type Mid = string;
 type TrackId = string;
-type MidToTrackId = Record<Mid, TrackId>
+type MidToTrackId = Record<Mid, TrackId>;
 
 export const getMidToTrackId = <EndpointMetadata, TrackMetadata>(
   connection: RTCPeerConnection | undefined,
-  localTrackIdToTrack: Map<RemoteTrackId, TrackContextImpl<EndpointMetadata, TrackMetadata>>,
+  localTrackIdToTrack: Map<
+    RemoteTrackId,
+    TrackContextImpl<EndpointMetadata, TrackMetadata>
+  >,
   midToTrackId: Map<string, string> = new Map(),
   localEndpoint: EndpointWithTrackContext<EndpointMetadata, TrackMetadata>,
 ): MidToTrackId | null => {
@@ -15,35 +18,55 @@ export const getMidToTrackId = <EndpointMetadata, TrackMetadata>(
 
   // - negotiated unmuted tracks: tracks added in previous negotiation, data is being transmitted
   // - not yet negotiated tracks: tracks added in this negotiation, data will be transmitted after successful negotiation
-  const mappingFromTransceivers = getTransceiverMapping(connection, localTrackIdToTrack)
+  const mappingFromTransceivers = getTransceiverMapping(
+    connection,
+    localTrackIdToTrack,
+  );
 
   // - negotiated unmuted tracks: tracks added in previous negotiation, data is being transmitted
   // - negotiated muted tracks: tracks added in previous negotiation, data is not being transmitted but can be transmitted in the future
-  const mappingFromLocalNegotiatedTracks = getAllNegotiatedLocalTracksMapping(midToTrackId, localEndpoint)
+  const mappingFromLocalNegotiatedTracks = getAllNegotiatedLocalTracksMapping(
+    midToTrackId,
+    localEndpoint,
+  );
 
   return { ...mappingFromTransceivers, ...mappingFromLocalNegotiatedTracks };
 };
 
-const getTrackContext = <EndpointMetadata, TrackMetadata>(localTrackIdToTrack: Map<RemoteTrackId, TrackContextImpl<EndpointMetadata, TrackMetadata>>, localTrackId: string) => Array.from(localTrackIdToTrack.values()).find(
-  (trackContext) => trackContext?.track?.id === localTrackId,
-)!;
+const getTrackContext = <EndpointMetadata, TrackMetadata>(
+  localTrackIdToTrack: Map<
+    RemoteTrackId,
+    TrackContextImpl<EndpointMetadata, TrackMetadata>
+  >,
+  localTrackId: string,
+) =>
+  Array.from(localTrackIdToTrack.values()).find(
+    (trackContext) => trackContext?.track?.id === localTrackId,
+  )!;
 
 const getTransceiverMapping = <EndpointMetadata, TrackMetadata>(
   connection: RTCPeerConnection,
-  localTrackIdToTrack: Map<RemoteTrackId, TrackContextImpl<EndpointMetadata, TrackMetadata>>,
+  localTrackIdToTrack: Map<
+    RemoteTrackId,
+    TrackContextImpl<EndpointMetadata, TrackMetadata>
+  >,
 ): MidToTrackId =>
-  connection.getTransceivers()
+  connection
+    .getTransceivers()
     .filter((transceiver) => transceiver.sender.track?.id && transceiver.mid)
-    .reduce((acc, transceiver) => {
-      const localTrackId = transceiver.sender.track!.id;
-      const mid = transceiver!.mid!;
+    .reduce(
+      (acc, transceiver) => {
+        const localTrackId = transceiver.sender.track!.id;
+        const mid = transceiver!.mid!;
 
-      const trackContext = getTrackContext(localTrackIdToTrack, localTrackId);
+        const trackContext = getTrackContext(localTrackIdToTrack, localTrackId);
 
-      acc[mid] = trackContext.trackId;
+        acc[mid] = trackContext.trackId;
 
-      return acc
-    }, {} as Record<Mid, TrackId>);
+        return acc;
+      },
+      {} as Record<Mid, TrackId>,
+    );
 
 const getAllNegotiatedLocalTracksMapping = <EndpointMetadata, TrackMetadata>(
   midToTrackId: Map<string, string> = new Map(),
@@ -51,9 +74,12 @@ const getAllNegotiatedLocalTracksMapping = <EndpointMetadata, TrackMetadata>(
 ): MidToTrackId => {
   return [...midToTrackId.entries()]
     .filter(([_mid, trackId]) => localEndpoint.tracks.get(trackId))
-    .reduce((acc, [mid, trackId]) => {
-      acc[mid] = trackId;
+    .reduce(
+      (acc, [mid, trackId]) => {
+        acc[mid] = trackId;
 
-      return acc
-    }, {} as Record<Mid, TrackId>);
-}
+        return acc;
+      },
+      {} as Record<Mid, TrackId>,
+    );
+};
diff --git a/packages/ts-client/src/webrtc/webRTCEndpoint.ts b/packages/ts-client/src/webrtc/webRTCEndpoint.ts
index 9c57cc4c..913e95df 100644
--- a/packages/ts-client/src/webrtc/webRTCEndpoint.ts
+++ b/packages/ts-client/src/webrtc/webRTCEndpoint.ts
@@ -32,8 +32,12 @@ import type { EndpointWithTrackContext } from './internal';
 import { TrackContextImpl, isTrackKind } from './internal';
 import { handleVoiceActivationDetectionNotification } from './voiceActivityDetection';
 import { applyBandwidthLimitation } from './bandwidth';
-import { createTrackVariantBitratesEvent, getTrackBitrates, getTrackIdToTrackBitrates, } from './bitrate';
-import { getMidToTrackId } from "./transceivers";
+import {
+  createTrackVariantBitratesEvent,
+  getTrackBitrates,
+  getTrackIdToTrackBitrates,
+} from './bitrate';
+import { getMidToTrackId } from './transceivers';
 
 /**
  * Main class that is responsible for connecting to the RTC Engine, sending and receiving media.
@@ -42,7 +46,7 @@ export class WebRTCEndpoint<
   EndpointMetadata = any,
   TrackMetadata = any,
 > extends (EventEmitter as {
-  new<EndpointMetadata, TrackMetadata>(): TypedEmitter<
+  new <EndpointMetadata, TrackMetadata>(): TypedEmitter<
     Required<WebRTCEndpointEvents<EndpointMetadata, TrackMetadata>>
   >;
 })<EndpointMetadata, TrackMetadata> {
@@ -724,7 +728,7 @@ export class WebRTCEndpoint<
       this.trackMetadataParser,
     );
 
-    if (!isTrackKind(track.kind)) throw new Error("Track has no kind")
+    if (!isTrackKind(track.kind)) throw new Error('Track has no kind');
 
     trackContext.track = track;
     trackContext.stream = stream;
@@ -1428,7 +1432,7 @@ export class WebRTCEndpoint<
             this.connection,
             this.localTrackIdToTrack,
             this.midToTrackId,
-            this.localEndpoint
+            this.localEndpoint,
           ),
         },
       });
@@ -1459,7 +1463,9 @@ export class WebRTCEndpoint<
     trackId: string,
     endpoint: EndpointWithTrackContext<EndpointMetadata, TrackMetadata>,
   ) =>
-    Array.from(endpoint.tracks.keys()).some((track) => trackId.startsWith(track));
+    Array.from(endpoint.tracks.keys()).some((track) =>
+      trackId.startsWith(track),
+    );
 
   private onOfferData = async (offerData: MediaEvent) => {
     if (!this.connection) {
@@ -1596,7 +1602,7 @@ export class WebRTCEndpoint<
 
       if (this.checkIfTrackBelongToEndpoint(trackId, this.localEndpoint))
         return;
-      if (!isTrackKind(event.track.kind)) throw new Error("Track has no kind")
+      if (!isTrackKind(event.track.kind)) throw new Error('Track has no kind');
 
       const trackContext = this.trackIdToTrack.get(trackId)!;