@axonkit/client-sdk-js 0.1.0

package/dist/protocol/types.d.ts

@@ -0,0 +1,522 @@
+import type { types as mediasoupTypes } from 'mediasoup-client';
+export declare enum RoomState {
+    Disconnected = "disconnected",
+    Connecting = "connecting",
+    Connected = "connected",
+    Reconnecting = "reconnecting"
+}
+export declare enum ConnectionQuality {
+    Excellent = "excellent",
+    Good = "good",
+    Poor = "poor",
+    Lost = "lost",
+    Unknown = "unknown"
+}
+export declare enum TrackKind {
+    Audio = "audio",
+    Video = "video"
+}
+export declare enum TrackSource {
+    Camera = "camera",
+    Microphone = "microphone",
+    ScreenShare = "screen_share",
+    ScreenShareAudio = "screen_share_audio",
+    Unknown = "unknown"
+}
+export declare enum VideoQuality {
+    LOW = 0,
+    MEDIUM = 1,
+    HIGH = 2
+}
+export declare enum AudioTrackFeature {
+    AutoGainControl = "auto_gain_control",
+    EchoCancellation = "echo_cancellation",
+    NoiseSuppression = "noise_suppression",
+    Stereo = "stereo",
+    NoDtx = "no_dtx",
+    EnhancedNoiseCancellation = "enhanced_noise_cancellation"
+}
+export declare enum StreamState {
+    Active = "active",
+    Paused = "paused",
+    Unknown = "unknown"
+}
+export declare enum DisconnectReason {
+    UnknownReason = 0,
+    ClientInitiated = 1,
+    DuplicateIdentity = 2,
+    ServerShutdown = 3,
+    ParticipantRemoved = 4,
+    RoomDeleted = 5,
+    StateMismatch = 6,
+    JoinFailure = 7,
+    Migration = 8,
+    SignalClose = 9,
+    RoomClosed = 10,
+    UserUnavailable = 11,
+    UserRejected = 12,
+    SipTrunkFailure = 13,
+    ConnectionTimeout = 14,
+    MediaFailure = 15
+}
+export declare enum ParticipantState {
+    Joining = 0,
+    Joined = 1,
+    Suspended = 2,
+    Disconnected = 3
+}
+export interface IceParameters {
+    usernameFragment: string;
+    password: string;
+    iceLite?: boolean;
+}
+export interface IceCandidate {
+    foundation: string;
+    priority: number;
+    ip: string;
+    address?: string;
+    protocol: 'udp' | 'tcp';
+    port: number;
+    type: 'host' | 'srflx' | 'prflx' | 'relay';
+    tcpType?: 'active' | 'passive' | 'so';
+}
+export interface DtlsParameters {
+    role?: 'auto' | 'client' | 'server';
+    fingerprints: DtlsFingerprint[];
+}
+export interface DtlsFingerprint {
+    algorithm: string;
+    value: string;
+}
+export interface SctpParameters {
+    port: number;
+    OS: number;
+    MIS: number;
+    maxMessageSize: number;
+}
+export interface SctpStreamParameters {
+    streamId: number;
+    ordered?: boolean;
+    maxPacketLifeTime?: number;
+    maxRetransmits?: number;
+}
+export interface TransportParams {
+    sid: string;
+    iceParameters: IceParameters;
+    iceCandidates: IceCandidate[];
+    dtlsParameters: DtlsParameters;
+    sctpParameters?: SctpParameters;
+}
+export interface DataChannelInfo {
+    channelSid: string;
+    dataSourceSid?: string;
+    sctpStreamParameters: SctpStreamParameters;
+    label: string;
+    protocol: string;
+}
+export interface SignalChannels {
+    receive: DataChannelInfo & {
+        dataSourceSid: string;
+    };
+    send: DataChannelInfo;
+}
+export interface ServerInfo {
+    nodeId: string;
+    region: string;
+    protocol: number;
+}
+export interface RoomInfo {
+    sid: string;
+    name: string;
+    metadata?: string;
+    numParticipants?: number;
+    numPublishers?: number;
+    activeRecording?: boolean;
+    sharedState?: Record<string, string>;
+}
+export declare enum ParticipantKind {
+    Standard = 0,
+    Ingress = 1,
+    Egress = 2,
+    Sip = 3,
+    Agent = 4
+}
+export interface ParticipantPermission {
+    canPublish: boolean;
+    canSubscribe: boolean;
+    canPublishData: boolean;
+    canPublishSources: TrackSource[];
+    canUpdateMetadata: boolean;
+    canManageGroups: boolean;
+    hidden: boolean;
+    recorder: boolean;
+    agent: boolean;
+}
+export interface ParticipantInfo {
+    sid: string;
+    identity: string;
+    name?: string;
+    metadata?: string;
+    state: ParticipantState;
+    tracks?: TrackInfo[];
+    attributes?: Record<string, string>;
+    kind?: ParticipantKind;
+    joinedAt?: number;
+    disconnectReason?: DisconnectReason;
+    permission?: ParticipantPermission;
+    groupId?: string;
+}
+export interface TrackInfo {
+    sid: string;
+    name: string;
+    kind: TrackKind;
+    source: TrackSource;
+    muted: boolean;
+    width?: number;
+    height?: number;
+    appData?: Record<string, unknown>;
+}
+export interface DataTrackInfo {
+    sid: string;
+    name: string;
+    label: string;
+    protocol: string;
+    appData?: Record<string, unknown>;
+}
+export interface ClientInfo {
+    sdk: number;
+    version: string;
+    protocol: number;
+}
+export interface ConnectionSettings {
+    autoSubscribe: boolean;
+    adaptiveStream: boolean;
+    lastN?: number;
+    dtlsFingerprints?: DtlsFingerprint[];
+}
+export interface JoinRequest {
+    room: {
+        name: string;
+        metadata?: string;
+    };
+    clientInfo: ClientInfo;
+    connectionSettings: ConnectionSettings;
+    reconnect: boolean;
+    participantSid: string;
+    nodeId: string;
+    token?: string;
+    refreshToken?: string;
+}
+export interface JoinResponse {
+    room: RoomInfo;
+    participant: ParticipantInfo;
+    pingTimeout: number;
+    pingInterval: number;
+    statsInterval?: number;
+    serverInfo: ServerInfo;
+    iceServers: RTCIceServer[];
+    sendTransport: TransportParams;
+    receiveTransport: TransportParams;
+    signal: SignalChannels;
+    rtpCapabilities: mediasoupTypes.RtpCapabilities;
+    otherParticipants?: ParticipantInfo[];
+    fullReconnect?: boolean;
+    refreshToken?: string;
+    iceTransportPolicy?: RTCIceTransportPolicy;
+}
+export interface TokenRefreshedNotification {
+    token: string;
+}
+export interface ReconnectResponse {
+    iceParameters: Record<string, IceParameters>;
+}
+export interface ConnectRequest {
+    nodeId: string;
+    participantSid: string;
+    transports: TransportConnectInfo[];
+    token?: string;
+}
+export interface TransportConnectInfo {
+    transportSid: string;
+    dtlsParameters: DtlsParameters;
+}
+export interface SyncState {
+    subscribedTrackSids: string[];
+    subscribedDataTrackSids: string[];
+    publishedTrackSids: string[];
+    dataReceiveStates: DataReceiveState[];
+    /** Timestamp of the last chat message the client received before disconnect. */
+    lastMessageTimestamp?: number;
+}
+export interface DataReceiveState {
+    dataTrackSid: string;
+    lastSeq: number;
+}
+export interface ReadyRequest {
+    rtpCapabilities: mediasoupTypes.RtpCapabilities;
+    syncState?: SyncState;
+}
+export interface ReadyResponse {
+    otherParticipants: ParticipantInfo[];
+    room?: RoomInfo;
+    groups?: GroupInfo[];
+    messages?: MessageInfo[];
+    sharedState?: Record<string, string>;
+}
+export interface MessageInfo {
+    id: string;
+    type?: string;
+    message: string;
+    timestamp: number;
+    editTimestamp?: number;
+    transient?: boolean;
+    participantSid?: string;
+    participantIdentity?: string;
+}
+/** @deprecated Use {@link MessageInfo} instead. */
+export type ChatMessageInfo = MessageInfo;
+export interface MessageDeletedNotification {
+    ids: string[];
+    type?: string;
+}
+export interface StateUpdatedNotification {
+    key: string;
+    value: string;
+    participantSid?: string;
+    participantIdentity?: string;
+}
+export interface StateDeletedNotification {
+    key: string;
+    participantSid?: string;
+    participantIdentity?: string;
+}
+export interface LeaveRequest {
+    reason?: string;
+}
+export interface PingRequest {
+    timestamp: number;
+}
+export interface PingResponse {
+    lastTimestamp: number;
+    serverTime: number;
+}
+export interface TrackPublishRequest {
+    clientTrackId: string;
+    name: string;
+    kind: TrackKind;
+    rtpParameters: mediasoupTypes.RtpParameters;
+    source: TrackSource;
+    width?: number;
+    height?: number;
+    muted: boolean;
+    videoCodec?: string;
+    backupCodec?: string;
+    backupCodecPolicy?: number;
+    appData?: Record<string, unknown>;
+}
+export interface PublishBackupTrackRequest {
+    trackSid: string;
+    clientTrackId: string;
+    rtpParameters: mediasoupTypes.RtpParameters;
+}
+export interface PublishBackupTrackResponse {
+    backupTrackSid: string;
+}
+export interface TrackPublishResponse {
+    trackSid: string;
+}
+export interface TrackUnpublishRequest {
+    trackSid: string;
+}
+export interface TrackMuteRequest {
+    trackSid: string;
+    muted: boolean;
+}
+export interface TrackUpdateRequest {
+    trackSid: string;
+    width?: number;
+    height?: number;
+}
+export interface DataTrackPublishRequest {
+    clientTrackId: string;
+    transportSid: string;
+    sctpStreamParameters: SctpStreamParameters;
+    name: string;
+    label: string;
+    protocol: string;
+    appData?: Record<string, unknown>;
+}
+export interface DataTrackPublishResponse {
+    dataTrackSid: string;
+}
+export interface DataTrackUnpublishRequest {
+    dataTrackSid: string;
+}
+export interface SubscriptionActionRequest {
+    subscriptionSid: string;
+}
+export interface SubscriptionSetLayersRequest {
+    subscriptionSid: string;
+    spatialLayer: number;
+    temporalLayer?: number;
+}
+export interface SubscriptionSetPriorityRequest {
+    subscriptionSid: string;
+    priority: number;
+}
+export interface DataSubscriptionCloseRequest {
+    dataSubscriptionSid: string;
+}
+export interface TransportGetStatsRequest {
+    transportSid: string;
+}
+export interface ParticipantUpdateRequest {
+    metadata?: string;
+    name?: string;
+    attributes?: Record<string, string>;
+}
+export interface ParticipantTrackPermission {
+    /** The participant identity this permission applies to. */
+    participantIdentity?: string;
+    /** The participant server id this permission applies to. */
+    participantSid?: string;
+    /** Grant permission to all tracks. Takes precedence over allowedTrackSids. */
+    allowAll?: boolean;
+    /** List of track sids the target participant can subscribe to. */
+    allowedTrackSids?: string[];
+}
+export interface UpdateSubscriptionPermissionsRequest {
+    allParticipantsAllowed: boolean;
+    trackPermissions: ParticipantTrackPermission[];
+}
+export interface SubscriptionCreateRequest {
+    subscriptionSid: string;
+    trackSid: string;
+    trackName: string;
+    trackSource: TrackSource;
+    publisherSid: string;
+    kind: TrackKind;
+    rtpParameters: mediasoupTypes.RtpParameters;
+    subscriptionType?: string;
+    trackMuted: boolean;
+    appData?: Record<string, unknown>;
+}
+export interface DataSubscriptionCreateRequest {
+    dataSubscriptionSid: string;
+    dataTrackSid: string;
+    publisherSid: string;
+    sctpStreamParameters: SctpStreamParameters;
+    label: string;
+    protocol: string;
+    appData?: Record<string, unknown>;
+}
+export interface SubscriptionClosedNotification {
+    subscriptionSid: string;
+}
+export interface DataSubscriptionClosedNotification {
+    dataSubscriptionSid: string;
+}
+export interface ParticipantJoinedNotification {
+    participant: ParticipantInfo;
+}
+export interface ParticipantLeftNotification {
+    participantSid: string;
+    reason?: string;
+}
+export interface ParticipantUpdatedNotification {
+    participant: ParticipantInfo;
+}
+export interface TrackPublishedNotification {
+    participantSid: string;
+    track: TrackInfo;
+}
+export interface TrackUnpublishedNotification {
+    participantSid: string;
+    trackSid: string;
+}
+export interface DataTrackPublishedNotification {
+    participantSid: string;
+    dataTrack: DataTrackInfo;
+}
+export interface DataTrackUnpublishedNotification {
+    participantSid: string;
+    dataTrackSid: string;
+}
+export interface TrackMutedNotification {
+    participantSid: string;
+    trackSid: string;
+    muted: boolean;
+}
+export interface SubscribedQualityInfo {
+    quality: VideoQuality;
+    enabled: boolean;
+}
+export interface SubscribedCodecInfo {
+    codec: string;
+    qualities: SubscribedQualityInfo[];
+}
+export interface TrackSubscribedQualityChangedNotification {
+    trackSid: string;
+    subscribedQualities: SubscribedQualityInfo[];
+    subscribedCodecs?: SubscribedCodecInfo[];
+}
+export interface TrackSubscriptionStatusChangedNotification {
+    trackSid: string;
+    hasSubscribers: boolean;
+}
+export interface ActiveSpeaker {
+    participantSid: string;
+    level: number;
+    active: boolean;
+}
+export interface ActiveSpeakersChangedNotification {
+    speakers: ActiveSpeaker[];
+}
+export interface RoomUpdatedNotification {
+    room: RoomInfo;
+}
+export interface DisconnectNotification {
+    reason: DisconnectReason;
+}
+export interface GroupInfo {
+    groupId: string;
+    name: string;
+    permissions?: ParticipantPermission;
+    participantCount: number;
+}
+export interface CreateGroupRequest {
+    name: string;
+    permissions?: ParticipantPermission;
+}
+export interface CreateGroupResponse {
+    group: GroupInfo;
+}
+export interface DeleteGroupRequest {
+    groupId: string;
+}
+export interface ListGroupsResponse {
+    groups: GroupInfo[];
+}
+export interface JoinGroupRequest {
+    groupId: string;
+}
+export interface JoinGroupResponse {
+    otherParticipants: ParticipantInfo[];
+}
+export interface GroupCreatedNotification {
+    group: GroupInfo;
+}
+export interface GroupUpdatedNotification {
+    group: GroupInfo;
+}
+export interface GroupDeletedNotification {
+    groupId: string;
+}
+export interface GroupParticipantJoinedNotification {
+    groupId: string;
+    participantSid: string;
+}
+export interface GroupParticipantLeftNotification {
+    groupId: string;
+    participantSid: string;
+}

package/dist/room/DefaultReconnectPolicy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Context provided to a reconnect policy when computing the next retry delay.
+ */
+export interface ReconnectContext {
+    retryCount: number;
+    elapsedMs: number;
+}
+/**
+ * Default reconnect policy with exponential back-off and jitter.
+ *
+ * @example
+ * ```ts
+ * const policy = new DefaultReconnectPolicy(10);
+ * const delay = policy.nextRetryDelayInMs({ retryCount: 1, elapsedMs: 0 });
+ * ```
+ */
+export declare class DefaultReconnectPolicy {
+    private readonly maxRetries;
+    private readonly baseDelay;
+    private readonly maxDelay;
+    constructor(maxRetries?: number, baseDelay?: number, maxDelay?: number);
+    /**
+     * Returns the number of milliseconds to wait before the next reconnect
+     * attempt, or `null` if the policy says to stop trying.
+     */
+    nextRetryDelayInMs(context: ReconnectContext): number | null;
+    reset(): void;
+}

package/dist/room/options.d.ts

@@ -0,0 +1,74 @@
+import type { VideoCaptureOptions, AudioCaptureOptions, TrackPublishDefaults } from '../track/options';
+/**
+ * Configuration for the adaptive stream feature. When enabled the SDK
+ * automatically manages video subscription quality based on element
+ * visibility and dimensions.
+ */
+export interface AdaptiveStreamSettings {
+    /**
+     * Pixel density to use when computing the required video resolution.
+     * Set to `'screen'` to use `window.devicePixelRatio`.
+     *
+     * @defaultValue `1`
+     */
+    pixelDensity?: number | 'screen';
+    /**
+     * Pause video subscriptions when the browser tab is hidden.
+     *
+     * @defaultValue `true`
+     */
+    pauseVideoInBackground?: boolean;
+}
+/**
+ * Top-level options for a {@link Room} instance.
+ */
+export interface RoomOptions {
+    /**
+     * Automatically manage subscribed video quality based on the size and
+     * visibility of attached elements. Pass `true` to enable with defaults
+     * or provide {@link AdaptiveStreamSettings} for fine-grained control.
+     */
+    adaptiveStream?: boolean | AdaptiveStreamSettings;
+    /**
+     * Enable Dynacast — dynamically pause video layers that have no
+     * subscribers on the server.
+     */
+    dynacast?: boolean;
+    /**
+     * Default capture options used when creating camera tracks.
+     */
+    videoCaptureDefaults?: VideoCaptureOptions;
+    /**
+     * Default capture options used when creating microphone tracks.
+     */
+    audioCaptureDefaults?: AudioCaptureOptions;
+    /**
+     * Default publish parameters applied to every track unless overridden
+     * per-track.
+     */
+    publishDefaults?: TrackPublishDefaults;
+    /**
+     * Room name sent in the JoinRequest for server-side routing and room
+     * creation. Must match the `room` claim in the JWT token (if present).
+     */
+    roomName?: string;
+    /**
+     * Room metadata (e.g. meeting topic) sent in the JoinRequest when the
+     * room is auto-created. Only takes effect for the first participant
+     * that causes the room to be created. Maximum size: 64 KB.
+     */
+    metadata?: string;
+    /**
+     * Maximum number of remote participants whose audio/video tracks this
+     * client will receive. `0` (default) means receive all participants.
+     *
+     * When set to a positive number, the server will only auto-subscribe
+     * this participant to at most `lastN` publishers' media tracks.
+     */
+    lastN?: number;
+}
+/**
+ * Options for Room.connect()
+ */
+export interface RoomConnectOptions extends Partial<InternalRoomConnectOptions> {
+}

package/dist/rpc.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Specialized error for RPC methods.
+ *
+ * When thrown in an RPC handler, the `message` and `code` are sent back to
+ * the caller. Built-in error codes 1001–1999 are reserved.
+ */
+export declare class RpcError extends Error {
+    static MAX_MESSAGE_BYTES: number;
+    static MAX_DATA_BYTES: number;
+    code: number;
+    data?: string;
+    constructor(code: number, message: string, data?: string);
+    static ErrorCode: {
+        readonly APPLICATION_ERROR: 1500;
+        readonly CONNECTION_TIMEOUT: 1501;
+        readonly RESPONSE_TIMEOUT: 1502;
+        readonly RECIPIENT_DISCONNECTED: 1503;
+        readonly RESPONSE_PAYLOAD_TOO_LARGE: 1504;
+        readonly SEND_FAILED: 1505;
+        readonly UNSUPPORTED_METHOD: 1400;
+        readonly RECIPIENT_NOT_FOUND: 1401;
+        readonly REQUEST_PAYLOAD_TOO_LARGE: 1402;
+    };
+    static ErrorMessage: Record<keyof typeof RpcError.ErrorCode, string>;
+    /** Create a built-in error by key name. */
+    static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string): RpcError;
+}
+export declare const MAX_RPC_PAYLOAD_BYTES = 15360;

package/dist/signal/RPCClient.d.ts

@@ -0,0 +1,28 @@
+import { types as mediasoupTypes } from 'mediasoup-client';
+import { TypedEmitter } from '../utils/typedEmitter';
+type RequestHandler = (body: any) => Promise<any>;
+type NotificationHandler = (body: any) => void;
+export type RPCEvents = {
+    closed: () => void;
+    error: (err: Error) => void;
+};
+export declare class RPCClient extends TypedEmitter<RPCEvents> {
+    private sendDC;
+    private pending;
+    private requestHandlers;
+    private notificationHandlers;
+    private closed;
+    lastSentAt: number;
+    bind(sendDC: mediasoupTypes.DataProducer, recvDC: mediasoupTypes.DataConsumer): void;
+    request<T = any>(method: string, body?: object, timeout?: number): Promise<T>;
+    respond(logId: string, status: number, body?: object, headers?: Record<string, string>): void;
+    notify(method: string, body?: object): void;
+    onRequest(method: string, handler: RequestHandler): void;
+    onNotification(method: string, handler: NotificationHandler): void;
+    close(): void;
+    private handleMessage;
+    private handleResponse;
+    private handleIncomingRequest;
+    private handleNotification;
+}
+export {};

package/dist/signal/SignalClient.d.ts

@@ -0,0 +1,14 @@
+import type { JoinRequest, JoinResponse, ReconnectResponse, ConnectRequest } from '../protocol/types';
+export interface JoinResult {
+    response: JoinResponse | ReconnectResponse;
+    logId: string;
+}
+export declare function isReconnectResponse(resp: any): resp is ReconnectResponse;
+export declare class SignalClient {
+    private nodeId;
+    private logId;
+    get currentNodeId(): string;
+    get currentLogId(): string;
+    join(url: string, request: JoinRequest): Promise<JoinResult>;
+    connect(url: string, request: ConnectRequest, roomName?: string): Promise<void>;
+}

package/dist/stats/StatsCollector.d.ts

@@ -0,0 +1,15 @@
+import { RPCClient } from '../signal/RPCClient';
+import { TransportManager } from '../transport/TransportManager';
+import { LocalParticipant } from '../participant/LocalParticipant';
+import { RemoteParticipant } from '../participant/RemoteParticipant';
+export declare class StatsCollector {
+    private rpc;
+    private transportManager;
+    private localParticipant;
+    private remoteParticipants;
+    private timer?;
+    constructor(rpc: RPCClient, transportManager: TransportManager, localParticipant: LocalParticipant, remoteParticipants: Map<string, RemoteParticipant>);
+    start(intervalSec: number): void;
+    stop(): void;
+    private collect;
+}