@ziztechnology/dial-library 0.0.4 → 0.0.6

package/dist/index.mjs

@@ -1,5 +1,32 @@
 import { Gunzip } from "fflate";
+//#region src/helper/debugger.ts
+const stringifyDebugData = (data) => {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return JSON.stringify(data, (_key, value) => {
+		if (value instanceof Error) return {
+			name: value.name,
+			message: value.message,
+			stack: value.stack
+		};
+		if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+		if (typeof value === "bigint") return value.toString();
+		if (typeof value === "object" && value !== null) {
+			if (seen.has(value)) return "[Circular]";
+			seen.add(value);
+		}
+		return value;
+	}) ?? String(data);
+};
+const dialSdkDebugWarn = (moduleName, scope, phase, data) => {
+	const message = `[DIAL_SDK_DEBUG - ${moduleName}] ${scope}: ${phase}`;
+	try {
+		if (data === void 0) console.warn(message);
+		else console.warn(message, stringifyDebugData(data));
+	} catch {}
+};
+//#endregion
 //#region src/sensor/check_status.ts
+const DEBUG_MODULE$5 = "check_status.ts";
 const DEFAULT_DRIVING_STATUS_TUNING = Object.freeze({
 	version: "driving-status-v1",
 	maxSampleAgeMs: 1e3,
@@ -36,12 +63,23 @@ const DEFAULT_DRIVING_STATUS_TUNING = Object.freeze({
 	})
 });
 const classifyDrivingSnapshot = (info, tuningOverrides) => {
+	dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingSnapshot", "called", {
+		info,
+		tuningOverrides
+	});
 	const tuning = resolveDrivingStatusTuning(tuningOverrides);
 	const metrics = extractDrivingSnapshotMetrics(info, tuning);
-	return metrics === null ? null : classifyDrivingMetrics(metrics, tuning);
+	const result = metrics === null ? null : classifyDrivingMetrics(metrics, tuning);
+	dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingSnapshot", "returned", {
+		tuning,
+		metrics,
+		result
+	});
+	return result;
 };
 const checkRunningStatus = classifyDrivingSnapshot;
 const resolveDrivingStatusTuning = (overrides = {}) => {
+	dialSdkDebugWarn(DEBUG_MODULE$5, "resolveDrivingStatusTuning", "called", { overrides });
 	const tuning = {
 		...DEFAULT_DRIVING_STATUS_TUNING,
 		...overrides,
@@ -70,19 +108,36 @@ const resolveDrivingStatusTuning = (overrides = {}) => {
 	if (!Number.isFinite(tuning.hysteresisRatio) || tuning.hysteresisRatio <= 0 || tuning.hysteresisRatio >= 1) throw new RangeError("hysteresisRatio must be greater than 0 and less than 1");
 	for (const [status, value] of Object.entries(tuning.confirmationSamples)) if (!Number.isInteger(value) || value < 1) throw new RangeError(`confirmationSamples.${status} must be a positive integer`);
 	for (const [status, value] of Object.entries(tuning.minimumDisplayMs)) if (!Number.isFinite(value) || value < 0) throw new RangeError(`minimumDisplayMs.${status} must be a non-negative finite number`);
+	dialSdkDebugWarn(DEBUG_MODULE$5, "resolveDrivingStatusTuning", "returned", { tuning });
 	return tuning;
 };
 const extractDrivingSnapshotMetrics = (info, tuning = DEFAULT_DRIVING_STATUS_TUNING) => {
-	if (!info || !Number.isFinite(info.capturedAtMs)) return null;
+	dialSdkDebugWarn(DEBUG_MODULE$5, "extractDrivingSnapshotMetrics", "called", {
+		info,
+		tuning
+	});
+	if (!info || !Number.isFinite(info.capturedAtMs)) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "extractDrivingSnapshotMetrics", "returned invalid capture time", { info });
+		return null;
+	}
 	const linearAcceleration = availableFreshVector(info.linearAcceleration, info.capturedAtMs, tuning.maxSampleAgeMs);
 	const gyroscope = availableFreshVector(info.gyroscope, info.capturedAtMs, tuning.maxSampleAgeMs);
-	if (linearAcceleration === null || gyroscope === null) return null;
+	if (linearAcceleration === null || gyroscope === null) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "extractDrivingSnapshotMetrics", "returned unavailable vectors", {
+			linearAcceleration,
+			gyroscope
+		});
+		return null;
+	}
 	const longitudinal = -linearAcceleration.z;
 	const lateral = linearAcceleration.x;
 	const yaw = gyroscope.y;
 	const motionIntensity = info.motionIntensity === void 0 ? vectorMagnitude(linearAcceleration) : availableFreshNumber(info.motionIntensity, info.capturedAtMs, tuning.maxSampleAgeMs);
-	if (motionIntensity === null) return null;
-	return {
+	if (motionIntensity === null) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "extractDrivingSnapshotMetrics", "returned unavailable motion intensity", { motionIntensity: info.motionIntensity });
+		return null;
+	}
+	const result = {
 		capturedAtMs: info.capturedAtMs,
 		longitudinal,
 		lateral,
@@ -90,44 +145,144 @@ const extractDrivingSnapshotMetrics = (info, tuning = DEFAULT_DRIVING_STATUS_TUN
 		motionIntensity,
 		gyroMagnitude: vectorMagnitude(gyroscope)
 	};
+	dialSdkDebugWarn(DEBUG_MODULE$5, "extractDrivingSnapshotMetrics", "returned", { result });
+	return result;
 };
 const classifyDrivingMetrics = (metrics, tuning = DEFAULT_DRIVING_STATUS_TUNING) => {
+	dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "called", {
+		metrics,
+		tuning
+	});
 	const { longitudinal, lateral, yaw, motionIntensity, gyroMagnitude } = metrics;
-	if (longitudinal <= -tuning.rapidLongitudinalThreshold) return "SUDDEN_BRAKING";
-	if (longitudinal >= tuning.rapidLongitudinalThreshold) return "RAPID_ACCELERATION";
-	if (Math.abs(yaw) >= tuning.turnYawThreshold) return yaw > 0 ? "LEFT_TURN" : "RIGHT_TURN";
-	if (Math.abs(lateral) >= tuning.turnLateralThreshold) return lateral < 0 ? "LEFT_TURN" : "RIGHT_TURN";
-	if (longitudinal <= -tuning.longitudinalThreshold) return "BRAKING";
-	if (longitudinal >= tuning.longitudinalThreshold) return "ACCELERATION";
-	if (motionIntensity < tuning.drivingMotionThreshold && gyroMagnitude <= tuning.stoppedGyroThreshold) return "STOPPED";
+	if (longitudinal <= -tuning.rapidLongitudinalThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", { result: "SUDDEN_BRAKING" });
+		return "SUDDEN_BRAKING";
+	}
+	if (longitudinal >= tuning.rapidLongitudinalThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", { result: "RAPID_ACCELERATION" });
+		return "RAPID_ACCELERATION";
+	}
+	if (Math.abs(yaw) >= tuning.turnYawThreshold) {
+		const result = yaw > 0 ? "LEFT_TURN" : "RIGHT_TURN";
+		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", {
+			result,
+			basis: "yaw"
+		});
+		return result;
+	}
+	if (Math.abs(lateral) >= tuning.turnLateralThreshold) {
+		const result = lateral < 0 ? "LEFT_TURN" : "RIGHT_TURN";
+		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", {
+			result,
+			basis: "lateral"
+		});
+		return result;
+	}
+	if (longitudinal <= -tuning.longitudinalThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", { result: "BRAKING" });
+		return "BRAKING";
+	}
+	if (longitudinal >= tuning.longitudinalThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", { result: "ACCELERATION" });
+		return "ACCELERATION";
+	}
+	if (motionIntensity < tuning.drivingMotionThreshold && gyroMagnitude <= tuning.stoppedGyroThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", { result: "STOPPED" });
+		return "STOPPED";
+	}
+	dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", { result: "STEADY_DRIVING" });
 	return "STEADY_DRIVING";
 };
 const availableFreshVector = (metric, capturedAtMs, maxSampleAgeMs) => {
-	if (!metric?.available || !isFresh(metric.sampledAtMs, capturedAtMs, maxSampleAgeMs)) return null;
+	dialSdkDebugWarn(DEBUG_MODULE$5, "availableFreshVector", "called", {
+		metric,
+		capturedAtMs,
+		maxSampleAgeMs
+	});
+	if (!metric?.available || !isFresh(metric.sampledAtMs, capturedAtMs, maxSampleAgeMs)) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "availableFreshVector", "returned", { result: null });
+		return null;
+	}
 	const { x, y, z } = metric.value;
-	return [
+	const result = [
 		x,
 		y,
 		z
 	].every(Number.isFinite) ? metric.value : null;
+	dialSdkDebugWarn(DEBUG_MODULE$5, "availableFreshVector", "returned", { result });
+	return result;
 };
 const availableFreshNumber = (metric, capturedAtMs, maxSampleAgeMs) => {
-	if (!metric?.available || !isFresh(metric.sampledAtMs, capturedAtMs, maxSampleAgeMs)) return null;
-	return Number.isFinite(metric.value) && metric.value >= 0 ? metric.value : null;
+	dialSdkDebugWarn(DEBUG_MODULE$5, "availableFreshNumber", "called", {
+		metric,
+		capturedAtMs,
+		maxSampleAgeMs
+	});
+	if (!metric?.available || !isFresh(metric.sampledAtMs, capturedAtMs, maxSampleAgeMs)) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "availableFreshNumber", "returned", { result: null });
+		return null;
+	}
+	const result = Number.isFinite(metric.value) && metric.value >= 0 ? metric.value : null;
+	dialSdkDebugWarn(DEBUG_MODULE$5, "availableFreshNumber", "returned", { result });
+	return result;
 };
 const isFresh = (sampledAtMs, capturedAtMs, maxSampleAgeMs) => {
-	if (sampledAtMs === null || !Number.isFinite(sampledAtMs)) return false;
+	dialSdkDebugWarn(DEBUG_MODULE$5, "isFresh", "called", {
+		sampledAtMs,
+		capturedAtMs,
+		maxSampleAgeMs
+	});
+	if (sampledAtMs === null || !Number.isFinite(sampledAtMs)) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "isFresh", "returned", { result: false });
+		return false;
+	}
 	const age = capturedAtMs - sampledAtMs;
-	return age >= 0 && age <= maxSampleAgeMs;
+	const result = age >= 0 && age <= maxSampleAgeMs;
+	dialSdkDebugWarn(DEBUG_MODULE$5, "isFresh", "returned", {
+		age,
+		result
+	});
+	return result;
+};
+const vectorMagnitude = ({ x, y, z }) => {
+	const result = Math.hypot(x, y, z);
+	dialSdkDebugWarn(DEBUG_MODULE$5, "vectorMagnitude", "returned", {
+		x,
+		y,
+		z,
+		result
+	});
+	return result;
 };
-const vectorMagnitude = ({ x, y, z }) => Math.hypot(x, y, z);
 const assertPositiveFinite = (name, value) => {
-	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a positive finite number`);
+	dialSdkDebugWarn(DEBUG_MODULE$5, "assertPositiveFinite", "called", {
+		name,
+		value
+	});
+	if (!Number.isFinite(value) || value <= 0) {
+		const error = /* @__PURE__ */ new RangeError(`${name} must be a positive finite number`);
+		dialSdkDebugWarn(DEBUG_MODULE$5, "assertPositiveFinite", "threw", error);
+		throw error;
+	}
+	dialSdkDebugWarn(DEBUG_MODULE$5, "assertPositiveFinite", "returned");
 };
 //#endregion
 //#region src/sensor/unified_info.ts
+const DEBUG_MODULE$4 = "unified_info.ts";
 const unifiedSensorInfo = () => {
-	return window.unifiedSensorInfo();
+	dialSdkDebugWarn(DEBUG_MODULE$4, "unifiedSensorInfo", "called");
+	try {
+		return window.unifiedSensorInfo().then((payload) => {
+			dialSdkDebugWarn(DEBUG_MODULE$4, "unifiedSensorInfo", "resolved", { payload });
+			return payload;
+		}, (error) => {
+			dialSdkDebugWarn(DEBUG_MODULE$4, "unifiedSensorInfo", "rejected", error);
+			throw error;
+		});
+	} catch (error) {
+		dialSdkDebugWarn(DEBUG_MODULE$4, "unifiedSensorInfo", "threw", error);
+		throw error;
+	}
 };
 //#endregion
 //#region src/sensor/constants.ts
@@ -172,6 +327,7 @@ const CAR_RUNNING_STATUS_PRIORITY = {
 };
 //#endregion
 //#region src/sensor/driving_expressions.ts
+const DEBUG_MODULE$3 = "driving_expressions.ts";
 const OFFICIAL_DRIVING_EXPRESSION_FALLBACKS = Object.freeze({
 	STOPPED: Object.freeze({
 		kind: "emoji",
@@ -212,20 +368,32 @@ const OFFICIAL_DRIVING_EXPRESSIONS_CONFIG = Object.freeze({
 });
 var DrivingExpressionsConfigError = class extends Error {
 	constructor(code, message, state) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "DrivingExpressionsConfigError.constructor", "called", {
+			code,
+			message,
+			state
+		});
 		super(message);
 		this.name = "DrivingExpressionsConfigError";
 		this.code = code;
 		this.state = state;
+		dialSdkDebugWarn(DEBUG_MODULE$3, "DrivingExpressionsConfigError.constructor", "created", { error: this });
 	}
 };
 var DrivingExpressionResolutionError = class extends Error {
 	constructor(status) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "DrivingExpressionResolutionError.constructor", "called", { status });
 		super(`No driving expression is configured for ${status}`);
 		this.name = "DrivingExpressionResolutionError";
 		this.status = status;
+		dialSdkDebugWarn(DEBUG_MODULE$3, "DrivingExpressionResolutionError.constructor", "created", { error: this });
 	}
 };
 const parseDrivingExpressionsConfig = (raw, options = {}) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseDrivingExpressionsConfig", "called", {
+		raw,
+		options
+	});
 	const parsed = parseJsonObject(raw);
 	if (parsed.schemaVersion !== 1 || !isRecord$1(parsed.states)) throw new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INVALID_SCHEMA", "drivingExpressions must use schemaVersion 1 and contain a states object");
 	const knownStatuses = new Set(CAR_RUNNING_STATUSES);
@@ -236,15 +404,24 @@ const parseDrivingExpressionsConfig = (raw, options = {}) => {
 		if (!Object.prototype.hasOwnProperty.call(parsed.states, status)) throw new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INCOMPLETE", `drivingExpressions.states is missing ${status}`, status);
 		states[status] = parseDrivingExpressionMedia(parsed.states[status], status, options);
 	}
-	return {
+	const result = {
 		schemaVersion: 1,
 		states
 	};
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseDrivingExpressionsConfig", "returned", { result });
+	return result;
 };
 const tryParseDrivingExpressionsConfig = (raw, options) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "tryParseDrivingExpressionsConfig", "called", {
+		raw,
+		options
+	});
 	try {
-		return parseDrivingExpressionsConfig(raw, options);
-	} catch {
+		const result = parseDrivingExpressionsConfig(raw, options);
+		dialSdkDebugWarn(DEBUG_MODULE$3, "tryParseDrivingExpressionsConfig", "returned", { result });
+		return result;
+	} catch (error) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "tryParseDrivingExpressionsConfig", "returned null after parse error", error);
 		return null;
 	}
 };
@@ -253,39 +430,221 @@ const tryParseDrivingExpressionsConfig = (raw, options) => {
 * It never installs official fallbacks implicitly.
 */
 const readDrivingExpressionsConfig = (raw, options) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "readDrivingExpressionsConfig", "called", {
+		raw,
+		options
+	});
 	const source = raw === void 0 ? readRuntimeDrivingExpressionsValue() : raw;
-	return source === void 0 ? null : tryParseDrivingExpressionsConfig(source, options);
+	const result = source === void 0 ? null : tryParseDrivingExpressionsConfig(source, options);
+	dialSdkDebugWarn(DEBUG_MODULE$3, "readDrivingExpressionsConfig", "returned", {
+		source,
+		result
+	});
+	return result;
+};
+/**
+* Waits for a valid Runtime-injected configuration using bounded polling.
+* It never installs official fallbacks implicitly.
+*/
+const waitForDrivingExpressionsConfig = (options = {}) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig", "called", { options });
+	const timeoutMs = requireNonNegativeFinite("timeoutMs", options.timeoutMs ?? 3e3);
+	const pollIntervalMs = requirePositiveFinite$1("pollIntervalMs", options.pollIntervalMs ?? 100);
+	const { signal } = options;
+	return new Promise((resolve, reject) => {
+		const deadlineMs = Date.now() + timeoutMs;
+		let timer;
+		let settled = false;
+		const cleanup = () => {
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.cleanup", "called", {
+				timer,
+				settled
+			});
+			if (timer !== void 0) {
+				globalThis.clearTimeout(timer);
+				timer = void 0;
+			}
+			signal?.removeEventListener("abort", handleAbort);
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.cleanup", "returned");
+		};
+		const finish = (config) => {
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.finish", "called", {
+				config,
+				settled
+			});
+			if (settled) {
+				dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.finish", "ignored");
+				return;
+			}
+			settled = true;
+			cleanup();
+			resolve(config);
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.finish", "resolved", { config });
+		};
+		const fail = (error) => {
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.fail", "called", {
+				error,
+				settled
+			});
+			if (settled) {
+				dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.fail", "ignored");
+				return;
+			}
+			settled = true;
+			cleanup();
+			reject(error);
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.fail", "rejected", error);
+		};
+		const handleAbort = () => {
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.handleAbort", "called");
+			fail(createAbortError$1());
+		};
+		const read = () => {
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.read", "called");
+			const result = readDrivingExpressionsConfig(void 0, options.parseOptions);
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.read", "returned", { result });
+			return result;
+		};
+		const poll = () => {
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.poll", "called", { settled });
+			if (settled) {
+				dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.poll", "ignored");
+				return;
+			}
+			if (signal?.aborted) {
+				handleAbort();
+				return;
+			}
+			const config = read();
+			if (config !== null) {
+				finish(config);
+				return;
+			}
+			const remainingMs = deadlineMs - Date.now();
+			if (remainingMs <= 0) {
+				finish(null);
+				return;
+			}
+			timer = globalThis.setTimeout(poll, Math.min(pollIntervalMs, remainingMs));
+			dialSdkDebugWarn(DEBUG_MODULE$3, "waitForDrivingExpressionsConfig.poll", "scheduled", {
+				remainingMs,
+				delayMs: Math.min(pollIntervalMs, remainingMs)
+			});
+		};
+		signal?.addEventListener("abort", handleAbort, { once: true });
+		poll();
+	});
 };
 /** Original resolver behavior: missing legacy slots fall back to STEADY_DRIVING. */
-const resolveDrivingExpression = (config, status) => config.states[status] ?? config.states.STEADY_DRIVING;
+const resolveDrivingExpression = (config, status) => {
+	const result = config.states[status] ?? config.states.STEADY_DRIVING;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "resolveDrivingExpression", "returned", {
+		config,
+		status,
+		result
+	});
+	return result;
+};
 /** Strict resolver used by the player; official fallbacks are opt-in. */
 const resolveDrivingExpressionStrict = (config, status, fallbacks) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "resolveDrivingExpressionStrict", "called", {
+		config,
+		status,
+		fallbacks
+	});
 	const configured = config.states[status];
-	if (configured !== void 0) return configured;
+	if (configured !== void 0) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "resolveDrivingExpressionStrict", "returned configured media", { configured });
+		return configured;
+	}
 	const fallback = fallbacks?.[status];
-	if (fallback !== void 0) return fallback;
-	throw new DrivingExpressionResolutionError(status);
+	if (fallback !== void 0) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "resolveDrivingExpressionStrict", "returned fallback media", { fallback });
+		return fallback;
+	}
+	const error = new DrivingExpressionResolutionError(status);
+	dialSdkDebugWarn(DEBUG_MODULE$3, "resolveDrivingExpressionStrict", "threw", error);
+	throw error;
 };
 const isPublicDrivingMediaUrl = (value) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicDrivingMediaUrl", "called", { value });
 	try {
 		const url = new URL(value);
-		if (url.protocol !== "https:" || url.username !== "" || url.password !== "") return false;
-		if (!isPublicHostname(url.hostname)) return false;
-		for (const key of url.searchParams.keys()) if (TEMPORARY_SIGNATURE_QUERY_KEYS.has(key.toLowerCase())) return false;
+		if (url.protocol !== "https:" || url.username !== "" || url.password !== "") {
+			dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicDrivingMediaUrl", "returned", {
+				result: false,
+				reason: "protocol_or_auth"
+			});
+			return false;
+		}
+		if (!isPublicHostname(url.hostname)) {
+			dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicDrivingMediaUrl", "returned", {
+				result: false,
+				reason: "hostname"
+			});
+			return false;
+		}
+		for (const key of url.searchParams.keys()) if (TEMPORARY_SIGNATURE_QUERY_KEYS.has(key.toLowerCase())) {
+			dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicDrivingMediaUrl", "returned", {
+				result: false,
+				reason: "temporary_signature",
+				key
+			});
+			return false;
+		}
+		dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicDrivingMediaUrl", "returned", { result: true });
 		return true;
-	} catch {
+	} catch (error) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicDrivingMediaUrl", "returned after URL parse error", {
+			result: false,
+			error
+		});
 		return false;
 	}
 };
 const isPublicHostname = (rawHostname) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicHostname", "called", { rawHostname });
 	const hostname = rawHostname.toLowerCase().replace(/^\[|\]$/gu, "").replace(/\.+$/gu, "");
-	if (hostname === "") return false;
+	if (hostname === "") {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicHostname", "returned", {
+			result: false,
+			hostname
+		});
+		return false;
+	}
 	const ipv4 = parseIpv4(hostname);
-	if (ipv4 !== null) return !isRestrictedIpv4(ipv4);
+	if (ipv4 !== null) {
+		const result = !isRestrictedIpv4(ipv4);
+		dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicHostname", "returned IPv4 result", {
+			hostname,
+			ipv4,
+			result
+		});
+		return result;
+	}
 	const ipv6 = parseIpv6(hostname);
-	if (ipv6 !== null) return !isRestrictedIpv6(ipv6);
-	if (!hostname.includes(".")) return false;
-	return !INTERNAL_HOST_SUFFIXES.some((suffix) => hostname === suffix || hostname.endsWith(`.${suffix}`));
+	if (ipv6 !== null) {
+		const result = !isRestrictedIpv6(ipv6);
+		dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicHostname", "returned IPv6 result", {
+			hostname,
+			ipv6,
+			result
+		});
+		return result;
+	}
+	if (!hostname.includes(".")) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicHostname", "returned", {
+			hostname,
+			result: false
+		});
+		return false;
+	}
+	const result = !INTERNAL_HOST_SUFFIXES.some((suffix) => hostname === suffix || hostname.endsWith(`.${suffix}`));
+	dialSdkDebugWarn(DEBUG_MODULE$3, "isPublicHostname", "returned DNS result", {
+		hostname,
+		result
+	});
+	return result;
 };
 const INTERNAL_HOST_SUFFIXES = [
 	"corp",
@@ -300,57 +659,108 @@ const INTERNAL_HOST_SUFFIXES = [
 	"private"
 ];
 const parseIpv4 = (hostname) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv4", "called", { hostname });
 	const parts = hostname.split(".");
-	if (parts.length !== 4 || parts.some((part) => !/^\d{1,3}$/u.test(part))) return null;
+	if (parts.length !== 4 || parts.some((part) => !/^\d{1,3}$/u.test(part))) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv4", "returned", { result: null });
+		return null;
+	}
 	const octets = parts.map(Number);
-	if (octets.some((octet) => octet > 255)) return null;
-	return octets;
+	if (octets.some((octet) => octet > 255)) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv4", "returned", {
+			result: null,
+			octets
+		});
+		return null;
+	}
+	const result = octets;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv4", "returned", { result });
+	return result;
+};
+const isRestrictedIpv4 = (value) => {
+	const [a, b, c] = value;
+	const result = a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 && c === 0 || a === 192 && b === 0 && c === 2 || a === 192 && b === 31 && c === 196 || a === 192 && b === 52 && c === 193 || a === 192 && b === 88 && c === 99 || a === 192 && b === 168 || a === 192 && b === 175 && c === 48 || a === 198 && (b === 18 || b === 19) || a === 198 && b === 51 && c === 100 || a === 203 && b === 0 && c === 113 || a >= 224;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "isRestrictedIpv4", "returned", {
+		value,
+		result
+	});
+	return result;
 };
-const isRestrictedIpv4 = ([a, b, c]) => a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 && c === 0 || a === 192 && b === 0 && c === 2 || a === 192 && b === 31 && c === 196 || a === 192 && b === 52 && c === 193 || a === 192 && b === 88 && c === 99 || a === 192 && b === 168 || a === 192 && b === 175 && c === 48 || a === 198 && (b === 18 || b === 19) || a === 198 && b === 51 && c === 100 || a === 203 && b === 0 && c === 113 || a >= 224;
 const parseIpv6 = (hostname) => {
-	if (!hostname.includes(":")) return null;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv6", "called", { hostname });
+	if (!hostname.includes(":")) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv6", "returned", { result: null });
+		return null;
+	}
 	let normalized = hostname;
 	if (normalized.includes(".")) {
 		const lastColon = normalized.lastIndexOf(":");
 		const ipv4 = parseIpv4(normalized.slice(lastColon + 1));
-		if (ipv4 === null) return null;
+		if (ipv4 === null) {
+			dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv6", "returned invalid embedded IPv4", { result: null });
+			return null;
+		}
 		normalized = `${normalized.slice(0, lastColon)}:${(ipv4[0] << 8 | ipv4[1]).toString(16)}:${(ipv4[2] << 8 | ipv4[3]).toString(16)}`;
 	}
 	const halves = normalized.split("::");
-	if (halves.length > 2) return null;
+	if (halves.length > 2) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv6", "returned invalid halves", {
+			result: null,
+			halves
+		});
+		return null;
+	}
 	const left = halves[0] === "" ? [] : halves[0].split(":");
 	const right = halves.length === 1 || halves[1] === "" ? [] : halves[1].split(":");
-	if ([...left, ...right].some((part) => !/^[\da-f]{1,4}$/u.test(part))) return null;
+	if ([...left, ...right].some((part) => !/^[\da-f]{1,4}$/u.test(part))) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv6", "returned invalid group", {
+			result: null,
+			left,
+			right
+		});
+		return null;
+	}
 	const omitted = 8 - left.length - right.length;
-	if (halves.length === 1 && omitted !== 0 || halves.length === 2 && omitted < 1) return null;
+	if (halves.length === 1 && omitted !== 0 || halves.length === 2 && omitted < 1) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv6", "returned invalid omission", {
+			result: null,
+			omitted
+		});
+		return null;
+	}
 	const groups = [
 		...left,
 		...Array.from({ length: omitted }, () => "0"),
 		...right
 	].map((part) => Number.parseInt(part, 16));
-	if (groups.length !== 8) return null;
+	if (groups.length !== 8) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv6", "returned invalid group count", {
+			result: null,
+			groups
+		});
+		return null;
+	}
 	const bytes = /* @__PURE__ */ new Uint8Array(16);
 	groups.forEach((group, index) => {
 		bytes[index * 2] = group >>> 8;
 		bytes[index * 2 + 1] = group & 255;
 	});
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseIpv6", "returned", { result: bytes });
 	return bytes;
 };
 const isRestrictedIpv6 = (bytes) => {
-	const allZeroPrefix = (length) => bytes.subarray(0, length).every((value) => value === 0);
-	if (bytes.every((value) => value === 0)) return true;
-	if (allZeroPrefix(15) && bytes[15] === 1) return true;
-	if (allZeroPrefix(12)) return true;
-	if (allZeroPrefix(10) && bytes[10] === 255 && bytes[11] === 255) return true;
-	if (bytes[0] === 0 && bytes[1] === 100 && bytes[2] === 255 && bytes[3] === 155) return true;
-	if ((bytes[0] & 254) === 252) return true;
-	if (bytes[0] === 254 && (bytes[1] & 192) === 128) return true;
-	if (bytes[0] === 255) return true;
-	if (bytes[0] === 1 && bytes.subarray(1, 8).every((value) => value === 0)) return true;
-	if (bytes[0] === 32 && bytes[1] === 1 && bytes[2] === 13 && bytes[3] === 184) return true;
-	if (bytes[0] === 32 && bytes[1] === 1 && bytes[2] <= 1) return true;
-	if (bytes[0] === 32 && bytes[1] === 2) return true;
-	return bytes[0] === 63 && bytes[1] === 254;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "isRestrictedIpv6", "called", { bytes });
+	const allZeroPrefix = (length) => {
+		const result = bytes.subarray(0, length).every((value) => value === 0);
+		dialSdkDebugWarn(DEBUG_MODULE$3, "isRestrictedIpv6.allZeroPrefix", "returned", {
+			length,
+			result
+		});
+		return result;
+	};
+	const result = bytes.every((value) => value === 0) || allZeroPrefix(15) && bytes[15] === 1 || allZeroPrefix(12) || allZeroPrefix(10) && bytes[10] === 255 && bytes[11] === 255 || bytes[0] === 0 && bytes[1] === 100 && bytes[2] === 255 && bytes[3] === 155 || (bytes[0] & 254) === 252 || bytes[0] === 254 && (bytes[1] & 192) === 128 || bytes[0] === 255 || bytes[0] === 1 && bytes.subarray(1, 8).every((value) => value === 0) || bytes[0] === 32 && bytes[1] === 1 && bytes[2] === 13 && bytes[3] === 184 || bytes[0] === 32 && bytes[1] === 1 && bytes[2] <= 1 || bytes[0] === 32 && bytes[1] === 2 || bytes[0] === 63 && bytes[1] === 254;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "isRestrictedIpv6", "returned", { result });
+	return result;
 };
 const TEMPORARY_SIGNATURE_QUERY_KEYS = /* @__PURE__ */ new Set([
 	"expires",
@@ -386,12 +796,19 @@ const TEMPORARY_SIGNATURE_QUERY_KEYS = /* @__PURE__ */ new Set([
 	"x-oss-signature"
 ]);
 const parseDrivingExpressionMedia = (raw, status, options) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseDrivingExpressionMedia", "called", {
+		raw,
+		status,
+		options
+	});
 	if (typeof raw === "string" && options.allowLegacyImageUrls) {
 		assertPublicUrl(raw, status, "url");
-		return {
+		const result = {
 			kind: "image",
 			url: raw
 		};
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseDrivingExpressionMedia", "returned legacy image", { result });
+		return result;
 	}
 	if (!isRecord$1(raw) || typeof raw.kind !== "string") throw invalidMedia(status, "media must be a structured object with a supported kind");
 	const mediaAssetId = parseMediaAssetId(raw.mediaAssetId, status);
@@ -401,7 +818,7 @@ const parseDrivingExpressionMedia = (raw, status, options) => {
 		"duration"
 	]);
 	switch (raw.kind) {
-		case "emoji":
+		case "emoji": {
 			assertFieldsAbsent(raw, status, [
 				"mediaAssetId",
 				"url",
@@ -410,10 +827,13 @@ const parseDrivingExpressionMedia = (raw, status, options) => {
 				"mimeType"
 			]);
 			if (typeof raw.text !== "string" || !isOneVisibleGrapheme(raw.text)) throw invalidMedia(status, "emoji.text must contain exactly one visible grapheme");
-			return {
+			const result = {
 				kind: "emoji",
 				text: raw.text.trim()
 			};
+			dialSdkDebugWarn(DEBUG_MODULE$3, "parseDrivingExpressionMedia", "returned emoji", { result });
+			return result;
+		}
 		case "image": {
 			assertFieldsAbsent(raw, status, [
 				"text",
@@ -422,25 +842,29 @@ const parseDrivingExpressionMedia = (raw, status, options) => {
 			]);
 			const url = parseRequiredUrl(raw.url, status, "url");
 			const mimeType = parseOptionalString(raw.mimeType, status, "mimeType");
-			return compact({
+			const result = compact({
 				kind: "image",
 				mediaAssetId,
 				url,
 				mimeType
 			});
+			dialSdkDebugWarn(DEBUG_MODULE$3, "parseDrivingExpressionMedia", "returned image", { result });
+			return result;
 		}
 		case "video": {
 			assertFieldsAbsent(raw, status, ["text", "motionUrl"]);
 			const url = parseRequiredUrl(raw.url, status, "url");
 			const coverUrl = parseOptionalUrl(raw.coverUrl, status, "coverUrl");
 			const mimeType = parseOptionalString(raw.mimeType, status, "mimeType");
-			return compact({
+			const result = compact({
 				kind: "video",
 				mediaAssetId,
 				url,
 				coverUrl,
 				mimeType
 			});
+			dialSdkDebugWarn(DEBUG_MODULE$3, "parseDrivingExpressionMedia", "returned video", { result });
+			return result;
 		}
 		case "live_photo": {
 			assertFieldsAbsent(raw, status, [
@@ -450,12 +874,14 @@ const parseDrivingExpressionMedia = (raw, status, options) => {
 			]);
 			const coverUrl = parseRequiredUrl(raw.coverUrl, status, "coverUrl");
 			const motionUrl = parseRequiredUrl(raw.motionUrl, status, "motionUrl");
-			return compact({
+			const result = compact({
 				kind: "live_photo",
 				mediaAssetId,
 				coverUrl,
 				motionUrl
 			});
+			dialSdkDebugWarn(DEBUG_MODULE$3, "parseDrivingExpressionMedia", "returned live photo", { result });
+			return result;
 		}
 		case "tgs": {
 			assertFieldsAbsent(raw, status, [
@@ -465,74 +891,228 @@ const parseDrivingExpressionMedia = (raw, status, options) => {
 			]);
 			const url = parseRequiredUrl(raw.url, status, "url");
 			const coverUrl = parseOptionalUrl(raw.coverUrl, status, "coverUrl");
-			return compact({
+			const result = compact({
 				kind: "tgs",
 				mediaAssetId,
 				url,
 				coverUrl
 			});
+			dialSdkDebugWarn(DEBUG_MODULE$3, "parseDrivingExpressionMedia", "returned TGS", { result });
+			return result;
 		}
 		default: throw invalidMedia(status, `unsupported media kind: ${raw.kind}`);
 	}
 };
 const parseJsonObject = (raw) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseJsonObject", "called", { raw });
 	let value = raw;
 	if (typeof value === "string") try {
 		value = JSON.parse(value);
-	} catch {
-		throw new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INVALID_SCHEMA", "drivingExpressions is not valid JSON");
+	} catch (cause) {
+		const error = new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INVALID_SCHEMA", "drivingExpressions is not valid JSON");
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseJsonObject", "threw", {
+			error,
+			cause
+		});
+		throw error;
 	}
-	if (!isRecord$1(value)) throw new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INVALID_SCHEMA", "drivingExpressions must be a JSON object or JSON object string");
+	if (!isRecord$1(value)) {
+		const error = new DrivingExpressionsConfigError("DRIVING_EXPRESSIONS_INVALID_SCHEMA", "drivingExpressions must be a JSON object or JSON object string");
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseJsonObject", "threw", error);
+		throw error;
+	}
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseJsonObject", "returned", { value });
 	return value;
 };
 const readRuntimeDrivingExpressionsValue = () => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "readRuntimeDrivingExpressionsValue", "called");
 	const runtimeGlobal = globalThis;
-	if (runtimeGlobal.__TOOOONY_DRIVING_EXPRESSIONS__ !== void 0) return runtimeGlobal.__TOOOONY_DRIVING_EXPRESSIONS__;
+	if (runtimeGlobal.__TOOOONY_DRIVING_EXPRESSIONS__ !== void 0) {
+		const result = runtimeGlobal.__TOOOONY_DRIVING_EXPRESSIONS__;
+		dialSdkDebugWarn(DEBUG_MODULE$3, "readRuntimeDrivingExpressionsValue", "returned typed injection", { result });
+		return result;
+	}
 	const faceConfig = runtimeGlobal.__TOOOONY_FACE_CONFIG__;
-	if (!isRecord$1(faceConfig)) return void 0;
-	if (faceConfig.drivingExpressions !== void 0) return faceConfig.drivingExpressions;
-	return isRecord$1(faceConfig.values) ? faceConfig.values.drivingExpressions : void 0;
+	if (!isRecord$1(faceConfig)) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "readRuntimeDrivingExpressionsValue", "returned", { result: void 0 });
+		return;
+	}
+	if (faceConfig.drivingExpressions !== void 0) {
+		const result = faceConfig.drivingExpressions;
+		dialSdkDebugWarn(DEBUG_MODULE$3, "readRuntimeDrivingExpressionsValue", "returned face config", { result });
+		return result;
+	}
+	const result = isRecord$1(faceConfig.values) ? faceConfig.values.drivingExpressions : void 0;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "readRuntimeDrivingExpressionsValue", "returned legacy face config", { result });
+	return result;
 };
 const parseMediaAssetId = (raw, status) => {
-	if (raw === void 0) return void 0;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseMediaAssetId", "called", {
+		raw,
+		status
+	});
+	if (raw === void 0) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseMediaAssetId", "returned", { result: void 0 });
+		return;
+	}
 	if (!Number.isSafeInteger(raw) || raw <= 0) throw invalidMedia(status, "mediaAssetId must be a positive safe integer when present");
-	return raw;
+	const result = raw;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseMediaAssetId", "returned", { result });
+	return result;
 };
 const assertFieldsAbsent = (value, status, fields) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "assertFieldsAbsent", "called", {
+		value,
+		status,
+		fields
+	});
 	const present = fields.find((field) => Object.prototype.hasOwnProperty.call(value, field));
-	if (present !== void 0) throw invalidMedia(status, `${present} is not allowed for this media kind`);
+	if (present !== void 0) {
+		const error = invalidMedia(status, `${present} is not allowed for this media kind`);
+		dialSdkDebugWarn(DEBUG_MODULE$3, "assertFieldsAbsent", "threw", error);
+		throw error;
+	}
+	dialSdkDebugWarn(DEBUG_MODULE$3, "assertFieldsAbsent", "returned");
 };
 const parseRequiredUrl = (raw, status, field) => {
-	if (typeof raw !== "string" || raw.length === 0) throw invalidMedia(status, `${field} is required`);
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseRequiredUrl", "called", {
+		raw,
+		status,
+		field
+	});
+	if (typeof raw !== "string" || raw.length === 0) {
+		const error = invalidMedia(status, `${field} is required`);
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseRequiredUrl", "threw", error);
+		throw error;
+	}
 	assertPublicUrl(raw, status, field);
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseRequiredUrl", "returned", { result: raw });
 	return raw;
 };
 const parseOptionalUrl = (raw, status, field) => {
-	if (raw === void 0) return void 0;
-	return parseRequiredUrl(raw, status, field);
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseOptionalUrl", "called", {
+		raw,
+		status,
+		field
+	});
+	if (raw === void 0) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseOptionalUrl", "returned", { result: void 0 });
+		return;
+	}
+	const result = parseRequiredUrl(raw, status, field);
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseOptionalUrl", "returned", { result });
+	return result;
 };
 const parseOptionalString = (raw, status, field) => {
-	if (raw === void 0) return void 0;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseOptionalString", "called", {
+		raw,
+		status,
+		field
+	});
+	if (raw === void 0) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "parseOptionalString", "returned", { result: void 0 });
+		return;
+	}
 	if (typeof raw !== "string" || raw.trim() === "" || raw.length > 255) throw invalidMedia(status, `${field} must be a non-empty string of at most 255 characters`);
+	dialSdkDebugWarn(DEBUG_MODULE$3, "parseOptionalString", "returned", { result: raw });
 	return raw;
 };
 const assertPublicUrl = (value, status, field) => {
-	if (!isPublicDrivingMediaUrl(value)) throw new DrivingExpressionsConfigError("MEDIA_URL_NOT_PUBLIC_HTTPS", `${status}.${field} must be a long-lived public HTTPS URL`, status);
+	dialSdkDebugWarn(DEBUG_MODULE$3, "assertPublicUrl", "called", {
+		value,
+		status,
+		field
+	});
+	if (!isPublicDrivingMediaUrl(value)) {
+		const error = new DrivingExpressionsConfigError("MEDIA_URL_NOT_PUBLIC_HTTPS", `${status}.${field} must be a long-lived public HTTPS URL`, status);
+		dialSdkDebugWarn(DEBUG_MODULE$3, "assertPublicUrl", "threw", error);
+		throw error;
+	}
+	dialSdkDebugWarn(DEBUG_MODULE$3, "assertPublicUrl", "returned");
 };
 const isOneVisibleGrapheme = (value) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "isOneVisibleGrapheme", "called", { value });
 	const trimmed = value.trim();
-	if (trimmed === "" || trimmed.length > 32) return false;
+	if (trimmed === "" || trimmed.length > 32) {
+		dialSdkDebugWarn(DEBUG_MODULE$3, "isOneVisibleGrapheme", "returned", {
+			result: false,
+			trimmed
+		});
+		return false;
+	}
 	const Segmenter = Intl.Segmenter;
-	return (Segmenter ? Array.from(new Segmenter(void 0, { granularity: "grapheme" }).segment(trimmed)) : Array.from(trimmed)).length === 1;
+	const graphemes = Segmenter ? Array.from(new Segmenter(void 0, { granularity: "grapheme" }).segment(trimmed)) : Array.from(trimmed);
+	const result = graphemes.length === 1;
+	dialSdkDebugWarn(DEBUG_MODULE$3, "isOneVisibleGrapheme", "returned", {
+		graphemes,
+		result
+	});
+	return result;
+};
+const invalidMedia = (status, detail) => {
+	const result = new DrivingExpressionsConfigError("DRIVING_EXPRESSION_INVALID_MEDIA", `Invalid driving expression for ${status}: ${detail}`, status);
+	dialSdkDebugWarn(DEBUG_MODULE$3, "invalidMedia", "returned", {
+		status,
+		detail,
+		result
+	});
+	return result;
 };
-const invalidMedia = (status, detail) => new DrivingExpressionsConfigError("DRIVING_EXPRESSION_INVALID_MEDIA", `Invalid driving expression for ${status}: ${detail}`, status);
 const compact = (value) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "compact", "called", { value });
 	for (const key of Object.keys(value)) if (value[key] === void 0) delete value[key];
+	dialSdkDebugWarn(DEBUG_MODULE$3, "compact", "returned", { result: value });
+	return value;
+};
+const isRecord$1 = (value) => {
+	const result = typeof value === "object" && value !== null && !Array.isArray(value);
+	dialSdkDebugWarn(DEBUG_MODULE$3, "isRecord", "returned", {
+		value,
+		result
+	});
+	return result;
+};
+const requireNonNegativeFinite = (name, value) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "requireNonNegativeFinite", "called", {
+		name,
+		value
+	});
+	if (!Number.isFinite(value) || value < 0) {
+		const error = /* @__PURE__ */ new RangeError(`${name} must be a non-negative finite number`);
+		dialSdkDebugWarn(DEBUG_MODULE$3, "requireNonNegativeFinite", "threw", error);
+		throw error;
+	}
+	dialSdkDebugWarn(DEBUG_MODULE$3, "requireNonNegativeFinite", "returned", { result: value });
+	return value;
+};
+const requirePositiveFinite$1 = (name, value) => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "requirePositiveFinite", "called", {
+		name,
+		value
+	});
+	if (!Number.isFinite(value) || value <= 0) {
+		const error = /* @__PURE__ */ new RangeError(`${name} must be a positive finite number`);
+		dialSdkDebugWarn(DEBUG_MODULE$3, "requirePositiveFinite", "threw", error);
+		throw error;
+	}
+	dialSdkDebugWarn(DEBUG_MODULE$3, "requirePositiveFinite", "returned", { result: value });
 	return value;
 };
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const createAbortError$1 = () => {
+	dialSdkDebugWarn(DEBUG_MODULE$3, "createAbortError", "called");
+	if (typeof DOMException === "function") {
+		const result = new DOMException("The operation was aborted", "AbortError");
+		dialSdkDebugWarn(DEBUG_MODULE$3, "createAbortError", "returned DOMException", { result });
+		return result;
+	}
+	const error = /* @__PURE__ */ new Error("The operation was aborted");
+	error.name = "AbortError";
+	dialSdkDebugWarn(DEBUG_MODULE$3, "createAbortError", "returned Error", { result: error });
+	return error;
+};
 //#endregion
 //#region src/sensor/page_lifecycle.ts
+const DEBUG_MODULE$2 = "page_lifecycle.ts";
 const subscribers = /* @__PURE__ */ new Set();
 let installedWindow = null;
 let installedDocument = null;
@@ -543,6 +1123,7 @@ let hadOwnResumeHook = false;
 let pauseHook = null;
 let resumeHook = null;
 const subscribeDrivingPageLifecycle = (pause, resume) => {
+	dialSdkDebugWarn(DEBUG_MODULE$2, "subscribeDrivingPageLifecycle", "called", { subscriberCount: subscribers.size });
 	const subscriber = {
 		pause,
 		resume
@@ -551,15 +1132,29 @@ const subscribeDrivingPageLifecycle = (pause, resume) => {
 	if (subscribers.size === 1) installLifecycleHooks();
 	if (isDrivingPageHidden()) safeInvoke(pause);
 	let subscribed = true;
+	dialSdkDebugWarn(DEBUG_MODULE$2, "subscribeDrivingPageLifecycle", "subscribed", { subscriberCount: subscribers.size });
 	return () => {
-		if (!subscribed) return;
+		dialSdkDebugWarn(DEBUG_MODULE$2, "subscribeDrivingPageLifecycle.unsubscribe", "called", { subscribed });
+		if (!subscribed) {
+			dialSdkDebugWarn(DEBUG_MODULE$2, "subscribeDrivingPageLifecycle.unsubscribe", "ignored");
+			return;
+		}
 		subscribed = false;
 		subscribers.delete(subscriber);
 		if (subscribers.size === 0) uninstallLifecycleHooks();
+		dialSdkDebugWarn(DEBUG_MODULE$2, "subscribeDrivingPageLifecycle.unsubscribe", "returned", { subscriberCount: subscribers.size });
 	};
 };
-const isDrivingPageHidden = () => typeof document !== "undefined" && document.visibilityState === "hidden";
+const isDrivingPageHidden = () => {
+	const result = typeof document !== "undefined" && document.visibilityState === "hidden";
+	dialSdkDebugWarn(DEBUG_MODULE$2, "isDrivingPageHidden", "returned", {
+		visibilityState: typeof document === "undefined" ? void 0 : document.visibilityState,
+		result
+	});
+	return result;
+};
 const installLifecycleHooks = () => {
+	dialSdkDebugWarn(DEBUG_MODULE$2, "installLifecycleHooks", "called");
 	installedDocument = typeof document === "undefined" ? null : document;
 	installedWindow = typeof window === "undefined" ? null : window;
 	installedDocument?.addEventListener("visibilitychange", handleVisibilityChange);
@@ -569,29 +1164,43 @@ const installLifecycleHooks = () => {
 	installedWindow?.addEventListener("resume", dispatchResume);
 	installedWindow?.addEventListener("toooony-device-sensors-release", dispatchPause);
 	installedWindow?.addEventListener("toooony-device-sensors-resume", dispatchResume);
-	if (!installedWindow) return;
+	if (!installedWindow) {
+		dialSdkDebugWarn(DEBUG_MODULE$2, "installLifecycleHooks", "returned without window");
+		return;
+	}
 	hadOwnPauseHook = Object.prototype.hasOwnProperty.call(installedWindow, "__watchFaceRuntimePause");
 	hadOwnResumeHook = Object.prototype.hasOwnProperty.call(installedWindow, "__watchFaceRuntimeResume");
 	previousPauseHook = installedWindow.__watchFaceRuntimePause;
 	previousResumeHook = installedWindow.__watchFaceRuntimeResume;
 	pauseHook = function(...args) {
+		dialSdkDebugWarn(DEBUG_MODULE$2, "runtimePauseHook", "called", { args });
 		try {
-			return typeof previousPauseHook === "function" ? previousPauseHook.apply(this, args) : void 0;
+			const result = typeof previousPauseHook === "function" ? previousPauseHook.apply(this, args) : void 0;
+			dialSdkDebugWarn(DEBUG_MODULE$2, "runtimePauseHook", "returned", { result });
+			return result;
 		} finally {
 			dispatchPause();
 		}
 	};
 	resumeHook = function(...args) {
+		dialSdkDebugWarn(DEBUG_MODULE$2, "runtimeResumeHook", "called", { args });
 		try {
-			return typeof previousResumeHook === "function" ? previousResumeHook.apply(this, args) : void 0;
+			const result = typeof previousResumeHook === "function" ? previousResumeHook.apply(this, args) : void 0;
+			dialSdkDebugWarn(DEBUG_MODULE$2, "runtimeResumeHook", "returned", { result });
+			return result;
 		} finally {
 			dispatchResume();
 		}
 	};
 	installedWindow.__watchFaceRuntimePause = pauseHook;
 	installedWindow.__watchFaceRuntimeResume = resumeHook;
+	dialSdkDebugWarn(DEBUG_MODULE$2, "installLifecycleHooks", "returned", {
+		hadOwnPauseHook,
+		hadOwnResumeHook
+	});
 };
 const uninstallLifecycleHooks = () => {
+	dialSdkDebugWarn(DEBUG_MODULE$2, "uninstallLifecycleHooks", "called");
 	installedDocument?.removeEventListener("visibilitychange", handleVisibilityChange);
 	installedWindow?.removeEventListener("pagehide", dispatchPause);
 	installedWindow?.removeEventListener("freeze", dispatchPause);
@@ -611,26 +1220,46 @@ const uninstallLifecycleHooks = () => {
 	hadOwnResumeHook = false;
 	pauseHook = null;
 	resumeHook = null;
+	dialSdkDebugWarn(DEBUG_MODULE$2, "uninstallLifecycleHooks", "returned");
 };
 const handleVisibilityChange = () => {
+	dialSdkDebugWarn(DEBUG_MODULE$2, "handleVisibilityChange", "called");
 	if (isDrivingPageHidden()) dispatchPause();
 	else dispatchResume();
+	dialSdkDebugWarn(DEBUG_MODULE$2, "handleVisibilityChange", "returned");
 };
 const dispatchPause = () => {
+	dialSdkDebugWarn(DEBUG_MODULE$2, "dispatchPause", "called", { subscriberCount: subscribers.size });
 	for (const subscriber of [...subscribers]) safeInvoke(subscriber.pause);
+	dialSdkDebugWarn(DEBUG_MODULE$2, "dispatchPause", "returned");
 };
 const dispatchResume = () => {
-	if (isDrivingPageHidden()) return;
+	dialSdkDebugWarn(DEBUG_MODULE$2, "dispatchResume", "called", { subscriberCount: subscribers.size });
+	if (isDrivingPageHidden()) {
+		dialSdkDebugWarn(DEBUG_MODULE$2, "dispatchResume", "ignored while hidden");
+		return;
+	}
 	for (const subscriber of [...subscribers]) safeInvoke(subscriber.resume);
+	dialSdkDebugWarn(DEBUG_MODULE$2, "dispatchResume", "returned");
 };
 const safeInvoke = (callback) => {
+	dialSdkDebugWarn(DEBUG_MODULE$2, "safeInvoke", "called");
 	try {
 		callback();
-	} catch {}
+		dialSdkDebugWarn(DEBUG_MODULE$2, "safeInvoke", "returned");
+	} catch (error) {
+		dialSdkDebugWarn(DEBUG_MODULE$2, "safeInvoke", "callback threw", error);
+	}
 };
 //#endregion
 //#region src/sensor/driving_status_controller.ts
-const createDrivingStatusController = (options = {}) => new DefaultDrivingStatusController(options);
+const DEBUG_MODULE$1 = "driving_status_controller.ts";
+const createDrivingStatusController = (options = {}) => {
+	dialSdkDebugWarn(DEBUG_MODULE$1, "createDrivingStatusController", "called", { options });
+	const result = new DefaultDrivingStatusController(options);
+	dialSdkDebugWarn(DEBUG_MODULE$1, "createDrivingStatusController", "returned", { snapshot: result.getSnapshot() });
+	return result;
+};
 var DefaultDrivingStatusController = class {
 	constructor(options) {
 		this.listeners = /* @__PURE__ */ new Set();
@@ -650,16 +1279,34 @@ var DefaultDrivingStatusController = class {
 		this.pendingRead = null;
 		this.unsubscribePageLifecycle = null;
 		this.handleLifecyclePause = () => {
-			if (!this.requestedRunning || this.lifecycleSuspended) return;
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecyclePause", "called", {
+				requestedRunning: this.requestedRunning,
+				lifecycleSuspended: this.lifecycleSuspended
+			});
+			if (!this.requestedRunning || this.lifecycleSuspended) {
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecyclePause", "ignored");
+				return;
+			}
 			this.lifecycleSuspended = true;
 			this.deactivatePolling();
 			this.resetTransientRecognition();
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecyclePause", "returned");
 		};
 		this.handleLifecycleResume = () => {
-			if (!this.requestedRunning || !this.lifecycleSuspended || this.destroyed || isDrivingPageHidden()) return;
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecycleResume", "called", {
+				requestedRunning: this.requestedRunning,
+				lifecycleSuspended: this.lifecycleSuspended,
+				destroyed: this.destroyed
+			});
+			if (!this.requestedRunning || !this.lifecycleSuspended || this.destroyed || isDrivingPageHidden()) {
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecycleResume", "ignored");
+				return;
+			}
 			this.lifecycleSuspended = false;
 			this.activatePolling();
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecycleResume", "returned");
 		};
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.constructor", "called", { options });
 		this.sensorProvider = options.sensorProvider ?? defaultSensorProvider;
 		this.pollIntervalMs = requirePositiveFinite("pollIntervalMs", options.pollIntervalMs ?? 200);
 		this.unavailableFallbackMs = requirePositiveFinite("unavailableFallbackMs", options.unavailableFallbackMs ?? 3e3);
@@ -672,23 +1319,51 @@ var DefaultDrivingStatusController = class {
 		this.status = initialStatus;
 		this.baseStatus = isBaseStatus(initialStatus) ? initialStatus : "STOPPED";
 		this.statusCommittedAtMs = this.clock.now();
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.constructor", "created", {
+			initialStatus,
+			baseStatus: this.baseStatus,
+			pollIntervalMs: this.pollIntervalMs,
+			unavailableFallbackMs: this.unavailableFallbackMs,
+			tuning: this.tuning,
+			managePageLifecycle: this.managePageLifecycle
+		});
 	}
 	start() {
-		if (this.destroyed || this.requestedRunning) return;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.start", "called", this.getSnapshot());
+		if (this.destroyed || this.requestedRunning) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.start", "ignored", {
+				destroyed: this.destroyed,
+				requestedRunning: this.requestedRunning
+			});
+			return;
+		}
 		this.requestedRunning = true;
 		this.attachLifecycleListeners();
 		if (!this.lifecycleSuspended) this.activatePolling();
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.start", "returned", this.getSnapshot());
 	}
 	stop() {
-		if (this.destroyed || !this.requestedRunning) return;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.stop", "called", this.getSnapshot());
+		if (this.destroyed || !this.requestedRunning) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.stop", "ignored", {
+				destroyed: this.destroyed,
+				requestedRunning: this.requestedRunning
+			});
+			return;
+		}
 		this.requestedRunning = false;
 		this.lifecycleSuspended = false;
 		this.detachLifecycleListeners();
 		this.deactivatePolling();
 		this.resetTransientRecognition();
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.stop", "returned", this.getSnapshot());
 	}
 	destroy() {
-		if (this.destroyed) return;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.destroy", "called", this.getSnapshot());
+		if (this.destroyed) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.destroy", "ignored");
+			return;
+		}
 		if (this.requestedRunning) this.stop();
 		else {
 			this.detachLifecycleListeners();
@@ -698,9 +1373,10 @@ var DefaultDrivingStatusController = class {
 		this.listeners.clear();
 		this.metricWindow.length = 0;
 		this.motionWindow.length = 0;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.destroy", "returned", this.getSnapshot());
 	}
 	getSnapshot() {
-		return {
+		const result = {
 			lifecycle: this.destroyed ? "destroyed" : this.polling ? "running" : "stopped",
 			status: this.status,
 			candidate: this.candidate,
@@ -710,25 +1386,59 @@ var DefaultDrivingStatusController = class {
 			unavailableSinceMs: this.unavailableSinceMs,
 			tuningVersion: this.tuning.version
 		};
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.getSnapshot", "returned", { result });
+		return result;
 	}
 	subscribe(listener) {
-		if (this.destroyed) return noop;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.subscribe", "called", {
+			destroyed: this.destroyed,
+			listenerCount: this.listeners.size
+		});
+		if (this.destroyed) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.subscribe", "returned noop");
+			return noop;
+		}
 		this.listeners.add(listener);
 		let subscribed = true;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.subscribe", "subscribed", { listenerCount: this.listeners.size });
 		return () => {
-			if (!subscribed) return;
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.unsubscribe", "called", { subscribed });
+			if (!subscribed) {
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.unsubscribe", "ignored");
+				return;
+			}
 			subscribed = false;
 			this.listeners.delete(listener);
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.unsubscribe", "returned", { listenerCount: this.listeners.size });
 		};
 	}
 	activatePolling() {
-		if (this.destroyed || this.polling || !this.requestedRunning || this.lifecycleSuspended) return;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.activatePolling", "called", {
+			destroyed: this.destroyed,
+			polling: this.polling,
+			requestedRunning: this.requestedRunning,
+			lifecycleSuspended: this.lifecycleSuspended,
+			generation: this.generation
+		});
+		if (this.destroyed || this.polling || !this.requestedRunning || this.lifecycleSuspended) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.activatePolling", "ignored");
+			return;
+		}
 		this.polling = true;
 		this.generation += 1;
 		this.schedulePoll(0, this.generation);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.activatePolling", "returned", { generation: this.generation });
 	}
 	deactivatePolling() {
-		if (!this.polling && this.timer === void 0 && this.pendingRead === null) return;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.deactivatePolling", "called", {
+			polling: this.polling,
+			timer: this.timer,
+			hasPendingRead: this.pendingRead !== null
+		});
+		if (!this.polling && this.timer === void 0 && this.pendingRead === null) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.deactivatePolling", "ignored");
+			return;
+		}
 		this.polling = false;
 		this.generation += 1;
 		if (this.timer !== void 0) {
@@ -737,34 +1447,77 @@ var DefaultDrivingStatusController = class {
 		}
 		this.pendingRead?.abort();
 		this.pendingRead = null;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.deactivatePolling", "returned", { generation: this.generation });
 	}
 	schedulePoll(delayMs, generation) {
-		if (!this.polling || generation !== this.generation || this.timer !== void 0) return;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.schedulePoll", "called", {
+			delayMs,
+			generation,
+			currentGeneration: this.generation,
+			polling: this.polling,
+			timer: this.timer
+		});
+		if (!this.polling || generation !== this.generation || this.timer !== void 0) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.schedulePoll", "ignored");
+			return;
+		}
 		this.timer = this.clock.setTimeout(() => {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.schedulePoll.callback", "called", { generation });
 			this.timer = void 0;
 			this.poll(generation);
 		}, delayMs);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.schedulePoll", "scheduled", {
+			delayMs,
+			generation,
+			timer: this.timer
+		});
 	}
 	async poll(generation) {
-		if (!this.polling || generation !== this.generation || this.pendingRead !== null) return;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "called", {
+			generation,
+			currentGeneration: this.generation,
+			polling: this.polling,
+			hasPendingRead: this.pendingRead !== null
+		});
+		if (!this.polling || generation !== this.generation || this.pendingRead !== null) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "ignored");
+			return;
+		}
 		const pendingRead = new AbortController();
 		this.pendingRead = pendingRead;
 		try {
 			const payload = await this.sensorProvider(pendingRead.signal);
-			if (!this.polling || generation !== this.generation || pendingRead.signal.aborted) return;
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "provider resolved", { payload });
+			if (!this.polling || generation !== this.generation || pendingRead.signal.aborted) {
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "discarded provider result");
+				return;
+			}
 			const metrics = extractDrivingSnapshotMetrics(payload, this.tuning);
 			const accelerometerSample = extractFreshAccelerometerSample(payload, this.tuning.maxSampleAgeMs);
 			if (metrics === null || accelerometerSample === null) this.processUnavailable("invalid_or_stale_snapshot");
 			else this.processAvailable(metrics, accelerometerSample);
 		} catch (error) {
-			if (!this.polling || generation !== this.generation || pendingRead.signal.aborted || isAbortError$1(error)) return;
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "provider rejected", error);
+			if (!this.polling || generation !== this.generation || pendingRead.signal.aborted || isAbortError$1(error)) {
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "ignored rejection");
+				return;
+			}
 			this.processUnavailable("provider_error");
 		} finally {
 			if (this.pendingRead === pendingRead) this.pendingRead = null;
 			if (this.polling && generation === this.generation) this.schedulePoll(this.pollIntervalMs, generation);
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "completed", {
+				generation,
+				polling: this.polling,
+				currentGeneration: this.generation
+			});
 		}
 	}
 	processAvailable(rawMetrics, accelerometerSample) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processAvailable", "called", {
+			rawMetrics,
+			accelerometerSample
+		});
 		const now = this.clock.now();
 		this.lastAvailableAtMs = now;
 		this.unavailableSinceMs = null;
@@ -781,18 +1534,42 @@ var DefaultDrivingStatusController = class {
 		const motionIntensity = this.recordMotionSample(accelerometerSample, rawMetrics.capturedAtMs);
 		const nextCandidate = classifyControllerCandidate(rawMetrics, smoothedMetrics, motionIntensity, this.status, this.baseStatus, this.tuning);
 		this.processCandidate(nextCandidate, now);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processAvailable", "returned", {
+			rawMetrics,
+			smoothedMetrics,
+			motionIntensity,
+			nextCandidate,
+			snapshot: this.getSnapshot()
+		});
 	}
 	recordMotionSample(sample, capturedAtMs) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.recordMotionSample", "called", {
+			sample,
+			capturedAtMs,
+			motionWindow: this.motionWindow
+		});
 		if (!this.motionWindow.some((existing) => existing.sampledAtMs === sample.sampledAtMs)) {
 			this.motionWindow.push(sample);
 			this.motionWindow.sort((left, right) => left.sampledAtMs - right.sampledAtMs);
 		}
 		const cutoffMs = capturedAtMs - this.tuning.motionWindowMs;
 		while (this.motionWindow[0] && this.motionWindow[0].sampledAtMs <= cutoffMs) this.motionWindow.shift();
-		if (this.motionWindow.length < this.tuning.motionMinimumSamples) return null;
-		return combinedAxisStandardDeviation(this.motionWindow);
+		if (this.motionWindow.length < this.tuning.motionMinimumSamples) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.recordMotionSample", "returned warmup", {
+				result: null,
+				motionWindow: this.motionWindow
+			});
+			return null;
+		}
+		const result = combinedAxisStandardDeviation(this.motionWindow);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.recordMotionSample", "returned", {
+			result,
+			motionWindow: this.motionWindow
+		});
+		return result;
 	}
 	processUnavailable(category) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processUnavailable", "called", { category });
 		const now = this.clock.now();
 		if (this.unavailableSinceMs === null) this.unavailableSinceMs = now;
 		const unavailableForMs = Math.max(0, now - this.unavailableSinceMs);
@@ -806,7 +1583,13 @@ var DefaultDrivingStatusController = class {
 			category,
 			tuningVersion: this.tuning.version
 		});
-		if (unavailableForMs < this.unavailableFallbackMs || this.fallbackApplied) return;
+		if (unavailableForMs < this.unavailableFallbackMs || this.fallbackApplied) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processUnavailable", "returned while holding", {
+				unavailableForMs,
+				fallbackApplied: this.fallbackApplied
+			});
+			return;
+		}
 		this.fallbackApplied = true;
 		this.emitDiagnostic({
 			type: "fallback_to_stopped",
@@ -815,10 +1598,22 @@ var DefaultDrivingStatusController = class {
 			tuningVersion: this.tuning.version
 		});
 		this.commit("STOPPED", now, "unavailable_fallback", true);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processUnavailable", "returned after fallback", {
+			unavailableForMs,
+			snapshot: this.getSnapshot()
+		});
 	}
 	processCandidate(nextCandidate, now) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processCandidate", "called", {
+			nextCandidate,
+			now,
+			currentStatus: this.status,
+			candidate: this.candidate,
+			candidateConfirmationCount: this.candidateConfirmationCount
+		});
 		if (nextCandidate === this.status) {
 			this.setCandidate(null, now);
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processCandidate", "returned current status");
 			return;
 		}
 		if (nextCandidate !== this.candidate) {
@@ -826,7 +1621,14 @@ var DefaultDrivingStatusController = class {
 			this.candidateConfirmationCount = 1;
 			this.heldCandidate = null;
 		} else this.candidateConfirmationCount += 1;
-		if (this.candidateConfirmationCount < this.tuning.confirmationSamples[nextCandidate]) return;
+		if (this.candidateConfirmationCount < this.tuning.confirmationSamples[nextCandidate]) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processCandidate", "awaiting confirmation", {
+				nextCandidate,
+				candidateConfirmationCount: this.candidateConfirmationCount,
+				required: this.tuning.confirmationSamples[nextCandidate]
+			});
+			return;
+		}
 		const elapsedMs = Math.max(0, now - this.statusCommittedAtMs);
 		const remainingMs = Math.max(0, this.tuning.minimumDisplayMs[this.status] - elapsedMs);
 		const canPreempt = CAR_RUNNING_STATUS_PRIORITY[nextCandidate] > CAR_RUNNING_STATUS_PRIORITY[this.status];
@@ -842,13 +1644,31 @@ var DefaultDrivingStatusController = class {
 					tuningVersion: this.tuning.version
 				});
 			}
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processCandidate", "held by minimum duration", {
+				nextCandidate,
+				remainingMs
+			});
 			return;
 		}
 		this.commit(nextCandidate, now, "candidate_confirmed");
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processCandidate", "returned after commit", { snapshot: this.getSnapshot() });
 	}
 	commit(nextStatus, now, reason, force = false) {
-		if (!force && nextStatus === this.status) return;
-		if (nextStatus === this.status) return;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.commit", "called", {
+			nextStatus,
+			now,
+			reason,
+			force,
+			currentStatus: this.status
+		});
+		if (!force && nextStatus === this.status) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.commit", "ignored unchanged status");
+			return;
+		}
+		if (nextStatus === this.status) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.commit", "ignored forced unchanged status");
+			return;
+		}
 		const previousStatus = this.status;
 		this.status = nextStatus;
 		if (isBaseStatus(nextStatus)) this.baseStatus = nextStatus;
@@ -871,10 +1691,21 @@ var DefaultDrivingStatusController = class {
 			reason,
 			tuningVersion: this.tuning.version
 		});
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.commit", "returned", {
+			event,
+			listenerCount: this.listeners.size,
+			snapshot: this.getSnapshot()
+		});
 	}
 	setCandidate(candidate, now) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.setCandidate", "called", {
+			candidate,
+			now,
+			currentCandidate: this.candidate
+		});
 		if (candidate === this.candidate) {
 			if (candidate === null) this.candidateConfirmationCount = 0;
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.setCandidate", "returned unchanged", { candidateConfirmationCount: this.candidateConfirmationCount });
 			return;
 		}
 		const previousCandidate = this.candidate;
@@ -888,8 +1719,17 @@ var DefaultDrivingStatusController = class {
 			previousCandidate,
 			tuningVersion: this.tuning.version
 		});
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.setCandidate", "returned", {
+			candidate,
+			previousCandidate
+		});
 	}
 	resetTransientRecognition() {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.resetTransientRecognition", "called", {
+			metricWindow: this.metricWindow,
+			motionWindow: this.motionWindow,
+			candidate: this.candidate
+		});
 		this.metricWindow.length = 0;
 		this.motionWindow.length = 0;
 		this.candidate = null;
@@ -897,54 +1737,144 @@ var DefaultDrivingStatusController = class {
 		this.unavailableSinceMs = null;
 		this.fallbackApplied = false;
 		this.heldCandidate = null;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.resetTransientRecognition", "returned");
 	}
 	emitDiagnostic(event) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.emitDiagnostic", "called", {
+			event,
+			hasListener: this.onDiagnostic !== void 0
+		});
 		if (this.onDiagnostic) safeCall(this.onDiagnostic, event);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.emitDiagnostic", "returned", { event });
 	}
 	attachLifecycleListeners() {
-		if (!this.managePageLifecycle || this.unsubscribePageLifecycle !== null) return;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.attachLifecycleListeners", "called", {
+			managePageLifecycle: this.managePageLifecycle,
+			attached: this.unsubscribePageLifecycle !== null
+		});
+		if (!this.managePageLifecycle || this.unsubscribePageLifecycle !== null) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.attachLifecycleListeners", "ignored");
+			return;
+		}
 		this.unsubscribePageLifecycle = subscribeDrivingPageLifecycle(this.handleLifecyclePause, this.handleLifecycleResume);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.attachLifecycleListeners", "returned");
 	}
 	detachLifecycleListeners() {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.detachLifecycleListeners", "called", { attached: this.unsubscribePageLifecycle !== null });
 		this.unsubscribePageLifecycle?.();
 		this.unsubscribePageLifecycle = null;
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.detachLifecycleListeners", "returned");
 	}
 };
 const classifyControllerCandidate = (raw, smoothed, motionIntensity, current, baseStatus, tuning) => {
+	dialSdkDebugWarn(DEBUG_MODULE$1, "classifyControllerCandidate", "called", {
+		raw,
+		smoothed,
+		motionIntensity,
+		current,
+		baseStatus,
+		tuning
+	});
 	const entry = classifyEntryCandidate(raw, smoothed, motionIntensity, baseStatus, tuning);
-	if (!retainsCurrentStatus(raw, smoothed, motionIntensity, current, tuning)) return entry;
-	if (entry === current) return current;
-	if (CAR_RUNNING_STATUS_PRIORITY[entry] > CAR_RUNNING_STATUS_PRIORITY[current]) return entry;
-	if (isOppositeTurn(entry, current)) return entry;
-	if ((entry === "STOPPED" || entry === "STEADY_DRIVING") && (current === "STOPPED" || current === "STEADY_DRIVING")) return entry;
-	return current;
+	const retained = retainsCurrentStatus(raw, smoothed, motionIntensity, current, tuning);
+	const result = !retained || CAR_RUNNING_STATUS_PRIORITY[entry] > CAR_RUNNING_STATUS_PRIORITY[current] || isOppositeTurn(entry, current) || (entry === "STOPPED" || entry === "STEADY_DRIVING") && (current === "STOPPED" || current === "STEADY_DRIVING") ? entry : current;
+	dialSdkDebugWarn(DEBUG_MODULE$1, "classifyControllerCandidate", "returned", {
+		entry,
+		retained,
+		result
+	});
+	return result;
 };
 const classifyEntryCandidate = (raw, smoothed, motionIntensity, baseStatus, tuning) => {
-	if (raw.longitudinal <= -tuning.rapidLongitudinalThreshold) return "SUDDEN_BRAKING";
-	if (raw.longitudinal >= tuning.rapidLongitudinalThreshold) return "RAPID_ACCELERATION";
-	if (Math.abs(smoothed.yaw) >= tuning.turnYawThreshold) return smoothed.yaw > 0 ? "LEFT_TURN" : "RIGHT_TURN";
-	if (Math.abs(smoothed.lateral) >= tuning.turnLateralThreshold) return smoothed.lateral < 0 ? "LEFT_TURN" : "RIGHT_TURN";
-	if (smoothed.longitudinal <= -tuning.longitudinalThreshold) return "BRAKING";
-	if (smoothed.longitudinal >= tuning.longitudinalThreshold) return "ACCELERATION";
-	if (motionIntensity === null) return baseStatus;
-	if (motionIntensity > tuning.drivingMotionThreshold || smoothed.gyroMagnitude > tuning.stoppedGyroThreshold) return "STEADY_DRIVING";
-	if (motionIntensity < tuning.stoppedMotionThreshold) return "STOPPED";
+	dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "called", {
+		raw,
+		smoothed,
+		motionIntensity,
+		baseStatus,
+		tuning
+	});
+	if (raw.longitudinal <= -tuning.rapidLongitudinalThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "returned", { result: "SUDDEN_BRAKING" });
+		return "SUDDEN_BRAKING";
+	}
+	if (raw.longitudinal >= tuning.rapidLongitudinalThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "returned", { result: "RAPID_ACCELERATION" });
+		return "RAPID_ACCELERATION";
+	}
+	if (Math.abs(smoothed.yaw) >= tuning.turnYawThreshold) {
+		const result = smoothed.yaw > 0 ? "LEFT_TURN" : "RIGHT_TURN";
+		dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "returned", { result });
+		return result;
+	}
+	if (Math.abs(smoothed.lateral) >= tuning.turnLateralThreshold) {
+		const result = smoothed.lateral < 0 ? "LEFT_TURN" : "RIGHT_TURN";
+		dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "returned", { result });
+		return result;
+	}
+	if (smoothed.longitudinal <= -tuning.longitudinalThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "returned", { result: "BRAKING" });
+		return "BRAKING";
+	}
+	if (smoothed.longitudinal >= tuning.longitudinalThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "returned", { result: "ACCELERATION" });
+		return "ACCELERATION";
+	}
+	if (motionIntensity === null) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "returned base status", { result: baseStatus });
+		return baseStatus;
+	}
+	if (motionIntensity > tuning.drivingMotionThreshold || smoothed.gyroMagnitude > tuning.stoppedGyroThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "returned", { result: "STEADY_DRIVING" });
+		return "STEADY_DRIVING";
+	}
+	if (motionIntensity < tuning.stoppedMotionThreshold) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "returned", { result: "STOPPED" });
+		return "STOPPED";
+	}
+	dialSdkDebugWarn(DEBUG_MODULE$1, "classifyEntryCandidate", "returned base status", { result: baseStatus });
 	return baseStatus;
 };
 const retainsCurrentStatus = (raw, smoothed, motionIntensity, current, tuning) => {
+	dialSdkDebugWarn(DEBUG_MODULE$1, "retainsCurrentStatus", "called", {
+		raw,
+		smoothed,
+		motionIntensity,
+		current,
+		tuning
+	});
 	const ratio = tuning.hysteresisRatio;
+	let result;
 	switch (current) {
-		case "SUDDEN_BRAKING": return raw.longitudinal <= -tuning.rapidLongitudinalThreshold * ratio;
-		case "RAPID_ACCELERATION": return raw.longitudinal >= tuning.rapidLongitudinalThreshold * ratio;
-		case "LEFT_TURN": return smoothed.yaw >= tuning.turnYawThreshold * ratio || smoothed.lateral <= -tuning.turnLateralThreshold * ratio;
-		case "RIGHT_TURN": return smoothed.yaw <= -tuning.turnYawThreshold * ratio || smoothed.lateral >= tuning.turnLateralThreshold * ratio;
-		case "BRAKING": return smoothed.longitudinal <= -tuning.longitudinalThreshold * ratio;
-		case "ACCELERATION": return smoothed.longitudinal >= tuning.longitudinalThreshold * ratio;
-		case "STOPPED": return (motionIntensity === null || motionIntensity <= tuning.drivingMotionThreshold) && smoothed.gyroMagnitude <= tuning.stoppedGyroThreshold;
-		case "STEADY_DRIVING": return motionIntensity === null || motionIntensity >= tuning.stoppedMotionThreshold || smoothed.gyroMagnitude > tuning.stoppedGyroThreshold;
+		case "SUDDEN_BRAKING":
+			result = raw.longitudinal <= -tuning.rapidLongitudinalThreshold * ratio;
+			break;
+		case "RAPID_ACCELERATION":
+			result = raw.longitudinal >= tuning.rapidLongitudinalThreshold * ratio;
+			break;
+		case "LEFT_TURN":
+			result = smoothed.yaw >= tuning.turnYawThreshold * ratio || smoothed.lateral <= -tuning.turnLateralThreshold * ratio;
+			break;
+		case "RIGHT_TURN":
+			result = smoothed.yaw <= -tuning.turnYawThreshold * ratio || smoothed.lateral >= tuning.turnLateralThreshold * ratio;
+			break;
+		case "BRAKING":
+			result = smoothed.longitudinal <= -tuning.longitudinalThreshold * ratio;
+			break;
+		case "ACCELERATION":
+			result = smoothed.longitudinal >= tuning.longitudinalThreshold * ratio;
+			break;
+		case "STOPPED":
+			result = (motionIntensity === null || motionIntensity <= tuning.drivingMotionThreshold) && smoothed.gyroMagnitude <= tuning.stoppedGyroThreshold;
+			break;
+		case "STEADY_DRIVING":
+			result = motionIntensity === null || motionIntensity >= tuning.stoppedMotionThreshold || smoothed.gyroMagnitude > tuning.stoppedGyroThreshold;
+			break;
 	}
+	dialSdkDebugWarn(DEBUG_MODULE$1, "retainsCurrentStatus", "returned", { result });
+	return result;
 };
 const averageMetrics = (metrics) => {
+	dialSdkDebugWarn(DEBUG_MODULE$1, "averageMetrics", "called", { metrics });
 	const result = {
 		capturedAtMs: metrics[metrics.length - 1]?.capturedAtMs ?? 0,
 		longitudinal: 0,
@@ -966,25 +1896,45 @@ const averageMetrics = (metrics) => {
 	result.yaw /= count;
 	result.motionIntensity /= count;
 	result.gyroMagnitude /= count;
+	dialSdkDebugWarn(DEBUG_MODULE$1, "averageMetrics", "returned", { result });
 	return result;
 };
 const extractFreshAccelerometerSample = (info, maxSampleAgeMs) => {
+	dialSdkDebugWarn(DEBUG_MODULE$1, "extractFreshAccelerometerSample", "called", {
+		info,
+		maxSampleAgeMs
+	});
 	const metric = info?.accelerometer;
-	if (!metric?.available || !Number.isFinite(info.capturedAtMs) || !Number.isFinite(metric.sampledAtMs)) return null;
+	if (!metric?.available || !Number.isFinite(info.capturedAtMs) || !Number.isFinite(metric.sampledAtMs)) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "extractFreshAccelerometerSample", "returned", { result: null });
+		return null;
+	}
 	const ageMs = info.capturedAtMs - metric.sampledAtMs;
-	if (ageMs < 0 || ageMs > maxSampleAgeMs) return null;
+	if (ageMs < 0 || ageMs > maxSampleAgeMs) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "extractFreshAccelerometerSample", "returned stale sample", {
+			result: null,
+			ageMs
+		});
+		return null;
+	}
 	const { x, y, z } = metric.value;
 	if (![
 		x,
 		y,
 		z
-	].every(Number.isFinite)) return null;
-	return {
+	].every(Number.isFinite)) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "extractFreshAccelerometerSample", "returned invalid vector", { result: null });
+		return null;
+	}
+	const result = {
 		sampledAtMs: metric.sampledAtMs,
 		value: metric.value
 	};
+	dialSdkDebugWarn(DEBUG_MODULE$1, "extractFreshAccelerometerSample", "returned", { result });
+	return result;
 };
 const combinedAxisStandardDeviation = (samples) => {
+	dialSdkDebugWarn(DEBUG_MODULE$1, "combinedAxisStandardDeviation", "called", { samples });
 	const count = samples.length;
 	let meanX = 0;
 	let meanY = 0;
@@ -1005,34 +1955,117 @@ const combinedAxisStandardDeviation = (samples) => {
 		varianceY += (sample.value.y - meanY) ** 2;
 		varianceZ += (sample.value.z - meanZ) ** 2;
 	}
-	return Math.sqrt((varianceX + varianceY + varianceZ) / count);
+	const result = Math.sqrt((varianceX + varianceY + varianceZ) / count);
+	dialSdkDebugWarn(DEBUG_MODULE$1, "combinedAxisStandardDeviation", "returned", {
+		meanX,
+		meanY,
+		meanZ,
+		varianceX,
+		varianceY,
+		varianceZ,
+		result
+	});
+	return result;
 };
 const defaultSensorProvider = () => {
+	dialSdkDebugWarn(DEBUG_MODULE$1, "defaultSensorProvider", "called");
 	const runtimeGlobal = globalThis;
-	if (typeof runtimeGlobal.unifiedSensorInfo !== "function") return Promise.reject(/* @__PURE__ */ new Error("window.unifiedSensorInfo is unavailable"));
-	return runtimeGlobal.unifiedSensorInfo();
+	if (typeof runtimeGlobal.unifiedSensorInfo !== "function") {
+		const error = /* @__PURE__ */ new Error("window.unifiedSensorInfo is unavailable");
+		dialSdkDebugWarn(DEBUG_MODULE$1, "defaultSensorProvider", "rejected", error);
+		return Promise.reject(error);
+	}
+	try {
+		const result = runtimeGlobal.unifiedSensorInfo();
+		result.then((payload) => dialSdkDebugWarn(DEBUG_MODULE$1, "defaultSensorProvider", "resolved", { payload }), (error) => dialSdkDebugWarn(DEBUG_MODULE$1, "defaultSensorProvider", "rejected", error));
+		return result;
+	} catch (error) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "defaultSensorProvider", "threw", error);
+		throw error;
+	}
 };
 const systemClock = {
-	now: () => Date.now(),
-	setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
-	clearTimeout: (handle) => globalThis.clearTimeout(handle)
+	now: () => {
+		const result = Date.now();
+		dialSdkDebugWarn(DEBUG_MODULE$1, "systemClock.now", "returned", { result });
+		return result;
+	},
+	setTimeout: (callback, delayMs) => {
+		const result = globalThis.setTimeout(callback, delayMs);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "systemClock.setTimeout", "returned", {
+			delayMs,
+			result
+		});
+		return result;
+	},
+	clearTimeout: (handle) => {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "systemClock.clearTimeout", "called", { handle });
+		globalThis.clearTimeout(handle);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "systemClock.clearTimeout", "returned");
+	}
+};
+const isOppositeTurn = (candidate, current) => {
+	const result = candidate === "LEFT_TURN" && current === "RIGHT_TURN" || candidate === "RIGHT_TURN" && current === "LEFT_TURN";
+	dialSdkDebugWarn(DEBUG_MODULE$1, "isOppositeTurn", "returned", {
+		candidate,
+		current,
+		result
+	});
+	return result;
+};
+const isBaseStatus = (status) => {
+	const result = status === "STOPPED" || status === "STEADY_DRIVING";
+	dialSdkDebugWarn(DEBUG_MODULE$1, "isBaseStatus", "returned", {
+		status,
+		result
+	});
+	return result;
+};
+const isAbortError$1 = (error) => {
+	const result = error instanceof Error && error.name === "AbortError";
+	dialSdkDebugWarn(DEBUG_MODULE$1, "isAbortError", "returned", {
+		error,
+		result
+	});
+	return result;
 };
-const isOppositeTurn = (candidate, current) => candidate === "LEFT_TURN" && current === "RIGHT_TURN" || candidate === "RIGHT_TURN" && current === "LEFT_TURN";
-const isBaseStatus = (status) => status === "STOPPED" || status === "STEADY_DRIVING";
-const isAbortError$1 = (error) => error instanceof Error && error.name === "AbortError";
 const requirePositiveFinite = (name, value) => {
-	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a positive finite number`);
+	dialSdkDebugWarn(DEBUG_MODULE$1, "requirePositiveFinite", "called", {
+		name,
+		value
+	});
+	if (!Number.isFinite(value) || value <= 0) {
+		const error = /* @__PURE__ */ new RangeError(`${name} must be a positive finite number`);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "requirePositiveFinite", "threw", error);
+		throw error;
+	}
+	dialSdkDebugWarn(DEBUG_MODULE$1, "requirePositiveFinite", "returned", { result: value });
 	return value;
 };
 const safeCall = (callback, value) => {
+	dialSdkDebugWarn(DEBUG_MODULE$1, "safeCall", "called", { value });
 	try {
 		callback(value);
-	} catch {}
+		dialSdkDebugWarn(DEBUG_MODULE$1, "safeCall", "returned");
+	} catch (error) {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "safeCall", "callback threw", error);
+	}
+};
+const noop = () => {
+	dialSdkDebugWarn(DEBUG_MODULE$1, "noop", "called and returned");
 };
-const noop = () => {};
 //#endregion
 //#region src/sensor/driving_expression_player.ts
-const createDrivingExpressionPlayer = (container, options) => new DefaultDrivingExpressionPlayer(container, options);
+const DEBUG_MODULE = "driving_expression_player.ts";
+const createDrivingExpressionPlayer = (container, options) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "createDrivingExpressionPlayer", "called", {
+		container,
+		options
+	});
+	const result = new DefaultDrivingExpressionPlayer(container, options);
+	dialSdkDebugWarn(DEBUG_MODULE, "createDrivingExpressionPlayer", "returned", { snapshot: result.getSnapshot() });
+	return result;
+};
 var DefaultDrivingExpressionPlayer = class {
 	constructor(container, options) {
 		this.status = null;
@@ -1054,16 +2087,34 @@ var DefaultDrivingExpressionPlayer = class {
 		this.activeTgs = null;
 		this.unsubscribePageLifecycle = null;
 		this.handleLifecyclePause = () => {
-			if (this.destroyed || this.lifecycleSuspended) return;
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleLifecyclePause", "called");
+			if (this.destroyed || this.lifecycleSuspended) {
+				dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleLifecyclePause", "ignored");
+				return;
+			}
 			this.lifecycleSuspended = true;
 			this.updatePauseState();
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleLifecyclePause", "returned");
 		};
 		this.handleLifecycleResume = () => {
-			if (this.destroyed || !this.lifecycleSuspended) return;
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleLifecycleResume", "called");
+			if (this.destroyed || !this.lifecycleSuspended) {
+				dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleLifecycleResume", "ignored");
+				return;
+			}
 			this.lifecycleSuspended = false;
 			this.updatePauseState();
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleLifecycleResume", "returned");
 		};
-		if (!container || typeof container.replaceChildren !== "function") throw new TypeError("container must be an HTMLElement-like DOM container");
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.constructor", "called", {
+			container,
+			options
+		});
+		if (!container || typeof container.replaceChildren !== "function") {
+			const error = /* @__PURE__ */ new TypeError("container must be an HTMLElement-like DOM container");
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.constructor", "threw", error);
+			throw error;
+		}
 		this.container = container;
 		this.document = container.ownerDocument;
 		this.config = options.config;
@@ -1078,9 +2129,25 @@ var DefaultDrivingExpressionPlayer = class {
 		this.maxTgsJsonBytes = positiveFinite("maxTgsJsonBytes", options.maxTgsJsonBytes ?? 8 * 1024 * 1024);
 		this.maxTgsLayers = positiveFinite("maxTgsLayers", options.maxTgsLayers ?? 500);
 		if (options.managePageLifecycle ?? true) this.unsubscribePageLifecycle = subscribeDrivingPageLifecycle(this.handleLifecyclePause, this.handleLifecycleResume);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.constructor", "created", {
+			loadTimeoutMs: this.loadTimeoutMs,
+			retryBackoffMs: this.retryBackoffMs,
+			fit: this.fit,
+			maxTgsCompressedBytes: this.maxTgsCompressedBytes,
+			maxTgsJsonBytes: this.maxTgsJsonBytes,
+			maxTgsLayers: this.maxTgsLayers,
+			managesPageLifecycle: this.unsubscribePageLifecycle !== null
+		});
 	}
 	async show(status) {
-		if (this.destroyed || status === this.status && this.phase !== "idle") return;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.show", "called", {
+			status,
+			snapshot: this.getSnapshot()
+		});
+		if (this.destroyed || status === this.status && this.phase !== "idle") {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.show", "ignored");
+			return;
+		}
 		this.status = status;
 		const operation = this.beginOperation();
 		const configured = this.config.states[status];
@@ -1088,36 +2155,59 @@ var DefaultDrivingExpressionPlayer = class {
 			const fallback = this.fallbacks?.[status];
 			if (fallback === void 0) {
 				this.handleFailure(status, null, new DrivingExpressionResolutionError(status), "invalid_config", operation, false);
+				dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.show", "returned after missing config");
 				return;
 			}
 			this.desiredMedia = fallback;
 			if (this.paused) {
 				this.phase = "idle";
+				dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.show", "deferred fallback while paused");
 				return;
 			}
 			this.renderFallback(status, fallback);
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.show", "returned fallback", { snapshot: this.getSnapshot() });
 			return;
 		}
 		const media = normalizeMedia(configured);
 		this.desiredMedia = media;
 		if (this.paused) {
 			this.phase = "idle";
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.show", "deferred media while paused", { media });
 			return;
 		}
 		await this.load(status, media, operation);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.show", "resolved", {
+			status,
+			media,
+			snapshot: this.getSnapshot()
+		});
 	}
 	pause() {
-		if (this.destroyed || this.userPaused) return;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.pause", "called", this.getSnapshot());
+		if (this.destroyed || this.userPaused) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.pause", "ignored");
+			return;
+		}
 		this.userPaused = true;
 		this.updatePauseState();
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.pause", "returned", this.getSnapshot());
 	}
 	resume() {
-		if (this.destroyed || !this.userPaused) return;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.resume", "called", this.getSnapshot());
+		if (this.destroyed || !this.userPaused) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.resume", "ignored");
+			return;
+		}
 		this.userPaused = false;
 		this.updatePauseState();
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.resume", "returned", this.getSnapshot());
 	}
 	destroy() {
-		if (this.destroyed) return;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.destroy", "called", this.getSnapshot());
+		if (this.destroyed) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.destroy", "ignored");
+			return;
+		}
 		this.destroyed = true;
 		this.unsubscribePageLifecycle?.();
 		this.unsubscribePageLifecycle = null;
@@ -1131,17 +2221,24 @@ var DefaultDrivingExpressionPlayer = class {
 		this.phase = "idle";
 		this.mediaKind = null;
 		this.errorCategory = null;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.destroy", "returned", this.getSnapshot());
 	}
 	getSnapshot() {
-		return {
+		const result = {
 			lifecycle: this.destroyed ? "destroyed" : this.paused ? "paused" : "active",
 			status: this.status,
 			phase: this.phase,
 			mediaKind: this.mediaKind,
 			errorCategory: this.errorCategory
 		};
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.getSnapshot", "returned", { result });
+		return result;
 	}
 	beginOperation() {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.beginOperation", "called", {
+			operation: this.operation,
+			snapshot: this.getSnapshot()
+		});
 		this.operation += 1;
 		this.failedOperation = null;
 		this.cancelPendingWork();
@@ -1150,17 +2247,28 @@ var DefaultDrivingExpressionPlayer = class {
 		this.phase = "loading";
 		this.mediaKind = null;
 		this.errorCategory = null;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.beginOperation", "returned", { operation: this.operation });
 		return this.operation;
 	}
 	updatePauseState() {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.updatePauseState", "called", {
+			userPaused: this.userPaused,
+			lifecycleSuspended: this.lifecycleSuspended,
+			paused: this.paused,
+			snapshot: this.getSnapshot()
+		});
 		const shouldPause = this.userPaused || this.lifecycleSuspended;
-		if (shouldPause === this.paused) return;
+		if (shouldPause === this.paused) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.updatePauseState", "ignored unchanged state");
+			return;
+		}
 		this.paused = shouldPause;
 		if (shouldPause) {
 			this.operation += 1;
 			this.cancelPendingWork();
 			this.activeVideo?.pause();
 			this.activeTgs?.pause?.();
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.updatePauseState", "paused", this.getSnapshot());
 			return;
 		}
 		if (this.phase === "ready") {
@@ -1173,23 +2281,33 @@ var DefaultDrivingExpressionPlayer = class {
 				video.play().catch((error) => this.handleActiveVideoFailure(video, status, media, operation, "decode", error));
 			}
 			this.activeTgs?.play?.();
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.updatePauseState", "resumed ready media");
 			return;
 		}
 		if (this.status !== null && this.desiredMedia !== null) {
 			const operation = this.beginOperation();
 			this.load(this.status, this.desiredMedia, operation);
 		}
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.updatePauseState", "returned", this.getSnapshot());
 	}
 	async load(status, media, operation) {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.load", "called", {
+			status,
+			media,
+			operation
+		});
 		const startedAt = Date.now();
 		this.mediaKind = media.kind;
 		if (media.kind === "emoji") {
 			this.renderEmoji(media.text);
 			this.markReady(status, media.kind, startedAt, operation);
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.load", "resolved emoji", { snapshot: this.getSnapshot() });
 			return;
 		}
-		if (firstInvalidMediaUrl(media) !== null) {
+		const invalidUrl = firstInvalidMediaUrl(media);
+		if (invalidUrl !== null) {
 			this.handleFailure(status, media, /* @__PURE__ */ new Error("One or more media URLs are not long-lived public HTTPS URLs"), "invalid_config", operation);
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.load", "returned invalid URL", { invalidUrl });
 			return;
 		}
 		const loadAbort = new AbortController();
@@ -1212,26 +2330,67 @@ var DefaultDrivingExpressionPlayer = class {
 					await this.loadTgs(media.url, loadAbort.signal, operation);
 					break;
 			}
-			if (!this.isCurrent(operation) || this.failedOperation === operation) return;
+			if (!this.isCurrent(operation) || this.failedOperation === operation) {
+				dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.load", "discarded completed load", {
+					operation,
+					failedOperation: this.failedOperation
+				});
+				return;
+			}
 			this.markReady(status, media.kind, startedAt, operation);
 			this.startPreloading(status, operation);
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.load", "resolved", {
+				status,
+				media,
+				operation,
+				snapshot: this.getSnapshot()
+			});
 		} catch (error) {
-			if (!this.isCurrent(operation) || isAbortError(error)) return;
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.load", "caught error", {
+				error,
+				operation
+			});
+			if (!this.isCurrent(operation) || isAbortError(error)) {
+				dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.load", "ignored error");
+				return;
+			}
 			this.handleFailure(status, media, error, categorizeMediaError(error), operation);
 		} finally {
 			loadAbort.abort();
 			if (this.loadAbort === loadAbort) this.loadAbort = null;
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.load", "completed", { operation });
 		}
 	}
 	async loadImage(url, signal, operation) {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadImage", "called", {
+			url,
+			signal,
+			operation
+		});
 		const image = this.createImage();
 		await waitForElementEvent(image, "load", "error", signal, this.loadTimeoutMs, () => {
 			image.src = url;
 		});
-		if (!this.isCurrent(operation)) return;
+		if (!this.isCurrent(operation)) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadImage", "discarded", { operation });
+			return;
+		}
 		this.container.replaceChildren(image);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadImage", "resolved", {
+			url,
+			operation,
+			image
+		});
 	}
 	async loadVideo(url, mimeType, status, media, signal, operation) {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadVideo", "called", {
+			url,
+			mimeType,
+			status,
+			media,
+			signal,
+			operation
+		});
 		const video = this.getReusableVideo();
 		resetVideo(video);
 		video.preload = "auto";
@@ -1240,25 +2399,55 @@ var DefaultDrivingExpressionPlayer = class {
 			video.src = url;
 			video.load();
 		});
-		if (!this.isCurrent(operation)) return;
+		if (!this.isCurrent(operation)) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadVideo", "discarded", { operation });
+			return;
+		}
 		video.currentTime = 0;
 		this.container.replaceChildren(video);
 		this.activeVideo = video;
 		this.attachActiveVideoFailureListeners(video, status, media, operation);
 		await video.play();
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadVideo", "resolved", {
+			url,
+			operation,
+			video
+		});
 	}
 	async loadLivePhoto(media, status, signal, operation) {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadLivePhoto", "called", {
+			media,
+			status,
+			signal,
+			operation
+		});
 		this.renderConfiguredFallback(status, false);
 		const cover = this.createImage();
 		await waitForElementEvent(cover, "load", "error", signal, this.loadTimeoutMs, () => {
 			cover.src = media.coverUrl;
 		});
-		if (!this.isCurrent(operation)) return;
+		if (!this.isCurrent(operation)) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadLivePhoto", "discarded", { operation });
+			return;
+		}
 		this.container.replaceChildren(cover);
 		await this.loadVideo(media.motionUrl, void 0, status, media, signal, operation);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadLivePhoto", "resolved", {
+			media,
+			operation
+		});
 	}
 	async loadTgs(url, signal, operation) {
-		if (!this.fetchImplementation) throw new MediaPlayerError("unsupported", "fetch is unavailable");
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadTgs", "called", {
+			url,
+			signal,
+			operation
+		});
+		if (!this.fetchImplementation) {
+			const error = new MediaPlayerError("unsupported", "fetch is unavailable");
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadTgs", "threw", error);
+			throw error;
+		}
 		const response = await withTimeout(this.fetchImplementation(url, {
 			credentials: "omit",
 			mode: "cors",
@@ -1266,6 +2455,12 @@ var DefaultDrivingExpressionPlayer = class {
 		}), this.loadTimeoutMs, signal);
 		if (!response.ok) throw new MediaPlayerError("network", `TGS request failed with HTTP ${response.status}`);
 		const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadTgs", "received response", {
+			ok: response.ok,
+			status: response.status,
+			contentType,
+			contentLength: response.headers.get("content-length")
+		});
 		if (!SUPPORTED_TGS_CONTENT_TYPES.has(contentType)) throw new MediaPlayerError("unsupported", `Unsupported TGS Content-Type: ${contentType || "missing"}`);
 		const contentLength = Number(response.headers.get("content-length"));
 		if (Number.isFinite(contentLength) && contentLength > this.maxTgsCompressedBytes) throw new MediaPlayerError("decode", "TGS compressed payload exceeds the configured limit");
@@ -1276,8 +2471,13 @@ var DefaultDrivingExpressionPlayer = class {
 		let animationData;
 		try {
 			animationData = JSON.parse(new TextDecoder().decode(bytes));
-		} catch {
-			throw new MediaPlayerError("decode", "TGS JSON is malformed");
+		} catch (cause) {
+			const error = new MediaPlayerError("decode", "TGS JSON is malformed");
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadTgs", "threw", {
+				error,
+				cause
+			});
+			throw error;
 		}
 		validateTgsAnimation(animationData, this.maxTgsLayers);
 		const host = this.document.createElement("div");
@@ -1285,33 +2485,72 @@ var DefaultDrivingExpressionPlayer = class {
 		const handle = await withTimeout(Promise.resolve(this.tgsRenderer(host, animationData, signal)), this.loadTimeoutMs, signal);
 		if (!this.isCurrent(operation)) {
 			handle.destroy();
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadTgs", "discarded", { operation });
 			return;
 		}
 		this.activeTgs = handle;
 		this.container.replaceChildren(host);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.loadTgs", "resolved", {
+			url,
+			operation,
+			animationData,
+			host
+		});
 	}
 	renderLoadingPlaceholder(status, coverUrl, operation, signal) {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderLoadingPlaceholder", "called", {
+			status,
+			coverUrl,
+			operation,
+			signal
+		});
 		this.renderConfiguredFallback(status, false);
-		if (!coverUrl) return;
+		if (!coverUrl) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderLoadingPlaceholder", "returned no cover");
+			return;
+		}
 		const cover = this.createImage();
 		waitForElementEvent(cover, "load", "error", signal, this.loadTimeoutMs, () => {
 			cover.src = coverUrl;
 		}).then(() => {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderLoadingPlaceholder.then", "called", {
+				operation,
+				cover
+			});
 			if (this.isCurrent(operation) && this.phase === "loading") this.container.replaceChildren(cover);
-		}).catch(() => {
+		}).catch((error) => {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderLoadingPlaceholder.catch", "called", {
+				operation,
+				error
+			});
 			if (this.isCurrent(operation) && this.phase === "loading") this.renderConfiguredFallback(status, false);
 		});
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderLoadingPlaceholder", "returned");
 	}
 	renderConfiguredFallback(status, report = true) {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderConfiguredFallback", "called", {
+			status,
+			report
+		});
 		const fallback = this.fallbacks?.[status];
 		if (!fallback) {
 			this.container.replaceChildren();
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderConfiguredFallback", "returned", { result: false });
 			return false;
 		}
 		this.renderFallback(status, fallback, report);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderConfiguredFallback", "returned", {
+			result: true,
+			fallback
+		});
 		return true;
 	}
 	renderFallback(status, fallback, report = true) {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderFallback", "called", {
+			status,
+			fallback,
+			report
+		});
 		if (report) {
 			this.phase = "fallback";
 			this.mediaKind = fallback.kind;
@@ -1328,8 +2567,10 @@ var DefaultDrivingExpressionPlayer = class {
 			status,
 			kind: fallback.kind
 		});
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderFallback", "returned", { snapshot: this.getSnapshot() });
 	}
 	renderEmoji(text) {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderEmoji", "called", { text });
 		const emoji = this.document.createElement("span");
 		emoji.textContent = text;
 		emoji.setAttribute("role", "img");
@@ -1345,9 +2586,19 @@ var DefaultDrivingExpressionPlayer = class {
 			width: "100%"
 		});
 		this.container.replaceChildren(emoji);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.renderEmoji", "returned", { emoji });
 	}
 	markReady(status, kind, startedAt, operation) {
-		if (!this.isCurrent(operation) || this.failedOperation === operation) return;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.markReady", "called", {
+			status,
+			kind,
+			startedAt,
+			operation
+		});
+		if (!this.isCurrent(operation) || this.failedOperation === operation) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.markReady", "ignored");
+			return;
+		}
 		this.phase = "ready";
 		this.mediaKind = kind;
 		this.errorCategory = null;
@@ -1357,9 +2608,21 @@ var DefaultDrivingExpressionPlayer = class {
 			kind,
 			elapsedMs: Math.max(0, Date.now() - startedAt)
 		});
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.markReady", "returned", this.getSnapshot());
 	}
 	handleFailure(status, media, error, category, operation, scheduleRetry = true) {
-		if (!this.isCurrent(operation) || this.failedOperation === operation) return;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleFailure", "called", {
+			status,
+			media,
+			error,
+			category,
+			operation,
+			scheduleRetry
+		});
+		if (!this.isCurrent(operation) || this.failedOperation === operation) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleFailure", "ignored");
+			return;
+		}
 		this.failedOperation = operation;
 		this.stopActiveVideo();
 		this.phase = "error";
@@ -1371,22 +2634,51 @@ var DefaultDrivingExpressionPlayer = class {
 			category,
 			message: safeErrorMessage(error)
 		});
-		if (!this.renderConfiguredFallback(status)) {
+		const fallbackApplied = this.renderConfiguredFallback(status);
+		if (!fallbackApplied) {
 			this.phase = "error";
 			this.errorCategory = category;
 		}
 		if (scheduleRetry && media !== null) this.scheduleRetry(status, media, operation);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleFailure", "returned", {
+			fallbackApplied,
+			snapshot: this.getSnapshot()
+		});
 	}
 	scheduleRetry(status, media, failedOperation) {
-		if (this.destroyed || this.paused || !this.isCurrent(failedOperation)) return;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.scheduleRetry", "called", {
+			status,
+			media,
+			failedOperation
+		});
+		if (this.destroyed || this.paused || !this.isCurrent(failedOperation)) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.scheduleRetry", "ignored");
+			return;
+		}
 		this.retryTimer = globalThis.setTimeout(() => {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.scheduleRetry.callback", "called", {
+				status,
+				media,
+				failedOperation
+			});
 			this.retryTimer = void 0;
-			if (this.destroyed || this.paused || this.status !== status || !this.isCurrent(failedOperation)) return;
+			if (this.destroyed || this.paused || this.status !== status || !this.isCurrent(failedOperation)) {
+				dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.scheduleRetry.callback", "ignored");
+				return;
+			}
 			const operation = this.beginOperation();
 			this.load(status, media, operation);
 		}, this.retryBackoffMs);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.scheduleRetry", "scheduled", {
+			retryTimer: this.retryTimer,
+			retryBackoffMs: this.retryBackoffMs
+		});
 	}
 	startPreloading(currentStatus, operation) {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.startPreloading", "called", {
+			currentStatus,
+			operation
+		});
 		this.preloadAbort?.abort();
 		const preloadAbort = new AbortController();
 		this.preloadAbort = preloadAbort;
@@ -1396,8 +2688,18 @@ var DefaultDrivingExpressionPlayer = class {
 			...CAR_RUNNING_STATUSES
 		].filter((status, index, all) => all.indexOf(status) === index);
 		(async () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.startPreloading.worker", "started", {
+				statuses,
+				operation
+			});
 			for (const status of statuses) {
-				if (!this.isCurrent(operation) || preloadAbort.signal.aborted) return;
+				if (!this.isCurrent(operation) || preloadAbort.signal.aborted) {
+					dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.startPreloading.worker", "cancelled", {
+						status,
+						operation
+					});
+					return;
+				}
 				const configured = this.config.states[status];
 				if (configured === void 0 || status === currentStatus) continue;
 				const media = normalizeMedia(configured);
@@ -1409,20 +2711,34 @@ var DefaultDrivingExpressionPlayer = class {
 						image.src = hintUrl;
 					});
 					image.removeAttribute("src");
-				} catch {
+					dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.startPreloading.worker", "preloaded", {
+						status,
+						hintUrl
+					});
+				} catch (error) {
+					dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.startPreloading.worker", "preload failed", {
+						status,
+						hintUrl,
+						error
+					});
 					if (preloadAbort.signal.aborted) return;
 				}
 			}
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.startPreloading.worker", "completed", { operation });
 		})();
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.startPreloading", "returned", { statuses });
 	}
 	createImage() {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.createImage", "called");
 		const image = this.document.createElement("img");
 		image.alt = "";
 		image.decoding = "async";
 		styleMediaElement(image, this.fit);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.createImage", "returned", { image });
 		return image;
 	}
 	getReusableVideo() {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.getReusableVideo", "called", { hasReusableVideo: this.reusableVideo !== null });
 		if (!this.reusableVideo) {
 			this.reusableVideo = this.document.createElement("video");
 			this.reusableVideo.muted = true;
@@ -1432,52 +2748,105 @@ var DefaultDrivingExpressionPlayer = class {
 			this.reusableVideo.setAttribute("playsinline", "");
 			styleMediaElement(this.reusableVideo, this.fit);
 		}
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.getReusableVideo", "returned", { video: this.reusableVideo });
 		return this.reusableVideo;
 	}
 	attachActiveVideoFailureListeners(video, status, media, operation) {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.attachActiveVideoFailureListeners", "called", {
+			video,
+			status,
+			media,
+			operation
+		});
 		this.detachActiveVideoFailureListeners();
 		let attached = true;
 		const cleanup = () => {
-			if (!attached) return;
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.videoListenerCleanup", "called", { attached });
+			if (!attached) {
+				dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.videoListenerCleanup", "ignored");
+				return;
+			}
 			attached = false;
 			video.removeEventListener("error", handleError);
 			video.removeEventListener("stalled", handleStalled);
 			if (this.activeVideoListenersCleanup === cleanup) this.activeVideoListenersCleanup = null;
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.videoListenerCleanup", "returned");
 		};
 		const failed = (category, event) => {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.videoListenerFailed", "called", {
+				category,
+				event,
+				attached
+			});
 			if (!attached) return;
 			this.handleActiveVideoFailure(video, status, media, operation, category, new MediaPlayerError(category, `${event.type} after video playback started`));
 		};
-		const handleError = (event) => failed("decode", event);
-		const handleStalled = (event) => failed("network", event);
+		const handleError = (event) => {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleVideoError", "called", { event });
+			failed("decode", event);
+		};
+		const handleStalled = (event) => {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleVideoStalled", "called", { event });
+			failed("network", event);
+		};
 		video.addEventListener("error", handleError);
 		video.addEventListener("stalled", handleStalled);
 		this.activeVideoListenersCleanup = cleanup;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.attachActiveVideoFailureListeners", "returned");
 	}
 	handleActiveVideoFailure(video, status, media, operation, category, error) {
-		if (this.activeVideo !== video || !this.isCurrent(operation)) return;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleActiveVideoFailure", "called", {
+			video,
+			status,
+			media,
+			operation,
+			category,
+			error
+		});
+		if (this.activeVideo !== video || !this.isCurrent(operation)) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleActiveVideoFailure", "ignored");
+			return;
+		}
 		this.stopActiveVideo();
 		this.handleFailure(status, media, error, category, operation);
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.handleActiveVideoFailure", "returned");
 	}
 	detachActiveVideoFailureListeners() {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.detachActiveVideoFailureListeners", "called");
 		const cleanup = this.activeVideoListenersCleanup;
 		this.activeVideoListenersCleanup = null;
 		cleanup?.();
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.detachActiveVideoFailureListeners", "returned");
 	}
 	stopActiveVideo() {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.stopActiveVideo", "called", { activeVideo: this.activeVideo });
 		this.detachActiveVideoFailureListeners();
-		if (!this.activeVideo) return;
+		if (!this.activeVideo) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.stopActiveVideo", "returned no active video");
+			return;
+		}
 		resetVideo(this.activeVideo);
 		this.activeVideo = null;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.stopActiveVideo", "returned");
 	}
 	releaseActiveMedia() {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.releaseActiveMedia", "called", {
+			activeVideo: this.activeVideo,
+			activeTgs: this.activeTgs
+		});
 		this.stopActiveVideo();
 		if (this.activeTgs) {
 			safeDestroy(this.activeTgs);
 			this.activeTgs = null;
 		}
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.releaseActiveMedia", "returned");
 	}
 	cancelPendingWork() {
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.cancelPendingWork", "called", {
+			hasLoad: this.loadAbort !== null,
+			hasPreload: this.preloadAbort !== null,
+			retryTimer: this.retryTimer
+		});
 		this.loadAbort?.abort();
 		this.loadAbort = null;
 		this.detachActiveVideoFailureListeners();
@@ -1488,22 +2857,46 @@ var DefaultDrivingExpressionPlayer = class {
 			globalThis.clearTimeout(this.retryTimer);
 			this.retryTimer = void 0;
 		}
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.cancelPendingWork", "returned");
 	}
 	isCurrent(operation) {
-		return !this.destroyed && !this.paused && operation === this.operation;
+		const result = !this.destroyed && !this.paused && operation === this.operation;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.isCurrent", "returned", {
+			operation,
+			currentOperation: this.operation,
+			destroyed: this.destroyed,
+			paused: this.paused,
+			result
+		});
+		return result;
 	}
 	emitDiagnostic(event) {
-		if (!this.onDiagnostic) return;
+		dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.emitDiagnostic", "called", {
+			event,
+			hasListener: this.onDiagnostic !== void 0
+		});
+		if (!this.onDiagnostic) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.emitDiagnostic", "returned no listener");
+			return;
+		}
 		try {
 			this.onDiagnostic(event);
-		} catch {}
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.emitDiagnostic", "returned", { event });
+		} catch (error) {
+			dialSdkDebugWarn(DEBUG_MODULE, "DefaultDrivingExpressionPlayer.emitDiagnostic", "listener threw", error);
+		}
 	}
 };
 var MediaPlayerError = class extends Error {
 	constructor(category, message) {
+		dialSdkDebugWarn(DEBUG_MODULE, "MediaPlayerError.constructor", "called", {
+			category,
+			message
+		});
 		super(message);
 		this.name = "MediaPlayerError";
 		this.category = category;
+		dialSdkDebugWarn(DEBUG_MODULE, "MediaPlayerError.constructor", "created", { error: this });
 	}
 };
 const SUPPORTED_TGS_CONTENT_TYPES = /* @__PURE__ */ new Set([
@@ -1513,11 +2906,19 @@ const SUPPORTED_TGS_CONTENT_TYPES = /* @__PURE__ */ new Set([
 	"application/x-gzip",
 	"application/x-tgsticker"
 ]);
-const normalizeMedia = (media) => typeof media === "string" ? {
-	kind: "image",
-	url: media
-} : media;
+const normalizeMedia = (media) => {
+	const result = typeof media === "string" ? {
+		kind: "image",
+		url: media
+	} : media;
+	dialSdkDebugWarn(DEBUG_MODULE, "normalizeMedia", "returned", {
+		media,
+		result
+	});
+	return result;
+};
 const firstInvalidMediaUrl = (media) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "firstInvalidMediaUrl", "called", { media });
 	let values;
 	switch (media.kind) {
 		case "emoji":
@@ -1534,75 +2935,129 @@ const firstInvalidMediaUrl = (media) => {
 			values = [media.url, media.coverUrl];
 			break;
 	}
-	return values.find((value) => typeof value === "string" && !isPublicDrivingMediaUrl(value)) ?? null;
+	const result = values.find((value) => typeof value === "string" && !isPublicDrivingMediaUrl(value)) ?? null;
+	dialSdkDebugWarn(DEBUG_MODULE, "firstInvalidMediaUrl", "returned", {
+		values,
+		result
+	});
+	return result;
 };
 const mediaPreloadHint = (media) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "mediaPreloadHint", "called", { media });
+	let result;
 	switch (media.kind) {
-		case "image": return media.url;
+		case "image":
+			result = media.url;
+			break;
 		case "video":
-		case "tgs": return media.coverUrl;
-		case "live_photo": return media.coverUrl;
-		case "emoji": return;
-	}
-};
-const waitForElementEvent = (element, successEvent, failureEvent, signal, timeoutMs, start) => new Promise((resolve, reject) => {
-	let timer;
-	const cleanup = () => {
-		element.removeEventListener(successEvent, handleSuccess);
-		element.removeEventListener(failureEvent, handleFailure);
-		signal.removeEventListener("abort", handleAbort);
-		if (timer !== void 0) globalThis.clearTimeout(timer);
-	};
-	const handleSuccess = () => {
-		cleanup();
-		resolve();
-	};
-	const handleFailure = () => {
-		cleanup();
-		reject(new MediaPlayerError("decode", `${failureEvent} while loading media`));
-	};
-	const handleAbort = () => {
-		cleanup();
-		reject(createAbortError());
-	};
-	element.addEventListener(successEvent, handleSuccess, { once: true });
-	element.addEventListener(failureEvent, handleFailure, { once: true });
-	signal.addEventListener("abort", handleAbort, { once: true });
-	timer = globalThis.setTimeout(() => {
-		cleanup();
-		reject(new MediaPlayerError("timeout", `media load timed out after ${timeoutMs}ms`));
-	}, timeoutMs);
-	try {
-		start();
-	} catch (error) {
-		cleanup();
-		reject(error);
+		case "tgs":
+			result = media.coverUrl;
+			break;
+		case "live_photo":
+			result = media.coverUrl;
+			break;
+		case "emoji":
+			result = void 0;
+			break;
 	}
-});
-const withTimeout = (promise, timeoutMs, signal) => new Promise((resolve, reject) => {
-	let timer;
-	const cleanup = () => {
-		signal.removeEventListener("abort", handleAbort);
-		if (timer !== void 0) globalThis.clearTimeout(timer);
-	};
-	const handleAbort = () => {
-		cleanup();
-		reject(createAbortError());
-	};
-	signal.addEventListener("abort", handleAbort, { once: true });
-	timer = globalThis.setTimeout(() => {
-		cleanup();
-		reject(new MediaPlayerError("timeout", `media load timed out after ${timeoutMs}ms`));
-	}, timeoutMs);
-	promise.then((value) => {
-		cleanup();
-		resolve(value);
-	}, (error) => {
-		cleanup();
-		reject(error);
+	dialSdkDebugWarn(DEBUG_MODULE, "mediaPreloadHint", "returned", { result });
+	return result;
+};
+const waitForElementEvent = (element, successEvent, failureEvent, signal, timeoutMs, start) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "waitForElementEvent", "called", {
+		element,
+		successEvent,
+		failureEvent,
+		signal,
+		timeoutMs
 	});
-});
+	const result = new Promise((resolve, reject) => {
+		let timer;
+		const cleanup = () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "waitForElementEvent.cleanup", "called", { timer });
+			element.removeEventListener(successEvent, handleSuccess);
+			element.removeEventListener(failureEvent, handleFailure);
+			signal.removeEventListener("abort", handleAbort);
+			if (timer !== void 0) globalThis.clearTimeout(timer);
+			dialSdkDebugWarn(DEBUG_MODULE, "waitForElementEvent.cleanup", "returned");
+		};
+		const handleSuccess = () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "waitForElementEvent.handleSuccess", "called", { successEvent });
+			cleanup();
+			resolve();
+		};
+		const handleFailure = () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "waitForElementEvent.handleFailure", "called", { failureEvent });
+			cleanup();
+			reject(new MediaPlayerError("decode", `${failureEvent} while loading media`));
+		};
+		const handleAbort = () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "waitForElementEvent.handleAbort", "called");
+			cleanup();
+			reject(createAbortError());
+		};
+		element.addEventListener(successEvent, handleSuccess, { once: true });
+		element.addEventListener(failureEvent, handleFailure, { once: true });
+		signal.addEventListener("abort", handleAbort, { once: true });
+		timer = globalThis.setTimeout(() => {
+			dialSdkDebugWarn(DEBUG_MODULE, "waitForElementEvent.timeout", "called", { timeoutMs });
+			cleanup();
+			reject(new MediaPlayerError("timeout", `media load timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+		try {
+			start();
+		} catch (error) {
+			cleanup();
+			reject(error);
+		}
+	});
+	result.then(() => dialSdkDebugWarn(DEBUG_MODULE, "waitForElementEvent", "resolved"), (error) => dialSdkDebugWarn(DEBUG_MODULE, "waitForElementEvent", "rejected", error));
+	return result;
+};
+const withTimeout = (promise, timeoutMs, signal) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "withTimeout", "called", {
+		promise,
+		timeoutMs,
+		signal
+	});
+	const result = new Promise((resolve, reject) => {
+		let timer;
+		const cleanup = () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "withTimeout.cleanup", "called", { timer });
+			signal.removeEventListener("abort", handleAbort);
+			if (timer !== void 0) globalThis.clearTimeout(timer);
+			dialSdkDebugWarn(DEBUG_MODULE, "withTimeout.cleanup", "returned");
+		};
+		const handleAbort = () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "withTimeout.handleAbort", "called");
+			cleanup();
+			reject(createAbortError());
+		};
+		signal.addEventListener("abort", handleAbort, { once: true });
+		timer = globalThis.setTimeout(() => {
+			dialSdkDebugWarn(DEBUG_MODULE, "withTimeout.timeout", "called", { timeoutMs });
+			cleanup();
+			reject(new MediaPlayerError("timeout", `media load timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+		promise.then((value) => {
+			dialSdkDebugWarn(DEBUG_MODULE, "withTimeout.promiseResolved", "called", { value });
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			dialSdkDebugWarn(DEBUG_MODULE, "withTimeout.promiseRejected", "called", { error });
+			cleanup();
+			reject(error);
+		});
+	});
+	result.then((value) => dialSdkDebugWarn(DEBUG_MODULE, "withTimeout", "resolved", { value }), (error) => dialSdkDebugWarn(DEBUG_MODULE, "withTimeout", "rejected", error));
+	return result;
+};
 const defaultTgsRenderer = async (container, animationData, signal) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer", "called", {
+		container,
+		animationData,
+		signal
+	});
 	if (signal.aborted) throw createAbortError();
 	const module = await import("lottie-web/build/player/lottie_light.js");
 	if (signal.aborted) throw createAbortError();
@@ -1616,47 +3071,80 @@ const defaultTgsRenderer = async (container, animationData, signal) => {
 	});
 	await new Promise((resolve, reject) => {
 		const ready = () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer.ready", "called");
 			cleanup();
 			resolve();
 		};
 		const failed = () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer.failed", "called");
 			cleanup();
 			reject(new MediaPlayerError("decode", "Lottie could not initialize the TGS animation"));
 		};
 		const aborted = () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer.aborted", "called");
 			cleanup();
 			animation.destroy();
 			reject(createAbortError());
 		};
 		const cleanup = () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer.cleanup", "called");
 			animation.removeEventListener("DOMLoaded", ready);
 			animation.removeEventListener("data_failed", failed);
 			signal.removeEventListener("abort", aborted);
+			dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer.cleanup", "returned");
 		};
 		animation.addEventListener("DOMLoaded", ready);
 		animation.addEventListener("data_failed", failed);
 		signal.addEventListener("abort", aborted, { once: true });
 	});
-	return {
-		destroy: () => animation.destroy(),
-		pause: () => animation.pause(),
-		play: () => animation.play(),
-		restart: () => animation.goToAndPlay(0, true)
+	const result = {
+		destroy: () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer.handle.destroy", "called");
+			animation.destroy();
+		},
+		pause: () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer.handle.pause", "called");
+			animation.pause();
+		},
+		play: () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer.handle.play", "called");
+			animation.play();
+		},
+		restart: () => {
+			dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer.handle.restart", "called");
+			animation.goToAndPlay(0, true);
+		}
 	};
+	dialSdkDebugWarn(DEBUG_MODULE, "defaultTgsRenderer", "resolved", { result });
+	return result;
 };
 function validateTgsAnimation(value, maxLayers) {
+	dialSdkDebugWarn(DEBUG_MODULE, "validateTgsAnimation", "called", {
+		value,
+		maxLayers
+	});
 	if (!isRecord(value) || !Array.isArray(value.layers)) throw new MediaPlayerError("decode", "TGS animation does not contain a layers array");
 	if (value.layers.length > maxLayers) throw new MediaPlayerError("decode", "TGS animation has too many layers");
 	if (typeof value.fr === "number" && (!Number.isFinite(value.fr) || value.fr <= 0 || value.fr > 120)) throw new MediaPlayerError("decode", "TGS animation frame rate is outside the supported range");
 	if (typeof value.ip === "number" && typeof value.op === "number" && (value.op <= value.ip || value.op - value.ip > 3e4)) throw new MediaPlayerError("decode", "TGS animation duration is outside the supported range");
+	dialSdkDebugWarn(DEBUG_MODULE, "validateTgsAnimation", "returned");
 }
 const gunzipWithLimit = (compressed, maxOutputBytes) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "gunzipWithLimit", "called", {
+		compressed,
+		maxOutputBytes
+	});
 	if (compressed.byteLength < 18) throw new MediaPlayerError("decode", "TGS gzip payload is truncated");
 	if (new DataView(compressed.buffer, compressed.byteOffset + compressed.byteLength - 4, 4).getUint32(0, true) > maxOutputBytes) throw new MediaPlayerError("decode", "TGS JSON payload exceeds the configured limit");
 	const chunks = [];
 	let outputBytes = 0;
 	try {
 		const gunzip = new Gunzip((chunk) => {
+			dialSdkDebugWarn(DEBUG_MODULE, "gunzipWithLimit.onChunk", "called", {
+				chunk,
+				outputBytes,
+				maxOutputBytes
+			});
 			outputBytes += chunk.byteLength;
 			if (outputBytes > maxOutputBytes) throw new MediaPlayerError("decode", "TGS JSON payload exceeds the configured limit");
 			if (chunk.byteLength > 0) chunks.push(chunk);
@@ -1667,8 +3155,11 @@ const gunzipWithLimit = (compressed, maxOutputBytes) => {
 			gunzip.push(compressed.subarray(offset, end), end === compressed.byteLength);
 		}
 	} catch (error) {
+		dialSdkDebugWarn(DEBUG_MODULE, "gunzipWithLimit", "caught error", error);
 		if (error instanceof MediaPlayerError) throw error;
-		throw new MediaPlayerError("decode", "TGS gzip decompression failed");
+		const wrapped = new MediaPlayerError("decode", "TGS gzip decompression failed");
+		dialSdkDebugWarn(DEBUG_MODULE, "gunzipWithLimit", "threw", wrapped);
+		throw wrapped;
 	}
 	const output = new Uint8Array(outputBytes);
 	let offset = 0;
@@ -1676,17 +3167,29 @@ const gunzipWithLimit = (compressed, maxOutputBytes) => {
 		output.set(chunk, offset);
 		offset += chunk.byteLength;
 	}
+	dialSdkDebugWarn(DEBUG_MODULE, "gunzipWithLimit", "returned", {
+		output,
+		outputBytes
+	});
 	return output;
 };
 const resetVideo = (video) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "resetVideo", "called", { video });
 	video.pause();
 	video.removeAttribute("src");
 	video.removeAttribute("type");
 	try {
 		video.load();
-	} catch {}
+	} catch (error) {
+		dialSdkDebugWarn(DEBUG_MODULE, "resetVideo", "load threw", error);
+	}
+	dialSdkDebugWarn(DEBUG_MODULE, "resetVideo", "returned", { video });
 };
 const styleMediaElement = (element, fit) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "styleMediaElement", "called", {
+		element,
+		fit
+	});
 	Object.assign(element.style, {
 		display: "block",
 		height: "100%",
@@ -1695,40 +3198,86 @@ const styleMediaElement = (element, fit) => {
 		objectFit: fit,
 		width: "100%"
 	});
+	dialSdkDebugWarn(DEBUG_MODULE, "styleMediaElement", "returned", { element });
 };
 const categorizeMediaError = (error) => {
-	if (error instanceof MediaPlayerError) return error.category;
-	if (error instanceof TypeError) return "network";
-	return "decode";
+	const result = error instanceof MediaPlayerError ? error.category : error instanceof TypeError ? "network" : "decode";
+	dialSdkDebugWarn(DEBUG_MODULE, "categorizeMediaError", "returned", {
+		error,
+		result
+	});
+	return result;
 };
 const safeErrorMessage = (error) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "safeErrorMessage", "called", { error });
 	const message = error instanceof Error ? error.message : String(error);
-	return redactUrlQueries(message).slice(0, 240);
+	const result = redactUrlQueries(message).slice(0, 240);
+	dialSdkDebugWarn(DEBUG_MODULE, "safeErrorMessage", "returned", { result });
+	return result;
+};
+const redactUrlQueries = (message) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "redactUrlQueries", "called", { message });
+	const result = message.replace(/https:\/\/[^\s"'<>]+/gu, (candidate) => {
+		dialSdkDebugWarn(DEBUG_MODULE, "redactUrlQueries.replace", "called", { candidate });
+		try {
+			const url = new URL(candidate);
+			return `${url.origin}${url.pathname}`;
+		} catch {
+			return "[url]";
+		}
+	});
+	dialSdkDebugWarn(DEBUG_MODULE, "redactUrlQueries", "returned", { result });
+	return result;
 };
-const redactUrlQueries = (message) => message.replace(/https:\/\/[^\s"'<>]+/gu, (candidate) => {
-	try {
-		const url = new URL(candidate);
-		return `${url.origin}${url.pathname}`;
-	} catch {
-		return "[url]";
-	}
-});
 const createAbortError = () => {
-	if (typeof DOMException !== "undefined") return new DOMException("Aborted", "AbortError");
+	dialSdkDebugWarn(DEBUG_MODULE, "createAbortError", "called");
+	if (typeof DOMException !== "undefined") {
+		const result = new DOMException("Aborted", "AbortError");
+		dialSdkDebugWarn(DEBUG_MODULE, "createAbortError", "returned DOMException", { result });
+		return result;
+	}
 	const error = /* @__PURE__ */ new Error("Aborted");
 	error.name = "AbortError";
+	dialSdkDebugWarn(DEBUG_MODULE, "createAbortError", "returned Error", { result: error });
 	return error;
 };
-const isAbortError = (error) => error instanceof Error && error.name === "AbortError";
+const isAbortError = (error) => {
+	const result = error instanceof Error && error.name === "AbortError";
+	dialSdkDebugWarn(DEBUG_MODULE, "isAbortError", "returned", {
+		error,
+		result
+	});
+	return result;
+};
 const positiveFinite = (name, value) => {
-	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a positive finite number`);
+	dialSdkDebugWarn(DEBUG_MODULE, "positiveFinite", "called", {
+		name,
+		value
+	});
+	if (!Number.isFinite(value) || value <= 0) {
+		const error = /* @__PURE__ */ new RangeError(`${name} must be a positive finite number`);
+		dialSdkDebugWarn(DEBUG_MODULE, "positiveFinite", "threw", error);
+		throw error;
+	}
+	dialSdkDebugWarn(DEBUG_MODULE, "positiveFinite", "returned", { result: value });
 	return value;
 };
 const safeDestroy = (handle) => {
+	dialSdkDebugWarn(DEBUG_MODULE, "safeDestroy", "called", { handle });
 	try {
 		handle.destroy();
-	} catch {}
+		dialSdkDebugWarn(DEBUG_MODULE, "safeDestroy", "returned");
+	} catch (error) {
+		dialSdkDebugWarn(DEBUG_MODULE, "safeDestroy", "destroy threw", error);
+	}
+};
+const isRecord = (value) => {
+	const result = typeof value === "object" && value !== null && !Array.isArray(value);
+	dialSdkDebugWarn(DEBUG_MODULE, "isRecord", "returned", {
+		value,
+		result
+	});
+	return result;
 };
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 //#endregion
-export { BATTERY_HEALTH_LABELS, CAR_RUNNING_LABELS, CAR_RUNNING_STATUSES, CAR_RUNNING_STATUS_PRIORITY, DEFAULT_DRIVING_STATUS_TUNING, DrivingExpressionResolutionError, DrivingExpressionsConfigError, OFFICIAL_DRIVING_EXPRESSIONS_CONFIG, OFFICIAL_DRIVING_EXPRESSION_FALLBACKS, checkRunningStatus, classifyDrivingMetrics, classifyDrivingSnapshot, createDrivingExpressionPlayer, createDrivingStatusController, extractDrivingSnapshotMetrics, isPublicDrivingMediaUrl, parseDrivingExpressionsConfig, readDrivingExpressionsConfig, resolveDrivingExpression, resolveDrivingExpressionStrict, resolveDrivingStatusTuning, tryParseDrivingExpressionsConfig, unifiedSensorInfo };
+export { BATTERY_HEALTH_LABELS, CAR_RUNNING_LABELS, CAR_RUNNING_STATUSES, CAR_RUNNING_STATUS_PRIORITY, DEFAULT_DRIVING_STATUS_TUNING, DrivingExpressionResolutionError, DrivingExpressionsConfigError, OFFICIAL_DRIVING_EXPRESSIONS_CONFIG, OFFICIAL_DRIVING_EXPRESSION_FALLBACKS, checkRunningStatus, classifyDrivingMetrics, classifyDrivingSnapshot, createDrivingExpressionPlayer, createDrivingStatusController, extractDrivingSnapshotMetrics, isPublicDrivingMediaUrl, parseDrivingExpressionsConfig, readDrivingExpressionsConfig, resolveDrivingExpression, resolveDrivingExpressionStrict, resolveDrivingStatusTuning, tryParseDrivingExpressionsConfig, unifiedSensorInfo, waitForDrivingExpressionsConfig };