gps-plus-slam-app-framework 1.3.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,
@@ -40,6 +44,27 @@ const DEFAULT_RECORDING_OPTIONS = {
 		enableCss3dRenderer: true,
 		enableCameraTextureAcquisition: true,
 		applyChromiumProjectionLayerWorkaround: true
+	},
+	occupancy: {
+		cellSizeM: .15,
+		minConfidence: 3
+	},
+	frameTileDisplay: { divisor: 2 },
+	visualization: {
+		frameTiles: true,
+		occupancyCubes: true,
+		gpsAlignmentMarkers: true,
+		compassCubes: true
+	},
+	qr: {
+		enabled: false,
+		intervalMs: 125,
+		captureSize: 1024
+	},
+	compassDebug: {
+		coldStartOverride: true,
+		rotationPrior: false,
+		webXRConsistency: false
 	}
 };
 /** Validation constraints for depth options */
@@ -74,6 +99,125 @@ 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
+* therefore the cube `InstancedMesh`, the grid `Map`, and the COLMAP
+* `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
+	},
+	minConfidence: {
+		min: 1,
+		max: 10,
+		step: 1
+	}
+};
+/**
+* Validation constraints for the frame-tile display-resolution divisor.
+*
+* Clamped to 1–8 (full down to one-eighth per dimension), mirroring the capture
+* `IMAGE_CONSTRAINTS.resolutionDivisor` range so the settings slider behaves the
+* same. The intended stops are 1, 2, 4, 8 (full / half / quarter / eighth); the
+* divisor is rounded to an integer so the resize target dimensions stay clean.
+*/
+const FRAME_TILE_DISPLAY_CONSTRAINTS = { divisor: {
+	min: 1,
+	max: 8,
+	step: 1
+} };
+/**
+* Validation constraints for QR-capture options.
+*
+* `intervalMs` is clamped to 50–1000 ms (20 Hz down to 1 Hz): below ~50 ms the
+* detector cannot keep up and frames just queue; above 1 s tracking feels dead.
+* `captureSize` is clamped to 256–2048 px: under 256 even a near QR loses its
+* modules; over 2048 the blit + decode cost is not worth it on a phone. Both
+* back a settings slider so a corrupt stored value can never break capture.
+*/
+const QR_CONSTRAINTS = {
+	intervalMs: {
+		min: 50,
+		max: 1e3,
+		step: 25
+	},
+	captureSize: {
+		min: 256,
+		max: 2048,
+		step: 128
+	}
+};
+/**
 * Validate and normalize AR crash isolation flags.
 * Missing or invalid values fall back to defaults.
 */
@@ -89,12 +233,56 @@ 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
+* the ON default so an overlay is never silently disabled by bad input.
+*/
+function validateVisualizationOptions(options) {
+	const defaults = DEFAULT_RECORDING_OPTIONS.visualization;
+	return {
+		frameTiles: typeof options.frameTiles === "boolean" ? options.frameTiles : defaults.frameTiles,
+		occupancyCubes: typeof options.occupancyCubes === "boolean" ? options.occupancyCubes : defaults.occupancyCubes,
+		gpsAlignmentMarkers: typeof options.gpsAlignmentMarkers === "boolean" ? options.gpsAlignmentMarkers : defaults.gpsAlignmentMarkers,
+		compassCubes: typeof options.compassCubes === "boolean" ? options.compassCubes : defaults.compassCubes
+	};
+}
+/**
 * Clamp a value to the specified constraints.
 */
 function clamp(value, min, max) {
 	return Math.max(min, Math.min(max, value));
 }
 /**
+* Validate and normalize QR-capture options. `enabled` is boolean-or-default
+* (a corrupt/pre-feature value falls back to the OFF default so QR never
+* silently turns ON); `intervalMs`/`captureSize` are clamped to
+* {@link QR_CONSTRAINTS}, with a `Number.isFinite` guard so a stored `NaN`
+* (which is `typeof 'number'` and survives `clamp`) falls back to the default
+* rather than breaking the camera-frame source.
+*/
+function validateQrOptions(options) {
+	const defaults = DEFAULT_RECORDING_OPTIONS.qr;
+	return {
+		enabled: typeof options.enabled === "boolean" ? options.enabled : defaults.enabled,
+		intervalMs: clamp(typeof options.intervalMs === "number" && Number.isFinite(options.intervalMs) ? options.intervalMs : defaults.intervalMs, QR_CONSTRAINTS.intervalMs.min, QR_CONSTRAINTS.intervalMs.max),
+		captureSize: clamp(typeof options.captureSize === "number" && Number.isFinite(options.captureSize) ? options.captureSize : defaults.captureSize, QR_CONSTRAINTS.captureSize.min, QR_CONSTRAINTS.captureSize.max)
+	};
+}
+/**
 * Validate and normalize depth options.
 * Invalid values are clamped to valid ranges.
 */
@@ -103,11 +291,46 @@ function validateDepthOptions(options) {
 	return {
 		enabled: typeof options.enabled === "boolean" ? options.enabled : defaults.enabled,
 		intervalMs: clamp(typeof options.intervalMs === "number" ? options.intervalMs : defaults.intervalMs, DEPTH_CONSTRAINTS.intervalMs.min, DEPTH_CONSTRAINTS.intervalMs.max),
-		gridSize: clamp(typeof options.gridSize === "number" ? options.gridSize : defaults.gridSize, DEPTH_CONSTRAINTS.gridSize.min, DEPTH_CONSTRAINTS.gridSize.max),
+		gridSize: clamp(typeof options.gridSize === "number" && Number.isFinite(options.gridSize) ? Math.round(options.gridSize) : defaults.gridSize, DEPTH_CONSTRAINTS.gridSize.min, DEPTH_CONSTRAINTS.gridSize.max),
 		rgb: typeof options.rgb === "boolean" ? options.rgb : defaults.rgb
 	};
 }
 /**
+* 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.
 */
@@ -117,10 +340,39 @@ 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 ?? {})
 	};
 }
 /**
+* Validate and normalize occupancy options.
+* Invalid values are clamped to valid ranges.
+*
+* Note the explicit `Number.isFinite` guard: `OccupancyGrid` throws a
+* `RangeError` on a non-finite cell size, and `clamp(NaN, …)` would otherwise
+* pass `NaN` straight through (it is `typeof 'number'`). Falling back to the
+* default keeps a corrupted stored value from crashing grid construction.
+*/
+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),
+		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
+* {@link FRAME_TILE_DISPLAY_CONSTRAINTS} and rounded to an integer, with a
+* `Number.isFinite` guard so a stored `NaN` (which is `typeof 'number'` and
+* survives `clamp`) falls back to the default rather than producing a broken
+* resize target.
+*/
+function validateFrameTileDisplayOptions(options) {
+	const defaults = DEFAULT_RECORDING_OPTIONS.frameTileDisplay;
+	return { divisor: clamp(typeof options.divisor === "number" && Number.isFinite(options.divisor) ? Math.round(options.divisor) : defaults.divisor, FRAME_TILE_DISPLAY_CONSTRAINTS.divisor.min, FRAME_TILE_DISPLAY_CONSTRAINTS.divisor.max) };
+}
+/**
 * Validate and normalize a full RecordingOptions object.
 * Merges with defaults and clamps invalid values.
 */
@@ -128,7 +380,12 @@ function validateRecordingOptions(options) {
 	return {
 		depth: validateDepthOptions(options.depth ?? {}),
 		images: validateImageOptions(options.images ?? {}),
-		arCrashIsolation: validateArCrashIsolationOptions(options.arCrashIsolation ?? {})
+		arCrashIsolation: validateArCrashIsolationOptions(options.arCrashIsolation ?? {}),
+		occupancy: validateOccupancyOptions(options.occupancy ?? {}),
+		frameTileDisplay: validateFrameTileDisplayOptions(options.frameTileDisplay ?? {}),
+		visualization: validateVisualizationOptions(options.visualization ?? {}),
+		qr: validateQrOptions(options.qr ?? {}),
+		compassDebug: validateCompassDebugOptions(options.compassDebug ?? {})
 	};
 }
 /**
@@ -186,9 +443,18 @@ function resetRecordingOptions(storageKey = STORAGE_KEY) {
 function cloneRecordingOptions(options) {
 	return {
 		depth: { ...options.depth },
-		images: { ...options.images },
-		arCrashIsolation: { ...options.arCrashIsolation }
+		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 },
+		compassDebug: { ...options.compassDebug }
 	};
 }
 //#endregion
-export { DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, IMAGE_CONSTRAINTS, STORAGE_KEY, cloneRecordingOptions, loadRecordingOptions, resetRecordingOptions, saveRecordingOptions, validateArCrashIsolationOptions, validateDepthOptions, validateImageOptions, validateRecordingOptions };
+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-BljusOua.js";
-import { n as replayRecording, t as ReplayRecordingOptions } from "../recording-replayer-r0DZ9ALp.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-89O07ebs.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/recording-slice.js

@@ -11,8 +11,12 @@ const recordingSlice = createSlice({
 	},
 	reducers: {
 		startSession(state, action) {
+			const { scenarioName, contextTag, ...rest } = action.payload;
 			state.isRecording = true;
-			state.sessionMetadata = action.payload;
+			state.sessionMetadata = {
+				...rest,
+				contextTag: contextTag ?? scenarioName ?? ""
+			};
 			state.actionCount = 0;
 			state.failedWriteCount = 0;
 			state.latestDepthSample = null;

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-XpDa0dy1.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/replay-engine.js

@@ -7,9 +7,12 @@ const MAX_CONSECUTIVE_ERRORS = 10;
 * Extract an absolute epoch-ms timestamp from a Redux action, or null
 * if the action type doesn't carry one.
 *
-* IMPORTANT: depthSample uses performance.now() (relative to page load),
-* NOT epoch ms. Returning it here would mix clock domains and produce
-* garbage delays. It must return null. (Risk R4)
+* IMPORTANT: the high-frequency sensor streams (depthSample, qrDetected) return
+* null here ON PURPOSE — they are NOT used to pace replay delays (they anchor to
+* the GPS/image/session timeline by recorded ORDER instead). Their payload
+* `timestamp` IS epoch ms (`performance.timeOrigin + frameTs`, see
+* `ar/depth-sampler.ts`); the QR size as-of join reads those payload timestamps
+* directly, independently of this pacing function. (Risk R4)
 *
 * @param action - A Redux action with type and optional payload
 * @returns Epoch milliseconds, or null if unavailable/unreliable
@@ -37,6 +40,7 @@ function extractActionTimestamp(action) {
 			return null;
 		}
 		case "recording/recordDepthSample": return null;
+		case "qrDetected/recordQrDetection": return null;
 		case "recording/endSession": return null;
 		default: return null;
 	}

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

@@ -1,3 +1,3 @@
-import { t as SubscribableStore } from "../subscribe-to-selector-CZ6k1NFP.js";
-import { n as wireStoreSubscribers, t as StoreSubscriberDeps } from "../store-subscribers-0YWyOLvV.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-CZ6k1NFP.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-BljusOua.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 };