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

package/dist/{opfs-storage-ChOzF_Wp.d.ts → opfs-storage-DOPkzgeT.d.ts}

@@ -6,20 +6,21 @@
  * OPFS works consistently on Desktop Chrome, Android Chrome, and iOS Safari,
  * unlike showDirectoryPicker which has write restrictions on Android.
  *
- * Directory structure:
- * /gps-recorder/
- *   └── scenarios/
- *       ├── {scenario-name}/
- *       │   ├── recording-YYYY-MM-DD_HH-MM-SSutc/
- *       │   │   ├── session.json
- *       │   │   ├── actions/
- *       │   │   │   ├── 000001.json
- *       │   │   │   └── ...
- *       │   │   └── frames/
- *       │   │       ├── frame-000001.jpg
- *       │   │       └── ...
- *       │   └── ...
+ * Directory structure (flat sessions — no scenario hierarchy):
+ * /gps-plus-slam/
+ *   └── sessions/
+ *       ├── recording-YYYY-MM-DD_HH-MM-SSutc/
+ *       │   ├── session.json
+ *       │   ├── actions/
+ *       │   │   ├── 000001.json
+ *       │   │   └── ...
+ *       │   └── frames/
+ *       │       ├── frame-000001.jpg
+ *       │       └── ...
  *       └── ...
+ *
+ * Scenario grouping (scenarios/{name}/recording-…) is a recorder-only concern,
+ * handled by ScenarioWrappingStorageBackend in the recorder app.
  */
 /**
  * Session metadata stored in session.json.
@@ -46,8 +47,12 @@ interface SessionMetadata {
   startedAt: string;
   /** ISO 8601 timestamp when recording ended */
   endedAt: string;
-  /** Name of the scenario this session belongs to */
-  scenarioName: string;
+  /**
+   * Opaque tag the framework does not interpret. Consumers (e.g. the recorder)
+   * use it to carry application-specific grouping info such as a scenario name.
+   * Replaces the former required `scenarioName` field.
+   */
+  contextTag?: string;
   /** Total number of actions recorded */
   actionCount: number;
   /** Total number of frames captured */
@@ -69,7 +74,6 @@ interface SessionMetadata {
  * Result from createSession.
  */
 interface CreateSessionResult {
-  scenarioName: string;
   sessionName: string;
 }
 /**
@@ -80,19 +84,17 @@ declare function resetOpfsStorage(): void;
 /**
  * Reset session-level handles only.
  *
- * Preserves opfsRoot/gpsRecorderDir/scenariosDir (OPFS stays initialized)
- * but clears current scenario/session/actions/frames handles so a new
- * session can be started fresh.
- *
- * Used during soft reset for new recordings (Issue 4, 2026-02-06 user feedback).
+ * Preserves opfsRoot/gpsPlusSlamDir/sessionsDir (OPFS stays initialized)
+ * but clears current session/actions/frames handles so a new session can
+ * be started fresh.
  */
 declare function resetSessionHandles(): void;
 /**
  * Initialize OPFS storage by creating the required directory structure.
  *
  * Creates:
- * - /gps-recorder/
- * - /gps-recorder/scenarios/
+ * - /gps-plus-slam/
+ * - /gps-plus-slam/sessions/
  *
  * This is idempotent - calling multiple times is safe.
  *
@@ -100,34 +102,46 @@ declare function resetSessionHandles(): void;
  */
 declare function initOpfsStorage(): Promise<void>;
 /**
- * Create a new recording session within a scenario.
+ * Get the sessions root directory handle.
+ * Used by consumers that need direct OPFS access (e.g. ZIP export).
+ */
+declare function getSessionsRootHandle(): FileSystemDirectoryHandle | null;
+/**
+ * Get the app root directory handle (gps-plus-slam/).
+ * Used by consumers that need to create additional directories alongside sessions/.
+ */
+declare function getAppRootHandle(): FileSystemDirectoryHandle | null;
+/**
+ * Create a new recording session.
  *
  * Creates the directory structure:
- * - /gps-recorder/scenarios/{scenarioName}/recording-{timestamp}/
- * - /gps-recorder/scenarios/{scenarioName}/recording-{timestamp}/actions/
- * - /gps-recorder/scenarios/{scenarioName}/recording-{timestamp}/frames/
+ * - /gps-plus-slam/sessions/recording-{timestamp}/
+ * - /gps-plus-slam/sessions/recording-{timestamp}/actions/
+ * - /gps-plus-slam/sessions/recording-{timestamp}/frames/
  *
- * @param scenarioName - Name of the scenario (creates if doesn't exist)
  * @param timestamp - Session start time (used for folder naming)
+ * @param _contextTag - Opaque tag; not used by the flat layout but accepted
+ *   for interface compatibility with wrapping backends
  * @returns Session information
  * @throws Error if storage not initialized
  */
-declare function createSession(scenarioName: string, timestamp: Date): Promise<CreateSessionResult>;
+declare function createSession(timestamp: Date, _contextTag?: string): Promise<CreateSessionResult>;
 /**
  * Get the current session directory handle.
- * Useful for test assertions.
  * @internal
  */
 declare function getSessionHandle(): FileSystemDirectoryHandle | null;
 /**
- * Get the current scenario directory handle.
- */
-declare function getScenarioHandle(): FileSystemDirectoryHandle | null;
-/**
- * Get the scenarios root directory handle.
- * Used for loading reference points across scenarios.
+ * Set the active session handles externally.
+ *
+ * Used by file-system.ts's scenario-based path to reuse opfs-storage's
+ * write infrastructure for sessions created outside the flat layout.
+ * This is a temporary bridge until the recorder migrates to
+ * ScenarioWrappingStorageBackend.
+ *
+ * @internal
  */
-declare function getScenariosRootHandle(): FileSystemDirectoryHandle | null;
+declare function setSessionHandles(session: FileSystemDirectoryHandle, actions: FileSystemDirectoryHandle, frames: FileSystemDirectoryHandle): void;
 /**
  * Write a Redux action to the current session's actions directory.
  *
@@ -152,25 +166,14 @@ declare function writeFrame(blob: Blob, index: number): Promise<void>;
  */
 declare function writeSessionMetadata(metadata: SessionMetadata): Promise<void>;
 /**
- * List all scenario names in OPFS storage.
+ * List all session names in OPFS storage.
  *
- * @returns Array of scenario folder names
- */
-declare function listScenarios(): Promise<string[]>;
-/**
- * List all session names within a scenario.
- *
- * @param scenarioName - Name of the scenario
  * @returns Array of session folder names
  */
-declare function listSessions(scenarioName: string): Promise<string[]>;
+declare function listSessions(): Promise<string[]>;
 /**
  * Check storage quota.
  *
- * Note: Prefer calling `initOpfsStorage()` before this function to ensure
- * the Storage API is available. If the Storage Manager API is not supported,
- * returns a safe default of `{ available: 0, used: 0 }`.
- *
  * @returns Available and used storage in bytes
  */
 declare function checkStorageQuota(): Promise<{
@@ -178,4 +181,4 @@ declare function checkStorageQuota(): Promise<{
   used: number;
 }>;
 //#endregion
-export { getScenarioHandle as a, initOpfsStorage as c, resetOpfsStorage as d, resetSessionHandles as f, writeSessionMetadata as h, createSession as i, listScenarios as l, writeFrame as m, SessionMetadata as n, getScenariosRootHandle as o, writeAction as p, checkStorageQuota as r, getSessionHandle as s, CreateSessionResult as t, listSessions as u };
+export { getAppRootHandle as a, initOpfsStorage as c, resetSessionHandles as d, setSessionHandles as f, writeSessionMetadata as h, createSession as i, listSessions as l, writeFrame as m, SessionMetadata as n, getSessionHandle as o, writeAction as p, checkStorageQuota as r, getSessionsRootHandle as s, CreateSessionResult as t, resetOpfsStorage as u };

package/dist/opfs-storage-backend-Cj_7PWoq.d.ts

@@ -0,0 +1,13 @@
+import { n as SessionMetadata } from "./opfs-storage-DOPkzgeT.js";
+import { n as StorageBackend, t as CreateSessionResult } from "./storage-backend-CT0Il_AB.js";
+
+//#region ../src/storage/opfs-storage-backend.d.ts
+declare class OpfsStorageBackend implements StorageBackend {
+  createSession(_timestamp: Date, _contextTag?: string): Promise<CreateSessionResult>;
+  listSessions(): Promise<string[]>;
+  writeAction(action: unknown, index: number): Promise<void>;
+  writeFrame(blob: Blob, index: number): Promise<void>;
+  writeSessionMetadata(metadata: SessionMetadata): Promise<void>;
+}
+//#endregion
+export { OpfsStorageBackend as t };

package/dist/{permission-checker-jO2ziCWC.d.ts → permission-checker-DPJl_RU6.d.ts}

@@ -117,6 +117,46 @@ declare function requestOrientationPermission(): Promise<PermissionStatus>;
  * Returns current known state of each permission.
  */
 declare function checkAllPermissions(): Promise<PermissionCheckResult>;
+/**
+ * Subscription handle returned by {@link subscribePermissionChanges}.
+ * Calling `unsubscribe()` detaches every listener wired by the subscription.
+ */
+interface PermissionSubscription {
+  unsubscribe(): void;
+}
+/**
+ * Subscribe to out-of-band permission changes.
+ *
+ * Today the recorder app only re-runs `checkAllPermissions()` at startup
+ * and after the user clicks "Grant Permissions" — so a permission flipped
+ * via browser settings (e.g. user denies location, then enables it under
+ * "site settings") is only detected after a full page reload.
+ *
+ * This subscription wires three signals:
+ * 1. `navigator.permissions.query(...)` returns a live `PermissionStatus`
+ *    for `'geolocation'` and `'camera'`; we keep those references and
+ *    attach a `'change'` listener via `addEventListener` so we react
+ *    immediately when the browser updates the underlying state.
+ * 2. `document.visibilitychange` (only when `visibilityState === 'visible'`)
+ *    covers the "user tabbed out to settings, toggled, tabbed back" case
+ *    on browsers where the `'change'` event does not fire reliably.
+ * 3. `window.focus` covers the same scenario for browsers/standalone
+ *    windows where `visibilitychange` is not dispatched on focus return.
+ *
+ * Each signal triggers a fresh {@link checkAllPermissions} call; the
+ * resulting {@link PermissionCheckResult} is passed to `callback`.
+ *
+ * No periodic polling is performed — the trio above is the complete
+ * fallback chain. If a browser supports none of these signals for a given
+ * permission, the user can still re-check by clicking the (now permanently
+ * visible) "Grant Permissions" button.
+ *
+ * @param callback - Invoked with the latest {@link PermissionCheckResult}
+ *   each time one of the signals fires. The initial state is **not**
+ *   delivered; callers are expected to have already rendered it.
+ * @returns A handle whose `unsubscribe()` removes every wired listener.
+ */
+declare function subscribePermissionChanges(callback: (result: PermissionCheckResult) => void): PermissionSubscription;
 /**
  * Request all mandatory permissions that haven't been granted yet.
  * Shows browser prompts for each permission that needs requesting.
@@ -143,4 +183,4 @@ declare function requestAllPermissions(): Promise<PermissionCheckResult>;
  */
 declare function requestWebXRWithDepthPermission(): Promise<PermissionStatus>;
 //#endregion
-export { checkFileSystemPermission as a, checkWebXRSupport as c, requestGeolocationPermission as d, requestOrientationPermission as f, setFileSystemState as h, checkCameraPermission as i, requestAllPermissions as l, resetFileSystemState as m, PermissionStatus as n, checkGeolocationPermission as o, requestWebXRWithDepthPermission as p, checkAllPermissions as r, checkOrientationPermission as s, PermissionCheckResult as t, requestCameraPermission as u };
+export { subscribePermissionChanges as _, checkCameraPermission as a, checkOrientationPermission as c, requestCameraPermission as d, requestGeolocationPermission as f, setFileSystemState as g, resetFileSystemState as h, checkAllPermissions as i, checkWebXRSupport as l, requestWebXRWithDepthPermission as m, PermissionStatus as n, checkFileSystemPermission as o, requestOrientationPermission as p, PermissionSubscription as r, checkGeolocationPermission as s, PermissionCheckResult as t, requestAllPermissions as u };

package/dist/persistence-middleware-BkHIqvaA.d.ts

@@ -0,0 +1,55 @@
+import { n as StorageBackend } from "./storage-backend-CT0Il_AB.js";
+import { Middleware } from "@reduxjs/toolkit";
+
+//#region ../src/state/persistence-middleware.d.ts
+interface PersistenceMiddlewareOptions {
+  /**
+   * StorageBackend to use for action persistence.
+   */
+  storageBackend: StorageBackend;
+  /**
+   * Slice names whose actions are persisted to the recording stream
+   * (e.g. `['gpsData', 'recording', 'refPoints']`).
+   *
+   * Callers MUST derive these from the actual slices — pass
+   * `slicePrefixOf(someActionCreator.type)` or a `slice.name`, never a
+   * hand-typed literal. A slice rename then propagates here automatically
+   * instead of silently dropping the renamed slice's actions from every
+   * recording (the 2026-05-28 `refPointsV2/` → `refPoints/` regression).
+   *
+   * `recording/recordWriteFailure` is always excluded regardless of this
+   * list, to prevent recursive persistence.
+   */
+  persistedPrefixes: readonly string[];
+  /**
+   * Callback invoked when a write operation fails during persistence.
+   * User Feedback Issue #1 Part B: Used to show toast notifications.
+   */
+  onWriteFailure?: (error: Error) => void;
+}
+/**
+ * Extract the slice prefix from a namespaced Redux action type.
+ *
+ * `'gpsData/setZeroPos'` → `'gpsData'`. Returns the whole string when there
+ * is no slash (e.g. `'@@INIT'`). This is the single point that turns a
+ * slice-owned action type into the value the persistence whitelist matches
+ * on, so call sites can derive prefixes from real action creators instead of
+ * re-typing literals.
+ */
+declare function slicePrefixOf(actionType: string): string;
+/**
+ * Create a Redux middleware that persists qualifying actions to storage
+ * during active recording sessions.
+ *
+ * Persistence rules:
+ * - Only persists when `state.recording.isRecording` is true (checked AFTER
+ *   the action is reduced, so `startSession` itself is included).
+ * - Persists actions whose slice prefix is listed in `persistedPrefixes`.
+ * - Excludes `recording/recordWriteFailure` to prevent recursive persistence.
+ * - Excludes `routing/*` and any other non-whitelisted actions.
+ * - Uses 1-based indexing for action files (000001.json, 000002.json, …).
+ * - Each middleware instance maintains its own action index (Bug 10 fix).
+ */
+declare function createPersistenceMiddleware(options: PersistenceMiddlewareOptions): Middleware;
+//#endregion
+export { createPersistenceMiddleware as n, slicePrefixOf as r, PersistenceMiddlewareOptions as t };

package/dist/{recording-replayer-oOzPITrd.d.ts → recording-replayer-CmCIIZ02.d.ts}

@@ -1,5 +1,5 @@
-import { n as CombinedRootState } from "./store-C7PKOj8S.js";
-import { i as RecordedAction } from "./zip-reader-D7pkpX8K.js";
+import { L as CombinedRootState } from "./create-slam-app-store-CNsZ3rcX.js";
+import { i as RecordedAction } from "./zip-reader-D1105idz.js";
 
 //#region ../src/state/recording-replayer.d.ts
 /**

package/dist/recording-slice-d6OtCrza.d.ts

@@ -0,0 +1,28 @@
+import { i as DepthSample } from "./ar-types-Ck8LEq8k.js";
+import { s as RecordingOptions } from "./recording-options-Dq6IsKAv.js";
+import * as _$_reduxjs_toolkit0 from "@reduxjs/toolkit";
+
+//#region ../src/state/recording-slice.d.ts
+interface SessionMetadata {
+  scenarioName: string;
+  sessionName: string;
+  startTime: number;
+  deviceInfo?: string;
+  notes?: string;
+  /** Recording options used for this session (for replay context) */
+  recordingOptions?: RecordingOptions;
+}
+interface RecordingState {
+  isRecording: boolean;
+  sessionMetadata: SessionMetadata | null;
+  actionCount: number;
+  /**
+   * Count of failed file write operations during this session.
+   * User Feedback Issue #1 Part B: Track write failures for visibility.
+   */
+  failedWriteCount: number;
+}
+declare const startSession: _$_reduxjs_toolkit0.ActionCreatorWithPayload<SessionMetadata, "recording/startSession">, endSession: _$_reduxjs_toolkit0.ActionCreatorWithoutPayload<"recording/endSession">, recordDepthSample: _$_reduxjs_toolkit0.ActionCreatorWithPayload<DepthSample, "recording/recordDepthSample">, recordWriteFailure: _$_reduxjs_toolkit0.ActionCreatorWithPayload<string, "recording/recordWriteFailure">;
+declare const recordingReducer: _$_reduxjs_toolkit0.Reducer<RecordingState>;
+//#endregion
+export { recordWriteFailure as a, recordDepthSample as i, SessionMetadata as n, recordingReducer as o, endSession as r, startSession as s, RecordingState as t };

package/dist/{replay-engine-DuX316ae.d.ts → replay-engine-BGBRQyXs.d.ts}

@@ -1,6 +1,9 @@
-import { l as RecorderStore } from "./store-C7PKOj8S.js";
+import { i as SlamAppStore } from "./create-slam-app-store-CNsZ3rcX.js";
+import { ReducersMapObject } from "@reduxjs/toolkit";
 
 //#region ../src/state/replay-engine.d.ts
+/** Minimal store contract used by the replay engine: dispatches plain actions. */
+type RecorderStore = SlamAppStore<ReducersMapObject>;
 /** Default maximum delay between actions in ms (30 seconds real-time) */
 declare const DEFAULT_MAX_DELAY_MS = 30000;
 type ReplayState = 'idle' | 'playing' | 'paused' | 'completed';

package/dist/{replay-scene-DtUm6bsr.d.ts → replay-scene-DpAGcAKY.d.ts}

@@ -1,6 +1,6 @@
-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 { t as CameraFollower } from "./camera-follower-1k8mnw5J.js";
+import { t as AlignmentLerper } from "./alignment-lerper-L1RbWHQ4.js";
+import { t as Css3dRendererManager } from "./css3d-renderer-manager-CkjCb2HW.js";
 import * as THREE from "three";
 import { OrbitControls } from "three/addons/controls/OrbitControls.js";
 

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

@@ -1,2 +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";
+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-Dg3ziRVY.js";
 export { GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, createGpsErrorHandler, getGpsErrorMessage };

package/dist/sensors/gps.d.ts

@@ -1,2 +1,2 @@
-import { a as startOrientationWatch, i as startGpsWatch, n as RawDeviceOrientation, o as stopGpsWatch, r as requestOrientationPermission, s as stopOrientationWatch, t as GpsPosition } from "../gps-Ddzr2KlX.js";
+import { a as startOrientationWatch, i as startGpsWatch, n as RawDeviceOrientation, o as stopGpsWatch, r as requestOrientationPermission, s as stopOrientationWatch, t as GpsPosition } from "../gps-DXoQb9Kf.js";
 export { GpsPosition, RawDeviceOrientation, requestOrientationPermission, startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch };

package/dist/sensors/gps.js

@@ -36,8 +36,8 @@ function startGpsWatch(onPosition, onError) {
 		onError?.(err);
 	}, {
 		enableHighAccuracy: true,
-		maximumAge: 0,
-		timeout: 1e4
+		maximumAge: 5e3,
+		timeout: 15e3
 	});
 	log.info("Watch started");
 }

package/dist/sensors/index.d.ts

@@ -1,4 +1,4 @@
-import { a as startOrientationWatch, i as startGpsWatch, n as RawDeviceOrientation, o as stopGpsWatch, r as requestOrientationPermission, s as stopOrientationWatch, t as GpsPosition } from "../gps-Ddzr2KlX.js";
-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";
-import { a as checkFileSystemPermission, c as checkWebXRSupport, d as requestGeolocationPermission, f as requestOrientationPermission$1, h as setFileSystemState, i as checkCameraPermission, l as requestAllPermissions, m as resetFileSystemState, n as PermissionStatus, o as checkGeolocationPermission, p as requestWebXRWithDepthPermission, r as checkAllPermissions, s as checkOrientationPermission, t as PermissionCheckResult, u as requestCameraPermission } from "../permission-checker-jO2ziCWC.js";
+import { a as startOrientationWatch, i as startGpsWatch, n as RawDeviceOrientation, o as stopGpsWatch, r as requestOrientationPermission, s as stopOrientationWatch, t as GpsPosition } from "../gps-DXoQb9Kf.js";
+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-Dg3ziRVY.js";
+import { a as checkCameraPermission, c as checkOrientationPermission, d as requestCameraPermission, f as requestGeolocationPermission, g as setFileSystemState, h as resetFileSystemState, i as checkAllPermissions, l as checkWebXRSupport, m as requestWebXRWithDepthPermission, n as PermissionStatus, o as checkFileSystemPermission, p as requestOrientationPermission$1, s as checkGeolocationPermission, t as PermissionCheckResult, u as requestAllPermissions } from "../permission-checker-DPJl_RU6.js";
 export { GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, type GpsPosition, type PermissionCheckResult, type PermissionStatus, type RawDeviceOrientation, checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, createGpsErrorHandler, getGpsErrorMessage, requestAllPermissions, requestCameraPermission, requestOrientationPermission as requestDeviceOrientationPermission, requestGeolocationPermission, requestOrientationPermission$1 as requestOrientationPermission, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState, startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch };

package/dist/sensors/index.js

@@ -1,4 +1,4 @@
-import { checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, requestAllPermissions, requestCameraPermission, requestGeolocationPermission, requestOrientationPermission as requestOrientationPermission$1, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState } from "./permission-checker.js";
 import { requestOrientationPermission, startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch } from "./gps.js";
 import { GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, createGpsErrorHandler, getGpsErrorMessage } from "./gps-error-handler.js";
+import { checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, requestAllPermissions, requestCameraPermission, requestGeolocationPermission, requestOrientationPermission as requestOrientationPermission$1, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState } from "./permission-checker.js";
 export { GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, createGpsErrorHandler, getGpsErrorMessage, requestAllPermissions, requestCameraPermission, requestOrientationPermission as requestDeviceOrientationPermission, requestGeolocationPermission, requestOrientationPermission$1 as requestOrientationPermission, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState, startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch };

package/dist/sensors/permission-checker.d.ts

@@ -1,2 +1,2 @@
-import { a as checkFileSystemPermission, c as checkWebXRSupport, d as requestGeolocationPermission, f as requestOrientationPermission, h as setFileSystemState, i as checkCameraPermission, l as requestAllPermissions, m as resetFileSystemState, n as PermissionStatus, o as checkGeolocationPermission, p as requestWebXRWithDepthPermission, r as checkAllPermissions, s as checkOrientationPermission, t as PermissionCheckResult, u as requestCameraPermission } from "../permission-checker-jO2ziCWC.js";
-export { PermissionCheckResult, PermissionStatus, checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, requestAllPermissions, requestCameraPermission, requestGeolocationPermission, requestOrientationPermission, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState };
+import { _ as subscribePermissionChanges, a as checkCameraPermission, c as checkOrientationPermission, d as requestCameraPermission, f as requestGeolocationPermission, g as setFileSystemState, h as resetFileSystemState, i as checkAllPermissions, l as checkWebXRSupport, m as requestWebXRWithDepthPermission, n as PermissionStatus, o as checkFileSystemPermission, p as requestOrientationPermission, r as PermissionSubscription, s as checkGeolocationPermission, t as PermissionCheckResult, u as requestAllPermissions } from "../permission-checker-DPJl_RU6.js";
+export { PermissionCheckResult, PermissionStatus, PermissionSubscription, checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, requestAllPermissions, requestCameraPermission, requestGeolocationPermission, requestOrientationPermission, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState, subscribePermissionChanges };

package/dist/sensors/permission-checker.js

@@ -321,6 +321,84 @@ async function checkAllPermissions() {
 	};
 }
 /**
+* Subscribe to out-of-band permission changes.
+*
+* Today the recorder app only re-runs `checkAllPermissions()` at startup
+* and after the user clicks "Grant Permissions" — so a permission flipped
+* via browser settings (e.g. user denies location, then enables it under
+* "site settings") is only detected after a full page reload.
+*
+* This subscription wires three signals:
+* 1. `navigator.permissions.query(...)` returns a live `PermissionStatus`
+*    for `'geolocation'` and `'camera'`; we keep those references and
+*    attach a `'change'` listener via `addEventListener` so we react
+*    immediately when the browser updates the underlying state.
+* 2. `document.visibilitychange` (only when `visibilityState === 'visible'`)
+*    covers the "user tabbed out to settings, toggled, tabbed back" case
+*    on browsers where the `'change'` event does not fire reliably.
+* 3. `window.focus` covers the same scenario for browsers/standalone
+*    windows where `visibilitychange` is not dispatched on focus return.
+*
+* Each signal triggers a fresh {@link checkAllPermissions} call; the
+* resulting {@link PermissionCheckResult} is passed to `callback`.
+*
+* No periodic polling is performed — the trio above is the complete
+* fallback chain. If a browser supports none of these signals for a given
+* permission, the user can still re-check by clicking the (now permanently
+* visible) "Grant Permissions" button.
+*
+* @param callback - Invoked with the latest {@link PermissionCheckResult}
+*   each time one of the signals fires. The initial state is **not**
+*   delivered; callers are expected to have already rendered it.
+* @returns A handle whose `unsubscribe()` removes every wired listener.
+*/
+function subscribePermissionChanges(callback) {
+	let disposed = false;
+	const cleanups = [];
+	const notify = () => {
+		if (disposed) return;
+		checkAllPermissions().then((result) => {
+			if (!disposed) callback(result);
+		}).catch((err) => {
+			log.warn("subscribePermissionChanges: re-check failed", err);
+		});
+	};
+	if (typeof navigator !== "undefined" && navigator.permissions && typeof navigator.permissions.query === "function") {
+		const wireStatus = (name) => {
+			try {
+				navigator.permissions.query({ name }).then((status) => {
+					if (disposed) return;
+					const handler = () => notify();
+					status.addEventListener("change", handler);
+					cleanups.push(() => status.removeEventListener("change", handler));
+				}, () => {});
+			} catch {}
+		};
+		wireStatus("geolocation");
+		wireStatus("camera");
+	}
+	if (typeof document !== "undefined") {
+		const onVisibility = () => {
+			if (document.visibilityState === "visible") notify();
+		};
+		document.addEventListener("visibilitychange", onVisibility);
+		cleanups.push(() => document.removeEventListener("visibilitychange", onVisibility));
+	}
+	if (typeof window !== "undefined") {
+		const onFocus = () => notify();
+		window.addEventListener("focus", onFocus);
+		cleanups.push(() => window.removeEventListener("focus", onFocus));
+	}
+	return { unsubscribe() {
+		disposed = true;
+		for (const c of cleanups.splice(0)) try {
+			c();
+		} catch (err) {
+			log.warn("subscribePermissionChanges: cleanup failed", err);
+		}
+	} };
+}
+/**
 * Request all mandatory permissions that haven't been granted yet.
 * Shows browser prompts for each permission that needs requesting.
 *
@@ -394,4 +472,4 @@ async function requestWebXRWithDepthPermission() {
 	}
 }
 //#endregion
-export { checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, requestAllPermissions, requestCameraPermission, requestGeolocationPermission, requestOrientationPermission, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState };
+export { checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, requestAllPermissions, requestCameraPermission, requestGeolocationPermission, requestOrientationPermission, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState, subscribePermissionChanges };

package/dist/state/app-selectors.d.ts

@@ -1,2 +1,2 @@
-import { a as selectReferencePoints, i as selectOdometryRotations, n as selectGpsPositions, o as selectZeroReference, r as selectOdometryPositions, t as selectAlignmentMatrix } from "../app-selectors-DyMzxCEC.js";
-export { selectAlignmentMatrix, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectReferencePoints, selectZeroReference };
+import { a as selectOdometryRotations, i as selectOdometryPositions, n as selectFrameTilesInWebXR, o as selectZeroReference, r as selectGpsPositions, t as selectAlignmentMatrix } from "../app-selectors-BeU0_ab8.js";
+export { selectAlignmentMatrix, selectFrameTilesInWebXR, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectZeroReference };

package/dist/state/app-selectors.js

@@ -1,3 +1,4 @@
+import { nueQuaternionToWebXR, nueToWebXR } from "gps-plus-slam-js";
 import { createSelector } from "@reduxjs/toolkit";
 //#region ../src/state/app-selectors.ts
 /**
@@ -17,7 +18,7 @@ import { createSelector } from "@reduxjs/toolkit";
 const EMPTY_GPS_POSITIONS = [];
 const EMPTY_ODOM_POSITIONS = [];
 const EMPTY_ODOM_ROTATIONS = [];
-const EMPTY_REF_POINTS = [];
+const EMPTY_FRAME_TILES = [];
 const selectGpsData = (state) => state.gpsData;
 /** Alignment matrix (4×4), or null if not yet computed. */
 const selectAlignmentMatrix = createSelector([selectGpsData], (gpsData) => gpsData?.gpsEvents?.alignmentMatrix ?? null);
@@ -30,6 +31,35 @@ const selectOdometryRotations = createSelector([selectGpsData], (gpsData) => gps
 /** GPS zero reference (origin for coordinate conversion), or null. */
 const selectZeroReference = createSelector([selectGpsData], (gpsData) => gpsData?.zero ?? null);
 /** User-defined reference points for ground truth validation. */
-const selectReferencePoints = createSelector([selectGpsData], (gpsData) => gpsData?.referencePoints ?? EMPTY_REF_POINTS);
+/**
+* Captured AR image frames in WebXR coordinate space.
+*
+* Reads `state.gpsData.odometryPath.points` (which the library reducer
+* stores in NUE convention — see `gpsDataSlice.ts` `add2dImage`) and
+* converts each entry back to WebXR so the live AR scene visualizer can
+* apply the pose directly. This is the source of truth for the
+* frame-tile visualizer; the legacy `framesInScene` slice is a dead
+* mirror scheduled for removal (Step 5 of the 2026-05-27
+* slice-collapse plan).
+*
+* Memoized via createSelector keyed on `odometryPath.points` (NOT the whole
+* `gpsData`). The library reducer uses Immer, so unrelated updates (GPS
+* observations, VIO offsets) produce a new `gpsData` reference while
+* `odometryPath.points` keeps its reference via structural sharing. Keying on
+* the points array therefore preserves referential stability of the output
+* across those dispatches — subscribers like `wireFrameTileSubscribers` only
+* re-run when frames actually change.
+*/
+const selectOdometryPathPoints = (state) => state.gpsData?.odometryPath?.points;
+const selectFrameTilesInWebXR = createSelector([selectOdometryPathPoints], (points) => {
+	if (!points || points.length === 0) return EMPTY_FRAME_TILES;
+	return points.map((p) => ({
+		imageFile: p.imageFile,
+		position: nueToWebXR(p.position),
+		rotation: nueQuaternionToWebXR(p.rotation),
+		screenRotation: p.screenRotation,
+		capturedAt: p.capturedAt
+	}));
+});
 //#endregion
-export { selectAlignmentMatrix, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectReferencePoints, selectZeroReference };
+export { selectAlignmentMatrix, selectFrameTilesInWebXR, selectGpsPositions, selectOdometryPositions, selectOdometryRotations, selectZeroReference };

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

@@ -0,0 +1,2 @@
+import { L as CombinedRootState } from "../create-slam-app-store-CNsZ3rcX.js";
+export { CombinedRootState };

package/dist/state/combined-root-state.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+import { a as SlamAppStoreOptions, i as SlamAppStore, n as SlamAppMiddleware, o as createSlamAppStore, r as SlamAppRootState, t as SlamAppCombinedState } from "../create-slam-app-store-CNsZ3rcX.js";
+export { SlamAppCombinedState, SlamAppMiddleware, SlamAppRootState, SlamAppStore, SlamAppStoreOptions, createSlamAppStore };