@decartai/sdk 0.0.66 → 0.0.68

package/README.md

@@ -62,6 +62,33 @@ realtimeClient.setPrompt("Cyberpunk city");
 realtimeClient.disconnect();
 ```
 
+#### Front-camera mirroring
+
+Pre-flip the input stream:
+
+```ts
+const realtimeClient = await client.realtime.connect(stream, {
+  model,
+  mirror: "auto", // or true to always mirror
+  // ...
+});
+```
+
+Options:
+- `false` (default) — never mirror.
+- `"auto"` — mirror when the input track reports `facingMode: "user"` (mobile front cameras).
+- `true` — always mirror (e.g. desktop webcams).
+
+#### Output resolution
+
+```ts
+const realtimeClient = await client.realtime.connect(stream, {
+  model,
+  resolution: "1080p", // default: "720p"
+  // ...
+});
+```
+
 ### Async Processing (Queue API)
 
 For video generation jobs, use the queue API to submit jobs and poll for results:

package/dist/index.d.ts

@@ -5,11 +5,11 @@ import { ProcessClient } from "./process/client.js";
 import { JobStatus, JobStatusResponse, JobSubmitResponse, QueueJobResult, QueueSubmitAndPollOptions, QueueSubmitOptions } from "./queue/types.js";
 import { QueueClient } from "./queue/client.js";
 import { DecartSDKError, ERROR_CODES } from "./utils/errors.js";
-import { ConnectionPhase, DiagnosticEvent, DiagnosticEventName, DiagnosticEvents, IceCandidateEvent, IceStateEvent, PeerConnectionStateEvent, PhaseTimingEvent, ReconnectEvent, SelectedCandidatePairEvent, SignalingStateEvent, VideoStallEvent } from "./realtime/diagnostics.js";
 import { ConnectionState } from "./realtime/types.js";
+import { ConnectionPhase, DiagnosticEvent, DiagnosticEventName, DiagnosticEvents, IceCandidateEvent, IceStateEvent, PeerConnectionStateEvent, PhaseTimingEvent, ReconnectEvent, SelectedCandidatePairEvent, SignalingStateEvent, VideoStallEvent } from "./realtime/observability/diagnostics.js";
+import { WebRTCStats } from "./realtime/observability/webrtc-stats.js";
 import { SetInput } from "./realtime/methods.js";
 import { RealTimeSubscribeClient, SubscribeEvents, SubscribeOptions } from "./realtime/subscribe-client.js";
-import { WebRTCStats } from "./realtime/webrtc-stats.js";
 import { Events, RealTimeClient, RealTimeClientConnectOptions, RealTimeClientInitialState } from "./realtime/client.js";
 import { ModelState } from "./shared/types.js";
 import { CreateTokenOptions, CreateTokenResponse, TokensClient } from "./tokens/client.js";

package/dist/realtime/client.d.ts

@@ -1,9 +1,9 @@
 import { CustomModelDefinition, ModelDefinition } from "../shared/model.js";
 import { DecartSDKError } from "../utils/errors.js";
-import { DiagnosticEvent } from "./diagnostics.js";
 import { ConnectionState } from "./types.js";
+import { DiagnosticEvent } from "./observability/diagnostics.js";
+import { WebRTCStats } from "./observability/webrtc-stats.js";
 import { SetInput } from "./methods.js";
-import { WebRTCStats } from "./webrtc-stats.js";
 import { z } from "zod";
 
 //#region src/realtime/client.d.ts
@@ -36,6 +36,11 @@ declare const realTimeClientConnectOptionsSchema: z.ZodObject<{
     image: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Blob, Blob>, z.ZodCustom<File, File>, z.ZodString]>>;
   }, z.core.$strip>>;
   customizeOffer: z.ZodOptional<z.ZodCustom<z.core.$InferInnerFunctionTypeAsync<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>, z.core.$InferInnerFunctionTypeAsync<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>>;
+  mirror: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBoolean]>>;
+  resolution: z.ZodOptional<z.ZodEnum<{
+    "720p": "720p";
+    "1080p": "1080p";
+  }>>;
 }, z.core.$strip>;
 type RealTimeClientConnectOptions = Omit<z.infer<typeof realTimeClientConnectOptionsSchema>, "model"> & {
   model: ModelDefinition | CustomModelDefinition;

package/dist/realtime/client.js

@@ -3,10 +3,10 @@ import { modelDefinitionSchema } from "../shared/model.js";
 import { modelStateSchema } from "../shared/types.js";
 import { createEventBuffer } from "./event-buffer.js";
 import { realtimeMethods } from "./methods.js";
+import { createMirroredStream, shouldMirrorTrack } from "./mirror-stream.js";
+import { RealtimeObservability } from "./observability/realtime-observability.js";
 import { decodeSubscribeToken, encodeSubscribeToken } from "./subscribe-client.js";
-import { NullTelemetryReporter, TelemetryReporter } from "./telemetry-reporter.js";
 import { WebRTCManager } from "./webrtc-manager.js";
-import { WebRTCStatsCollector } from "./webrtc-stats.js";
 import { z } from "zod";
 
 //#region src/realtime/client.ts
@@ -56,18 +56,39 @@ const realTimeClientConnectOptionsSchema = z.object({
 	model: modelDefinitionSchema,
 	onRemoteStream: z.custom((val) => typeof val === "function", { message: "onRemoteStream must be a function" }),
 	initialState: realTimeClientInitialStateSchema.optional(),
-	customizeOffer: createAsyncFunctionSchema(z.function()).optional()
+	customizeOffer: createAsyncFunctionSchema(z.function()).optional(),
+	mirror: z.union([z.literal("auto"), z.boolean()]).optional(),
+	resolution: z.enum(["720p", "1080p"]).optional()
 });
 const createRealTimeClient = (opts) => {
 	const { baseUrl, apiKey, integration, logger } = opts;
 	const connect = async (stream, options) => {
 		const parsedOptions = realTimeClientConnectOptionsSchema.safeParse(options);
 		if (!parsedOptions.success) throw parsedOptions.error;
-		const { onRemoteStream, initialState } = parsedOptions.data;
-		const inputStream = stream ?? new MediaStream();
+		const { onRemoteStream, initialState, resolution } = parsedOptions.data;
+		const mirror = parsedOptions.data.mirror ?? false;
+		let inputStream = stream ?? new MediaStream();
+		let mirroredStream;
+		if (mirror !== false) try {
+			const firstVideoTrack = inputStream.getVideoTracks?.()[0];
+			if (firstVideoTrack && (mirror === true || shouldMirrorTrack(firstVideoTrack))) {
+				mirroredStream = createMirroredStream(inputStream, { fps: options.model.fps });
+				inputStream = mirroredStream.stream;
+			} else if (mirror === true && !firstVideoTrack) logger.warn("mirror: true requested but no video track was found on the input stream");
+		} catch (error) {
+			logger.warn("Failed to mirror input stream; falling back to un-mirrored input", { error: error instanceof Error ? error.message : String(error) });
+		}
 		let webrtcManager;
-		let telemetryReporter = new NullTelemetryReporter();
-		let handleConnectionStateChange = null;
+		const { emitter: eventEmitter, emitOrBuffer, flush, stop } = createEventBuffer();
+		const observability = new RealtimeObservability({
+			telemetryEnabled: opts.telemetryEnabled,
+			apiKey,
+			model: options.model.name,
+			integration,
+			logger,
+			onDiagnostic: (event) => emitOrBuffer("diagnostic", event),
+			onStats: opts.telemetryEnabled ? (stats) => emitOrBuffer("stats", stats) : void 0
+		});
 		try {
 			const initialImage = initialState?.image ? await imageToBase64(initialState.image) : void 0;
 			const initialPrompt = initialState?.prompt ? {
@@ -75,22 +96,15 @@ const createRealTimeClient = (opts) => {
 				enhance: initialState.prompt.enhance
 			} : void 0;
 			const url = `${baseUrl}${options.model.urlPath}`;
-			const { emitter: eventEmitter, emitOrBuffer, flush, stop } = createEventBuffer();
+			const resolutionQs = resolution ? `&resolution=${encodeURIComponent(resolution)}` : "";
 			webrtcManager = new WebRTCManager({
-				webrtcUrl: `${url}?api_key=${encodeURIComponent(apiKey)}&model=${encodeURIComponent(options.model.name)}`,
+				webrtcUrl: `${url}?api_key=${encodeURIComponent(apiKey)}&model=${encodeURIComponent(options.model.name)}${resolutionQs}`,
 				integration,
 				logger,
-				onDiagnostic: (name, data) => {
-					emitOrBuffer("diagnostic", {
-						name,
-						data
-					});
-					addTelemetryDiagnostic(name, data);
-				},
+				observability,
 				onRemoteStream,
 				onConnectionStateChange: (state) => {
 					emitOrBuffer("connectionChange", state);
-					handleConnectionStateChange?.(state);
 				},
 				onError: (error) => {
 					logger.error("WebRTC error", { error: error.message });
@@ -105,42 +119,10 @@ const createRealTimeClient = (opts) => {
 			const manager = webrtcManager;
 			let sessionId = null;
 			let subscribeToken = null;
-			const pendingTelemetryDiagnostics = [];
-			let telemetryReporterReady = false;
-			const addTelemetryDiagnostic = (name, data, timestamp = Date.now()) => {
-				if (!opts.telemetryEnabled) return;
-				if (!telemetryReporterReady) {
-					pendingTelemetryDiagnostics.push({
-						name,
-						data,
-						timestamp
-					});
-					return;
-				}
-				telemetryReporter.addDiagnostic({
-					name,
-					data,
-					timestamp
-				});
-			};
 			const sessionIdListener = (msg) => {
 				subscribeToken = encodeSubscribeToken(msg.session_id, msg.server_ip, msg.server_port);
 				sessionId = msg.session_id;
-				if (opts.telemetryEnabled) {
-					if (telemetryReporterReady) telemetryReporter.stop();
-					const reporter = new TelemetryReporter({
-						apiKey,
-						sessionId: msg.session_id,
-						model: options.model.name,
-						integration,
-						logger
-					});
-					reporter.start();
-					telemetryReporter = reporter;
-					telemetryReporterReady = true;
-					for (const diagnostic of pendingTelemetryDiagnostics) telemetryReporter.addDiagnostic(diagnostic);
-					pendingTelemetryDiagnostics.length = 0;
-				}
+				observability.sessionStarted(msg.session_id);
 			};
 			manager.getWebsocketMessageEmitter().on("sessionId", sessionIdListener);
 			const tickListener = (msg) => {
@@ -149,76 +131,16 @@ const createRealTimeClient = (opts) => {
 			manager.getWebsocketMessageEmitter().on("generationTick", tickListener);
 			await manager.connect(inputStream);
 			const methods = realtimeMethods(manager, imageToBase64);
-			let statsCollector = null;
-			let statsCollectorPeerConnection = null;
-			const STALL_FPS_THRESHOLD = .5;
-			let videoStalled = false;
-			let stallStartMs = 0;
-			const startStatsCollection = () => {
-				statsCollector?.stop();
-				videoStalled = false;
-				stallStartMs = 0;
-				statsCollector = new WebRTCStatsCollector();
-				const pc = manager.getPeerConnection();
-				statsCollectorPeerConnection = pc;
-				if (pc) statsCollector.start(pc, (stats) => {
-					emitOrBuffer("stats", stats);
-					telemetryReporter.addStats(stats);
-					const fps = stats.video?.framesPerSecond ?? 0;
-					if (!videoStalled && stats.video && fps < STALL_FPS_THRESHOLD) {
-						videoStalled = true;
-						stallStartMs = Date.now();
-						emitOrBuffer("diagnostic", {
-							name: "videoStall",
-							data: {
-								stalled: true,
-								durationMs: 0
-							}
-						});
-						addTelemetryDiagnostic("videoStall", {
-							stalled: true,
-							durationMs: 0
-						}, stallStartMs);
-					} else if (videoStalled && fps >= STALL_FPS_THRESHOLD) {
-						const durationMs = Date.now() - stallStartMs;
-						videoStalled = false;
-						emitOrBuffer("diagnostic", {
-							name: "videoStall",
-							data: {
-								stalled: false,
-								durationMs
-							}
-						});
-						addTelemetryDiagnostic("videoStall", {
-							stalled: false,
-							durationMs
-						});
-					}
-				});
-				return () => {
-					statsCollector?.stop();
-					statsCollector = null;
-					statsCollectorPeerConnection = null;
-				};
-			};
-			handleConnectionStateChange = (state) => {
-				if (!opts.telemetryEnabled) return;
-				if (state !== "connected" && state !== "generating") return;
-				const peerConnection = manager.getPeerConnection();
-				if (!peerConnection || peerConnection === statsCollectorPeerConnection) return;
-				startStatsCollection();
-			};
-			if (opts.telemetryEnabled) startStatsCollection();
 			const client = {
 				set: methods.set,
 				setPrompt: methods.setPrompt,
 				isConnected: () => manager.isConnected(),
 				getConnectionState: () => manager.getConnectionState(),
 				disconnect: () => {
-					statsCollector?.stop();
-					telemetryReporter.stop();
+					observability.stop();
 					stop();
 					manager.cleanup();
+					mirroredStream?.dispose();
 				},
 				on: eventEmitter.on,
 				off: eventEmitter.off,
@@ -237,8 +159,9 @@ const createRealTimeClient = (opts) => {
 			flush();
 			return client;
 		} catch (error) {
-			telemetryReporter.stop();
+			observability.stop();
 			webrtcManager?.cleanup();
+			mirroredStream?.dispose();
 			throw error;
 		}
 	};
@@ -247,17 +170,21 @@ const createRealTimeClient = (opts) => {
 		const subscribeUrl = `${baseUrl}/subscribe/${encodeURIComponent(sid)}?IP=${encodeURIComponent(ip)}&port=${encodeURIComponent(port)}&api_key=${encodeURIComponent(apiKey)}`;
 		const { emitter: eventEmitter, emitOrBuffer, flush, stop } = createEventBuffer();
 		let webrtcManager;
+		const observability = new RealtimeObservability({
+			telemetryEnabled: opts.telemetryEnabled,
+			apiKey,
+			integration,
+			logger,
+			onDiagnostic: (event) => emitOrBuffer("diagnostic", event),
+			onStats: opts.telemetryEnabled ? (stats) => emitOrBuffer("stats", stats) : void 0
+		});
+		observability.sessionStarted(sid);
 		try {
 			webrtcManager = new WebRTCManager({
 				webrtcUrl: subscribeUrl,
 				integration,
 				logger,
-				onDiagnostic: (name, data) => {
-					emitOrBuffer("diagnostic", {
-						name,
-						data
-					});
-				},
+				observability,
 				onRemoteStream: options.onRemoteStream,
 				onConnectionStateChange: (state) => {
 					emitOrBuffer("connectionChange", state);
@@ -273,6 +200,7 @@ const createRealTimeClient = (opts) => {
 				isConnected: () => manager.isConnected(),
 				getConnectionState: () => manager.getConnectionState(),
 				disconnect: () => {
+					observability.stop();
 					stop();
 					manager.cleanup();
 				},
@@ -282,6 +210,7 @@ const createRealTimeClient = (opts) => {
 			flush();
 			return client;
 		} catch (error) {
+			observability.stop();
 			webrtcManager?.cleanup();
 			throw error;
 		}

package/dist/realtime/mirror-stream.js

@@ -0,0 +1,116 @@
+//#region src/realtime/mirror-stream.ts
+function isMediaStreamTrackProcessorSupported() {
+	return typeof globalThis !== "undefined" && typeof globalThis.MediaStreamTrackProcessor === "function" && typeof globalThis.MediaStreamTrackGenerator === "function";
+}
+function shouldMirrorTrack(track) {
+	if (track.kind !== "video") return false;
+	let facingMode;
+	try {
+		facingMode = track.getSettings?.().facingMode;
+	} catch {
+		return false;
+	}
+	return facingMode === "user";
+}
+function createMirroredStream(input, opts) {
+	const [sourceVideo] = input.getVideoTracks();
+	const audioTracks = input.getAudioTracks();
+	if (!sourceVideo) return {
+		stream: input,
+		dispose: () => {},
+		impl: "noop"
+	};
+	if (isMediaStreamTrackProcessorSupported()) return createWithTrackProcessor(sourceVideo, audioTracks);
+	return createWithCanvas(sourceVideo, audioTracks, opts.fps);
+}
+function createWithTrackProcessor(sourceVideo, audioTracks) {
+	const Processor = globalThis.MediaStreamTrackProcessor;
+	const Generator = globalThis.MediaStreamTrackGenerator;
+	if (!new OffscreenCanvas(1, 1).getContext("2d")) throw new Error("createMirroredStream: OffscreenCanvas 2D context unavailable");
+	const processor = new Processor({ track: sourceVideo });
+	const generator = new Generator({ kind: "video" });
+	let canvas = new OffscreenCanvas(1, 1);
+	let ctx = canvas.getContext("2d");
+	const transform = new TransformStream({ transform(frame, controller) {
+		const w = frame.displayWidth;
+		const h = frame.displayHeight;
+		if (canvas.width !== w || canvas.height !== h) {
+			canvas = new OffscreenCanvas(w, h);
+			ctx = canvas.getContext("2d");
+		}
+		let flipped;
+		try {
+			ctx.save();
+			ctx.setTransform(-1, 0, 0, 1, w, 0);
+			ctx.drawImage(frame, 0, 0, w, h);
+			ctx.restore();
+			flipped = new VideoFrame(canvas, {
+				timestamp: frame.timestamp,
+				alpha: "discard"
+			});
+			controller.enqueue(flipped);
+			flipped = void 0;
+		} finally {
+			flipped?.close();
+			frame.close();
+		}
+	} });
+	processor.readable.pipeThrough(transform).pipeTo(generator.writable).catch(() => {});
+	const stream = new MediaStream([generator, ...audioTracks]);
+	let disposed = false;
+	return {
+		stream,
+		impl: "track-processor",
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			generator.stop();
+		}
+	};
+}
+function createWithCanvas(sourceVideo, audioTracks, fps) {
+	if (typeof document === "undefined") throw new Error("createMirroredStream requires a DOM environment (document is undefined)");
+	const canvas = document.createElement("canvas");
+	const ctx = canvas.getContext("2d");
+	if (!ctx) throw new Error("createMirroredStream: 2D canvas context unavailable");
+	if (typeof canvas.captureStream !== "function") throw new Error("createMirroredStream: canvas.captureStream unavailable");
+	const [flippedTrack] = canvas.captureStream(fps).getVideoTracks();
+	if (!flippedTrack) throw new Error("createMirroredStream: canvas.captureStream produced no video track");
+	const video = document.createElement("video");
+	video.muted = true;
+	video.playsInline = true;
+	video.autoplay = true;
+	video.srcObject = new MediaStream([sourceVideo]);
+	let disposed = false;
+	let rafHandle = null;
+	const draw = () => {
+		if (disposed) return;
+		const w = video.videoWidth;
+		const h = video.videoHeight;
+		if (w > 0 && h > 0) {
+			if (canvas.width !== w) canvas.width = w;
+			if (canvas.height !== h) canvas.height = h;
+			ctx.save();
+			ctx.setTransform(-1, 0, 0, 1, w, 0);
+			ctx.drawImage(video, 0, 0, w, h);
+			ctx.restore();
+		}
+		rafHandle = requestAnimationFrame(draw);
+	};
+	video.play().catch(() => {});
+	rafHandle = requestAnimationFrame(draw);
+	return {
+		stream: new MediaStream([flippedTrack, ...audioTracks]),
+		impl: "canvas",
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			if (rafHandle !== null) cancelAnimationFrame(rafHandle);
+			flippedTrack.stop();
+			video.srcObject = null;
+		}
+	};
+}
+
+//#endregion
+export { createMirroredStream, shouldMirrorTrack };

package/dist/realtime/{diagnostics.d.ts → observability/diagnostics.d.ts}

@@ -1,4 +1,4 @@
-//#region src/realtime/diagnostics.d.ts
+//#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 = {

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

@@ -0,0 +1,109 @@
+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;
+	videoStalled = false;
+	stallStartMs = 0;
+	constructor(options) {
+		this.options = options;
+	}
+	diagnostic(name, data, timestamp = Date.now()) {
+		this.options.logger.debug(name, data);
+		this.options.onDiagnostic?.({
+			name,
+			data
+		});
+		this.addTelemetryDiagnostic(name, data, timestamp);
+	}
+	sessionStarted(sessionId) {
+		if (!this.options.telemetryEnabled) return;
+		if (this.telemetryReporterReady) this.telemetryReporter.stop();
+		const reporter = new TelemetryReporter({
+			apiKey: this.options.apiKey,
+			sessionId,
+			model: this.options.model,
+			integration: this.options.integration,
+			logger: this.options.logger
+		});
+		reporter.start();
+		this.telemetryReporter = reporter;
+		this.telemetryReporterReady = true;
+		for (const diagnostic of this.pendingTelemetryDiagnostics) this.telemetryReporter.addDiagnostic(diagnostic);
+		this.pendingTelemetryDiagnostics.length = 0;
+	}
+	setStatsProvider(source) {
+		if (!source) {
+			this.stopStats();
+			return;
+		}
+		if (source === this.statsCollectorSource) return;
+		this.stopStats();
+		this.statsCollectorSource = source;
+		if (!this.options.telemetryEnabled && !this.options.onStats) return;
+		this.statsCollector = new WebRTCStatsCollector();
+		this.statsCollector.start(source, (stats) => this.handleStats(stats));
+	}
+	stopStats() {
+		this.statsCollector?.stop();
+		this.statsCollector = null;
+		this.statsCollectorSource = null;
+		this.resetStallDetection();
+	}
+	stop() {
+		this.stopStats();
+		this.telemetryReporter.stop();
+		this.telemetryReporter = new NullTelemetryReporter();
+		this.telemetryReporterReady = false;
+		this.pendingTelemetryDiagnostics.length = 0;
+	}
+	handleStats(stats) {
+		this.options.onStats?.(stats);
+		this.telemetryReporter.addStats(stats);
+		this.detectVideoStall(stats);
+	}
+	detectVideoStall(stats) {
+		const fps = stats.video?.framesPerSecond ?? 0;
+		if (!this.videoStalled && stats.video && fps < STALL_FPS_THRESHOLD) {
+			this.videoStalled = true;
+			this.stallStartMs = Date.now();
+			this.diagnostic("videoStall", {
+				stalled: true,
+				durationMs: 0
+			}, this.stallStartMs);
+		} else if (this.videoStalled && fps >= STALL_FPS_THRESHOLD) {
+			const durationMs = Date.now() - this.stallStartMs;
+			this.videoStalled = false;
+			this.diagnostic("videoStall", {
+				stalled: false,
+				durationMs
+			});
+		}
+	}
+	addTelemetryDiagnostic(name, data, timestamp) {
+		if (!this.options.telemetryEnabled) return;
+		const diagnostic = {
+			name,
+			data,
+			timestamp
+		};
+		if (!this.telemetryReporterReady) {
+			this.pendingTelemetryDiagnostics.push(diagnostic);
+			return;
+		}
+		this.telemetryReporter.addDiagnostic(diagnostic);
+	}
+	resetStallDetection() {
+		this.videoStalled = false;
+		this.stallStartMs = 0;
+	}
+};
+
+//#endregion
+export { RealtimeObservability };

package/dist/realtime/{telemetry-reporter.js → observability/telemetry-reporter.js}

@@ -1,7 +1,7 @@
-import { VERSION } from "../version.js";
-import { buildAuthHeaders } from "../shared/request.js";
+import { VERSION } from "../../version.js";
+import { buildAuthHeaders } from "../../shared/request.js";
 
-//#region src/realtime/telemetry-reporter.ts
+//#region src/realtime/observability/telemetry-reporter.ts
 const DEFAULT_REPORT_INTERVAL_MS = 1e4;
 const TELEMETRY_URL = "https://platform.decart.ai/api/v1/telemetry";
 /**