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

package/dist/{app-selectors-DyMzxCEC.d.ts → app-selectors-CHt7DLuq.d.ts}

@@ -1,11 +1,12 @@
-import { n as CombinedRootState } from "./store-C7PKOj8S.js";
-import * as _$_reduxjs_toolkit0 from "@reduxjs/toolkit";
+import { r as SlamAppRootState } from "./create-slam-app-store-DBm7g2Zd.js";
+import { t as CombinedRootState } from "./combined-root-state-B3SvPNjU.js";
 import * as _$gps_plus_slam_js0 from "gps-plus-slam-js";
 import { GpsPoint, LatLong, Matrix4, Quaternion, ReferencePoint, Vector3 } from "gps-plus-slam-js";
+import * as _$_reduxjs_toolkit0 from "@reduxjs/toolkit";
 
 //#region ../src/state/app-selectors.d.ts
 /** Alignment matrix (4×4), or null if not yet computed. */
-declare const selectAlignmentMatrix: ((state: CombinedRootState) => Matrix4 | null) & {
+declare const selectAlignmentMatrix: ((state: SlamAppRootState & {}) => Matrix4 | null) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -27,7 +28,7 @@ declare const selectAlignmentMatrix: ((state: CombinedRootState) => Matrix4 | nu
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
 /** Recorded GPS positions with metadata. */
-declare const selectGpsPositions: ((state: CombinedRootState) => readonly GpsPoint[]) & {
+declare const selectGpsPositions: ((state: SlamAppRootState & {}) => readonly GpsPoint[]) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -49,7 +50,7 @@ declare const selectGpsPositions: ((state: CombinedRootState) => readonly GpsPoi
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
 /** Recorded odometry positions (AR-local space). */
-declare const selectOdometryPositions: ((state: CombinedRootState) => readonly Vector3[]) & {
+declare const selectOdometryPositions: ((state: SlamAppRootState & {}) => readonly Vector3[]) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -71,7 +72,7 @@ declare const selectOdometryPositions: ((state: CombinedRootState) => readonly V
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
 /** Recorded odometry rotations (AR-local space). */
-declare const selectOdometryRotations: ((state: CombinedRootState) => readonly Quaternion[]) & {
+declare const selectOdometryRotations: ((state: SlamAppRootState & {}) => readonly Quaternion[]) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -93,7 +94,7 @@ declare const selectOdometryRotations: ((state: CombinedRootState) => readonly Q
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
 /** GPS zero reference (origin for coordinate conversion), or null. */
-declare const selectZeroReference: ((state: CombinedRootState) => LatLong | null) & {
+declare const selectZeroReference: ((state: SlamAppRootState & {}) => LatLong | null) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -115,7 +116,7 @@ declare const selectZeroReference: ((state: CombinedRootState) => LatLong | null
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
 /** User-defined reference points for ground truth validation. */
-declare const selectReferencePoints: ((state: CombinedRootState) => readonly ReferencePoint[]) & {
+declare const selectReferencePoints: ((state: SlamAppRootState & {}) => readonly ReferencePoint[]) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;

package/dist/ar/depth-sampler.js

@@ -1,4 +1,4 @@
-import { extractOdomPosition } from "../state/recording-coordinator.js";
+import { extractOdomPosition } from "../state/gps-event-coordinator.js";
 //#region ../src/ar/depth-sampler.ts
 const DEFAULT_CONFIG = {
 	intervalMs: 1e3,

package/dist/ar/tracking-state.js

@@ -1,5 +1,5 @@
 import { createLogger } from "../utils/logger.js";
-import { extractOdomPosition } from "../state/recording-coordinator.js";
+import { extractOdomPosition } from "../state/gps-event-coordinator.js";
 //#region ../src/ar/tracking-state.ts
 /**
 * Tracking State Manager

package/dist/ar/webxr-session.js

@@ -1,6 +1,6 @@
 import { createLogger } from "../utils/logger.js";
 import { CameraBlitCapture, computeCaptureSize } from "./camera-blit-capture.js";
-import { getLastDeviceOrientation } from "../state/recording-coordinator.js";
+import { getLastDeviceOrientation } from "../state/gps-event-coordinator.js";
 import { DepthSampler } from "./depth-sampler.js";
 import { DEFAULT_CAPTURE_CONFIG, ImageCaptureManager } from "./image-capture.js";
 import { TrackingStateManager } from "./tracking-state.js";

package/dist/combined-root-state-B3SvPNjU.d.ts

@@ -0,0 +1,6 @@
+import { t as SlamAppCombinedState } from "./create-slam-app-store-DBm7g2Zd.js";
+
+//#region ../src/state/combined-root-state.d.ts
+type CombinedRootState = SlamAppCombinedState;
+//#endregion
+export { CombinedRootState as t };

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+import { GpsPoint, LatLong, LatLongAlt, Matrix4, Quaternion, RootState, RootState as LibraryRootState, Vector3, calcGpsCoords, createGpsSlamStore, isIdentityMatrix4, odometryTrackingRestarted, validateLicenseKey, webxrToNUE } from "gps-plus-slam-js";
+export { type GpsPoint, type LatLong, type LatLongAlt, type LibraryRootState, type Matrix4, type Quaternion, type RootState, type Vector3, calcGpsCoords, createGpsSlamStore, isIdentityMatrix4, odometryTrackingRestarted, validateLicenseKey, webxrToNUE };

package/dist/core/index.js

@@ -0,0 +1,2 @@
+import { calcGpsCoords, createGpsSlamStore, isIdentityMatrix4, odometryTrackingRestarted, validateLicenseKey, webxrToNUE } from "gps-plus-slam-js";
+export { calcGpsCoords, createGpsSlamStore, isIdentityMatrix4, odometryTrackingRestarted, validateLicenseKey, webxrToNUE };

package/dist/create-slam-app-store-DBm7g2Zd.d.ts

@@ -0,0 +1,85 @@
+import { t as RecordingState } from "./recording-slice-BiktUIWF.js";
+import { n as SessionMetadata } from "./opfs-storage-Dlq1I_Gb.js";
+import { n as StorageBackend } from "./storage-backend-yVnuWGTr.js";
+import { RootState } from "gps-plus-slam-js";
+import { Middleware, Reducer, ReducersMapObject, configureStore } from "@reduxjs/toolkit";
+
+//#region ../src/state/create-slam-app-store.d.ts
+/**
+ * Base shape produced by `createSlamAppStore` with no `extraReducers`.
+ *
+ * Library state (`gpsData` / `gpsElements` / `arElements`) plus the
+ * framework recording slice (`recording`).
+ */
+interface SlamAppRootState extends RootState {
+  recording: RecordingState;
+}
+/** A bare-minimum middleware signature compatible with RTK's middleware list. */
+type SlamAppMiddleware = Middleware<any, any, any>;
+/**
+ * Options for {@link createSlamAppStore}.
+ */
+interface SlamAppStoreOptions<ExtraReducers extends ReducersMapObject = Record<string, never>> {
+  /**
+   * Persistence backend used to bridge Redux actions to durable storage.
+   * Tests / replay paths should pass `NullStorageBackend`.
+   */
+  storageBackend: StorageBackend;
+  /**
+   * Caller-supplied reducers added alongside the framework's built-ins.
+   * Use this seam to plug recorder slices (routing, refPoints, scenario)
+   * or any app-specific state without forking the factory.
+   */
+  extraReducers?: ExtraReducers;
+  /**
+   * Caller-supplied middlewares appended after RTK defaults and the
+   * persistence middleware.
+   */
+  extraMiddleware?: ReadonlyArray<SlamAppMiddleware>;
+  /**
+   * Invoked when the persistence middleware fails to durably write an action.
+   */
+  onWriteFailure?: (error: Error) => void;
+  /**
+   * Disables RTK's expensive dev-only middleware (Serializable / Immutable
+   * checks). Default `true`; set `false` for high-throughput replay scenarios.
+   */
+  enableDevChecks?: boolean;
+  /**
+   * License key for the core library. Defaults to the bundled community key.
+   * Apps with a paid license override here. Validation always runs and throws
+   * on invalid / expired / empty keys.
+   *
+   * @see EULA.md §3 — License Key
+   */
+  licenseKey?: string;
+}
+/**
+ * Combined root state: the framework's base state plus any caller-supplied
+ * extras. Generic so consumers get exact typing for the slices they add.
+ */
+type SlamAppCombinedState<ExtraReducers extends ReducersMapObject = Record<never, never>> = SlamAppRootState & { [K in keyof ExtraReducers]: ExtraReducers[K] extends Reducer<infer S> ? S : never };
+/**
+ * The store object returned by {@link createSlamAppStore}.
+ *
+ * Wraps RTK's store and adds storage-delegation helpers so consumers can
+ * issue frame / metadata writes without holding a separate handle to the
+ * `StorageBackend`.
+ */
+interface SlamAppStore<ExtraReducers extends ReducersMapObject = Record<string, never>> {
+  getState: () => SlamAppCombinedState<ExtraReducers>;
+  dispatch: ReturnType<typeof configureStore>['dispatch'];
+  subscribe: (listener: () => void) => () => void;
+  /** Persist a captured camera frame via the configured backend. */
+  writeFrame: (blob: Blob, index: number) => Promise<void>;
+  /** Persist session metadata (`session.json`) via the configured backend. */
+  writeSessionMetadata: (metadata: SessionMetadata) => Promise<void>;
+}
+/**
+ * Build a Redux store wired with library + recording slices, persistence
+ * middleware, and any caller-supplied extras. See module docstring for the
+ * design rationale.
+ */
+declare function createSlamAppStore<ExtraReducers extends ReducersMapObject = Record<string, never>>(options: SlamAppStoreOptions<ExtraReducers>): SlamAppStore<ExtraReducers>;
+//#endregion
+export { SlamAppStoreOptions as a, SlamAppStore as i, SlamAppMiddleware as n, createSlamAppStore as o, SlamAppRootState as r, SlamAppCombinedState as t };

package/dist/file-system-DD5TczSO.d.ts

@@ -0,0 +1,84 @@
+import { n as SessionMetadata } from "./opfs-storage-Dlq1I_Gb.js";
+
+//#region ../src/storage/file-system.d.ts
+/**
+ * Reset module state - exported for testing only
+ * @internal
+ */
+declare function resetStorageState(): void;
+/**
+ * Reset session-level state for a new recording.
+ *
+ * Clears scenario/session names and OPFS session handles, but preserves
+ * `storageInitialized` and the OPFS root so `initStorage()` doesn't need
+ * to be called again.
+ */
+declare function resetForNewSession(): void;
+/**
+ * Result of write access verification.
+ */
+interface WriteAccessResult {
+  /** Whether write access was successfully verified */
+  success: boolean;
+  /** Error message if write verification failed */
+  error?: string;
+}
+/**
+ * Verify that we have actual write access to a directory.
+ */
+declare function verifyWriteAccess(dirHandle: FileSystemDirectoryHandle): Promise<WriteAccessResult>;
+/**
+ * Initialize storage using OPFS.
+ *
+ * @returns List of existing scenario folder names
+ * @throws Error if OPFS is not supported
+ */
+declare function initStorage(): Promise<string[]>;
+/**
+ * Create a new session folder.
+ *
+ * When scenarioName is provided, creates under the scenario directory
+ * (legacy scenario layout for the recorder). When omitted, creates under
+ * the flat sessions/ directory.
+ *
+ * @param scenarioName - Optional name of the scenario (omit for flat layout)
+ */
+declare function startSession(scenarioName?: string): Promise<{
+  scenarioPath: string;
+  sessionPath: string;
+}>;
+/**
+ * List all session names.
+ * When scenarioName is provided, lists sessions under that scenario.
+ * Otherwise lists flat sessions.
+ */
+declare function listSessions(scenarioName?: string): Promise<string[]>;
+/**
+ * Write a Redux action to OPFS as a JSON file.
+ */
+declare function writeAction(action: unknown, index: number): Promise<void>;
+/**
+ * Write a captured frame image to OPFS.
+ */
+declare function writeFrame(blob: Blob, index: number): Promise<void>;
+/**
+ * Write session metadata (session.json) to OPFS.
+ */
+declare function writeSessionMetadata(metadata: SessionMetadata): Promise<void>;
+/**
+ * Get the current scenario handle (for loading prior sessions).
+ * Legacy: uses scenario directory layout.
+ */
+declare function getCurrentScenarioHandle(): FileSystemDirectoryHandle | null;
+/**
+ * Set the current scenario handle (when user selects a scenario).
+ * Legacy: uses scenario directory layout.
+ */
+declare function setCurrentScenario(scenarioName: string): Promise<FileSystemDirectoryHandle | null>;
+/**
+ * Ensure a scenario directory exists in OPFS, creating it if necessary.
+ * Legacy: used during OPFS recovery.
+ */
+declare function ensureScenarioDirectory(scenarioName: string): Promise<FileSystemDirectoryHandle | null>;
+//#endregion
+export { listSessions as a, setCurrentScenario as c, writeAction as d, writeFrame as f, initStorage as i, startSession as l, ensureScenarioDirectory as n, resetForNewSession as o, writeSessionMetadata as p, getCurrentScenarioHandle as r, resetStorageState as s, WriteAccessResult as t, verifyWriteAccess as u };

package/dist/geo/h3-proximity.d.ts

@@ -0,0 +1,2 @@
+import { a as gpsToH3, i as findNearbyGeoAnchor, n as KnownGeoAnchor, o as h3CellsMatch, r as approxDistanceMetres, s as isH3Index, t as H3_RESOLUTION } from "../h3-proximity-GwesPTFT.js";
+export { H3_RESOLUTION, KnownGeoAnchor, approxDistanceMetres, findNearbyGeoAnchor, gpsToH3, h3CellsMatch, isH3Index };

package/dist/{ref-points/h3-ref-point.js → geo/h3-proximity.js}

@@ -1,12 +1,16 @@
 import { gridDisk, latLngToCell } from "h3-js";
-//#region ../src/ref-points/h3-ref-point.ts
+//#region ../src/geo/h3-proximity.ts
 /**
-* H3 Reference Point Matching
+* H3 Geo-Anchor Proximity Matching
 *
-* Utility for matching GPS positions to known reference points using
-* H3 hexagonal grid indices. Uses gridDisk(cell, 1) to create a ~65m
+* Generic utility for matching GPS positions to known geo-anchored points
+* using H3 hexagonal grid indices. Uses gridDisk(cell, 1) to create a ~65m
 * safe zone that absorbs GPS jitter of 3-10m.
 *
+* Renamed from `ref-points/h3-ref-point.ts` in Iter 4 to drop recorder-only
+* naming. The math is unchanged; only the public type/function names were
+* generalised so the framework can serve any geo-anchored consumer.
+*
 * @see docs/2026-03-08-ref-point-naming-investigation.md §6
 */
 /** H3 resolution 11: ~25m edge, ~65m gridDisk safe zone */
@@ -32,20 +36,20 @@ function approxDistanceMetres(lat1, lon1, lat2, lon2) {
 	return R * Math.sqrt(dLat * dLat + x * x);
 }
 /**
-* Find the known reference point closest to the given GPS position,
+* Find the known geo-anchor 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
+* which absorbs GPS jitter of 3-10m while keeping anchors >130m apart
 * distinguishable.
 *
-* When multiple ref points have overlapping safe zones (65–130 m apart),
+* When multiple anchors 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;
+function findNearbyGeoAnchor(lat, lng, knownAnchors) {
+	if (knownAnchors.length === 0) return;
 	const safeZone = gridDisk(latLngToCell(lat, lng, 11), 1);
-	const candidates = knownRefPoints.filter((rp) => safeZone.includes(rp.h3Index));
+	const candidates = knownAnchors.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) => {
@@ -57,7 +61,7 @@ function findNearbyRefPoint(lat, lng, knownRefPoints) {
 * (i.e., one falls within the other's gridDisk safe zone).
 * This is the canonical cross-session matching check.
 */
-function h3RefsMatch(h3a, h3b) {
+function h3CellsMatch(h3a, h3b) {
 	if (h3a === h3b) return true;
 	return gridDisk(h3a, 1).includes(h3b);
 }
@@ -71,4 +75,4 @@ function isH3Index(id) {
 	return H3_INDEX_PATTERN.test(id);
 }
 //#endregion
-export { H3_RESOLUTION, approxDistanceMetres, findNearbyRefPoint, gpsToH3, h3RefsMatch, isH3Index };
+export { H3_RESOLUTION, approxDistanceMetres, findNearbyGeoAnchor, gpsToH3, h3CellsMatch, isH3Index };

package/dist/geo/index.d.ts

@@ -0,0 +1,2 @@
+import { a as gpsToH3, i as findNearbyGeoAnchor, n as KnownGeoAnchor, o as h3CellsMatch, r as approxDistanceMetres, s as isH3Index, t as H3_RESOLUTION } from "../h3-proximity-GwesPTFT.js";
+export { H3_RESOLUTION, type KnownGeoAnchor, approxDistanceMetres, findNearbyGeoAnchor, gpsToH3, h3CellsMatch, isH3Index };

package/dist/geo/index.js

@@ -0,0 +1,2 @@
+import { H3_RESOLUTION, approxDistanceMetres, findNearbyGeoAnchor, gpsToH3, h3CellsMatch, isH3Index } from "./h3-proximity.js";
+export { H3_RESOLUTION, approxDistanceMetres, findNearbyGeoAnchor, gpsToH3, h3CellsMatch, isH3Index };

package/dist/gps-anchored-mesh-manager-CovAFK4g.d.ts

@@ -0,0 +1,56 @@
+import { LatLong } from "gps-plus-slam-js";
+
+//#region ../src/visualization/gps-anchored-mesh-manager.d.ts
+/**
+ * Plain GPS-anchored item consumed by the manager. Callers project their
+ * domain types (ref points, POIs, anchors, …) onto this shape.
+ */
+interface GpsAnchoredItem {
+  readonly id: string;
+  readonly lat: number;
+  readonly lon: number;
+  readonly altitude?: number;
+}
+interface GpsAnchoredMeshManagerOptions {
+  /** Hex color for the shared material (e.g. `0x00ff00`). */
+  readonly color: number;
+  /** Sphere radius in meters. Defaults to `0.1` (10 cm). */
+  readonly radius?: number;
+  /** Mesh `name` prefix. Mesh names become `${namePrefix}-${item.id}`. */
+  readonly namePrefix: string;
+  /** Logger label. Defaults to `'GpsAnchoredMeshManager'`. */
+  readonly loggerLabel?: string;
+}
+/**
+ * Manages a single colored mesh group anchored to GPS coordinates.
+ * One instance == one color/group.
+ */
+declare class GpsAnchoredMeshManager {
+  private readonly color;
+  private readonly radius;
+  private readonly namePrefix;
+  private readonly log;
+  private meshes;
+  private zeroRef;
+  private geometry;
+  private material;
+  constructor(options: GpsAnchoredMeshManagerOptions);
+  /** Set the GPS origin used to project items into local meters. */
+  setZeroRef(zero: LatLong): void;
+  getZeroRef(): LatLong | null;
+  /**
+   * Replace the entire mesh group with one mesh per provided item.
+   * Items without GPS or before `setZeroRef` are skipped.
+   */
+  setItems(items: readonly GpsAnchoredItem[]): void;
+  /** Append a single item to the existing mesh group. */
+  addItem(item: GpsAnchoredItem): void;
+  /** Remove all meshes and dispose the shared geometry/material. */
+  clear(): void;
+  /** Number of meshes currently rendered. */
+  getCount(): number;
+  /** Convenience: clear and forget the zero reference. */
+  dispose(): void;
+}
+//#endregion
+export { GpsAnchoredMeshManager as n, GpsAnchoredMeshManagerOptions as r, GpsAnchoredItem as t };

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

@@ -0,0 +1,43 @@
+import { t as ARPose } from "./ar-types-B-ORgk6Z.js";
+import { Quaternion, Vector3 } from "gps-plus-slam-js";
+
+//#region ../src/state/gps-ar-pose-sampler.d.ts
+/**
+ * GPS coordinate captured at observation time. Loosely typed so the recorder
+ * can pass either a `RawGpsPoint` or a plain `{ latitude, longitude,
+ * altitude? }` shape from the fused-path computation.
+ */
+interface GpsAnchorSampleGpsPoint {
+  readonly latitude: number;
+  readonly longitude: number;
+  readonly altitude?: number;
+}
+/**
+ * A snapshot pairing the raw GPS reading, the optional fused GPS reading
+ * (computed when an alignment matrix is available), and the AR pose at the
+ * moment of capture. The `odomPosition` and `odomRotation` are pre-extracted
+ * from the AR pose for convenience — callers persisting the snapshot
+ * usually need them in tuple form.
+ */
+interface GpsAnchorSample {
+  readonly gpsPoint: GpsAnchorSampleGpsPoint;
+  readonly fusedGpsPoint?: GpsAnchorSampleGpsPoint;
+  readonly arPose: ARPose;
+  readonly odomPosition: Vector3;
+  readonly odomRotation: Quaternion;
+  readonly timestamp: number;
+}
+interface CaptureGpsAnchorSampleOptions {
+  /** Optional fused GPS point (computed elsewhere from the alignment matrix). */
+  readonly fusedGpsPoint?: GpsAnchorSampleGpsPoint;
+  /** Defaults to `Date.now()` at capture time. */
+  readonly timestamp?: number;
+}
+/**
+ * Capture a GPS-AR pose snapshot. Extracts `odomPosition`/`odomRotation`
+ * from the supplied `arPose`. The supplied `gpsPoint` and optional
+ * `fusedGpsPoint` are stored verbatim.
+ */
+declare function captureGpsAnchorSample(arPose: ARPose, gpsPoint: GpsAnchorSampleGpsPoint, options?: CaptureGpsAnchorSampleOptions): GpsAnchorSample;
+//#endregion
+export { captureGpsAnchorSample as i, GpsAnchorSample as n, GpsAnchorSampleGpsPoint as r, CaptureGpsAnchorSampleOptions as t };

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

@@ -1,15 +1,16 @@
 import { t as ARPose } from "./ar-types-B-ORgk6Z.js";
-import { n as RawDeviceOrientation, t as GpsPosition } from "./gps-Ddzr2KlX.js";
-import { c as RecordGpsEventPayload, l as RecorderStore } from "./store-C7PKOj8S.js";
-import { Quaternion, RawGpsPoint, Vector3, eulerToQuaternion } from "gps-plus-slam-js";
+import { n as RawDeviceOrientation, t as GpsPosition } from "./gps-GKc6_Cly.js";
+import { i as SlamAppStore } from "./create-slam-app-store-DBm7g2Zd.js";
+import { Quaternion, RawGpsPoint, RecordGpsEventPayload, Vector3, eulerToQuaternion } from "gps-plus-slam-js";
+import { ReducersMapObject } from "@reduxjs/toolkit";
 
-//#region ../src/state/recording-coordinator.d.ts
+//#region ../src/state/gps-event-coordinator.d.ts
 /**
  * Configuration for the recording coordinator
  */
 interface RecordingCoordinatorConfig {
   /** Redux store to dispatch actions to */
-  store: RecorderStore;
+  store: SlamAppStore<ReducersMapObject>;
   /** Function to get current AR pose (from WebXR module) */
   getArPose: () => ARPose | null;
 }

package/dist/{h3-ref-point-CFhayNSZ.d.ts → h3-proximity-GwesPTFT.d.ts}

@@ -1,21 +1,25 @@
-//#region ../src/ref-points/h3-ref-point.d.ts
+//#region ../src/geo/h3-proximity.d.ts
 /**
- * H3 Reference Point Matching
+ * H3 Geo-Anchor Proximity Matching
  *
- * Utility for matching GPS positions to known reference points using
- * H3 hexagonal grid indices. Uses gridDisk(cell, 1) to create a ~65m
+ * Generic utility for matching GPS positions to known geo-anchored points
+ * using H3 hexagonal grid indices. Uses gridDisk(cell, 1) to create a ~65m
  * safe zone that absorbs GPS jitter of 3-10m.
  *
+ * Renamed from `ref-points/h3-ref-point.ts` in Iter 4 to drop recorder-only
+ * naming. The math is unchanged; only the public type/function names were
+ * generalised so the framework can serve any geo-anchored consumer.
+ *
  * @see docs/2026-03-08-ref-point-naming-investigation.md §6
  */
 /** H3 resolution 11: ~25m edge, ~65m gridDisk safe zone */
 declare const H3_RESOLUTION = 11;
 /**
- * A known reference point with its H3 cell index and GPS coordinates,
+ * A known geo-anchored point with its H3 cell index and GPS coordinates,
  * used for proximity matching. GPS coordinates are needed to rank
  * multiple candidates by distance when their gridDisk zones overlap.
  */
-interface KnownRefPoint {
+interface KnownGeoAnchor {
   readonly h3Index: string;
   readonly displayName?: string;
   readonly lat: number;
@@ -33,27 +37,27 @@ declare function gpsToH3(lat: number, lng: number): string;
  */
 declare function approxDistanceMetres(lat1: number, lon1: number, lat2: number, lon2: number): number;
 /**
- * Find the known reference point closest to the given GPS position,
+ * Find the known geo-anchor 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
+ * which absorbs GPS jitter of 3-10m while keeping anchors >130m apart
  * distinguishable.
  *
- * When multiple ref points have overlapping safe zones (65–130 m apart),
+ * When multiple anchors have overlapping safe zones (65–130 m apart),
  * the closest one by equirectangular distance is returned.
  */
-declare function findNearbyRefPoint(lat: number, lng: number, knownRefPoints: readonly KnownRefPoint[]): KnownRefPoint | undefined;
+declare function findNearbyGeoAnchor(lat: number, lng: number, knownAnchors: readonly KnownGeoAnchor[]): KnownGeoAnchor | undefined;
 /**
  * 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.
  */
-declare function h3RefsMatch(h3a: string, h3b: string): boolean;
+declare function h3CellsMatch(h3a: string, h3b: string): boolean;
 /**
  * Check whether a string looks like a valid H3 resolution-11 index.
  * Used to distinguish H3 IDs from legacy user-typed string IDs.
  */
 declare function isH3Index(id: string): boolean;
 //#endregion
-export { gpsToH3 as a, findNearbyRefPoint as i, KnownRefPoint as n, h3RefsMatch as o, approxDistanceMetres as r, isH3Index as s, H3_RESOLUTION as t };
+export { gpsToH3 as a, findNearbyGeoAnchor as i, KnownGeoAnchor as n, h3CellsMatch as o, approxDistanceMetres as r, isH3Index as s, H3_RESOLUTION as t };