@decartai/sdk 0.0.68 → 0.1.0

package/dist/realtime/config-realtime.js

@@ -0,0 +1,49 @@
+//#region src/realtime/config-realtime.ts
+const REALTIME_CONFIG = {
+	signaling: {
+		connectTimeoutMs: 6e4,
+		handshakeTimeoutMs: 15e3,
+		requestTimeoutMs: 3e4
+	},
+	session: {
+		connectionTimeoutMs: 6e4 * 5,
+		retry: {
+			retries: 5,
+			factor: 2,
+			minTimeout: 1e3,
+			maxTimeout: 1e4
+		},
+		permanentErrorSubstrings: [
+			"permission denied",
+			"not allowed",
+			"invalid session",
+			"401",
+			"invalid api key",
+			"unauthorized"
+		]
+	},
+	methods: {
+		promptTimeoutMs: 15e3,
+		updateTimeoutMs: 3e4
+	},
+	livekit: {
+		inferenceServerIdentityPrefix: "inference-server-",
+		roomOptions: {
+			adaptiveStream: false,
+			dynacast: false
+		},
+		defaultVideoCodec: "h264",
+		defaultMaxVideoBitrateBps: 35e5,
+		defaultPublishFps: 30
+	},
+	observability: {
+		stallFpsThreshold: .5,
+		statsDefaultIntervalMs: 1e3,
+		statsMinIntervalMs: 500,
+		telemetryReportIntervalMs: 1e4,
+		telemetryUrl: "https://platform.decart.ai/api/v1/telemetry",
+		telemetryMaxItemsPerReport: 120
+	}
+};
+//#endregion
+export { REALTIME_CONFIG };

package/dist/realtime/event-buffer.js

@@ -1,5 +1,4 @@
 import mitt from "mitt";
-
 //#region src/realtime/event-buffer.ts
 function createEventBuffer() {
 	const emitter = mitt();
@@ -30,6 +29,5 @@ function createEventBuffer() {
 		stop
 	};
 }
-
 //#endregion
-export { createEventBuffer };
+export { createEventBuffer };

package/dist/realtime/initial-state-gate.js

@@ -0,0 +1,21 @@
+//#region src/realtime/initial-state-gate.ts
+var InitialStateGate = class {
+	attemptId = 0;
+	startAttempt(initialState) {
+		const attemptId = ++this.attemptId;
+		const shouldWait = hasCallerProvidedInitialState(initialState);
+		return { waitForReadiness: async (initialStateAck) => {
+			if (shouldWait) await initialStateAck;
+			return this.attemptId === attemptId;
+		} };
+	}
+	reset() {
+		this.attemptId++;
+	}
+};
+function hasCallerProvidedInitialState(state) {
+	if (!state) return false;
+	return state.image !== void 0 && state.image !== null || state.prompt !== void 0 && state.prompt !== null;
+}
+//#endregion
+export { InitialStateGate };

package/dist/realtime/media-channel.js

@@ -0,0 +1,82 @@
+import { createConsoleLogger } from "../utils/logger.js";
+import { REALTIME_CONFIG } from "./config-realtime.js";
+import mitt from "mitt";
+import { Room, RoomEvent, Track, TrackEvent } from "livekit-client";
+//#region src/realtime/media-channel.ts
+function getDefaultVideoPublishOptions(videoCodec) {
+	const videoEncoding = {
+		maxBitrate: REALTIME_CONFIG.livekit.defaultMaxVideoBitrateBps,
+		maxFramerate: REALTIME_CONFIG.livekit.defaultPublishFps
+	};
+	return {
+		source: Track.Source.Camera,
+		videoCodec: videoCodec ?? REALTIME_CONFIG.livekit.defaultVideoCodec,
+		simulcast: true,
+		videoEncoding
+	};
+}
+var MediaChannel = class {
+	room = null;
+	remoteStream = null;
+	events = mitt();
+	logger;
+	constructor(config) {
+		this.config = config;
+		this.logger = config.logger ?? createConsoleLogger("warn");
+	}
+	get localStream() {
+		return this.config.localStream;
+	}
+	on(event, handler) {
+		this.events.on(event, handler);
+	}
+	off(event, handler) {
+		this.events.off(event, handler);
+	}
+	async connect(opts) {
+		this.room ??= new Room(REALTIME_CONFIG.livekit.roomOptions);
+		const room = this.room;
+		room.on(RoomEvent.TrackSubscribed, (track, _pub, participant) => {
+			if (!participant.identity.startsWith(REALTIME_CONFIG.livekit.inferenceServerIdentityPrefix)) return;
+			if (track.kind !== Track.Kind.Video && track.kind !== Track.Kind.Audio) return;
+			track.attach();
+			const mediaStreamTrack = track.mediaStreamTrack;
+			if (mediaStreamTrack) {
+				this.remoteStream ??= new MediaStream();
+				if (!this.remoteStream.getTracks().includes(mediaStreamTrack)) this.remoteStream.addTrack(mediaStreamTrack);
+				this.events.emit("remoteStream", this.remoteStream);
+			}
+			track.on(TrackEvent.VideoPlaybackStarted, () => {
+				this.events.emit("firstFrame");
+			});
+		});
+		room.on(RoomEvent.Disconnected, (reason) => {
+			this.logger.warn("livekit: room disconnected", { reason });
+			this.events.emit("disconnected", { reason });
+		});
+		this.config.observability?.startPhase("webrtc-handshake");
+		await room.connect(opts.url, opts.token);
+		this.config.observability?.endPhase("webrtc-handshake", { success: true });
+		this.config.observability?.setLiveKitRoom(room);
+	}
+	async publishLocalTracks() {
+		if (!this.config.localStream) return;
+		this.config.observability?.startPhase("publish-local-track");
+		await this.publishTracks(this.config.localStream);
+		this.config.observability?.endPhase("publish-local-track", { success: true });
+	}
+	disconnect() {
+		const room = this.room;
+		this.room = null;
+		this.remoteStream = null;
+		this.config.observability?.setLiveKitRoom(null);
+		if (room) room.disconnect().catch(() => {});
+	}
+	async publishTracks(stream) {
+		if (!this.room) return;
+		for (const track of stream.getTracks()) if (track.kind === "video") await this.room.localParticipant.publishTrack(track, getDefaultVideoPublishOptions(this.config.videoCodec));
+		else await this.room.localParticipant.publishTrack(track);
+	}
+};
+//#endregion
+export { MediaChannel };

package/dist/realtime/methods.js

@@ -1,8 +1,6 @@
+import { REALTIME_CONFIG } from "./config-realtime.js";
 import { z } from "zod";
-
 //#region src/realtime/methods.ts
-const PROMPT_TIMEOUT_MS = 15 * 1e3;
-const UPDATE_TIMEOUT_MS = 30 * 1e3;
 const setInputSchema = z.object({
 	prompt: z.string().min(1).optional(),
 	enhance: z.boolean().optional().default(true),
@@ -17,61 +15,33 @@ const setPromptInputSchema = z.object({
 	prompt: z.string().min(1),
 	enhance: z.boolean().optional().default(true)
 });
-const realtimeMethods = (webrtcManager, imageToBase64) => {
-	const assertConnected = () => {
-		const state = webrtcManager.getConnectionState();
-		if (state !== "connected" && state !== "generating") throw new Error(`Cannot send message: connection is ${state}`);
-	};
+const realtimeMethods = (session, imageToBase64) => {
 	const set = async (input) => {
-		assertConnected();
 		const parsed = setInputSchema.safeParse(input);
 		if (!parsed.success) throw parsed.error;
 		const { prompt, enhance, image } = parsed.data;
-		let imageBase64 = null;
-		if (image !== void 0 && image !== null) imageBase64 = await imageToBase64(image);
-		await webrtcManager.setImage(imageBase64, {
+		const imageBase64 = image !== void 0 && image !== null ? await imageToBase64(image) : null;
+		await session.setImage(imageBase64, {
 			prompt,
 			enhance,
-			timeout: UPDATE_TIMEOUT_MS
+			timeout: REALTIME_CONFIG.methods.updateTimeoutMs
 		});
 	};
 	const setPrompt = async (prompt, { enhance } = {}) => {
-		assertConnected();
-		const parsedInput = setPromptInputSchema.safeParse({
+		const parsed = setPromptInputSchema.safeParse({
 			prompt,
 			enhance
 		});
-		if (!parsedInput.success) throw parsedInput.error;
-		const emitter = webrtcManager.getWebsocketMessageEmitter();
-		let promptAckListener;
-		let timeoutId;
-		try {
-			const ackPromise = new Promise((resolve, reject) => {
-				promptAckListener = (promptAckMessage) => {
-					if (promptAckMessage.prompt === parsedInput.data.prompt) if (promptAckMessage.success) resolve();
-					else reject(new Error(promptAckMessage.error ?? "Failed to send prompt"));
-				};
-				emitter.on("promptAck", promptAckListener);
-			});
-			if (!webrtcManager.sendMessage({
-				type: "prompt",
-				prompt: parsedInput.data.prompt,
-				enhance_prompt: parsedInput.data.enhance
-			})) throw new Error("WebSocket is not open");
-			const timeoutPromise = new Promise((_, reject) => {
-				timeoutId = setTimeout(() => reject(/* @__PURE__ */ new Error("Prompt timed out")), PROMPT_TIMEOUT_MS);
-			});
-			await Promise.race([ackPromise, timeoutPromise]);
-		} finally {
-			if (promptAckListener) emitter.off("promptAck", promptAckListener);
-			if (timeoutId) clearTimeout(timeoutId);
-		}
+		if (!parsed.success) throw parsed.error;
+		await session.sendPrompt(parsed.data.prompt, {
+			enhance: parsed.data.enhance,
+			timeout: REALTIME_CONFIG.methods.promptTimeoutMs
+		});
 	};
 	return {
 		set,
 		setPrompt
 	};
 };
-
 //#endregion
-export { realtimeMethods };
+export { realtimeMethods };

package/dist/realtime/mirror-stream.js

@@ -111,6 +111,5 @@ function createWithCanvas(sourceVideo, audioTracks, fps) {
 		}
 	};
 }
-
 //#endregion
-export { createMirroredStream, shouldMirrorTrack };
+export { createMirroredStream, shouldMirrorTrack };

package/dist/realtime/observability/diagnostics.d.ts

@@ -1,47 +1,17 @@
 //#region src/realtime/observability/diagnostics.d.ts
-/** Connection phase names for timing events. */
-type ConnectionPhase = "websocket" | "avatar-image" | "initial-prompt" | "webrtc-handshake" | "total";
-type PhaseTimingEvent = {
-  phase: ConnectionPhase;
+type ClientSessionConnectionBreakdownPhase = {
+  phase: string;
   durationMs: number;
   success: boolean;
   error?: string;
 };
-type IceCandidateEvent = {
-  source: "local" | "remote";
-  candidateType: "host" | "srflx" | "prflx" | "relay" | "unknown";
-  protocol: "udp" | "tcp" | "unknown";
-  address?: string;
-  port?: number;
-};
-type IceStateEvent = {
-  state: string;
-  previousState: string;
-  timestampMs: number;
-};
-type PeerConnectionStateEvent = {
-  state: string;
-  previousState: string;
-  timestampMs: number;
-};
-type SignalingStateEvent = {
-  state: string;
-  previousState: string;
-  timestampMs: number;
-};
-type SelectedCandidatePairEvent = {
-  local: {
-    candidateType: string;
-    protocol: string;
-    address?: string;
-    port?: number;
-  };
-  remote: {
-    candidateType: string;
-    protocol: string;
-    address?: string;
-    port?: number;
-  };
+type ClientSessionConnectionBreakdownEvent = {
+  attempt: number;
+  success: boolean;
+  totalDurationMs: number;
+  initialImageSizeKb: number | null;
+  phases: ClientSessionConnectionBreakdownPhase[];
+  error?: string;
 };
 type ReconnectEvent = {
   attempt: number;
@@ -51,28 +21,19 @@ type ReconnectEvent = {
   error?: string;
 };
 type VideoStallEvent = {
-  /** True when a stall is detected, false when recovered. */
   stalled: boolean;
-  /** Duration of the stall in ms (0 when stall first detected, actual duration on recovery). */
   durationMs: number;
 };
-/** All diagnostic event types keyed by name. */
 type DiagnosticEvents = {
-  phaseTiming: PhaseTimingEvent;
-  iceCandidate: IceCandidateEvent;
-  iceStateChange: IceStateEvent;
-  peerConnectionStateChange: PeerConnectionStateEvent;
-  signalingStateChange: SignalingStateEvent;
-  selectedCandidatePair: SelectedCandidatePairEvent;
+  "client-session-connection-breakdown": ClientSessionConnectionBreakdownEvent;
   reconnect: ReconnectEvent;
   videoStall: VideoStallEvent;
 };
 type DiagnosticEventName = keyof DiagnosticEvents;
-/** A single diagnostic event with its name and typed data. */
-type DiagnosticEvent = { [K in DiagnosticEventName]: {
+type DiagnosticEventForName<K extends DiagnosticEventName> = {
   name: K;
   data: DiagnosticEvents[K];
-} }[DiagnosticEventName];
-/** Callback for emitting diagnostic events from the connection/manager layers. */
+};
+type DiagnosticEvent = { [K in DiagnosticEventName]: DiagnosticEventForName<K> }[DiagnosticEventName];
 //#endregion
-export { ConnectionPhase, DiagnosticEvent, DiagnosticEventName, DiagnosticEvents, IceCandidateEvent, IceStateEvent, PeerConnectionStateEvent, PhaseTimingEvent, ReconnectEvent, SelectedCandidatePairEvent, SignalingStateEvent, VideoStallEvent };
+export { ClientSessionConnectionBreakdownEvent, ClientSessionConnectionBreakdownPhase, DiagnosticEvent, DiagnosticEventName, DiagnosticEvents, ReconnectEvent, VideoStallEvent };

package/dist/realtime/observability/livekit-stats-provider.js

@@ -0,0 +1,25 @@
+//#region src/realtime/observability/livekit-stats-provider.ts
+function createLiveKitStatsProvider(room) {
+	let uid = 0;
+	const collectFromTrack = async (track, entries) => {
+		if (!track) return;
+		let report;
+		try {
+			report = await track.getRTCStatsReport();
+		} catch {
+			return;
+		}
+		if (!report) return;
+		report.forEach((stat, id) => {
+			entries.push([`${id}#${uid++}`, stat]);
+		});
+	};
+	return { async getStats() {
+		const entries = [];
+		for (const pub of room.localParticipant.trackPublications.values()) await collectFromTrack(pub.track, entries);
+		for (const participant of room.remoteParticipants.values()) for (const pub of participant.trackPublications.values()) await collectFromTrack(pub.track, entries);
+		return new Map(entries);
+	} };
+}
+//#endregion
+export { createLiveKitStatsProvider };

package/dist/realtime/observability/realtime-observability.js

@@ -1,16 +1,18 @@
+import { REALTIME_CONFIG } from "../config-realtime.js";
+import { createLiveKitStatsProvider } from "./livekit-stats-provider.js";
 import { NullTelemetryReporter, TelemetryReporter } from "./telemetry-reporter.js";
 import { WebRTCStatsCollector } from "./webrtc-stats.js";
-
 //#region src/realtime/observability/realtime-observability.ts
-const STALL_FPS_THRESHOLD = .5;
 var RealtimeObservability = class {
 	telemetryReporter = new NullTelemetryReporter();
 	telemetryReporterReady = false;
 	pendingTelemetryDiagnostics = [];
 	statsCollector = null;
 	statsCollectorSource = null;
+	liveKitRoom = null;
 	videoStalled = false;
 	stallStartMs = 0;
+	connectionBreakdown = null;
 	constructor(options) {
 		this.options = options;
 	}
@@ -22,6 +24,56 @@ var RealtimeObservability = class {
 		});
 		this.addTelemetryDiagnostic(name, data, timestamp);
 	}
+	beginConnectionBreakdown(attempt, initialImageSizeKb) {
+		this.connectionBreakdown = {
+			attempt,
+			connectStartedAt: Date.now(),
+			initialImageSizeKb,
+			phases: /* @__PURE__ */ new Map()
+		};
+	}
+	startPhase(name) {
+		if (!this.connectionBreakdown) return;
+		this.connectionBreakdown.phases.set(name, { startedAt: Date.now() });
+	}
+	endPhase(name, opts) {
+		if (!this.connectionBreakdown) return;
+		const entry = this.connectionBreakdown.phases.get(name);
+		if (!entry) {
+			this.options.logger.warn("observability: endPhase called for unknown phase", { phase: name });
+			return;
+		}
+		entry.endedAt = Date.now();
+		entry.success = opts.success;
+		if (opts.error !== void 0) entry.error = opts.error;
+	}
+	finishConnectionBreakdown(opts) {
+		const buffer = this.connectionBreakdown;
+		if (!buffer) return;
+		this.connectionBreakdown = null;
+		const now = Date.now();
+		const phases = [];
+		for (const [phase, entry] of buffer.phases) {
+			const unfinished = entry.endedAt === void 0;
+			const endedAt = entry.endedAt ?? now;
+			const success = entry.success ?? false;
+			const error = entry.error ?? (unfinished && !opts.success ? opts.error : void 0);
+			phases.push({
+				phase,
+				durationMs: endedAt - entry.startedAt,
+				success,
+				...error !== void 0 ? { error } : {}
+			});
+		}
+		this.diagnostic("client-session-connection-breakdown", {
+			attempt: buffer.attempt,
+			success: opts.success,
+			totalDurationMs: now - buffer.connectStartedAt,
+			initialImageSizeKb: buffer.initialImageSizeKb,
+			phases,
+			...opts.error !== void 0 ? { error: opts.error } : {}
+		}, now);
+	}
 	sessionStarted(sessionId) {
 		if (!this.options.telemetryEnabled) return;
 		if (this.telemetryReporterReady) this.telemetryReporter.stop();
@@ -45,15 +97,27 @@ var RealtimeObservability = class {
 		}
 		if (source === this.statsCollectorSource) return;
 		this.stopStats();
+		this.resetStallDetection();
 		this.statsCollectorSource = source;
 		if (!this.options.telemetryEnabled && !this.options.onStats) return;
 		this.statsCollector = new WebRTCStatsCollector();
 		this.statsCollector.start(source, (stats) => this.handleStats(stats));
 	}
+	setLiveKitRoom(room) {
+		if (!room) {
+			this.liveKitRoom = null;
+			this.setStatsProvider(null);
+			return;
+		}
+		if (room === this.liveKitRoom) return;
+		this.setStatsProvider(createLiveKitStatsProvider(room));
+		this.liveKitRoom = room;
+	}
 	stopStats() {
 		this.statsCollector?.stop();
 		this.statsCollector = null;
 		this.statsCollectorSource = null;
+		this.liveKitRoom = null;
 		this.resetStallDetection();
 	}
 	stop() {
@@ -62,6 +126,7 @@ var RealtimeObservability = class {
 		this.telemetryReporter = new NullTelemetryReporter();
 		this.telemetryReporterReady = false;
 		this.pendingTelemetryDiagnostics.length = 0;
+		this.connectionBreakdown = null;
 	}
 	handleStats(stats) {
 		this.options.onStats?.(stats);
@@ -70,14 +135,14 @@ var RealtimeObservability = class {
 	}
 	detectVideoStall(stats) {
 		const fps = stats.video?.framesPerSecond ?? 0;
-		if (!this.videoStalled && stats.video && fps < STALL_FPS_THRESHOLD) {
+		if (!this.videoStalled && stats.video && fps < REALTIME_CONFIG.observability.stallFpsThreshold) {
 			this.videoStalled = true;
 			this.stallStartMs = Date.now();
 			this.diagnostic("videoStall", {
 				stalled: true,
 				durationMs: 0
 			}, this.stallStartMs);
-		} else if (this.videoStalled && fps >= STALL_FPS_THRESHOLD) {
+		} else if (this.videoStalled && fps >= REALTIME_CONFIG.observability.stallFpsThreshold) {
 			const durationMs = Date.now() - this.stallStartMs;
 			this.videoStalled = false;
 			this.diagnostic("videoStall", {
@@ -104,6 +169,5 @@ var RealtimeObservability = class {
 		this.stallStartMs = 0;
 	}
 };
-
 //#endregion
-export { RealtimeObservability };
+export { RealtimeObservability };

package/dist/realtime/observability/telemetry-reporter.js

@@ -1,14 +1,7 @@
 import { VERSION } from "../../version.js";
 import { buildAuthHeaders } from "../../shared/request.js";
-
+import { REALTIME_CONFIG } from "../config-realtime.js";
 //#region src/realtime/observability/telemetry-reporter.ts
-const DEFAULT_REPORT_INTERVAL_MS = 1e4;
-const TELEMETRY_URL = "https://platform.decart.ai/api/v1/telemetry";
-/**
-* Maximum number of items per array (stats / diagnostics) in a single report.
-* Matches the backend Zod schema which enforces `z.array().max(120)`.
-*/
-const MAX_ITEMS_PER_REPORT = 120;
 /** No-op reporter that silently discards all data. Used when telemetry is disabled. */
 var NullTelemetryReporter = class {
 	start() {}
@@ -22,7 +15,6 @@ var TelemetryReporter = class {
 	sessionId;
 	model;
 	integration;
-	logger;
 	reportIntervalMs;
 	intervalId = null;
 	statsBuffer = [];
@@ -32,8 +24,7 @@ var TelemetryReporter = class {
 		this.sessionId = options.sessionId;
 		this.model = options.model;
 		this.integration = options.integration;
-		this.logger = options.logger;
-		this.reportIntervalMs = options.reportIntervalMs ?? DEFAULT_REPORT_INTERVAL_MS;
+		this.reportIntervalMs = options.reportIntervalMs ?? REALTIME_CONFIG.observability.telemetryReportIntervalMs;
 	}
 	/** Start the periodic reporting timer. */
 	start() {
@@ -62,7 +53,7 @@ var TelemetryReporter = class {
 		this.diagnosticsBuffer = [];
 	}
 	/**
-	* Build a single chunk from the front of the buffers, respecting MAX_ITEMS_PER_REPORT.
+	* Build a single chunk from the front of the buffers, respecting the configured report item cap.
 	* Returns null when both buffers are empty.
 	*/
 	createReportChunk() {
@@ -79,8 +70,8 @@ var TelemetryReporter = class {
 			sdkVersion: VERSION,
 			...this.model ? { model: this.model } : {},
 			tags,
-			stats: this.statsBuffer.splice(0, MAX_ITEMS_PER_REPORT),
-			diagnostics: this.diagnosticsBuffer.splice(0, MAX_ITEMS_PER_REPORT)
+			stats: this.statsBuffer.splice(0, REALTIME_CONFIG.observability.telemetryMaxItemsPerReport),
+			diagnostics: this.diagnosticsBuffer.splice(0, REALTIME_CONFIG.observability.telemetryMaxItemsPerReport)
 		};
 	}
 	sendReport() {
@@ -95,25 +86,15 @@ var TelemetryReporter = class {
 			};
 			let chunk = this.createReportChunk();
 			while (chunk !== null) {
-				fetch(TELEMETRY_URL, {
+				fetch(REALTIME_CONFIG.observability.telemetryUrl, {
 					method: "POST",
 					headers: commonHeaders,
 					body: JSON.stringify(chunk)
-				}).then((response) => {
-					if (!response.ok) this.logger.warn("Telemetry report rejected", {
-						status: response.status,
-						statusText: response.statusText
-					});
-				}).catch((error) => {
-					this.logger.debug("Telemetry report failed", { error: String(error) });
-				});
+				}).catch(() => {});
 				chunk = this.createReportChunk();
 			}
-		} catch (error) {
-			this.logger.debug("Telemetry report failed", { error: String(error) });
-		}
+		} catch {}
 	}
 };
-
 //#endregion
-export { NullTelemetryReporter, TelemetryReporter };
+export { NullTelemetryReporter, TelemetryReporter };

package/dist/realtime/observability/webrtc-stats.d.ts

@@ -127,10 +127,7 @@ type WebRTCStats = {
      * jitter and failure modes, so this is essential signal for
      * benchmarking and incident triage.
      */
-    selectedCandidatePairs: Array<{
-      local: IceCandidateInfo;
-      remote: IceCandidateInfo;
-    }>;
+    selectedCandidatePairs: IceCandidatePair[];
   };
 };
 /** One side of an ICE candidate pair (sender or receiver). */
@@ -143,5 +140,9 @@ type IceCandidateInfo = {
   /** "udp" | "tcp" */
   protocol: string;
 };
+type IceCandidatePair = {
+  local: IceCandidateInfo;
+  remote: IceCandidateInfo;
+};
 //#endregion
 export { WebRTCStats };

package/dist/realtime/observability/webrtc-stats.js

@@ -1,6 +1,5 @@
+import { REALTIME_CONFIG } from "../config-realtime.js";
 //#region src/realtime/observability/webrtc-stats.ts
-const DEFAULT_INTERVAL_MS = 1e3;
-const MIN_INTERVAL_MS = 500;
 var WebRTCStatsCollector = class {
 	source = null;
 	intervalId = null;
@@ -17,7 +16,7 @@ var WebRTCStatsCollector = class {
 	onStats = null;
 	intervalMs;
 	constructor(options = {}) {
-		this.intervalMs = Math.max(options.intervalMs ?? DEFAULT_INTERVAL_MS, MIN_INTERVAL_MS);
+		this.intervalMs = Math.max(options.intervalMs ?? REALTIME_CONFIG.observability.statsDefaultIntervalMs, REALTIME_CONFIG.observability.statsMinIntervalMs);
 	}
 	/** Attach to a stats provider and start polling. */
 	start(source, onStats) {
@@ -273,6 +272,5 @@ var WebRTCStatsCollector = class {
 		};
 	}
 };
-
 //#endregion
-export { WebRTCStatsCollector };
+export { WebRTCStatsCollector };