gps-plus-slam-app-framework 1.0.0

package/dist/sensors/gps-error-handler.js

@@ -0,0 +1,53 @@
+import { createLogger } from "../utils/logger.js";
+//#region ../src/sensors/gps-error-handler.ts
+/**
+* GPS Error Handler
+*
+* Provides user-facing error messages for GPS failures.
+* Separates error handling logic from GPS module for testability.
+*/
+const log = createLogger("GPSError");
+/**
+* GPS error codes from the Geolocation API.
+* Duplicated here to avoid depending on browser types in tests.
+*/
+const GPS_ERROR_CODES = {
+	PERMISSION_DENIED: 1,
+	POSITION_UNAVAILABLE: 2,
+	TIMEOUT: 3
+};
+/**
+* User-friendly error messages for each GPS error type.
+*/
+const GPS_ERROR_MESSAGES = {
+	[GPS_ERROR_CODES.PERMISSION_DENIED]: "GPS permission denied. Enable location access in your browser or device settings.",
+	[GPS_ERROR_CODES.POSITION_UNAVAILABLE]: "GPS position unavailable. Move outdoors for better signal.",
+	[GPS_ERROR_CODES.TIMEOUT]: "GPS timeout. Move outdoors or check that location services are enabled."
+};
+/**
+* Default message for unknown error codes.
+*/
+const GPS_ERROR_MESSAGE_UNKNOWN = "GPS error. Check your device settings.";
+/**
+* Get a user-friendly error message for a GPS error.
+*
+* @param error - The GeolocationPositionError from the browser API
+* @returns A user-friendly error message
+*/
+function getGpsErrorMessage(error) {
+	return GPS_ERROR_MESSAGES[error.code] ?? "GPS error. Check your device settings.";
+}
+/**
+* Create a GPS error handler that logs and shows user-facing errors.
+*
+* @param showError - Function to display error to user (e.g., from hud.ts)
+* @returns A function suitable for use as startGpsWatch's onError callback
+*/
+function createGpsErrorHandler(showError) {
+	return (error) => {
+		log.error(`GPS error (code ${error.code}):`, error.message);
+		showError(getGpsErrorMessage(error));
+	};
+}
+//#endregion
+export { GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, createGpsErrorHandler, getGpsErrorMessage };

package/dist/sensors/gps.d.ts

@@ -0,0 +1,2 @@
+import { a as startOrientationWatch, i as startGpsWatch, n as RawDeviceOrientation, o as stopGpsWatch, r as requestOrientationPermission, s as stopOrientationWatch, t as GpsPosition } from "../gps-Ddzr2KlX.js";
+export { GpsPosition, RawDeviceOrientation, requestOrientationPermission, startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch };

package/dist/sensors/gps.js

@@ -0,0 +1,93 @@
+import { createLogger } from "../utils/logger.js";
+//#region ../src/sensors/gps.ts
+/**
+* GPS Module
+*
+* Handles Geolocation API access and device orientation/compass.
+*/
+const log = createLogger("GPS");
+let watchId = null;
+let orientationHandler = null;
+/**
+* Start watching GPS position.
+* Idempotent: clears any existing watch before starting a new one
+* (Issue 4, 2026-02-27 user feedback — prevents watch leaks when
+* transitioning from warm-up to recording watch).
+*/
+function startGpsWatch(onPosition, onError) {
+	if (!navigator.geolocation) {
+		log.error("Geolocation API not available");
+		return;
+	}
+	stopGpsWatch();
+	watchId = navigator.geolocation.watchPosition((pos) => {
+		onPosition({
+			lat: pos.coords.latitude,
+			lon: pos.coords.longitude,
+			altitude: pos.coords.altitude,
+			accuracy: pos.coords.accuracy,
+			altitudeAccuracy: pos.coords.altitudeAccuracy,
+			heading: pos.coords.heading,
+			speed: pos.coords.speed,
+			timestamp: pos.timestamp
+		});
+	}, (err) => {
+		log.error("Error:", err.message);
+		onError?.(err);
+	}, {
+		enableHighAccuracy: true,
+		maximumAge: 0,
+		timeout: 1e4
+	});
+	log.info("Watch started");
+}
+/**
+* Stop watching GPS position
+*/
+function stopGpsWatch() {
+	if (watchId !== null) {
+		navigator.geolocation.clearWatch(watchId);
+		watchId = null;
+		log.info("Watch stopped");
+	}
+}
+/**
+* Start listening for device orientation (compass)
+*/
+function startOrientationWatch(onOrientation) {
+	stopOrientationWatch();
+	orientationHandler = (event) => {
+		onOrientation({
+			alpha: event.alpha,
+			beta: event.beta,
+			gamma: event.gamma,
+			absolute: event.absolute
+		});
+	};
+	window.addEventListener("deviceorientation", orientationHandler);
+	log.info("Orientation watch started");
+}
+/**
+* Stop listening for device orientation
+*/
+function stopOrientationWatch() {
+	if (orientationHandler) {
+		window.removeEventListener("deviceorientation", orientationHandler);
+		orientationHandler = null;
+		log.info("Orientation watch stopped");
+	}
+}
+/**
+* Request permission for device orientation (required on iOS 13+)
+*/
+async function requestOrientationPermission() {
+	const DeviceOrientationEventWithPermission = DeviceOrientationEvent;
+	if (typeof DeviceOrientationEventWithPermission.requestPermission === "function") try {
+		return await DeviceOrientationEventWithPermission.requestPermission() === "granted";
+	} catch {
+		return false;
+	}
+	return true;
+}
+//#endregion
+export { requestOrientationPermission, startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch };

package/dist/sensors/index.d.ts

@@ -0,0 +1,4 @@
+import { a as startOrientationWatch, i as startGpsWatch, n as RawDeviceOrientation, o as stopGpsWatch, r as requestOrientationPermission, s as stopOrientationWatch, t as GpsPosition } from "../gps-Ddzr2KlX.js";
+import { a as getGpsErrorMessage, i as createGpsErrorHandler, n as GPS_ERROR_MESSAGES, r as GPS_ERROR_MESSAGE_UNKNOWN, t as GPS_ERROR_CODES } from "../gps-error-handler-VPuNOuf8.js";
+import { a as checkFileSystemPermission, c as checkWebXRSupport, d as requestGeolocationPermission, f as requestOrientationPermission$1, h as setFileSystemState, i as checkCameraPermission, l as requestAllPermissions, m as resetFileSystemState, n as PermissionStatus, o as checkGeolocationPermission, p as requestWebXRWithDepthPermission, r as checkAllPermissions, s as checkOrientationPermission, t as PermissionCheckResult, u as requestCameraPermission } from "../permission-checker-jO2ziCWC.js";
+export { GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, type GpsPosition, type PermissionCheckResult, type PermissionStatus, type RawDeviceOrientation, checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, createGpsErrorHandler, getGpsErrorMessage, requestAllPermissions, requestCameraPermission, requestOrientationPermission as requestDeviceOrientationPermission, requestGeolocationPermission, requestOrientationPermission$1 as requestOrientationPermission, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState, startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch };

package/dist/sensors/index.js

@@ -0,0 +1,4 @@
+import { checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, requestAllPermissions, requestCameraPermission, requestGeolocationPermission, requestOrientationPermission as requestOrientationPermission$1, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState } from "./permission-checker.js";
+import { requestOrientationPermission, startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch } from "./gps.js";
+import { GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, createGpsErrorHandler, getGpsErrorMessage } from "./gps-error-handler.js";
+export { GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, createGpsErrorHandler, getGpsErrorMessage, requestAllPermissions, requestCameraPermission, requestOrientationPermission as requestDeviceOrientationPermission, requestGeolocationPermission, requestOrientationPermission$1 as requestOrientationPermission, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState, startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch };

package/dist/sensors/permission-checker.d.ts

@@ -0,0 +1,2 @@
+import { a as checkFileSystemPermission, c as checkWebXRSupport, d as requestGeolocationPermission, f as requestOrientationPermission, h as setFileSystemState, i as checkCameraPermission, l as requestAllPermissions, m as resetFileSystemState, n as PermissionStatus, o as checkGeolocationPermission, p as requestWebXRWithDepthPermission, r as checkAllPermissions, s as checkOrientationPermission, t as PermissionCheckResult, u as requestCameraPermission } from "../permission-checker-jO2ziCWC.js";
+export { PermissionCheckResult, PermissionStatus, checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, requestAllPermissions, requestCameraPermission, requestGeolocationPermission, requestOrientationPermission, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState };

package/dist/sensors/permission-checker.js

@@ -0,0 +1,397 @@
+import { createLogger } from "../utils/logger.js";
+//#region ../src/sensors/permission-checker.ts
+/**
+* Permission Checker Module
+*
+* Provides utilities to check and verify mandatory device permissions
+* required for AR+GPS tracking: WebXR (immersive-ar), Camera, and Geolocation.
+*
+* This module is used by the setup modal to verify permissions BEFORE
+* the user enters AR mode, providing clear feedback on what's missing.
+*/
+const log = createLogger("PermissionChecker");
+let fileSystemState = {
+	folderSelected: false,
+	writeVerified: false
+};
+/**
+* Reset file system permission state.
+* Exported for testing purposes.
+* @internal
+*/
+function resetFileSystemState() {
+	fileSystemState = {
+		folderSelected: false,
+		writeVerified: false
+	};
+}
+/**
+* Set file system permission state.
+* Used by the storage module after folder selection and write verification.
+* @internal
+*/
+function setFileSystemState(state) {
+	fileSystemState = {
+		...fileSystemState,
+		...state
+	};
+}
+/**
+* Check file system access permission status.
+*
+* User Feedback Issue #1: File system access is critical for recording.
+* This function checks:
+* 1. If OPFS (Origin Private File System) is available
+* 2. If storage has been initialized
+* 3. If write access has been verified
+*
+* Note: We now use OPFS instead of showDirectoryPicker because it works
+* consistently on Android Chrome, iOS Safari, and Desktop browsers.
+*
+* @returns Permission status for file system access
+*/
+function checkFileSystemPermission() {
+	if (typeof navigator === "undefined" || !navigator.storage || typeof navigator.storage.getDirectory !== "function") return {
+		supported: false,
+		granted: null,
+		error: "Origin Private File System (OPFS) not supported. Use Chrome 86+, Safari 15.2+, or Firefox 111+."
+	};
+	if (!fileSystemState.folderSelected) return {
+		supported: true,
+		granted: null
+	};
+	if (!fileSystemState.writeVerified) return {
+		supported: true,
+		granted: false,
+		error: fileSystemState.writeError || "Storage write failed. Please try again."
+	};
+	return {
+		supported: true,
+		granted: true
+	};
+}
+/**
+* Check if WebXR immersive-ar mode is supported.
+* Does not request a session, only checks support.
+*/
+async function checkWebXRSupport() {
+	if (!navigator.xr) return {
+		supported: false,
+		granted: null,
+		error: "WebXR API not available. Use a compatible browser like Chrome on Android."
+	};
+	try {
+		if (!await navigator.xr.isSessionSupported("immersive-ar")) return {
+			supported: false,
+			granted: null,
+			error: "AR mode not supported. Ensure you have ARCore/ARKit installed."
+		};
+		return {
+			supported: true,
+			granted: true
+		};
+	} catch (err) {
+		log.error("WebXR support check failed:", err);
+		return {
+			supported: false,
+			granted: null,
+			error: "Failed to check AR support. Please refresh and try again."
+		};
+	}
+}
+/**
+* Check geolocation permission status without triggering a prompt.
+* Uses the Permissions API if available, otherwise returns unknown state.
+*/
+async function checkGeolocationPermission() {
+	if (!navigator.geolocation) return {
+		supported: false,
+		granted: null,
+		error: "Geolocation API not available in this browser."
+	};
+	if (navigator.permissions) try {
+		const result = await navigator.permissions.query({ name: "geolocation" });
+		if (result.state === "granted") return {
+			supported: true,
+			granted: true
+		};
+		else if (result.state === "denied") return {
+			supported: true,
+			granted: false,
+			error: "Location access denied. Please enable in browser settings."
+		};
+		return {
+			supported: true,
+			granted: null
+		};
+	} catch {}
+	return {
+		supported: true,
+		granted: null
+	};
+}
+/**
+* Request geolocation permission by triggering a position request.
+* This will show the browser's permission prompt if not already granted.
+*
+* @param timeoutMs - Maximum time to wait for position (default 10s)
+* @returns Updated permission status after request
+*/
+async function requestGeolocationPermission(timeoutMs = 1e4) {
+	if (!navigator.geolocation) return {
+		supported: false,
+		granted: null,
+		error: "Geolocation API not available in this browser."
+	};
+	return new Promise((resolve) => {
+		navigator.geolocation.getCurrentPosition(() => {
+			log.info("Geolocation permission granted");
+			resolve({
+				supported: true,
+				granted: true
+			});
+		}, (error) => {
+			log.warn("Geolocation error:", error.message);
+			if (error.code === error.PERMISSION_DENIED) resolve({
+				supported: true,
+				granted: false,
+				error: "Location access denied. Please enable in browser settings."
+			});
+			else if (error.code === error.POSITION_UNAVAILABLE) resolve({
+				supported: true,
+				granted: null,
+				error: "Location unavailable. Check GPS is enabled on your device."
+			});
+			else resolve({
+				supported: true,
+				granted: null,
+				error: "Location request timed out. Please try again."
+			});
+		}, {
+			enableHighAccuracy: true,
+			timeout: timeoutMs,
+			maximumAge: 0
+		});
+	});
+}
+/**
+* Check camera permission status without triggering a prompt.
+* Uses the Permissions API if available.
+*/
+async function checkCameraPermission() {
+	if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) return {
+		supported: false,
+		granted: null,
+		error: "Camera API not available. Use HTTPS and a modern browser."
+	};
+	if (navigator.permissions) try {
+		const result = await navigator.permissions.query({ name: "camera" });
+		if (result.state === "granted") return {
+			supported: true,
+			granted: true
+		};
+		else if (result.state === "denied") return {
+			supported: true,
+			granted: false,
+			error: "Camera access denied. Please enable in browser settings."
+		};
+		return {
+			supported: true,
+			granted: null
+		};
+	} catch {}
+	return {
+		supported: true,
+		granted: null
+	};
+}
+/**
+* Request camera permission by triggering getUserMedia.
+* This will show the browser's permission prompt if not already granted.
+*
+* @returns Updated permission status after request
+*/
+async function requestCameraPermission() {
+	if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) return {
+		supported: false,
+		granted: null,
+		error: "Camera API not available. Use HTTPS and a modern browser."
+	};
+	try {
+		const stream = await navigator.mediaDevices.getUserMedia({ video: true });
+		for (const track of stream.getTracks()) track.stop();
+		log.info("Camera permission granted");
+		return {
+			supported: true,
+			granted: true
+		};
+	} catch (err) {
+		log.warn("Camera permission error:", err);
+		const error = err;
+		if (error.name === "NotAllowedError") return {
+			supported: true,
+			granted: false,
+			error: "Camera access denied. Please enable in browser settings."
+		};
+		else if (error.name === "NotFoundError") return {
+			supported: false,
+			granted: null,
+			error: "No camera found on this device."
+		};
+		return {
+			supported: true,
+			granted: null,
+			error: "Camera access failed. Please try again."
+		};
+	}
+}
+/**
+* Check device orientation permission status.
+* On iOS 13+, this requires explicit permission request.
+*/
+function checkOrientationPermission() {
+	if (typeof DeviceOrientationEvent === "undefined") return Promise.resolve({
+		supported: false,
+		granted: null,
+		error: "Device orientation not supported."
+	});
+	if (typeof DeviceOrientationEvent.requestPermission === "function") return Promise.resolve({
+		supported: true,
+		granted: null
+	});
+	return Promise.resolve({
+		supported: true,
+		granted: true
+	});
+}
+/**
+* Request device orientation permission (iOS 13+).
+* On other platforms, this is a no-op that returns granted.
+*/
+async function requestOrientationPermission() {
+	if (typeof DeviceOrientationEvent === "undefined") return {
+		supported: false,
+		granted: null,
+		error: "Device orientation not supported."
+	};
+	const DeviceOrientationEventWithPermission = DeviceOrientationEvent;
+	if (typeof DeviceOrientationEventWithPermission.requestPermission === "function") try {
+		if (await DeviceOrientationEventWithPermission.requestPermission() === "granted") {
+			log.info("Orientation permission granted");
+			return {
+				supported: true,
+				granted: true
+			};
+		} else return {
+			supported: true,
+			granted: false,
+			error: "Motion & orientation access denied."
+		};
+	} catch {
+		return {
+			supported: true,
+			granted: null,
+			error: "Orientation permission request failed."
+		};
+	}
+	return {
+		supported: true,
+		granted: true
+	};
+}
+/**
+* Check all permissions without triggering any prompts.
+* Returns current known state of each permission.
+*/
+async function checkAllPermissions() {
+	const [webxr, geolocation, camera, orientation] = await Promise.all([
+		checkWebXRSupport(),
+		checkGeolocationPermission(),
+		checkCameraPermission(),
+		checkOrientationPermission()
+	]);
+	const fileSystem = checkFileSystemPermission();
+	return {
+		webxr,
+		geolocation,
+		camera,
+		orientation,
+		fileSystem,
+		allMandatoryReady: webxr.supported && webxr.granted === true && geolocation.supported && geolocation.granted === true && camera.supported && camera.granted === true && fileSystem.supported && fileSystem.granted === true
+	};
+}
+/**
+* Request all mandatory permissions that haven't been granted yet.
+* Shows browser prompts for each permission that needs requesting.
+*
+* This now includes the WebXR+Depth probe to trigger the "3D map" permission
+* upfront, rather than surprising users with a second prompt after "Enter AR".
+*
+* @returns Updated permission check result after requests
+*/
+async function requestAllPermissions() {
+	const result = await checkAllPermissions();
+	if (result.webxr.supported) result.webxr = await requestWebXRWithDepthPermission();
+	if (result.geolocation.supported && result.geolocation.granted !== true) result.geolocation = await requestGeolocationPermission();
+	if (result.camera.supported && result.camera.granted !== true) result.camera = await requestCameraPermission();
+	if (result.orientation.supported && result.orientation.granted !== true) result.orientation = await requestOrientationPermission();
+	result.fileSystem = checkFileSystemPermission();
+	result.allMandatoryReady = result.webxr.supported && result.webxr.granted === true && result.geolocation.supported && result.geolocation.granted === true && result.camera.supported && result.camera.granted === true && result.fileSystem.supported && result.fileSystem.granted === true;
+	return result;
+}
+/**
+* Request WebXR permission with depth-sensing by starting a probe session.
+*
+* The depth-sensing permission (ARCore's "3D map of surroundings") is only
+* triggered when an XR session is actually started with depth-sensing options.
+* This function starts a minimal probe session to trigger the permission prompt,
+* then immediately ends it.
+*
+* This allows the app to request all AR permissions upfront during the
+* setup flow, rather than surprising users with a second prompt when
+* they click "Enter AR".
+*
+* @returns Permission status indicating if AR+depth access was granted
+*/
+async function requestWebXRWithDepthPermission() {
+	if (!navigator.xr) return {
+		supported: false,
+		granted: null,
+		error: "WebXR not available"
+	};
+	try {
+		const session = await navigator.xr.requestSession("immersive-ar", {
+			requiredFeatures: ["local-floor"],
+			optionalFeatures: ["depth-sensing"],
+			depthSensing: {
+				usagePreference: ["cpu-optimized"],
+				dataFormatPreference: ["luminance-alpha", "float32"]
+			}
+		});
+		try {
+			await session.end();
+		} catch (endError) {
+			log.warn("Probe session end failed (permission still granted):", endError);
+		}
+		log.info("WebXR with depth-sensing permission granted");
+		return {
+			supported: true,
+			granted: true
+		};
+	} catch (err) {
+		const error = err;
+		log.warn("WebXR depth probe failed:", error);
+		if (error.name === "NotAllowedError") return {
+			supported: true,
+			granted: false,
+			error: "AR access denied"
+		};
+		return {
+			supported: false,
+			granted: null,
+			error: error.message
+		};
+	}
+}
+//#endregion
+export { checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, requestAllPermissions, requestCameraPermission, requestGeolocationPermission, requestOrientationPermission, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState };

package/dist/state/app-selectors.d.ts

@@ -0,0 +1,2 @@
+import { a as selectReferencePoints, i as selectOdometryRotations, n as selectGpsPositions, o as selectZeroReference, r as selectOdometryPositions, t as selectAlignmentMatrix } from "../app-selectors-DyMzxCEC.js";
+export { selectAlignmentMatrix, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectReferencePoints, selectZeroReference };

package/dist/state/app-selectors.js

@@ -0,0 +1,35 @@
+import { createSelector } from "@reduxjs/toolkit";
+//#region ../src/state/app-selectors.ts
+/**
+* App-level memoized selectors for CombinedRootState.
+*
+* Wraps library getter functions with createSelector (RTK/reselect) for
+* standard memoization. The library getters already return stable references
+* via immutable state, but createSelector adds:
+* - Explicit memoization contract (input comparison → cached output)
+* - Consistent select* naming convention matching selectCachedKnownRefPoints
+* - Composition-ready building blocks for derived selectors
+*
+* Used by subscribeToSelector in store-subscribers.ts for change detection.
+*
+* @see docs/2026-04-07-architecture-observations-consolidated.md §1
+*/
+const EMPTY_GPS_POSITIONS = [];
+const EMPTY_ODOM_POSITIONS = [];
+const EMPTY_ODOM_ROTATIONS = [];
+const EMPTY_REF_POINTS = [];
+const selectGpsData = (state) => state.gpsData;
+/** Alignment matrix (4×4), or null if not yet computed. */
+const selectAlignmentMatrix = createSelector([selectGpsData], (gpsData) => gpsData?.gpsEvents?.alignmentMatrix ?? null);
+/** Recorded GPS positions with metadata. */
+const selectGpsPositions = createSelector([selectGpsData], (gpsData) => gpsData?.gpsEvents?.gpsPositions ?? EMPTY_GPS_POSITIONS);
+/** Recorded odometry positions (AR-local space). */
+const selectOdometryPositions = createSelector([selectGpsData], (gpsData) => gpsData?.gpsEvents?.odometryPositions ?? EMPTY_ODOM_POSITIONS);
+/** Recorded odometry rotations (AR-local space). */
+const selectOdometryRotations = createSelector([selectGpsData], (gpsData) => gpsData?.gpsEvents?.odometryRotations ?? EMPTY_ODOM_ROTATIONS);
+/** GPS zero reference (origin for coordinate conversion), or null. */
+const selectZeroReference = createSelector([selectGpsData], (gpsData) => gpsData?.zero ?? null);
+/** User-defined reference points for ground truth validation. */
+const selectReferencePoints = createSelector([selectGpsData], (gpsData) => gpsData?.referencePoints ?? EMPTY_REF_POINTS);
+//#endregion
+export { selectAlignmentMatrix, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectReferencePoints, selectZeroReference };

package/dist/state/index.d.ts

@@ -0,0 +1,17 @@
+import { i as DepthSample, r as DepthPoint } from "../ar-types-B-ORgk6Z.js";
+import { _ as validateRecordingOptions, a as IMAGE_CONSTRAINTS, c as RecordingOptionsInput, d as loadRecordingOptions, f as resetRecordingOptions, g as validateImageOptions, h as validateDepthOptions, i as DepthCaptureOptions, l as STORAGE_KEY, n as DEFAULT_RECORDING_OPTIONS, o as ImageCaptureOptions, p as saveRecordingOptions, r as DEPTH_CONSTRAINTS, s as RecordingOptions, u as cloneRecordingOptions } from "../recording-options-BYUFX8iU.js";
+import { n as SessionMetadata } from "../opfs-storage-ChOzF_Wp.js";
+import { t as StorageBackend } from "../storage-backend-BcEItnFr.js";
+import { a as recordWriteFailure, c as startSession, i as recordDepthSample, n as SessionMetadata$1, o as recorderReducer, r as endSession, s as setCurrentScenarioName, t as RecorderState } from "../recorder-slice-fcwAXrsh.js";
+import { a as resetRefPointsState, i as refPointsReducer, n as clearSessionRefPointUsage, o as selectCachedKnownRefPoints, r as incrementRefPointUsage, s as setImportedRefPoints, t as RefPointsState } from "../ref-points-slice-tC-Wd6XJ.js";
+import { i as routingReducer, n as RoutingState, r as navigateTo, t as AppScreen } from "../routing-slice-BlHTM8eh.js";
+import { n as RefPointMark } from "../ref-point-loader-Pt1smgHS.js";
+import { _ as setZeroPos, a as MarkReferencePointPayload, c as RecordGpsEventPayload, d as RootState, f as add2dImage, g as recordGpsEvent, h as markReferencePoint, i as LatLong, l as RecorderStore, m as createRecorderStore, n as CombinedRootState, o as RawDeviceOrientation, p as calcRelativeCoordsInMeters, r as GpsPoint, s as RawGpsPoint, t as AppDispatch, u as RecorderStoreOptions } from "../store-C7PKOj8S.js";
+import { a as eulerToQuaternion, c as getLastDeviceOrientation, i as createGpsPositionHandler, l as resetCoordinatorState, n as buildRawGpsPoint, o as extractOdomPosition, r as buildRecordGpsEventPayload, s as extractOdomRotation, t as RecordingCoordinatorConfig, u as updateDeviceOrientation } from "../recording-coordinator-DzflP07_.js";
+import { n as replayRecording, t as ReplayRecordingOptions } from "../recording-replayer-oOzPITrd.js";
+import { n as createPersistenceMiddleware, t as PersistenceMiddlewareOptions } from "../persistence-middleware-DrptY02i.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-DuX316ae.js";
+import { n as subscribeToSelector, t as SubscribableStore } from "../subscribe-to-selector-UTZ0KkAc.js";
+import { n as wireStoreSubscribers, t as StoreSubscriberDeps } from "../store-subscribers-CuoIzB5T.js";
+import { a as selectReferencePoints, i as selectOdometryRotations, n as selectGpsPositions, o as selectZeroReference, r as selectOdometryPositions, t as selectAlignmentMatrix } from "../app-selectors-DyMzxCEC.js";
+export { type AppDispatch, type AppScreen, type CombinedRootState, type CompleteCallback, DEFAULT_MAX_DELAY_MS, DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, type DepthCaptureOptions, type DepthPoint, type DepthSample, type ErrorCallback, type GpsPoint, IMAGE_CONSTRAINTS, type ImageCaptureOptions, type LatLong, type MarkReferencePointPayload, type SessionMetadata as OpfsSessionMetadata, type PersistenceMiddlewareOptions, type ProgressCallback, type RawDeviceOrientation, type RawGpsPoint, type RecordGpsEventPayload, type RecorderState, type RecorderStore, type RecorderStoreOptions, type RecordingCoordinatorConfig, type RecordingOptions, type RecordingOptionsInput, type RefPointMark, type RefPointsState, type ReplayAction, ReplayEngine, type ReplayRecordingOptions, type ReplayState, type RootState, type RoutingState, STORAGE_KEY, type SessionMetadata$1 as SessionMetadata, type StorageBackend, type StoreSubscriberDeps, type SubscribableStore, add2dImage, buildRawGpsPoint, buildRecordGpsEventPayload, calcRelativeCoordsInMeters, clearSessionRefPointUsage, cloneRecordingOptions, computeInterActionDelay, createGpsPositionHandler, createPersistenceMiddleware, createRecorderStore, endSession, eulerToQuaternion, extractActionTimestamp, extractOdomPosition, extractOdomRotation, getLastDeviceOrientation, incrementRefPointUsage, loadRecordingOptions, markReferencePoint, navigateTo, recordDepthSample, recordGpsEvent, recordWriteFailure, recorderReducer, refPointsReducer, replayRecording, resetCoordinatorState, resetRecordingOptions, resetRefPointsState, routingReducer, saveRecordingOptions, selectAlignmentMatrix, selectCachedKnownRefPoints, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectReferencePoints, selectZeroReference, setCurrentScenarioName, setImportedRefPoints, setZeroPos, startSession, subscribeToSelector, updateDeviceOrientation, validateDepthOptions, validateImageOptions, validateRecordingOptions, wireStoreSubscribers };

package/dist/state/index.js

@@ -0,0 +1,13 @@
+import { endSession, recordDepthSample, recordWriteFailure, recorderReducer, setCurrentScenarioName, startSession } from "./recorder-slice.js";
+import { clearSessionRefPointUsage, incrementRefPointUsage, refPointsReducer, resetRefPointsState, selectCachedKnownRefPoints, setImportedRefPoints } from "./ref-points-slice.js";
+import { navigateTo, routingReducer } from "./routing-slice.js";
+import { createPersistenceMiddleware } from "./persistence-middleware.js";
+import { add2dImage, calcRelativeCoordsInMeters, createRecorderStore, markReferencePoint, recordGpsEvent, setZeroPos } from "./store.js";
+import { buildRawGpsPoint, buildRecordGpsEventPayload, createGpsPositionHandler, eulerToQuaternion, extractOdomPosition, extractOdomRotation, getLastDeviceOrientation, resetCoordinatorState, updateDeviceOrientation } from "./recording-coordinator.js";
+import { DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, IMAGE_CONSTRAINTS, STORAGE_KEY, cloneRecordingOptions, loadRecordingOptions, resetRecordingOptions, saveRecordingOptions, validateDepthOptions, validateImageOptions, validateRecordingOptions } from "./recording-options.js";
+import { replayRecording } from "./recording-replayer.js";
+import { DEFAULT_MAX_DELAY_MS, ReplayEngine, computeInterActionDelay, extractActionTimestamp } from "./replay-engine.js";
+import { subscribeToSelector } from "./subscribe-to-selector.js";
+import { selectAlignmentMatrix, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectReferencePoints, selectZeroReference } from "./app-selectors.js";
+import { wireStoreSubscribers } from "./store-subscribers.js";
+export { DEFAULT_MAX_DELAY_MS, DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, IMAGE_CONSTRAINTS, ReplayEngine, STORAGE_KEY, add2dImage, buildRawGpsPoint, buildRecordGpsEventPayload, calcRelativeCoordsInMeters, clearSessionRefPointUsage, cloneRecordingOptions, computeInterActionDelay, createGpsPositionHandler, createPersistenceMiddleware, createRecorderStore, endSession, eulerToQuaternion, extractActionTimestamp, extractOdomPosition, extractOdomRotation, getLastDeviceOrientation, incrementRefPointUsage, loadRecordingOptions, markReferencePoint, navigateTo, recordDepthSample, recordGpsEvent, recordWriteFailure, recorderReducer, refPointsReducer, replayRecording, resetCoordinatorState, resetRecordingOptions, resetRefPointsState, routingReducer, saveRecordingOptions, selectAlignmentMatrix, selectCachedKnownRefPoints, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectReferencePoints, selectZeroReference, setCurrentScenarioName, setImportedRefPoints, setZeroPos, startSession, subscribeToSelector, updateDeviceOrientation, validateDepthOptions, validateImageOptions, validateRecordingOptions, wireStoreSubscribers };

package/dist/state/persistence-middleware.d.ts

@@ -0,0 +1,2 @@
+import { n as createPersistenceMiddleware, t as PersistenceMiddlewareOptions } from "../persistence-middleware-DrptY02i.js";
+export { PersistenceMiddlewareOptions, createPersistenceMiddleware };