gps-plus-slam-app-framework 1.3.0 → 1.4.0

package/dist/{webxr-session-GjZ2BIpS.d.ts → webxr-session-COsOjJwn.d.ts}

@@ -1,10 +1,11 @@
-import { i as DepthSample, t as ARPose } from "./ar-types-Dan1MVTi.js";
-import { i as DepthSamplerConfig } from "./depth-sampler-Bhanfwla.js";
-import { t as ArCrashIsolationOptions } from "./recording-options-DJBXuMxV.js";
-import { a as ImageCaptureConfig, n as CapturedImage } from "./image-capture-qAZ5Fh5X.js";
-import { a as TrackingSliceState, r as ResetTransformData } from "./tracking-slice-CdK8c-8P.js";
-import { t as Css3dRendererManager } from "./css3d-renderer-manager-ptu_t3B3.js";
-import { r as XRCameraLike } from "./xr-camera-texture-DBwCaKTd.js";
+import { i as DepthSample, t as ARPose } from "./ar-types-BckI1E-O.js";
+import { i as DepthSamplerConfig } from "./depth-sampler-DwfPYzS7.js";
+import { t as ArCrashIsolationOptions } from "./recording-options-D93kksJU.js";
+import { a as ImageCaptureConfig, n as CapturedImage } from "./image-capture-C2Feywet.js";
+import { a as TrackingSliceState, r as ResetTransformData } from "./tracking-slice-DJZ9qeGg.js";
+import { o as RgbaImage } from "./qr-frontend-DufZp2xS.js";
+import { t as Css3dRendererManager } from "./css3d-renderer-manager-m-ab19vp.js";
+import { r as XRCameraLike } from "./xr-camera-texture-BmrP7iNZ.js";
 import * as THREE from "three";
 import { OdometryTrackingRestartedPayload } from "gps-plus-slam-js";
 
@@ -68,6 +69,18 @@ declare function shouldLogCameraAccessDiagnostic(pose: XRViewerPose | null, alre
  * @internal
  */
 declare function resetWebXRState(): void;
+/**
+ * Default longer-edge resolution (px) for the camera-frame blit the QR / CV
+ * detector sees. The on-device capture-resolution sweep (2026-06-17, via the
+ * `?capture=` override) showed **1024** decodes a small / out-of-focus QR
+ * markedly better than the prior 512 with no perceptible cadence cost on the
+ * test phone; 2048 helped slightly more but risks low-end devices (4096 lagged),
+ * so 1024 is the safe default. Raise per-consumer via
+ * `startCameraFrameCapture({ captureSize })`.
+ *
+ * @see GpsPlusSlamJs_Docs/docs/2026-06-17-qr-size-accuracy-and-thin-demo-plan.md (WS-C)
+ */
+declare const DEFAULT_CAMERA_FRAME_CAPTURE_SIZE = 1024;
 /**
  * Extract the reset transform from an XRReferenceSpaceEvent-like object.
  *
@@ -371,6 +384,61 @@ declare function stopDepthCapture(): void;
  * Get the current depth sample count.
  */
 declare function getDepthSampleCount(): number;
+/** Optional tuning for {@link startCameraFrameCapture}. */
+interface CameraFrameCaptureConfig {
+  /** Detection cadence (ms between captures). Default 125 (~8 Hz). */
+  intervalMs?: number;
+  /**
+   * Longer-edge resolution (px) of the camera-frame blit. Default
+   * {@link DEFAULT_CAMERA_FRAME_CAPTURE_SIZE} (1024). The blit preserves the
+   * camera ASPECT with its longer edge at this value (e.g. 1024 → 1024×768 for a
+   * 4:3 camera), so the target reaches the detector undistorted. A QR needs ~3–5
+   * px per module; the on-device sweep settled on 1024 (512 made small QRs decode
+   * only at very close range). Applied before the first capture.
+   */
+  captureSize?: number;
+}
+/**
+ * Set the per-frame camera RGBA callback (B2) — the generic CV frame feed (QR
+ * detection today, object detection / OpenCV later). Call this BEFORE initAR to
+ * enable in-session camera frame capture; `startCameraFrameCapture` then begins
+ * delivering frames.
+ *
+ * The callback receives a **top-left-origin** RGBA image (no JPEG round-trip),
+ * captured at the throttled detection cadence — feed it straight to a
+ * `BarcodeDetector` / OpenCV front-end. Mirrors `setDepthCaptureCallback`.
+ *
+ * @param onFrame - Called with each throttled camera frame, or `null` to clear.
+ */
+declare function setCameraFrameCallback(onFrame: ((image: RgbaImage) => void) | null): void;
+/**
+ * Start camera frame capture during an AR session. Must call
+ * setCameraFrameCallback before initAR (the source is created there). No-op if
+ * the source was not initialized (callback not set before initAR).
+ *
+ * The source is the single cadence owner: drive your detection scheduler from
+ * the delivered frames with its own `minIntervalMs: 0` (Option A).
+ *
+ * @param config - optional cadence / blit-resolution overrides.
+ */
+declare function startCameraFrameCapture(config?: CameraFrameCaptureConfig): void;
+/**
+ * Stop camera frame capture. Safe to call when not running.
+ */
+declare function stopCameraFrameCapture(): void;
+/**
+ * Get the number of camera frames captured since the last
+ * `startCameraFrameCapture`.
+ */
+declare function getCameraFrameCount(): number;
+/**
+ * The current longer-edge resolution (px) of the camera-frame blit — the
+ * {@link DEFAULT_CAMERA_FRAME_CAPTURE_SIZE} default unless overridden via
+ * `startCameraFrameCapture({ captureSize })`. Exposed for diagnostics and to
+ * let tests assert the on-device-tuned default without reaching into module
+ * state.
+ */
+declare function getCameraFrameCaptureSize(): number;
 /**
  * Set a per-frame callback for custom updates.
  * The callback is invoked every XR frame after pose updates but before render.
@@ -386,4 +454,4 @@ declare function setFrameCallback(callback: (() => void) | null): void;
  */
 declare function getLiveCss3dManager(): Css3dRendererManager | null;
 //#endregion
-export { setScene as A, resetWebXRState as C, setDepthCaptureCallback as D, setCamera as E, shouldLogCameraAccessDiagnostic as F, startDepthCapture as I, startImageCapture as L, setTrackingLostCallback as M, setTrackingRecoveredCallback as N, setFrameCallback as O, setTrackingStore as P, stopDepthCapture as R, nueQuaternionToWebXR$1 as S, setArWorldGroup as T, getXrCameraFromPose as _, createSceneHierarchy as a, isXRCameraLike as b, extractResetTransformData as c, getCamera as d, getCurrentArPose as f, getScene as g, getLiveCss3dManager as h, buildSessionOptions as i, setTrackingCallbacks as j, setImageCaptureCallback as k, getArPose as l, getImageCaptureFrameCount as m, TrackingSubscribableStore as n, endARSession as o, getDepthSampleCount as p, applyAlignmentMatrix as r, extractPoseFromViewer as s, SessionFeatureOptions as t, getArWorldGroup as u, initAR as v, setArPose as w, nuePositionToWebXR as x, isWebXRSupported as y, stopImageCapture as z };
+export { setCamera as A, shouldLogCameraAccessDiagnostic as B, isWebXRSupported as C, resetWebXRState as D, nueQuaternionToWebXR$1 as E, setScene as F, stopDepthCapture as G, startDepthCapture as H, setTrackingCallbacks as I, stopImageCapture as K, setTrackingLostCallback as L, setDepthCaptureCallback as M, setFrameCallback as N, setArPose as O, setImageCaptureCallback as P, setTrackingRecoveredCallback as R, initAR as S, nuePositionToWebXR as T, startImageCapture as U, startCameraFrameCapture as V, stopCameraFrameCapture as W, getDepthSampleCount as _, applyAlignmentMatrix as a, getScene as b, endARSession as c, getArPose as d, getArWorldGroup as f, getCurrentArPose as g, getCameraFrameCount as h, TrackingSubscribableStore as i, setCameraFrameCallback as j, setArWorldGroup as k, extractPoseFromViewer as l, getCameraFrameCaptureSize as m, DEFAULT_CAMERA_FRAME_CAPTURE_SIZE as n, buildSessionOptions as o, getCamera as p, SessionFeatureOptions as r, createSceneHierarchy as s, CameraFrameCaptureConfig as t, extractResetTransformData as u, getImageCaptureFrameCount as v, isXRCameraLike as w, getXrCameraFromPose as x, getLiveCss3dManager as y, setTrackingStore as z };

package/dist/zip-coverage-embed-tFohI2J4.d.ts

@@ -0,0 +1,41 @@
+//#region ../src/storage/zip-coverage-embed.d.ts
+/**
+ * Zip Coverage Embed — write a recording's H3 coverage into its `session.json`.
+ *
+ * The map-centric browser indexes legacy recordings (those predating the
+ * `h3Cells` field) by reading their full GPS path — slow, and repeated on every
+ * folder open. This primitive lets a one-time "upgrade" embed the derived
+ * coverage **inside the recording's own `session.json`**, so the recording
+ * indexes instantly on every future open in this app *and any other reader*
+ * (the portability the user asked for; O3 — in-zip rewrite).
+ *
+ * It is a pure transform `(zip, cells, resolution) -> zip`: it reads every entry
+ * and re-emits a new zip identical to the input except that `session.json` gains
+ * `h3Cells` + `h3Resolution`. It never mutates anything in place — the caller
+ * (the RecorderApp backfill) owns the safe write-then-verify-then-overwrite
+ * protocol around it.
+ *
+ * @see ./zip-coverage-embed.ts.md
+ * @see GpsPlusSlamJs_Docs/docs/2026-06-14-followup-progressive-map-browser-indexing-and-backfill.md (B3)
+ */
+/**
+ * Return a new zip blob identical to `zip` except its `session.json` gains
+ * `h3Cells` + `h3Resolution`.
+ *
+ * **Skips (returns the input blob unchanged, by reference) when:**
+ *   - the zip has no `session.json` (nothing to embed into);
+ *   - `session.json` is present but unparseable (never write over a broken one);
+ *   - `session.json` already carries `h3Cells` (idempotent — re-running the
+ *     upgrade is a no-op, and new recordings are skipped).
+ *
+ * On any unexpected read/write failure it also returns the input untouched —
+ * it never emits a partial zip. Callers can detect a skip via reference
+ * equality (`result === zip`).
+ *
+ * Built on `@zip.js/zip.js` (the same library as the exporter) in store mode, so
+ * every non-`session.json` entry is re-emitted with byte-identical uncompressed
+ * content.
+ */
+declare function embedCoverageInSessionJson(zip: Blob, h3Cells: string[], h3Resolution: number): Promise<Blob>;
+//#endregion
+export { embedCoverageInSessionJson as t };

package/dist/{zip-export-G14hkSPG.d.ts → zip-export-DDWXInTR.d.ts}

@@ -78,24 +78,38 @@ interface ExportSessionAsZipOptions {
   readonly contributors?: readonly ZipExportContributor[];
 }
 /**
- * Export a session from OPFS as a ZIP blob.
+ * Export a flat-layout session from OPFS as a ZIP blob.
  *
  * The ZIP structure mirrors the OPFS session structure:
  * - session.json (at root)
  * - actions/000001.json, actions/000002.json, ...
  * - images/frame-000001.jpg, images/frame-000002.jpg, ... (legacy: frames/)
- * - refPoints/{h3}.json (only observations from this session, scenario layout only)
  *
- * Uses "store" mode (compression level 0) for fast packaging.
- *
- * Supports both flat and scenario-based layouts:
- * - `exportSessionAsZip(sessionName)` — flat layout (sessions/)
- * - `exportSessionAsZip(scenarioName, sessionName)` — scenario layout (scenarios/{name}/)
+ * Uses "store" mode (compression level 0) for fast packaging. Consumers with a
+ * different on-disk layout (one that nests sessions under a named bucket)
+ * resolve their own session handle and call {@link exportSessionHandleAsZip}.
  *
+ * @param sessionName - Name of the session folder under `sessions/`.
  * @returns ZIP export result with blob and file count
- * @throws Error if session not found
+ * @throws Error if the session is not found
+ */
+declare function exportSessionAsZip(sessionName: string, options?: ExportSessionAsZipOptions): Promise<ZipExportResult>;
+/**
+ * Stream an already-resolved session directory handle to a ZIP blob, running
+ * any caller-supplied extension {@link ZipExportContributor}s after the
+ * framework-owned files.
+ *
+ * This is the layout-agnostic core of {@link exportSessionAsZip}: consumers
+ * that resolve a session directory handle themselves (e.g. an app that nests
+ * sessions under its own grouping layer) call this directly so the framework's
+ * ZIP schema stays the single source of truth without the framework needing to
+ * know how the handle was located.
+ *
+ * @param sessionHandle - The session directory to package (must contain the
+ *   framework-owned `session.json` / `actions/` / `images/` tree).
+ * @returns ZIP export result with blob and file count.
  */
-declare function exportSessionAsZip(scenarioNameOrSessionName: string, sessionName?: string, options?: ExportSessionAsZipOptions): Promise<ZipExportResult>;
+declare function exportSessionHandleAsZip(sessionHandle: FileSystemDirectoryHandle, options?: ExportSessionAsZipOptions): Promise<ZipExportResult>;
 /**
  * Sync current OPFS session data to an external file handle.
  *
@@ -109,12 +123,11 @@ declare function exportSessionAsZip(scenarioNameOrSessionName: string, sessionNa
  * the last synced ZIP contains all data up to that point.
  *
  * @param fileHandle - File handle from showSaveFilePicker
- * @param scenarioName - Name of the scenario
- * @param sessionName - Name of the session folder
+ * @param sessionName - Name of the session folder under `sessions/`
  * @returns ZIP export result with blob and file count
- * @throws Error if scenario or session not found
+ * @throws Error if the session is not found
  */
-declare function syncToExternalZip(fileHandle: FileSystemFileHandle, scenarioName: string, sessionName: string, options?: ExportSessionAsZipOptions): Promise<ZipExportResult>;
+declare function syncToExternalZip(fileHandle: FileSystemFileHandle, sessionName: string, options?: ExportSessionAsZipOptions): Promise<ZipExportResult>;
 /**
  * Trigger a file download in the browser.
  *
@@ -125,14 +138,5 @@ declare function syncToExternalZip(fileHandle: FileSystemFileHandle, scenarioNam
  * @param filename - Suggested filename
  */
 declare function downloadZip(blob: Blob, filename: string): Promise<void>;
-/**
- * Export and download a session in one step.
- *
- * Convenience function combining exportSessionAsZip and downloadZip.
- *
- * @param scenarioName - Name of the scenario
- * @param sessionName - Name of the session folder
- */
-declare function exportAndDownloadSession(scenarioName: string, sessionName: string): Promise<void>;
 //#endregion
-export { downloadZip as a, syncToExternalZip as c, ZipExportResult as i, ZipContributorAddFile as n, exportAndDownloadSession as o, ZipExportContributor as r, exportSessionAsZip as s, ExportSessionAsZipOptions as t };
+export { downloadZip as a, syncToExternalZip as c, ZipExportResult as i, ZipContributorAddFile as n, exportSessionAsZip as o, ZipExportContributor as r, exportSessionHandleAsZip as s, ExportSessionAsZipOptions as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gps-plus-slam-app-framework",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Reusable AR+GPS app framework layer — WebXR session management, Three.js visualization, GPS sensors, storage abstractions, replay engine, and store wiring for gps-plus-slam-js.",
   "type": "module",
   "files": [
@@ -36,7 +36,7 @@
   "dependencies": {
     "@reduxjs/toolkit": "^2.11.2",
     "gl-matrix": "3.4.4",
-    "gps-plus-slam-js": "^1.3.0"
+    "gps-plus-slam-js": "^1.4.0"
   },
   "peerDependencies": {
     "@sentry/browser": ">=10.0.0",

package/dist/concurrency-CO1FQvs3.d.ts

@@ -1,24 +0,0 @@
-//#region ../src/utils/concurrency.d.ts
-/**
- * Concurrency Utilities
- *
- * Provides helpers for limiting the number of concurrent async operations.
- * Used to prevent excessive memory consumption when scanning many files
- * in parallel (e.g., reading zip metadata during scenario discovery).
- */
-/**
- * Map over an array with a concurrency limit on the async mapper function.
- *
- * Behaves like `Promise.all(items.map(fn))` but limits how many mapper
- * invocations run simultaneously. Results are returned in the same order
- * as the input items.
- *
- * @param items - Array of items to process
- * @param limit - Maximum number of concurrent mapper invocations
- * @param mapper - Async function to apply to each item
- * @returns Array of results in the same order as input items
- * @throws Re-throws the first error from any mapper invocation (fail-fast)
- */
-declare function mapWithConcurrencyLimit<T, R>(items: T[], limit: number, mapper: (item: T, index: number) => Promise<R>): Promise<R[]>;
-//#endregion
-export { mapWithConcurrencyLimit as t };

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

@@ -1,114 +0,0 @@
-import { n as SessionMetadata } from "./opfs-storage-D5zAn_lx.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>;
-/**
- * Result of clearing the reference-point cache across all scenarios.
- */
-interface ClearRefPointsCacheResult {
-  /** Number of scenarios whose `refPoints/` directory was deleted. */
-  readonly scenariosCleared: number;
-  /** Total number of scenarios scanned (including ones with no cache). */
-  readonly scenariosScanned: number;
-  /** Names of scenarios that failed to clear, with reason. */
-  readonly errors: {
-    scenarioName: string;
-    reason: string;
-  }[];
-}
-/**
- * Clear the cached `refPoints/` directory for every scenario in OPFS.
- *
- * Used by the "Clear Reference Point Cache" maintenance action so that the
- * next scenario load re-imports ref points from the read folder's `*.zip`
- * recordings (see ref-point-recovery in the recorder app).
- *
- * Failures for individual scenarios are collected in `errors` rather than
- * aborting the whole operation — partial progress is still useful.
- *
- * @throws Error if OPFS storage is unavailable (e.g. `initStorage()` not yet
- *   called, or browser does not support OPFS). Surfacing this loudly avoids
- *   reporting a silent "0 scenarios cleared" success that would mask the
- *   real failure to the user.
- */
-declare function clearRefPointsCacheForAllScenarios(): Promise<ClearRefPointsCacheResult>;
-//#endregion
-export { getCurrentScenarioHandle as a, resetForNewSession as c, startSession as d, verifyWriteAccess as f, writeSessionMetadata as h, ensureScenarioDirectory as i, resetStorageState as l, writeFrame as m, WriteAccessResult as n, initStorage as o, writeAction as p, clearRefPointsCacheForAllScenarios as r, listSessions as s, ClearRefPointsCacheResult as t, setCurrentScenario as u };

package/dist/recording-options-DJBXuMxV.d.ts

@@ -1,182 +0,0 @@
-//#region ../src/state/recording-options.d.ts
-/**
- * Recording Options - User-configurable settings for data capture.
- *
- * Allows users to disable/configure high-frequency data streams
- * (depth sampling, image capture) to improve performance on lower-end devices.
- *
- * Options persist in localStorage across sessions.
- */
-/**
- * Input type for validateRecordingOptions allowing partial nested objects.
- * This allows passing incomplete objects that will be merged with defaults.
- */
-interface RecordingOptionsInput {
-  depth?: Partial<DepthCaptureOptions>;
-  images?: Partial<ImageCaptureOptions>;
-  arCrashIsolation?: Partial<ArCrashIsolationOptions>;
-}
-/**
- * Diagnostic flags for isolating pre-recording AR startup crashes.
- * These gates affect XR session negotiation and frame-loop behavior,
- * independently of recording-time image/depth capture.
- */
-interface ArCrashIsolationOptions {
-  enableDomOverlay: boolean;
-  enableCameraAccess: boolean;
-  enableDepthSensingFeature: boolean;
-  enableCss3dRenderer: boolean;
-  enableCameraTextureAcquisition: boolean;
-  /**
-   * Apply the Chromium WebXR camera-access tab-crash workaround at app
-   * bootstrap. The workaround always deletes
-   * `XRWebGLBinding.prototype.createProjectionLayer` /
-   * `XRRenderState.prototype.layers` (forcing `XRWebGLLayer`) — required on
-   * every affected Chrome build observed on-device, including Chrome 150 — and
-   * additionally persists the `baseLayer` across
-   * `XRSession.prototype.updateRenderState` only for Chrome builds inside the
-   * affected window (148.0.7778.12 up to 149.0.7821).
-   *
-   * Default `true`. Opt-out is offered because forcing `XRWebGLLayer` may break
-   * WebXR on unaffected (e.g. Quest) devices.
-   *
-   * @see GpsPlusSlamJs_AppFramework/src/ar/chromium-camera-access-workaround.ts
-   * @see https://github.com/mrdoob/three.js/issues/33404
-   */
-  applyChromiumProjectionLayerWorkaround: boolean;
-}
-/**
- * Configuration for depth sampling during recording.
- */
-interface DepthCaptureOptions {
-  /** Whether to capture depth samples. Default: true */
-  enabled: boolean;
-  /** Interval between samples in milliseconds. Default: 1000 */
-  intervalMs: number;
-  /**
-   * Grid size (N×N points per sample). Default: 16 — dense enough to
-   * populate the AR-space occupancy grid (2026-06-11 port plan §1).
-   */
-  gridSize: number;
-  /**
-   * Whether to enrich each depth point with the camera color at its view
-   * coordinates (RGB voxel coloring, occupancy-grid port plan Iter 8).
-   * Costs one small GPU blit+readback per sample (~1 Hz); when off, the
-   * occupancy cubes keep the height-based coloring. Default: true.
-   */
-  rgb: boolean;
-}
-/**
- * Configuration for image capture during recording.
- */
-interface ImageCaptureOptions {
-  /** Whether to capture images. Default: true */
-  enabled: boolean;
-  /** Interval between captures in milliseconds. Default: 2000 */
-  intervalMs: number;
-  /** JPEG quality (0.0 - 1.0). Default: 0.7 */
-  quality: number;
-  /** Resolution divisor: 1 = full native resolution, 2 = half, 4 = quarter. Default: 1 */
-  resolutionDivisor: number;
-}
-/**
- * User-configurable recording options.
- * Persisted to localStorage for cross-session consistency.
- */
-interface RecordingOptions {
-  /** Depth sampling configuration */
-  depth: DepthCaptureOptions;
-  /** Image capture configuration */
-  images: ImageCaptureOptions;
-  /** Diagnostic flags for pre-recording AR crash isolation */
-  arCrashIsolation: ArCrashIsolationOptions;
-}
-/**
- * localStorage key for persisted options.
- *
- * **Multi-tab caveat:** All tabs/instances sharing the same origin will
- * read and write this key. In multi-tab or embedded scenarios, concurrent
- * saves can silently overwrite each other. Use a custom `storageKey`
- * parameter in `loadRecordingOptions` / `saveRecordingOptions` to isolate
- * instances when needed.
- */
-declare const STORAGE_KEY = "gps-plus-slam-recorder-options";
-/** Default recording options (all streams enabled) */
-declare const DEFAULT_RECORDING_OPTIONS: RecordingOptions;
-/** Validation constraints for depth options */
-declare const DEPTH_CONSTRAINTS: {
-  readonly intervalMs: {
-    readonly min: 500;
-    readonly max: 5000;
-    readonly step: 100;
-  };
-  readonly gridSize: {
-    readonly min: 2;
-    readonly max: 32;
-    readonly step: 1;
-  };
-};
-/** Validation constraints for image options */
-declare const IMAGE_CONSTRAINTS: {
-  readonly intervalMs: {
-    readonly min: 1000;
-    readonly max: 10000;
-    readonly step: 500;
-  };
-  readonly quality: {
-    readonly min: 0.3;
-    readonly max: 1;
-    readonly step: 0.1;
-  };
-  readonly resolutionDivisor: {
-    readonly min: 1;
-    readonly max: 8;
-    readonly step: 1;
-  };
-};
-/**
- * Validate and normalize AR crash isolation flags.
- * Missing or invalid values fall back to defaults.
- */
-declare function validateArCrashIsolationOptions(options: Partial<ArCrashIsolationOptions>): ArCrashIsolationOptions;
-/**
- * Validate and normalize depth options.
- * Invalid values are clamped to valid ranges.
- */
-declare function validateDepthOptions(options: Partial<DepthCaptureOptions>): DepthCaptureOptions;
-/**
- * Validate and normalize image options.
- * Invalid values are clamped to valid ranges.
- */
-declare function validateImageOptions(options: Partial<ImageCaptureOptions>): ImageCaptureOptions;
-/**
- * Validate and normalize a full RecordingOptions object.
- * Merges with defaults and clamps invalid values.
- */
-declare function validateRecordingOptions(options: RecordingOptionsInput): RecordingOptions;
-/**
- * Load recording options from localStorage.
- * Returns defaults if no saved options exist or parsing fails.
- * Validates and merges with defaults to handle schema evolution.
- * @param storageKey - Optional custom localStorage key (defaults to STORAGE_KEY).
- */
-declare function loadRecordingOptions(storageKey?: string): RecordingOptions;
-/**
- * Save recording options to localStorage.
- * Options are validated before saving.
- * @param storageKey - Optional custom localStorage key (defaults to STORAGE_KEY).
- */
-declare function saveRecordingOptions(options: RecordingOptions, storageKey?: string): void;
-/**
- * Reset recording options to defaults.
- * Clears localStorage and returns default options.
- * @param storageKey - Optional custom localStorage key (defaults to STORAGE_KEY).
- */
-declare function resetRecordingOptions(storageKey?: string): RecordingOptions;
-/**
- * Create a deep copy of recording options.
- * Useful for creating mutable copies of the frozen defaults.
- */
-declare function cloneRecordingOptions(options: RecordingOptions): RecordingOptions;
-//#endregion
-export { validateRecordingOptions as _, IMAGE_CONSTRAINTS as a, RecordingOptionsInput as c, loadRecordingOptions as d, resetRecordingOptions as f, validateImageOptions as g, validateDepthOptions as h, DepthCaptureOptions as i, STORAGE_KEY as l, validateArCrashIsolationOptions as m, DEFAULT_RECORDING_OPTIONS as n, ImageCaptureOptions as o, saveRecordingOptions as p, DEPTH_CONSTRAINTS as r, RecordingOptions as s, ArCrashIsolationOptions as t, cloneRecordingOptions as u };

package/dist/recording-slice-89O07ebs.d.ts

@@ -1,36 +0,0 @@
-import { i as DepthSample } from "./ar-types-Dan1MVTi.js";
-import { s as RecordingOptions } from "./recording-options-DJBXuMxV.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;
-  /**
-   * The most recent depth sample, kept ONLY so subscribers can observe new
-   * samples via reference comparison (the AR-space occupancy grid is fed
-   * this way — see the 2026-06-11 occupancy-grid port plan). The persisted
-   * action stream remains the source of truth; no history is kept here.
-   * The payload stays in raw WebXR coordinates — conversion-free.
-   */
-  latestDepthSample: DepthSample | null;
-}
-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/storage/file-system.d.ts

@@ -1,2 +0,0 @@
-import { a as getCurrentScenarioHandle, c as resetForNewSession, d as startSession, f as verifyWriteAccess, h as writeSessionMetadata, i as ensureScenarioDirectory, l as resetStorageState, m as writeFrame, n as WriteAccessResult, o as initStorage, p as writeAction, r as clearRefPointsCacheForAllScenarios, s as listSessions, t as ClearRefPointsCacheResult, u as setCurrentScenario } from "../file-system-CwXTNHmB.js";
-export { ClearRefPointsCacheResult, WriteAccessResult, clearRefPointsCacheForAllScenarios, ensureScenarioDirectory, getCurrentScenarioHandle, initStorage, listSessions, resetForNewSession, resetStorageState, setCurrentScenario, startSession, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata };