@axonkit/client-sdk-js 0.1.0

package/dist/track/LocalAudioTrack.d.ts

@@ -0,0 +1,20 @@
+import { LocalTrack } from './LocalTrack';
+export declare class LocalAudioTrack extends LocalTrack {
+    /**
+     * When `true`, the underlying `MediaStreamTrack` is stopped when the track
+     * is muted and restarted when unmuted. Useful for disabling the microphone
+     * recording indicator on some platforms.
+     */
+    stopOnMute: boolean;
+    /**
+     * Pending constraints to apply on the next unmute. Used when the user
+     * switches devices while the track is muted — the actual restart is
+     * deferred until unmute.
+     */
+    private pendingRestartConstraints?;
+    private muteLock;
+    constructor(mediaStreamTrack: MediaStreamTrack, constraints?: MediaTrackConstraints);
+    mute(): Promise<void>;
+    unmute(): Promise<void>;
+    setDeviceId(deviceId: string): Promise<void>;
+}

package/dist/track/LocalTrack.d.ts

@@ -0,0 +1,108 @@
+import { Mutex } from 'async-mutex';
+import { Track, type TrackDimensions, type TrackEvents } from './Track';
+import { TrackKind, TrackSource } from '../protocol/types';
+import { TrackEvent } from '../events';
+import type { TrackProcessor } from './processor/types';
+export type LocalTrackEvents = TrackEvents & {
+    [TrackEvent.Restarted]: (track: LocalTrack) => void;
+};
+export declare class LocalTrack extends Track {
+    private _constraints?;
+    private _producer?;
+    protected _processor?: TrackProcessor;
+    protected processorElement?: HTMLMediaElement;
+    private _isUpstreamPaused;
+    private _providedByUser;
+    private _prevBytesSent;
+    private _prevStatsTime;
+    private _mediaTrackMuteDebounce;
+    private _handleVisibilityChange;
+    protected trackChangeLock: Mutex;
+    protected pauseUpstreamLock: Mutex;
+    constructor(kind: TrackKind, mediaStreamTrack: MediaStreamTrack, source?: TrackSource, constraints?: MediaTrackConstraints, userProvided?: boolean);
+    /**
+     * Returns the processed track if a processor is active, otherwise the
+     * raw source track. Consumers should use this for playback and
+     * publishing.
+     */
+    get mediaStreamTrack(): MediaStreamTrack;
+    get isLocal(): boolean;
+    /** The MediaStreamTrack id. */
+    get id(): string;
+    /** Current capture constraints. */
+    get constraints(): MediaTrackConstraints | undefined;
+    /**
+     * Video dimensions from the current track settings.
+     * Returns `undefined` for audio tracks.
+     */
+    get dimensions(): TrackDimensions | undefined;
+    /** Whether upstream publishing has been paused via {@link pauseUpstream}. */
+    get isUpstreamPaused(): boolean;
+    /** Whether the track was provided by the user (not managed by the SDK). */
+    get isUserProvided(): boolean;
+    /** Returns the currently active processor, or `undefined`. */
+    getProcessor(): TrackProcessor | undefined;
+    /**
+     * Returns the settings of the *original* source track, ignoring any
+     * active processor.  Useful when you need the real capture resolution
+     * or device info regardless of post-processing.
+     */
+    getSourceTrackSettings(): MediaTrackSettings;
+    /**
+     * Set a {@link TrackProcessor} on this track. Pass `undefined` to remove
+     * the current processor.
+     */
+    setProcessor(processor: TrackProcessor | undefined, showProcessedStreamLocally?: boolean): Promise<void>;
+    /** Stop and remove the current processor. */
+    stopProcessor(): Promise<void>;
+    /** Mute the track (disables the MediaStreamTrack). */
+    mute(): void;
+    /** Unmute the track (enables the MediaStreamTrack). */
+    unmute(): void;
+    /**
+     * Pause publishing to the server without disabling the local
+     * MediaStreamTrack. Useful for showing a local preview while
+     * not sending to remote participants.
+     */
+    pauseUpstream(): Promise<void>;
+    /** Resume publishing after a call to {@link pauseUpstream}. */
+    resumeUpstream(): Promise<void>;
+    /**
+     * Gets the RTCStatsReport for the underlying RTP sender.
+     */
+    getRTCStatsReport(): Promise<RTCStatsReport | undefined>;
+    /**
+     * Get the device ID currently used by this track.
+     */
+    getDeviceId(): Promise<string | undefined>;
+    /**
+     * Wait until the video track reports valid dimensions.
+     * @throws Error if the track is audio or dimensions don't become
+     *         available within the timeout.
+     */
+    waitForDimensions(timeout?: number): Promise<TrackDimensions>;
+    restart(constraints?: MediaTrackConstraints): Promise<void>;
+    replaceTrack(newTrack: MediaStreamTrack): Promise<void>;
+    /** Internal replace without acquiring trackChangeLock (caller must hold it). */
+    private replaceTrackInternal;
+    stop(): void;
+    protected setTrackMuted(muted: boolean): void;
+    private monitorSender;
+    private attachMediaTrackListeners;
+    private detachMediaTrackListeners;
+    private onMediaTrackMute;
+    private onMediaTrackUnmute;
+    /** Start listening for visibility changes (should be called after publishing). */
+    addVisibilityListener(): void;
+    private removeVisibilityListener;
+    private onVisibilityChange;
+    /**
+     * Ensures a hidden HTMLMediaElement exists for the processor to read
+     * frames from the source track. Reuses the existing element if present.
+     */
+    private ensureProcessorElement;
+    private attachTrackToProcessorElement;
+    private destroyProcessorElement;
+    /** Re-attach all user-facing elements to the given track. */
+    private reattachElementsToTrack;
+}

package/dist/track/LocalVideoTrack.d.ts

@@ -0,0 +1,35 @@
+import { LocalTrack } from './LocalTrack';
+import { TrackSource, VideoQuality } from '../protocol/types';
+import type { VideoEncoding, VideoResolution } from './options';
+export declare class LocalVideoTrack extends LocalTrack {
+    private simulcast;
+    private encoding?;
+    private senderLock;
+    /** The codec used for the primary producer (e.g. 'vp9', 'av1'). */
+    publishedCodec?: string;
+    /** The backup codec name (e.g. 'vp8'). */
+    backupCodec?: string;
+    constructor(mediaStreamTrack: MediaStreamTrack, source?: TrackSource, constraints?: MediaTrackConstraints);
+    get dimensions(): VideoResolution | undefined;
+    setSimulcast(enabled: boolean): void;
+    setEncoding(encoding: VideoEncoding): void;
+    getSimulcastEncodings(): RTCRtpEncodingParameters[];
+    /**
+     * Applies dynacast quality updates from the server.
+     *
+     * - Simulcast: toggles each encoding's `active` by rid.
+     * - SVC (single encoding): sets `active = false` only when ALL qualities
+     *   are disabled; otherwise keeps it `true`.
+     */
+    setDynacastQuality(qualities: {
+        quality: VideoQuality;
+        enabled: boolean;
+    }[]): Promise<void>;
+    /**
+     * Set the degradation preference hint for the browser encoder.
+     * Takes effect on the next `setParameters` call (or immediately if
+     * an RTP sender is available).
+     */
+    setDegradationPreference(preference: RTCDegradationPreference): Promise<void>;
+    setDeviceId(deviceId: string): Promise<void>;
+}

package/dist/track/RemoteAudioTrack.d.ts

@@ -0,0 +1,7 @@
+import { RemoteTrack } from './RemoteTrack';
+export declare class RemoteAudioTrack extends RemoteTrack {
+    private _volume;
+    constructor(mediaStreamTrack: MediaStreamTrack);
+    get volume(): number;
+    setVolume(volume: number): void;
+}

package/dist/track/RemoteTrack.d.ts

@@ -0,0 +1,33 @@
+import { Track } from './Track';
+import { TrackKind, TrackSource } from '../protocol/types';
+export declare class RemoteTrack extends Track {
+    private _prevBytesReceived;
+    private _prevStatsTime;
+    private _rtpTimestamp?;
+    private _timeSyncHandle?;
+    constructor(kind: TrackKind, source: TrackSource | undefined, mediaStreamTrack: MediaStreamTrack);
+    get isLocal(): boolean;
+    /**
+     * Stop the remote track.
+     */
+    stop(): void;
+    /**
+     * Gets the RTCStatsReport for the underlying RTP receiver.
+     */
+    getRTCStatsReport(): Promise<RTCStatsReport | undefined>;
+    /**
+     * Set a playout delay (in seconds) for this track. Higher values allow
+     * more buffering in the browser and add latency.
+     */
+    setPlayoutDelay(delayInSeconds: number): void;
+    /** Returns the current playout delay (in seconds). */
+    getPlayoutDelay(): number;
+    /**
+     * Registers a loop that emits {@link TrackEvent.TimeSyncUpdate} events
+     * with the current RTP timestamp and browser timestamp, useful for
+     * lip-sync and cross-track synchronization.
+     */
+    private registerTimeSyncUpdate;
+    private supportsSynchronizationSources;
+    private monitorReceiver;
+}

package/dist/track/RemoteVideoTrack.d.ts

@@ -0,0 +1,31 @@
+import { RemoteTrack } from './RemoteTrack';
+import { TrackSource } from '../protocol/types';
+import type { AdaptiveStreamSettings } from '../room/options';
+export declare class RemoteVideoTrack extends RemoteTrack {
+    adaptiveStreamSettings?: AdaptiveStreamSettings;
+    private rpc?;
+    private elementInfos;
+    private intersectionObserver?;
+    private resizeObserver?;
+    private visibilityBound?;
+    private debounceTimer?;
+    private pipElement?;
+    constructor(source: TrackSource | undefined, mediaStreamTrack: MediaStreamTrack);
+    get isAdaptiveStream(): boolean;
+    attach(element?: HTMLMediaElement): HTMLMediaElement;
+    detach(element?: HTMLMediaElement): HTMLMediaElement[];
+    /** Enter Picture-in-Picture on the first attached video element. */
+    requestPictureInPicture(): Promise<PictureInPictureWindow | undefined>;
+    stop(): void;
+    private setupAdaptiveObservers;
+    private observeElement;
+    private unobserveElement;
+    private handleVisibilityUpdate;
+    private handlePageVisibilityChange;
+    private debouncedUpdateLayers;
+    private updatePreferredLayers;
+    private getPixelDensity;
+    private calculateSpatialLayer;
+    private cleanupAdaptive;
+    private getFirstVideoElement;
+}

package/dist/track/Track.d.ts

@@ -0,0 +1,62 @@
+import { TypedEmitter } from '../utils/typedEmitter';
+import { TrackKind, TrackSource, StreamState } from '../protocol/types';
+import { TrackEvent } from '../events';
+export type TrackEvents = {
+    [TrackEvent.Muted]: (track: Track) => void;
+    [TrackEvent.Unmuted]: (track: Track) => void;
+    [TrackEvent.Ended]: (track: Track) => void;
+    [TrackEvent.ElementAttached]: (element: HTMLMediaElement) => void;
+    [TrackEvent.ElementDetached]: (element: HTMLMediaElement) => void;
+    [TrackEvent.AudioPlaybackStarted]: () => void;
+    [TrackEvent.AudioPlaybackFailed]: (error?: Error) => void;
+    [TrackEvent.VideoPlaybackStarted]: () => void;
+    [TrackEvent.VideoPlaybackFailed]: (error?: Error) => void;
+    [TrackEvent.UpstreamPaused]: (track: Track) => void;
+    [TrackEvent.UpstreamResumed]: (track: Track) => void;
+    [TrackEvent.VisibilityChanged]: (visible: boolean, track: Track) => void;
+    [TrackEvent.VideoDimensionsChanged]: (dimensions: TrackDimensions, track: Track) => void;
+    [TrackEvent.AudioSilenceDetected]: () => void;
+    [TrackEvent.StreamStateChanged]: (track: Track, streamState: StreamState) => void;
+    [TrackEvent.TimeSyncUpdate]: (update: {
+        timestamp: number;
+        rtpTimestamp: number;
+    }) => void;
+};
+export declare abstract class Track extends TypedEmitter<TrackEvents> {
+    kind: TrackKind;
+    source: TrackSource;
+    sid?: string;
+    protected _mediaStreamTrack: MediaStreamTrack;
+    get mediaStreamTrack(): MediaStreamTrack;
+    protected _isMuted: boolean;
+    private _streamState;
+    attachedElements: HTMLMediaElement[];
+    protected _currentBitrate: number;
+    protected monitorInterval?: ReturnType<typeof setInterval>;
+    constructor(kind: TrackKind, source: TrackSource | undefined, mediaStreamTrack: MediaStreamTrack);
+    /** Current bitrate in bits per second, updated by the monitor. */
+    get currentBitrate(): number;
+    abstract get isLocal(): boolean;
+    /**
+     * Whether the track is currently muted.
+     * This reflects the publisher's intent and is independent of consumer
+     * pause state or {@link streamState}.
+     */
+    get isMuted(): boolean;
+    /**
+     * The current stream state of the track.
+     * {@link StreamState.Active} means the server is actively forwarding media;
+     * {@link StreamState.Paused} means the server has temporarily stopped forwarding (e.g. bandwidth limits).
+     * This is separate from `isMuted`, which reflects the publisher's intent.
+     */
+    get streamState(): StreamState;
+    attach(element?: HTMLMediaElement): HTMLMediaElement;
+    detach(element?: HTMLMediaElement): HTMLMediaElement[];
+    private detachElement;
+    private recycleElement;
+    stop(): void;
+}
+export interface TrackDimensions {
+    width: number;
+    height: number;
+}

package/dist/track/create.d.ts

@@ -0,0 +1,30 @@
+import { LocalTrack } from './LocalTrack';
+import { LocalAudioTrack } from './LocalAudioTrack';
+import { LocalVideoTrack } from './LocalVideoTrack';
+import { type AudioCaptureOptions, type VideoCaptureOptions, type ScreenShareCaptureOptions, type CreateLocalTracksOptions } from './options';
+/**
+ * Create local audio and video tracks with the given options.
+ *
+ * @param options - Capture options for audio and video. Defaults to
+ *   `{ audio: true, video: true }`.
+ * @returns An array of created local tracks.
+ */
+export declare function createLocalTracks(options?: CreateLocalTracksOptions): Promise<LocalTrack[]>;
+/**
+ * Create a local audio track from the microphone.
+ *
+ * @param options - Audio capture options. Uses defaults when omitted.
+ */
+export declare function createLocalAudioTrack(options?: AudioCaptureOptions): Promise<LocalAudioTrack>;
+/**
+ * Create a local video track from the camera.
+ *
+ * @param options - Video capture options. Uses defaults when omitted.
+ */
+export declare function createLocalVideoTrack(options?: VideoCaptureOptions): Promise<LocalVideoTrack>;
+/**
+ * Create local screen share tracks (video and optionally audio).
+ *
+ * @param options - Screen share capture options.
+ */
+export declare function createLocalScreenTracks(options?: ScreenShareCaptureOptions): Promise<LocalTrack[]>;