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

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

@@ -1,2 +1,2 @@
-import { C as validateFrameTileDisplayOptions, D as validateRecordingOptions, E as validateQrOptions, O as validateVisualizationOptions, S as validateDepthOptions, T as validateOccupancyOptions, _ as cloneRecordingOptions, a as FRAME_TILE_DISPLAY_CONSTRAINTS, b as saveRecordingOptions, c as ImageCaptureOptions, d as QR_CONSTRAINTS, f as QrCaptureOptions, g as VisualizationOptions, h as STORAGE_KEY, i as DepthCaptureOptions, l as OCCUPANCY_CONSTRAINTS, m as RecordingOptionsInput, n as DEFAULT_RECORDING_OPTIONS, o as FrameTileDisplayOptions, p as RecordingOptions, r as DEPTH_CONSTRAINTS, s as IMAGE_CONSTRAINTS, t as ArCrashIsolationOptions, u as OccupancyOptions, v as loadRecordingOptions, w as validateImageOptions, x as validateArCrashIsolationOptions, y as resetRecordingOptions } from "../recording-options-D93kksJU.js";
-export { ArCrashIsolationOptions, DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, DepthCaptureOptions, FRAME_TILE_DISPLAY_CONSTRAINTS, FrameTileDisplayOptions, IMAGE_CONSTRAINTS, ImageCaptureOptions, OCCUPANCY_CONSTRAINTS, OccupancyOptions, QR_CONSTRAINTS, QrCaptureOptions, RecordingOptions, RecordingOptionsInput, STORAGE_KEY, VisualizationOptions, cloneRecordingOptions, loadRecordingOptions, resetRecordingOptions, saveRecordingOptions, validateArCrashIsolationOptions, validateDepthOptions, validateFrameTileDisplayOptions, validateImageOptions, validateOccupancyOptions, validateQrOptions, validateRecordingOptions, validateVisualizationOptions };
+import { A as validateImageOptions, C as loadRecordingOptions, D as validateCompassDebugOptions, E as validateArCrashIsolationOptions, F as validateRecordingOptions, I as validateVisualizationOptions, M as validateOccupancyOptions, N as validateQrOptions, O as validateDepthOptions, P as validateQualityFilterOptions, S as cloneRecordingOptions, T as saveRecordingOptions, _ as QrCaptureOptions, a as DepthCaptureOptions, b as STORAGE_KEY, c as IMAGE_CONSTRAINTS, d as OCCUPANCY_CONSTRAINTS, f as OccluderDebugStyle, g as QUALITY_FILTER_CONSTRAINTS, h as QR_CONSTRAINTS, i as DEPTH_CONSTRAINTS, j as validateMotionFilterOptions, k as validateFrameTileDisplayOptions, l as ImageCaptureOptions, m as OccupancyOptions, n as CompassDebugOptions, o as FRAME_TILE_DISPLAY_CONSTRAINTS, p as OccluderMeshMode, r as DEFAULT_RECORDING_OPTIONS, s as FrameTileDisplayOptions, t as ArCrashIsolationOptions, u as MOTION_FILTER_CONSTRAINTS, v as RecordingOptions, w as resetRecordingOptions, x as VisualizationOptions, y as RecordingOptionsInput } from "../recording-options-vASCFzc5.js";
+export { ArCrashIsolationOptions, CompassDebugOptions, DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, DepthCaptureOptions, FRAME_TILE_DISPLAY_CONSTRAINTS, FrameTileDisplayOptions, IMAGE_CONSTRAINTS, ImageCaptureOptions, MOTION_FILTER_CONSTRAINTS, OCCUPANCY_CONSTRAINTS, OccluderDebugStyle, OccluderMeshMode, OccupancyOptions, QR_CONSTRAINTS, QUALITY_FILTER_CONSTRAINTS, QrCaptureOptions, RecordingOptions, RecordingOptionsInput, STORAGE_KEY, VisualizationOptions, cloneRecordingOptions, loadRecordingOptions, resetRecordingOptions, saveRecordingOptions, validateArCrashIsolationOptions, validateCompassDebugOptions, validateDepthOptions, validateFrameTileDisplayOptions, validateImageOptions, validateMotionFilterOptions, validateOccupancyOptions, validateQrOptions, validateQualityFilterOptions, validateRecordingOptions, validateVisualizationOptions };

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-_NdTSwKi.js";
+import { DEFAULT_QUALITY_FILTER } from "../ar/image-quality.js";
 //#region ../src/state/recording-options.ts
 /**
 * Recording Options - User-configurable settings for data capture.
@@ -10,6 +12,55 @@ import { createLogger } from "../utils/logger.js";
 */
 const log = createLogger("RecordingOptions");
 /**
+* Configuration for the derived AR-space occupancy grid (the voxelization of
+* the depth samples, port plan 2026-06-11). These settings do NOT change what
+* is recorded — they govern the grid derived from the recorded depth points,
+* so they also apply when replaying an existing recording, letting the same
+* session be re-quantized at a different resolution.
+*/
+/**
+* Mesher strategy for the **persistent occluder** mesh, exposed as a recorder
+* setting (2026-06-30 occluder-tuning, F2/F2b) so the two surface-hugging
+* approaches can be A/B-tested on-device against the blocky baseline:
+* - `'greedy'` — blocky greedy cubes (the existing default; fewest triangles).
+* - `'corner-fit'` — cubes with corners pulled to the measured centroids
+*   (surface-hugging **and** watertight).
+* - `'smooth'` — surface nets: smoothest, hugs the measured surface, but an open
+*   sheet over thin features.
+*
+* Maps directly onto `meshOccupiedCells` / `OcclusionMesh` `MeshMode` (a subset).
+* `'per-face'` is intentionally not offered (same shape as `'greedy'`, more
+* triangles — no on-device value).
+*/
+const OCCLUDER_MESH_MODES = [
+	"greedy",
+	"corner-fit",
+	"smooth"
+];
+/**
+* Debug-visualization style for the **persistent occluder** mesh (2026-07-02
+* debug-viz-styles plan) — which visible debug skin(s) `OcclusionMesh` renders
+* on top of the invisible depth-only occluder:
+* - `'off'` — no debug rendering (the shipped default; occlusion is invisible).
+* - `'matcap'` — the original shiny semi-transparent cyan skin.
+* - `'depth-shaded'` — matcap + camera-distance fade + white fresnel rim, so
+*   overlapping near/far surfaces read as separate shells.
+* - `'wireframe'` — the raw triangulation as GL lines (mesh-structure
+*   inspection: triangle density, mesher seams, degenerate spots).
+* - `'depth-shaded-wireframe'` — both of the above composed.
+*
+* Values array module-private (validation only; the settings `<select>`
+* options are hardcoded in the recorder's `index.html`), type exported —
+* mirroring `OCCLUDER_MESH_MODES` / {@link OccluderMeshMode}.
+*/
+const OCCLUDER_DEBUG_STYLES = [
+	"off",
+	"matcap",
+	"depth-shaded",
+	"wireframe",
+	"depth-shaded-wireframe"
+];
+/**
 * localStorage key for persisted options.
 *
 * **Multi-tab caveat:** All tabs/instances sharing the same origin will
@@ -23,15 +74,17 @@ const STORAGE_KEY = "gps-plus-slam-recorder-options";
 const DEFAULT_RECORDING_OPTIONS = {
 	depth: {
 		enabled: true,
-		intervalMs: 1e3,
-		gridSize: 16,
+		intervalMs: 500,
+		gridSize: 32,
 		rgb: true
 	},
 	images: {
 		enabled: true,
 		intervalMs: 2e3,
 		quality: .7,
-		resolutionDivisor: 1
+		resolutionDivisor: 1,
+		motionFilter: { ...DEFAULT_MOTION_FILTER },
+		qualityFilter: { ...DEFAULT_QUALITY_FILTER }
 	},
 	arCrashIsolation: {
 		enableDomOverlay: true,
@@ -41,18 +94,36 @@ const DEFAULT_RECORDING_OPTIONS = {
 		enableCameraTextureAcquisition: true,
 		applyChromiumProjectionLayerWorkaround: true
 	},
-	occupancy: { cellSizeM: .15 },
-	frameTileDisplay: { divisor: 2 },
+	occupancy: {
+		cellSizeM: .15,
+		minConfidence: 3,
+		persistentOcclusion: true,
+		liveOcclusion: false,
+		occluderDebugStyle: "off",
+		occluderMeshMode: "smooth",
+		occluderRadiusM: 25
+	},
+	frameTileDisplay: {
+		divisor: 2,
+		maxTiles: 100
+	},
 	visualization: {
 		frameTiles: true,
 		occupancyCubes: true,
 		gpsAlignmentMarkers: true,
-		compassCubes: true
+		compassCubes: true,
+		headingUpMap: true,
+		statsOverlay: false
 	},
 	qr: {
 		enabled: false,
 		intervalMs: 125,
 		captureSize: 1024
+	},
+	compassDebug: {
+		coldStartOverride: true,
+		rotationPrior: false,
+		webXRConsistency: false
 	}
 };
 /** Validation constraints for depth options */
@@ -64,7 +135,7 @@ const DEPTH_CONSTRAINTS = {
 	},
 	gridSize: {
 		min: 2,
-		max: 32,
+		max: 64,
 		step: 1
 	}
 };
@@ -87,6 +158,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 +224,29 @@ 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
+	},
+	occluderRadiusM: {
+		min: 0,
+		max: 200,
+		step: 5
+	}
+};
 /**
 * Validation constraints for the frame-tile display-resolution divisor.
 *
@@ -108,11 +255,18 @@ const OCCUPANCY_CONSTRAINTS = { cellSizeM: {
 * 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
-} };
+const FRAME_TILE_DISPLAY_CONSTRAINTS = {
+	divisor: {
+		min: 1,
+		max: 8,
+		step: 1
+	},
+	maxTiles: {
+		min: 0,
+		max: 2e3,
+		step: 10
+	}
+};
 /**
 * Validation constraints for QR-capture options.
 *
@@ -150,6 +304,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
@@ -161,7 +328,9 @@ function validateVisualizationOptions(options) {
 		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
+		compassCubes: typeof options.compassCubes === "boolean" ? options.compassCubes : defaults.compassCubes,
+		headingUpMap: typeof options.headingUpMap === "boolean" ? options.headingUpMap : defaults.headingUpMap,
+		statsOverlay: typeof options.statsOverlay === "boolean" ? options.statsOverlay : defaults.statsOverlay
 	};
 }
 /**
@@ -200,6 +369,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 +413,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 ?? {})
 	};
 }
 /**
@@ -220,10 +426,56 @@ function validateImageOptions(options) {
 * `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.
+*
+* **Backward-compat migration:** the occlusion options were a single
+* `occlusionMeshEnabled` boolean before 2026-06-29; they are now the two
+* composable booleans `persistentOcclusion` + `liveOcclusion`. A persisted
+* object that predates the split carries only the legacy field, so when the new
+* `persistentOcclusion` is absent we read `occlusionMeshEnabled` and map
+* `true → persistentOcclusion: true` (the old mesh occluder is the persistent
+* one); the legacy shape never enabled a live occluder, so `liveOcclusion`
+* stays at its default. A present new field always wins over the legacy one.
+* See `2026-06-29-occupancy-mesh-followups.md`.
+*/
+/**
+* Resolve `persistentOcclusion` with legacy migration. A **present** new field
+* always wins over the legacy `occlusionMeshEnabled` — even when its value is
+* invalid: a present-but-corrupt value falls back to the default, never to the
+* legacy flag, so corrupted saved options can't silently flip the occluder
+* against the "new field wins" contract. Only an **absent** new field migrates
+* the legacy boolean (`true → persistent on`); else the default.
 */
+function resolvePersistentOcclusion(options, legacyOcclusionMeshEnabled, defaultValue) {
+	if ("persistentOcclusion" in options) return typeof options.persistentOcclusion === "boolean" ? options.persistentOcclusion : defaultValue;
+	return typeof legacyOcclusionMeshEnabled === "boolean" ? legacyOcclusionMeshEnabled : defaultValue;
+}
+/**
+* Resolve `occluderDebugStyle` with legacy migration, following the same
+* contract as {@link resolvePersistentOcclusion}: a **present** new field
+* always wins over the legacy `occluderDebugViz` boolean — even when its value
+* is unknown/corrupt it falls back to the default (`'off'`), never to the
+* legacy flag, so corrupted saved options can't silently turn a debug render
+* on. Only an **absent** new field migrates the legacy boolean
+* (`true → 'matcap'`, the skin the boolean used to enable); else the default.
+*/
+function resolveOccluderDebugStyle(options, legacyOccluderDebugViz, defaultValue) {
+	if ("occluderDebugStyle" in options) return OCCLUDER_DEBUG_STYLES.includes(options.occluderDebugStyle) ? options.occluderDebugStyle : defaultValue;
+	if (typeof legacyOccluderDebugViz === "boolean") return legacyOccluderDebugViz ? "matcap" : "off";
+	return defaultValue;
+}
 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) };
+	const legacyOcclusionMeshEnabled = options.occlusionMeshEnabled;
+	const legacyOccluderDebugViz = options.occluderDebugViz;
+	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),
+		persistentOcclusion: resolvePersistentOcclusion(options, legacyOcclusionMeshEnabled, defaults.persistentOcclusion),
+		liveOcclusion: typeof options.liveOcclusion === "boolean" ? options.liveOcclusion : defaults.liveOcclusion,
+		occluderDebugStyle: resolveOccluderDebugStyle(options, legacyOccluderDebugViz, defaults.occluderDebugStyle),
+		occluderMeshMode: OCCLUDER_MESH_MODES.includes(options.occluderMeshMode) ? options.occluderMeshMode : defaults.occluderMeshMode,
+		occluderRadiusM: clamp(typeof options.occluderRadiusM === "number" && Number.isFinite(options.occluderRadiusM) ? Math.round(options.occluderRadiusM) : defaults.occluderRadiusM, OCCUPANCY_CONSTRAINTS.occluderRadiusM.min, OCCUPANCY_CONSTRAINTS.occluderRadiusM.max)
+	};
 }
 /**
 * Validate and normalize frame-tile display options. `divisor` is clamped to
@@ -234,7 +486,10 @@ function validateOccupancyOptions(options) {
 */
 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) };
+	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),
+		maxTiles: clamp(typeof options.maxTiles === "number" && Number.isFinite(options.maxTiles) ? Math.round(options.maxTiles) : defaults.maxTiles, FRAME_TILE_DISPLAY_CONSTRAINTS.maxTiles.min, FRAME_TILE_DISPLAY_CONSTRAINTS.maxTiles.max)
+	};
 }
 /**
 * Validate and normalize a full RecordingOptions object.
@@ -248,7 +503,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 +562,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-D3nzh9Wb.js";
+import { n as replayRecording, t as ReplayRecordingOptions } from "../recording-replayer-D0V9WkmY.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-DXiAnJwR.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-DTUtSVgd.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-xdrUgWJi.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-B9ylM5Oh.js";
+import { n as wireStoreSubscribers, t as StoreSubscriberDeps } from "../store-subscribers-DScA7tdT.js";
 export { StoreSubscriberDeps, SubscribableStore, wireStoreSubscribers };

package/dist/state/store-subscribers.js

@@ -1,5 +1,5 @@
 import { selectAlignmentMatrix, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectZeroReference } from "./app-selectors.js";
-import { buildMapData } from "../visualization/map-data.js";
+import { t as buildMapData } from "../map-data-D7rpMC6f.js";
 import { subscribeToSelector } from "./subscribe-to-selector.js";
 import { calcGpsCoords } from "gps-plus-slam-js";
 import { mat4, vec3 } from "gl-matrix";
@@ -46,6 +46,7 @@ function wireStoreSubscribers(store, deps) {
 		deps.mapOverlay.render(buildMapData({
 			rawGpsPath,
 			odometryPositions: selectOdometryPositions(state),
+			odometryRotations: selectOdometryRotations(state),
 			alignmentMatrix: selectAlignmentMatrix(state),
 			zeroRef: selectZeroReference(state),
 			alignmentSnapshots: alignmentSnapshotGps

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-B9ylM5Oh.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-D3nzh9Wb.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 };