gps-plus-slam-app-framework 1.9.1 → 1.11.0

package/README.md

@@ -262,19 +262,19 @@ that guard's `APP_OVERLAY_CONTRACTS` list.
 
 WebXR session lifecycle, Three.js renderer setup, image/depth capture, replay scene management.
 
-| Export                                         | Description                                                                                                                                                                                                                                                             |
-| ---------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `initAR(container, isolation?, features?)`     | Start a WebXR AR session with Three.js rendering. `features.requestHitTest` opts the session into the WebXR `hit-test` feature                                                                                                                                          |
-| `endARSession()`                               | End the active XR session                                                                                                                                                                                                                                               |
-| `createEnableGpsArController()`                | Headless "Enable GPS AR" orchestration (support check + permission bundling + sensor watches + `initAR`) with observable state; the app renders its own button over it                                                                                                  |
-| `registerXrFrameUpdate(cb)`                    | Per-frame access to the live `XRFrame` + reference space + session (valid only synchronously inside the callback). Enables app-side hit-test / other WebXR features                                                                                                     |
-| `isFullySupported(s)` / `capabilityMessage(s)` | WebXR + geolocation capability gating + a user-facing message                                                                                                                                                                                                           |
-| `startImageCapture()` / `stopImageCapture()`   | Toggle camera frame capture                                                                                                                                                                                                                                             |
-| `ImageCaptureManager`                          | Configurable camera frame capture pipeline                                                                                                                                                                                                                              |
-| `DepthSampler`                                 | Depth buffer sampling with configurable grids                                                                                                                                                                                                                           |
-| `CameraBlitCapture`                            | GPU blit-based camera capture                                                                                                                                                                                                                                           |
-| `initReplayScene(container)`                   | Create a 3D replay scene with orbit/FPS controls                                                                                                                                                                                                                        |
-| `applyChromiumProjectionLayerWorkaround`       | Chromium camera-access tab-crash workaround. Always deletes projection-layer hooks (forces `XRWebGLLayer`; required on every affected build incl. Chrome 150) and additionally persists `baseLayer` only on the affected Chrome window (148.0.7778.12 up to 149.0.7821) |
+| Export                                                 | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `initAR(container, isolation?, features?, callbacks?)` | Start a WebXR AR session with Three.js rendering. `features.requestHitTest` opts the session into the WebXR `hit-test` feature. `callbacks` (`ArSessionCallbacks`) carries ALL per-session host callbacks — `imageCapture`, `tracking` (store + callbacks together), `depth`, `cameraFrame`, `onFrame`, `onSessionEnd` — replacing the former pre-init setter exports; re-pass it with each session (cleared at session end). `rebindTrackingStore(store)` remains for the one mid-session need (swapping the tracking store per recording) |
+| `endARSession()`                                       | End the active XR session                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `createEnableGpsArController()`                        | Headless "Enable GPS AR" orchestration (support check + permission bundling + sensor watches + `initAR`) with observable state; the app renders its own button over it                                                                                                                                                                                                                                                                                                                                                                      |
+| `registerXrFrameUpdate(cb)`                            | Per-frame access to the live `XRFrame` + reference space + session (valid only synchronously inside the callback). Enables app-side hit-test / other WebXR features                                                                                                                                                                                                                                                                                                                                                                         |
+| `isFullySupported(s)` / `capabilityMessage(s)`         | WebXR + geolocation capability gating + a user-facing message                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `startImageCapture()` / `stopImageCapture()`           | Toggle camera frame capture                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `ImageCaptureManager`                                  | Configurable camera frame capture pipeline                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `DepthSampler`                                         | Depth buffer sampling with configurable grids                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `CameraBlitCapture`                                    | GPU blit-based camera capture                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `initReplayScene(container)`                           | Create a 3D replay scene with orbit/FPS controls                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `applyChromiumProjectionLayerWorkaround`               | Chromium camera-access tab-crash workaround. Always deletes projection-layer hooks (forces `XRWebGLLayer`; required on every affected build incl. Chrome 150) and additionally persists `baseLayer` only on the affected Chrome window (148.0.7778.12 up to 149.0.7821)                                                                                                                                                                                                                                                                     |
 
 ### `sensors/` — GPS & Permissions
 
@@ -341,7 +341,6 @@ H3-based proximity matching for GPS-anchored points (renamed from `ref-points/`
 | Export                         | Description                                            |
 | ------------------------------ | ------------------------------------------------------ |
 | `LeafletMapOverlay`            | 2D Leaflet map integrated via CSS3D into a 3D scene.   |
-| `MapOverlay`                   | Tile-based 3D map overlay (no Leaflet dependency).     |
 | `GpsEventVisualizer`           | Three.js spheres for GPS event positions.              |
 | `createAlignmentLerper()`      | Smooth alignment matrix interpolation.                 |
 | `createCameraFollower()`       | Camera that tracks a moving target.                    |
@@ -392,6 +391,7 @@ pnpm run build     # build with tsdown
 ```
 src/
 ├── ar/             # WebXR session, capture, replay scene
+│   └── qr/         # QR detection, pose (planar PnP), size-from-depth, GPS vote
 ├── sensors/        # GPS, orientation, permissions
 ├── state/          # createSlamAppStore, recording, replay, persistence middleware
 ├── storage/        # OPFS, ZIP export/import, StorageBackend

package/dist/{absolute-orientation-BAxc15J6.d.ts → absolute-orientation-Dj1One3y.d.ts}

@@ -3,7 +3,7 @@
  * AbsoluteOrientationSensor capture (Generic Sensor API).
  *
  * Phase 1 of the AbsoluteOrientationSensor plan
- * (GpsPlusSlamJs_Docs/docs/2026-06-25-absolute-orientation-sensor-plan.md §5.1):
+ * (GpsPlusSlamJs_Docs/docs/2026-06-25-0543-absolute-orientation-sensor-plan.md §5.1):
  * passive instrumentation that fuses accelerometer + gyroscope + magnetometer
  * into an Earth-referenced (ENU) quaternion, captured per GPS event as an
  * independent north reference. No production behaviour change.

package/dist/{accuracy-circles-DkWBkF5g.d.ts → accuracy-circles-BHz7yVIL.d.ts}

@@ -16,7 +16,7 @@ import L from "leaflet";
  * @deprecated Stroke-only since 2026-06-28 (Finding 1) — accuracy circles no
  * longer render a fill, so this opacity is unused. Retained as an exported
  * constant only to preserve the published API surface; do not pass it to
- * `L.circle`. See `2026-06-28-map-rings-transparency-and-view-direction-user-feedback.md`.
+ * `L.circle`. See `2026-06-28-1822-map-rings-transparency-and-view-direction-user-feedback.md`.
  */
 declare const ACCURACY_CIRCLE_FILL_OPACITY = 0.12;
 declare const ACCURACY_CIRCLE_STROKE_OPACITY = 0.5;

package/dist/{alignment-lerper-gD70k7Fq.d.ts → alignment-lerper-DAHicRON.d.ts}

@@ -18,12 +18,6 @@ interface AlignmentLerper {
   /** Lifecycle cleanup (no-op — lerper does not own arWorldGroup). */
   dispose(): void;
 }
-/**
- * Create an AlignmentLerper that drives arWorldGroup.matrix smoothly.
- *
- * @param arWorldGroup The group whose matrix is interpolated.
- * @param lerpRate     Lerp speed multiplier (default 8).
- */
 declare function createAlignmentLerper(arWorldGroup: THREE.Object3D, lerpRate?: number): AlignmentLerper;
 //#endregion
 export { createAlignmentLerper as n, AlignmentLerper as t };

package/dist/{app-selectors-BbAiCRUT.d.ts → app-selectors-DG0ZqaeI.d.ts}

@@ -1,11 +1,21 @@
-import { N as CombinedRootState, r as SlamAppRootState } from "./create-slam-app-store-D1QSMuKu.js";
+import { N as CombinedRootState } from "./create-slam-app-store-DFm5K9Ob.js";
 import * as _$gps_plus_slam_js0 from "gps-plus-slam-js";
 import { ArImageCapture, GpsPoint, LatLong, Matrix4, Quaternion, Vector3 } from "gps-plus-slam-js";
 import * as _$_reduxjs_toolkit0 from "@reduxjs/toolkit";
 
 //#region ../src/state/app-selectors.d.ts
+/**
+ * Minimal root these selectors read (quality-review G-2). Typed as a Pick of
+ * the `gpsData` slice ONLY, so ANY consumer store that mounts the library's
+ * gpsData reducer is structurally assignable — the former full
+ * `CombinedRootState` parameter forced `as unknown as` casts (MinimalExample),
+ * a `sel()` helper (AnchorStarter), or a re-declared root type (RecorderApp)
+ * in every consumer, and a renamed slice would have compiled and failed at
+ * runtime.
+ */
+type RootWithGpsData = Pick<CombinedRootState, 'gpsData'>;
 /** Alignment matrix (4×4), or null if not yet computed. */
-declare const selectAlignmentMatrix: ((state: SlamAppRootState & {}) => Matrix4 | null) & {
+declare const selectAlignmentMatrix: ((state: RootWithGpsData) => Matrix4 | null) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -17,7 +27,7 @@ declare const selectAlignmentMatrix: ((state: SlamAppRootState & {}) => Matrix4
     resetResultsCount: () => void;
   };
   lastResult: () => Matrix4 | null;
-  dependencies: [(state: CombinedRootState) => _$gps_plus_slam_js0.GpsModel | null];
+  dependencies: [(state: RootWithGpsData) => _$gps_plus_slam_js0.GpsModel | null];
   recomputations: () => number;
   resetRecomputations: () => void;
   dependencyRecomputations: () => number;
@@ -27,7 +37,7 @@ declare const selectAlignmentMatrix: ((state: SlamAppRootState & {}) => Matrix4
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
 /** Recorded GPS positions with metadata. */
-declare const selectGpsPositions: ((state: SlamAppRootState & {}) => readonly GpsPoint[]) & {
+declare const selectGpsPositions: ((state: RootWithGpsData) => readonly GpsPoint[]) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -39,7 +49,7 @@ declare const selectGpsPositions: ((state: SlamAppRootState & {}) => readonly Gp
     resetResultsCount: () => void;
   };
   lastResult: () => readonly GpsPoint[];
-  dependencies: [(state: CombinedRootState) => _$gps_plus_slam_js0.GpsModel | null];
+  dependencies: [(state: RootWithGpsData) => _$gps_plus_slam_js0.GpsModel | null];
   recomputations: () => number;
   resetRecomputations: () => void;
   dependencyRecomputations: () => number;
@@ -49,7 +59,7 @@ declare const selectGpsPositions: ((state: SlamAppRootState & {}) => readonly Gp
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
 /** Recorded odometry positions (AR-local space). */
-declare const selectOdometryPositions: ((state: SlamAppRootState & {}) => readonly Vector3[]) & {
+declare const selectOdometryPositions: ((state: RootWithGpsData) => readonly Vector3[]) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -61,7 +71,7 @@ declare const selectOdometryPositions: ((state: SlamAppRootState & {}) => readon
     resetResultsCount: () => void;
   };
   lastResult: () => readonly Vector3[];
-  dependencies: [(state: CombinedRootState) => _$gps_plus_slam_js0.GpsModel | null];
+  dependencies: [(state: RootWithGpsData) => _$gps_plus_slam_js0.GpsModel | null];
   recomputations: () => number;
   resetRecomputations: () => void;
   dependencyRecomputations: () => number;
@@ -71,7 +81,7 @@ declare const selectOdometryPositions: ((state: SlamAppRootState & {}) => readon
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
 /** Recorded odometry rotations (AR-local space). */
-declare const selectOdometryRotations: ((state: SlamAppRootState & {}) => readonly Quaternion[]) & {
+declare const selectOdometryRotations: ((state: RootWithGpsData) => readonly Quaternion[]) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -83,7 +93,7 @@ declare const selectOdometryRotations: ((state: SlamAppRootState & {}) => readon
     resetResultsCount: () => void;
   };
   lastResult: () => readonly Quaternion[];
-  dependencies: [(state: CombinedRootState) => _$gps_plus_slam_js0.GpsModel | null];
+  dependencies: [(state: RootWithGpsData) => _$gps_plus_slam_js0.GpsModel | null];
   recomputations: () => number;
   resetRecomputations: () => void;
   dependencyRecomputations: () => number;
@@ -93,7 +103,7 @@ declare const selectOdometryRotations: ((state: SlamAppRootState & {}) => readon
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
 /** GPS zero reference (origin for coordinate conversion), or null. */
-declare const selectZeroReference: ((state: SlamAppRootState & {}) => LatLong | null) & {
+declare const selectZeroReference: ((state: RootWithGpsData) => LatLong | null) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -105,7 +115,7 @@ declare const selectZeroReference: ((state: SlamAppRootState & {}) => LatLong |
     resetResultsCount: () => void;
   };
   lastResult: () => LatLong | null;
-  dependencies: [(state: CombinedRootState) => _$gps_plus_slam_js0.GpsModel | null];
+  dependencies: [(state: RootWithGpsData) => _$gps_plus_slam_js0.GpsModel | null];
   recomputations: () => number;
   resetRecomputations: () => void;
   dependencyRecomputations: () => number;
@@ -114,7 +124,7 @@ declare const selectZeroReference: ((state: SlamAppRootState & {}) => LatLong |
   memoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
-declare const selectFrameTilesInWebXR: ((state: SlamAppRootState & {}) => readonly ArImageCapture[]) & {
+declare const selectFrameTilesInWebXR: ((state: RootWithGpsData) => readonly ArImageCapture[]) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
@@ -126,7 +136,7 @@ declare const selectFrameTilesInWebXR: ((state: SlamAppRootState & {}) => readon
     resetResultsCount: () => void;
   };
   lastResult: () => readonly ArImageCapture[];
-  dependencies: [(state: CombinedRootState) => ArImageCapture[] | undefined];
+  dependencies: [(state: RootWithGpsData) => ArImageCapture[] | undefined];
   recomputations: () => number;
   resetRecomputations: () => void;
   dependencyRecomputations: () => number;

package/dist/ar/ar-crash-isolation.d.ts

@@ -0,0 +1,2 @@
+import { n as DEFAULT_AR_CRASH_ISOLATION, r as validateArCrashIsolationOptions, t as ArCrashIsolationOptions } from "../ar-crash-isolation-DlXCGzMf.js";
+export { ArCrashIsolationOptions, DEFAULT_AR_CRASH_ISOLATION, validateArCrashIsolationOptions };

package/dist/ar/ar-crash-isolation.js

@@ -0,0 +1,40 @@
+//#region ../src/ar/ar-crash-isolation.ts
+/** Default AR-crash-isolation flags (all features enabled). */
+const DEFAULT_AR_CRASH_ISOLATION = {
+	enableDomOverlay: true,
+	enableCameraAccess: true,
+	enableDepthSensingFeature: true,
+	enableCss3dRenderer: true,
+	enableCameraTextureAcquisition: true,
+	applyChromiumProjectionLayerWorkaround: true
+};
+/**
+* Boolean-or-default (quality-review C-1): persisted/external values are
+* untrusted, so anything that is not a real boolean falls back to the
+* default. Local copy of the recorder catalog's helper — the validator must
+* stay dependency-free so the framework owns the whole group.
+*/
+function boolOr(value, fallback) {
+	return typeof value === "boolean" ? value : fallback;
+}
+/**
+* Validate and normalize AR crash isolation flags.
+* Missing or invalid values fall back to defaults. The container itself is as
+* untrusted as its fields (persisted blobs may lack the key entirely or hold
+* `null`), so a nullish container yields the full defaults instead of
+* throwing.
+*/
+function validateArCrashIsolationOptions(rawOptions) {
+	const options = rawOptions ?? {};
+	const defaults = DEFAULT_AR_CRASH_ISOLATION;
+	return {
+		enableDomOverlay: boolOr(options.enableDomOverlay, defaults.enableDomOverlay),
+		enableCameraAccess: boolOr(options.enableCameraAccess, defaults.enableCameraAccess),
+		enableDepthSensingFeature: boolOr(options.enableDepthSensingFeature, defaults.enableDepthSensingFeature),
+		enableCss3dRenderer: boolOr(options.enableCss3dRenderer, defaults.enableCss3dRenderer),
+		enableCameraTextureAcquisition: boolOr(options.enableCameraTextureAcquisition, defaults.enableCameraTextureAcquisition),
+		applyChromiumProjectionLayerWorkaround: boolOr(options.applyChromiumProjectionLayerWorkaround, defaults.applyChromiumProjectionLayerWorkaround)
+	};
+}
+//#endregion
+export { DEFAULT_AR_CRASH_ISOLATION, validateArCrashIsolationOptions };

package/dist/ar/bresenham3d.d.ts

@@ -1,2 +1,2 @@
-import { n as MAX_TRACE_STEPS, r as bresenham3d, t as GridCell } from "../bresenham3d-DGc4nIb-.js";
+import { n as MAX_TRACE_STEPS, r as bresenham3d, t as GridCell } from "../bresenham3d-D-t9i_b5.js";
 export { GridCell, MAX_TRACE_STEPS, bresenham3d };

package/dist/ar/camera-blit-capture.d.ts

@@ -1,2 +1,2 @@
-import { a as computeCaptureSize, i as computeAspectFitSize, n as CameraBlitCaptureConfig, r as DEFAULT_BLIT_CONFIG, t as CameraBlitCapture } from "../camera-blit-capture-BimSdyih.js";
+import { a as computeCaptureSize, i as computeAspectFitSize, n as CameraBlitCaptureConfig, r as DEFAULT_BLIT_CONFIG, t as CameraBlitCapture } from "../camera-blit-capture-BlC-arRb.js";
 export { CameraBlitCapture, CameraBlitCaptureConfig, DEFAULT_BLIT_CONFIG, computeAspectFitSize, computeCaptureSize };

package/dist/ar/capability-checker.d.ts

@@ -1,2 +1,2 @@
-import { i as isFullySupported, n as CapabilitySupport, r as capabilityMessage, t as CapabilityMessageOptions } from "../capability-checker-BTTpygvZ.js";
+import { i as isFullySupported, n as CapabilitySupport, r as capabilityMessage, t as CapabilityMessageOptions } from "../capability-checker-BZ3_x1YL.js";
 export { CapabilityMessageOptions, CapabilitySupport, capabilityMessage, isFullySupported };

package/dist/ar/capture-failure-tracker.d.ts

@@ -1,2 +1,2 @@
-import { a as createCaptureFailureTracker, i as DEFAULT_CAPTURE_TRACKER_CONFIG, n as CaptureFailureTracker, r as CaptureFailureTrackerConfig, t as CAPTURE_FAILURE_WARNING } from "../capture-failure-tracker-_BVfhpxv.js";
+import { a as createCaptureFailureTracker, i as DEFAULT_CAPTURE_TRACKER_CONFIG, n as CaptureFailureTracker, r as CaptureFailureTrackerConfig, t as CAPTURE_FAILURE_WARNING } from "../capture-failure-tracker-BAUKjtXU.js";
 export { CAPTURE_FAILURE_WARNING, CaptureFailureTracker, CaptureFailureTrackerConfig, DEFAULT_CAPTURE_TRACKER_CONFIG, createCaptureFailureTracker };

package/dist/ar/capture-motion-gate.d.ts

@@ -0,0 +1,2 @@
+import { a as MotionWindow, i as MotionFilterConfig, n as DEFAULT_MOTION_FILTER, o as decideCapture, r as DEFAULT_MOTION_WINDOW_SIZE, t as CaptureDecisionInput } from "../capture-motion-gate-CPwLekNf.js";
+export { CaptureDecisionInput, DEFAULT_MOTION_FILTER, DEFAULT_MOTION_WINDOW_SIZE, MotionFilterConfig, MotionWindow, decideCapture };

package/dist/{capture-motion-gate-_NdTSwKi.js → ar/capture-motion-gate.js}

@@ -1,3 +1,26 @@
+//#region ../src/ar/capture-motion-gate.ts
+/**
+* Capture motion gate — the policy that decides whether a *due* capture should
+* fire on the current frame or be deferred until the device settles.
+*
+* Two cohesive pieces, both pure/deterministic and unit-testable in isolation
+* from `ImageCaptureManager`:
+*  - {@link decideCapture} — the stateless capture-vs-defer decision over the
+*    windowed motion maxima, the thresholds, and the time since the capture
+*    became due (the never-calm safety fallback).
+*  - {@link MotionWindow} — a tiny fixed-size ring of recent per-frame
+*    velocities with glitch rejection, so the decision judges "max over the
+*    last N frames" rather than one lucky-calm sample.
+*
+* The window size and glitch ceilings are INTERNAL constants, deliberately not
+* user-facing config: the user-facing surface is only enabled / maxAngular /
+* maxLinear / maxWaitMs (plan §5.1). Keeping the stateful policy here (not in a
+* speculative framework-wide service) matches the plan's §4.1 scope note.
+*
+* @see GpsPlusSlamJs_Docs/docs/2026-06-23-2105-blurry-frame-motion-gating-plan.md §4.2-4.4
+*/
+/** Default number of recent frames the gate judges motion over (~50 ms @ 60fps). */
+const DEFAULT_MOTION_WINDOW_SIZE = 3;
 /**
 * Angular velocity (rad/s) above which a sample is treated as a tracking glitch
 * (e.g. relocalization teleport), not real motion. A genuine hand/device turn
@@ -27,7 +50,7 @@ const LINEAR_GLITCH_CEILING_M_S = 20;
 * — demoting the (weak-at-scanning-distance) linear signal to a gross-motion
 * safety net and letting the well-behaved angular gate be the primary blur
 * selector. See
-* `GpsPlusSlamJs_Docs/docs/2026-07-02-image-capture-rate-motion-gate-finding.md`.
+* `GpsPlusSlamJs_Docs/docs/2026-07-02-0117-image-capture-rate-motion-gate-finding.md`.
 *
 * `maxAngularVelocity` remains a PLACEHOLDER pending on-device field tuning
 * (plan §7). `maxWaitMs` of 4000 ms is 2× the default 2000 ms image interval.
@@ -103,4 +126,4 @@ var MotionWindow = class {
 	}
 };
 //#endregion
-export { MotionWindow as n, decideCapture as r, DEFAULT_MOTION_FILTER as t };
+export { DEFAULT_MOTION_FILTER, DEFAULT_MOTION_WINDOW_SIZE, MotionWindow, decideCapture };

package/dist/ar/chromium-camera-access-workaround.d.ts

@@ -1,2 +1,2 @@
-import { a as applyChromiumProjectionLayerWorkaround, i as ChromiumProjectionLayerWorkaroundResult, n as BASELAYER_WINDOW_MIN, o as needsBaseLayerPersistence, r as ChromeVersion, s as parseChromeVersion, t as BASELAYER_WINDOW_MAX } from "../chromium-camera-access-workaround-C6yJLXz9.js";
+import { a as applyChromiumProjectionLayerWorkaround, i as ChromiumProjectionLayerWorkaroundResult, n as BASELAYER_WINDOW_MIN, o as needsBaseLayerPersistence, r as ChromeVersion, s as parseChromeVersion, t as BASELAYER_WINDOW_MAX } from "../chromium-camera-access-workaround-BHR4clTE.js";
 export { BASELAYER_WINDOW_MAX, BASELAYER_WINDOW_MIN, ChromeVersion, ChromiumProjectionLayerWorkaroundResult, applyChromiumProjectionLayerWorkaround, needsBaseLayerPersistence, parseChromeVersion };

package/dist/ar/chromium-camera-access-workaround.js

@@ -11,7 +11,7 @@ import { createLogger } from "../utils/logger.js";
 * added — i.e. it is not specific to this app's session setup. See:
 *
 *   - GpsPlusSlamJs_Docs/docs/2026-04-22-camera-access-reproducer-plan.md
-*   - GpsPlusSlamJs_Docs/docs/2026-06-04-camera-access-crash-regression-chrome-148.md
+*   - GpsPlusSlamJs_Docs/docs/2026-06-04-0458-camera-access-crash-regression-chrome-148.md
 *   - https://github.com/mrdoob/three.js/issues/33404
 *   - https://issues.chromium.org/issues/507508099 (root-cause, marked Fixed)
 *

package/dist/ar/depth-grid-lookup.d.ts

@@ -1,2 +1,2 @@
-import { n as createDepthGridLookup, t as DepthGridLookup } from "../depth-grid-lookup-D5atpNZ3.js";
+import { n as createDepthGridLookup, t as DepthGridLookup } from "../depth-grid-lookup-CCuzlqUo.js";
 export { DepthGridLookup, createDepthGridLookup };

package/dist/ar/depth-occluder.d.ts

@@ -1,4 +1,4 @@
-import { t as DepthInfo } from "../depth-sampler-CwObAwEA.js";
+import { t as DepthInfo } from "../depth-sampler-CS2jAFw4.js";
 import * as THREE from "three";
 
 //#region ../src/ar/depth-occluder.d.ts

package/dist/ar/depth-occluder.js

@@ -10,7 +10,7 @@ import * as THREE from "three";
 * occludes per-pixel against the surface currently in view (sharp, registration-
 * free, no memory). They **compose** — both depth-only under `arWorldGroup`, the
 * live occluder wins where this frame has depth, the mesh fills out-of-view / depth
-* holes (2026-06-14-webxr-depth-occlusion-plan.md §5).
+* holes (2026-06-14-0009-webxr-depth-occlusion-plan.md §5).
 *
 * **Two layers, two confidence levels:**
 *  - The **pure occlusion math** (this file's exported functions) is the CI-tested

package/dist/ar/depth-sampler.d.ts

@@ -1,3 +1,3 @@
-import { i as DepthSample } from "../ar-types-Cc5yvBwn.js";
-import { a as wrapXRDepthInfo, i as DepthSamplerConfig, n as DepthSampler, r as DepthSamplerCallbacks, t as DepthInfo } from "../depth-sampler-CwObAwEA.js";
+import { i as DepthSample } from "../ar-types-D6PYS4bc.js";
+import { a as wrapXRDepthInfo, i as DepthSamplerConfig, n as DepthSampler, r as DepthSamplerCallbacks, t as DepthInfo } from "../depth-sampler-CS2jAFw4.js";
 export { DepthInfo, DepthSample, DepthSampler, DepthSamplerCallbacks, DepthSamplerConfig, wrapXRDepthInfo };

package/dist/ar/depth-sampler.js

@@ -1,4 +1,4 @@
-import { extractOdomPosition } from "../state/gps-event-coordinator.js";
+import { extractOdomPosition } from "../types/ar-types.js";
 //#region ../src/ar/depth-sampler.ts
 /**
 * Defensively copy a 16-element column-major matrix into a plain serializable
@@ -127,19 +127,30 @@ var DepthSampler = class {
 		if (typeof config.rgb === "boolean") this.config.rgb = config.rgb;
 	}
 	/**
-	* Called each frame with depth information.
+	* Called each frame with a LAZY depth provider (quality-review E-4: the
+	* caller used to acquire + wrap the depth info every frame while this
+	* method threw ~59 of 60 acquisitions away at the interval check — the
+	* provider is now invoked only when a sample is due).
+	*
+	* Unavailability detection is preserved by construction:
+	* `lastSampleTime` only advances when a sample is EMITTED, so while depth
+	* is unavailable the sampler stays "due" and probes the provider every
+	* frame — exactly the cadence the old per-frame acquisition gave
+	* `checkDepthUnavailability` (Field Test Readiness Issue #8).
 	*
 	* @param timestamp - Current frame timestamp in milliseconds
-	* @param depthInfo - WebXR depth information, or null if unavailable
+	* @param acquireDepthInfo - Returns the frame's depth info, or null if
+	*   unavailable. Only invoked when a sample is due.
 	*/
-	onFrame(timestamp, depthInfo) {
+	onFrame(timestamp, acquireDepthInfo) {
 		if (!this.running) return;
+		if (timestamp - this.lastSampleTime < this.config.intervalMs) return;
+		const depthInfo = acquireDepthInfo();
 		if (!depthInfo) {
 			this.checkDepthUnavailability();
 			return;
 		}
 		this.depthReceived = true;
-		if (timestamp - this.lastSampleTime < this.config.intervalMs) return;
 		const pose = this.callbacks.getCurrentPose();
 		if (!pose) return;
 		const points = this.sampleGrid(depthInfo, this.acquireRgbLookupSafely());

package/dist/ar/depth-unprojection.d.ts

@@ -1,2 +1,2 @@
-import { n as createDepthUnprojector, r as unprojectDepthPoint, t as DepthUnprojector } from "../depth-unprojection-DRdBU90S.js";
+import { n as createDepthUnprojector, r as unprojectDepthPoint, t as DepthUnprojector } from "../depth-unprojection-ET3Gwedf.js";
 export { DepthUnprojector, createDepthUnprojector, unprojectDepthPoint };

package/dist/ar/enable-gps-ar.d.ts

@@ -1,2 +1,2 @@
-import { a as EnableGpsArState, i as EnableGpsArResult, n as EnableGpsArController, o as EnableGpsArStatus, r as EnableGpsArDeps, s as createEnableGpsArController, t as EnableGpsArConfig } from "../enable-gps-ar-BBtRO2FJ.js";
+import { a as EnableGpsArState, i as EnableGpsArResult, n as EnableGpsArController, o as EnableGpsArStatus, r as EnableGpsArDeps, s as createEnableGpsArController, t as EnableGpsArConfig } from "../enable-gps-ar-D_xEHzh5.js";
 export { EnableGpsArConfig, EnableGpsArController, EnableGpsArDeps, EnableGpsArResult, EnableGpsArState, EnableGpsArStatus, createEnableGpsArController };

package/dist/ar/enable-gps-ar.js

@@ -1,5 +1,5 @@
 import { createLogger } from "../utils/logger.js";
-import { C as initAR, c as endARSession, w as isWebXRSupported } from "../webxr-session-BCP2XK7k.js";
+import { _ as initAR, a as endARSession, v as isWebXRSupported } from "../webxr-session-OyR3YbTq.js";
 import { requestGeolocationPermission, requestOrientationPermission, requestWebXRWithDepthPermission } from "../sensors/permission-checker.js";
 import { startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch } from "../sensors/gps.js";
 //#region ../src/ar/enable-gps-ar.ts
@@ -78,7 +78,7 @@ function createEnableGpsArController(deps = {}) {
 		try {
 			const permissionError = await requestPermissions(config);
 			if (permissionError !== null) return fail(permissionError);
-			await resolved.initAR(config.container, config.isolationOptions, { requestHitTest: config.requestHitTest });
+			await resolved.initAR(config.container, config.isolationOptions, { requestHitTest: config.requestHitTest }, config.callbacks);
 			sessionStarted = true;
 			if (config.onGpsPosition) {
 				resolved.startGpsWatch(config.onGpsPosition);

package/dist/ar/image-capture.d.ts

@@ -1,2 +1,2 @@
-import { a as ImageCaptureCallbacks, c as MIN_VALID_IMAGE_BYTES, i as FrameQualityVerdict, n as CapturedImage, o as ImageCaptureConfig, r as DEFAULT_CAPTURE_CONFIG, s as ImageCaptureManager, t as CapturedFrame } from "../image-capture-Bp6Pd4Md.js";
+import { a as ImageCaptureCallbacks, c as MIN_VALID_IMAGE_BYTES, i as FrameQualityVerdict, n as CapturedImage, o as ImageCaptureConfig, r as DEFAULT_CAPTURE_CONFIG, s as ImageCaptureManager, t as CapturedFrame } from "../image-capture-BevgKpoO.js";
 export { CapturedFrame, CapturedImage, DEFAULT_CAPTURE_CONFIG, FrameQualityVerdict, ImageCaptureCallbacks, ImageCaptureConfig, ImageCaptureManager, MIN_VALID_IMAGE_BYTES };

package/dist/ar/image-capture.js

@@ -1,2 +1,2 @@
-import { n as ImageCaptureManager, r as MIN_VALID_IMAGE_BYTES, t as DEFAULT_CAPTURE_CONFIG } from "../image-capture-DVcuqMtX.js";
+import { n as ImageCaptureManager, r as MIN_VALID_IMAGE_BYTES, t as DEFAULT_CAPTURE_CONFIG } from "../image-capture-C4DwxC10.js";
 export { DEFAULT_CAPTURE_CONFIG, ImageCaptureManager, MIN_VALID_IMAGE_BYTES };

package/dist/ar/image-quality.d.ts

@@ -1,2 +1,2 @@
-import { a as QualityFilterConfig, c as meanLuminance, i as ImageQualityGate, l as rgbaToGrayscale, n as DEFAULT_SHARPNESS_HISTORY_SIZE, o as QualityRejectReason, r as DEFAULT_SHARPNESS_MIN_SAMPLES, s as QualityVerdict, t as DEFAULT_QUALITY_FILTER, u as sharpnessScore } from "../image-quality-BMx2ko9-.js";
-export { DEFAULT_QUALITY_FILTER, DEFAULT_SHARPNESS_HISTORY_SIZE, DEFAULT_SHARPNESS_MIN_SAMPLES, ImageQualityGate, QualityFilterConfig, QualityRejectReason, QualityVerdict, meanLuminance, rgbaToGrayscale, sharpnessScore };
+import { a as DEFAULT_SHARPNESS_MIN_SAMPLES, c as QualityRejectReason, d as highFrequencyEnergyRatio, f as meanLuminance, i as DEFAULT_SHARPNESS_HISTORY_SIZE, l as QualityVerdict, m as sharpnessScore, n as BlurMetricId, o as ImageQualityGate, p as rgbaToGrayscale, r as DEFAULT_QUALITY_FILTER, s as QualityFilterConfig, t as BLUR_METRIC_IDS, u as blurMetricScorer } from "../image-quality--HLuyJ2r.js";
+export { BLUR_METRIC_IDS, BlurMetricId, DEFAULT_QUALITY_FILTER, DEFAULT_SHARPNESS_HISTORY_SIZE, DEFAULT_SHARPNESS_MIN_SAMPLES, ImageQualityGate, QualityFilterConfig, QualityRejectReason, QualityVerdict, blurMetricScorer, highFrequencyEnergyRatio, meanLuminance, rgbaToGrayscale, sharpnessScore };