mediasfu-shared 1.0.6 → 1.2.0

package/src/methods/utils/headless/viewerSession.ts

@@ -0,0 +1,246 @@
+/**
+ * Viewers who are part of a session without joining the room.
+ *
+ * **Why this exists.** Joining a MediaSFU room auto-consumes WebRTC: the SDK
+ * creates consumers from the server's `newProducer` events, unconditionally —
+ * there is no receive-nothing mode. For a large passive audience watching over
+ * HLS that is pure waste: transports, consumers and layout churn for media they
+ * will never render. Joining and then pausing the consumers is worse than it
+ * looks, because the layout pass keeps resuming them.
+ *
+ * So an HLS viewer does not join at all. They hold a *viewer session* instead —
+ * enough to be counted, to raise a hand, and to be told when the host approves —
+ * and they only perform a real SDK join at the moment they reach the floor.
+ *
+ * How that session is stored is deliberately not decided here. The transport,
+ * lifecycle and state machine are the SDK's business; issuing playback URLs and
+ * tracking presence belong to whatever backend you run. You supply a
+ * `ViewerSessionProvider`; this drives it. Same reasoning as `hlsFactory`: the
+ * SDK owns the mechanism, the app owns the dependency.
+ */
+
+export type ViewerSessionPhase =
+  | 'idle'
+  | 'joining'
+  | 'watching'
+  | 'requested'
+  | 'approved'
+  | 'left'
+  | 'error';
+
+export interface ViewerSessionIdentity {
+  /** Opaque id for this viewer, issued by the provider. */
+  viewerId: string;
+  /** The room being watched. */
+  roomName: string;
+  /** Where to play from. Absent until the provider issues one. */
+  playbackUrl?: string;
+  /** 'hls' or 'whep'; inferred from the URL when omitted. */
+  protocol?: 'hls' | 'whep';
+  /** Anything the provider needs handed back on later calls. */
+  token?: string;
+  [key: string]: any;
+}
+
+export interface ViewerSessionStatus {
+  /** True once the host has approved this viewer for the floor. */
+  approved: boolean;
+  /** True while a request is outstanding. */
+  pending?: boolean;
+  /** Free-text reason when a request was refused. */
+  reason?: string;
+  /** Provider may refresh the playback URL (signed URLs expire). */
+  playbackUrl?: string;
+}
+
+/**
+ * What your backend has to do. Only `join` is required — a provider that just
+ * hands back a playback URL is a valid provider, it simply cannot support
+ * promotion.
+ */
+export interface ViewerSessionProvider {
+  join(options: {
+    roomName: string;
+    displayName?: string;
+    signal?: AbortSignal;
+  }): Promise<ViewerSessionIdentity>;
+  /** Keep the viewer counted as present. */
+  heartbeat?(options: { session: ViewerSessionIdentity; signal?: AbortSignal }): Promise<void>;
+  /** Raise a hand for the floor. */
+  requestPromotion?(options: { session: ViewerSessionIdentity; signal?: AbortSignal }): Promise<void>;
+  /** Has the host decided yet? */
+  poll?(options: { session: ViewerSessionIdentity; signal?: AbortSignal }): Promise<ViewerSessionStatus>;
+  /** Release the session. */
+  leave?(options: { session: ViewerSessionIdentity }): Promise<void>;
+}
+
+export interface ViewerSessionSnapshot {
+  phase: ViewerSessionPhase;
+  session: ViewerSessionIdentity | null;
+  status: ViewerSessionStatus | null;
+  error: string;
+  /** True when the provider can accept a promotion request at all. */
+  canRequestPromotion: boolean;
+}
+
+export interface CreateViewerSessionOptions {
+  provider: ViewerSessionProvider;
+  roomName: string;
+  displayName?: string;
+  /** Poll interval for approval, ms. Defaults to 5000. */
+  pollIntervalMs?: number;
+  /** Heartbeat interval, ms. Defaults to 30000. Ignored without a heartbeat. */
+  heartbeatIntervalMs?: number;
+  /** Called on every state change. */
+  onChange?: (snapshot: ViewerSessionSnapshot) => void;
+}
+
+export interface ViewerSessionHandle {
+  /** Current state, readable at any time. */
+  getSnapshot: () => ViewerSessionSnapshot;
+  /** Register with the provider and begin watching. */
+  start: () => Promise<ViewerSessionSnapshot>;
+  /** Raise a hand for the floor. */
+  requestPromotion: () => Promise<ViewerSessionSnapshot>;
+  /** Stop everything and release the session. */
+  stop: () => Promise<void>;
+}
+
+const MIN_INTERVAL_MS = 1000;
+
+/**
+ * Drive a viewer session.
+ *
+ * Deliberately framework-agnostic — no hooks, no observables — so the same
+ * implementation serves React, Vue and Angular. Wrap it in whatever your
+ * framework prefers.
+ *
+ * @example
+ * ```ts
+ * const viewer = createViewerSession({
+ *   provider: myProvider,
+ *   roomName,
+ *   onChange: (snapshot) => setState(snapshot),
+ * });
+ * await viewer.start();                     // watching over HLS, never joined
+ * await viewer.requestPromotion();          // hand raised
+ * // when snapshot.phase === 'approved', perform a real SDK join.
+ * ```
+ */
+export function createViewerSession({
+  provider,
+  roomName,
+  displayName,
+  pollIntervalMs = 5000,
+  heartbeatIntervalMs = 30000,
+  onChange,
+}: CreateViewerSessionOptions): ViewerSessionHandle {
+  let snapshot: ViewerSessionSnapshot = {
+    phase: 'idle',
+    session: null,
+    status: null,
+    error: '',
+    canRequestPromotion: typeof provider?.requestPromotion === 'function',
+  };
+  let pollTimer: any = null;
+  let heartbeatTimer: any = null;
+  let stopped = false;
+
+  const emit = (next: Partial<ViewerSessionSnapshot>) => {
+    snapshot = { ...snapshot, ...next };
+    try {
+      onChange?.(snapshot);
+    } catch {
+      // A consumer's observer must never break the session.
+    }
+  };
+
+  const clearTimers = () => {
+    if (pollTimer) { clearInterval(pollTimer); pollTimer = null; }
+    if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+  };
+
+  const startTimers = () => {
+    clearTimers();
+    if (typeof provider.poll === 'function') {
+      pollTimer = setInterval(async () => {
+        if (stopped || !snapshot.session) return;
+        try {
+          const status = await provider.poll!({ session: snapshot.session });
+          if (stopped) return;
+          // A refreshed URL matters: signed playback URLs expire mid-session,
+          // and a silently dead player looks like a broken stream.
+          const session = status?.playbackUrl
+            ? { ...snapshot.session, playbackUrl: status.playbackUrl }
+            : snapshot.session;
+          emit({
+            status,
+            session,
+            phase: status?.approved ? 'approved' : snapshot.phase === 'requested' ? 'requested' : 'watching',
+          });
+          // Once approved there is nothing left to poll for.
+          if (status?.approved) clearTimers();
+        } catch {
+          // Transient poll failures are normal; the session is not lost.
+        }
+      }, Math.max(MIN_INTERVAL_MS, pollIntervalMs));
+    }
+    if (typeof provider.heartbeat === 'function') {
+      heartbeatTimer = setInterval(() => {
+        if (stopped || !snapshot.session) return;
+        Promise.resolve(provider.heartbeat!({ session: snapshot.session })).catch(() => {});
+      }, Math.max(MIN_INTERVAL_MS, heartbeatIntervalMs));
+    }
+  };
+
+  return {
+    getSnapshot: () => snapshot,
+
+    async start() {
+      if (snapshot.phase !== 'idle' && snapshot.phase !== 'left' && snapshot.phase !== 'error') {
+        return snapshot;
+      }
+      stopped = false;
+      emit({ phase: 'joining', error: '' });
+      try {
+        const session = await provider.join({ roomName, displayName });
+        if (stopped) return snapshot;
+        if (!session?.viewerId) throw new Error('The viewer session provider returned no viewerId.');
+        emit({ phase: 'watching', session, error: '' });
+        startTimers();
+      } catch (error: any) {
+        emit({ phase: 'error', error: error?.message || 'The viewer session could not start.' });
+      }
+      return snapshot;
+    },
+
+    async requestPromotion() {
+      if (!snapshot.session) {
+        emit({ error: 'Start the viewer session before requesting the floor.' });
+        return snapshot;
+      }
+      if (typeof provider.requestPromotion !== 'function') {
+        emit({ error: 'This viewer session provider does not support promotion.' });
+        return snapshot;
+      }
+      try {
+        await provider.requestPromotion({ session: snapshot.session });
+        emit({ phase: 'requested', error: '' });
+      } catch (error: any) {
+        emit({ error: error?.message || 'The request could not be sent.' });
+      }
+      return snapshot;
+    },
+
+    async stop() {
+      stopped = true;
+      clearTimers();
+      const session = snapshot.session;
+      emit({ phase: 'left' });
+      if (session && typeof provider.leave === 'function') {
+        // Best-effort: teardown often runs during unload.
+        try { await provider.leave({ session }); } catch { /* ignore */ }
+      }
+    },
+  };
+}

package/src/methods/utils/headless/virtualBackground.ts

@@ -0,0 +1,280 @@
+import { SelfieSegmentation } from '@mediapipe/selfie_segmentation';
+import { HeadlessOptions } from './headlessTypes';
+import { getCurrentParams } from './getCurrentParams';
+import { getLocalVideoStream } from './getMediaStreams';
+import { HeadlessActionResult } from './roomActions';
+import { compositeVirtualBackgroundFrame } from '../virtualBackgroundCompositor';
+
+const MEDIAPIPE_CDN = 'https://cdn.jsdelivr.net/npm/@mediapipe/selfie_segmentation';
+
+/**
+ * One running background session. Kept module-level because the pipeline owns
+ * real resources (a MediaPipe instance, a RAF loop, an offscreen canvas) that
+ * must be torn down exactly once, and because a second call should replace the
+ * first rather than stack another loop on the same camera.
+ */
+interface BackgroundSession {
+  stop: () => void;
+  stream: MediaStream;
+  /** A live raw-camera clone that can be returned to the producer on clear. */
+  restoreTrack: MediaStreamTrack | null;
+}
+let session: BackgroundSession | null = null;
+
+function loadImage(src: string): Promise<HTMLImageElement> {
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    // Backgrounds are usually served cross-origin; without this the canvas is
+    // tainted and captureStream() throws a SecurityError instead of producing
+    // frames — a failure that looks like "virtual background silently does nothing".
+    image.crossOrigin = 'anonymous';
+    image.onload = () => resolve(image);
+    image.onerror = () => reject(new Error('The background image could not be loaded.'));
+    image.src = src;
+  });
+}
+
+export interface ApplyVirtualBackgroundOptions extends HeadlessOptions {
+  /**
+   * Background image URL, or a ready `HTMLImageElement` / `HTMLCanvasElement`.
+   * Pass `null` to segment the person onto a transparent background.
+   */
+  image: string | HTMLImageElement | HTMLCanvasElement | null;
+  /** Capture frame rate for the processed stream. Defaults to 30. */
+  frameRate?: number;
+  /** MediaPipe model: 0 = general, 1 = landscape (faster). Defaults to 1. */
+  modelSelection?: 0 | 1;
+  /**
+   * Replace the live producer's track so remote viewers see the background
+   * immediately. Defaults to true; set false to preview locally first.
+   */
+  publish?: boolean;
+  /**
+   * Where to load the MediaPipe model and wasm from. Defaults to the jsDelivr
+   * CDN. Point this at a self-hosted copy of
+   * `node_modules/@mediapipe/selfie_segmentation` for offline or air-gapped
+   * deployments, or where a Content-Security-Policy forbids the CDN.
+   * A trailing slash is added if missing.
+   */
+  assetPath?: string;
+}
+
+export type ApplyVirtualBackgroundType = (
+  options: ApplyVirtualBackgroundOptions
+) => Promise<HeadlessActionResult & { stream: MediaStream | null }>;
+
+/**
+ * Apply a virtual background headlessly — no modal, no DOM of your own.
+ *
+ * The SDK's own background support lives inside `BackgroundModal`, whose apply
+ * path is bound to that component's refs (a preview `<video>` and a `<canvas>`)
+ * and is driven by `autoClickBackground` / `isBackgroundModalVisible`. A
+ * `returnUI={false}` surface therefore had no way to turn a background on
+ * without mounting the modal off-screen and simulating a click.
+ *
+ * This runs the same MediaPipe pipeline the modal uses — identical compositing:
+ * draw the segmentation mask, retain the person with `source-in`, then paint
+ * the replacement behind them with `destination-over` — against an offscreen video and
+ * canvas it creates and owns.
+ *
+ * It also keeps the SDK's own state honest (`virtualStream`, `processedStream`,
+ * `keepBackground`), so `getLocalVideoStream` keeps returning the right
+ * self-view without the caller choosing. Callers should not select the
+ * processed stream themselves.
+ *
+ * The camera must already be on: this processes `localStreamVideo`, it does not
+ * acquire one.
+ *
+ * @example
+ * ```ts
+ * await applyVirtualBackground({ parameters, image: '/backgrounds/office.jpg' });
+ * await clearVirtualBackground({ parameters });
+ * ```
+ */
+export async function applyVirtualBackground({
+  parameters,
+  image,
+  frameRate = 30,
+  modelSelection = 1,
+  publish = true,
+  assetPath = MEDIAPIPE_CDN,
+}: ApplyVirtualBackgroundOptions): Promise<HeadlessActionResult & { stream: MediaStream | null }> {
+  const live = getCurrentParams({ parameters });
+  if (live.audioOnlyRoom) {
+    return { ok: false, error: 'You cannot use a background in an audio-only event.', stream: null };
+  }
+  if (typeof document === 'undefined' || typeof window === 'undefined') {
+    return { ok: false, error: 'Virtual backgrounds require a browser environment.', stream: null };
+  }
+
+  // Always process the *raw* camera. Reading through getLocalVideoStream would
+  // feed an already-processed stream back through segmentation once a
+  // background is running, compounding artefacts on every change.
+  const camera = (live.localStreamVideo as MediaStream | null)
+    || getLocalVideoStream({ parameters: live });
+  const sourceTrack = camera?.getVideoTracks?.()[0] || null;
+  if (!sourceTrack || sourceTrack.readyState !== 'live') {
+    return { ok: false, error: 'Turn your camera on before applying a background.', stream: null };
+  }
+
+  const previousSession = session;
+  let candidateStop: (() => void) | null = null;
+  try {
+    const settings = sourceTrack.getSettings ? sourceTrack.getSettings() : {};
+    const width = Number(settings.width) || 640;
+    const height = Number(settings.height) || 360;
+
+    const backgroundImage = typeof image === 'string' ? await loadImage(image) : image;
+    const producer = publish ? (live.videoProducer || live.localVideoProducer) : null;
+
+    // mediasoup Producers normally own their track (`stopTracks: true`). Their
+    // replaceTrack operation therefore stops the old raw track. Keep MediaPipe
+    // on an isolated clone and retain a second live clone for a clean clear.
+    const processingTrack = sourceTrack.clone?.();
+    if (!processingTrack) throw new Error('This camera cannot create the isolated track required for a virtual background.');
+    const restoreTrack = producer ? sourceTrack.clone?.() : sourceTrack;
+    if (!restoreTrack) {
+      processingTrack.stop();
+      throw new Error('This camera cannot preserve a track for restoring the original view.');
+    }
+
+    const video = document.createElement('video');
+    video.autoplay = true;
+    video.muted = true;
+    video.playsInline = true;
+    video.srcObject = new MediaStream([processingTrack]);
+    await video.play().catch(() => {});
+
+    const canvas = document.createElement('canvas');
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) throw new Error('This browser cannot composite a background.');
+
+    const base = assetPath.endsWith('/') ? assetPath.slice(0, -1) : assetPath;
+    const segmentation = new SelfieSegmentation({
+      locateFile: (file: string) => `${base}/${file}`,
+    });
+    segmentation.setOptions({ modelSelection, selfieMode: false });
+    await segmentation.initialize();
+
+    // Same compositing as the SDK's modal, so the result is visually identical.
+    segmentation.onResults((results: any) => {
+      try {
+        if (!canvas.width || !canvas.height) return;
+        compositeVirtualBackgroundFrame({
+          ctx,
+          segmentationMask: results.segmentationMask,
+          sourceImage: results.image,
+          backgroundImage: backgroundImage as CanvasImageSource | null,
+          width: canvas.width,
+          height: canvas.height,
+        });
+      } catch {
+        // A dropped frame must never kill the loop.
+      }
+    });
+
+    let stopped = false;
+    let frameHandle = 0;
+    const pump = async () => {
+      if (stopped) return;
+      try {
+        if (video.readyState >= 2) await segmentation.send({ image: video });
+      } catch {
+        // Ignore a single failed frame; the next one is already queued.
+      }
+      frameHandle = window.requestAnimationFrame(() => { void pump(); });
+    };
+    void pump();
+
+    const processed: MediaStream = (canvas as any).captureStream(frameRate);
+    if (!processed?.getVideoTracks?.().length) {
+      throw new Error('The processed background stream produced no video track.');
+    }
+
+    const stop = () => {
+      if (stopped) return;
+      stopped = true;
+      window.cancelAnimationFrame(frameHandle);
+      try { segmentation.close(); } catch { /* already closed */ }
+      processed.getTracks().forEach((track) => track.stop());
+      processingTrack.stop();
+      video.srcObject = null;
+    };
+    candidateStop = stop;
+
+    if (producer) {
+      const track = processed.getVideoTracks()[0];
+      if (producer && typeof producer.replaceTrack === 'function' && track) {
+        // replaceTrack avoids renegotiation, so remote viewers see the
+        // background appear without the call visibly reconnecting.
+        await producer.replaceTrack({ track });
+      }
+      if (camera?.removeTrack && camera?.addTrack && restoreTrack !== sourceTrack) {
+        camera.removeTrack(sourceTrack);
+        camera.addTrack(restoreTrack);
+        if (sourceTrack.readyState === 'live') sourceTrack.stop();
+      }
+    }
+
+    previousSession?.stop();
+    session = { stop, stream: processed, restoreTrack };
+    candidateStop = null;
+    live.updateVirtualStream?.(processed);
+    live.updateProcessedStream?.(processed);
+    live.updateKeepBackground?.(true);
+
+    return { ok: true, error: '', stream: processed };
+  } catch (error: any) {
+    candidateStop?.();
+    return {
+      ok: false,
+      error: error?.message || 'The virtual background could not be applied.',
+      stream: null,
+    };
+  }
+}
+
+export type ClearVirtualBackgroundType = (
+  options: HeadlessOptions
+) => Promise<HeadlessActionResult>;
+
+/**
+ * Remove the virtual background and go back to the raw camera.
+ *
+ * Restores the original camera track on the live producer before tearing the
+ * pipeline down, so viewers transition straight from processed to raw rather
+ * than through a frozen or black frame.
+ */
+export async function clearVirtualBackground({
+  parameters,
+}: HeadlessOptions): Promise<HeadlessActionResult> {
+  const live = getCurrentParams({ parameters });
+  const active = session;
+  if (!active) {
+    live.updateKeepBackground?.(false);
+    return { ok: true, error: '' };
+  }
+  try {
+    const producer = live.videoProducer || live.localVideoProducer;
+    const original = active.restoreTrack;
+    if (producer && typeof producer.replaceTrack === 'function'
+      && original && original.readyState === 'live') {
+      await producer.replaceTrack({ track: original });
+    }
+    active.stop();
+    session = null;
+    live.updateVirtualStream?.(null);
+    live.updateProcessedStream?.(null);
+    live.updateKeepBackground?.(false);
+    return { ok: true, error: '' };
+  } catch (error: any) {
+    return { ok: false, error: error?.message || 'The virtual background could not be cleared.' };
+  }
+}
+
+/** True while a headless background pipeline is running in this tab. */
+export function isVirtualBackgroundRunning(): boolean {
+  return session !== null;
+}

package/src/methods/utils/resolveMediaSFURoomApi.ts

@@ -1,4 +1,4 @@
-const DEFAULT_MEDIA_SFU_ROOM_API_URL = 'https://mediasfu.com/v1/rooms/';
+const DEFAULT_MEDIA_SFU_ROOM_API_URL = 'https://mediasfu.com/v1/rooms/';
 
 type MediaSFURoomApiAction = 'createRoom' | 'joinRoom';
 
@@ -28,4 +28,4 @@ export const resolveMediaSFURoomApi = (
   }
 
   return `${normalizedLink.replace(/\/$/, '')}/${action}`;
-};
+};

package/src/methods/utils/virtualBackgroundCompositor.ts

@@ -0,0 +1,53 @@
+/** Options for composing one segmented camera frame. */
+export interface CompositeVirtualBackgroundFrameOptions {
+  ctx: CanvasRenderingContext2D;
+  segmentationMask: CanvasImageSource;
+  sourceImage: CanvasImageSource;
+  backgroundImage?: CanvasImageSource | null;
+  width: number;
+  height: number;
+  repeatPattern?: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
+  blurFallbackPixels?: number;
+}
+
+/**
+ * Paint the segmented person over a replacement background.
+ *
+ * Keeping this operation in the shared runtime makes headless web adapters and
+ * the React SDK use the same compositing contract. It is deliberately not
+ * exported from the native entry point; native platforms use their camera
+ * processor instead of a browser canvas.
+ */
+export function compositeVirtualBackgroundFrame({
+  ctx,
+  segmentationMask,
+  sourceImage,
+  backgroundImage = null,
+  width,
+  height,
+  repeatPattern = 'repeat',
+  blurFallbackPixels = 0,
+}: CompositeVirtualBackgroundFrameOptions): void {
+  const previousFilter = ctx.filter;
+  ctx.save();
+  try {
+    ctx.clearRect(0, 0, width, height);
+    ctx.globalCompositeOperation = 'source-over';
+    ctx.drawImage(segmentationMask, 0, 0, width, height);
+    ctx.globalCompositeOperation = 'source-in';
+    ctx.drawImage(sourceImage, 0, 0, width, height);
+    ctx.globalCompositeOperation = 'destination-over';
+    if (backgroundImage) {
+      const pattern = ctx.createPattern(backgroundImage, repeatPattern);
+      ctx.fillStyle = pattern || 'transparent';
+      ctx.fillRect(0, 0, width, height);
+    } else if (blurFallbackPixels > 0) {
+      ctx.filter = `blur(${blurFallbackPixels}px)`;
+      ctx.drawImage(sourceImage, 0, 0, width, height);
+    }
+  } finally {
+    ctx.filter = previousFilter || 'none';
+    ctx.globalCompositeOperation = 'source-over';
+    ctx.restore();
+  }
+}

package/src/methods/whiteboard/captureCanvasStream.ts

@@ -1,4 +1,4 @@
-import type { Producer } from 'mediasoup-client/lib/types';
+import type { Producer } from 'mediasoup-client/types';
 import type {
   ConnectSendTransportScreenParameters,
   ConnectSendTransportScreenType,
@@ -125,4 +125,4 @@ export const captureCanvasStream = async ({
   } catch (error) {
     console.error(error, 'error in captureCanvasStream');
   }
-};
+};

package/src/producers/producerEmits/joinConRoom.ts

@@ -1,6 +1,6 @@
 import { Socket } from "socket.io-client";
 import { validateAlphanumeric } from "../../methods/utils/validateAlphanumeric"; // Import the validateAlphanumeric function from the validateAlphanumeric file
-import type { RtpCapabilities } from "mediasoup-client/lib/types";
+import type { RtpCapabilities } from "mediasoup-client/types";
 
 export interface JoinConRoomOptions {
   socket: Socket;

package/src/producers/producerEmits/joinRoom.ts

@@ -1,5 +1,5 @@
 import { Socket } from 'socket.io-client';
-import type { RtpCapabilities } from 'mediasoup-client/lib/types';
+import type { RtpCapabilities } from 'mediasoup-client/types';
 import { validateAlphanumeric } from '../../methods/utils/validateAlphanumeric';
 
 export interface JoinRoomOptions {

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './types';

package/src/types/shared-base-types.ts

@@ -1,6 +1,6 @@
 import { Socket } from 'socket.io-client';
-import type { Consumer, DtlsParameters, IceCandidate, IceParameters, ProducerCodecOptions, RtpCapabilities } from 'mediasoup-client/lib/types';
-import type { RtpEncodingParameters } from 'mediasoup-client/lib/types';
+import type { Consumer, DtlsParameters, IceCandidate, IceParameters, ProducerCodecOptions, RtpCapabilities } from 'mediasoup-client/types';
+import type { RtpEncodingParameters } from 'mediasoup-client/types';
 
 export interface Participant {
   id?: string;
@@ -760,4 +760,3 @@ export type MessageParticipantsType = (options: any) => void;
 export type RemoveParticipantsType = (options: any) => Promise<void>;
 
 // Consumer types - import from consumer-types file
-