gps-plus-slam-app-framework 1.0.0 → 1.0.7

package/dist/state/create-slam-app-store.js

@@ -0,0 +1,75 @@
+import { trackingReducer } from "./tracking-slice.js";
+import { recordWriteFailure, recordingReducer } from "./recording-slice.js";
+import { createTrackingQualityListenerMiddleware, trackingQualityReducer } from "./tracking-quality.js";
+import { createPersistenceMiddleware, slicePrefixOf } from "./persistence-middleware.js";
+import { arElementsReducer, gpsDataReducer, gpsElementsReducer, sanitizeForDevTools, setZeroPos, validateLicenseKey } from "gps-plus-slam-js";
+import { configureStore } from "@reduxjs/toolkit";
+import { COMMUNITY_LICENSE_KEY } from "gps-plus-slam-js/community-license-key";
+//#region ../src/state/create-slam-app-store.ts
+/**
+* `createSlamAppStore` — composable Redux store factory for AR+GPS apps.
+*
+* Introduced in Iter 1 of the AppFramework/RecorderApp boundary migration.
+* Wires the three library reducers (`gpsData`, `gpsElements`, `arElements`),
+* the framework's recording lifecycle slice, and the persistence middleware.
+*
+* Recorder-only state (routing screen, ref-points, scenario) is plugged in
+* by the consumer via `extraReducers` / `extraMiddleware`. The factory itself
+* never references those concepts so apps that don't need them (POI viewers,
+* navigation arrows, …) compose freely.
+*
+* The legacy `createRecorderStore` from `store.ts` is built on top of this
+* factory and will move out of the framework in Iter 1D.
+*
+* @see docs/2026-05-03-appframework-vs-recorderapp-boundary-analysis.md — Iter 1
+*/
+/**
+* Slice prefixes the framework always persists, derived from the actual
+* library / framework action creators (never hand-typed). A rename of the
+* `gpsData` or `recording` slice therefore propagates here automatically
+* instead of silently dropping that slice's actions from recordings.
+*/
+const BUILTIN_PERSISTED_PREFIXES = [slicePrefixOf(setZeroPos.type), slicePrefixOf(recordWriteFailure.type)];
+/**
+* Build a Redux store wired with library + recording slices, persistence
+* middleware, and any caller-supplied extras. See module docstring for the
+* design rationale.
+*/
+function createSlamAppStore(options) {
+	const { storageBackend, extraReducers, extraMiddleware, persistedExtraPrefixes, onWriteFailure, enableDevChecks = true, licenseKey = COMMUNITY_LICENSE_KEY, trackingQualityOptions } = options;
+	validateLicenseKey(licenseKey);
+	const reducer = {
+		gpsData: gpsDataReducer,
+		gpsElements: gpsElementsReducer,
+		arElements: arElementsReducer,
+		recording: recordingReducer,
+		tracking: trackingReducer,
+		trackingQuality: trackingQualityReducer,
+		...extraReducers ?? {}
+	};
+	const trackingQualityMiddleware = createTrackingQualityListenerMiddleware(trackingQualityOptions);
+	const store = configureStore({
+		reducer,
+		middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+			serializableCheck: enableDevChecks,
+			immutableCheck: enableDevChecks
+		}).prepend(trackingQualityMiddleware).concat(createPersistenceMiddleware({
+			storageBackend,
+			onWriteFailure,
+			persistedPrefixes: [...BUILTIN_PERSISTED_PREFIXES, ...persistedExtraPrefixes ?? []]
+		}), ...extraMiddleware ?? []),
+		devTools: {
+			actionSanitizer: sanitizeForDevTools,
+			stateSanitizer: sanitizeForDevTools
+		}
+	});
+	return {
+		getState: () => store.getState(),
+		dispatch: store.dispatch,
+		subscribe: (listener) => store.subscribe(listener),
+		writeFrame: (blob, index) => storageBackend.writeFrame(blob, index),
+		writeSessionMetadata: (metadata) => storageBackend.writeSessionMetadata(metadata)
+	};
+}
+//#endregion
+export { createSlamAppStore };

package/dist/state/gps-ar-pose-sampler.d.ts

@@ -0,0 +1,4 @@
+import { t as ARPose } from "../ar-types-Ck8LEq8k.js";
+import { o as extractOdomPosition, s as extractOdomRotation } from "../gps-event-coordinator-DBx9I1YX.js";
+import { i as captureGpsAnchorSample, n as GpsAnchorSample, r as GpsAnchorSampleGpsPoint, t as CaptureGpsAnchorSampleOptions } from "../gps-ar-pose-sampler-DsM1Kb2N.js";
+export { ARPose, CaptureGpsAnchorSampleOptions, GpsAnchorSample, GpsAnchorSampleGpsPoint, captureGpsAnchorSample, extractOdomPosition, extractOdomRotation };

package/dist/state/gps-ar-pose-sampler.js

@@ -0,0 +1,19 @@
+import { extractOdomPosition, extractOdomRotation } from "./gps-event-coordinator.js";
+//#region ../src/state/gps-ar-pose-sampler.ts
+/**
+* Capture a GPS-AR pose snapshot. Extracts `odomPosition`/`odomRotation`
+* from the supplied `arPose`. The supplied `gpsPoint` and optional
+* `fusedGpsPoint` are stored verbatim.
+*/
+function captureGpsAnchorSample(arPose, gpsPoint, options = {}) {
+	return {
+		gpsPoint,
+		fusedGpsPoint: options.fusedGpsPoint,
+		arPose,
+		odomPosition: extractOdomPosition(arPose),
+		odomRotation: extractOdomRotation(arPose),
+		timestamp: options.timestamp ?? Date.now()
+	};
+}
+//#endregion
+export { captureGpsAnchorSample, extractOdomPosition, extractOdomRotation };

package/dist/state/{recording-coordinator.d.ts → gps-event-coordinator.d.ts}

@@ -1,2 +1,2 @@
-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 { 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 "../gps-event-coordinator-DBx9I1YX.js";
 export { RecordingCoordinatorConfig, buildRawGpsPoint, buildRecordGpsEventPayload, createGpsPositionHandler, eulerToQuaternion, extractOdomPosition, extractOdomRotation, getLastDeviceOrientation, resetCoordinatorState, updateDeviceOrientation };

package/dist/state/{recording-coordinator.js → gps-event-coordinator.js}

@@ -1,7 +1,6 @@
 import { createLogger } from "../utils/logger.js";
-import { recordGpsEvent, setZeroPos } from "./store.js";
-import { eulerToQuaternion, getOdometryPositions, getZeroReference } from "gps-plus-slam-js";
-//#region ../src/state/recording-coordinator.ts
+import { eulerToQuaternion, getOdometryPositions, getZeroReference, recordGpsEvent, setZeroPos } from "gps-plus-slam-js";
+//#region ../src/state/gps-event-coordinator.ts
 const log = createLogger("RecordingCoordinator");
 /** Counter for generating unique GPS point IDs */
 let gpsEventCounter = 0;
@@ -122,7 +121,7 @@ function buildRecordGpsEventPayload(gpsPosition, arPose, deviceOrientation) {
 function createGpsPositionHandler(config) {
 	const { store, getArPose } = config;
 	return (position) => {
-		if (!store.getState().recorder.isRecording) return;
+		if (!store.getState().recording.isRecording) return;
 		const arPose = getArPose();
 		if (!arPose) {
 			log.warn("GPS arrived but no AR pose available");

package/dist/state/index.d.ts

@@ -1,17 +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 };
+import { i as DepthSample, r as DepthPoint } from "../ar-types-Ck8LEq8k.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-utCNND8t.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, u as cloneRecordingOptions } from "../recording-options-Dq6IsKAv.js";
+import { a as recordWriteFailure, i as recordDepthSample, n as SessionMetadata$1, o as recordingReducer, r as endSession, s as startSession, t as RecordingState } from "../recording-slice-d6OtCrza.js";
+import { n as SessionMetadata } from "../opfs-storage-DOPkzgeT.js";
+import { n as StorageBackend } from "../storage-backend-CT0Il_AB.js";
+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, a as SlamAppStoreOptions, b as computeCoverage, d as DEFAULT_TRACKING_QUALITY_OPTIONS, g as TrackingQualitySliceState, h as TrackingQualityReport, i as SlamAppStore, j as selectFirstAgreementObservationIndex, k as reportUpdated, m as TrackingQualityOptions, n as SlamAppMiddleware, o as createSlamAppStore, r as SlamAppRootState, s as AlignmentSnapshot, t as SlamAppCombinedState, v as computeCompassAgreement, w as computeTrackingQualityReport, x as computeGpsAccuracy, y as computeConvergence } from "../create-slam-app-store-CNsZ3rcX.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 "../gps-event-coordinator-DBx9I1YX.js";
+import { i as captureGpsAnchorSample, n as GpsAnchorSample, r as GpsAnchorSampleGpsPoint, t as CaptureGpsAnchorSampleOptions } from "../gps-ar-pose-sampler-DsM1Kb2N.js";
+import { n as replayRecording, t as ReplayRecordingOptions } from "../recording-replayer-CmCIIZ02.js";
+import { n as createPersistenceMiddleware, r as slicePrefixOf, t as PersistenceMiddlewareOptions } from "../persistence-middleware-BkHIqvaA.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-BGBRQyXs.js";
+import { n as subscribeToSelector, t as SubscribableStore } from "../subscribe-to-selector-DIHm3BRZ.js";
+import { n as wireStoreSubscribers, t as StoreSubscriberDeps } from "../store-subscribers-Dce_CoJF.js";
+import { a as selectOdometryRotations, i as selectOdometryPositions, n as selectFrameTilesInWebXR, o as selectZeroReference, r as selectGpsPositions, t as selectAlignmentMatrix } from "../app-selectors-BeU0_ab8.js";
+import { Add2dImagePayload, GpsPoint, LatLong, RawDeviceOrientation, RawGpsPoint, RecordGpsEventPayload, add2dImage, calcRelativeCoordsInMeters, recordGpsEvent, setZeroPos } from "gps-plus-slam-js";
+export { type Add2dImagePayload, type AlignmentSnapshot, type CaptureGpsAnchorSampleOptions, type CompleteCallback, DEFAULT_MAX_DELAY_MS, DEFAULT_RECORDING_OPTIONS, DEFAULT_TRACKING_QUALITY_OPTIONS, DEPTH_CONSTRAINTS, type DepthCaptureOptions, type DepthPoint, type DepthSample, type DeviceOrientation, type ErrorCallback, type GpsAnchorSample, type GpsAnchorSampleGpsPoint, type GpsPoint, IMAGE_CONSTRAINTS, type ImageCaptureOptions, type LatLong, type SessionMetadata as OpfsSessionMetadata, type PersistenceMiddlewareOptions, type PoseReceivedPayload, type ProgressCallback, type RawDeviceOrientation, type RawGpsPoint, type RecordGpsEventPayload, type RecordingCoordinatorConfig, type RecordingOptionsInput, type RecordingState, type ReplayAction, ReplayEngine, type ReplayRecordingOptions, type ReplayState, type ResetTransformData, STORAGE_KEY, type SessionMetadata$1 as SessionMetadata, type SlamAppCombinedState, type SlamAppMiddleware, type SlamAppRootState, type SlamAppStore, type SlamAppStoreOptions, type StorageBackend, type StoreSubscriberDeps, type SubscribableStore, type TrackingPhase, type TrackingQualityOptions, type TrackingQualityReport, type TrackingQualitySliceState, type TrackingQualityState, type TrackingSliceState, add2dImage, buildRawGpsPoint, buildRecordGpsEventPayload, calcRelativeCoordsInMeters, captureGpsAnchorSample, clearLastRestartedPayload, cloneRecordingOptions, computeCompassAgreement, computeConvergence, computeCoverage, computeGpsAccuracy, computeGpsVsFusedDivergence, computeInterActionDelay, computeResidualConsensus, computeTrackingQualityReport, createGpsPositionHandler, createPersistenceMiddleware, createSlamAppStore, createTrackingQualityListenerMiddleware, degradedCountUpdated, endSession, eulerToQuaternion, extractActionTimestamp, extractOdomPosition, extractOdomRotation, firstAgreementReached, getLastDeviceOrientation, loadRecordingOptions, matrixDelta, originReset, poseLost, poseReceived, recordDepthSample, recordGpsEvent, recordWriteFailure, recordingReducer, replayRecording, reportUpdated, resetCoordinatorState, resetRecordingOptions, resetTracking, resetTrackingQuality, saveRecordingOptions, selectAlignmentMatrix, selectFirstAgreementObservationIndex, selectFrameTilesInWebXR, selectGpsPositions, selectLastRestartedPayload, selectLastSensorOrientation, selectLastValidPose, selectLostFrameCount, selectOdometryPositions, selectOdometryRotations, selectRecentAlignments, selectTrackingPhase, selectTrackingQuality, selectZeroReference, setZeroPos, slicePrefixOf, snapshotPushed, snapshotsTrimmed, startSession, subscribeToSelector, trackingQualityReducer, trackingReducer, updateDeviceOrientation, validateDepthOptions, validateImageOptions, validateRecordingOptions, wireStoreSubscribers };

package/dist/state/index.js

@@ -1,13 +1,15 @@
-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 { buildRawGpsPoint, buildRecordGpsEventPayload, createGpsPositionHandler, eulerToQuaternion, extractOdomPosition, extractOdomRotation, getLastDeviceOrientation, resetCoordinatorState, updateDeviceOrientation } from "./gps-event-coordinator.js";
+import { clearLastRestartedPayload, originReset, poseLost, poseReceived, resetTracking, selectLastRestartedPayload, selectLastSensorOrientation, selectLastValidPose, selectLostFrameCount, selectTrackingPhase, trackingReducer } from "./tracking-slice.js";
 import { DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, IMAGE_CONSTRAINTS, STORAGE_KEY, cloneRecordingOptions, loadRecordingOptions, resetRecordingOptions, saveRecordingOptions, validateDepthOptions, validateImageOptions, validateRecordingOptions } from "./recording-options.js";
+import { endSession, recordDepthSample, recordWriteFailure, recordingReducer, startSession } from "./recording-slice.js";
+import { captureGpsAnchorSample } from "./gps-ar-pose-sampler.js";
+import { selectAlignmentMatrix, selectFrameTilesInWebXR, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectZeroReference } from "./app-selectors.js";
+import { DEFAULT_TRACKING_QUALITY_OPTIONS, computeCompassAgreement, computeConvergence, computeCoverage, computeGpsAccuracy, computeGpsVsFusedDivergence, computeResidualConsensus, computeTrackingQualityReport, createTrackingQualityListenerMiddleware, degradedCountUpdated, firstAgreementReached, matrixDelta, reportUpdated, resetTrackingQuality, selectFirstAgreementObservationIndex, selectRecentAlignments, selectTrackingQuality, snapshotPushed, snapshotsTrimmed, trackingQualityReducer } from "./tracking-quality.js";
+import { createPersistenceMiddleware, slicePrefixOf } from "./persistence-middleware.js";
+import { createSlamAppStore } from "./create-slam-app-store.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 };
+import { add2dImage, calcRelativeCoordsInMeters, recordGpsEvent, setZeroPos } from "gps-plus-slam-js";
+export { DEFAULT_MAX_DELAY_MS, DEFAULT_RECORDING_OPTIONS, DEFAULT_TRACKING_QUALITY_OPTIONS, DEPTH_CONSTRAINTS, IMAGE_CONSTRAINTS, ReplayEngine, STORAGE_KEY, add2dImage, buildRawGpsPoint, buildRecordGpsEventPayload, calcRelativeCoordsInMeters, captureGpsAnchorSample, clearLastRestartedPayload, cloneRecordingOptions, computeCompassAgreement, computeConvergence, computeCoverage, computeGpsAccuracy, computeGpsVsFusedDivergence, computeInterActionDelay, computeResidualConsensus, computeTrackingQualityReport, createGpsPositionHandler, createPersistenceMiddleware, createSlamAppStore, createTrackingQualityListenerMiddleware, degradedCountUpdated, endSession, eulerToQuaternion, extractActionTimestamp, extractOdomPosition, extractOdomRotation, firstAgreementReached, getLastDeviceOrientation, loadRecordingOptions, matrixDelta, originReset, poseLost, poseReceived, recordDepthSample, recordGpsEvent, recordWriteFailure, recordingReducer, replayRecording, reportUpdated, resetCoordinatorState, resetRecordingOptions, resetTracking, resetTrackingQuality, saveRecordingOptions, selectAlignmentMatrix, selectFirstAgreementObservationIndex, selectFrameTilesInWebXR, selectGpsPositions, selectLastRestartedPayload, selectLastSensorOrientation, selectLastValidPose, selectLostFrameCount, selectOdometryPositions, selectOdometryRotations, selectRecentAlignments, selectTrackingPhase, selectTrackingQuality, selectZeroReference, setZeroPos, slicePrefixOf, snapshotPushed, snapshotsTrimmed, startSession, subscribeToSelector, trackingQualityReducer, trackingReducer, updateDeviceOrientation, validateDepthOptions, validateImageOptions, validateRecordingOptions, wireStoreSubscribers };

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

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

package/dist/state/persistence-middleware.js

@@ -1,5 +1,5 @@
 import { createLogger } from "../utils/logger.js";
-import { recordWriteFailure } from "./recorder-slice.js";
+import { recordWriteFailure } from "./recording-slice.js";
 //#region ../src/state/persistence-middleware.ts
 const log = createLogger("PersistenceMiddleware");
 /** Maximum number of concurrent OPFS write operations. */
@@ -27,31 +27,59 @@ var WriteQueue = class {
 	}
 };
 /**
+* Extract the slice prefix from a namespaced Redux action type.
+*
+* `'gpsData/setZeroPos'` → `'gpsData'`. Returns the whole string when there
+* is no slash (e.g. `'@@INIT'`). This is the single point that turns a
+* slice-owned action type into the value the persistence whitelist matches
+* on, so call sites can derive prefixes from real action creators instead of
+* re-typing literals.
+*/
+function slicePrefixOf(actionType) {
+	const slashIndex = actionType.indexOf("/");
+	return slashIndex === -1 ? actionType : actionType.slice(0, slashIndex);
+}
+/** Read `state.recording.isRecording`, defaulting to false for any shape. */
+function readIsRecording(state) {
+	return state?.recording?.isRecording ?? false;
+}
+/**
+* Decide whether the just-reduced action belongs to a session whose actions
+* must be persisted. True while recording, and also for the `endSession`
+* action that just flipped `isRecording` to false (Issue 5) so the session's
+* final action is still captured.
+*/
+function isInPersistableSession(wasRecording, isRecording, actionType) {
+	return isRecording || wasRecording && actionType === "recording/endSession";
+}
+/**
 * Create a Redux middleware that persists qualifying actions to storage
 * during active recording sessions.
 *
 * Persistence rules:
-* - Only persists when `state.recorder.isRecording` is true (checked AFTER
+* - Only persists when `state.recording.isRecording` is true (checked AFTER
 *   the action is reduced, so `startSession` itself is included).
-* - Persists `gpsData/*` and `recorder/*` actions.
-* - Excludes `recorder/recordWriteFailure` to prevent recursive persistence.
-* - Excludes `routing/*`, `refPoints/*`, and any other non-recording actions.
+* - Persists actions whose slice prefix is listed in `persistedPrefixes`.
+* - Excludes `recording/recordWriteFailure` to prevent recursive persistence.
+* - Excludes `routing/*` and any other non-whitelisted actions.
 * - Uses 1-based indexing for action files (000001.json, 000002.json, …).
 * - Each middleware instance maintains its own action index (Bug 10 fix).
 */
 function createPersistenceMiddleware(options) {
-	const { storageBackend, onWriteFailure } = options;
+	const { storageBackend, onWriteFailure, persistedPrefixes } = options;
+	const normalizedPrefixes = persistedPrefixes.map((prefix) => prefix.endsWith("/") ? prefix : `${prefix}/`);
+	const excludedActionType = recordWriteFailure.type;
 	let actionIndex = 0;
 	const writeQueue = new WriteQueue();
 	const middleware = (store) => (next) => (action) => {
 		const typedAction = action;
 		const actionType = typeof typedAction.type === "string" ? typedAction.type : null;
-		const wasRecording = store.getState().recorder?.isRecording ?? false;
+		const wasRecording = readIsRecording(store.getState());
 		const result = next(action);
 		if (!actionType) return result;
-		if (actionType === "recorder/startSession") actionIndex = 0;
-		if (!((store.getState().recorder?.isRecording ?? false) || wasRecording && actionType === "recorder/endSession")) return result;
-		if (!(actionType.startsWith("gpsData/") || actionType.startsWith("recorder/") && actionType !== "recorder/recordWriteFailure")) return result;
+		if (actionType === "recording/startSession") actionIndex = 0;
+		if (!isInPersistableSession(wasRecording, readIsRecording(store.getState()), actionType)) return result;
+		if (!(actionType !== excludedActionType && normalizedPrefixes.some((prefix) => actionType.startsWith(prefix)))) return result;
 		const index = ++actionIndex;
 		writeQueue.enqueue(async () => {
 			try {
@@ -68,4 +96,4 @@ function createPersistenceMiddleware(options) {
 	return middleware;
 }
 //#endregion
-export { createPersistenceMiddleware };
+export { createPersistenceMiddleware, slicePrefixOf };

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

@@ -1,2 +1,2 @@
-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, m as validateArCrashIsolationOptions, n as DEFAULT_RECORDING_OPTIONS, o as ImageCaptureOptions, p as saveRecordingOptions, r as DEPTH_CONSTRAINTS, s as RecordingOptions, t as ArCrashIsolationOptions, u as cloneRecordingOptions } from "../recording-options-BYUFX8iU.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, m as validateArCrashIsolationOptions, n as DEFAULT_RECORDING_OPTIONS, o as ImageCaptureOptions, p as saveRecordingOptions, r as DEPTH_CONSTRAINTS, s as RecordingOptions, t as ArCrashIsolationOptions, u as cloneRecordingOptions } from "../recording-options-Dq6IsKAv.js";
 export { ArCrashIsolationOptions, DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, DepthCaptureOptions, IMAGE_CONSTRAINTS, ImageCaptureOptions, RecordingOptions, RecordingOptionsInput, STORAGE_KEY, cloneRecordingOptions, loadRecordingOptions, resetRecordingOptions, saveRecordingOptions, validateArCrashIsolationOptions, validateDepthOptions, validateImageOptions, validateRecordingOptions };

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

@@ -1,2 +1,3 @@
-import { n as replayRecording, t as ReplayRecordingOptions } from "../recording-replayer-oOzPITrd.js";
-export { ReplayRecordingOptions, replayRecording };
+import { L as CombinedRootState } from "../create-slam-app-store-CNsZ3rcX.js";
+import { n as replayRecording, t as ReplayRecordingOptions } from "../recording-replayer-CmCIIZ02.js";
+export { CombinedRootState, ReplayRecordingOptions, replayRecording };

package/dist/state/recording-replayer.js

@@ -1,6 +1,6 @@
-import { createRecorderStore } from "./store.js";
 import { loadActionsFromZip } from "../storage/zip-reader.js";
 import { NullStorageBackend } from "../storage/null-storage-backend.js";
+import { createSlamAppStore } from "./create-slam-app-store.js";
 //#region ../src/state/recording-replayer.ts
 /**
 * Recording Replayer
@@ -29,7 +29,7 @@ import { NullStorageBackend } from "../storage/null-storage-backend.js";
 * @throws If the zip cannot be parsed or contains invalid data
 */
 async function replayRecording(zipData, options) {
-	const store = createRecorderStore({ storageBackend: new NullStorageBackend() });
+	const store = createSlamAppStore({ storageBackend: new NullStorageBackend() });
 	let actions = (await loadActionsFromZip(zipData)).map((e) => e.action);
 	if (options?.migrateActions) actions = options.migrateActions(actions);
 	for (const action of actions) store.dispatch(action);

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

@@ -0,0 +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-d6OtCrza.js";
+export { RecordingState, SessionMetadata, endSession, recordDepthSample, recordWriteFailure, recordingReducer, startSession };

package/dist/state/{recorder-slice.js → recording-slice.js}

@@ -1,13 +1,12 @@
 import { createSlice } from "@reduxjs/toolkit";
-//#region ../src/state/recorder-slice.ts
-const recorderSlice = createSlice({
-	name: "recorder",
+//#region ../src/state/recording-slice.ts
+const recordingSlice = createSlice({
+	name: "recording",
 	initialState: {
 		isRecording: false,
 		sessionMetadata: null,
 		actionCount: 0,
-		failedWriteCount: 0,
-		currentScenarioName: ""
+		failedWriteCount: 0
 	},
 	reducers: {
 		startSession(state, action) {
@@ -31,17 +30,10 @@ const recorderSlice = createSlice({
 		*/
 		recordWriteFailure(state, _action) {
 			state.failedWriteCount += 1;
-		},
-		/**
-		* Set the currently selected scenario name.
-		* Replaces the closure variable threading through folder-manager deps.
-		*/
-		setCurrentScenarioName(state, action) {
-			state.currentScenarioName = action.payload;
 		}
 	}
 });
-const { startSession, endSession, recordDepthSample, recordWriteFailure, setCurrentScenarioName } = recorderSlice.actions;
-const recorderReducer = recorderSlice.reducer;
+const { startSession, endSession, recordDepthSample, recordWriteFailure } = recordingSlice.actions;
+const recordingReducer = recordingSlice.reducer;
 //#endregion
-export { endSession, recordDepthSample, recordWriteFailure, recorderReducer, setCurrentScenarioName, startSession };
+export { 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-DuX316ae.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-BGBRQyXs.js";
 export { CompleteCallback, DEFAULT_MAX_DELAY_MS, ErrorCallback, ProgressCallback, ReplayAction, ReplayEngine, ReplayState, computeInterActionDelay, extractActionTimestamp };

package/dist/state/replay-engine.js

@@ -25,7 +25,7 @@ function extractActionTimestamp(action) {
 			if (gpsPoint && typeof gpsPoint.timestamp === "number") return gpsPoint.timestamp;
 			return null;
 		}
-		case "recorder/startSession":
+		case "recording/startSession":
 			if (typeof payload.startTime === "number") return payload.startTime;
 			return null;
 		case "gpsData/markReferencePoint": {
@@ -36,8 +36,8 @@ function extractActionTimestamp(action) {
 			if (gpsPoint && typeof gpsPoint.timestamp === "number") return gpsPoint.timestamp;
 			return null;
 		}
-		case "recorder/recordDepthSample": return null;
-		case "recorder/endSession": return null;
+		case "recording/recordDepthSample": 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-UTZ0KkAc.js";
-import { n as wireStoreSubscribers, t as StoreSubscriberDeps } from "../store-subscribers-CuoIzB5T.js";
+import { t as SubscribableStore } from "../subscribe-to-selector-DIHm3BRZ.js";
+import { n as wireStoreSubscribers, t as StoreSubscriberDeps } from "../store-subscribers-Dce_CoJF.js";
 export { StoreSubscriberDeps, SubscribableStore, wireStoreSubscribers };

package/dist/state/store-subscribers.js

@@ -1,6 +1,6 @@
-import { fusedGpsFromOdom } from "../utils/fused-path.js";
+import { selectAlignmentMatrix, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectZeroReference } from "./app-selectors.js";
+import { buildMapData } from "../visualization/map-data.js";
 import { subscribeToSelector } from "./subscribe-to-selector.js";
-import { selectAlignmentMatrix, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectReferencePoints, selectZeroReference } from "./app-selectors.js";
 import { calcGpsCoords } from "gps-plus-slam-js";
 import { mat4, vec3 } from "gl-matrix";
 //#region ../src/state/store-subscribers.ts
@@ -27,6 +27,30 @@ function wireStoreSubscribers(store, deps) {
 	const _odomVec = vec3.create();
 	const _alignedVec = vec3.create();
 	const unsubs = [];
+	const alignmentSnapshotGps = [];
+	/**
+	* Rebuild the full map snapshot from the current store state and hand it to
+	* the overlay's `render`. Called whenever the alignment matrix or the GPS
+	* positions change — the change-gated subscriptions below provide the
+	* throttling, so no extra debouncing is needed. The fused path is always
+	* recomputed from the latest matrix inside `buildMapData` (D2).
+	*/
+	function rebuildMap() {
+		if (!deps.mapOverlay?.render) return;
+		const state = store.getState();
+		const rawGpsPath = selectGpsPositions(state).map((p) => ({
+			lat: p.latitude,
+			lng: p.longitude,
+			accuracy: p.latLongAccuracy
+		}));
+		deps.mapOverlay.render(buildMapData({
+			rawGpsPath,
+			odometryPositions: selectOdometryPositions(state),
+			alignmentMatrix: selectAlignmentMatrix(state),
+			zeroRef: selectZeroReference(state),
+			alignmentSnapshots: alignmentSnapshotGps
+		}));
+	}
 	unsubs.push(subscribeToSelector(store, selectAlignmentMatrix, (matrix) => {
 		if (!matrix) return;
 		deps.applyAlignmentMatrix(matrix);
@@ -45,11 +69,15 @@ function wireStoreSubscribers(store, deps) {
 			deps.gpsEventVisualizer.addAlignmentSnapshot(snapshotPos);
 			deps.onAlignmentSnapshot?.(snapshotPos);
 			const zeroRef = selectZeroReference(state);
-			if (zeroRef && deps.mapOverlay?.addAlignmentSnapshot) {
+			if (zeroRef) {
 				const gps = calcGpsCoords(zeroRef, _alignedVec);
-				deps.mapOverlay.addAlignmentSnapshot(gps.lat, gps.lon);
+				alignmentSnapshotGps.push({
+					lat: gps.lat,
+					lng: gps.lon
+				});
 			}
 		}
+		rebuildMap();
 	}));
 	unsubs.push(subscribeToSelector(store, selectGpsPositions, (gpsPositions, prevPositions) => {
 		const prevCount = prevPositions?.length ?? 0;
@@ -62,16 +90,13 @@ function wireStoreSubscribers(store, deps) {
 			const gpsPoint = gpsPositions[i];
 			const odomPos = odomPositions[i];
 			if (gpsPoint && odomPos) {
-				deps.gpsEventVisualizer.addGpsEvent(gpsPoint.coordinates, odomPos);
+				const accuracy = deps.showAccuracySpheres ? {
+					horizontal: gpsPoint.latLongAccuracy,
+					vertical: gpsPoint.altitudeAccuracy
+				} : void 0;
+				deps.gpsEventVisualizer.addGpsEvent(gpsPoint.coordinates, odomPos, accuracy);
 				deps.onNewGpsPosition?.(gpsPoint.coordinates);
 				deps.onNewGpsLatLng?.(gpsPoint.latitude, gpsPoint.longitude);
-				deps.mapOverlay?.addRawGpsPoint?.(gpsPoint.latitude, gpsPoint.longitude);
-				const alignmentMatrix = selectAlignmentMatrix(state);
-				const zero = selectZeroReference(state);
-				if (alignmentMatrix && zero && deps.mapOverlay?.addFusedPoint) {
-					const fusedGps = fusedGpsFromOdom(alignmentMatrix, odomPos, zero);
-					deps.mapOverlay.addFusedPoint(fusedGps.lat, fusedGps.lon);
-				}
 				const odomRot = odomRotations[i];
 				if (odomRot) deps.onNewOdomPose?.(odomPos, odomRot);
 			}
@@ -80,14 +105,7 @@ function wireStoreSubscribers(store, deps) {
 			const lastGpsPoint = gpsPositions[gpsPositions.length - 1];
 			deps.mapOverlay.setGpsPosition(lastGpsPoint.latitude, lastGpsPoint.longitude);
 		}
-	}));
-	unsubs.push(subscribeToSelector(store, selectReferencePoints, (refPoints, prevPoints) => {
-		const prevCount = prevPoints?.length ?? 0;
-		if (!deps.mapOverlay?.addRefPoint || refPoints.length <= prevCount) return;
-		for (let i = prevCount; i < refPoints.length; i++) {
-			const rp = refPoints[i];
-			deps.mapOverlay.addRefPoint(rp.gpsPoint.latitude, rp.gpsPoint.longitude, rp.id);
-		}
+		rebuildMap();
 	}));
 	return () => {
 		for (const unsub of unsubs) unsub();

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

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

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

@@ -0,0 +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-CNsZ3rcX.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 };