@ziztechnology/dial-library 0.0.14 → 0.0.16

package/dist/index.mjs

@@ -1,9 +1,10 @@
 import { Gunzip } from "fflate";
-const resolveLogIntervalMs = (intervalMs = void 0) => typeof intervalMs === "number" && Number.isFinite(intervalMs) && intervalMs > 0 ? intervalMs : 500;
+const resolveLogIntervalMs = (intervalMs = void 0) => typeof intervalMs === "number" && Number.isFinite(intervalMs) && intervalMs > 0 ? intervalMs : 200;
 //#endregion
 //#region src/helper/debugger.ts
 const logIntervalMs = resolveLogIntervalMs();
 const lastLoggedAtByType = /* @__PURE__ */ new Map();
+let hasLoggedSdkVersion = false;
 const createLogTypeKey = (moduleName, scope, phase) => JSON.stringify([
 	moduleName,
 	scope,
@@ -38,6 +39,10 @@ const dialSdkDebugWarn = (moduleName, scope, phase, data) => {
 	if (!shouldLog(moduleName, scope, phase)) return;
 	const message = `[DIAL_SDK_DEBUG - ${moduleName}] ${scope}: ${phase}`;
 	try {
+		if (!hasLoggedSdkVersion) {
+			console.log(`[DIAL_SDK_DEBUG] SDK version: 0.0.16`);
+			hasLoggedSdkVersion = true;
+		}
 		if (data === void 0) console.log(message);
 		else console.log(message, stringifyDebugData(data));
 	} catch {}
@@ -143,6 +148,25 @@ const isRecord = (value, debug) => {
 	return result;
 };
 //#endregion
+//#region src/driving_expression/directional_longitudinal_tuning.ts
+const BRAKING_ENTRY_OFFSET = .3;
+const BRAKING_EXIT_OFFSET = .15;
+const SUDDEN_BRAKING_PEAK_OFFSET = .4;
+const SUDDEN_BRAKING_MEAN_OFFSET = .3;
+const resolveDirectionalLongitudinalTuning = (tuning) => ({
+	accelerationThreshold: tuning.longitudinalThreshold,
+	accelerationExitThreshold: tuning.longitudinalExitThreshold,
+	brakingThreshold: tuning.longitudinalThreshold + BRAKING_ENTRY_OFFSET,
+	brakingExitThreshold: tuning.longitudinalExitThreshold + BRAKING_EXIT_OFFSET,
+	rapidAccelerationPeakThreshold: tuning.rapidLongitudinalPeakThreshold,
+	rapidAccelerationMeanThreshold: tuning.rapidLongitudinalMeanThreshold,
+	suddenBrakingPeakThreshold: tuning.rapidLongitudinalPeakThreshold + SUDDEN_BRAKING_PEAK_OFFSET,
+	suddenBrakingMeanThreshold: tuning.rapidLongitudinalMeanThreshold + SUDDEN_BRAKING_MEAN_OFFSET,
+	normalBrakingMinimumDominance: .8,
+	suddenBrakingMinimumDominance: 1.25,
+	maximumBrakingGravityDirectionChangeRad: Math.PI / 60
+});
+//#endregion
 //#region src/driving_expression/check_status.ts
 const DEBUG_MODULE$4 = "check_status.ts";
 const DEVICE_RIGHT = {
@@ -156,7 +180,7 @@ const ZERO_VECTOR$1 = {
 	z: 0
 };
 const DEFAULT_DRIVING_STATUS_TUNING = Object.freeze({
-	version: "driving-status-calibrated-2026-07-17-r2",
+	version: "driving-status-calibrated-2026-07-17-r3",
 	maxSampleAgeMs: 1e3,
 	gravityFilterTimeConstantMs: 1e3,
 	biasFilterTimeConstantMs: 1e4,
@@ -377,8 +401,9 @@ const buildVehicleFrame = (gravity, rightMinimumNorm = DEFAULT_DRIVING_STATUS_TU
 	return result;
 };
 const classifyInstantaneousEvidence = (metrics, tuning) => {
+	const directionalTuning = resolveDirectionalLongitudinalTuning(tuning);
 	const longitudinalMagnitude = Math.abs(metrics.longitudinal);
-	if (longitudinalMagnitude >= tuning.rapidLongitudinalPeakThreshold) {
+	if (longitudinalMagnitude >= (metrics.longitudinal < 0 ? directionalTuning.suddenBrakingPeakThreshold : directionalTuning.rapidAccelerationPeakThreshold)) {
 		if (Math.abs(metrics.vertical) > longitudinalMagnitude * tuning.verticalBumpRatio) return {
 			candidateStatus: null,
 			rejectionReason: "vertical_bump"
@@ -392,7 +417,7 @@ const classifyInstantaneousEvidence = (metrics, tuning) => {
 		candidateStatus: metrics.yaw > 0 ? "LEFT_TURN" : "RIGHT_TURN",
 		rejectionReason: null
 	};
-	if (longitudinalMagnitude >= tuning.longitudinalThreshold) return {
+	if (longitudinalMagnitude >= (metrics.longitudinal < 0 ? directionalTuning.brakingThreshold : directionalTuning.accelerationThreshold)) return {
 		candidateStatus: metrics.longitudinal > 0 ? "ACCELERATION" : "BRAKING",
 		rejectionReason: null
 	};
@@ -1402,6 +1427,7 @@ var DefaultDrivingStatusController = class {
 		this.unavailableSinceMs = null;
 		this.fallbackApplied = false;
 		this.filteredGravity = null;
+		this.rawGravity = null;
 		this.lastGravitySampledAtMs = null;
 		this.linearAccelerationBias = { ...ZERO_VECTOR };
 		this.gyroscopeBias = { ...ZERO_VECTOR };
@@ -1471,6 +1497,7 @@ var DefaultDrivingStatusController = class {
 		this.pollIntervalMs = requirePositiveFinite("pollIntervalMs", options.pollIntervalMs ?? 200, REQUIRE_POSITIVE_FINITE_DEBUG);
 		this.unavailableFallbackMs = requirePositiveFinite("unavailableFallbackMs", options.unavailableFallbackMs ?? 3e3, REQUIRE_POSITIVE_FINITE_DEBUG);
 		this.tuning = resolveDrivingStatusTuning(options.tuning);
+		this.directionalLongitudinalTuning = resolveDirectionalLongitudinalTuning(this.tuning);
 		this.clock = options.clock ?? systemClock;
 		this.onDiagnostic = options.onDiagnostic;
 		this.managePageLifecycle = options.managePageLifecycle ?? true;
@@ -1483,6 +1510,7 @@ var DefaultDrivingStatusController = class {
 		this.status = initialStatus;
 		this.baseStatus = isBaseStatus(initialStatus) ? initialStatus : "STOPPED";
 		this.statusCommittedAtMs = this.clock.now();
+		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.constructor", "resolved directional longitudinal tuning", this.directionalLongitudinalTuning);
 		dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.constructor", "created", this.getSnapshot());
 	}
 	start() {
@@ -1674,38 +1702,46 @@ var DefaultDrivingStatusController = class {
 	resolveGravityFrame(info) {
 		const sample = extractFreshVector(info.gravity, info.capturedAtMs, this.tuning.maxSampleAgeMs);
 		if (sample === null) {
-			if (this.filteredGravity === null || this.lastGravitySampledAtMs === null) return null;
+			if (this.filteredGravity === null || this.rawGravity === 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"
+				source: "cached",
+				rawValue: this.rawGravity
 			} : null;
 		}
-		if (sample.sampledAtMs === this.lastGravitySampledAtMs && this.filteredGravity !== null) return {
-			value: this.filteredGravity,
-			sampledAtMs: sample.sampledAtMs,
-			source: "live"
-		};
+		if (sample.sampledAtMs === this.lastGravitySampledAtMs && this.filteredGravity !== null) {
+			this.rawGravity = { ...sample.value };
+			return {
+				value: this.filteredGravity,
+				sampledAtMs: sample.sampledAtMs,
+				source: "live",
+				rawValue: this.rawGravity
+			};
+		}
 		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 ? {
+				return ageMs >= 0 && ageMs <= this.tuning.maxSampleAgeMs && this.rawGravity !== null ? {
 					value: this.filteredGravity,
 					sampledAtMs: this.lastGravitySampledAtMs,
-					source: "cached"
+					source: "cached",
+					rawValue: this.rawGravity
 				} : 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.rawGravity = { ...sample.value };
 		this.lastGravitySampledAtMs = sample.sampledAtMs;
 		return {
 			value: this.filteredGravity,
 			sampledAtMs: sample.sampledAtMs,
-			source: "live"
+			source: "live",
+			rawValue: this.rawGravity
 		};
 	}
 	processAvailable(metrics, accelerometerSample, gravity) {
@@ -1726,7 +1762,10 @@ var DefaultDrivingStatusController = class {
 			tuningVersion: this.tuning.version
 		});
 		const longitudinalRetentionMs = Math.max(recognitionRetentionMs(this.tuning.longitudinalWindowMs, this.tuning.longitudinalMinimumSamples), recognitionRetentionMs(this.tuning.rapidLongitudinalWindowMs, this.tuning.rapidLongitudinalMinimumSamples));
-		const addedLongitudinal = pushUniqueMetric(this.longitudinalWindow, metrics, "linearAccelerationSampledAtMs", longitudinalRetentionMs);
+		const addedLongitudinal = pushUniqueLongitudinalObservation(this.longitudinalWindow, {
+			metrics,
+			rawGravity: gravity.rawValue
+		}, longitudinalRetentionMs);
 		const yawRetentionMs = Math.max(this.tuning.turnWindowMs, this.tuning.turnClosureWindowMs, recognitionRetentionMs(this.tuning.turnConfirmationMs, this.tuning.turnMinimumSamples));
 		const addedYaw = pushUniqueMetric(this.yawWindow, metrics, "gyroscopeSampledAtMs", yawRetentionMs);
 		const addedMotion = pushUniqueVector(this.motionWindow, accelerometerSample, recognitionRetentionMs(this.tuning.motionWindowMs, this.tuning.motionMinimumSamples));
@@ -1742,7 +1781,11 @@ var DefaultDrivingStatusController = class {
 		const previousLongitudinalStatus = this.normalLongitudinalStatus;
 		const previousTurnStatus = this.turnStatus;
 		const baseCondition = this.updateBaseDetector(motionMad, metrics, accelerometerSample.sampledAtMs, addedMotion, motionCoverageWindow?.[0]?.sampledAtMs ?? accelerometerSample.sampledAtMs);
-		const longitudinalEvidence = detectLongitudinalEvidence(this.longitudinalWindow, this.tuning);
+		const longitudinalEvidence = detectLongitudinalEvidence(this.longitudinalWindow, this.tuning, this.directionalLongitudinalTuning);
+		if (longitudinalEvidence.brakingQualityRejection !== null || longitudinalEvidence.suddenBrakingQualityRejection !== null) dialSdkDebugWarn(DEBUG_MODULE$1, "DefaultDrivingStatusController.processAvailable", "rejected braking quality", {
+			braking: longitudinalEvidence.brakingQualityRejection,
+			suddenBraking: longitudinalEvidence.suddenBrakingQualityRejection
+		});
 		if (addedLongitudinal) this.updateLongitudinalDetector(longitudinalEvidence, metrics.linearAccelerationSampledAtMs);
 		const turnEvidence = detectTurnEvidence(this.yawWindow, this.tuning);
 		if (addedYaw) this.updateTurnDetector(turnEvidence);
@@ -1773,7 +1816,7 @@ var DefaultDrivingStatusController = class {
 		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);
+		const pendingCandidate = instantaneousCandidate(metrics, this.tuning, this.directionalLongitudinalTuning);
 		this.setCandidate(pendingCandidate === this.status ? null : pendingCandidate, observationTime(metrics));
 		this.emitDiagnostic({
 			type: "detector_evidence",
@@ -1840,7 +1883,7 @@ var DefaultDrivingStatusController = class {
 		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.normalLongitudinalStatus !== null) if (this.normalLongitudinalStatus === "BRAKING" ? evidence.retainedBraking : evidence.retainedAcceleration) this.longitudinalClearSinceMs = null;
 		else {
 			if (this.longitudinalClearSinceMs === null) this.longitudinalClearSinceMs = sampledAtMs;
 			if (sampledAtMs - this.longitudinalClearSinceMs >= this.tuning.longitudinalReleaseMs) {
@@ -2046,6 +2089,7 @@ var DefaultDrivingStatusController = class {
 		this.unavailableSinceMs = null;
 		this.fallbackApplied = false;
 		this.filteredGravity = null;
+		this.rawGravity = null;
 		this.lastGravitySampledAtMs = null;
 	}
 	emitDiagnostic(event) {
@@ -2069,27 +2113,31 @@ var DefaultDrivingStatusController = class {
 		this.unsubscribePageLifecycle = null;
 	}
 };
-const detectLongitudinalEvidence = (window, tuning) => {
-	const recentRapidWindow = recentMetrics(window, tuning.rapidLongitudinalWindowMs, "linearAccelerationSampledAtMs");
-	const rapidCoverageWindow = selectCoverageWindow(window, tuning.rapidLongitudinalMinimumSamples, tuning.rapidLongitudinalWindowMs, (sample) => sample.linearAccelerationSampledAtMs);
+const detectLongitudinalEvidence = (window, tuning, directionalTuning) => {
+	const recentRapidWindow = recentLongitudinalObservations(window, tuning.rapidLongitudinalWindowMs);
+	const rapidCoverageWindow = selectCoverageWindow(window, tuning.rapidLongitudinalMinimumSamples, tuning.rapidLongitudinalWindowMs, (sample) => sample.metrics.linearAccelerationSampledAtMs);
 	const rapidWindow = rapidCoverageWindow ?? recentRapidWindow;
-	const recentNormalWindow = recentMetrics(window, tuning.longitudinalWindowMs, "linearAccelerationSampledAtMs");
-	const normalCoverageWindow = selectCoverageWindow(window, tuning.longitudinalMinimumSamples, tuning.longitudinalWindowMs, (sample) => sample.linearAccelerationSampledAtMs);
+	const recentNormalWindow = recentLongitudinalObservations(window, tuning.longitudinalWindowMs);
+	const normalCoverageWindow = selectCoverageWindow(window, tuning.longitudinalMinimumSamples, tuning.longitudinalWindowMs, (sample) => sample.metrics.linearAccelerationSampledAtMs);
 	const normalWindow = normalCoverageWindow ?? recentNormalWindow;
 	let rapidCandidate = null;
 	let rejectionReason = null;
-	const rapidValues = rapidWindow.map((sample) => sample.longitudinal);
+	let suddenBrakingQualityRejection = null;
+	const rapidMetrics = rapidWindow.map((sample) => sample.metrics);
+	const rapidValues = rapidMetrics.map((sample) => sample.longitudinal);
 	const rapidMean = trimmedMean(rapidValues);
 	const rapidDirection = Math.sign(rapidMean);
-	const rapidCoherence = signCoherence(rapidValues, rapidDirection, tuning.longitudinalExitThreshold);
+	const rapidDeadband = rapidDirection < 0 ? directionalTuning.brakingExitThreshold : directionalTuning.accelerationExitThreshold;
+	const rapidCoherence = signCoherence(rapidValues, rapidDirection, rapidDeadband);
 	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 verticalRms = rootMeanSquare(rapidMetrics.map((sample) => sample.vertical));
+	const reversalWindow = recentLongitudinalObservations(window, tuning.longitudinalReversalWindowMs);
+	const hasReversal = containsBothSigns(reversalWindow.map((sample) => sample.metrics.longitudinal), tuning.longitudinalThreshold);
+	const rapidBrakingQuality = brakingQualityRejection(rapidWindow, directionalTuning.suddenBrakingMinimumDominance, directionalTuning.maximumBrakingGravityDirectionChangeRad);
 	const rapidStatistics = rapidWindow.length === 0 ? null : {
 		sampleCount: rapidWindow.length,
-		durationMs: metricWindowDuration(rapidWindow, "linearAccelerationSampledAtMs"),
+		durationMs: metricWindowDuration(rapidMetrics, "linearAccelerationSampledAtMs"),
 		mean: rapidMean,
 		peak: rapidPeak,
 		coherence: rapidCoherence,
@@ -2098,36 +2146,52 @@ const detectLongitudinalEvidence = (window, tuning) => {
 		hasReversal
 	};
 	if (rapidCoverageWindow !== null) {
-		if (rapidPeak >= tuning.rapidLongitudinalPeakThreshold && Math.abs(rapidMean) >= tuning.rapidLongitudinalMeanThreshold) {
+		const rapidPeakThreshold = rapidDirection < 0 ? directionalTuning.suddenBrakingPeakThreshold : directionalTuning.rapidAccelerationPeakThreshold;
+		const rapidMeanThreshold = rapidDirection < 0 ? directionalTuning.suddenBrakingMeanThreshold : directionalTuning.rapidAccelerationMeanThreshold;
+		if (rapidPeak >= rapidPeakThreshold && Math.abs(rapidMean) >= rapidMeanThreshold) {
 			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";
+			else if (rapidDirection !== 0 && rapidCoherence >= tuning.rapidLongitudinalSignCoherence) if (rapidDirection < 0 && rapidBrakingQuality !== null) suddenBrakingQualityRejection = rapidBrakingQuality;
+			else rapidCandidate = rapidDirection > 0 ? "RAPID_ACCELERATION" : "SUDDEN_BRAKING";
 		}
 	}
 	let normalCandidate = null;
-	let retainedNormal = false;
+	let retainedAcceleration = false;
+	let retainedBraking = false;
+	let brakingQualityRejectionResult = null;
 	let normalStatistics = null;
 	if (normalWindow.length > 0) {
-		const values = normalWindow.map((sample) => sample.longitudinal);
+		const normalMetrics = normalWindow.map((sample) => sample.metrics);
+		const values = normalMetrics.map((sample) => sample.longitudinal);
 		const mean = trimmedMean(values);
 		const direction = Math.sign(mean);
-		const coherence = signCoherence(values, direction, tuning.longitudinalExitThreshold);
+		const deadband = direction < 0 ? directionalTuning.brakingExitThreshold : directionalTuning.accelerationExitThreshold;
+		const coherence = signCoherence(values, direction, deadband);
+		const normalBrakingQuality = brakingQualityRejection(normalWindow, directionalTuning.normalBrakingMinimumDominance, directionalTuning.maximumBrakingGravityDirectionChangeRad);
 		normalStatistics = {
 			sampleCount: normalWindow.length,
-			durationMs: metricWindowDuration(normalWindow, "linearAccelerationSampledAtMs"),
+			durationMs: metricWindowDuration(normalMetrics, "linearAccelerationSampledAtMs"),
 			mean,
 			peak: maximumAbsolute(values),
 			coherence
 		};
-		const retentionValues = recentNormalWindow.map((sample) => sample.longitudinal);
-		retainedNormal = Math.abs(trimmedMean(retentionValues)) >= tuning.longitudinalExitThreshold;
-		if (normalCoverageWindow !== null && Math.abs(mean) >= tuning.longitudinalThreshold && coherence >= tuning.longitudinalSignCoherence) normalCandidate = direction > 0 ? "ACCELERATION" : "BRAKING";
+		const retentionValues = recentNormalWindow.map((sample) => sample.metrics.longitudinal);
+		const retentionMean = trimmedMean(retentionValues);
+		const retentionBrakingQuality = brakingQualityRejection(recentNormalWindow, directionalTuning.normalBrakingMinimumDominance, directionalTuning.maximumBrakingGravityDirectionChangeRad);
+		retainedAcceleration = retentionMean >= directionalTuning.accelerationExitThreshold;
+		retainedBraking = retentionMean <= -directionalTuning.brakingExitThreshold && retentionBrakingQuality === null;
+		const threshold = direction < 0 ? directionalTuning.brakingThreshold : directionalTuning.accelerationThreshold;
+		if (normalCoverageWindow !== null && Math.abs(mean) >= threshold && coherence >= tuning.longitudinalSignCoherence) if (direction < 0 && normalBrakingQuality !== null) brakingQualityRejectionResult = normalBrakingQuality;
+		else normalCandidate = direction > 0 ? "ACCELERATION" : "BRAKING";
 	}
 	return {
 		rapidCandidate,
 		normalCandidate,
-		retainedNormal,
+		retainedAcceleration,
+		retainedBraking,
 		rejectionReason,
+		brakingQualityRejection: brakingQualityRejectionResult,
+		suddenBrakingQualityRejection,
 		normalStatistics,
 		rapidStatistics
 	};
@@ -2183,13 +2247,17 @@ const detectTurnEvidence = (window, tuning) => {
 		}
 	};
 };
-const instantaneousCandidate = (metrics, tuning) => {
+const instantaneousCandidate = (metrics, tuning, directionalTuning) => {
 	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 (longitudinalMagnitude >= (metrics.longitudinal < 0 ? directionalTuning.suddenBrakingPeakThreshold : directionalTuning.rapidAccelerationPeakThreshold) && 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";
+	if (longitudinalMagnitude >= (metrics.longitudinal < 0 ? directionalTuning.brakingThreshold : directionalTuning.accelerationThreshold)) return metrics.longitudinal > 0 ? "ACCELERATION" : "BRAKING";
 	return null;
 };
+const recentLongitudinalObservations = (values, windowMs) => {
+	const latestAtMs = values[values.length - 1]?.metrics.linearAccelerationSampledAtMs ?? 0;
+	return values.filter((value) => value.metrics.linearAccelerationSampledAtMs >= latestAtMs - windowMs);
+};
 const recentMetrics = (values, windowMs, timestampKey) => {
 	const latestAtMs = values[values.length - 1]?.[timestampKey] ?? 0;
 	return values.filter((value) => value[timestampKey] >= latestAtMs - windowMs);
@@ -2240,6 +2308,23 @@ const signCoherence = (values, direction, deadband) => {
 };
 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 brakingQualityRejection = (observations, minimumDominance, maximumGravityDirectionChangeRad) => {
+	if (observations.length === 0) return null;
+	if (rootMeanSquare(observations.map((sample) => sample.metrics.longitudinal)) < rootMeanSquare(observations.map((sample) => Math.hypot(sample.metrics.lateral, sample.metrics.vertical))) * minimumDominance) return "cross_axis_motion";
+	return maximumVectorAngle(observations.map((sample) => sample.rawGravity)) > maximumGravityDirectionChangeRad ? "gravity_direction_change" : null;
+};
+const maximumVectorAngle = (values) => {
+	let maximumAngle = 0;
+	for (let leftIndex = 0; leftIndex < values.length; leftIndex += 1) for (let rightIndex = leftIndex + 1; rightIndex < values.length; rightIndex += 1) {
+		const left = values[leftIndex];
+		const right = values[rightIndex];
+		const denominator = Math.hypot(left.x, left.y, left.z) * Math.hypot(right.x, right.y, right.z);
+		if (denominator <= Number.EPSILON) return Number.POSITIVE_INFINITY;
+		const cosine = (left.x * right.x + left.y * right.y + left.z * right.z) / denominator;
+		maximumAngle = Math.max(maximumAngle, Math.acos(Math.max(-1, Math.min(1, cosine))));
+	}
+	return maximumAngle;
+};
 const maximumAbsolute = (values) => values.length === 0 ? 0 : Math.max(...values.map(Math.abs));
 const metricWindowDuration = (values, timestampKey) => {
 	const first = values[0];
@@ -2275,6 +2360,15 @@ const pushUniqueMetric = (window, metrics, timestampKey, windowMs) => {
 	while (window[0] && window[0][timestampKey] < cutoffMs) window.shift();
 	return true;
 };
+const pushUniqueLongitudinalObservation = (window, observation, windowMs) => {
+	const latest = window[window.length - 1];
+	const sampledAtMs = observation.metrics.linearAccelerationSampledAtMs;
+	if (latest && sampledAtMs <= latest.metrics.linearAccelerationSampledAtMs) return false;
+	window.push(observation);
+	const cutoffMs = sampledAtMs - windowMs;
+	while (window[0] && window[0].metrics.linearAccelerationSampledAtMs < cutoffMs) window.shift();
+	return true;
+};
 const pushUniqueVector = (window, sample, windowMs) => {
 	const latest = window[window.length - 1];
 	if (latest && sample.sampledAtMs <= latest.sampledAtMs) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziztechnology/dial-library",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "private": false,
   "description": "Tooony 表盘工具函数、方法",
   "files": [