gps-plus-slam-app-framework 1.0.0

package/dist/state/persistence-middleware.js

@@ -0,0 +1,71 @@
+import { createLogger } from "../utils/logger.js";
+import { recordWriteFailure } from "./recorder-slice.js";
+//#region ../src/state/persistence-middleware.ts
+const log = createLogger("PersistenceMiddleware");
+/** Maximum number of concurrent OPFS write operations. */
+const MAX_CONCURRENT_WRITES = 3;
+/**
+* Simple write queue that limits concurrent OPFS operations.
+* Prevents unbounded memory growth when storage is slow.
+*/
+var WriteQueue = class {
+	pendingCount = 0;
+	queue = [];
+	enqueue(writeFn) {
+		this.queue.push(writeFn);
+		this.drain();
+	}
+	drain() {
+		while (this.pendingCount < MAX_CONCURRENT_WRITES && this.queue.length > 0) {
+			const fn = this.queue.shift();
+			this.pendingCount++;
+			fn().finally(() => {
+				this.pendingCount--;
+				this.drain();
+			});
+		}
+	}
+};
+/**
+* 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
+*   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.
+* - 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;
+	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 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;
+		const index = ++actionIndex;
+		writeQueue.enqueue(async () => {
+			try {
+				await storageBackend.writeAction(typedAction, index);
+			} catch (err) {
+				const normalized = err instanceof Error ? err : new Error(String(err));
+				log.error("Failed to persist action:", normalized);
+				store.dispatch(recordWriteFailure(normalized.message));
+				if (onWriteFailure) onWriteFailure(normalized);
+			}
+		});
+		return result;
+	};
+	return middleware;
+}
+//#endregion
+export { createPersistenceMiddleware };

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

@@ -0,0 +1,2 @@
+import { a as recordWriteFailure, c as startSession, i as recordDepthSample, n as SessionMetadata, o as recorderReducer, r as endSession, s as setCurrentScenarioName, t as RecorderState } from "../recorder-slice-fcwAXrsh.js";
+export { RecorderState, SessionMetadata, endSession, recordDepthSample, recordWriteFailure, recorderReducer, setCurrentScenarioName, startSession };

package/dist/state/recorder-slice.js

@@ -0,0 +1,47 @@
+import { createSlice } from "@reduxjs/toolkit";
+//#region ../src/state/recorder-slice.ts
+const recorderSlice = createSlice({
+	name: "recorder",
+	initialState: {
+		isRecording: false,
+		sessionMetadata: null,
+		actionCount: 0,
+		failedWriteCount: 0,
+		currentScenarioName: ""
+	},
+	reducers: {
+		startSession(state, action) {
+			state.isRecording = true;
+			state.sessionMetadata = action.payload;
+			state.actionCount = 0;
+			state.failedWriteCount = 0;
+		},
+		endSession(state) {
+			state.isRecording = false;
+		},
+		/**
+		* Record a depth sample from WebXR depth sensing.
+		* The sample includes camera pose and a grid of depth points.
+		* This action is persisted to enable replay with depth data.
+		*/
+		recordDepthSample(_state, _action) {},
+		/**
+		* Record a write failure during persistence.
+		* User Feedback Issue #1 Part B: Track write failures for session summary.
+		*/
+		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;
+//#endregion
+export { endSession, recordDepthSample, recordWriteFailure, recorderReducer, setCurrentScenarioName, startSession };

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

@@ -0,0 +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";
+export { RecordingCoordinatorConfig, buildRawGpsPoint, buildRecordGpsEventPayload, createGpsPositionHandler, eulerToQuaternion, extractOdomPosition, extractOdomRotation, getLastDeviceOrientation, resetCoordinatorState, updateDeviceOrientation };

package/dist/state/recording-coordinator.js

@@ -0,0 +1,150 @@
+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
+const log = createLogger("RecordingCoordinator");
+/** Counter for generating unique GPS point IDs */
+let gpsEventCounter = 0;
+/**
+* State for device orientation (captured separately from GPS)
+*/
+let lastDeviceOrientation = null;
+/**
+* Update the cached device orientation.
+* Called by orientation watch, used when GPS event arrives.
+*/
+function updateDeviceOrientation(orientation) {
+	lastDeviceOrientation = orientation;
+}
+/**
+* Get the current cached device orientation.
+*/
+function getLastDeviceOrientation() {
+	return lastDeviceOrientation;
+}
+/**
+* Clear cached state (for testing or session reset)
+*/
+function resetCoordinatorState() {
+	lastDeviceOrientation = null;
+	gpsEventCounter = 0;
+}
+/**
+* Extract raw odometry position tuple from ARPose.
+*
+* Returns the raw WebXR position without coordinate conversion.
+* The reducer applies the WebXR→NUE transform when storing into state
+* (raw-storage pattern, see docs/2026-04-09-raw-storage-convert-on-read.md).
+*
+* WebXR local-floor frame: X=East, Y=Up, Z=South (toward viewer / backward).
+*/
+function extractOdomPosition(arPose) {
+	return [
+		arPose.position.x,
+		arPose.position.y,
+		arPose.position.z
+	];
+}
+/**
+* Extract odometry rotation tuple from ARPose.
+*/
+function extractOdomRotation(arPose) {
+	return [
+		arPose.orientation.x,
+		arPose.orientation.y,
+		arPose.orientation.z,
+		arPose.orientation.w
+	];
+}
+/**
+* Build a RawGpsPoint from GPS position data.
+* Returns only raw sensor fields — no derived fields (coordinates, weight,
+* zeroRef, deviceRotation). Derived fields are computed by the library
+* reducer when the action is dispatched (raw-storage pattern).
+*
+* @param gpsPosition - GPS position from Geolocation API
+* @param deviceOrientation - Optional device orientation from sensors
+* @returns RawGpsPoint ready for the action payload
+*/
+function buildRawGpsPoint(gpsPosition, deviceOrientation) {
+	const compassAbsolute = deviceOrientation ? deviceOrientation.absolute : void 0;
+	return {
+		id: `gps-${++gpsEventCounter}`,
+		latitude: gpsPosition.lat,
+		longitude: gpsPosition.lon,
+		altitude: gpsPosition.altitude ?? void 0,
+		latLongAccuracy: gpsPosition.accuracy,
+		altitudeAccuracy: gpsPosition.altitudeAccuracy ?? void 0,
+		heading: gpsPosition.heading ?? void 0,
+		speed: gpsPosition.speed ?? void 0,
+		compassAbsolute,
+		timestamp: gpsPosition.timestamp
+	};
+}
+/**
+* Build a RecordGpsEventPayload from GPS position and AR pose.
+* This is a pure function for testability.
+*
+* Stores only raw sensor data in the payload. The library reducer
+* computes derived fields (coordinates, weight, deviceRotation)
+* when the action is processed (raw-storage pattern).
+*
+* @param gpsPosition - GPS position from Geolocation API
+* @param arPose - AR pose from WebXR
+* @param deviceOrientation - Optional device orientation from sensors
+* @returns RecordGpsEventPayload ready for dispatch
+*/
+function buildRecordGpsEventPayload(gpsPosition, arPose, deviceOrientation) {
+	const rawDeviceOrientation = deviceOrientation?.alpha != null && deviceOrientation?.beta != null && deviceOrientation?.gamma != null ? {
+		alpha: deviceOrientation.alpha,
+		beta: deviceOrientation.beta,
+		gamma: deviceOrientation.gamma,
+		absolute: deviceOrientation.absolute
+	} : void 0;
+	return {
+		odomPosition: extractOdomPosition(arPose),
+		odomRotation: extractOdomRotation(arPose),
+		rawGpsPoint: buildRawGpsPoint(gpsPosition, deviceOrientation),
+		rawDeviceOrientation
+	};
+}
+/**
+* Create a GPS position handler that dispatches combined GPS+AR events.
+*
+* This is the CRITICAL function that implements the correct architecture:
+* - Called when GPS arrives
+* - Reads current AR pose
+* - Dispatches single combined action
+*
+* @param config - Configuration with store and getArPose function
+* @returns Callback function for GPS watch
+*/
+function createGpsPositionHandler(config) {
+	const { store, getArPose } = config;
+	return (position) => {
+		if (!store.getState().recorder.isRecording) return;
+		const arPose = getArPose();
+		if (!arPose) {
+			log.warn("GPS arrived but no AR pose available");
+			return;
+		}
+		if (!store.getState().gpsData) {
+			const zeroRef = {
+				lat: position.lat,
+				lon: position.lon
+			};
+			store.dispatch(setZeroPos(zeroRef));
+			log.info(`Set zero reference: ${zeroRef.lat}, ${zeroRef.lon}`);
+		}
+		if (!getZeroReference(store.getState())) {
+			log.error("Failed to get zero reference");
+			return;
+		}
+		const payload = buildRecordGpsEventPayload(position, arPose, lastDeviceOrientation);
+		store.dispatch(recordGpsEvent(payload));
+		const eventCount = getOdometryPositions(store.getState()).length;
+		log.info(`Recorded GPS event #${eventCount}`);
+	};
+}
+//#endregion
+export { buildRawGpsPoint, buildRecordGpsEventPayload, createGpsPositionHandler, eulerToQuaternion, extractOdomPosition, extractOdomRotation, getLastDeviceOrientation, resetCoordinatorState, updateDeviceOrientation };

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

@@ -0,0 +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";
+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-options.js

@@ -0,0 +1,192 @@
+import { createLogger } from "../utils/logger.js";
+//#region ../src/state/recording-options.ts
+/**
+* Recording Options - User-configurable settings for data capture.
+*
+* Allows users to disable/configure high-frequency data streams
+* (depth sampling, image capture) to improve performance on lower-end devices.
+*
+* Options persist in localStorage across sessions.
+*/
+const log = createLogger("RecordingOptions");
+/**
+* localStorage key for persisted options.
+*
+* **Multi-tab caveat:** All tabs/instances sharing the same origin will
+* read and write this key. In multi-tab or embedded scenarios, concurrent
+* saves can silently overwrite each other. Use a custom `storageKey`
+* parameter in `loadRecordingOptions` / `saveRecordingOptions` to isolate
+* instances when needed.
+*/
+const STORAGE_KEY = "gps-plus-slam-recorder-options";
+/** Default recording options (all streams enabled) */
+const DEFAULT_RECORDING_OPTIONS = {
+	depth: {
+		enabled: true,
+		intervalMs: 1e3,
+		gridSize: 3
+	},
+	images: {
+		enabled: true,
+		intervalMs: 2e3,
+		quality: .7,
+		resolutionDivisor: 1
+	},
+	arCrashIsolation: {
+		enableDomOverlay: true,
+		enableCameraAccess: true,
+		enableDepthSensingFeature: true,
+		enableCss3dRenderer: true,
+		enableCameraTextureAcquisition: true,
+		applyChromiumProjectionLayerWorkaround: true
+	}
+};
+/** Validation constraints for depth options */
+const DEPTH_CONSTRAINTS = {
+	intervalMs: {
+		min: 500,
+		max: 5e3,
+		step: 100
+	},
+	gridSize: {
+		min: 2,
+		max: 10,
+		step: 1
+	}
+};
+/** Validation constraints for image options */
+const IMAGE_CONSTRAINTS = {
+	intervalMs: {
+		min: 1e3,
+		max: 1e4,
+		step: 500
+	},
+	quality: {
+		min: .3,
+		max: 1,
+		step: .1
+	},
+	resolutionDivisor: {
+		min: 1,
+		max: 8,
+		step: 1
+	}
+};
+/**
+* Validate and normalize AR crash isolation flags.
+* Missing or invalid values fall back to defaults.
+*/
+function validateArCrashIsolationOptions(options) {
+	const defaults = DEFAULT_RECORDING_OPTIONS.arCrashIsolation;
+	return {
+		enableDomOverlay: typeof options.enableDomOverlay === "boolean" ? options.enableDomOverlay : defaults.enableDomOverlay,
+		enableCameraAccess: typeof options.enableCameraAccess === "boolean" ? options.enableCameraAccess : defaults.enableCameraAccess,
+		enableDepthSensingFeature: typeof options.enableDepthSensingFeature === "boolean" ? options.enableDepthSensingFeature : defaults.enableDepthSensingFeature,
+		enableCss3dRenderer: typeof options.enableCss3dRenderer === "boolean" ? options.enableCss3dRenderer : defaults.enableCss3dRenderer,
+		enableCameraTextureAcquisition: typeof options.enableCameraTextureAcquisition === "boolean" ? options.enableCameraTextureAcquisition : defaults.enableCameraTextureAcquisition,
+		applyChromiumProjectionLayerWorkaround: typeof options.applyChromiumProjectionLayerWorkaround === "boolean" ? options.applyChromiumProjectionLayerWorkaround : defaults.applyChromiumProjectionLayerWorkaround
+	};
+}
+/**
+* Clamp a value to the specified constraints.
+*/
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(max, value));
+}
+/**
+* Validate and normalize depth options.
+* Invalid values are clamped to valid ranges.
+*/
+function validateDepthOptions(options) {
+	const defaults = DEFAULT_RECORDING_OPTIONS.depth;
+	return {
+		enabled: typeof options.enabled === "boolean" ? options.enabled : defaults.enabled,
+		intervalMs: clamp(typeof options.intervalMs === "number" ? options.intervalMs : defaults.intervalMs, DEPTH_CONSTRAINTS.intervalMs.min, DEPTH_CONSTRAINTS.intervalMs.max),
+		gridSize: clamp(typeof options.gridSize === "number" ? options.gridSize : defaults.gridSize, DEPTH_CONSTRAINTS.gridSize.min, DEPTH_CONSTRAINTS.gridSize.max)
+	};
+}
+/**
+* Validate and normalize image options.
+* Invalid values are clamped to valid ranges.
+*/
+function validateImageOptions(options) {
+	const defaults = DEFAULT_RECORDING_OPTIONS.images;
+	return {
+		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)
+	};
+}
+/**
+* Validate and normalize a full RecordingOptions object.
+* Merges with defaults and clamps invalid values.
+*/
+function validateRecordingOptions(options) {
+	return {
+		depth: validateDepthOptions(options.depth ?? {}),
+		images: validateImageOptions(options.images ?? {}),
+		arCrashIsolation: validateArCrashIsolationOptions(options.arCrashIsolation ?? {})
+	};
+}
+/**
+* Load recording options from localStorage.
+* Returns defaults if no saved options exist or parsing fails.
+* Validates and merges with defaults to handle schema evolution.
+* @param storageKey - Optional custom localStorage key (defaults to STORAGE_KEY).
+*/
+function loadRecordingOptions(storageKey = STORAGE_KEY) {
+	try {
+		const stored = localStorage.getItem(storageKey);
+		if (stored) {
+			const parsed = JSON.parse(stored);
+			log.debug("Loaded options from storage:", parsed);
+			return validateRecordingOptions(parsed);
+		}
+	} catch (err) {
+		log.warn("Failed to load recording options:", err);
+	}
+	log.debug("Using default recording options");
+	return cloneRecordingOptions(DEFAULT_RECORDING_OPTIONS);
+}
+/**
+* Save recording options to localStorage.
+* Options are validated before saving.
+* @param storageKey - Optional custom localStorage key (defaults to STORAGE_KEY).
+*/
+function saveRecordingOptions(options, storageKey = STORAGE_KEY) {
+	try {
+		const validated = validateRecordingOptions(options);
+		localStorage.setItem(storageKey, JSON.stringify(validated));
+		log.debug("Saved recording options:", validated);
+	} catch (err) {
+		log.warn("Failed to save recording options:", err);
+	}
+}
+/**
+* Reset recording options to defaults.
+* Clears localStorage and returns default options.
+* @param storageKey - Optional custom localStorage key (defaults to STORAGE_KEY).
+*/
+function resetRecordingOptions(storageKey = STORAGE_KEY) {
+	try {
+		localStorage.removeItem(storageKey);
+		log.debug("Reset recording options to defaults");
+	} catch (err) {
+		log.warn("Failed to clear recording options from storage:", err);
+	}
+	return cloneRecordingOptions(DEFAULT_RECORDING_OPTIONS);
+}
+/**
+* Create a deep copy of recording options.
+* Useful for creating mutable copies of the frozen defaults.
+*/
+function cloneRecordingOptions(options) {
+	return {
+		depth: { ...options.depth },
+		images: { ...options.images },
+		arCrashIsolation: { ...options.arCrashIsolation }
+	};
+}
+//#endregion
+export { DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, IMAGE_CONSTRAINTS, STORAGE_KEY, cloneRecordingOptions, loadRecordingOptions, resetRecordingOptions, saveRecordingOptions, validateArCrashIsolationOptions, validateDepthOptions, validateImageOptions, validateRecordingOptions };

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

@@ -0,0 +1,2 @@
+import { n as replayRecording, t as ReplayRecordingOptions } from "../recording-replayer-oOzPITrd.js";
+export { ReplayRecordingOptions, replayRecording };

package/dist/state/recording-replayer.js

@@ -0,0 +1,39 @@
+import { createRecorderStore } from "./store.js";
+import { loadActionsFromZip } from "../storage/zip-reader.js";
+import { NullStorageBackend } from "../storage/null-storage-backend.js";
+//#region ../src/state/recording-replayer.ts
+/**
+* Recording Replayer
+*
+* Replays a recorded session from a zip file into a fresh store,
+* producing the fully-computed CombinedRootState without any persistence
+* side effects.
+*
+* This is the primary entry point for loading recordings for
+* visualization, comparison, validation, or offline analysis.
+*
+* Uses NullStorageBackend to ensure no OPFS writes occur during replay.
+*
+* See also: Finding F5 in docs/2026-02-15-replay-integration-test-review.md
+*/
+/**
+* Replay a recording session from zip data, returning the final state.
+*
+* Loads all actions from the zip, creates a store with no persistence,
+* optionally migrates old-format actions, dispatches in order, and returns
+* the resulting state.
+*
+* @param zipData - The zip file content as a Uint8Array
+* @param options - Optional replay configuration (e.g., action migration)
+* @returns The fully-replayed combined state (library + recorder)
+* @throws If the zip cannot be parsed or contains invalid data
+*/
+async function replayRecording(zipData, options) {
+	const store = createRecorderStore({ 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);
+	return store.getState();
+}
+//#endregion
+export { replayRecording };

package/dist/state/ref-points-slice.d.ts

@@ -0,0 +1,2 @@
+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";
+export { RefPointsState, clearSessionRefPointUsage, incrementRefPointUsage, refPointsReducer, resetRefPointsState, selectCachedKnownRefPoints, setImportedRefPoints };

package/dist/state/ref-points-slice.js

@@ -0,0 +1,44 @@
+import { gpsToH3 } from "../ref-points/h3-ref-point.js";
+import { createSelector, createSlice } from "@reduxjs/toolkit";
+//#region ../src/state/ref-points-slice.ts
+const initialState = {
+	importedRefPoints: [],
+	sessionRefPointUsage: {}
+};
+const refPointsSlice = createSlice({
+	name: "refPoints",
+	initialState,
+	reducers: {
+		setImportedRefPoints(state, action) {
+			state.importedRefPoints = action.payload;
+		},
+		incrementRefPointUsage(state, action) {
+			const id = action.payload;
+			state.sessionRefPointUsage[id] = (state.sessionRefPointUsage[id] ?? 0) + 1;
+		},
+		clearSessionRefPointUsage(state) {
+			state.sessionRefPointUsage = {};
+		},
+		resetRefPointsState() {
+			return initialState;
+		}
+	}
+});
+const { setImportedRefPoints, incrementRefPointUsage, clearSessionRefPointUsage, resetRefPointsState } = refPointsSlice.actions;
+const refPointsReducer = refPointsSlice.reducer;
+/**
+* Memoized selector that derives KnownRefPoint[] (with H3 indices) from
+* importedRefPoints. Replaces the closure-based `recomputeKnownRefPoints()`
+* in ref-point-handlers.ts.
+*
+* Uses createSelector (reselect) for standard RTK memoization — recomputes
+* only when the importedRefPoints array reference changes.
+*/
+const selectCachedKnownRefPoints = createSelector((state) => state.importedRefPoints, (importedRefPoints) => importedRefPoints.map((rp) => ({
+	h3Index: gpsToH3(rp.lat, rp.lon),
+	displayName: rp.name || rp.id,
+	lat: rp.lat,
+	lon: rp.lon
+})));
+//#endregion
+export { clearSessionRefPointUsage, incrementRefPointUsage, refPointsReducer, resetRefPointsState, selectCachedKnownRefPoints, setImportedRefPoints };

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

@@ -0,0 +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";
+export { CompleteCallback, DEFAULT_MAX_DELAY_MS, ErrorCallback, ProgressCallback, ReplayAction, ReplayEngine, ReplayState, computeInterActionDelay, extractActionTimestamp };