gps-plus-slam-app-framework 1.4.0 → 1.7.0

package/dist/state/recording-options.js

@@ -1,4 +1,6 @@
 import { createLogger } from "../utils/logger.js";
+import { t as DEFAULT_MOTION_FILTER } from "../capture-motion-gate-4EscNZCw.js";
+import { DEFAULT_QUALITY_FILTER } from "../ar/image-quality.js";
 //#region ../src/state/recording-options.ts
 /**
 * Recording Options - User-configurable settings for data capture.
@@ -31,7 +33,9 @@ const DEFAULT_RECORDING_OPTIONS = {
 		enabled: true,
 		intervalMs: 2e3,
 		quality: .7,
-		resolutionDivisor: 1
+		resolutionDivisor: 1,
+		motionFilter: { ...DEFAULT_MOTION_FILTER },
+		qualityFilter: { ...DEFAULT_QUALITY_FILTER }
 	},
 	arCrashIsolation: {
 		enableDomOverlay: true,
@@ -41,7 +45,10 @@ const DEFAULT_RECORDING_OPTIONS = {
 		enableCameraTextureAcquisition: true,
 		applyChromiumProjectionLayerWorkaround: true
 	},
-	occupancy: { cellSizeM: .15 },
+	occupancy: {
+		cellSizeM: .15,
+		minConfidence: 3
+	},
 	frameTileDisplay: { divisor: 2 },
 	visualization: {
 		frameTiles: true,
@@ -53,6 +60,11 @@ const DEFAULT_RECORDING_OPTIONS = {
 		enabled: false,
 		intervalMs: 125,
 		captureSize: 1024
+	},
+	compassDebug: {
+		coldStartOverride: true,
+		rotationPrior: false,
+		webXRConsistency: false
 	}
 };
 /** Validation constraints for depth options */
@@ -87,6 +99,65 @@ const IMAGE_CONSTRAINTS = {
 	}
 };
 /**
+* Validation constraints for the motion-filter (blurry-frame gate) thresholds.
+*
+* The velocity ranges (0.05–5) bracket the plausible scanning regime: below
+* ~0.05 the gate would reject almost everything; above ~5 rad/s ≈ 286°/s (or
+* 5 m/s) it would never reject, so the gate would be inert. `maxWaitMs` is
+* clamped to 0.5–20 s — the never-calm fallback must always be able to fire.
+* All three back a (currently advanced/hidden) settings slider, so a corrupt
+* stored value can never disable capture. The default thresholds themselves are
+* placeholders pending on-device field tuning (plan §7).
+*/
+const MOTION_FILTER_CONSTRAINTS = {
+	maxAngularVelocity: {
+		min: .05,
+		max: 5,
+		step: .05
+	},
+	maxLinearVelocity: {
+		min: .05,
+		max: 5,
+		step: .05
+	},
+	maxWaitMs: {
+		min: 500,
+		max: 2e4,
+		step: 500
+	}
+};
+/**
+* Validation constraints for the image-quality (blur/blackness) gate thresholds.
+*
+* `blurRelativeThreshold` (`k` in `sharpness < k·median`) is clamped to
+* 0.05–0.95: it is a fraction of the recent sharpness median, so values must sit
+* strictly inside (0, 1) — at ~0 the blur check never rejects, near 1 it rejects
+* almost everything. `minMeanLuminance` (the absolute black cutoff on a 0–255
+* luma scale) is clamped to 0–128: 0 disables the black check, and a cutoff
+* above mid-grey would reject normally-lit frames. `maxWaitMs` mirrors the motion
+* gate's range (0.5–20 s) so the never-good fallback can always fire. All back a
+* (currently advanced/hidden) settings slider, so a corrupt stored value can
+* never disable capture. The default thresholds are placeholders pending
+* on-device field tuning (plan §5, §10).
+*/
+const QUALITY_FILTER_CONSTRAINTS = {
+	blurRelativeThreshold: {
+		min: .05,
+		max: .95,
+		step: .05
+	},
+	minMeanLuminance: {
+		min: 0,
+		max: 128,
+		step: 1
+	},
+	maxWaitMs: {
+		min: 500,
+		max: 2e4,
+		step: 500
+	}
+};
+/**
 * Validation constraints for occupancy options.
 *
 * `cellSizeM` is clamped to 1–20 cm. The floor exists because cell count (and
@@ -94,12 +165,24 @@ const IMAGE_CONSTRAINTS = {
 * `points3D` row count) scales as 1/cellSize³ — sub-centimetre voxels are both
 * a memory/perf cliff on a phone and below the depth sensor's noise floor.
 * Step is 1 cm (the settings slider operates in cm).
+*
+* `minConfidence` is clamped to 1–10 (integer). 1 disables the filter (legacy
+* behaviour: a single observation counts as occupied); the ceiling exists
+* because real surfaces accumulate only a handful of observations per second
+* of dwell, so a floor above ~10 would start hiding genuine geometry.
 */
-const OCCUPANCY_CONSTRAINTS = { cellSizeM: {
-	min: .01,
-	max: .2,
-	step: .01
-} };
+const OCCUPANCY_CONSTRAINTS = {
+	cellSizeM: {
+		min: .01,
+		max: .2,
+		step: .01
+	},
+	minConfidence: {
+		min: 1,
+		max: 10,
+		step: 1
+	}
+};
 /**
 * Validation constraints for the frame-tile display-resolution divisor.
 *
@@ -150,6 +233,19 @@ function validateArCrashIsolationOptions(options) {
 	};
 }
 /**
+* Validate and normalize the compass alignment debug toggles. Boolean-or-default
+* per field; a missing/corrupted/pre-feature value falls back to the OFF default
+* so a bad persisted value can never silently turn an alignment override ON.
+*/
+function validateCompassDebugOptions(options) {
+	const defaults = DEFAULT_RECORDING_OPTIONS.compassDebug;
+	return {
+		coldStartOverride: typeof options.coldStartOverride === "boolean" ? options.coldStartOverride : defaults.coldStartOverride,
+		rotationPrior: typeof options.rotationPrior === "boolean" ? options.rotationPrior : defaults.rotationPrior,
+		webXRConsistency: typeof options.webXRConsistency === "boolean" ? options.webXRConsistency : defaults.webXRConsistency
+	};
+}
+/**
 * Validate and normalize the live debug-overlay visibility toggles.
 * Each field is boolean-or-default (same policy as the AR-crash-isolation
 * flags): a missing, corrupted, or pre-feature persisted value falls back to
@@ -200,6 +296,41 @@ function validateDepthOptions(options) {
 	};
 }
 /**
+* Validate and normalize the motion-filter (blurry-frame gate) options.
+* `enabled` is boolean-or-default; the three numeric thresholds are clamped to
+* {@link MOTION_FILTER_CONSTRAINTS} with a `Number.isFinite` guard (a stored
+* `NaN` is `typeof 'number'` and would survive `clamp`). A missing group
+* default-fills entirely — a pre-feature persisted options object that lacks
+* `motionFilter` therefore loads with the gate enabled rather than crashing.
+*/
+function validateMotionFilterOptions(options) {
+	const defaults = DEFAULT_RECORDING_OPTIONS.images.motionFilter;
+	return {
+		enabled: typeof options.enabled === "boolean" ? options.enabled : defaults.enabled,
+		maxAngularVelocity: clamp(typeof options.maxAngularVelocity === "number" && Number.isFinite(options.maxAngularVelocity) ? options.maxAngularVelocity : defaults.maxAngularVelocity, MOTION_FILTER_CONSTRAINTS.maxAngularVelocity.min, MOTION_FILTER_CONSTRAINTS.maxAngularVelocity.max),
+		maxLinearVelocity: clamp(typeof options.maxLinearVelocity === "number" && Number.isFinite(options.maxLinearVelocity) ? options.maxLinearVelocity : defaults.maxLinearVelocity, MOTION_FILTER_CONSTRAINTS.maxLinearVelocity.min, MOTION_FILTER_CONSTRAINTS.maxLinearVelocity.max),
+		maxWaitMs: clamp(typeof options.maxWaitMs === "number" && Number.isFinite(options.maxWaitMs) ? options.maxWaitMs : defaults.maxWaitMs, MOTION_FILTER_CONSTRAINTS.maxWaitMs.min, MOTION_FILTER_CONSTRAINTS.maxWaitMs.max)
+	};
+}
+/**
+* Validate and normalize the image-quality (blur/blackness gate) options. Same
+* policy as {@link validateMotionFilterOptions}: `enabled` is boolean-or-default;
+* the three numeric thresholds are clamped to {@link QUALITY_FILTER_CONSTRAINTS}
+* with a `Number.isFinite` guard (a stored `NaN` is `typeof 'number'` and would
+* survive `clamp`). A missing group default-fills entirely — a pre-feature
+* persisted options object that lacks `qualityFilter` loads with the gate
+* disabled (the safe default) rather than crashing.
+*/
+function validateQualityFilterOptions(options) {
+	const defaults = DEFAULT_RECORDING_OPTIONS.images.qualityFilter;
+	return {
+		enabled: typeof options.enabled === "boolean" ? options.enabled : defaults.enabled,
+		blurRelativeThreshold: clamp(typeof options.blurRelativeThreshold === "number" && Number.isFinite(options.blurRelativeThreshold) ? options.blurRelativeThreshold : defaults.blurRelativeThreshold, QUALITY_FILTER_CONSTRAINTS.blurRelativeThreshold.min, QUALITY_FILTER_CONSTRAINTS.blurRelativeThreshold.max),
+		minMeanLuminance: clamp(typeof options.minMeanLuminance === "number" && Number.isFinite(options.minMeanLuminance) ? options.minMeanLuminance : defaults.minMeanLuminance, QUALITY_FILTER_CONSTRAINTS.minMeanLuminance.min, QUALITY_FILTER_CONSTRAINTS.minMeanLuminance.max),
+		maxWaitMs: clamp(typeof options.maxWaitMs === "number" && Number.isFinite(options.maxWaitMs) ? options.maxWaitMs : defaults.maxWaitMs, QUALITY_FILTER_CONSTRAINTS.maxWaitMs.min, QUALITY_FILTER_CONSTRAINTS.maxWaitMs.max)
+	};
+}
+/**
 * Validate and normalize image options.
 * Invalid values are clamped to valid ranges.
 */
@@ -209,7 +340,9 @@ function validateImageOptions(options) {
 		enabled: typeof options.enabled === "boolean" ? options.enabled : defaults.enabled,
 		intervalMs: clamp(typeof options.intervalMs === "number" ? options.intervalMs : defaults.intervalMs, IMAGE_CONSTRAINTS.intervalMs.min, IMAGE_CONSTRAINTS.intervalMs.max),
 		quality: clamp(typeof options.quality === "number" ? options.quality : defaults.quality, IMAGE_CONSTRAINTS.quality.min, IMAGE_CONSTRAINTS.quality.max),
-		resolutionDivisor: clamp(typeof options.resolutionDivisor === "number" ? options.resolutionDivisor : defaults.resolutionDivisor, IMAGE_CONSTRAINTS.resolutionDivisor.min, IMAGE_CONSTRAINTS.resolutionDivisor.max)
+		resolutionDivisor: clamp(typeof options.resolutionDivisor === "number" ? options.resolutionDivisor : defaults.resolutionDivisor, IMAGE_CONSTRAINTS.resolutionDivisor.min, IMAGE_CONSTRAINTS.resolutionDivisor.max),
+		motionFilter: validateMotionFilterOptions(options.motionFilter ?? {}),
+		qualityFilter: validateQualityFilterOptions(options.qualityFilter ?? {})
 	};
 }
 /**
@@ -223,7 +356,10 @@ function validateImageOptions(options) {
 */
 function validateOccupancyOptions(options) {
 	const defaults = DEFAULT_RECORDING_OPTIONS.occupancy;
-	return { cellSizeM: clamp(typeof options.cellSizeM === "number" && Number.isFinite(options.cellSizeM) ? options.cellSizeM : defaults.cellSizeM, OCCUPANCY_CONSTRAINTS.cellSizeM.min, OCCUPANCY_CONSTRAINTS.cellSizeM.max) };
+	return {
+		cellSizeM: clamp(typeof options.cellSizeM === "number" && Number.isFinite(options.cellSizeM) ? options.cellSizeM : defaults.cellSizeM, OCCUPANCY_CONSTRAINTS.cellSizeM.min, OCCUPANCY_CONSTRAINTS.cellSizeM.max),
+		minConfidence: clamp(typeof options.minConfidence === "number" && Number.isFinite(options.minConfidence) ? Math.round(options.minConfidence) : defaults.minConfidence, OCCUPANCY_CONSTRAINTS.minConfidence.min, OCCUPANCY_CONSTRAINTS.minConfidence.max)
+	};
 }
 /**
 * Validate and normalize frame-tile display options. `divisor` is clamped to
@@ -248,7 +384,8 @@ function validateRecordingOptions(options) {
 		occupancy: validateOccupancyOptions(options.occupancy ?? {}),
 		frameTileDisplay: validateFrameTileDisplayOptions(options.frameTileDisplay ?? {}),
 		visualization: validateVisualizationOptions(options.visualization ?? {}),
-		qr: validateQrOptions(options.qr ?? {})
+		qr: validateQrOptions(options.qr ?? {}),
+		compassDebug: validateCompassDebugOptions(options.compassDebug ?? {})
 	};
 }
 /**
@@ -306,13 +443,18 @@ function resetRecordingOptions(storageKey = STORAGE_KEY) {
 function cloneRecordingOptions(options) {
 	return {
 		depth: { ...options.depth },
-		images: { ...options.images },
+		images: {
+			...options.images,
+			motionFilter: { ...options.images.motionFilter },
+			qualityFilter: { ...options.images.qualityFilter }
+		},
 		arCrashIsolation: { ...options.arCrashIsolation },
 		occupancy: { ...options.occupancy },
 		frameTileDisplay: { ...options.frameTileDisplay },
 		visualization: { ...options.visualization },
-		qr: { ...options.qr }
+		qr: { ...options.qr },
+		compassDebug: { ...options.compassDebug }
 	};
 }
 //#endregion
-export { DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, FRAME_TILE_DISPLAY_CONSTRAINTS, IMAGE_CONSTRAINTS, OCCUPANCY_CONSTRAINTS, QR_CONSTRAINTS, STORAGE_KEY, cloneRecordingOptions, loadRecordingOptions, resetRecordingOptions, saveRecordingOptions, validateArCrashIsolationOptions, validateDepthOptions, validateFrameTileDisplayOptions, validateImageOptions, validateOccupancyOptions, validateQrOptions, validateRecordingOptions, validateVisualizationOptions };
+export { DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, FRAME_TILE_DISPLAY_CONSTRAINTS, IMAGE_CONSTRAINTS, MOTION_FILTER_CONSTRAINTS, OCCUPANCY_CONSTRAINTS, QR_CONSTRAINTS, QUALITY_FILTER_CONSTRAINTS, STORAGE_KEY, cloneRecordingOptions, loadRecordingOptions, resetRecordingOptions, saveRecordingOptions, validateArCrashIsolationOptions, validateCompassDebugOptions, validateDepthOptions, validateFrameTileDisplayOptions, validateImageOptions, validateMotionFilterOptions, validateOccupancyOptions, validateQrOptions, validateQualityFilterOptions, validateRecordingOptions, validateVisualizationOptions };

package/dist/state/recording-replayer.d.ts

@@ -1,3 +1,3 @@
-import { L as CombinedRootState } from "../create-slam-app-store-Ce2FMKCp.js";
-import { n as replayRecording, t as ReplayRecordingOptions } from "../recording-replayer-CUEK82tM.js";
+import { N as CombinedRootState } from "../create-slam-app-store-n_VF63D5.js";
+import { n as replayRecording, t as ReplayRecordingOptions } from "../recording-replayer-DQKpAGyQ.js";
 export { CombinedRootState, ReplayRecordingOptions, replayRecording };

package/dist/state/recording-replayer.js

@@ -1,6 +1,6 @@
 import { loadActionsFromZip } from "../storage/zip-reader.js";
 import { NullStorageBackend } from "../storage/null-storage-backend.js";
-import { createSlamAppStore } from "./create-slam-app-store.js";
+import { t as createSlamAppStore } from "../create-slam-app-store-DkCHOpvb.js";
 //#region ../src/state/recording-replayer.ts
 /**
 * Recording Replayer

package/dist/state/recording-slice.d.ts

@@ -1,2 +1,2 @@
-import { a as recordWriteFailure, i as recordDepthSample, n as SessionMetadata, o as recordingReducer, r as endSession, s as startSession, t as RecordingState } from "../recording-slice-B-uCgGoh.js";
+import { a as recordWriteFailure, i as recordDepthSample, n as SessionMetadata, o as recordingReducer, r as endSession, s as startSession, t as RecordingState } from "../recording-slice-DaxHZvNu.js";
 export { RecordingState, SessionMetadata, endSession, recordDepthSample, recordWriteFailure, recordingReducer, startSession };

package/dist/state/replay-engine.d.ts

@@ -1,2 +1,2 @@
-import { a as ReplayAction, c as computeInterActionDelay, i as ProgressCallback, l as extractActionTimestamp, n as DEFAULT_MAX_DELAY_MS, o as ReplayEngine, r as ErrorCallback, s as ReplayState, t as CompleteCallback } from "../replay-engine-BSVd7Zzb.js";
+import { a as ReplayAction, c as computeInterActionDelay, i as ProgressCallback, l as extractActionTimestamp, n as DEFAULT_MAX_DELAY_MS, o as ReplayEngine, r as ErrorCallback, s as ReplayState, t as CompleteCallback } from "../replay-engine-CmKh_4wf.js";
 export { CompleteCallback, DEFAULT_MAX_DELAY_MS, ErrorCallback, ProgressCallback, ReplayAction, ReplayEngine, ReplayState, computeInterActionDelay, extractActionTimestamp };

package/dist/state/store-subscribers.d.ts

@@ -1,3 +1,3 @@
-import { t as SubscribableStore } from "../subscribe-to-selector-Bp3sLx8L.js";
-import { n as wireStoreSubscribers, t as StoreSubscriberDeps } from "../store-subscribers-BZP81hjh.js";
+import { t as SubscribableStore } from "../subscribe-to-selector-B6EUmQ3I.js";
+import { n as wireStoreSubscribers, t as StoreSubscriberDeps } from "../store-subscribers-CA6AJH_8.js";
 export { StoreSubscriberDeps, SubscribableStore, wireStoreSubscribers };

package/dist/state/subscribe-to-selector.d.ts

@@ -1,2 +1,2 @@
-import { n as subscribeToSelector, t as SubscribableStore } from "../subscribe-to-selector-Bp3sLx8L.js";
+import { n as subscribeToSelector, t as SubscribableStore } from "../subscribe-to-selector-B6EUmQ3I.js";
 export { SubscribableStore, subscribeToSelector };

package/dist/state/tracking-quality.d.ts

@@ -1,2 +1,2 @@
-import { A as resetTrackingQuality, C as computeResidualConsensus, D as firstAgreementReached, E as degradedCountUpdated, F as snapshotsTrimmed, I as trackingQualityReducer, M as selectRecentAlignments, N as selectTrackingQuality, O as matrixDelta, P as snapshotPushed, S as computeGpsVsFusedDivergence, T as createTrackingQualityListenerMiddleware, _ as TrackingQualityState, b as computeCoverage, c as CompassAgreementResult, d as DEFAULT_TRACKING_QUALITY_OPTIONS, f as GpsAccuracyResult, g as TrackingQualitySliceState, h as TrackingQualityReport, j as selectFirstAgreementObservationIndex, k as reportUpdated, l as ConvergenceResult, m as TrackingQualityOptions, p as ResidualConsensusResult, s as AlignmentSnapshot, u as CoverageResult, v as computeCompassAgreement, w as computeTrackingQualityReport, x as computeGpsAccuracy, y as computeConvergence } from "../create-slam-app-store-Ce2FMKCp.js";
-export { AlignmentSnapshot, CompassAgreementResult, ConvergenceResult, CoverageResult, DEFAULT_TRACKING_QUALITY_OPTIONS, GpsAccuracyResult, ResidualConsensusResult, TrackingQualityOptions, TrackingQualityReport, TrackingQualitySliceState, TrackingQualityState, computeCompassAgreement, computeConvergence, computeCoverage, computeGpsAccuracy, computeGpsVsFusedDivergence, computeResidualConsensus, computeTrackingQualityReport, createTrackingQualityListenerMiddleware, degradedCountUpdated, firstAgreementReached, matrixDelta, reportUpdated, resetTrackingQuality, selectFirstAgreementObservationIndex, selectRecentAlignments, selectTrackingQuality, snapshotPushed, snapshotsTrimmed, trackingQualityReducer };
+import { A as snapshotPushed, C as createTrackingQualityListenerMiddleware, D as resetTrackingQuality, E as reportUpdated, M as trackingQualityReducer, O as selectRecentAlignments, S as computeTrackingQualityReport, T as matrixDelta, _ as computeConvergence, b as computeGpsVsFusedDivergence, c as ConvergenceResult, d as GpsAccuracyResult, f as ResidualConsensusResult, g as TrackingQualityState, h as TrackingQualitySliceState, j as snapshotsTrimmed, k as selectTrackingQuality, l as CoverageResult, m as TrackingQualityReport, p as TrackingQualityOptions, s as AlignmentSnapshot, u as DEFAULT_TRACKING_QUALITY_OPTIONS, v as computeCoverage, w as degradedCountUpdated, x as computeResidualConsensus, y as computeGpsAccuracy } from "../create-slam-app-store-n_VF63D5.js";
+export { AlignmentSnapshot, ConvergenceResult, CoverageResult, DEFAULT_TRACKING_QUALITY_OPTIONS, GpsAccuracyResult, ResidualConsensusResult, TrackingQualityOptions, TrackingQualityReport, TrackingQualitySliceState, TrackingQualityState, computeConvergence, computeCoverage, computeGpsAccuracy, computeGpsVsFusedDivergence, computeResidualConsensus, computeTrackingQualityReport, createTrackingQualityListenerMiddleware, degradedCountUpdated, matrixDelta, reportUpdated, resetTrackingQuality, selectRecentAlignments, selectTrackingQuality, snapshotPushed, snapshotsTrimmed, trackingQualityReducer };

package/dist/state/tracking-quality.js

@@ -1,4 +1,5 @@
-import { selectLastSensorOrientation, selectLastValidPose, selectTrackingPhase } from "./tracking-slice.js";
+import { t as geodesicAngleRad } from "../geodesic-angle-BTldfFgs.js";
+import { selectTrackingPhase } from "./tracking-slice.js";
 import { selectAlignmentMatrix, selectGpsPositions, selectOdometryPositions, selectZeroReference } from "./app-selectors.js";
 import { calcGpsCoords, distanceInMeters } from "gps-plus-slam-js";
 import { mat4, quat, vec3 } from "gl-matrix";
@@ -13,19 +14,15 @@ const DEFAULT_TRACKING_QUALITY_OPTIONS = {
 	coverageDirectionSpreadDeg: 90,
 	convergenceRotationWarnDeg: 6,
 	convergenceTranslationWarnM: 2,
-	compassWarnDeg: 15,
-	compassFailDeg: 35,
 	warmupMinObservations: 10,
 	warmupMinCoverage: .5,
 	residualConfidenceTargetM: 3,
 	gpsAccuracyFloorM: 1,
-	firstAgreementMinStreak: 3,
 	degradedHoldoff: 3,
 	convergenceEmaAlpha: .3
 };
 const initialState = {
 	recentAlignments: [],
-	firstAgreementObservationIndex: null,
 	report: null,
 	degradedConsecutiveCount: 0,
 	smoothedConvergence: null
@@ -47,11 +44,6 @@ function emaBlend(prev, raw, alpha) {
 	if (prev === null) return raw;
 	return prev + (Number.isFinite(alpha) ? alpha : 1) * (raw - prev);
 }
-function wrapToHalfCircle(deg) {
-	let d = (deg + 180) % 360 - 180;
-	if (d < -180) d += 360;
-	return d;
-}
 function bearingDeg(north, east) {
 	let deg = Math.atan2(east, north) * 180 / Math.PI;
 	if (deg < 0) deg += 360;
@@ -87,6 +79,11 @@ function rampUp(value, low, high) {
 	if (value >= high) return 1;
 	return (value - low) / (high - low);
 }
+/** True iff every element of the matrix is a finite number (no NaN/Infinity). */
+function isFiniteMatrix(m) {
+	for (let i = 0; i < m.length; i++) if (!Number.isFinite(m[i])) return false;
+	return true;
+}
 /**
 * §4.1 matrix-history convergence over the buffered snapshots.
 *
@@ -118,7 +115,15 @@ function computeConvergence(snapshots, options = {}) {
 	let sumTransM = 0;
 	let pairCount = 0;
 	for (let i = 1; i < snapshots.length; i++) {
-		const { rotationDeltaDeg, translationDeltaM } = matrixDelta(snapshots[i - 1].matrix, snapshots[i].matrix);
+		const prevM = snapshots[i - 1].matrix;
+		const currM = snapshots[i].matrix;
+		if (!isFiniteMatrix(prevM) || !isFiniteMatrix(currM)) {
+			sumRotDeg += rotFail;
+			sumTransM += transFail;
+			pairCount += 1;
+			continue;
+		}
+		const { rotationDeltaDeg, translationDeltaM } = matrixDelta(prevM, currM);
 		sumRotDeg += Math.abs(rotationDeltaDeg);
 		sumTransM += Math.abs(translationDeltaM);
 		pairCount += 1;
@@ -137,7 +142,8 @@ function computeConvergence(snapshots, options = {}) {
 * the column-major layout that gl-matrix and the framework use.
 *
 * Rotation: extract the orientation quaternion with `mat4.getRotation`
-* and compute the relative angle via `quat.getAngle` (degrees).
+* and compute the relative angle via the shared `geodesicAngleRad` kernel
+* (radians, converted to degrees here).
 * Translation: extract the origin column with `mat4.getTranslation` and
 * compute the Euclidean distance.
 *
@@ -161,15 +167,16 @@ function matrixDelta(prev, curr) {
 	mat4.getRotation(currQuat, currMat);
 	quat.normalize(prevQuat, prevQuat);
 	quat.normalize(currQuat, currQuat);
-	const angleRad = quat.getAngle(prevQuat, currQuat);
-	const rotationDeltaDeg = Number.isNaN(angleRad) ? 0 : angleRad * 180 / Math.PI;
+	const angleRad = geodesicAngleRad(prevQuat, currQuat);
+	const rotationDeltaDeg = Number.isFinite(angleRad) ? angleRad * 180 / Math.PI : 0;
 	const prevT = vec3.create();
 	const currT = vec3.create();
 	mat4.getTranslation(prevT, prevMat);
 	mat4.getTranslation(currT, currMat);
+	const rawTranslation = vec3.distance(prevT, currT);
 	return {
 		rotationDeltaDeg,
-		translationDeltaM: vec3.distance(prevT, currT)
+		translationDeltaM: Number.isFinite(rawTranslation) ? rawTranslation : 0
 	};
 }
 /**
@@ -319,56 +326,6 @@ function computeCoverage(odometryPositions, options = {}) {
 	};
 }
 /**
-* §4.3 — Compare the alignment matrix's mapping of AR-forward to ENU
-* against the device compass heading. Returns `score = null` whenever
-* the sensor's `absolute !== true` so the aggregate excludes the
-* sub-score (per Q2 in the plan).
-*
-* AR-forward in our `ARPose` convention is `(0, 0, -1)` (right-handed,
-* Y-up). We rotate that by the alignment's 3×3 rotation, take its
-* North/East components, and compare against the compass alpha.
-*/
-function computeCompassAgreement(alignmentMatrix, sensorOrientation, arPose, options = {}) {
-	const warn = options.warnDeg ?? DEFAULT_TRACKING_QUALITY_OPTIONS.compassWarnDeg;
-	const fail = options.failDeg ?? DEFAULT_TRACKING_QUALITY_OPTIONS.compassFailDeg;
-	if (!alignmentMatrix || !sensorOrientation || !arPose) return {
-		score: null,
-		headingDeltaDeg: null
-	};
-	if (sensorOrientation.absolute !== true) return {
-		score: null,
-		headingDeltaDeg: null
-	};
-	const q = arPose.orientation;
-	const fx = 0;
-	const fy = 0;
-	const fz = -1;
-	const x = q.x, y = q.y, z = q.z, w = q.w;
-	const tx = 2 * (y * fz - z * fy);
-	const ty = 2 * (z * fx - x * fz);
-	const tz = 2 * (x * fy - y * fx);
-	const arForwardLocal = [
-		fx + w * tx + (y * tz - z * ty),
-		fy + w * ty + (z * tx - x * tz),
-		fz + w * tz + (x * ty - y * tx)
-	];
-	const m = alignmentMatrix;
-	const enuN = m[0] * arForwardLocal[0] + m[4] * arForwardLocal[1] + m[8] * arForwardLocal[2];
-	m[1] * arForwardLocal[0] + m[5] * arForwardLocal[1] + m[9] * arForwardLocal[2];
-	const enuE = m[2] * arForwardLocal[0] + m[6] * arForwardLocal[1] + m[10] * arForwardLocal[2];
-	if (Math.hypot(enuN, enuE) < 1e-6) return {
-		score: null,
-		headingDeltaDeg: null
-	};
-	const alignmentHeadingDeg = bearingDeg(enuN, enuE);
-	const compassHeadingDeg = sensorOrientation.alpha;
-	const delta = Math.abs(wrapToHalfCircle(alignmentHeadingDeg - compassHeadingDeg));
-	return {
-		score: rampDown(delta, warn, fail),
-		headingDeltaDeg: delta
-	};
-}
-/**
 * §4.6 — Maximum lateral distance between raw GPS positions and the
 * positions you would predict by transforming the matching odometry
 * positions through the current alignment. Diagnostic only — never
@@ -418,9 +375,6 @@ const trackingQualitySlice = createSlice({
 		reportUpdated(state, action) {
 			state.report = action.payload;
 		},
-		firstAgreementReached(state, action) {
-			state.firstAgreementObservationIndex = action.payload;
-		},
 		/** §4.8 — update the hysteresis counter for ok → degraded holdoff. */
 		degradedCountUpdated(state, action) {
 			state.degradedConsecutiveCount = action.payload;
@@ -439,7 +393,7 @@ const trackingQualitySlice = createSlice({
 		}
 	}
 });
-const { snapshotPushed, snapshotsTrimmed, reportUpdated, firstAgreementReached, degradedCountUpdated, resetTrackingQuality } = trackingQualitySlice.actions;
+const { snapshotPushed, snapshotsTrimmed, reportUpdated, degradedCountUpdated, resetTrackingQuality } = trackingQualitySlice.actions;
 const { smoothedConvergenceUpdated } = trackingQualitySlice.actions;
 const trackingQualityReducer = trackingQualitySlice.reducer;
 function selectTrackingQuality(state) {
@@ -448,9 +402,6 @@ function selectTrackingQuality(state) {
 function selectRecentAlignments(state) {
 	return state.trackingQuality?.recentAlignments ?? EMPTY_SNAPSHOTS;
 }
-function selectFirstAgreementObservationIndex(state) {
-	return state.trackingQuality?.firstAgreementObservationIndex ?? null;
-}
 const EMPTY_SNAPSHOTS = Object.freeze([]);
 /**
 * Pure function — produces a {@link TrackingQualityReport} from a root
@@ -474,10 +425,7 @@ function computeTrackingQualityReport(rootState, options = {}) {
 	const odometryPositions = selectOdometryPositions(rootState);
 	const zeroRef = selectZeroReference(rootState);
 	const trackingPhase = selectTrackingPhase(rootState);
-	const sensorOrientation = selectLastSensorOrientation(rootState);
-	const lastPose = selectLastValidPose(rootState);
 	const snapshots = selectRecentAlignments(rootState);
-	const firstAgreementIdx = selectFirstAgreementObservationIndex(rootState);
 	const coverage = computeCoverage(odometryPositions, {
 		walkedDistanceM: opts.coverageWalkedDistanceM,
 		directionSpreadDeg: opts.coverageDirectionSpreadDeg
@@ -492,15 +440,10 @@ function computeTrackingQualityReport(rootState, options = {}) {
 		rotationWarnDeg: opts.convergenceRotationWarnDeg,
 		translationWarnM: opts.convergenceTranslationWarnM
 	});
-	const compass = computeCompassAgreement(alignmentMatrix, sensorOrientation, lastPose, {
-		warnDeg: opts.compassWarnDeg,
-		failDeg: opts.compassFailDeg
-	});
 	const gpsVsFusedMaxDivergenceM = computeGpsVsFusedDivergence(alignmentMatrix, gpsPositions, odometryPositions, zeroRef);
 	const subScores = {
 		convergence: clamp01(emaBlend(rootState.trackingQuality?.smoothedConvergence ?? null, convergence.score, opts.convergenceEmaAlpha)),
 		residualConsensus: clamp01(residual.score),
-		compassAgreement: compass.score === null ? null : clamp01(compass.score),
 		gpsAccuracy: clamp01(gpsAccuracy.score),
 		coverage: clamp01(coverage.score)
 	};
@@ -510,7 +453,6 @@ function computeTrackingQualityReport(rootState, options = {}) {
 		subScores.gpsAccuracy,
 		subScores.coverage
 	];
-	if (subScores.compassAgreement !== null) aggregateInputs.push(subScores.compassAgreement);
 	const confidence = clamp01(Math.min(...aggregateInputs));
 	const observationsSeen = gpsPositions.length;
 	let state;
@@ -529,8 +471,6 @@ function computeTrackingQualityReport(rootState, options = {}) {
 			medianRecentGpsAccuracyM: gpsAccuracy.medianM,
 			walkedDistanceM: coverage.walkedDistanceM,
 			directionSpreadDeg: coverage.directionSpreadDeg,
-			headingDeltaDeg: compass.headingDeltaDeg,
-			compassDriftDetected: firstAgreementIdx !== null && compass.headingDeltaDeg !== null && compass.headingDeltaDeg > opts.compassWarnDeg,
 			observationsSeen,
 			gpsVsFusedMaxDivergenceM
 		}
@@ -540,15 +480,14 @@ function computeTrackingQualityReport(rootState, options = {}) {
 * Per-field tolerances for the {@link reportsEqual} dispatch gate.
 *
 * Why this exists: `tracking/poseReceived` fires on *every* XR frame
-* (30–60 fps). The §4.3 compass cross-check consumes the live AR pose
-* and sensor heading, so `subScores.compassAgreement` and
-* `diagnostics.headingDeltaDeg` (and, when compass is the minimum,
-* `confidence`) jitter by imperceptible floating-point amounts on a
-* held-still device. With a strict `!==` comparison every such frame
-* produced a fresh `reportUpdated` dispatch → high Redux churn and a
-* HUD re-render at frame rate. The tolerances below quantise those
-* sub-perceptual changes so the gate only fires when the user-visible
-* quality actually moved.
+* (30–60 fps). The per-frame recompute reuses GPS/odometry windows that
+* are unchanged between pose frames, so the float sub-scores and
+* diagnostics (and `confidence`) jitter by imperceptible floating-point
+* amounts on a held-still device. With a strict `!==` comparison every
+* such frame produced a fresh `reportUpdated` dispatch → high Redux
+* churn and a HUD re-render at frame rate. The tolerances below quantise
+* those sub-perceptual changes so the gate only fires when the
+* user-visible quality actually moved.
 *
 * The gate compares the freshly computed report against the *last
 * dispatched* report (the stored `prev`), not against the previous
@@ -567,10 +506,9 @@ const REPORT_METRE_EPSILON_M = .001;
 * (both `null` ⇒ equal; exactly one `null` ⇒ different) and otherwise
 * compares with an absolute epsilon. Non-finite values are compared with
 * {@link Object.is}, so a genuine finite↔NaN/Infinity transition still
-* fires a dispatch, but a *persistently* NaN diagnostic (the only
-* unguarded path is a NaN compass `alpha` leaking into
-* `diagnostics.headingDeltaDeg`) does NOT churn the gate every frame —
-* `Object.is(NaN, NaN)` is `true` whereas `NaN === NaN` is `false`.
+* fires a dispatch, but a *persistently* NaN diagnostic does NOT churn
+* the gate every frame — `Object.is(NaN, NaN)` is `true` whereas
+* `NaN === NaN` is `false`.
 */
 function nearlyEqual(a, b, eps) {
 	if (a === null || b === null) return a === b;
@@ -585,8 +523,8 @@ function nearlyEqual(a, b, eps) {
 *
 * Float fields use the per-field tolerances above
 * ({@link REPORT_SCORE_EPSILON} et al.) so imperceptible per-frame
-* compass jitter does not churn the store — see the constants' doc
-* comment for the rationale.
+* jitter does not churn the store — see the constants' doc comment for
+* the rationale.
 */
 function reportsEqual(a, b) {
 	if (a === b) return true;
@@ -595,10 +533,10 @@ function reportsEqual(a, b) {
 	if (!nearlyEqual(a.confidence, b.confidence, REPORT_SCORE_EPSILON)) return false;
 	const sa = a.subScores;
 	const sb = b.subScores;
-	if (!nearlyEqual(sa.convergence, sb.convergence, REPORT_SCORE_EPSILON) || !nearlyEqual(sa.residualConsensus, sb.residualConsensus, REPORT_SCORE_EPSILON) || !nearlyEqual(sa.compassAgreement, sb.compassAgreement, REPORT_SCORE_EPSILON) || !nearlyEqual(sa.gpsAccuracy, sb.gpsAccuracy, REPORT_SCORE_EPSILON) || !nearlyEqual(sa.coverage, sb.coverage, REPORT_SCORE_EPSILON)) return false;
+	if (!nearlyEqual(sa.convergence, sb.convergence, REPORT_SCORE_EPSILON) || !nearlyEqual(sa.residualConsensus, sb.residualConsensus, REPORT_SCORE_EPSILON) || !nearlyEqual(sa.gpsAccuracy, sb.gpsAccuracy, REPORT_SCORE_EPSILON) || !nearlyEqual(sa.coverage, sb.coverage, REPORT_SCORE_EPSILON)) return false;
 	const da = a.diagnostics;
 	const db = b.diagnostics;
-	return da.compassDriftDetected === db.compassDriftDetected && da.observationsSeen === db.observationsSeen && nearlyEqual(da.recentSumRotationDeltaDeg, db.recentSumRotationDeltaDeg, REPORT_ANGLE_EPSILON_DEG) && nearlyEqual(da.directionSpreadDeg, db.directionSpreadDeg, REPORT_ANGLE_EPSILON_DEG) && nearlyEqual(da.headingDeltaDeg, db.headingDeltaDeg, REPORT_ANGLE_EPSILON_DEG) && nearlyEqual(da.recentSumTranslationDeltaM, db.recentSumTranslationDeltaM, REPORT_METRE_EPSILON_M) && nearlyEqual(da.medianResidualM, db.medianResidualM, REPORT_METRE_EPSILON_M) && nearlyEqual(da.medianRecentGpsAccuracyM, db.medianRecentGpsAccuracyM, REPORT_METRE_EPSILON_M) && nearlyEqual(da.walkedDistanceM, db.walkedDistanceM, REPORT_METRE_EPSILON_M) && nearlyEqual(da.gpsVsFusedMaxDivergenceM, db.gpsVsFusedMaxDivergenceM, REPORT_METRE_EPSILON_M);
+	return da.observationsSeen === db.observationsSeen && nearlyEqual(da.recentSumRotationDeltaDeg, db.recentSumRotationDeltaDeg, REPORT_ANGLE_EPSILON_DEG) && nearlyEqual(da.directionSpreadDeg, db.directionSpreadDeg, REPORT_ANGLE_EPSILON_DEG) && nearlyEqual(da.recentSumTranslationDeltaM, db.recentSumTranslationDeltaM, REPORT_METRE_EPSILON_M) && nearlyEqual(da.medianResidualM, db.medianResidualM, REPORT_METRE_EPSILON_M) && nearlyEqual(da.medianRecentGpsAccuracyM, db.medianRecentGpsAccuracyM, REPORT_METRE_EPSILON_M) && nearlyEqual(da.walkedDistanceM, db.walkedDistanceM, REPORT_METRE_EPSILON_M) && nearlyEqual(da.gpsVsFusedMaxDivergenceM, db.gpsVsFusedMaxDivergenceM, REPORT_METRE_EPSILON_M);
 }
 function matricesNearlyEqual(a, b) {
 	if (a.length !== b.length) return false;
@@ -650,16 +588,14 @@ function createTrackingQualityListenerMiddleware(options = {}) {
 		...DEFAULT_TRACKING_QUALITY_OPTIONS,
 		...options
 	};
-	let compassStreak = 0;
 	const listenerMiddleware = createListenerMiddleware();
 	listenerMiddleware.startListening({
 		predicate: (action) => inputActionPredicate(action),
 		effect: (action, api) => {
 			const state = api.getState();
 			if (action.type === TRACKING_QUALITY_INPUT_ACTIONS.startSession || action.type === TRACKING_QUALITY_INPUT_ACTIONS.resetTracking) {
-				compassStreak = 0;
 				const tq = state.trackingQuality;
-				if (tq && (tq.recentAlignments.length > 0 || tq.firstAgreementObservationIndex !== null || tq.report !== null || tq.degradedConsecutiveCount > 0)) api.dispatch(resetTrackingQuality());
+				if (tq && (tq.recentAlignments.length > 0 || tq.report !== null || tq.degradedConsecutiveCount > 0)) api.dispatch(resetTrackingQuality());
 				return;
 			}
 			if (action.type === TRACKING_QUALITY_INPUT_ACTIONS.gpsRecorded || action.type === TRACKING_QUALITY_INPUT_ACTIONS.setZeroPos) {
@@ -678,30 +614,6 @@ function createTrackingQualityListenerMiddleware(options = {}) {
 					}
 				}
 			}
-			const midState = api.getState();
-			const midTq = midState.trackingQuality;
-			if (midTq && midTq.firstAgreementObservationIndex === null) {
-				const snapshots = selectRecentAlignments(midState);
-				if (snapshots.length >= 2) {
-					const conv = computeConvergence(snapshots, {
-						rotationWarnDeg: opts.convergenceRotationWarnDeg,
-						translationWarnM: opts.convergenceTranslationWarnM
-					});
-					const sensorOr = selectLastSensorOrientation(midState);
-					const pose = selectLastValidPose(midState);
-					const compass = computeCompassAgreement(selectAlignmentMatrix(midState), sensorOr, pose, {
-						warnDeg: opts.compassWarnDeg,
-						failDeg: opts.compassFailDeg
-					});
-					if (conv.score >= .7 && compass.headingDeltaDeg !== null && compass.headingDeltaDeg <= opts.compassWarnDeg) {
-						compassStreak += 1;
-						if (compassStreak >= opts.firstAgreementMinStreak) {
-							const obsCount = selectGpsPositions(midState).length;
-							api.dispatch(firstAgreementReached(obsCount));
-						}
-					} else compassStreak = 0;
-				}
-			}
 			const next = api.getState();
 			const report = computeTrackingQualityReport(next, opts);
 			const prev = next.trackingQuality?.report ?? null;
@@ -720,4 +632,4 @@ function createTrackingQualityListenerMiddleware(options = {}) {
 	return listenerMiddleware.middleware;
 }
 //#endregion
-export { DEFAULT_TRACKING_QUALITY_OPTIONS, computeCompassAgreement, computeConvergence, computeCoverage, computeGpsAccuracy, computeGpsVsFusedDivergence, computeResidualConsensus, computeTrackingQualityReport, createTrackingQualityListenerMiddleware, degradedCountUpdated, firstAgreementReached, matrixDelta, reportUpdated, resetTrackingQuality, selectFirstAgreementObservationIndex, selectRecentAlignments, selectTrackingQuality, snapshotPushed, snapshotsTrimmed, trackingQualityReducer };
+export { DEFAULT_TRACKING_QUALITY_OPTIONS, computeConvergence, computeCoverage, computeGpsAccuracy, computeGpsVsFusedDivergence, computeResidualConsensus, computeTrackingQualityReport, createTrackingQualityListenerMiddleware, degradedCountUpdated, matrixDelta, reportUpdated, resetTrackingQuality, selectRecentAlignments, selectTrackingQuality, snapshotPushed, snapshotsTrimmed, trackingQualityReducer };

package/dist/state/tracking-slice.d.ts

@@ -1,2 +1,2 @@
-import { a as TrackingSliceState, c as poseLost, d as selectLastRestartedPayload, f as selectLastSensorOrientation, g as trackingReducer, h as selectTrackingPhase, i as TrackingPhase, l as poseReceived, m as selectLostFrameCount, n as PoseReceivedPayload, o as clearLastRestartedPayload, p as selectLastValidPose, r as ResetTransformData, s as originReset, t as DeviceOrientation, u as resetTracking } from "../tracking-slice-DJZ9qeGg.js";
+import { a as TrackingSliceState, c as poseLost, d as selectLastRestartedPayload, f as selectLastSensorOrientation, g as trackingReducer, h as selectTrackingPhase, i as TrackingPhase, l as poseReceived, m as selectLostFrameCount, n as PoseReceivedPayload, o as clearLastRestartedPayload, p as selectLastValidPose, r as ResetTransformData, s as originReset, t as DeviceOrientation, u as resetTracking } from "../tracking-slice-BuAZxXZ5.js";
 export { DeviceOrientation, PoseReceivedPayload, ResetTransformData, TrackingPhase, TrackingSliceState, clearLastRestartedPayload, originReset, poseLost, poseReceived, resetTracking, selectLastRestartedPayload, selectLastSensorOrientation, selectLastValidPose, selectLostFrameCount, selectTrackingPhase, trackingReducer };