gps-plus-slam-app-framework 1.0.0

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

@@ -0,0 +1,62 @@
+//#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

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

@@ -0,0 +1,2 @@
+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/h3-ref-point.js

@@ -0,0 +1,74 @@
+import { gridDisk, latLngToCell } from "h3-js";
+//#region ../src/ref-points/h3-ref-point.ts
+/**
+* H3 Reference Point Matching
+*
+* Utility for matching GPS positions to known reference points using
+* H3 hexagonal grid indices. Uses gridDisk(cell, 1) to create a ~65m
+* safe zone that absorbs GPS jitter of 3-10m.
+*
+* @see docs/2026-03-08-ref-point-naming-investigation.md §6
+*/
+/** H3 resolution 11: ~25m edge, ~65m gridDisk safe zone */
+const H3_RESOLUTION = 11;
+/**
+* Compute the H3 resolution-11 index for a GPS position.
+*/
+function gpsToH3(lat, lng) {
+	return latLngToCell(lat, lng, 11);
+}
+/**
+* Approximate distance in metres using equirectangular projection.
+* Accurate to < 0.1% for distances under 1 km at mid-latitudes,
+* which is sufficient for ranking ref point candidates within a
+* gridDisk safe zone (~65–130 m).
+*/
+function approxDistanceMetres(lat1, lon1, lat2, lon2) {
+	const R = 6371e3;
+	const dLat = (lat2 - lat1) * Math.PI / 180;
+	let dLonDeg = lon2 - lon1;
+	dLonDeg -= 360 * Math.floor((dLonDeg + 180) / 360);
+	const x = dLonDeg * Math.PI / 180 * Math.cos((lat1 + lat2) / 2 * Math.PI / 180);
+	return R * Math.sqrt(dLat * dLat + x * x);
+}
+/**
+* Find the known reference point closest to the given GPS position,
+* provided it falls within the gridDisk safe zone.
+*
+* The safe zone is the center cell plus its 6 neighbors (~65m radius),
+* which absorbs GPS jitter of 3-10m while keeping ref points >130m apart
+* distinguishable.
+*
+* When multiple ref points have overlapping safe zones (65–130 m apart),
+* the closest one by equirectangular distance is returned.
+*/
+function findNearbyRefPoint(lat, lng, knownRefPoints) {
+	if (knownRefPoints.length === 0) return;
+	const safeZone = gridDisk(latLngToCell(lat, lng, 11), 1);
+	const candidates = knownRefPoints.filter((rp) => safeZone.includes(rp.h3Index));
+	if (candidates.length === 0) return void 0;
+	if (candidates.length === 1) return candidates[0];
+	return candidates.reduce((closest, rp) => {
+		return approxDistanceMetres(lat, lng, rp.lat, rp.lon) < approxDistanceMetres(lat, lng, closest.lat, closest.lon) ? rp : closest;
+	});
+}
+/**
+* Check whether two H3 indices refer to the same physical location
+* (i.e., one falls within the other's gridDisk safe zone).
+* This is the canonical cross-session matching check.
+*/
+function h3RefsMatch(h3a, h3b) {
+	if (h3a === h3b) return true;
+	return gridDisk(h3a, 1).includes(h3b);
+}
+/** H3 resolution-11 indices are 15-character lowercase hex strings. */
+const H3_INDEX_PATTERN = /^[0-9a-f]{15}$/;
+/**
+* Check whether a string looks like a valid H3 resolution-11 index.
+* Used to distinguish H3 IDs from legacy user-typed string IDs.
+*/
+function isH3Index(id) {
+	return H3_INDEX_PATTERN.test(id);
+}
+//#endregion
+export { H3_RESOLUTION, approxDistanceMetres, findNearbyRefPoint, gpsToH3, h3RefsMatch, isH3Index };

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

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

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

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

@@ -0,0 +1,68 @@
+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/replay-engine-DuX316ae.d.ts

@@ -0,0 +1,103 @@
+import { l as RecorderStore } from "./store-C7PKOj8S.js";
+
+//#region ../src/state/replay-engine.d.ts
+/** Default maximum delay between actions in ms (30 seconds real-time) */
+declare const DEFAULT_MAX_DELAY_MS = 30000;
+type ReplayState = 'idle' | 'playing' | 'paused' | 'completed';
+type ProgressCallback = (current: number, total: number) => void;
+type CompleteCallback = () => void;
+type ErrorCallback = (actionIndex: number, error: Error) => void;
+/** Minimal action shape for replay — just needs type and optional payload */
+interface ReplayAction {
+  type: string;
+  payload?: unknown;
+}
+/**
+ * Extract an absolute epoch-ms timestamp from a Redux action, or null
+ * if the action type doesn't carry one.
+ *
+ * IMPORTANT: depthSample uses performance.now() (relative to page load),
+ * NOT epoch ms. Returning it here would mix clock domains and produce
+ * garbage delays. It must return null. (Risk R4)
+ *
+ * @param action - A Redux action with type and optional payload
+ * @returns Epoch milliseconds, or null if unavailable/unreliable
+ */
+declare function extractActionTimestamp(action: ReplayAction): number | null;
+/**
+ * Compute the delay in ms between two consecutive actions for replay.
+ *
+ * @param currentTs - Epoch ms of the current (just-dispatched) action, or null
+ * @param nextTs - Epoch ms of the next action, or null
+ * @param speedFactor - Playback speed multiplier (1 = real-time)
+ * @param maxDelay - Maximum delay in ms (default: DEFAULT_MAX_DELAY_MS)
+ * @returns Delay in ms, clamped to [0, maxDelay]
+ */
+declare function computeInterActionDelay(currentTs: number | null, nextTs: number | null, speedFactor: number, maxDelay?: number): number;
+/**
+ * Async controller that dispatches recorded actions with timed delays.
+ *
+ * Uses AbortController for pause/cancel:
+ * - play() starts the async loop
+ * - pause() aborts the current controller → loop exits
+ * - resume() creates a new controller and restarts from current index
+ * - setSpeed() updates a closure variable, picked up on next delay calc
+ * - dispose() stops everything and resets state
+ */
+declare class ReplayEngine {
+  private state;
+  private currentIndex;
+  private actions;
+  private store;
+  private speedFactor;
+  private abortController;
+  private progressCallbacks;
+  private completeCallbacks;
+  private errorCallbacks;
+  private currentPlayPromise;
+  /** Get the current engine state */
+  getState(): ReplayState;
+  /** Get the current action index (1-based after dispatch, 0 before play) */
+  getCurrentActionIndex(): number;
+  /** Register a progress callback: (currentIndex, totalCount) */
+  onProgress(callback: ProgressCallback): void;
+  /** Register a completion callback */
+  onComplete(callback: CompleteCallback): void;
+  /**
+   * Register an error callback: (actionIndex, error).
+   * Called when a dispatch throws. Replay continues past the error.
+   * After MAX_CONSECUTIVE_ERRORS consecutive failures, engine auto-pauses (R7).
+   */
+  onError(callback: ErrorCallback): void;
+  /** Update playback speed (takes effect on next delay calculation) */
+  setSpeed(factor: number): void;
+  /**
+   * Start replaying actions with timed delays.
+   *
+   * @param actions - Array of Redux actions to dispatch
+   * @param store - RecorderStore to dispatch into
+   * @param speedFactor - Initial playback speed (1 = real-time)
+   * @returns Promise that resolves when replay completes or is paused
+   */
+  play(actions: ReplayAction[], store: RecorderStore, speedFactor: number): Promise<void>;
+  /** Pause the replay. Can be resumed later with resume(). */
+  pause(): void;
+  /**
+   * Resume from the current action index after a pause.
+   * @returns Promise that resolves when replay completes or is paused again
+   */
+  resume(): Promise<void>;
+  /** Stop playback and reset to idle. */
+  dispose(): void;
+  private runLoop;
+  /**
+   * Promise-based delay that resolves on timeout or rejects on abort.
+   * Returns true if aborted, false if delay completed normally.
+   */
+  private abortableDelay;
+  private notifyProgress;
+  private notifyComplete;
+  private notifyError;
+}
+//#endregion
+export { ReplayAction as a, computeInterActionDelay as c, ProgressCallback as i, extractActionTimestamp as l, DEFAULT_MAX_DELAY_MS as n, ReplayEngine as o, ErrorCallback as r, ReplayState as s, CompleteCallback as t };

package/dist/replay-scene-DtUm6bsr.d.ts

@@ -0,0 +1,109 @@
+import { t as CameraFollower } from "./camera-follower-BMqPddxx.js";
+import { t as AlignmentLerper } from "./alignment-lerper-D9BeDwZX.js";
+import { t as Css3dRendererManager } from "./css3d-renderer-manager-rgLMVAvd.js";
+import * as THREE from "three";
+import { OrbitControls } from "three/addons/controls/OrbitControls.js";
+
+//#region ../src/ar/replay-scene.d.ts
+type CameraMode = 'orbit' | 'fps';
+interface ReplaySceneState {
+  scene: THREE.Scene;
+  arWorldGroup: THREE.Group;
+  camera: THREE.PerspectiveCamera;
+  renderer: THREE.WebGLRenderer;
+  orbitControls: OrbitControls;
+  cameraMode: CameraMode;
+  rAFId: number;
+  container: HTMLElement;
+  cameraFollower: CameraFollower;
+  alignmentLerper: AlignmentLerper;
+  css3dManager: Css3dRendererManager;
+}
+/**
+ * Initialize the replay scene with a standard Three.js renderer.
+ *
+ * - Creates the scene hierarchy via createSceneHierarchy()
+ * - Reparents camera from arWorldGroup to scene root (Risk R5)
+ * - Creates a WebGLRenderer WITHOUT WebXR
+ * - Registers scene with module-global getters (Risk R1)
+ * - Inserts canvas into the provided container
+ * - Starts a requestAnimationFrame render loop
+ * - Sets up OrbitControls as default camera mode
+ *
+ * @param container - DOM element to insert the canvas into
+ * @returns Scene state object for downstream use
+ * @throws If already initialized (call disposeReplayScene first)
+ */
+declare function initReplayScene(container: HTMLElement): {
+  scene: THREE.Scene;
+  arWorldGroup: THREE.Group;
+  camera: THREE.PerspectiveCamera;
+  renderer: THREE.WebGLRenderer;
+};
+/**
+ * Dispose the replay scene, cleaning up all resources.
+ *
+ * - Cancels the rAF render loop
+ * - Disposes renderer (frees GPU resources)
+ * - Disposes camera controls
+ * - Removes canvas from DOM
+ * - Clears module-global scene references
+ *
+ * Safe to call multiple times (idempotent).
+ */
+declare function disposeReplayScene(): void;
+/**
+ * Get the current replay scene state, or null if not initialized.
+ */
+declare function getReplayState(): ReplaySceneState | null;
+/**
+ * Update the OrbitControls target position and translate the camera
+ * by the same delta so the orbit viewing relationship is preserved.
+ *
+ * OrbitControls.update() does NOT automatically move the camera when
+ * the target changes — it recomputes offset = camera.position - target
+ * each frame, which is a no-op without user input. Without explicit
+ * camera translation, the camera would sit still while the trajectory
+ * moves away. Moving the camera by the target delta keeps the viewing
+ * angle and distance constant as the trajectory progresses.
+ *
+ * Call this as new odom poses are replayed so the orbit camera
+ * auto-follows the recorded trajectory.
+ *
+ * No-op if not initialized.
+ */
+declare function updateOrbitTarget(position: THREE.Vector3): void;
+/**
+ * Get the current camera control mode.
+ * Returns 'orbit' if not initialized.
+ */
+declare function getCameraMode(): CameraMode;
+/**
+ * Get the camera follower's Object3D, or null if the replay scene
+ * is not initialized. Use this to attach children (e.g., map mesh)
+ * that should track the camera's position but stay GPS-aligned.
+ */
+declare function getCameraFollower(): THREE.Object3D | null;
+/**
+ * Get the alignment lerper, or null if not initialized.
+ * Used by replay-mode to route store-subscriber alignment updates
+ * through the lerper instead of applying them directly.
+ */
+declare function getAlignmentLerper(): AlignmentLerper | null;
+/**
+ * Get the CSS3D renderer manager, or null if not initialized.
+ * Used for external resize handling or to verify the CSS3D layer exists.
+ */
+declare function getCss3dManager(): Css3dRendererManager | null;
+/**
+ * Toggle between orbit and FPS camera modes.
+ *
+ * - orbit → fps: Disables OrbitControls, creates and enables
+ *   PointerLockControls + WASD keyboard handler
+ * - fps → orbit: Disables PointerLockControls, re-enables OrbitControls
+ *
+ * No-op if not initialized.
+ */
+declare function toggleCameraMode(): void;
+//#endregion
+export { getCameraFollower as a, getReplayState as c, updateOrbitTarget as d, getAlignmentLerper as i, initReplayScene as l, ReplaySceneState as n, getCameraMode as o, disposeReplayScene as r, getCss3dManager as s, CameraMode as t, toggleCameraMode as u };

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

@@ -0,0 +1,23 @@
+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/scene-node-names-DPsaE2z3.d.ts

@@ -0,0 +1,14 @@
+//#region ../src/ar/scene-node-names.d.ts
+/**
+ * Scene-graph node name constants.
+ *
+ * Used in .name assignments and getObjectByName() lookups.
+ * Centralised here (R4) so a rename is a single-point change
+ * with compile-time safety instead of grep-and-replace.
+ */
+declare const SCENE_NODE: {
+  /** Basis-change node (WebXR → NUE coordinate system) */readonly BASIS_CHANGE: "webxr-to-nue"; /** Camera follower node (GPS-world-aligned, tracks camera position) */
+  readonly CAMERA_FOLLOWER: "camera-follower";
+};
+//#endregion
+export { SCENE_NODE as t };

package/dist/sensors/gps-error-handler.d.ts

@@ -0,0 +1,2 @@
+import { a as getGpsErrorMessage, i as createGpsErrorHandler, n as GPS_ERROR_MESSAGES, r as GPS_ERROR_MESSAGE_UNKNOWN, t as GPS_ERROR_CODES } from "../gps-error-handler-VPuNOuf8.js";
+export { GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, createGpsErrorHandler, getGpsErrorMessage };