mediasfu-shared 1.0.1 → 1.0.3

package/src/consumers/changeVids.ts

@@ -1,78 +1,146 @@
 
  
-import { Stream, Participant, DispStreamsType, DispStreamsParameters, AudioDecibels, MixStreamsType, BreakoutParticipant, EventType } from "../types/types";
+import { Stream, Participant, AudioDecibels, EventType } from "../types/types";
+
+interface ChangeVidsStreamLike {
+  producerId?: string | null;
+  audioID?: string | null;
+  name?: string;
+  muted?: boolean | null;
+  stream?: unknown;
+}
+
+interface ChangeVidsParticipantLike {
+  name: string;
+  islevel?: string | null;
+  videoID?: string | null;
+  audioID?: string | null;
+  muted?: boolean | null;
+  breakRoom?: number | null;
+  stream?: unknown;
+}
 
-export interface ChangeVidsParameters extends DispStreamsParameters {
+interface BreakoutParticipantLike {
+  name: string;
+  breakRoom?: number | null;
+}
+
+interface AudioDecibelLike {
+  name: string;
+  averageLoudness?: number | null;
+}
 
-  allVideoStreams: (Stream | Participant)[];
+type BooleanUpdater = (value: boolean) => void;
+type NumberUpdater = (value: number) => void;
+type StringListUpdater = (names: string[]) => void;
+
+type EntryArrayUpdater<TEntry> = {
+  bivarianceHack: (entries: TEntry[]) => void;
+}["bivarianceHack"];
+
+type EntryMatrixUpdater<TEntry> = {
+  bivarianceHack: (entries: TEntry[][]) => void;
+}["bivarianceHack"];
+
+type MixStreamsInvoker<TEntry, TParticipant> = (options: {
+  alVideoStreams: TEntry[];
+  non_alVideoStreams: TParticipant[];
+  ref_participants: TEntry[];
+}) => Promise<TEntry[]>;
+
+type DispStreamsInvoker = (options: {
+  lStreams: any[];
+  ind: number;
+  auto?: boolean;
+  parameters: any;
+  breakRoom?: number;
+  inBreakRoom?: boolean;
+  ChatSkip?: boolean;
+  forChatCard?: any;
+  forChatID?: any;
+}) => Promise<void>;
+
+export interface ChangeVidsParameters<
+  TStream extends ChangeVidsStreamLike = Stream,
+  TParticipant extends ChangeVidsParticipantLike = Participant,
+  TBreakoutParticipant extends BreakoutParticipantLike = BreakoutParticipantLike,
+  TAudioDecibel extends AudioDecibelLike = AudioDecibels,
+  TMediaHandle = unknown,
+> {
+
+  allVideoStreams: (TStream | TParticipant)[];
   p_activeNames: string[];
   activeNames: string[];
   dispActiveNames: string[];
   shareScreenStarted: boolean;
   shared: boolean;
-  newLimitedStreams: (Stream | Participant)[];
-  non_alVideoStreams: Participant[];
-  ref_participants: Participant[];
-  participants: Participant[];
+  newLimitedStreams: (TStream | TParticipant)[];
+  non_alVideoStreams: TParticipant[];
+  ref_participants: TParticipant[];
+  participants: TParticipant[];
   eventType: EventType;
   islevel: string;
   member: string;
   sortAudioLoudness: boolean;
-  audioDecibels: AudioDecibels[];
-  mixed_alVideoStreams: (Stream | Participant)[];
-  non_alVideoStreams_muted: Participant[];
+  audioDecibels: TAudioDecibel[];
+  mixed_alVideoStreams: (TStream | TParticipant)[];
+  non_alVideoStreams_muted: TParticipant[];
   remoteProducerId?: string;
-  localStreamVideo: MediaStream | null;
-  oldAllStreams: (Stream | Participant)[];
+  localStreamVideo: TMediaHandle | null;
+  oldAllStreams: (TStream | TParticipant)[];
   screenPageLimit: number;
   meetingDisplayType: string;
   meetingVideoOptimized: boolean;
   recordingVideoOptimized: boolean;
   recordingDisplayType: "video" | "media" | "all";
-  paginatedStreams: (Stream | Participant)[][];
+  paginatedStreams: (TStream | TParticipant)[][];
   itemPageLimit: number;
   doPaginate: boolean;
   prevDoPaginate: boolean;
   currentUserPage: number;
-  breakoutRooms: BreakoutParticipant[][];
+  breakoutRooms: TBreakoutParticipant[][];
   hostNewRoom: number;
   breakOutRoomStarted: boolean;
   breakOutRoomEnded: boolean;
-  virtualStream: MediaStream | null;
+  virtualStream: TMediaHandle | null;
   mainRoomsLength: number;
   memberRoom: number;
-  updateP_activeNames: (names: string[]) => void;
-  updateActiveNames: (names: string[]) => void;
-  updateDispActiveNames: (names: string[]) => void;
-  updateNewLimitedStreams: (streams: (Stream | Participant)[]) => void;
-  updateNon_alVideoStreams: (participants: Participant[]) => void;
-  updateRef_participants: (participants: Participant[]) => void;
-  updateSortAudioLoudness: (sort: boolean) => void;
-  updateMixed_alVideoStreams: (streams: (Stream | Participant)[]) => void;
-  updateNon_alVideoStreams_muted: (participants: Participant[]) => void;
-  updatePaginatedStreams: (streams: (Stream | Participant)[][]) => void;
-  updateDoPaginate: (paginate: boolean) => void;
-  updatePrevDoPaginate: (paginate: boolean) => void;
-  updateCurrentUserPage: (page: number) => void;
-  updateNumberPages: (pages: number) => void;
-  updateMainRoomsLength: (length: number) => void;
-  updateMemberRoom: (room: number) => void;
+  updateP_activeNames: StringListUpdater;
+  updateActiveNames: StringListUpdater;
+  updateDispActiveNames: StringListUpdater;
+  updateNewLimitedStreams: EntryArrayUpdater<TStream | TParticipant>;
+  updateNon_alVideoStreams: EntryArrayUpdater<TParticipant>;
+  updateRef_participants: EntryArrayUpdater<TParticipant>;
+  updateSortAudioLoudness: BooleanUpdater;
+  updateMixed_alVideoStreams: EntryArrayUpdater<TStream | TParticipant>;
+  updateNon_alVideoStreams_muted: EntryArrayUpdater<TParticipant>;
+  updatePaginatedStreams: EntryMatrixUpdater<TStream | TParticipant>;
+  updateDoPaginate: BooleanUpdater;
+  updatePrevDoPaginate: BooleanUpdater;
+  updateCurrentUserPage: NumberUpdater;
+  updateNumberPages: NumberUpdater;
+  updateMainRoomsLength: NumberUpdater;
+  updateMemberRoom: NumberUpdater;
 
   // mediasfu functions
-  mixStreams: MixStreamsType;
-  dispStreams: DispStreamsType;
-  getUpdatedAllParams: () => ChangeVidsParameters;
+  mixStreams: MixStreamsInvoker<TStream | TParticipant, TParticipant>;
+  dispStreams: DispStreamsInvoker;
+  getUpdatedAllParams: () => ChangeVidsParameters<TStream, TParticipant, TBreakoutParticipant, TAudioDecibel, TMediaHandle>;
   [key: string]: any;
 
 }
 
-export interface ChangeVidsOptions {
+export interface ChangeVidsOptions<
+  TParameters extends ChangeVidsParameters<any, any, any, any, any> = ChangeVidsParameters,
+> {
   screenChanged?: boolean;
-  parameters: ChangeVidsParameters;
+  parameters: TParameters;
 }
 
 // Export the type definition for the function
-export type ChangeVidsType = (options: ChangeVidsOptions) => Promise<void>;
+export type ChangeVidsType = <
+  TParameters extends ChangeVidsParameters<any, any, any, any, any> = ChangeVidsParameters,
+>(options: ChangeVidsOptions<TParameters>) => Promise<void>;
 
 /**
  * Asynchronously changes the video streams based on the provided options.
@@ -210,9 +278,11 @@ export type ChangeVidsType = (options: ChangeVidsOptions) => Promise<void>;
  *   });
  */
 
-export const changeVids = async ({ screenChanged = false, parameters }: ChangeVidsOptions): Promise<void> => {
-  let { getUpdatedAllParams } = parameters;
-  parameters = getUpdatedAllParams();
+export const changeVids = async <
+  TParameters extends ChangeVidsParameters<any, any, any, any, any> = ChangeVidsParameters,
+>({ screenChanged = false, parameters }: ChangeVidsOptions<TParameters>): Promise<void> => {
+  const { getUpdatedAllParams } = parameters;
+  const updatedParameters = getUpdatedAllParams() as TParameters;
 
   let {
     allVideoStreams,
@@ -270,7 +340,7 @@ export const changeVids = async ({ screenChanged = false, parameters }: ChangeVi
     updateMemberRoom,
     mixStreams,
     dispStreams,
-  } = parameters;
+  } = updatedParameters;
 
   try {
     let alVideoStreams = [...allVideoStreams];

package/src/consumers/checkPermission.ts

@@ -1,9 +1,13 @@
+import { PermissionConfig } from '../methods/permissions/updatePermissionConfig';
+
 export interface CheckPermissionOptions {
   audioSetting: string;
   videoSetting: string;
   screenshareSetting: string;
   chatSetting: string;
   permissionType: 'audioSetting' | 'videoSetting' | 'screenshareSetting' | 'chatSetting';
+  permissionConfig?: PermissionConfig | null;
+  participantLevel?: string;
 }
 
 // Export the type definition for the function
@@ -39,9 +43,39 @@ export type CheckPermissionType = (options: CheckPermissionOptions) => Promise<n
  *   });
  */
 
-export async function checkPermission({ permissionType, audioSetting, videoSetting, screenshareSetting, chatSetting }: CheckPermissionOptions) {
+export async function checkPermission({
+  permissionType,
+  audioSetting,
+  videoSetting,
+  screenshareSetting,
+  chatSetting,
+  permissionConfig,
+  participantLevel,
+}: CheckPermissionOptions) {
   try {
 
+    const permissionTypeToCapability: Record<string, keyof import('../methods/permissions/updatePermissionConfig').PermissionCapabilities> = {
+      audioSetting: 'useMic',
+      videoSetting: 'useCamera',
+      screenshareSetting: 'useScreen',
+      chatSetting: 'useChat',
+    };
+
+    if (permissionConfig && participantLevel && participantLevel !== '2') {
+      const levelKey = `level${participantLevel}` as 'level0' | 'level1';
+      const levelConfig = permissionConfig[levelKey];
+
+      if (levelConfig) {
+        const capability = permissionTypeToCapability[permissionType];
+        if (capability) {
+          const configValue = levelConfig[capability];
+          if (configValue === 'allow') return 0;
+          if (configValue === 'approval') return 1;
+          return 2;
+        }
+      }
+    }
+
     // PermissionType is audioSetting, videoSetting, screenshareSetting, chatSetting
     // Perform a switch case to check for the permissionType and return the response
     switch (permissionType) {

package/src/consumers/connectIps.ts

@@ -125,13 +125,15 @@ export const connectIps = async ({
           }
 
           // Handle new pipe producer event
-          remote_sock.on("new-pipe-producer", async ({ producerId, islevel }: { producerId: string; islevel: string }) => {
+          remote_sock.on("new-pipe-producer", async ({ producerId, islevel, isTranslation, translationMeta }: { producerId: string; islevel: string; isTranslation?: boolean; translationMeta?: { speakerId: string; speakerName: string; language: string; originalProducerId?: string; isSpeakerControlled?: boolean } }) => {
             if (newProducerMethod) {
               await newProducerMethod({
                 producerId,
                 islevel,
                 nsock: remote_sock,
                 parameters,
+                isTranslation,
+                translationMeta,
               });
             }
           });

package/src/consumers/connectLocalIps.ts

@@ -76,13 +76,15 @@ export const connectLocalIps = async ({
 
     // Connect to the remote socket using socket.io-client
     // Handle new pipe producer event
-    socket.on("new-producer", async ({ producerId, islevel }: { producerId: string; islevel: string }) => {
+    socket.on("new-producer", async ({ producerId, islevel, isTranslation, translationMeta }: { producerId: string; islevel: string; isTranslation?: boolean; translationMeta?: { speakerId: string; speakerName: string; language: string; originalProducerId?: string } }) => {
       if (newProducerMethod) {
         await newProducerMethod({
           producerId,
           islevel,
           nsock: socket,
           parameters,
+          isTranslation,
+          translationMeta,
         });
       }
     });

package/src/consumers/connectRecvTransport.ts

@@ -1,6 +1,84 @@
 import { Socket } from "socket.io-client";
-import { ConsumerResumeType, ConsumerResumeParameters, Transport as TransportType } from "../types/types";
+import { ConsumerResumeType, ConsumerResumeParameters, Transport as TransportType, Participant } from "../types/types";
 import type { Consumer, Device, Transport } from "mediasoup-client/lib/types";
+
+interface SpeakerTranslationState {
+  speakerId: string;
+  speakerName: string;
+  inputLanguage: string;
+  outputLanguage: string;
+  originalProducerId: string;
+  enabled: boolean;
+}
+
+const getSpeakerNameForProducerId = (
+  producerId: string,
+  parameters: Record<string, any>,
+): string | undefined => {
+  const participants = parameters.participants as Participant[] | undefined;
+  const participant = participants?.find((candidate) => candidate.audioID === producerId);
+
+  if (participant?.name) {
+    return participant.name;
+  }
+
+  const audStreamName = (parameters.audStreamNames as Array<{ producerId?: string; name?: string }> | undefined)
+    ?.find((stream) => stream.producerId === producerId && typeof stream.name === 'string');
+  if (audStreamName?.name) {
+    return audStreamName.name;
+  }
+
+  return (parameters.allAudioStreams as Array<{ producerId?: string; name?: string }> | undefined)
+    ?.find((stream) => stream.producerId === producerId && typeof stream.name === 'string')
+    ?.name;
+};
+
+const isOriginalAudioSuppressedByTranslation = (
+  producerId: string,
+  parameters: Record<string, any>,
+): boolean => {
+  const activeTranslationProducerIds = parameters.activeTranslationProducerIds as Set<string> | undefined;
+  if (activeTranslationProducerIds?.has(producerId)) {
+    return false;
+  }
+
+  const speakerTranslationStates = parameters.speakerTranslationStates as
+    | Map<string, SpeakerTranslationState>
+    | undefined;
+
+  if (!speakerTranslationStates?.size) {
+    return false;
+  }
+
+  const speakerName = getSpeakerNameForProducerId(producerId, parameters);
+
+  if (speakerName) {
+    const speakerState = speakerTranslationStates.get(speakerName);
+    if (speakerState?.enabled) {
+      return true;
+    }
+  }
+
+  return Array.from(speakerTranslationStates.values()).some((speakerState) => {
+    if (!speakerState?.enabled) {
+      return false;
+    }
+
+    if (speakerState.originalProducerId === producerId) {
+      return true;
+    }
+
+    if (!speakerName) {
+      return false;
+    }
+
+    return (
+      speakerState.speakerId === speakerName ||
+      speakerState.speakerName === speakerName
+    );
+  });
+};
+
 interface Params {
   id: string;
   producerId: string;
@@ -14,6 +92,7 @@ export interface ConnectRecvTransportParameters extends ConsumerResumeParameters
   device: Device | null;
   consumerTransports: TransportType[];
   updateConsumerTransports: (transports: TransportType[]) => void;
+  speakerTranslationStates?: Map<string, SpeakerTranslationState>;
 
   // mediasfu functions
   consumerResume: ConsumerResumeType;
@@ -137,6 +216,22 @@ export const connectRecvTransport = async ({
                     nsock,
                     consumer,
                   });
+
+                  if (params.kind === 'audio') {
+                    try {
+                      const updatedParams = parameters.getUpdatedAllParams();
+                      if (isOriginalAudioSuppressedByTranslation(remoteProducerId, updatedParams)) {
+                        consumer.pause();
+                        nsock.emit(
+                          'consumer-pause',
+                          { serverConsumerId: params.serverConsumerId },
+                          () => {},
+                        );
+                        return;
+                      }
+                    } catch {
+                    }
+                  }
                 } catch (error) {
                   // Handle error
                   console.log("consumerResume error", error);

package/src/consumers/consumerResume.ts

@@ -2,6 +2,7 @@
 // This is a React component in the original and not needed for the shared package
 
 import { Socket } from 'socket.io-client';
+import { createFrameworkConsumerContractError } from './frameworkConsumerContract';
 
 export interface ConsumerResumeParameters {
   [key: string]: any;
@@ -20,6 +21,5 @@ export interface ConsumerResumeOptions {
 export type ConsumerResumeType = (options: ConsumerResumeOptions) => Promise<void>;
 
 export const consumerResume: ConsumerResumeType = async () => {
-  // Stub implementation - actual logic handled in framework-specific packages
-  console.warn('consumerResume called on shared package - should be implemented in framework package');
+  throw createFrameworkConsumerContractError('consumerResume');
 };

package/src/consumers/dispStreams.ts

@@ -1,15 +1,52 @@
 import {
-  Stream, Participant, Transport, PrepopulateUserMediaParameters, PrepopulateUserMediaType, RePortParameters, RePortType,
-  ProcessConsumerTransportsParameters, ProcessConsumerTransportsType, ResumePauseStreamsParameters, ResumePauseStreamsType, ReadjustParameters, ReadjustType, AddVideosGridType, AddVideosGridParameters, GetEstimateType, CheckGridType, ResumePauseAudioStreamsParameters, ResumePauseAudioStreamsType, GetEstimateParameters,
+  Stream, Participant, Transport,
   EventType
 } from "../types/types";
 
-export interface DispStreamsParameters extends PrepopulateUserMediaParameters, RePortParameters, ProcessConsumerTransportsParameters, ResumePauseStreamsParameters, ReadjustParameters, ResumePauseAudioStreamsParameters, GetEstimateParameters, AddVideosGridParameters {
-  consumerTransports: Transport[];
-  streamNames: Stream[];
-  audStreamNames: Stream[];
-  participants: Participant[];
-  ref_participants: Participant[];
+interface DispStreamEntryLike<TMediaStream = MediaStream> {
+  producerId?: string | null;
+  audioID?: string | null;
+  id?: string | null;
+  name?: string | null;
+  muted?: boolean | null;
+  stream?: TMediaStream | null;
+}
+
+interface DispParticipantLike<TMediaStream = MediaStream> extends DispStreamEntryLike<TMediaStream> {
+  name: string;
+  islevel?: string | null;
+  videoID?: string | null;
+}
+
+type StreamCollectionUpdater<TEntry> = {
+  bivarianceHack: (streams: TEntry[]) => void;
+}["bivarianceHack"];
+
+type OpaqueAsyncInvoker = {
+  bivarianceHack: (options: any) => Promise<any>;
+}["bivarianceHack"];
+
+type EstimateResult = [unknown, number, number, ...unknown[]];
+
+type OpaqueEstimateInvoker = {
+  bivarianceHack: (options: any) => EstimateResult;
+}["bivarianceHack"];
+
+type OpaqueCheckGridInvoker = {
+  bivarianceHack: (options: any) => Promise<any> | any;
+}["bivarianceHack"];
+
+export interface DispStreamsParameters<
+  TStream extends DispStreamEntryLike<any> = Stream,
+  TParticipant extends DispParticipantLike<any> = Participant,
+  TTransport = Transport,
+  TMediaStream = MediaStream,
+> {
+  consumerTransports: TTransport[];
+  streamNames: TStream[];
+  audStreamNames: TStream[];
+  participants: TParticipant[];
+  ref_participants: TParticipant[];
   recordingDisplayType: 'video' | 'media' | 'all';
   recordingVideoOptimized: boolean;
   meetingDisplayType: string;
@@ -24,7 +61,7 @@ export interface DispStreamsParameters extends PrepopulateUserMediaParameters, R
   shared: boolean;
   shareScreenStarted: boolean;
   shareEnded: boolean;
-  oldAllStreams: (Stream | Participant)[];
+  oldAllStreams: (TStream | TParticipant)[];
   updateMainWindow: boolean;
   remoteProducerId?: string;
   activeNames: string[];
@@ -33,53 +70,59 @@ export interface DispStreamsParameters extends PrepopulateUserMediaParameters, R
   nForReadjustRecord: number;
   first_round: boolean;
   lock_screen: boolean;
-  chatRefStreams: (Stream | Participant)[];
+  chatRefStreams: (TStream | TParticipant)[];
   eventType: EventType;
   islevel: string;
-  localStreamVideo: MediaStream | null;
+  localStreamVideo: TMediaStream | null;
 
   breakOutRoomStarted: boolean;
   breakOutRoomEnded: boolean;
   keepBackground: boolean;
-  virtualStream: MediaStream | null;
+  virtualStream: TMediaStream | null;
 
   updateActiveNames: (names: string[]) => void;
   updateDispActiveNames: (names: string[]) => void;
-  updateLStreams: (streams: (Stream | Participant)[]) => void;
-  updateChatRefStreams: (streams: (Stream | Participant)[]) => void;
+  updateLStreams: StreamCollectionUpdater<TStream | TParticipant>;
+  updateChatRefStreams: StreamCollectionUpdater<TStream | TParticipant>;
   updateNForReadjustRecord: (n: number) => void;
   updateUpdateMainWindow: (value: boolean) => void;
   updateShowMiniView: (value: boolean) => void;
 
   // mediasfu functions
-  prepopulateUserMedia: PrepopulateUserMediaType;
-  rePort: RePortType;
-  processConsumerTransports: ProcessConsumerTransportsType;
-  resumePauseStreams: ResumePauseStreamsType;
-  readjust: ReadjustType;
-  addVideosGrid: AddVideosGridType;
-  getEstimate: GetEstimateType;
-  checkGrid: CheckGridType;
-  resumePauseAudioStreams: ResumePauseAudioStreamsType;
-
-  getUpdatedAllParams: () => DispStreamsParameters;
+  prepopulateUserMedia: OpaqueAsyncInvoker;
+  rePort: OpaqueAsyncInvoker;
+  processConsumerTransports: OpaqueAsyncInvoker;
+  resumePauseStreams: OpaqueAsyncInvoker;
+  readjust: OpaqueAsyncInvoker;
+  addVideosGrid: OpaqueAsyncInvoker;
+  getEstimate: OpaqueEstimateInvoker;
+  checkGrid: OpaqueCheckGridInvoker;
+  resumePauseAudioStreams: OpaqueAsyncInvoker;
+
+  getUpdatedAllParams: () => DispStreamsParameters<TStream, TParticipant, TTransport, TMediaStream>;
   [key: string]: any;
 }
 
-export interface DispStreamsOptions {
-  lStreams: (Stream | Participant)[];
+export interface DispStreamsOptions<
+  TParameters extends DispStreamsParameters<any, any, any, any> = DispStreamsParameters,
+> {
+  lStreams: TParameters extends DispStreamsParameters<infer TStream, infer TParticipant, any, any>
+    ? (TStream | TParticipant)[]
+    : (Stream | Participant)[];
   ind: number;
   auto?: boolean;
   ChatSkip?: boolean;
   forChatCard?: any;
   forChatID?: any;
-  parameters: DispStreamsParameters;
+  parameters: TParameters;
   breakRoom?: number;
   inBreakRoom?: boolean;
 }
 
 // Export the type definition for the function
-export type DispStreamsType = (options: DispStreamsOptions) => Promise<void>;
+export type DispStreamsType = <
+  TParameters extends DispStreamsParameters<any, any, any, any> = DispStreamsParameters,
+>(options: DispStreamsOptions<TParameters>) => Promise<void>;
 
 /**
  * Function to display streams based on various parameters and conditions.
@@ -173,7 +216,9 @@ export type DispStreamsType = (options: DispStreamsOptions) => Promise<void>;
  *   });
  */
 
-export async function dispStreams({
+export async function dispStreams<
+  TParameters extends DispStreamsParameters<any, any, any, any> = DispStreamsParameters,
+>({
   lStreams,
   ind,
   auto = false,
@@ -182,11 +227,12 @@ export async function dispStreams({
   parameters,
   breakRoom = -1,
   inBreakRoom = false,
-}: DispStreamsOptions): Promise<void> {
+}: DispStreamsOptions<TParameters>): Promise<void> {
   // Function to display streams
 
-  let { getUpdatedAllParams } = parameters;
-  parameters = getUpdatedAllParams();
+  const { getUpdatedAllParams } = parameters;
+  const updatedParameters = getUpdatedAllParams() as TParameters;
+  parameters = updatedParameters;
 
   let {
     consumerTransports,
@@ -547,11 +593,11 @@ export async function dispStreams({
   }
 
   if (eventType == "broadcast") {
-    lStreams = lStreams_;
+    lStreams = lStreams_ as typeof lStreams;
     updateLStreams(lStreams);
   } else if (eventType == "chat") {
     if (forChatID != null) {
-      lStreams = chatRefStreams;
+      lStreams = chatRefStreams as typeof lStreams;
       updateLStreams(lStreams);
     } else {
       updateShowMiniView(false);
@@ -581,7 +627,7 @@ export async function dispStreams({
               //remove any stream with name of host.name
               lStreams = lStreams.filter((stream) => {
                 return stream.name != host.name;
-              });
+              }) as typeof lStreams;
 
               lStreams.push(streame);
             }
@@ -598,7 +644,7 @@ export async function dispStreams({
         return (
           stream.producerId != "youyou" && stream.producerId != "youyouyou"
         );
-      });
+      }) as typeof lStreams;
 
       if (youyou) {
         lStreams.push(youyou);

package/src/consumers/frameworkConsumerContract.ts

@@ -0,0 +1,6 @@
+export const createFrameworkConsumerContractError = (consumerName: string): Error => {
+  return new Error(
+    `${consumerName} is a render-coupled consumer helper and has no shared runtime implementation. ` +
+      `Inject the framework-specific ${consumerName} implementation instead of calling the shared fallback export.`
+  );
+};