@ziztechnology/dial-library 0.0.10 → 0.0.12

package/dist/index.mjs

@@ -45,40 +45,59 @@ const dialSdkDebugWarn = (moduleName, scope, phase, data) => {
 //#endregion
 //#region src/sensor/check_status.ts
 const DEBUG_MODULE$5 = "check_status.ts";
+const DEVICE_RIGHT = {
+	x: 1,
+	y: 0,
+	z: 0
+};
+const ZERO_VECTOR$1 = {
+	x: 0,
+	y: 0,
+	z: 0
+};
 const DEFAULT_DRIVING_STATUS_TUNING = Object.freeze({
-	version: "driving-status-v1",
+	version: "driving-status-calibrated-2026-07",
 	maxSampleAgeMs: 1e3,
-	rapidLongitudinalThreshold: 3,
-	longitudinalThreshold: 1,
-	turnYawThreshold: .5,
-	turnLateralThreshold: 2.5,
+	gravityFilterTimeConstantMs: 1e3,
+	biasFilterTimeConstantMs: 1e4,
+	vehicleRightMinimumNorm: .2,
 	motionWindowMs: 1e3,
 	motionMinimumSamples: 5,
-	drivingMotionThreshold: .4,
-	stoppedMotionThreshold: .25,
-	stoppedGyroThreshold: .1,
-	hysteresisRatio: .75,
-	smoothingWindowSize: 3,
-	confirmationSamples: Object.freeze({
-		STOPPED: 5,
-		STEADY_DRIVING: 3,
-		ACCELERATION: 2,
-		RAPID_ACCELERATION: 1,
-		BRAKING: 2,
-		SUDDEN_BRAKING: 1,
-		LEFT_TURN: 2,
-		RIGHT_TURN: 2
-	}),
-	minimumDisplayMs: Object.freeze({
-		STOPPED: 1200,
-		STEADY_DRIVING: 1200,
-		ACCELERATION: 700,
-		RAPID_ACCELERATION: 1200,
-		BRAKING: 700,
-		SUDDEN_BRAKING: 1200,
-		LEFT_TURN: 800,
-		RIGHT_TURN: 800
-	})
+	stoppedMotionThreshold: .12,
+	drivingMotionThreshold: .18,
+	stoppedGyroThreshold: .025,
+	stoppedRawGyroThreshold: .065,
+	drivingGyroThreshold: .04,
+	drivingRawGyroThreshold: .08,
+	stoppedConfirmationMs: 5e3,
+	drivingConfirmationMs: 600,
+	longitudinalWindowMs: 800,
+	longitudinalMinimumSamples: 5,
+	longitudinalThreshold: .7,
+	longitudinalExitThreshold: .35,
+	longitudinalSignCoherence: .8,
+	longitudinalReleaseMs: 500,
+	rapidLongitudinalWindowMs: 600,
+	rapidLongitudinalMinimumSamples: 4,
+	rapidLongitudinalPeakThreshold: 2.2,
+	rapidLongitudinalMeanThreshold: 1.4,
+	rapidLongitudinalSignCoherence: .75,
+	rapidMinimumDisplayMs: 500,
+	verticalBumpRatio: 1.25,
+	longitudinalReversalWindowMs: 400,
+	turnWindowMs: 1500,
+	turnMinimumSamples: 4,
+	turnYawThreshold: .12,
+	turnConfirmationMs: 600,
+	turnIntegratedAngleThreshold: .12,
+	turnSignCoherence: .7,
+	turnYawDominanceThreshold: .6,
+	turnLateralEvidenceThreshold: .25,
+	turnVerticalNoiseFloor: .1,
+	turnVerticalBumpRatio: 1.25,
+	turnExitYawThreshold: .04,
+	turnExitConfirmationMs: 700,
+	turnClosureWindowMs: 1500
 });
 const classifyDrivingSnapshot = (info, tuningOverrides) => {
 	dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingSnapshot", "called", {
@@ -87,52 +106,95 @@ const classifyDrivingSnapshot = (info, tuningOverrides) => {
 	});
 	const tuning = resolveDrivingStatusTuning(tuningOverrides);
 	const metrics = extractDrivingSnapshotMetrics(info, tuning);
-	const result = metrics === null ? null : classifyDrivingMetrics(metrics, tuning);
-	dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingSnapshot", "returned", {
-		tuning,
+	if (metrics === null) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingSnapshot", "returned", { result: null });
+		return null;
+	}
+	const { candidateStatus, rejectionReason } = classifyInstantaneousEvidence(metrics, tuning);
+	const result = {
+		capturedAtMs: info.capturedAtMs,
 		metrics,
-		result
-	});
+		candidateStatus,
+		rejectionReason,
+		quality: {
+			frameValid: true,
+			maximumSampleAgeMs: Math.max(info.capturedAtMs - metrics.linearAccelerationSampledAtMs, info.capturedAtMs - metrics.gyroscopeSampledAtMs, info.capturedAtMs - metrics.gravitySampledAtMs)
+		}
+	};
+	dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingSnapshot", "returned", { result });
 	return result;
 };
-const checkRunningStatus = classifyDrivingSnapshot;
 const resolveDrivingStatusTuning = (overrides = {}) => {
 	dialSdkDebugWarn(DEBUG_MODULE$5, "resolveDrivingStatusTuning", "called", { overrides });
 	const tuning = {
 		...DEFAULT_DRIVING_STATUS_TUNING,
-		...overrides,
-		confirmationSamples: {
-			...DEFAULT_DRIVING_STATUS_TUNING.confirmationSamples,
-			...overrides.confirmationSamples
-		},
-		minimumDisplayMs: {
-			...DEFAULT_DRIVING_STATUS_TUNING.minimumDisplayMs,
-			...overrides.minimumDisplayMs
-		}
+		...overrides
 	};
-	assertPositiveFinite("maxSampleAgeMs", tuning.maxSampleAgeMs);
-	assertPositiveFinite("rapidLongitudinalThreshold", tuning.rapidLongitudinalThreshold);
-	assertPositiveFinite("longitudinalThreshold", tuning.longitudinalThreshold);
-	assertPositiveFinite("turnYawThreshold", tuning.turnYawThreshold);
-	assertPositiveFinite("turnLateralThreshold", tuning.turnLateralThreshold);
-	assertPositiveFinite("motionWindowMs", tuning.motionWindowMs);
-	if (!Number.isInteger(tuning.motionMinimumSamples) || tuning.motionMinimumSamples < 1) throw new RangeError("motionMinimumSamples must be a positive integer");
-	assertPositiveFinite("drivingMotionThreshold", tuning.drivingMotionThreshold);
-	assertPositiveFinite("stoppedMotionThreshold", tuning.stoppedMotionThreshold);
-	assertPositiveFinite("stoppedGyroThreshold", tuning.stoppedGyroThreshold);
-	if (tuning.drivingMotionThreshold <= tuning.stoppedMotionThreshold) throw new RangeError("drivingMotionThreshold must be greater than stoppedMotionThreshold");
-	if (!Number.isInteger(tuning.smoothingWindowSize) || tuning.smoothingWindowSize < 1) throw new RangeError("smoothingWindowSize must be a positive integer");
-	if (tuning.rapidLongitudinalThreshold < tuning.longitudinalThreshold) throw new RangeError("rapidLongitudinalThreshold must be greater than or equal to longitudinalThreshold");
-	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`);
+	for (const field of [
+		"maxSampleAgeMs",
+		"gravityFilterTimeConstantMs",
+		"biasFilterTimeConstantMs",
+		"vehicleRightMinimumNorm",
+		"motionWindowMs",
+		"stoppedMotionThreshold",
+		"drivingMotionThreshold",
+		"stoppedGyroThreshold",
+		"stoppedRawGyroThreshold",
+		"drivingGyroThreshold",
+		"drivingRawGyroThreshold",
+		"stoppedConfirmationMs",
+		"drivingConfirmationMs",
+		"longitudinalWindowMs",
+		"longitudinalThreshold",
+		"longitudinalExitThreshold",
+		"longitudinalReleaseMs",
+		"rapidLongitudinalWindowMs",
+		"rapidLongitudinalPeakThreshold",
+		"rapidLongitudinalMeanThreshold",
+		"rapidMinimumDisplayMs",
+		"verticalBumpRatio",
+		"longitudinalReversalWindowMs",
+		"turnWindowMs",
+		"turnYawThreshold",
+		"turnConfirmationMs",
+		"turnIntegratedAngleThreshold",
+		"turnLateralEvidenceThreshold",
+		"turnVerticalNoiseFloor",
+		"turnVerticalBumpRatio",
+		"turnExitYawThreshold",
+		"turnExitConfirmationMs",
+		"turnClosureWindowMs"
+	]) assertPositiveFinite(field, tuning[field]);
+	for (const field of [
+		"motionMinimumSamples",
+		"longitudinalMinimumSamples",
+		"rapidLongitudinalMinimumSamples",
+		"turnMinimumSamples"
+	]) if (!Number.isInteger(tuning[field]) || tuning[field] < 1) throwLoggedRangeError("resolveDrivingStatusTuning", `${field} must be a positive integer`);
+	for (const field of [
+		"longitudinalSignCoherence",
+		"rapidLongitudinalSignCoherence",
+		"turnSignCoherence",
+		"turnYawDominanceThreshold"
+	]) {
+		const value = tuning[field];
+		if (!Number.isFinite(value) || value <= .5 || value > 1) throwLoggedRangeError("resolveDrivingStatusTuning", `${field} must be greater than 0.5 and less than or equal to 1`);
+	}
+	if (tuning.drivingMotionThreshold <= tuning.stoppedMotionThreshold) throwLoggedRangeError("resolveDrivingStatusTuning", "drivingMotionThreshold must be greater than stoppedMotionThreshold");
+	if (tuning.drivingGyroThreshold <= tuning.stoppedGyroThreshold) throwLoggedRangeError("resolveDrivingStatusTuning", "drivingGyroThreshold must be greater than stoppedGyroThreshold");
+	if (tuning.drivingRawGyroThreshold <= tuning.stoppedRawGyroThreshold) throwLoggedRangeError("resolveDrivingStatusTuning", "drivingRawGyroThreshold must be greater than stoppedRawGyroThreshold");
+	if (tuning.longitudinalThreshold <= tuning.longitudinalExitThreshold) throwLoggedRangeError("resolveDrivingStatusTuning", "longitudinalThreshold must be greater than longitudinalExitThreshold");
+	if (tuning.rapidLongitudinalMeanThreshold <= tuning.longitudinalThreshold) throwLoggedRangeError("resolveDrivingStatusTuning", "rapidLongitudinalMeanThreshold must be greater than longitudinalThreshold");
+	if (tuning.rapidLongitudinalPeakThreshold < tuning.rapidLongitudinalMeanThreshold) throwLoggedRangeError("resolveDrivingStatusTuning", "rapidLongitudinalPeakThreshold must be greater than or equal to rapidLongitudinalMeanThreshold");
+	if (tuning.turnYawThreshold <= tuning.turnExitYawThreshold) throwLoggedRangeError("resolveDrivingStatusTuning", "turnYawThreshold must be greater than turnExitYawThreshold");
 	dialSdkDebugWarn(DEBUG_MODULE$5, "resolveDrivingStatusTuning", "returned", { tuning });
 	return tuning;
 };
-const extractDrivingSnapshotMetrics = (info, tuning = DEFAULT_DRIVING_STATUS_TUNING) => {
+const extractDrivingSnapshotMetrics = (info, tuning = DEFAULT_DRIVING_STATUS_TUNING, correction = {}) => {
 	dialSdkDebugWarn(DEBUG_MODULE$5, "extractDrivingSnapshotMetrics", "called", {
 		info,
-		tuning
+		tuning,
+		correction
 	});
 	if (!info || !Number.isFinite(info.capturedAtMs)) {
 		dialSdkDebugWarn(DEBUG_MODULE$5, "extractDrivingSnapshotMetrics", "returned invalid capture time", { info });
@@ -140,149 +202,164 @@ const extractDrivingSnapshotMetrics = (info, tuning = DEFAULT_DRIVING_STATUS_TUN
 	}
 	const linearAcceleration = availableFreshVector(info.linearAcceleration, info.capturedAtMs, tuning.maxSampleAgeMs);
 	const gyroscope = availableFreshVector(info.gyroscope, info.capturedAtMs, tuning.maxSampleAgeMs);
-	if (linearAcceleration === null || gyroscope === null) {
+	const gravityMetric = availableFreshVector(info.gravity, info.capturedAtMs, tuning.maxSampleAgeMs);
+	const gravity = availableCorrectedGravity(correction, info.capturedAtMs, tuning.maxSampleAgeMs) ?? (correction.filteredGravity !== void 0 && gravityMetric !== null ? {
+		value: correction.filteredGravity,
+		sampledAtMs: gravityMetric.sampledAtMs
+	} : gravityMetric);
+	if (linearAcceleration === null || gyroscope === null || gravity === null) {
 		dialSdkDebugWarn(DEBUG_MODULE$5, "extractDrivingSnapshotMetrics", "returned unavailable vectors", {
 			linearAcceleration,
-			gyroscope
+			gyroscope,
+			gravity
 		});
 		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) {
-		dialSdkDebugWarn(DEBUG_MODULE$5, "extractDrivingSnapshotMetrics", "returned unavailable motion intensity", { motionIntensity: info.motionIntensity });
+	const frame = buildVehicleFrame(gravity.value, tuning.vehicleRightMinimumNorm);
+	if (frame === null) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "extractDrivingSnapshotMetrics", "returned invalid vehicle frame", {
+			gravity: gravity.value,
+			vehicleRightMinimumNorm: tuning.vehicleRightMinimumNorm
+		});
 		return null;
 	}
+	const correctedLinear = subtract(linearAcceleration.value, correction.linearAccelerationBias ?? ZERO_VECTOR$1);
+	const correctedGyroscope = subtract(gyroscope.value, correction.gyroscopeBias ?? ZERO_VECTOR$1);
 	const result = {
 		capturedAtMs: info.capturedAtMs,
-		longitudinal,
-		lateral,
-		yaw,
-		motionIntensity,
-		gyroMagnitude: vectorMagnitude(gyroscope)
+		linearAccelerationSampledAtMs: linearAcceleration.sampledAtMs,
+		gyroscopeSampledAtMs: gyroscope.sampledAtMs,
+		gravitySampledAtMs: gravity.sampledAtMs,
+		longitudinal: dot(correctedLinear, frame.forward),
+		lateral: dot(correctedLinear, frame.right),
+		vertical: dot(correctedLinear, frame.up),
+		yaw: dot(correctedGyroscope, frame.up),
+		gyroMagnitude: magnitude(correctedGyroscope),
+		rawGyroMagnitude: magnitude(gyroscope.value),
+		rawLinearAcceleration: linearAcceleration.value,
+		rawGyroscope: gyroscope.value,
+		frame
 	};
 	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 buildVehicleFrame = (gravity, rightMinimumNorm = DEFAULT_DRIVING_STATUS_TUNING.vehicleRightMinimumNorm) => {
+	dialSdkDebugWarn(DEBUG_MODULE$5, "buildVehicleFrame", "called", {
+		gravity,
+		rightMinimumNorm
 	});
-	const { longitudinal, lateral, yaw, motionIntensity, gyroMagnitude } = metrics;
-	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;
+	const gravityDirection = normalize(gravity);
+	if (gravityDirection === null) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "buildVehicleFrame", "returned invalid gravity", { result: null });
+		return null;
 	}
-	if (longitudinal <= -tuning.longitudinalThreshold) {
-		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", { result: "BRAKING" });
-		return "BRAKING";
+	const up = gravityDirection;
+	const projectedRight = subtract(DEVICE_RIGHT, scale(up, dot(DEVICE_RIGHT, up)));
+	if (magnitude(projectedRight) < rightMinimumNorm) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "buildVehicleFrame", "returned degenerate right axis", { result: null });
+		return null;
 	}
-	if (longitudinal >= tuning.longitudinalThreshold) {
-		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", { result: "ACCELERATION" });
-		return "ACCELERATION";
+	const right = normalize(projectedRight);
+	if (right === null) {
+		dialSdkDebugWarn(DEBUG_MODULE$5, "buildVehicleFrame", "returned invalid right axis", { result: null });
+		return null;
 	}
-	if (motionIntensity < tuning.drivingMotionThreshold && gyroMagnitude <= tuning.stoppedGyroThreshold) {
-		dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", { result: "STOPPED" });
-		return "STOPPED";
+	const forward = normalize(cross(right, up));
+	const result = forward === null ? null : {
+		up,
+		right,
+		forward
+	};
+	dialSdkDebugWarn(DEBUG_MODULE$5, "buildVehicleFrame", "returned", { result });
+	return result;
+};
+const classifyInstantaneousEvidence = (metrics, tuning) => {
+	const longitudinalMagnitude = Math.abs(metrics.longitudinal);
+	if (longitudinalMagnitude >= tuning.rapidLongitudinalPeakThreshold) {
+		if (Math.abs(metrics.vertical) > longitudinalMagnitude * tuning.verticalBumpRatio) return {
+			candidateStatus: null,
+			rejectionReason: "vertical_bump"
+		};
+		return {
+			candidateStatus: metrics.longitudinal > 0 ? "RAPID_ACCELERATION" : "SUDDEN_BRAKING",
+			rejectionReason: null
+		};
 	}
-	dialSdkDebugWarn(DEBUG_MODULE$5, "classifyDrivingMetrics", "returned", { result: "STEADY_DRIVING" });
-	return "STEADY_DRIVING";
+	if (Math.abs(metrics.yaw) >= tuning.turnYawThreshold) return {
+		candidateStatus: metrics.yaw > 0 ? "LEFT_TURN" : "RIGHT_TURN",
+		rejectionReason: null
+	};
+	if (longitudinalMagnitude >= tuning.longitudinalThreshold) return {
+		candidateStatus: metrics.longitudinal > 0 ? "ACCELERATION" : "BRAKING",
+		rejectionReason: null
+	};
+	return {
+		candidateStatus: null,
+		rejectionReason: null
+	};
 };
 const availableFreshVector = (metric, capturedAtMs, maxSampleAgeMs) => {
-	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;
-	}
+	if (!metric?.available || !isFresh(metric.sampledAtMs, capturedAtMs, maxSampleAgeMs)) return null;
 	const { x, y, z } = metric.value;
-	const result = [
+	return [
 		x,
 		y,
 		z
-	].every(Number.isFinite) ? metric.value : null;
-	dialSdkDebugWarn(DEBUG_MODULE$5, "availableFreshVector", "returned", { result });
-	return result;
-};
-const availableFreshNumber = (metric, capturedAtMs, maxSampleAgeMs) => {
-	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;
+	].every(Number.isFinite) ? {
+		value: metric.value,
+		sampledAtMs: metric.sampledAtMs
+	} : null;
+};
+const availableCorrectedGravity = (correction, capturedAtMs, maxSampleAgeMs) => {
+	const { filteredGravity, filteredGravitySampledAtMs } = correction;
+	if (filteredGravity === void 0 || filteredGravitySampledAtMs === void 0 || !isFresh(filteredGravitySampledAtMs, capturedAtMs, maxSampleAgeMs)) return null;
+	const { x, y, z } = filteredGravity;
+	return [
+		x,
+		y,
+		z
+	].every(Number.isFinite) ? {
+		value: filteredGravity,
+		sampledAtMs: filteredGravitySampledAtMs
+	} : null;
 };
 const isFresh = (sampledAtMs, capturedAtMs, maxSampleAgeMs) => {
-	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;
-	}
+	if (sampledAtMs === null || !Number.isFinite(sampledAtMs)) return false;
 	const age = capturedAtMs - sampledAtMs;
-	const result = age >= 0 && age <= maxSampleAgeMs;
-	dialSdkDebugWarn(DEBUG_MODULE$5, "isFresh", "returned", {
-		age,
-		result
-	});
-	return result;
+	return age >= 0 && age <= maxSampleAgeMs;
 };
-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 dot = (left, right) => left.x * right.x + left.y * right.y + left.z * right.z;
+const cross = (left, right) => ({
+	x: left.y * right.z - left.z * right.y,
+	y: left.z * right.x - left.x * right.z,
+	z: left.x * right.y - left.y * right.x
+});
+const subtract = (left, right) => ({
+	x: left.x - right.x,
+	y: left.y - right.y,
+	z: left.z - right.z
+});
+const scale = (value, factor) => ({
+	x: value.x * factor,
+	y: value.y * factor,
+	z: value.z * factor
+});
+const magnitude = (value) => Math.hypot(value.x, value.y, value.z);
+const normalize = (value) => {
+	const length = magnitude(value);
+	return Number.isFinite(length) && length > Number.EPSILON ? scale(value, 1 / length) : null;
 };
 const assertPositiveFinite = (name, value) => {
-	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");
+};
+const throwLoggedRangeError = (scope, message) => {
+	const error = new RangeError(message);
+	dialSdkDebugWarn(DEBUG_MODULE$5, scope, "threw", error);
+	throw error;
 };
 //#endregion
 //#region src/sensor/unified_info.ts
@@ -1272,6 +1349,11 @@ const safeInvoke = (callback) => {
 //#endregion
 //#region src/sensor/driving_status_controller.ts
 const DEBUG_MODULE$1 = "driving_status_controller.ts";
+const ZERO_VECTOR = {
+	x: 0,
+	y: 0,
+	z: 0
+};
 const createDrivingStatusController = (options = {}) => {
 	dialSdkDebugWarn(DEBUG_MODULE$1, "createDrivingStatusController", "called", { options });
 	const result = new DefaultDrivingStatusController(options);
@@ -1281,14 +1363,42 @@ const createDrivingStatusController = (options = {}) => {
 var DefaultDrivingStatusController = class {
 	constructor(options) {
 		this.listeners = /* @__PURE__ */ new Set();
-		this.metricWindow = [];
+		this.longitudinalWindow = [];
+		this.yawWindow = [];
 		this.motionWindow = [];
 		this.candidate = null;
-		this.candidateConfirmationCount = 0;
+		this.candidateSinceMs = null;
 		this.lastAvailableAtMs = null;
 		this.unavailableSinceMs = null;
 		this.fallbackApplied = false;
-		this.heldCandidate = null;
+		this.filteredGravity = null;
+		this.lastGravitySampledAtMs = null;
+		this.linearAccelerationBias = { ...ZERO_VECTOR };
+		this.gyroscopeBias = { ...ZERO_VECTOR };
+		this.biasCalibrated = false;
+		this.lastBiasSampledAtMs = null;
+		this.stoppedConditionSinceMs = null;
+		this.drivingConditionSinceMs = null;
+		this.stationaryConfirmed = false;
+		this.urgentStatus = null;
+		this.urgentStartedAtMs = null;
+		this.normalLongitudinalStatus = null;
+		this.longitudinalClearSinceMs = null;
+		this.turnStatus = null;
+		this.turnQuietSinceMs = null;
+		this.oppositeTurnSinceMs = null;
+		this.detectorCandidates = {
+			base: null,
+			rapid_longitudinal: null,
+			longitudinal: null,
+			turn: null
+		};
+		this.detectorRejections = {
+			base: null,
+			rapid_longitudinal: null,
+			longitudinal: null,
+			turn: null
+		};
 		this.requestedRunning = false;
 		this.polling = false;
 		this.lifecycleSuspended = false;
@@ -1297,12 +1407,12 @@ var DefaultDrivingStatusController = class {
 		this.pendingRead = null;
 		this.unsubscribePageLifecycle = null;
 		this.handleLifecyclePause = () => {
-			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecyclePause", "called", {
-				requestedRunning: this.requestedRunning,
-				lifecycleSuspended: this.lifecycleSuspended
-			});
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecyclePause", "called");
 			if (!this.requestedRunning || this.lifecycleSuspended) {
-				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecyclePause", "ignored");
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecyclePause", "ignored", {
+					requestedRunning: this.requestedRunning,
+					lifecycleSuspended: this.lifecycleSuspended
+				});
 				return;
 			}
 			this.lifecycleSuspended = true;
@@ -1311,13 +1421,15 @@ var DefaultDrivingStatusController = class {
 			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecyclePause", "returned");
 		};
 		this.handleLifecycleResume = () => {
-			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");
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecycleResume", "called");
+			const pageHidden = this.requestedRunning && this.lifecycleSuspended && !this.destroyed ? isDrivingPageHidden() : false;
+			if (!this.requestedRunning || !this.lifecycleSuspended || this.destroyed || pageHidden) {
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.handleLifecycleResume", "ignored", {
+					requestedRunning: this.requestedRunning,
+					lifecycleSuspended: this.lifecycleSuspended,
+					destroyed: this.destroyed,
+					pageHidden
+				});
 				return;
 			}
 			this.lifecycleSuspended = false;
@@ -1333,18 +1445,15 @@ var DefaultDrivingStatusController = class {
 		this.onDiagnostic = options.onDiagnostic;
 		this.managePageLifecycle = options.managePageLifecycle ?? true;
 		const initialStatus = options.initialStatus ?? "STOPPED";
-		if (!CAR_RUNNING_STATUSES.includes(initialStatus)) throw new TypeError(`Unsupported initialStatus: ${initialStatus}`);
+		if (!CAR_RUNNING_STATUSES.includes(initialStatus)) {
+			const error = /* @__PURE__ */ new TypeError(`Unsupported initialStatus: ${initialStatus}`);
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.constructor", "threw", error);
+			throw error;
+		}
 		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
-		});
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.constructor", "created", this.getSnapshot());
 	}
 	start() {
 		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.start", "called", this.getSnapshot());
@@ -1389,16 +1498,17 @@ var DefaultDrivingStatusController = class {
 		}
 		this.destroyed = true;
 		this.listeners.clear();
-		this.metricWindow.length = 0;
-		this.motionWindow.length = 0;
+		this.resetTransientRecognition();
 		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.destroy", "returned", this.getSnapshot());
 	}
 	getSnapshot() {
 		const result = {
 			lifecycle: this.destroyed ? "destroyed" : this.polling ? "running" : "stopped",
 			status: this.status,
+			baseStatus: this.baseStatus,
+			activeTurn: this.turnStatus,
 			candidate: this.candidate,
-			candidateConfirmationCount: this.candidateConfirmationCount,
+			candidateSinceMs: this.candidateSinceMs,
 			statusCommittedAtMs: this.statusCommittedAtMs,
 			lastAvailableAtMs: this.lastAvailableAtMs,
 			unavailableSinceMs: this.unavailableSinceMs,
@@ -1409,16 +1519,16 @@ var DefaultDrivingStatusController = class {
 	}
 	subscribe(listener) {
 		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.subscribe", "called", {
-			destroyed: this.destroyed,
-			listenerCount: this.listeners.size
+			listener,
+			destroyed: this.destroyed
 		});
 		if (this.destroyed) {
-			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.subscribe", "returned noop");
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.subscribe", "ignored destroyed controller");
 			return noop;
 		}
 		this.listeners.add(listener);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.subscribe", "returned", { listenerCount: this.listeners.size });
 		let subscribed = true;
-		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.subscribe", "subscribed", { listenerCount: this.listeners.size });
 		return () => {
 			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.unsubscribe", "called", { subscribed });
 			if (!subscribed) {
@@ -1431,15 +1541,14 @@ var DefaultDrivingStatusController = class {
 		};
 	}
 	activatePolling() {
-		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.activatePolling", "called", {
-			destroyed: this.destroyed,
-			polling: this.polling,
-			requestedRunning: this.requestedRunning,
-			lifecycleSuspended: this.lifecycleSuspended,
-			generation: this.generation
-		});
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.activatePolling", "called");
 		if (this.destroyed || this.polling || !this.requestedRunning || this.lifecycleSuspended) {
-			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.activatePolling", "ignored");
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.activatePolling", "ignored", {
+				destroyed: this.destroyed,
+				polling: this.polling,
+				requestedRunning: this.requestedRunning,
+				lifecycleSuspended: this.lifecycleSuspended
+			});
 			return;
 		}
 		this.polling = true;
@@ -1449,14 +1558,10 @@ var DefaultDrivingStatusController = class {
 	}
 	deactivatePolling() {
 		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.deactivatePolling", "called", {
-			polling: this.polling,
-			timer: this.timer,
+			generation: this.generation,
+			hasTimer: this.timer !== void 0,
 			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) {
@@ -1468,72 +1573,110 @@ var DefaultDrivingStatusController = class {
 		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.deactivatePolling", "returned", { generation: this.generation });
 	}
 	schedulePoll(delayMs, generation) {
-		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;
-		}
+		if (!this.polling || generation !== this.generation || this.timer !== void 0) 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) {
-		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "called", {
-			generation,
-			currentGeneration: this.generation,
-			polling: this.polling,
-			hasPendingRead: this.pendingRead !== null
-		});
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "called", { generation });
 		if (!this.polling || generation !== this.generation || this.pendingRead !== null) {
-			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "ignored");
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "ignored", {
+				polling: this.polling,
+				generation,
+				currentGeneration: this.generation,
+				hasPendingRead: this.pendingRead !== null
+			});
 			return;
 		}
 		const pendingRead = new AbortController();
 		this.pendingRead = pendingRead;
 		try {
 			const payload = await this.sensorProvider(pendingRead.signal);
-			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");
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "discarded provider result", {
+					generation,
+					currentGeneration: this.generation,
+					polling: this.polling,
+					aborted: pendingRead.signal.aborted
+				});
 				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);
+			const gravity = this.resolveGravityFrame(payload);
+			const metrics = gravity === null ? null : extractDrivingSnapshotMetrics(payload, this.tuning, {
+				filteredGravity: gravity.value,
+				filteredGravitySampledAtMs: gravity.sampledAtMs,
+				linearAccelerationBias: this.linearAccelerationBias,
+				gyroscopeBias: this.gyroscopeBias
+			});
+			const accelerometerSample = extractFreshVectorMetric(payload.accelerometer, payload.capturedAtMs, this.tuning.maxSampleAgeMs);
+			if (gravity === null || metrics === null || accelerometerSample === null) {
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "invalid or stale snapshot", {
+					metrics,
+					accelerometerSample
+				});
+				this.processUnavailable("invalid_or_stale_snapshot");
+			} else {
+				this.processAvailable(metrics, accelerometerSample, gravity);
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "processed sample", { capturedAtMs: metrics.capturedAtMs });
+			}
 		} catch (error) {
-			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");
+				dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "ignored provider error", { error });
 				return;
 			}
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.poll", "caught provider error", { error });
 			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
+				polling: this.polling
 			});
 		}
 	}
-	processAvailable(rawMetrics, accelerometerSample) {
+	resolveGravityFrame(info) {
+		const sample = extractFreshVectorMetric(info.gravity, info.capturedAtMs, this.tuning.maxSampleAgeMs);
+		if (sample === null) {
+			if (this.filteredGravity === null || this.lastGravitySampledAtMs === null) return null;
+			const ageMs = info.capturedAtMs - this.lastGravitySampledAtMs;
+			return ageMs >= 0 && ageMs <= this.tuning.maxSampleAgeMs ? {
+				value: this.filteredGravity,
+				sampledAtMs: this.lastGravitySampledAtMs,
+				source: "cached"
+			} : null;
+		}
+		if (sample.sampledAtMs === this.lastGravitySampledAtMs && this.filteredGravity !== null) return {
+			value: this.filteredGravity,
+			sampledAtMs: sample.sampledAtMs,
+			source: "live"
+		};
+		if (this.filteredGravity === null || this.lastGravitySampledAtMs === null) this.filteredGravity = { ...sample.value };
+		else {
+			if (sample.sampledAtMs < this.lastGravitySampledAtMs) {
+				const ageMs = info.capturedAtMs - this.lastGravitySampledAtMs;
+				return ageMs >= 0 && ageMs <= this.tuning.maxSampleAgeMs ? {
+					value: this.filteredGravity,
+					sampledAtMs: this.lastGravitySampledAtMs,
+					source: "cached"
+				} : null;
+			}
+			const elapsedMs = Math.max(0, sample.sampledAtMs - this.lastGravitySampledAtMs);
+			const alpha = 1 - Math.exp(-elapsedMs / this.tuning.gravityFilterTimeConstantMs);
+			this.filteredGravity = lerpVector(this.filteredGravity, sample.value, alpha);
+		}
+		this.lastGravitySampledAtMs = sample.sampledAtMs;
+		return {
+			value: this.filteredGravity,
+			sampledAtMs: sample.sampledAtMs,
+			source: "live"
+		};
+	}
+	processAvailable(metrics, accelerometerSample, gravity) {
 		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processAvailable", "called", {
-			rawMetrics,
+			metrics,
 			accelerometerSample
 		});
 		const now = this.clock.now();
@@ -1543,56 +1686,211 @@ var DefaultDrivingStatusController = class {
 		this.emitDiagnostic({
 			type: "sample_available",
 			atMs: now,
-			capturedAtMs: rawMetrics.capturedAtMs,
+			capturedAtMs: metrics.capturedAtMs,
+			frameSource: gravity.source,
+			frameAgeMs: metrics.capturedAtMs - gravity.sampledAtMs,
 			tuningVersion: this.tuning.version
 		});
-		this.metricWindow.push(rawMetrics);
-		while (this.metricWindow.length > Math.floor(this.tuning.smoothingWindowSize)) this.metricWindow.shift();
-		const smoothedMetrics = averageMetrics(this.metricWindow);
-		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()
+		const addedLongitudinal = pushUniqueMetric(this.longitudinalWindow, metrics, "linearAccelerationSampledAtMs", Math.max(this.tuning.longitudinalWindowMs, this.tuning.rapidLongitudinalWindowMs));
+		const addedYaw = pushUniqueMetric(this.yawWindow, metrics, "gyroscopeSampledAtMs", Math.max(this.tuning.turnWindowMs, this.tuning.turnClosureWindowMs));
+		const addedMotion = pushUniqueVector(this.motionWindow, accelerometerSample, this.tuning.motionWindowMs);
+		if (!addedLongitudinal && !addedYaw && !addedMotion) {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processAvailable", "ignored duplicate sample");
+			return;
+		}
+		const motionMad = calculateCombinedAxisMad(this.motionWindow, this.tuning.motionMinimumSamples);
+		const previousBaseStatus = this.baseStatus;
+		const previousUrgentStatus = this.urgentStatus;
+		const previousLongitudinalStatus = this.normalLongitudinalStatus;
+		const previousTurnStatus = this.turnStatus;
+		const baseCondition = this.updateBaseDetector(motionMad, metrics, accelerometerSample.sampledAtMs, addedMotion);
+		const longitudinalEvidence = detectLongitudinalEvidence(this.longitudinalWindow, this.tuning);
+		if (addedLongitudinal) this.updateLongitudinalDetector(longitudinalEvidence, metrics.linearAccelerationSampledAtMs);
+		const turnEvidence = detectTurnEvidence(this.yawWindow, this.tuning);
+		if (addedYaw) this.updateTurnDetector(turnEvidence);
+		if (this.urgentStatus !== null || this.turnStatus !== null || this.normalLongitudinalStatus !== null) {
+			this.baseStatus = "STEADY_DRIVING";
+			this.stoppedConditionSinceMs = null;
+			this.stationaryConfirmed = false;
+		}
+		if (this.stationaryConfirmed) this.updateBias(metrics);
+		const statistics = {
+			base: {
+				sampleCount: this.motionWindow.length,
+				durationMs: vectorWindowDuration(this.motionWindow),
+				motionMad,
+				gyroMagnitude: metrics.gyroMagnitude,
+				rawGyroMagnitude: metrics.rawGyroMagnitude
+			},
+			longitudinal: longitudinalEvidence.normalStatistics,
+			rapidLongitudinal: longitudinalEvidence.rapidStatistics,
+			turn: turnEvidence.statistics
+		};
+		const baseCandidate = baseCondition === "stationary" ? "STOPPED" : baseCondition === "moving" ? "STEADY_DRIVING" : null;
+		this.updateDetectorCandidate("base", baseCandidate, null, statistics, now);
+		this.updateDetectorCandidate("rapid_longitudinal", longitudinalEvidence.rapidCandidate, longitudinalEvidence.rejectionReason, statistics, now);
+		this.updateDetectorCandidate("longitudinal", longitudinalEvidence.normalCandidate, null, statistics, now);
+		this.updateDetectorCandidate("turn", turnEvidence.candidate, turnEvidence.rejectionReason, statistics, now);
+		this.emitDetectorConfirmation("base", previousBaseStatus, this.baseStatus, statistics, now);
+		this.emitDetectorConfirmation("rapid_longitudinal", previousUrgentStatus, this.urgentStatus, statistics, now);
+		this.emitDetectorConfirmation("longitudinal", previousLongitudinalStatus, this.normalLongitudinalStatus, statistics, now);
+		this.emitDetectorConfirmation("turn", previousTurnStatus, this.turnStatus, statistics, now);
+		const pendingCandidate = instantaneousCandidate(metrics, this.tuning);
+		this.setCandidate(pendingCandidate === this.status ? null : pendingCandidate, observationTime(metrics));
+		this.emitDiagnostic({
+			type: "detector_evidence",
+			atMs: now,
+			motionMad,
+			baseCondition,
+			rapidCandidate: longitudinalEvidence.rapidCandidate,
+			longitudinalCandidate: longitudinalEvidence.normalCandidate,
+			turnCandidate: turnEvidence.candidate,
+			rejectionReason: longitudinalEvidence.rejectionReason ?? turnEvidence.rejectionReason,
+			frameSource: gravity.source,
+			frameAgeMs: metrics.capturedAtMs - gravity.sampledAtMs,
+			statistics,
+			tuningVersion: this.tuning.version
 		});
+		const hasAction = this.urgentStatus !== null || this.turnStatus !== null || this.normalLongitudinalStatus !== null;
+		if (motionMad !== null || hasAction) this.commitSelectedStatus(now);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processAvailable", "returned", {
+			motionMad,
+			baseCondition,
+			status: this.status,
+			baseStatus: this.baseStatus,
+			urgentStatus: this.urgentStatus,
+			turnStatus: this.turnStatus,
+			normalLongitudinalStatus: this.normalLongitudinalStatus
+		});
+	}
+	updateBaseDetector(motionMad, metrics, sampledAtMs, isNewMotionSample) {
+		if (motionMad === null || !isNewMotionSample) return "warming_up";
+		const gyroForStop = this.biasCalibrated ? metrics.gyroMagnitude : metrics.rawGyroMagnitude;
+		const stoppedGyroThreshold = this.biasCalibrated ? this.tuning.stoppedGyroThreshold : this.tuning.stoppedRawGyroThreshold;
+		const drivingGyroThreshold = this.biasCalibrated ? this.tuning.drivingGyroThreshold : this.tuning.drivingRawGyroThreshold;
+		const stationary = motionMad <= this.tuning.stoppedMotionThreshold && gyroForStop <= stoppedGyroThreshold;
+		const moving = motionMad >= this.tuning.drivingMotionThreshold || gyroForStop >= drivingGyroThreshold;
+		if (stationary) {
+			this.drivingConditionSinceMs = null;
+			if (this.stoppedConditionSinceMs === null) this.stoppedConditionSinceMs = this.motionWindow[0]?.sampledAtMs ?? sampledAtMs;
+			if (sampledAtMs - this.stoppedConditionSinceMs >= this.tuning.stoppedConfirmationMs) {
+				this.baseStatus = "STOPPED";
+				this.stationaryConfirmed = true;
+			}
+			return "stationary";
+		}
+		this.stoppedConditionSinceMs = null;
+		this.stationaryConfirmed = false;
+		if (moving) {
+			if (this.drivingConditionSinceMs === null) this.drivingConditionSinceMs = this.motionWindow[0]?.sampledAtMs ?? sampledAtMs;
+			if (sampledAtMs - this.drivingConditionSinceMs >= this.tuning.drivingConfirmationMs) this.baseStatus = "STEADY_DRIVING";
+			return "moving";
+		}
+		this.drivingConditionSinceMs = null;
+		return "hysteresis";
+	}
+	updateLongitudinalDetector(evidence, sampledAtMs) {
+		if (evidence.rapidCandidate !== null) {
+			if (this.urgentStatus !== evidence.rapidCandidate) {
+				this.urgentStatus = evidence.rapidCandidate;
+				this.urgentStartedAtMs = sampledAtMs;
+			}
+		} else if (this.urgentStatus !== null && this.urgentStartedAtMs !== null && sampledAtMs - this.urgentStartedAtMs >= this.tuning.rapidMinimumDisplayMs) {
+			this.urgentStatus = null;
+			this.urgentStartedAtMs = null;
+		}
+		if (evidence.normalCandidate !== null) {
+			this.normalLongitudinalStatus = evidence.normalCandidate;
+			this.longitudinalClearSinceMs = null;
+		} else if (this.normalLongitudinalStatus !== null) if (evidence.retainedNormal) this.longitudinalClearSinceMs = null;
+		else {
+			if (this.longitudinalClearSinceMs === null) this.longitudinalClearSinceMs = sampledAtMs;
+			if (sampledAtMs - this.longitudinalClearSinceMs >= this.tuning.longitudinalReleaseMs) {
+				this.normalLongitudinalStatus = null;
+				this.longitudinalClearSinceMs = null;
+			}
+		}
 	}
-	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);
+	updateTurnDetector(evidence) {
+		if (this.turnStatus === null) {
+			if (evidence.candidate !== null) this.turnStatus = evidence.candidate;
+			this.turnQuietSinceMs = null;
+			this.oppositeTurnSinceMs = null;
+			return;
 		}
-		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) {
-			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.recordMotionSample", "returned warmup", {
-				result: null,
-				motionWindow: this.motionWindow
-			});
-			return null;
+		const direction = evidence.latestYaw > 0 ? "LEFT_TURN" : "RIGHT_TURN";
+		if (!(Math.abs(evidence.latestYaw) >= this.tuning.turnExitYawThreshold)) {
+			this.oppositeTurnSinceMs = null;
+			if (this.turnQuietSinceMs === null) this.turnQuietSinceMs = evidence.sampledAtMs;
+			if (evidence.sampledAtMs - this.turnQuietSinceMs >= this.tuning.turnExitConfirmationMs) {
+				this.turnStatus = null;
+				this.turnQuietSinceMs = null;
+				this.yawWindow.length = 0;
+			}
+			return;
 		}
-		const result = combinedAxisStandardDeviation(this.motionWindow);
-		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.recordMotionSample", "returned", {
-			result,
-			motionWindow: this.motionWindow
+		this.turnQuietSinceMs = null;
+		if (direction === this.turnStatus) {
+			this.oppositeTurnSinceMs = null;
+			return;
+		}
+		if (this.oppositeTurnSinceMs === null) this.oppositeTurnSinceMs = evidence.sampledAtMs;
+		if (evidence.sampledAtMs - this.oppositeTurnSinceMs >= this.tuning.turnClosureWindowMs) {
+			this.turnStatus = direction;
+			this.oppositeTurnSinceMs = null;
+		}
+	}
+	updateBias(metrics) {
+		const sampledAtMs = Math.min(metrics.linearAccelerationSampledAtMs, metrics.gyroscopeSampledAtMs);
+		if (sampledAtMs === this.lastBiasSampledAtMs) return;
+		if (this.lastBiasSampledAtMs !== null && sampledAtMs < this.lastBiasSampledAtMs) return;
+		if (!this.biasCalibrated || this.lastBiasSampledAtMs === null) {
+			this.linearAccelerationBias = { ...metrics.rawLinearAcceleration };
+			this.gyroscopeBias = { ...metrics.rawGyroscope };
+			this.biasCalibrated = true;
+		} else {
+			const elapsedMs = Math.max(0, sampledAtMs - this.lastBiasSampledAtMs);
+			const alpha = 1 - Math.exp(-elapsedMs / this.tuning.biasFilterTimeConstantMs);
+			this.linearAccelerationBias = lerpVector(this.linearAccelerationBias, metrics.rawLinearAcceleration, alpha);
+			this.gyroscopeBias = lerpVector(this.gyroscopeBias, metrics.rawGyroscope, alpha);
+		}
+		this.lastBiasSampledAtMs = sampledAtMs;
+	}
+	updateDetectorCandidate(detector, candidate, rejectionReason, statistics, atMs) {
+		const previousCandidate = this.detectorCandidates[detector];
+		if (previousCandidate !== candidate) {
+			if (previousCandidate !== null) this.emitDetectorTransition(detector, "candidate_exited", previousCandidate, null, statistics, atMs);
+			if (candidate !== null) this.emitDetectorTransition(detector, "candidate_entered", candidate, null, statistics, atMs);
+			this.detectorCandidates[detector] = candidate;
+		}
+		if (rejectionReason !== null && rejectionReason !== this.detectorRejections[detector]) this.emitDetectorTransition(detector, "candidate_rejected", null, rejectionReason, statistics, atMs);
+		this.detectorRejections[detector] = rejectionReason;
+	}
+	emitDetectorConfirmation(detector, previousStatus, status, statistics, atMs) {
+		if (status !== null && status !== previousStatus) this.emitDetectorTransition(detector, "candidate_confirmed", status, null, statistics, atMs);
+	}
+	emitDetectorTransition(detector, phase, status, rejectionReason, statistics, atMs) {
+		this.emitDiagnostic({
+			type: "detector_transition",
+			atMs,
+			detector,
+			phase,
+			status,
+			rejectionReason,
+			statistics,
+			tuningVersion: this.tuning.version
 		});
-		return result;
+	}
+	commitSelectedStatus(now) {
+		const selected = this.urgentStatus ?? this.turnStatus ?? this.normalLongitudinalStatus ?? this.baseStatus;
+		this.commit(selected, now, "candidate_confirmed");
 	}
 	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);
-		this.metricWindow.length = 0;
-		this.motionWindow.length = 0;
+		this.clearRecognitionWindows();
 		this.setCandidate(null, now);
 		this.emitDiagnostic({
 			type: "sample_unavailable",
@@ -1602,97 +1900,39 @@ var DefaultDrivingStatusController = class {
 			tuningVersion: this.tuning.version
 		});
 		if (unavailableForMs < this.unavailableFallbackMs || this.fallbackApplied) {
-			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processUnavailable", "returned while holding", {
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processUnavailable", "holding previous status", {
+				category,
 				unavailableForMs,
 				fallbackApplied: this.fallbackApplied
 			});
 			return;
 		}
 		this.fallbackApplied = true;
+		this.baseStatus = "STOPPED";
 		this.emitDiagnostic({
 			type: "fallback_to_stopped",
 			atMs: now,
 			unavailableForMs,
 			tuningVersion: this.tuning.version
 		});
-		this.commit("STOPPED", now, "unavailable_fallback", true);
-		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processUnavailable", "returned after fallback", {
+		this.commit("STOPPED", now, "unavailable_fallback");
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processUnavailable", "returned 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
+			status: this.status
 		});
-		if (nextCandidate === this.status) {
-			this.setCandidate(null, now);
-			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processCandidate", "returned current status");
-			return;
-		}
-		if (nextCandidate !== this.candidate) {
-			this.setCandidate(nextCandidate, now);
-			this.candidateConfirmationCount = 1;
-			this.heldCandidate = null;
-		} else this.candidateConfirmationCount += 1;
-		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];
-		if (remainingMs > 0 && !canPreempt) {
-			if (this.heldCandidate !== nextCandidate) {
-				this.heldCandidate = nextCandidate;
-				this.emitDiagnostic({
-					type: "status_held_by_min_duration",
-					atMs: now,
-					status: this.status,
-					candidate: nextCandidate,
-					remainingMs,
-					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) {
-		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;
-		}
+	commit(nextStatus, now, reason) {
 		if (nextStatus === this.status) {
-			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.commit", "ignored forced unchanged status");
+			dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.commit", "ignored unchanged status", {
+				status: this.status,
+				reason
+			});
 			return;
 		}
 		const previousStatus = this.status;
 		this.status = nextStatus;
-		if (isBaseStatus(nextStatus)) this.baseStatus = nextStatus;
 		this.statusCommittedAtMs = now;
 		this.setCandidate(null, now);
-		this.heldCandidate = null;
 		const event = {
 			type: "status_changed",
 			status: nextStatus,
@@ -1709,53 +1949,53 @@ var DefaultDrivingStatusController = class {
 			reason,
 			tuningVersion: this.tuning.version
 		});
-		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.commit", "returned", {
-			event,
-			listenerCount: this.listeners.size,
-			snapshot: this.getSnapshot()
-		});
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.commit", "status changed", { event });
 	}
-	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;
-		}
+	setCandidate(candidate, atMs) {
+		if (candidate === this.candidate) return;
 		const previousCandidate = this.candidate;
 		this.candidate = candidate;
-		this.candidateConfirmationCount = 0;
-		this.heldCandidate = null;
+		this.candidateSinceMs = candidate === null ? null : atMs;
 		this.emitDiagnostic({
 			type: "candidate_changed",
-			atMs: now,
+			atMs: this.clock.now(),
 			candidate,
 			previousCandidate,
 			tuningVersion: this.tuning.version
 		});
-		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.setCandidate", "returned", {
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.setCandidate", "candidate changed", {
 			candidate,
-			previousCandidate
+			previousCandidate,
+			candidateSinceMs: this.candidateSinceMs
 		});
 	}
-	resetTransientRecognition() {
-		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.resetTransientRecognition", "called", {
-			metricWindow: this.metricWindow,
-			motionWindow: this.motionWindow,
-			candidate: this.candidate
-		});
-		this.metricWindow.length = 0;
+	clearRecognitionWindows() {
+		this.longitudinalWindow.length = 0;
+		this.yawWindow.length = 0;
 		this.motionWindow.length = 0;
+		this.stoppedConditionSinceMs = null;
+		this.drivingConditionSinceMs = null;
+		this.stationaryConfirmed = false;
+		this.urgentStatus = null;
+		this.urgentStartedAtMs = null;
+		this.normalLongitudinalStatus = null;
+		this.longitudinalClearSinceMs = null;
+		this.turnStatus = null;
+		this.turnQuietSinceMs = null;
+		this.oppositeTurnSinceMs = null;
+		for (const detector of Object.keys(this.detectorCandidates)) {
+			this.detectorCandidates[detector] = null;
+			this.detectorRejections[detector] = null;
+		}
+	}
+	resetTransientRecognition() {
+		this.clearRecognitionWindows();
 		this.candidate = null;
-		this.candidateConfirmationCount = 0;
+		this.candidateSinceMs = null;
 		this.unavailableSinceMs = null;
 		this.fallbackApplied = false;
-		this.heldCandidate = null;
-		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.resetTransientRecognition", "returned");
+		this.filteredGravity = null;
+		this.lastGravitySampledAtMs = null;
 	}
 	emitDiagnostic(event) {
 		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.emitDiagnostic", "called", {
@@ -1763,315 +2003,256 @@ var DefaultDrivingStatusController = class {
 			hasListener: this.onDiagnostic !== void 0
 		});
 		if (this.onDiagnostic) safeCall(this.onDiagnostic, event);
-		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.emitDiagnostic", "returned", { event });
 	}
 	attachLifecycleListeners() {
-		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;
-		}
+		if (!this.managePageLifecycle || this.unsubscribePageLifecycle !== null) 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);
-	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 detectLongitudinalEvidence = (window, tuning) => {
+	const rapidWindow = recentMetrics(window, tuning.rapidLongitudinalWindowMs, "linearAccelerationSampledAtMs");
+	const normalWindow = recentMetrics(window, tuning.longitudinalWindowMs, "linearAccelerationSampledAtMs");
+	let rapidCandidate = null;
+	let rejectionReason = null;
+	const rapidValues = rapidWindow.map((sample) => sample.longitudinal);
+	const rapidMean = trimmedMean(rapidValues);
+	const rapidDirection = Math.sign(rapidMean);
+	const rapidCoherence = signCoherence(rapidValues, rapidDirection, tuning.longitudinalExitThreshold);
+	const rapidPeak = maximumAbsolute(rapidValues);
+	const longitudinalRms = rootMeanSquare(rapidValues);
+	const verticalRms = rootMeanSquare(rapidWindow.map((sample) => sample.vertical));
+	const reversalWindow = recentMetrics(window, tuning.longitudinalReversalWindowMs, "linearAccelerationSampledAtMs");
+	const hasReversal = containsBothSigns(reversalWindow.map((sample) => sample.longitudinal), tuning.longitudinalThreshold);
+	const rapidStatistics = rapidWindow.length === 0 ? null : {
+		sampleCount: rapidWindow.length,
+		durationMs: metricWindowDuration(rapidWindow, "linearAccelerationSampledAtMs"),
+		mean: rapidMean,
+		peak: rapidPeak,
+		coherence: rapidCoherence,
+		longitudinalRms,
+		verticalRms,
+		hasReversal
+	};
+	if (windowCovers(rapidWindow, tuning.rapidLongitudinalMinimumSamples, tuning.rapidLongitudinalWindowMs, "linearAccelerationSampledAtMs")) {
+		if (rapidPeak >= tuning.rapidLongitudinalPeakThreshold && Math.abs(rapidMean) >= tuning.rapidLongitudinalMeanThreshold) {
+			if (verticalRms > longitudinalRms * tuning.verticalBumpRatio) rejectionReason = "vertical_bump";
+			else if (hasReversal) rejectionReason = "longitudinal_reversal";
+			else if (rapidDirection !== 0 && rapidCoherence >= tuning.rapidLongitudinalSignCoherence) rapidCandidate = rapidDirection > 0 ? "RAPID_ACCELERATION" : "SUDDEN_BRAKING";
+		}
+	}
+	let normalCandidate = null;
+	let retainedNormal = false;
+	let normalStatistics = null;
+	if (normalWindow.length > 0) {
+		const values = normalWindow.map((sample) => sample.longitudinal);
+		const mean = trimmedMean(values);
+		const direction = Math.sign(mean);
+		const coherence = signCoherence(values, direction, tuning.longitudinalExitThreshold);
+		normalStatistics = {
+			sampleCount: normalWindow.length,
+			durationMs: metricWindowDuration(normalWindow, "linearAccelerationSampledAtMs"),
+			mean,
+			peak: maximumAbsolute(values),
+			coherence
+		};
+		retainedNormal = Math.abs(mean) >= tuning.longitudinalExitThreshold;
+		if (windowCovers(normalWindow, tuning.longitudinalMinimumSamples, tuning.longitudinalWindowMs, "linearAccelerationSampledAtMs") && Math.abs(mean) >= tuning.longitudinalThreshold && coherence >= tuning.longitudinalSignCoherence) normalCandidate = direction > 0 ? "ACCELERATION" : "BRAKING";
+	}
+	return {
+		rapidCandidate,
+		normalCandidate,
+		retainedNormal,
+		rejectionReason,
+		normalStatistics,
+		rapidStatistics
+	};
 };
-const classifyEntryCandidate = (raw, smoothed, motionIntensity, baseStatus, tuning) => {
-	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 detectTurnEvidence = (window, tuning) => {
+	const latest = window[window.length - 1];
+	if (!latest) return {
+		candidate: null,
+		latestYaw: 0,
+		sampledAtMs: 0,
+		rejectionReason: null,
+		statistics: null
+	};
+	const strongWindow = recentMetrics(window, tuning.turnConfirmationMs, "gyroscopeSampledAtMs");
+	const strongMean = trimmedMean(strongWindow.map((sample) => sample.yaw));
+	const strongDirection = Math.sign(strongMean);
+	const strongCoherence = signCoherence(strongWindow.map((sample) => sample.yaw), strongDirection, tuning.turnExitYawThreshold);
+	const strong = windowCovers(strongWindow, tuning.turnMinimumSamples, tuning.turnConfirmationMs, "gyroscopeSampledAtMs") && Math.abs(strongMean) >= tuning.turnYawThreshold && strongCoherence >= tuning.turnSignCoherence;
+	const signedAngle = integrateYaw(window);
+	const gentleDirection = Math.sign(signedAngle);
+	const gentleCoherence = signCoherence(window.map((sample) => sample.yaw), gentleDirection, tuning.turnExitYawThreshold);
+	const yawRms = rootMeanSquare(window.map((sample) => sample.yaw));
+	const rawGyroRms = rootMeanSquare(window.map((sample) => sample.rawGyroMagnitude));
+	const yawDominance = rawGyroRms <= Number.EPSILON ? 0 : Math.min(1, yawRms / rawGyroRms);
+	const lateralRms = rootMeanSquare(window.map((sample) => sample.lateral));
+	const verticalRms = rootMeanSquare(window.map((sample) => sample.vertical));
+	const gentleShape = window.length >= tuning.turnMinimumSamples && Math.abs(signedAngle) >= tuning.turnIntegratedAngleThreshold && gentleCoherence >= tuning.turnSignCoherence;
+	const verticalDominant = verticalRms > Math.max(lateralRms, tuning.turnVerticalNoiseFloor) * tuning.turnVerticalBumpRatio;
+	const yawDominant = yawDominance >= tuning.turnYawDominanceThreshold;
+	const laterallySupported = lateralRms >= tuning.turnLateralEvidenceThreshold;
+	const rejectionReason = !strong && gentleShape && verticalDominant && !yawDominant ? "vertical_bump" : null;
+	const direction = strong ? strongDirection : gentleShape && rejectionReason === null && (yawDominant || laterallySupported) ? gentleDirection : 0;
+	return {
+		candidate: direction === 0 ? null : direction > 0 ? "LEFT_TURN" : "RIGHT_TURN",
+		latestYaw: latest.yaw,
+		sampledAtMs: latest.gyroscopeSampledAtMs,
+		rejectionReason,
+		statistics: {
+			sampleCount: window.length,
+			durationMs: metricWindowDuration(window, "gyroscopeSampledAtMs"),
+			strongMean,
+			strongCoherence,
+			signedAngle,
+			gentleCoherence,
+			yawRms,
+			rawGyroRms,
+			yawDominance,
+			lateralRms,
+			verticalRms
+		}
+	};
 };
-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":
-			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 instantaneousCandidate = (metrics, tuning) => {
+	const longitudinalMagnitude = Math.abs(metrics.longitudinal);
+	if (longitudinalMagnitude >= tuning.rapidLongitudinalPeakThreshold && Math.abs(metrics.vertical) <= longitudinalMagnitude * tuning.verticalBumpRatio) return metrics.longitudinal > 0 ? "RAPID_ACCELERATION" : "SUDDEN_BRAKING";
+	if (Math.abs(metrics.yaw) >= tuning.turnYawThreshold) return metrics.yaw > 0 ? "LEFT_TURN" : "RIGHT_TURN";
+	if (longitudinalMagnitude >= tuning.longitudinalThreshold) return metrics.longitudinal > 0 ? "ACCELERATION" : "BRAKING";
+	return null;
+};
+const recentMetrics = (values, windowMs, timestampKey) => {
+	const latestAtMs = values[values.length - 1]?.[timestampKey] ?? 0;
+	return values.filter((value) => value[timestampKey] >= latestAtMs - windowMs);
+};
+const windowCovers = (values, minimumSamples, durationMs, timestampKey) => {
+	if (values.length < minimumSamples) return false;
+	const first = values[0];
+	return values[values.length - 1][timestampKey] - first[timestampKey] >= durationMs;
+};
+const integrateYaw = (values) => {
+	let angle = 0;
+	for (let index = 1; index < values.length; index += 1) {
+		const previous = values[index - 1];
+		const current = values[index];
+		const elapsedSeconds = Math.max(0, current.gyroscopeSampledAtMs - previous.gyroscopeSampledAtMs) / 1e3;
+		angle += (previous.yaw + current.yaw) / 2 * elapsedSeconds;
+	}
+	return angle;
+};
+const trimmedMean = (values) => {
+	if (values.length === 0) return 0;
+	if (values.length < 4) return values.reduce((sum, value) => sum + value, 0) / values.length;
+	const sorted = [...values].sort((left, right) => left - right).slice(1, -1);
+	return sorted.reduce((sum, value) => sum + value, 0) / sorted.length;
+};
+const signCoherence = (values, direction, deadband) => {
+	if (values.length === 0 || direction === 0) return 0;
+	return values.filter((value) => Math.abs(value) >= deadband && Math.sign(value) === direction).length / values.length;
+};
+const containsBothSigns = (values, threshold) => values.some((value) => value >= threshold) && values.some((value) => value <= -threshold);
+const rootMeanSquare = (values) => values.length === 0 ? 0 : Math.sqrt(values.reduce((sum, value) => sum + value ** 2, 0) / values.length);
+const maximumAbsolute = (values) => values.length === 0 ? 0 : Math.max(...values.map(Math.abs));
+const metricWindowDuration = (values, timestampKey) => {
+	const first = values[0];
+	const last = values[values.length - 1];
+	return first && last ? Math.max(0, last[timestampKey] - first[timestampKey]) : 0;
+};
+const calculateCombinedAxisMad = (samples, minimumSamples) => {
+	if (samples.length < minimumSamples) return null;
+	const medianX = median(samples.map((sample) => sample.value.x));
+	const medianY = median(samples.map((sample) => sample.value.y));
+	const medianZ = median(samples.map((sample) => sample.value.z));
+	const madX = median(samples.map((sample) => Math.abs(sample.value.x - medianX)));
+	const madY = median(samples.map((sample) => Math.abs(sample.value.y - medianY)));
+	const madZ = median(samples.map((sample) => Math.abs(sample.value.z - medianZ)));
+	return Math.hypot(madX, madY, madZ);
+};
+const vectorWindowDuration = (values) => {
+	const first = values[0];
+	const last = values[values.length - 1];
+	return first && last ? Math.max(0, last.sampledAtMs - first.sampledAtMs) : 0;
+};
+const median = (values) => {
+	if (values.length === 0) return 0;
+	const sorted = [...values].sort((left, right) => left - right);
+	const middle = Math.floor(sorted.length / 2);
+	return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
+};
+const pushUniqueMetric = (window, metrics, timestampKey, windowMs) => {
+	const latest = window[window.length - 1];
+	if (latest && metrics[timestampKey] <= latest[timestampKey]) return false;
+	if (window.some((value) => value[timestampKey] === metrics[timestampKey])) return false;
+	window.push(metrics);
+	const cutoffMs = metrics[timestampKey] - windowMs;
+	while (window[0] && window[0][timestampKey] < cutoffMs) window.shift();
+	return true;
 };
-const averageMetrics = (metrics) => {
-	dialSdkDebugWarn(DEBUG_MODULE$1, "averageMetrics", "called", { metrics });
-	const result = {
-		capturedAtMs: metrics[metrics.length - 1]?.capturedAtMs ?? 0,
-		longitudinal: 0,
-		lateral: 0,
-		yaw: 0,
-		motionIntensity: 0,
-		gyroMagnitude: 0
-	};
-	for (const value of metrics) {
-		result.longitudinal += value.longitudinal;
-		result.lateral += value.lateral;
-		result.yaw += value.yaw;
-		result.motionIntensity += value.motionIntensity;
-		result.gyroMagnitude += value.gyroMagnitude;
-	}
-	const count = Math.max(1, metrics.length);
-	result.longitudinal /= count;
-	result.lateral /= count;
-	result.yaw /= count;
-	result.motionIntensity /= count;
-	result.gyroMagnitude /= count;
-	dialSdkDebugWarn(DEBUG_MODULE$1, "averageMetrics", "returned", { result });
-	return result;
+const pushUniqueVector = (window, sample, windowMs) => {
+	const latest = window[window.length - 1];
+	if (latest && sample.sampledAtMs <= latest.sampledAtMs) return false;
+	if (window.some((value) => value.sampledAtMs === sample.sampledAtMs)) return false;
+	window.push(sample);
+	const cutoffMs = sample.sampledAtMs - windowMs;
+	while (window[0] && window[0].sampledAtMs < cutoffMs) window.shift();
+	return true;
 };
-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)) {
-		dialSdkDebugWarn(DEBUG_MODULE$1, "extractFreshAccelerometerSample", "returned", { result: null });
-		return null;
-	}
-	const ageMs = info.capturedAtMs - metric.sampledAtMs;
-	if (ageMs < 0 || ageMs > maxSampleAgeMs) {
-		dialSdkDebugWarn(DEBUG_MODULE$1, "extractFreshAccelerometerSample", "returned stale sample", {
-			result: null,
-			ageMs
-		});
-		return null;
-	}
+const extractFreshVectorMetric = (metric, capturedAtMs, maxSampleAgeMs) => {
+	if (!metric?.available || !Number.isFinite(capturedAtMs) || !Number.isFinite(metric.sampledAtMs)) return null;
+	const ageMs = capturedAtMs - metric.sampledAtMs;
+	if (ageMs < 0 || ageMs > maxSampleAgeMs) return null;
 	const { x, y, z } = metric.value;
-	if (![
+	return [
 		x,
 		y,
 		z
-	].every(Number.isFinite)) {
-		dialSdkDebugWarn(DEBUG_MODULE$1, "extractFreshAccelerometerSample", "returned invalid vector", { result: null });
-		return null;
-	}
-	const result = {
+	].every(Number.isFinite) ? {
 		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;
-	let meanZ = 0;
-	for (const sample of samples) {
-		meanX += sample.value.x;
-		meanY += sample.value.y;
-		meanZ += sample.value.z;
-	}
-	meanX /= count;
-	meanY /= count;
-	meanZ /= count;
-	let varianceX = 0;
-	let varianceY = 0;
-	let varianceZ = 0;
-	for (const sample of samples) {
-		varianceX += (sample.value.x - meanX) ** 2;
-		varianceY += (sample.value.y - meanY) ** 2;
-		varianceZ += (sample.value.z - meanZ) ** 2;
-	}
-	const result = Math.sqrt((varianceX + varianceY + varianceZ) / count);
-	dialSdkDebugWarn(DEBUG_MODULE$1, "combinedAxisStandardDeviation", "returned", {
-		meanX,
-		meanY,
-		meanZ,
-		varianceX,
-		varianceY,
-		varianceZ,
-		result
-	});
-	return result;
+	} : null;
 };
+const observationTime = (metrics) => Math.max(metrics.linearAccelerationSampledAtMs, metrics.gyroscopeSampledAtMs);
+const lerpVector = (from, to, alpha) => ({
+	x: from.x + (to.x - from.x) * alpha,
+	y: from.y + (to.y - from.y) * alpha,
+	z: from.z + (to.z - from.z) * alpha
+});
 const defaultSensorProvider = () => {
-	dialSdkDebugWarn(DEBUG_MODULE$1, "defaultSensorProvider", "called");
 	const runtimeGlobal = globalThis;
-	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;
-	}
+	if (typeof runtimeGlobal.unifiedSensorInfo !== "function") return Promise.reject(/* @__PURE__ */ new Error("window.unifiedSensorInfo is unavailable"));
+	return runtimeGlobal.unifiedSensorInfo();
 };
 const systemClock = {
-	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;
+	now: () => Date.now(),
+	setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
+	clearTimeout: (handle) => globalThis.clearTimeout(handle)
 };
+const isBaseStatus = (status) => status === "STOPPED" || status === "STEADY_DRIVING";
+const isAbortError$1 = (error) => error instanceof Error && error.name === "AbortError";
 const requirePositiveFinite = (name, value) => {
-	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);
-		dialSdkDebugWarn(DEBUG_MODULE$1, "safeCall", "returned");
 	} catch (error) {
-		dialSdkDebugWarn(DEBUG_MODULE$1, "safeCall", "callback threw", error);
+		dialSdkDebugWarn(DEBUG_MODULE$1, "safeCall", "callback threw", {
+			error,
+			value
+		});
 	}
 };
-const noop = () => {
-	dialSdkDebugWarn(DEBUG_MODULE$1, "noop", "called and returned");
-};
+const noop = () => void 0;
 //#endregion
 //#region src/sensor/driving_expression_player.ts
 const DEBUG_MODULE = "driving_expression_player.ts";
@@ -3351,4 +3532,4 @@ const isRecord = (value) => {
 	return result;
 };
 //#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, waitForDrivingExpressionsConfig };
+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, buildVehicleFrame, classifyDrivingSnapshot, createDrivingExpressionPlayer, createDrivingStatusController, extractDrivingSnapshotMetrics, isPublicDrivingMediaUrl, parseDrivingExpressionsConfig, readDrivingExpressionsConfig, resolveDrivingExpression, resolveDrivingExpressionStrict, resolveDrivingStatusTuning, tryParseDrivingExpressionsConfig, unifiedSensorInfo, waitForDrivingExpressionsConfig };