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

package/dist/reference-points-CFWy8_wj.d.ts

@@ -1,68 +0,0 @@
-import { n as RefPointMark } from "./ref-point-loader-Pt1smgHS.js";
-import { LatLong } from "gps-plus-slam-js";
-
-//#region ../src/visualization/reference-points.d.ts
-/**
- * Manager for reference point visualization
- */
-declare class RefPointVisualizer {
-  private priorRefMeshes;
-  private currentRefMeshes;
-  private zeroRef;
-  /** Shared geometry for prior-session ref point meshes (lazy-created) */
-  private priorRefGeometry;
-  /** Shared material for prior-session ref point meshes (lazy-created) */
-  private priorRefMaterial;
-  /** Shared geometry for current-session ref point meshes (lazy-created) */
-  private currentRefGeometry;
-  /**
-   * Set the GPS zero reference (origin for coordinate conversion).
-   * Must be called before displaying reference points.
-   *
-   * @param zero - GPS coordinates of the origin
-   */
-  setZeroRef(zero: LatLong): void;
-  /**
-   * Get the current zero reference
-   */
-  getZeroRef(): LatLong | null;
-  /**
-   * Display reference points from prior sessions.
-   * Clears any existing prior ref points first.
-   *
-   * @param refPoints - Array of reference point marks to visualize
-   */
-  displayPriorRefPoints(refPoints: RefPointMark[]): void;
-  /**
-   * Add a reference point from the current session.
-   *
-   * @param refPoint - Reference point mark to visualize
-   */
-  addCurrentRefPoint(refPoint: RefPointMark): void;
-  /**
-   * Clear all prior reference point meshes from the scene.
-   */
-  clearPriorRefPoints(): void;
-  /**
-   * Clear current session reference point meshes from the scene.
-   */
-  clearCurrentRefPoints(): void;
-  /**
-   * Clear all visualizations and reset state.
-   */
-  clearAll(): void;
-  /**
-   * Get count of visible reference points.
-   */
-  getCounts(): {
-    prior: number;
-    current: number;
-  };
-}
-/**
- * Singleton instance for global use.
- * Import this to visualize reference points.
- */
-declare const refPointVisualizer: RefPointVisualizer;
-//#endregion
-export { refPointVisualizer as n, RefPointVisualizer as t };

package/dist/routing-slice-BlHTM8eh.d.ts

@@ -1,23 +0,0 @@
-import * as _$_reduxjs_toolkit0 from "@reduxjs/toolkit";
-
-//#region ../src/state/routing-slice.d.ts
-/**
- * Routing Slice — Redux state for current application screen.
- *
- * Bug 2 fix (SPA architecture audit): Moves `currentScreen` from a
- * module-level variable in navigation.ts into Redux, making it the
- * single source of truth for screen state. This enables time-travel
- * debugging and prevents desync between navigation state and Redux.
- *
- * @see docs/2026-04-06-spa-architecture-audit.md — Bug 2
- * @see docs_guides/spa-architecture-best-practices.md — §4 State-Driven Routing
- */
-/** Application screen states for history-based navigation. */
-type AppScreen = 'setup' | 'ar' | 'recording' | 'summary';
-interface RoutingState {
-  currentScreen: AppScreen;
-}
-declare const navigateTo: _$_reduxjs_toolkit0.ActionCreatorWithPayload<AppScreen, "routing/navigateTo">;
-declare const routingReducer: _$_reduxjs_toolkit0.Reducer<RoutingState>;
-//#endregion
-export { routingReducer as i, RoutingState as n, navigateTo as r, AppScreen as t };

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

@@ -1,2 +0,0 @@
-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/ref-points-slice.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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/routing-slice.d.ts

@@ -1,2 +0,0 @@
-import { i as routingReducer, n as RoutingState, r as navigateTo, t as AppScreen } from "../routing-slice-BlHTM8eh.js";
-export { AppScreen, RoutingState, navigateTo, routingReducer };

package/dist/state/routing-slice.js

@@ -1,13 +0,0 @@
-import { createSlice } from "@reduxjs/toolkit";
-//#region ../src/state/routing-slice.ts
-const routingSlice = createSlice({
-	name: "routing",
-	initialState: { currentScreen: "setup" },
-	reducers: { navigateTo(state, action) {
-		state.currentScreen = action.payload;
-	} }
-});
-const { navigateTo } = routingSlice.actions;
-const routingReducer = routingSlice.reducer;
-//#endregion
-export { navigateTo, routingReducer };

package/dist/state/store.d.ts

@@ -1,9 +0,0 @@
-import { i as DepthSample, r as DepthPoint } from "../ar-types-B-ORgk6Z.js";
-import { s as RecordingOptions } 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, r as endSession, s as setCurrentScenarioName, t as RecorderState } from "../recorder-slice-fcwAXrsh.js";
-import { a as resetRefPointsState, n as clearSessionRefPointUsage, o as selectCachedKnownRefPoints, r as incrementRefPointUsage, s as setImportedRefPoints, t as RefPointsState } from "../ref-points-slice-tC-Wd6XJ.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";
-export { AppDispatch, CombinedRootState, DepthPoint, DepthSample, GpsPoint, LatLong, MarkReferencePointPayload, SessionMetadata as OpfsSessionMetadata, RawDeviceOrientation, RawGpsPoint, RecordGpsEventPayload, RecorderState, RecorderStore, RecorderStoreOptions, RecordingOptions, RefPointMark, RefPointsState, RootState, SessionMetadata$1 as SessionMetadata, StorageBackend, add2dImage, calcRelativeCoordsInMeters, clearSessionRefPointUsage, createRecorderStore, endSession, incrementRefPointUsage, markReferencePoint, recordDepthSample, recordGpsEvent, recordWriteFailure, resetRefPointsState, selectCachedKnownRefPoints, setCurrentScenarioName, setImportedRefPoints, setZeroPos, startSession };

package/dist/state/store.js

@@ -1,71 +0,0 @@
-import { endSession, recordDepthSample, recordWriteFailure, recorderReducer, setCurrentScenarioName, startSession } from "./recorder-slice.js";
-import { clearSessionRefPointUsage, incrementRefPointUsage, refPointsReducer, resetRefPointsState, selectCachedKnownRefPoints, setImportedRefPoints } from "./ref-points-slice.js";
-import { routingReducer } from "./routing-slice.js";
-import { OpfsStorageBackend } from "../storage/opfs-storage-backend.js";
-import { createPersistenceMiddleware } from "./persistence-middleware.js";
-import "../licensing/community-license-key.js";
-import { configureStore } from "@reduxjs/toolkit";
-import { add2dImage, arElementsReducer, calcRelativeCoordsInMeters, gpsDataReducer, gpsElementsReducer, markReferencePoint, recordGpsEvent, sanitizeForDevTools, setZeroPos, validateLicenseKey } from "gps-plus-slam-js";
-//#region ../src/state/store.ts
-/**
-* Redux Store for Recorder App
-*
-* Uses Redux Toolkit's configureStore to combine all reducers (library +
-* app-level) into a single store. Action persistence during recording is
-* handled by the persistence middleware.
-*
-* ARCHITECTURE NOTE: See docs/architecture-ar-gps-pose-separation.md
-* The library's recordGpsEvent action captures paired AR+GPS data
-* that feeds directly into the alignment algorithm.
-*
-* Migration note (§4 — architecture-observations-consolidated.md):
-* Previously the store used a manual wrapper pattern with action.type.startsWith()
-* prefix matching to route actions between a library store and local state
-* variables. This has been replaced with a single configureStore call that
-* combines all 6 reducers declaratively.
-*/
-/**
-* Create the recorder store using Redux Toolkit's configureStore.
-*
-* Combines all 6 reducers (3 library: gpsData, gpsElements, arElements;
-* 3 app: recorder, refPoints, routing) into a single store with the
-* persistence middleware for action recording.
-*
-* @param options - Optional configuration including callbacks
-*/
-function createRecorderStore(options = {}) {
-	const { onWriteFailure } = options;
-	const storageBackend = options.storageBackend ?? new OpfsStorageBackend();
-	const enableDevChecks = options.enableDevChecks ?? true;
-	validateLicenseKey(options.licenseKey ?? "eyJ0eXBlIjoiY29tbXVuaXR5IiwiZXhwIjoxODA4NzcyNDI3fQ.YYNf0IdqniZdMzRXCuvewxsQQ01XNywrKsfL5IpiJotfFJfqtrGg4u9z0QFhXeszPtUhnvgC8_oOnbOkbXPuAw");
-	const store = configureStore({
-		reducer: {
-			gpsData: gpsDataReducer,
-			gpsElements: gpsElementsReducer,
-			arElements: arElementsReducer,
-			recorder: recorderReducer,
-			refPoints: refPointsReducer,
-			routing: routingReducer
-		},
-		middleware: (getDefaultMiddleware) => getDefaultMiddleware({
-			serializableCheck: enableDevChecks,
-			immutableCheck: enableDevChecks
-		}).concat(createPersistenceMiddleware({
-			storageBackend,
-			onWriteFailure
-		})),
-		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 { add2dImage, calcRelativeCoordsInMeters, clearSessionRefPointUsage, createRecorderStore, endSession, incrementRefPointUsage, markReferencePoint, recordDepthSample, recordGpsEvent, recordWriteFailure, resetRefPointsState, selectCachedKnownRefPoints, setCurrentScenarioName, setImportedRefPoints, setZeroPos, startSession };

package/dist/storage/ref-point-importer.d.ts

@@ -1,2 +0,0 @@
-import { n as RefPointImportResult, r as importRefPointsFromFolder, t as ImportedRefPoint } from "../ref-point-importer-B_wn5ABk.js";
-export { ImportedRefPoint, RefPointImportResult, importRefPointsFromFolder };

package/dist/storage/ref-point-importer.js

@@ -1,163 +0,0 @@
-import { createLogger } from "../utils/logger.js";
-import { h3RefsMatch, isH3Index } from "../ref-points/h3-ref-point.js";
-import { BlobReader, TextWriter, ZipReader } from "@zip.js/zip.js";
-//#region ../src/storage/ref-point-importer.ts
-/**
-* Reference Point Importer Module
-*
-* Extracts reference points from ZIP files in a folder, enabling reuse of
-* ref points from previous recording sessions.
-*
-* This module:
-* 1. Enumerates all *.zip files in a folder
-* 2. Opens each ZIP and looks for refPoints/*.json files
-* 3. Parses and validates each ref point definition
-* 4. Merges and deduplicates ref points by ID
-*
-* Uses @zip.js/zip.js for ZIP reading (same library as zip-export.ts).
-*/
-const log = createLogger("RefPointImporter");
-/**
-* Check if a file name is a ZIP file (case-insensitive).
-*/
-function isZipFileName(name) {
-	return name.toLowerCase().endsWith(".zip");
-}
-/**
-* Check if a ZIP entry path is a ref point JSON file.
-* Expected path: refPoints/{id}.json
-*/
-function isRefPointEntry(entryPath) {
-	return entryPath.startsWith("refPoints/") && entryPath.endsWith(".json") && entryPath !== "refPoints/";
-}
-/**
-* Type guard to validate parsed JSON matches RefPointDefinition shape.
-* Validates at least one observation exists with required nested properties.
-*/
-function isValidRefPointDefinition(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const obj = value;
-	if (typeof obj.id !== "string" || typeof obj.name !== "string" || typeof obj.createdAt !== "number" || !Array.isArray(obj.observations)) return false;
-	if (obj.observations.length === 0) return true;
-	const firstObs = obj.observations[0];
-	if (typeof firstObs !== "object" || firstObs === null) return false;
-	const gpsPoint = firstObs.gpsPoint;
-	if (typeof gpsPoint !== "object" || gpsPoint === null || typeof gpsPoint.latitude !== "number" || typeof gpsPoint.longitude !== "number") return false;
-	return true;
-}
-/**
-* Convert a RefPointDefinition to an ImportedRefPoint.
-* Extracts GPS coordinates from the first observation.
-*/
-function toImportedRefPoint(def, sourceZipName) {
-	if (def.observations.length === 0) return null;
-	const firstObs = def.observations[0];
-	return {
-		id: def.id,
-		name: def.name,
-		lat: firstObs.gpsPoint.latitude,
-		lon: firstObs.gpsPoint.longitude,
-		alt: firstObs.gpsPoint.altitude,
-		sourceZipName
-	};
-}
-/**
-* Extract reference points from a single ZIP file.
-*
-* @param zipBlob - The ZIP file as a Blob
-* @param zipFileName - Name of the ZIP file (for error messages)
-* @returns Array of imported ref points and any errors
-*/
-async function extractRefPointsFromZip(zipBlob, zipFileName) {
-	const refPoints = [];
-	const errors = [];
-	const zipReader = new ZipReader(new BlobReader(zipBlob));
-	try {
-		const entries = await zipReader.getEntries();
-		for (const entry of entries) {
-			if (entry.directory) continue;
-			if (!isRefPointEntry(entry.filename)) continue;
-			try {
-				const textWriter = new TextWriter();
-				const jsonText = await entry.getData(textWriter);
-				let parsed;
-				try {
-					parsed = JSON.parse(jsonText);
-				} catch (parseErr) {
-					errors.push(`${zipFileName}/${entry.filename}: Invalid JSON - ${parseErr.message}`);
-					continue;
-				}
-				if (!isValidRefPointDefinition(parsed)) {
-					errors.push(`${zipFileName}/${entry.filename}: Invalid ref point schema`);
-					continue;
-				}
-				const imported = toImportedRefPoint(parsed, zipFileName);
-				if (imported) refPoints.push(imported);
-			} catch (entryErr) {
-				errors.push(`${zipFileName}/${entry.filename}: ${entryErr.message}`);
-			}
-		}
-	} finally {
-		await zipReader.close();
-	}
-	return {
-		refPoints,
-		errors
-	};
-}
-/**
-* Import reference points from all ZIP files in a folder.
-*
-* Enumerates all *.zip files in the folder, extracts refPoints/*.json from each,
-* and merges them into a deduplicated list.
-*
-* Deduplication: If the same ref point ID appears in multiple ZIPs, the first
-* occurrence is kept (based on iteration order).
-*
-* @param folderHandle - Read-only directory handle from showDirectoryPicker
-* @returns Result containing merged ref points, scan count, and errors
-*/
-async function importRefPointsFromFolder(folderHandle) {
-	const allRefPoints = [];
-	const seenIds = /* @__PURE__ */ new Set();
-	const allErrors = [];
-	let zipFilesScanned = 0;
-	log.info(`Scanning folder: ${folderHandle.name}`);
-	try {
-		for await (const entry of folderHandle.values()) {
-			if (entry.kind !== "file" || !isZipFileName(entry.name)) continue;
-			log.debug(`Processing ZIP: ${entry.name}`);
-			try {
-				const { refPoints, errors } = await extractRefPointsFromZip(await (await folderHandle.getFileHandle(entry.name)).getFile(), entry.name);
-				zipFilesScanned++;
-				allErrors.push(...errors);
-				for (const refPoint of refPoints) if (!(isH3Index(refPoint.id) ? allRefPoints.some((existing) => isH3Index(existing.id) && h3RefsMatch(existing.id, refPoint.id)) : seenIds.has(refPoint.id))) {
-					seenIds.add(refPoint.id);
-					allRefPoints.push(refPoint);
-				} else log.debug(`Skipping duplicate ref point: ${refPoint.id} from ${entry.name}`);
-			} catch (zipErr) {
-				const errorMsg = `Failed to process ${entry.name}: ${zipErr.message}`;
-				log.warn(errorMsg);
-				allErrors.push(errorMsg);
-			}
-		}
-		log.info(`Imported ${allRefPoints.length} ref points from ${zipFilesScanned} ZIP files`);
-		return {
-			success: true,
-			refPoints: allRefPoints,
-			zipFilesScanned,
-			errors: allErrors
-		};
-	} catch (err) {
-		const errorMsg = `Failed to scan folder: ${err.message}`;
-		log.error(errorMsg);
-		return {
-			success: false,
-			refPoints: allRefPoints,
-			zipFilesScanned,
-			errors: [...allErrors, errorMsg]
-		};
-	}
-}
-//#endregion
-export { importRefPointsFromFolder };

package/dist/storage/ref-point-loader.d.ts

@@ -1,2 +0,0 @@
-import { a as flattenRefPointsToMarks, c as loadRefPoint, i as averageGpsPerRefPoint, l as saveRefPointObservation, n as RefPointMark, o as listRefPointIds, r as RefPointObservation, s as loadAllRefPoints, t as RefPointDefinition, u as writeRefPointDefinition } from "../ref-point-loader-Pt1smgHS.js";
-export { RefPointDefinition, RefPointMark, RefPointObservation, averageGpsPerRefPoint, flattenRefPointsToMarks, listRefPointIds, loadAllRefPoints, loadRefPoint, saveRefPointObservation, writeRefPointDefinition };

package/dist/storage/ref-point-loader.js

@@ -1,248 +0,0 @@
-import { createLogger } from "../utils/logger.js";
-//#region ../src/storage/ref-point-loader.ts
-const log = createLogger("RefPointLoader");
-/**
-* Check if arPose has required position and rotation arrays.
-*/
-function hasValidArPose(o) {
-	if (typeof o.arPose !== "object" || o.arPose === null) return false;
-	const arPose = o.arPose;
-	return Array.isArray(arPose.position) && Array.isArray(arPose.rotation);
-}
-/**
-* Check if gpsPoint has required lat/lon numbers.
-*/
-function hasValidGpsPoint(o) {
-	if (typeof o.gpsPoint !== "object" || o.gpsPoint === null) return false;
-	const gpsPoint = o.gpsPoint;
-	return typeof gpsPoint.latitude === "number" && typeof gpsPoint.longitude === "number";
-}
-/**
-* Type guard to validate a single observation has required nested properties.
-* Prevents runtime errors from accessing arPose.position or gpsPoint.latitude on malformed data.
-*/
-function isValidObservation(obs) {
-	if (typeof obs !== "object" || obs === null) return false;
-	const o = obs;
-	return hasValidArPose(o) && hasValidGpsPoint(o);
-}
-/**
-* Type guard to validate parsed JSON matches RefPointDefinition shape.
-* Prevents runtime errors from malformed or corrupted JSON files.
-* Also validates each observation to ensure nested properties exist.
-*/
-function isRefPointDefinition(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const obj = value;
-	if (typeof obj.id !== "string" || typeof obj.name !== "string" || typeof obj.createdAt !== "number" || !Array.isArray(obj.observations)) return false;
-	return obj.observations.every(isValidObservation);
-}
-/**
-* Parse a single reference point file and validate its schema.
-* Returns null if parsing fails or schema is invalid.
-*/
-async function parseRefPointFile(fileHandle, fileName) {
-	try {
-		const text = await (await fileHandle.getFile()).text();
-		const parsed = JSON.parse(text);
-		if (isRefPointDefinition(parsed)) return parsed;
-		log.warn(`Invalid schema in ${fileName}`);
-		return null;
-	} catch (parseErr) {
-		log.error(`Failed to parse ${fileName}:`, parseErr);
-		return null;
-	}
-}
-/**
-* Load all reference point definitions from the scenario's refPoints/ directory.
-*
-* @param scenarioHandle - File system handle for the scenario folder
-* @returns Array of all reference point definitions
-*/
-async function loadAllRefPoints(scenarioHandle) {
-	try {
-		const refPointsHandle = await scenarioHandle.getDirectoryHandle("refPoints");
-		const refPoints = [];
-		for await (const [name, handle] of refPointsHandle.entries()) {
-			if (handle.kind !== "file" || !name.endsWith(".json")) continue;
-			const parsed = await parseRefPointFile(handle, name);
-			if (parsed) refPoints.push(parsed);
-		}
-		return refPoints;
-	} catch (err) {
-		log.debug("No refPoints directory found (yet):", err);
-		return [];
-	}
-}
-/**
-* Load a specific reference point by ID.
-*
-* @param scenarioHandle - File system handle for the scenario folder
-* @param pointId - Reference point ID
-* @returns Reference point definition or null if not found
-*/
-async function loadRefPoint(scenarioHandle, pointId) {
-	try {
-		const text = await (await (await (await scenarioHandle.getDirectoryHandle("refPoints")).getFileHandle(`${pointId}.json`)).getFile()).text();
-		const parsed = JSON.parse(text);
-		if (!isRefPointDefinition(parsed)) {
-			log.warn(`Invalid schema for ${pointId}`);
-			return null;
-		}
-		return parsed;
-	} catch (err) {
-		log.debug(`Reference point ${pointId} not found:`, err);
-		return null;
-	}
-}
-/**
-* Save or update a reference point observation.
-* Creates the refPoints/ directory if it doesn't exist.
-* If the reference point exists, appends the new observation.
-* If it doesn't exist, creates a new reference point file.
-*
-* @param scenarioHandle - File system handle for the scenario folder
-* @param pointId - Reference point ID
-* @param pointName - Human-readable name for the reference point
-* @param observation - New observation to add
-*/
-async function saveRefPointObservation(scenarioHandle, pointId, pointName, observation) {
-	try {
-		const refPointsHandle = await scenarioHandle.getDirectoryHandle("refPoints", { create: true });
-		const existing = await loadRefPoint(scenarioHandle, pointId);
-		const definition = existing ? {
-			...existing,
-			observations: [...existing.observations, observation]
-		} : {
-			id: pointId,
-			name: pointName,
-			createdAt: observation.timestamp,
-			observations: [observation]
-		};
-		const writable = await (await refPointsHandle.getFileHandle(`${pointId}.json`, { create: true })).createWritable();
-		let writeError = null;
-		try {
-			await writable.write(JSON.stringify(definition, null, 2));
-			await writable.close();
-		} catch (error) {
-			writeError = error;
-		} finally {
-			if (writeError !== null) try {
-				await writable.abort();
-			} catch {}
-		}
-		if (writeError !== null) {
-			if (writeError instanceof Error) throw writeError;
-			throw new Error("OPFS write failed");
-		}
-		log.info(`Saved observation for ${pointId} (${definition.observations.length} total observations)`);
-	} catch (err) {
-		log.error(`Failed to save reference point ${pointId}:`, err);
-		throw err;
-	}
-}
-/**
-* Write a complete RefPointDefinition to OPFS.
-* Creates the refPoints/ directory if it doesn't exist.
-* Used by the recovery flow to restore definitions extracted from ZIPs.
-*
-* @param scenarioHandle - File system handle for the scenario folder
-* @param definition - Complete ref point definition to write
-*/
-async function writeRefPointDefinition(scenarioHandle, definition) {
-	const writable = await (await (await scenarioHandle.getDirectoryHandle("refPoints", { create: true })).getFileHandle(`${definition.id}.json`, { create: true })).createWritable();
-	let writeError = null;
-	try {
-		await writable.write(JSON.stringify(definition, null, 2));
-		await writable.close();
-	} catch (error) {
-		writeError = error;
-	} finally {
-		if (writeError !== null) try {
-			await writable.abort();
-		} catch {}
-	}
-	if (writeError !== null) {
-		if (writeError instanceof Error) throw writeError;
-		throw new Error("OPFS write failed");
-	}
-}
-/**
-* Get list of all reference point IDs in the scenario.
-* Useful for autocomplete/suggestions.
-*
-* @param scenarioHandle - File system handle for the scenario folder
-* @returns Array of reference point IDs
-*/
-async function listRefPointIds(scenarioHandle) {
-	try {
-		const refPointsHandle = await scenarioHandle.getDirectoryHandle("refPoints");
-		const ids = [];
-		for await (const [name, handle] of refPointsHandle.entries()) if (handle.kind === "file" && name.endsWith(".json")) ids.push(name.slice(0, -5));
-		return ids.sort();
-	} catch (err) {
-		log.debug("No refPoints directory found (yet):", err);
-		return [];
-	}
-}
-/**
-* Flatten an array of RefPointDefinition objects into individual RefPointMark
-* observations suitable for visualization.
-*
-* @param refPointDefs - Array of reference point definitions with observations
-* @returns Flat array of individual marks (one per observation)
-*/
-function flattenRefPointsToMarks(refPointDefs) {
-	return refPointDefs.flatMap((def) => def.observations.map((obs) => {
-		const src = obs.fusedGpsPoint ?? obs.gpsPoint;
-		const gpsPosition = {
-			lat: src.latitude,
-			lon: src.longitude,
-			altitude: src.altitude
-		};
-		return {
-			id: def.id,
-			odomPosition: obs.arPose.position,
-			odomRotation: obs.arPose.rotation,
-			gpsPosition,
-			timestamp: obs.timestamp
-		};
-	}));
-}
-/**
-* Compute one averaged GPS position per reference point ID.
-* For each observation, prefers `fusedGpsPoint` (sub-meter accuracy) when
-* available, falling back to raw `gpsPoint`. Returns the centroid (mean
-* lat/lon) across all observations.
-*/
-function averageGpsPerRefPoint(refPointDefs) {
-	return refPointDefs.filter((def) => def.observations.length > 0).map((def) => {
-		const coords = def.observations.map((obs) => {
-			if (obs.fusedGpsPoint) return {
-				lat: obs.fusedGpsPoint.latitude,
-				lon: obs.fusedGpsPoint.longitude,
-				alt: obs.fusedGpsPoint.altitude
-			};
-			if (typeof obs.gpsPoint.latitude === "number" && typeof obs.gpsPoint.longitude === "number") return {
-				lat: obs.gpsPoint.latitude,
-				lon: obs.gpsPoint.longitude,
-				alt: obs.gpsPoint.altitude
-			};
-			return null;
-		}).filter((c) => c !== null);
-		if (coords.length === 0) return null;
-		const avgLat = coords.reduce((s, c) => s + c.lat, 0) / coords.length;
-		const avgLon = coords.reduce((s, c) => s + c.lon, 0) / coords.length;
-		const alts = coords.filter((c) => c.alt != null);
-		const avgAlt = alts.length > 0 ? alts.reduce((s, c) => s + c.alt, 0) / alts.length : void 0;
-		return {
-			id: def.id,
-			name: def.name,
-			lat: avgLat,
-			lon: avgLon,
-			alt: avgAlt
-		};
-	}).filter((r) => r !== null);
-}
-//#endregion
-export { averageGpsPerRefPoint, flattenRefPointsToMarks, listRefPointIds, loadAllRefPoints, loadRefPoint, saveRefPointObservation, writeRefPointDefinition };