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

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

@@ -1,62 +0,0 @@
-//#region ../src/storage/ref-point-importer.d.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).
- */
-/**
- * Simplified reference point for import/suggestion purposes.
- * Contains only the essential data needed for ref point suggestions and display.
- * The `lat`/`lon` are kept for "nearby ref point" proximity suggestions.
- */
-interface ImportedRefPoint {
-  /** Unique identifier — H3 hex index since the March 2026 H3 migration */
-  readonly id: string;
-  /** Human-readable display name entered by the user (e.g., "Bench Corner") */
-  readonly name: string;
-  /** Latitude from first observation (for future proximity-based suggestions) */
-  readonly lat: number;
-  /** Longitude from first observation */
-  readonly lon: number;
-  /** Optional altitude */
-  readonly alt?: number;
-  /** Source ZIP file name for debugging/tracking */
-  readonly sourceZipName: string;
-}
-/**
- * Result from importing reference points from a folder.
- */
-interface RefPointImportResult {
-  /** Whether the import completed (even with some errors) */
-  readonly success: boolean;
-  /** Merged, deduplicated reference points from all ZIPs */
-  readonly refPoints: ImportedRefPoint[];
-  /** Number of ZIP files successfully scanned */
-  readonly zipFilesScanned: number;
-  /** Error messages from failed ZIPs or malformed ref points */
-  readonly errors: string[];
-}
-/**
- * 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
- */
-declare function importRefPointsFromFolder(folderHandle: FileSystemDirectoryHandle): Promise<RefPointImportResult>;
-//#endregion
-export { RefPointImportResult as n, importRefPointsFromFolder as r, ImportedRefPoint as t };

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

@@ -1,117 +0,0 @@
-import { n as ArPoseTuples } from "./ar-types-B-ORgk6Z.js";
-import { GpsPoint, LatLongAlt, Quaternion, Vector3 } from "gps-plus-slam-js";
-
-//#region ../src/storage/ref-point-loader.d.ts
-/**
- * A single observation of a reference point in one session.
- */
-interface RefPointObservation {
-  /** Session ID (e.g., "recording-2025-02-28_14-30-11utc") */
-  readonly sessionId: string;
-  /** When this observation was made */
-  readonly timestamp: number;
-  /** AR pose at the moment of marking */
-  readonly arPose: ArPoseTuples;
-  /** Full GPS point from library (includes lat/lon, accuracy, etc.) */
-  readonly gpsPoint: GpsPoint;
-  /** Fused GPS from aligned VIO path at mark time (absent in legacy data) */
-  readonly fusedGpsPoint?: {
-    latitude: number;
-    longitude: number;
-    altitude?: number;
-  };
-}
-/**
- * Complete definition of a reference point with all observations.
- */
-interface RefPointDefinition {
-  /** Unique identifier (e.g., "pointA", "benchCorner") */
-  id: string;
-  /** Human-readable name */
-  name: string;
-  /** Timestamp of first observation */
-  createdAt: number;
-  /** All observations across sessions */
-  observations: RefPointObservation[];
-}
-/**
- * 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
- */
-declare function loadAllRefPoints(scenarioHandle: FileSystemDirectoryHandle): Promise<RefPointDefinition[]>;
-/**
- * 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
- */
-declare function loadRefPoint(scenarioHandle: FileSystemDirectoryHandle, pointId: string): Promise<RefPointDefinition | 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
- */
-declare function saveRefPointObservation(scenarioHandle: FileSystemDirectoryHandle, pointId: string, pointName: string, observation: RefPointObservation): Promise<void>;
-/**
- * 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
- */
-declare function writeRefPointDefinition(scenarioHandle: FileSystemDirectoryHandle, definition: RefPointDefinition): Promise<void>;
-/**
- * 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
- */
-declare function listRefPointIds(scenarioHandle: FileSystemDirectoryHandle): Promise<string[]>;
-/**
- * Marker type representing a single observation suitable for visualization.
- * Position/rotation use odometry frame; gpsPosition provides world coordinates.
- */
-interface RefPointMark {
-  id: string;
-  /** Odometry position at the moment of marking */
-  odomPosition: Vector3;
-  /** Odometry rotation at the moment of marking */
-  odomRotation: Quaternion;
-  /** GPS position if available */
-  gpsPosition?: LatLongAlt;
-  timestamp: number;
-}
-/**
- * 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)
- */
-declare function flattenRefPointsToMarks(refPointDefs: RefPointDefinition[]): RefPointMark[];
-/**
- * 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.
- */
-declare function averageGpsPerRefPoint(refPointDefs: RefPointDefinition[]): Array<{
-  id: string;
-  name: string;
-  lat: number;
-  lon: number;
-  alt?: number;
-}>;
-//#endregion
-export { flattenRefPointsToMarks as a, loadRefPoint as c, averageGpsPerRefPoint as i, saveRefPointObservation as l, RefPointMark as n, listRefPointIds as o, RefPointObservation as r, loadAllRefPoints as s, RefPointDefinition as t, writeRefPointDefinition as u };

package/dist/ref-points/h3-ref-point.d.ts

@@ -1,2 +0,0 @@
-import { a as gpsToH3, i as findNearbyRefPoint, n as KnownRefPoint, o as h3RefsMatch, r as approxDistanceMetres, s as isH3Index, t as H3_RESOLUTION } from "../h3-ref-point-CFhayNSZ.js";
-export { H3_RESOLUTION, KnownRefPoint, approxDistanceMetres, findNearbyRefPoint, gpsToH3, h3RefsMatch, isH3Index };

package/dist/ref-points/index.d.ts

@@ -1,2 +0,0 @@
-import { a as gpsToH3, i as findNearbyRefPoint, n as KnownRefPoint, o as h3RefsMatch, r as approxDistanceMetres, s as isH3Index, t as H3_RESOLUTION } from "../h3-ref-point-CFhayNSZ.js";
-export { H3_RESOLUTION, type KnownRefPoint, approxDistanceMetres, findNearbyRefPoint, gpsToH3, h3RefsMatch, isH3Index };

package/dist/ref-points/index.js

@@ -1,2 +0,0 @@
-import { H3_RESOLUTION, approxDistanceMetres, findNearbyRefPoint, gpsToH3, h3RefsMatch, isH3Index } from "./h3-ref-point.js";
-export { H3_RESOLUTION, approxDistanceMetres, findNearbyRefPoint, gpsToH3, h3RefsMatch, isH3Index };

package/dist/ref-points-slice-tC-Wd6XJ.d.ts

@@ -1,48 +0,0 @@
-import { n as KnownRefPoint } from "./h3-ref-point-CFhayNSZ.js";
-import { t as ImportedRefPoint } from "./ref-point-importer-B_wn5ABk.js";
-import * as _$_reduxjs_toolkit0 from "@reduxjs/toolkit";
-
-//#region ../src/state/ref-points-slice.d.ts
-interface RefPointsState {
-  /** Prior ref points loaded from previous session ZIPs. */
-  importedRefPoints: ImportedRefPoint[];
-  /**
-   * Tracks how many times each ref point was marked in the current session.
-   * Keyed by ref-point ID (H3 index). Plain object for Redux serializability
-   * (replaces the Map<string, number> that lived in the closure).
-   */
-  sessionRefPointUsage: Record<string, number>;
-}
-declare const setImportedRefPoints: _$_reduxjs_toolkit0.ActionCreatorWithPayload<ImportedRefPoint[], "refPoints/setImportedRefPoints">, incrementRefPointUsage: _$_reduxjs_toolkit0.ActionCreatorWithPayload<string, "refPoints/incrementRefPointUsage">, clearSessionRefPointUsage: _$_reduxjs_toolkit0.ActionCreatorWithoutPayload<"refPoints/clearSessionRefPointUsage">, resetRefPointsState: _$_reduxjs_toolkit0.ActionCreatorWithoutPayload<"refPoints/resetRefPointsState">;
-declare const refPointsReducer: _$_reduxjs_toolkit0.Reducer<RefPointsState>;
-/**
- * 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.
- */
-declare const selectCachedKnownRefPoints: ((state: RefPointsState) => KnownRefPoint[]) & {
-  clearCache: () => void;
-  resultsCount: () => number;
-  resetResultsCount: () => void;
-} & {
-  resultFunc: (resultFuncArgs_0: ImportedRefPoint[]) => KnownRefPoint[];
-  memoizedResultFunc: ((resultFuncArgs_0: ImportedRefPoint[]) => KnownRefPoint[]) & {
-    clearCache: () => void;
-    resultsCount: () => number;
-    resetResultsCount: () => void;
-  };
-  lastResult: () => KnownRefPoint[];
-  dependencies: [(state: RefPointsState) => ImportedRefPoint[]];
-  recomputations: () => number;
-  resetRecomputations: () => void;
-  dependencyRecomputations: () => number;
-  resetDependencyRecomputations: () => void;
-} & {
-  memoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
-  argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
-};
-//#endregion
-export { resetRefPointsState as a, refPointsReducer as i, clearSessionRefPointUsage as n, selectCachedKnownRefPoints as o, incrementRefPointUsage as r, setImportedRefPoints as s, RefPointsState as t };

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 };