sceyt-call 1.3.1 → 1.3.2

package/README.md

@@ -13,6 +13,8 @@ JavaScript SDK for real-time voice and video calls with WebRTC. This SDK works a
 * [Call Events](#call-events)
 * [Client Events](#client-events)
 * [Call Management](#call-management)
+* [Remote Participant Control](#remote-participant-control)
+* [Call Permissions](#call-permissions)
 * [Call History (CDR)](#call-history-cdr)
 * [Participant States](#participant-states)
 * [Logging](#logging)
@@ -90,7 +92,7 @@ call.on('participantStateChanged', ({ participant, state }) => {
 ```typescript
 // Audio controls
 call.mute(true);       // Mute microphone
-call.mute(false);      // Unmute
+call.mute(false);      // Unmute (blocked if hard-muted by host or call audio is locked)
 call.hold(true);       // Put on hold
 
 // Video controls
@@ -170,7 +172,7 @@ await call.switchToSFU(handleError);
 - `call.enableVideo(enabled, errorCallback?)` — camera/signal errors via callback
 - `call.startScreenShare(errorCallback?)` — screen share errors via callback
 - `call.stopScreenShare(errorCallback?)` — signal errors via callback
-- `call.mute(mute, errorCallback?)` — signal errors via callback
+- `call.mute(mute, errorCallback?)` — signal errors via callback; returns error immediately if hard-muted
 - `call.switchToSFU(errorCallback?)` — signal errors via callback
 - `call.leave()` — no callback, check return value
 
@@ -206,8 +208,10 @@ call.on('videoTrackAdded', ({ participant, track }) => {
   videoElement.srcObject = new MediaStream([track]);
 });
 
-call.on('participantEvent', ({ participant, event }) => {
-  // event: 'Mute' | 'Unmute' | 'Hold' | 'VideoEnabled' | etc.
+call.on('participantEvent', ({ participant, event, changedBy }) => {
+  // event: 'Mute' | 'Unmute' | 'Hold' | 'VideoEnabled' | 'VideoDisabled' |
+  //        'ScreenSharingStarted' | 'ScreenSharingStopped' | etc.
+  // changedBy: userId of whoever triggered the change (e.g. a host muting a participant)
 });
 
 call.on('activeSpeakersChanged', ({ activeSpeakers }) => {
@@ -217,6 +221,18 @@ call.on('activeSpeakersChanged', ({ activeSpeakers }) => {
 call.on('sessionRenewed', ({ call, sessionId }) => {
   // Fired when the server assigns a new sessionId to an existing call
 });
+
+call.on('callPermissionsUpdated', ({ call, permissions }) => {
+  // Fired when the host updates call-level audio/video permissions
+  console.log('Audio allowed:', permissions.allowPublishAudio);
+  console.log('Video allowed:', permissions.allowPublishVideo);
+});
+
+call.on('participantPermissionsUpdated', ({ call, participant, permissions }) => {
+  // Fired when a participant's individual permissions are updated by the host
+  console.log(`${participant.id} canPublishAudio: ${permissions.canPublishAudio}`);
+  console.log(`${participant.id} canPublishVideo: ${permissions.canPublishVideo}`);
+});
 ```
 
 ## Client Events
@@ -266,6 +282,103 @@ const speakers = call?.activeSpeakers;
 const { data } = await callClient.fetchCall('call-id');
 ```
 
+## Remote Participant Control
+
+Host participants can mute, disable video, or update permissions for other participants in the call. All methods return `CallClientResult<boolean>` and accept an optional error callback.
+
+### Mute / Unmute Remote Participants
+
+```typescript
+// Mute a specific participant (soft-mute — they can unmute themselves)
+call.muteRemoteParticipant('user1');
+
+// Hard-mute: revoke publish-audio permission (they cannot unmute)
+call.disableRemoteParticipantAudio('user1');
+
+// Restore audio permission (allow them to unmute)
+call.enableRemoteParticipantAudio('user1');
+// or equivalently:
+call.unmuteRemoteParticipant('user1');
+
+// Mute all participants at once
+call.muteAllRemoteParticipants();
+```
+
+### Disable Video for Remote Participants
+
+```typescript
+// Turn off a specific participant's video
+call.disableRemoteParticipantVideo('user1');
+// or equivalently:
+call.videoOffRemoteParticipant('user1');
+
+// Turn off video for all participants
+call.videoOffAllRemoteParticipants();
+// or equivalently:
+call.disableAllRemoteParticipantsVideo();
+```
+
+### Update Participant Permissions
+
+```typescript
+import type { IParticipantPermissions } from 'sceyt-call';
+
+// Grant or revoke individual publish permissions
+call.updateParticipantPermissions('user1', {
+  canPublishAudio: true,
+  canPublishVideo: false,
+});
+```
+
+## Call Permissions
+
+The host can lock audio or video at the call level, preventing all participants from publishing.
+
+```typescript
+import type { ICallPermissions } from 'sceyt-call';
+
+// Lock audio for the entire call
+call.disableCallAudio();
+
+// Restore audio for the entire call
+call.enableCallAudio();
+
+// Lock video for the entire call
+call.disableCallVideo();
+
+// Restore video for the entire call
+call.enableCallVideo();
+
+// Update both at once
+call.updateCallPermissions({ allowPublishAudio: false, allowPublishVideo: true });
+```
+
+Current call-level permissions are exposed on the `call.permissions` property:
+
+```typescript
+console.log(call.permissions?.allowPublishAudio); // boolean | undefined
+console.log(call.permissions?.allowPublishVideo); // boolean | undefined
+```
+
+### Participant-level media state
+
+Each participant now exposes a structured `mediaState` object instead of the old flat `muted`, `videoEnabled`, and `screenSharing` boolean fields:
+
+```typescript
+const p = call.participants[0];
+
+console.log(p.mediaState?.audio.enabled);           // mic on/off
+console.log(p.mediaState?.video.enabled);           // camera on/off
+console.log(p.mediaState?.screenShare.enabled);     // screen share on/off
+
+// changedBy tells you who last changed the state (e.g. a host action)
+console.log(p.mediaState?.audio.changedBy);
+
+// Individual publish permissions assigned by the host
+console.log(p.permissions?.canPublishAudio);
+console.log(p.permissions?.canPublishVideo);
+```
+
 ## Call History (CDR)
 
 ```typescript
@@ -318,6 +431,10 @@ import type {
   CallEventMap,
   CallClientEventMap,
   ICallDetailRecord,
+  ICallPermissions,
+  IParticipantPermissions,
+  IParticipantMediaState,
+  IMediaState,
   ParticipantState,
   CallState,
   MediaFlow

package/index.d.ts

@@ -215,6 +215,8 @@ export interface CallSettings {
 	maxParticipantsCount?: number;
 	/** Type identifier for the call (e.g. 'audio', 'video', custom string) */
 	callType?: string;
+	/** Call-level audio/video permissions set by the owner */
+	permissions: ICallPermissions;
 }
 /**
  * Options for creating a call.
@@ -276,11 +278,29 @@ interface SignalCallSettings {
 	persistent?: boolean;
 	notifyOnParticipantJoin?: boolean;
 	maxParticipantsCount?: number;
+	permissions: ICallPermissions;
 }
 interface SignalCallOptions {
 	settings?: SignalCallSettings;
 	callType?: string;
 }
+interface IMediaState {
+	enabled: boolean;
+	changedBy?: string;
+}
+interface IParticipantMediaState {
+	audio: IMediaState;
+	video: IMediaState;
+	screenShare: IMediaState;
+}
+interface IParticipantPermissions {
+	canPublishAudio: boolean;
+	canPublishVideo: boolean;
+}
+interface ICallPermissions {
+	allowPublishAudio: boolean;
+	allowPublishVideo: boolean;
+}
 /**
  * Raw participant data as received from the server.
  * Use the `Participant` class for a richer API.
@@ -292,10 +312,6 @@ export interface IParticipant {
 	clientId: string;
 	/** Whether this participant is the presenter */
 	presenter?: boolean;
-	/** Whether the participant's camera is on */
-	videoEnabled?: boolean;
-	/** Whether the participant's microphone is muted */
-	muted?: boolean;
 	/** Whether the participant is on hold */
 	onHold?: boolean;
 	/** Whether the participant is sharing their screen */
@@ -306,6 +322,10 @@ export interface IParticipant {
 	connectionState?: ParticipantConnectionState;
 	/** Whether the call was silenced for this participant */
 	isCallSilenced?: boolean;
+	/** Combined media track states */
+	mediaState?: IParticipantMediaState;
+	/** What this participant is allowed to publish */
+	permissions?: IParticipantPermissions;
 }
 type CallMetadata = {
 	[key: string]: string | number;
@@ -461,14 +481,8 @@ export declare class Participant {
 	id: string;
 	/** Client identifier for multi-device support. Empty string if not applicable. */
 	clientId: string;
-	/** Whether the participant's microphone is muted */
-	muted: boolean;
 	/** Whether the participant is on hold */
 	onHold: boolean;
-	/** Whether the participant's camera is enabled */
-	videoEnabled: boolean;
-	/** Whether the participant is sharing their screen */
-	screenSharing: boolean;
 	/** Array of audio tracks from this participant. Use these to play participant's audio. */
 	audioTracks: MediaStreamTrack[];
 	/** Array of video tracks from this participant. Use these to display participant's video. */
@@ -477,6 +491,10 @@ export declare class Participant {
 	state: ParticipantState;
 	/** Current WebRTC connection state of the participant */
 	connectionState: ParticipantConnectionState;
+	/** Combined media track states (audio, video, screenShare) */
+	mediaState?: IParticipantMediaState;
+	/** What this participant is allowed to publish */
+	permissions?: IParticipantPermissions;
 }
 interface ActiveSpeakerInfo {
 	participant: Participant;
@@ -579,6 +597,7 @@ export interface CallEventMap {
 		call: Call;
 		participant: Participant;
 		event: ParticipantEvent;
+		changedBy?: string;
 	};
 	/** Fired when participants are added to the call */
 	participantsAdded: {
@@ -610,6 +629,17 @@ export interface CallEventMap {
 		call: Call;
 		sessionId: string;
 	};
+	/** Fired when the owner updates call-level audio/video permissions */
+	callPermissionsUpdated: {
+		call: Call;
+		permissions: ICallPermissions;
+	};
+	/** Fired when a participant's individual permissions are updated by the owner */
+	participantPermissionsUpdated: {
+		call: Call;
+		participant: Participant;
+		permissions: IParticipantPermissions;
+	};
 }
 /**
  * Event map for SceytCallClient class.
@@ -681,6 +711,8 @@ export declare class Call extends TypedEventEmitter<CallEventMap> {
 	callType?: string;
 	/** Scheduling and broadcast settings for this call */
 	settings?: CallSettings;
+	/** Current call-level audio/video permissions set by the owner */
+	permissions?: ICallPermissions;
 	/** Current list of active speakers in the call */
 	get activeSpeakers(): ActiveSpeakerInfo[];
 	set activeSpeakers(speakers: ActiveSpeakerInfo[]);
@@ -793,6 +825,21 @@ export declare class Call extends TypedEventEmitter<CallEventMap> {
 	 * ```
 	 */
 	mute(mute: boolean, errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	muteAllRemoteParticipants(errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	videoOffAllRemoteParticipants(errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	disableAllRemoteParticipantsVideo(errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	updateParticipantPermissions(id: string, permissions: IParticipantPermissions, errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	muteRemoteParticipant(id: string, errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	disableRemoteParticipantAudio(id: string, errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	enableRemoteParticipantAudio(id: string, errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	enableCallAudio(errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	disableCallAudio(errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	unmuteRemoteParticipant(id: string, errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	disableRemoteParticipantVideo(id: string, errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	videoOffRemoteParticipant(id: string, errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	disableCallVideo(errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	enableCallVideo(errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
+	updateCallPermissions(permissions: ICallPermissions, errorCallback?: (result: CallClientResult<boolean>) => void): CallClientResult<boolean>;
 	/**
 	 * Put the call on hold or resume it.
 	 * When on hold, audio/video is paused but the call remains active.