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

package/dist/ar/qr-detection-controller.d.ts

@@ -1,2 +1,2 @@
-import { a as createQrDetectionController, i as RawObservationSink, n as QrDetectionControllerDeps, r as QrScanStatus, t as QrDetectionController } from "../qr-detection-controller-Cd2Ih4cC.js";
+import { a as createQrDetectionController, i as RawObservationSink, n as QrDetectionControllerDeps, r as QrScanStatus, t as QrDetectionController } from "../qr-detection-controller-CDurHv8E.js";
 export { QrDetectionController, QrDetectionControllerDeps, QrScanStatus, RawObservationSink, createQrDetectionController };

package/dist/ar/qr-frontend.d.ts

@@ -1,2 +1,2 @@
-import { a as QrFrontEnd, c as createBarcodeDetectorFrontEnd, i as QrDetection, n as BarcodeDetectorLike, o as RgbaImage, r as DetectedBarcodeLike, s as ToImageBitmapSource, t as BarcodeDetectorFrontEnd } from "../qr-frontend-DufZp2xS.js";
+import { a as QrFrontEnd, c as createBarcodeDetectorFrontEnd, i as QrDetection, n as BarcodeDetectorLike, o as RgbaImage, r as DetectedBarcodeLike, s as ToImageBitmapSource, t as BarcodeDetectorFrontEnd } from "../qr-frontend--fFX25mV.js";
 export { BarcodeDetectorFrontEnd, BarcodeDetectorLike, DetectedBarcodeLike, QrDetection, QrFrontEnd, RgbaImage, ToImageBitmapSource, createBarcodeDetectorFrontEnd };

package/dist/ar/qr-pose.d.ts

@@ -1,2 +1,2 @@
-import { _ as solveQrPose, a as QrPoseSolution, c as SolveQrPoseInput, d as intrinsicsFromProjection, f as invertPose, g as signedQuadArea, h as reprojectionErrorPx, i as Pose, l as buildObjectPoints, m as qrInCameraFromOpenCv, n as OpenCvPnpResult, o as QuadValidation, p as projectViewPoint, r as Point2, s as SolvePnpSquare, t as CameraIntrinsics, u as composePose, v as transformPoint, y as validateQuad } from "../qr-pose-Bt2reSw7.js";
+import { _ as solveQrPose, a as QrPoseSolution, c as SolveQrPoseInput, d as intrinsicsFromProjection, f as invertPose, g as signedQuadArea, h as reprojectionErrorPx, i as Pose, l as buildObjectPoints, m as qrInCameraFromOpenCv, n as OpenCvPnpResult, o as QuadValidation, p as projectViewPoint, r as Point2, s as SolvePnpSquare, t as CameraIntrinsics, u as composePose, v as transformPoint, y as validateQuad } from "../qr-pose-D2rfu5DA.js";
 export { CameraIntrinsics, OpenCvPnpResult, Point2, Pose, QrPoseSolution, QuadValidation, SolvePnpSquare, SolveQrPoseInput, buildObjectPoints, composePose, intrinsicsFromProjection, invertPose, projectViewPoint, qrInCameraFromOpenCv, reprojectionErrorPx, signedQuadArea, solveQrPose, transformPoint, validateQuad };

package/dist/ar/qr-size-depth-context.d.ts

@@ -1,3 +1,3 @@
-import { n as QrSizeDepthContext } from "../qr-size-measurer-D7739ZpB.js";
-import { t as createQrSizeDepthContext } from "../qr-size-depth-context-onu36E9s.js";
+import { n as QrSizeDepthContext } from "../qr-size-measurer-DQdAsid1.js";
+import { t as createQrSizeDepthContext } from "../qr-size-depth-context-CeAG53fy.js";
 export { QrSizeDepthContext, createQrSizeDepthContext };

package/dist/ar/qr-size-measurer.d.ts

@@ -1,2 +1,2 @@
-import { a as QrSizeMeasurerOptions, i as QrSizeMeasurer, n as QrSizeDepthContext, o as createQrSizeMeasurer, r as QrSizeMeasurement, t as ImageSize } from "../qr-size-measurer-D7739ZpB.js";
+import { a as QrSizeMeasurerOptions, i as QrSizeMeasurer, n as QrSizeDepthContext, o as createQrSizeMeasurer, r as QrSizeMeasurement, t as ImageSize } from "../qr-size-measurer-DQdAsid1.js";
 export { ImageSize, QrSizeDepthContext, QrSizeMeasurement, QrSizeMeasurer, QrSizeMeasurerOptions, createQrSizeMeasurer };

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

@@ -1,2 +1,2 @@
-import { a as getCameraFollower, c as getReplayState, d as updateOrbitTarget, i as getAlignmentLerper, l as initReplayScene, n as ReplaySceneState, o as getCameraMode, r as disposeReplayScene, s as getCss3dManager, t as CameraMode, u as toggleCameraMode } from "../replay-scene-CPt56pps.js";
+import { a as getCameraFollower, c as getReplayState, d as updateOrbitTarget, i as getAlignmentLerper, l as initReplayScene, n as ReplaySceneState, o as getCameraMode, r as disposeReplayScene, s as getCss3dManager, t as CameraMode, u as toggleCameraMode } from "../replay-scene-DBlDrV_x.js";
 export { CameraMode, ReplaySceneState, disposeReplayScene, getAlignmentLerper, getCameraFollower, getCameraMode, getCss3dManager, getReplayState, initReplayScene, toggleCameraMode, updateOrbitTarget };

package/dist/ar/replay-scene.js

@@ -1,5 +1,5 @@
 import { createLogger } from "../utils/logger.js";
-import { D as setCamera, E as setArWorldGroup, M as setScene, T as setArPose, i as createSceneHierarchy } from "../webxr-session-CJF9Nijp.js";
+import { D as setCamera, E as setArWorldGroup, N as setScene, T as setArPose, i as createSceneHierarchy } from "../webxr-session-DG-eNfny.js";
 import { createCss3dRendererManager } from "../visualization/css3d-renderer-manager.js";
 import { createCameraFollower } from "../visualization/camera-follower.js";
 import { createAlignmentLerper } from "../visualization/alignment-lerper.js";

package/dist/ar/scene-node-names.d.ts

@@ -1,2 +1,2 @@
-import { t as SCENE_NODE } from "../scene-node-names-CdNeQjOE.js";
+import { t as SCENE_NODE } from "../scene-node-names-BiShOQDB.js";
 export { SCENE_NODE };

package/dist/ar/webxr-nue-basis.d.ts

@@ -1,2 +1,2 @@
-import { t as WEBXR_TO_NUE } from "../webxr-nue-basis-CW1wsbm6.js";
+import { t as WEBXR_TO_NUE } from "../webxr-nue-basis-3nfjDJJp.js";
 export { WEBXR_TO_NUE };

package/dist/ar/webxr-session.d.ts

@@ -1,4 +1,4 @@
-import { i as DepthSample, t as ARPose } from "../ar-types-BckI1E-O.js";
-import { n as CapturedImage } from "../image-capture-C2Feywet.js";
-import { A as setCamera, B as shouldLogCameraAccessDiagnostic, C as isWebXRSupported, D as resetWebXRState, E as nueQuaternionToWebXR, F as setScene, G as stopDepthCapture, H as startDepthCapture, I as setTrackingCallbacks, K as stopImageCapture, L as setTrackingLostCallback, M as setDepthCaptureCallback, N as setFrameCallback, O as setArPose, P as setImageCaptureCallback, R as setTrackingRecoveredCallback, S as initAR, T as nuePositionToWebXR, U as startImageCapture, V as startCameraFrameCapture, W as stopCameraFrameCapture, _ as getDepthSampleCount, a as applyAlignmentMatrix, b as getScene, c as endARSession, d as getArPose, f as getArWorldGroup, g as getCurrentArPose, h as getCameraFrameCount, i as TrackingSubscribableStore, j as setCameraFrameCallback, k as setArWorldGroup, l as extractPoseFromViewer, m as getCameraFrameCaptureSize, n as DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, o as buildSessionOptions, p as getCamera, r as SessionFeatureOptions, s as createSceneHierarchy, t as CameraFrameCaptureConfig, u as extractResetTransformData, v as getImageCaptureFrameCount, w as isXRCameraLike, x as getXrCameraFromPose, y as getLiveCss3dManager, z as setTrackingStore } from "../webxr-session-COsOjJwn.js";
-export { ARPose, CameraFrameCaptureConfig, CapturedImage, DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, DepthSample, SessionFeatureOptions, TrackingSubscribableStore, applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCameraFrameCaptureSize, getCameraFrameCount, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setCameraFrameCallback, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startCameraFrameCapture, startDepthCapture, startImageCapture, stopCameraFrameCapture, stopDepthCapture, stopImageCapture };
+import { i as DepthSample, t as ARPose } from "../ar-types-BFX2r1wk.js";
+import { n as CapturedImage } from "../image-capture-CNZDrQXG.js";
+import { A as setCamera, B as setTrackingStore, C as isWebXRSupported, D as resetWebXRState, E as nueQuaternionToWebXR, F as setImageQualityAnalyzer, G as stopCameraFrameCapture, H as startCameraFrameCapture, I as setScene, K as stopDepthCapture, L as setTrackingCallbacks, M as setDepthCaptureCallback, N as setFrameCallback, O as setArPose, P as setImageCaptureCallback, R as setTrackingLostCallback, S as initAR, T as nuePositionToWebXR, U as startDepthCapture, V as shouldLogCameraAccessDiagnostic, W as startImageCapture, _ as getDepthSampleCount, a as applyAlignmentMatrix, b as getScene, c as endARSession, d as getArPose, f as getArWorldGroup, g as getCurrentArPose, h as getCameraFrameCount, i as TrackingSubscribableStore, j as setCameraFrameCallback, k as setArWorldGroup, l as extractPoseFromViewer, m as getCameraFrameCaptureSize, n as DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, o as buildSessionOptions, p as getCamera, q as stopImageCapture, r as SessionFeatureOptions, s as createSceneHierarchy, t as CameraFrameCaptureConfig, u as extractResetTransformData, v as getImageCaptureFrameCount, w as isXRCameraLike, x as getXrCameraFromPose, y as getLiveCss3dManager, z as setTrackingRecoveredCallback } from "../webxr-session-Do5L6G3B.js";
+export { ARPose, CameraFrameCaptureConfig, CapturedImage, DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, DepthSample, SessionFeatureOptions, TrackingSubscribableStore, applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCameraFrameCaptureSize, getCameraFrameCount, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setCameraFrameCallback, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setImageQualityAnalyzer, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startCameraFrameCapture, startDepthCapture, startImageCapture, stopCameraFrameCapture, stopDepthCapture, stopImageCapture };

package/dist/ar/webxr-session.js

@@ -1,2 +1,2 @@
-import { A as setFrameCallback, B as startImageCapture, C as nueQuaternionToWebXR, D as setCamera, E as setArWorldGroup, F as setTrackingRecoveredCallback, H as stopDepthCapture, I as setTrackingStore, L as shouldLogCameraAccessDiagnostic, M as setScene, N as setTrackingCallbacks, O as setCameraFrameCallback, P as setTrackingLostCallback, R as startCameraFrameCapture, S as nuePositionToWebXR, T as setArPose, U as stopImageCapture, V as stopCameraFrameCapture, _ as getScene, a as endARSession, b as isWebXRSupported, c as getArPose, d as getCameraFrameCaptureSize, f as getCameraFrameCount, g as getLiveCss3dManager, h as getImageCaptureFrameCount, i as createSceneHierarchy, j as setImageCaptureCallback, k as setDepthCaptureCallback, l as getArWorldGroup, m as getDepthSampleCount, n as applyAlignmentMatrix, o as extractPoseFromViewer, p as getCurrentArPose, r as buildSessionOptions, s as extractResetTransformData, t as DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, u as getCamera, v as getXrCameraFromPose, w as resetWebXRState, x as isXRCameraLike, y as initAR, z as startDepthCapture } from "../webxr-session-CJF9Nijp.js";
-export { DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCameraFrameCaptureSize, getCameraFrameCount, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setCameraFrameCallback, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startCameraFrameCapture, startDepthCapture, startImageCapture, stopCameraFrameCapture, stopDepthCapture, stopImageCapture };
+import { A as setFrameCallback, B as startDepthCapture, C as nueQuaternionToWebXR, D as setCamera, E as setArWorldGroup, F as setTrackingLostCallback, H as stopCameraFrameCapture, I as setTrackingRecoveredCallback, L as setTrackingStore, M as setImageQualityAnalyzer, N as setScene, O as setCameraFrameCallback, P as setTrackingCallbacks, R as shouldLogCameraAccessDiagnostic, S as nuePositionToWebXR, T as setArPose, U as stopDepthCapture, V as startImageCapture, W as stopImageCapture, _ as getScene, a as endARSession, b as isWebXRSupported, c as getArPose, d as getCameraFrameCaptureSize, f as getCameraFrameCount, g as getLiveCss3dManager, h as getImageCaptureFrameCount, i as createSceneHierarchy, j as setImageCaptureCallback, k as setDepthCaptureCallback, l as getArWorldGroup, m as getDepthSampleCount, n as applyAlignmentMatrix, o as extractPoseFromViewer, p as getCurrentArPose, r as buildSessionOptions, s as extractResetTransformData, t as DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, u as getCamera, v as getXrCameraFromPose, w as resetWebXRState, x as isXRCameraLike, y as initAR, z as startCameraFrameCapture } from "../webxr-session-DG-eNfny.js";
+export { DEFAULT_CAMERA_FRAME_CAPTURE_SIZE, applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCameraFrameCaptureSize, getCameraFrameCount, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setCameraFrameCallback, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setImageQualityAnalyzer, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startCameraFrameCapture, startDepthCapture, startImageCapture, stopCameraFrameCapture, stopDepthCapture, stopImageCapture };

package/dist/ar/xr-camera-texture.d.ts

@@ -1,2 +1,2 @@
-import { i as acquireCameraTexture, n as RendererLike, r as XRCameraLike, t as CameraTextureResult } from "../xr-camera-texture-BmrP7iNZ.js";
+import { i as acquireCameraTexture, n as RendererLike, r as XRCameraLike, t as CameraTextureResult } from "../xr-camera-texture-Cva1q3Qj.js";
 export { CameraTextureResult, RendererLike, XRCameraLike, acquireCameraTexture };

package/dist/ar/xr-error-handler.d.ts

@@ -1,2 +1,2 @@
-import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "../xr-error-handler-BEjRgZjt.js";
+import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "../xr-error-handler-CtvHpjfm.js";
 export { XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, getXrErrorMessage };

package/dist/ar/xr-frame-loop.d.ts

@@ -1,2 +1,2 @@
-import { a as runXrFrameUpdates, i as registerXrFrameUpdate, n as XrFrameUpdate, r as clearXrFrameUpdates, t as XrFrameContext } from "../xr-frame-loop-K8ebdjLw.js";
+import { a as runXrFrameUpdates, i as registerXrFrameUpdate, n as XrFrameUpdate, r as clearXrFrameUpdates, t as XrFrameContext } from "../xr-frame-loop-DIYtRcUa.js";
 export { XrFrameContext, XrFrameUpdate, clearXrFrameUpdates, registerXrFrameUpdate, runXrFrameUpdates };

package/dist/{ar-Dc72Ksiu.js → ar-MFpFlV7j.js}

@@ -10,12 +10,12 @@ import "./ar/qr-derived-pose.js";
 import "./ar/webxr-nue-basis.js";
 import "./ar/qr-debug-view.js";
 import { n as createDetectionScheduler } from "./qr-detection-controller-B-tLVd-S.js";
-import "./qr-pose-aggregation-DXR9STHs.js";
-import "./webxr-session-CJF9Nijp.js";
+import "./qr-pose-aggregation-DBiaLW0O.js";
+import "./webxr-session-DG-eNfny.js";
 import "./ar/occupancy-grid.js";
 import "./ar/frame-loop.js";
 import "./ar/xr-frame-loop.js";
-import "./ar/image-capture.js";
+import "./image-capture-B2-b6tKK.js";
 import "./ar/xr-camera-texture.js";
 import "./ar/enable-gps-ar.js";
 import "./ar/replay-scene.js";

package/dist/{ar-world-group-alignment-DDLkgNf_.d.ts → ar-world-group-alignment-69fgnB39.d.ts}

@@ -1,4 +1,4 @@
-import { t as SubscribableStore } from "./subscribe-to-selector-Bp3sLx8L.js";
+import { t as SubscribableStore } from "./subscribe-to-selector-B6EUmQ3I.js";
 import * as THREE from "three";
 
 //#region ../src/visualization/ar-world-group-alignment.d.ts

package/dist/capture-motion-gate-0Yl2NpQG.d.ts

@@ -0,0 +1,24 @@
+//#region ../src/ar/capture-motion-gate.d.ts
+/**
+ * User-/consumer-facing motion-filter configuration. Shared by both config
+ * shapes that carry it — `ImageCaptureConfig` (what `ImageCaptureManager`
+ * consumes) and `ImageCaptureOptions` (the persisted recorder options) — so the
+ * one definition cannot drift between them. The window size and glitch ceilings
+ * are deliberately NOT here: they are internal tuning constants, not exposed.
+ */
+interface MotionFilterConfig {
+  /** Master switch for the motion gate. Default `true`. */
+  enabled: boolean;
+  /** Angular-velocity threshold (rad/s); at/below this a frame is "calm". */
+  maxAngularVelocity: number;
+  /** Linear-velocity threshold (m/s); at/below this a frame is "calm". */
+  maxLinearVelocity: number;
+  /**
+   * Never-calm safety fallback: once a due capture has waited this many ms it
+   * fires regardless of motion, so an interval is never silently lost. A
+   * sensible value is ~2× the capture interval.
+   */
+  maxWaitMs: number;
+}
+//#endregion
+export { MotionFilterConfig as t };

package/dist/capture-motion-gate-4EscNZCw.js

@@ -0,0 +1,94 @@
+/**
+* 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
+* tops out well below this; a teleport is far above it. Module-internal tuning
+* constant (not exported — the gate's user surface is only the four
+* `MotionFilterConfig` fields); overridable per-instance via the `MotionWindow`
+* constructor for tests.
+*/
+const ANGULAR_GLITCH_CEILING_RAD_S = 50;
+/**
+* Linear velocity (m/s) above which a sample is treated as a tracking glitch.
+* ~20 m/s (72 km/h) is unreachable by handheld scanning but trivially exceeded
+* by a relocalization origin jump. Module-internal tuning constant (see
+* {@link ANGULAR_GLITCH_CEILING_RAD_S}).
+*/
+const LINEAR_GLITCH_CEILING_M_S = 20;
+/**
+* Default motion-filter configuration. Enabled by default (plan §1). Thresholds
+* are PLACEHOLDERS pending on-device field tuning (plan §7) — record measured
+* values in implementation-progress.md once known. `maxWaitMs` of 4000 ms is
+* 2× the default 2000 ms image interval.
+*/
+const DEFAULT_MOTION_FILTER = {
+	enabled: true,
+	maxAngularVelocity: .6,
+	maxLinearVelocity: .5,
+	maxWaitMs: 4e3
+};
+/**
+* Decide whether a due capture should fire now or defer to a later frame.
+*
+* A frame is "calm" when BOTH windowed maxima are at/below their thresholds —
+* an empty window reports `Infinity`, so it is never calm (no capture before a
+* valid sample exists). If not calm, the capture is deferred UNTIL `msSinceDue`
+* reaches `maxWaitMs`, at which point it fires regardless to guarantee an
+* interval is never silently lost (worst case: one blurry frame, not a gap).
+*/
+function decideCapture(input) {
+	if (input.windowMaxAngular <= input.maxAngularVelocity && input.windowMaxLinear <= input.maxLinearVelocity) return "capture";
+	if (input.msSinceDue >= input.maxWaitMs) return "capture";
+	return "defer";
+}
+/**
+* Fixed-size ring of the most recent VALID (non-glitch) per-frame velocities.
+*
+* `maxAngular()`/`maxLinear()` return the max over the retained samples, or
+* `Infinity` when empty so "no data yet" reads as not-calm in
+* {@link decideCapture}. A sample exceeding either glitch ceiling is rejected
+* outright (`push` returns `false`) and never stored, so a relocalization spike
+* neither pollutes the window (no spurious defer) nor is treated as motion.
+*/
+var MotionWindow = class {
+	angularGlitchCeiling;
+	linearGlitchCeiling;
+	size;
+	angular = [];
+	linear = [];
+	constructor(size = 3, angularGlitchCeiling = ANGULAR_GLITCH_CEILING_RAD_S, linearGlitchCeiling = LINEAR_GLITCH_CEILING_M_S) {
+		this.angularGlitchCeiling = angularGlitchCeiling;
+		this.linearGlitchCeiling = linearGlitchCeiling;
+		this.size = Number.isFinite(size) && size >= 1 ? Math.floor(size) : 1;
+	}
+	/**
+	* Record a per-frame velocity pair. Returns `false` (and stores nothing) when
+	* the sample exceeds either glitch ceiling, `true` otherwise.
+	*/
+	push(angularVel, linearVel) {
+		if (!Number.isFinite(angularVel) || !Number.isFinite(linearVel) || angularVel > this.angularGlitchCeiling || linearVel > this.linearGlitchCeiling) return false;
+		this.angular.push(angularVel);
+		this.linear.push(linearVel);
+		if (this.angular.length > this.size) this.angular.shift();
+		if (this.linear.length > this.size) this.linear.shift();
+		return true;
+	}
+	/** Whether the window holds at least one valid (non-glitch) sample yet. */
+	hasSamples() {
+		return this.angular.length > 0;
+	}
+	/** Max angular velocity over the retained window, or `Infinity` if empty. */
+	maxAngular() {
+		return this.angular.length === 0 ? Number.POSITIVE_INFINITY : Math.max(...this.angular);
+	}
+	/** Max linear velocity over the retained window, or `Infinity` if empty. */
+	maxLinear() {
+		return this.linear.length === 0 ? Number.POSITIVE_INFINITY : Math.max(...this.linear);
+	}
+	/** Clear all samples (e.g. on tracking loss / capture restart). */
+	reset() {
+		this.angular.length = 0;
+		this.linear.length = 0;
+	}
+};
+//#endregion
+export { MotionWindow as n, decideCapture as r, DEFAULT_MOTION_FILTER as t };

package/dist/core/index.d.ts

@@ -1,2 +1,2 @@
-import { a as LibraryRootState, c as RootState, d as calcRelativeCoordsInMeters, f as createGpsSlamStore, g as webxrToNUE, h as validateLicenseKey, i as LatLongAlt, l as Vector3, m as odometryTrackingRestarted, n as GpsPoint, o as Matrix4, p as isIdentityMatrix4, r as LatLong, s as Quaternion, t as ArImageCapture, u as calcGpsCoords } from "../index-eaI1Z1KR.js";
-export { ArImageCapture, GpsPoint, LatLong, LatLongAlt, LibraryRootState, Matrix4, Quaternion, RootState, Vector3, calcGpsCoords, calcRelativeCoordsInMeters, createGpsSlamStore, isIdentityMatrix4, odometryTrackingRestarted, validateLicenseKey, webxrToNUE };
+import { _ as odometryTrackingRestarted, a as LibraryRootState, c as RootState, d as bearingDeltaDeg, f as calcGpsCoords, g as magneticHeadingFromEnuQuat, h as isIdentityMatrix4, i as LatLongAlt, l as Vector3, m as createGpsSlamStore, n as GpsPoint, o as Matrix4, p as calcRelativeCoordsInMeters, r as LatLong, s as Quaternion, t as ArImageCapture, u as arNorthBearingDeg, v as validateLicenseKey, y as webxrToNUE } from "../index-_Rhgoqkh.js";
+export { ArImageCapture, GpsPoint, LatLong, LatLongAlt, LibraryRootState, Matrix4, Quaternion, RootState, Vector3, arNorthBearingDeg, bearingDeltaDeg, calcGpsCoords, calcRelativeCoordsInMeters, createGpsSlamStore, isIdentityMatrix4, magneticHeadingFromEnuQuat, odometryTrackingRestarted, validateLicenseKey, webxrToNUE };

package/dist/core/index.js

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

package/dist/create-slam-app-store-DkCHOpvb.js

@@ -0,0 +1,149 @@
+import { trackingReducer } from "./state/tracking-slice.js";
+import { recordWriteFailure, recordingReducer } from "./state/recording-slice.js";
+import { createTrackingQualityListenerMiddleware, trackingQualityReducer } from "./state/tracking-quality.js";
+import { createPersistenceMiddleware, slicePrefixOf } from "./state/persistence-middleware.js";
+import { arElementsReducer, gpsDataReducer, gpsElementsReducer, sanitizeForDevTools, setColdStartOverrideEnabled, setCompassRotationPriorEnabled, setCompassWebXRConsistencyEnabled, setZeroPos, validateLicenseKey } from "gps-plus-slam-js";
+import { configureStore, createListenerMiddleware } from "@reduxjs/toolkit";
+import { COMMUNITY_LICENSE_KEY } from "gps-plus-slam-js/community-license-key";
+//#region ../src/state/slam-app-store-listener.ts
+/**
+* Build a listener middleware that applies the requested compass opt-ins once
+* `gpsData` exists and a flag is still unset. Register it via `.prepend(...)`
+* (so its effect dispatches *outside* the trigger's `next()` — see module doc).
+*
+* Behaviour:
+*  - **Predicate** fires whenever the `gpsData` *object reference* is new since
+*    the last apply AND at least one opt-in is still unset. Two terms, each load-
+*    bearing:
+*    - `s.gpsData !== lastApplied` makes the predicate edge-triggered on gpsData
+*      identity. A recreated `gpsData` (store swap / origin reset) is a fresh
+*      object, so it still re-triggers the apply — the re-apply semantics the
+*      2026-06-27 field bug demands are preserved. Do NOT weaken this to a
+*      `null → non-null` transition: that would drop the re-apply. The point of
+*      keying on the *reference* (not on "a flag is unset") is that it also stops
+*      the effect from re-firing for the SAME gpsData.
+*    - `optIns.some((o) => !o.isSet(s))` keeps the no-op case (all flags already
+*      set) from scheduling an effect at all.
+*    Why the reference guard matters: without it the predicate is purely level-
+*    based, so if an opt-in's `apply` dispatches but `isSet` never flips true
+*    (e.g. consumer/library **version skew** where the action type no longer
+*    matches the reducer — the packages are published independently), the
+*    condition stays true forever and every effect dispatch re-arms it: an
+*    unbounded storm that freezes the app. The per-dispatch `isSet` re-check
+*    below guards only against dispatching an *already-set* flag twice; it does
+*    nothing when the flag never sets. The reference guard is what bounds it.
+*  - **Effect** records the gpsData reference it is acting on, then dispatches
+*    every still-unset opt-in as a top-level action. `isSet` is re-read against
+*    the *current* store state immediately before each dispatch (not one snapshot
+*    at effect entry): a dispatch is synchronous, so a flag is already set by the
+*    time the next check runs, and an opt-in's own dispatch can re-enter this
+*    effect before the loop finishes. Re-checking per dispatch makes that
+*    re-entrancy idempotent — a flag is dispatched only while still unset.
+*/
+function createSlamAppStoreListenerMiddleware(optIns) {
+	const listenerMiddleware = createListenerMiddleware();
+	let lastApplied = null;
+	listenerMiddleware.startListening({
+		predicate: (_action, currentState) => {
+			const s = currentState;
+			return s.gpsData !== null && s.gpsData !== lastApplied && optIns.some((optIn) => !optIn.isSet(s));
+		},
+		effect: (_action, api) => {
+			const entry = api.getState();
+			if (entry.gpsData === null) return;
+			lastApplied = entry.gpsData;
+			for (const optIn of optIns) {
+				const s = api.getState();
+				if (s.gpsData === null) return;
+				if (!optIn.isSet(s)) optIn.apply((action) => {
+					api.dispatch(action);
+				});
+			}
+		}
+	});
+	return listenerMiddleware.middleware;
+}
+//#endregion
+//#region ../src/state/create-slam-app-store.ts
+/**
+* `createSlamAppStore` — composable Redux store factory for AR+GPS apps.
+*
+* Introduced in Iter 1 of the AppFramework/RecorderApp boundary migration.
+* Wires the three library reducers (`gpsData`, `gpsElements`, `arElements`),
+* the framework's recording lifecycle slice, and the persistence middleware.
+*
+* Recorder-only state (routing screen, ref-points, scenario) is plugged in
+* by the consumer via `extraReducers` / `extraMiddleware`. The factory itself
+* never references those concepts so apps that don't need them (POI viewers,
+* navigation arrows, …) compose freely.
+*
+* The legacy `createRecorderStore` from `store.ts` is built on top of this
+* factory and will move out of the framework in Iter 1D.
+*
+* @see docs/2026-05-03-appframework-vs-recorderapp-boundary-analysis.md — Iter 1
+*/
+/**
+* Slice prefixes the framework always persists, derived from the actual
+* library / framework action creators (never hand-typed). A rename of the
+* `gpsData` or `recording` slice therefore propagates here automatically
+* instead of silently dropping that slice's actions from recordings.
+*/
+const BUILTIN_PERSISTED_PREFIXES = [slicePrefixOf(setZeroPos.type), slicePrefixOf(recordWriteFailure.type)];
+/**
+* Build a Redux store wired with library + recording slices, persistence
+* middleware, and any caller-supplied extras. See module docstring for the
+* design rationale.
+*/
+function createSlamAppStore(options) {
+	const { storageBackend, extraReducers, extraMiddleware, persistedExtraPrefixes, onWriteFailure, enableDevChecks = true, licenseKey = COMMUNITY_LICENSE_KEY, trackingQualityOptions, enableCompassColdStartOverride = true, enableCompassRotationPrior = false, enableCompassWebXRConsistency = false } = options;
+	validateLicenseKey(licenseKey);
+	const reducer = {
+		gpsData: gpsDataReducer,
+		gpsElements: gpsElementsReducer,
+		arElements: arElementsReducer,
+		recording: recordingReducer,
+		tracking: trackingReducer,
+		trackingQuality: trackingQualityReducer,
+		...extraReducers ?? {}
+	};
+	const trackingQualityMiddleware = createTrackingQualityListenerMiddleware(trackingQualityOptions);
+	const compassOptIns = [];
+	if (enableCompassColdStartOverride) compassOptIns.push({
+		isSet: (s) => s.gpsData?.coldStartOverrideEnabled === true,
+		apply: (dispatch) => dispatch(setColdStartOverrideEnabled(true))
+	});
+	if (enableCompassRotationPrior) compassOptIns.push({
+		isSet: (s) => s.gpsData?.compassRotationPriorEnabled === true,
+		apply: (dispatch) => dispatch(setCompassRotationPriorEnabled(true))
+	});
+	if (enableCompassWebXRConsistency) compassOptIns.push({
+		isSet: (s) => s.gpsData?.compassWebXRConsistencyEnabled === true,
+		apply: (dispatch) => dispatch(setCompassWebXRConsistencyEnabled(true))
+	});
+	const prependedListeners = [trackingQualityMiddleware];
+	if (compassOptIns.length > 0) prependedListeners.push(createSlamAppStoreListenerMiddleware(compassOptIns));
+	const store = configureStore({
+		reducer,
+		middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+			serializableCheck: enableDevChecks,
+			immutableCheck: enableDevChecks
+		}).prepend(...prependedListeners).concat(createPersistenceMiddleware({
+			storageBackend,
+			onWriteFailure,
+			persistedPrefixes: [...BUILTIN_PERSISTED_PREFIXES, ...persistedExtraPrefixes ?? []]
+		}), ...extraMiddleware ?? []),
+		devTools: {
+			actionSanitizer: sanitizeForDevTools,
+			stateSanitizer: sanitizeForDevTools
+		}
+	});
+	return {
+		getState: () => store.getState(),
+		dispatch: store.dispatch,
+		subscribe: (listener) => store.subscribe(listener),
+		writeFrame: (blob, index) => storageBackend.writeFrame(blob, index),
+		writeSessionMetadata: (metadata) => storageBackend.writeSessionMetadata(metadata)
+	};
+}
+//#endregion
+export { createSlamAppStore as t };

package/dist/{create-slam-app-store-Ce2FMKCp.d.ts → create-slam-app-store-n_VF63D5.d.ts}

@@ -1,8 +1,7 @@
-import { t as ARPose } from "./ar-types-BckI1E-O.js";
-import { a as TrackingSliceState, t as DeviceOrientation } from "./tracking-slice-DJZ9qeGg.js";
-import { t as RecordingState } from "./recording-slice-B-uCgGoh.js";
-import { n as SessionMetadata } from "./opfs-storage-DMtlt57S.js";
-import { n as StorageBackend } from "./storage-backend-CTJHNdMp.js";
+import { a as TrackingSliceState } from "./tracking-slice-BuAZxXZ5.js";
+import { t as RecordingState } from "./recording-slice-DaxHZvNu.js";
+import { n as SessionMetadata } from "./opfs-storage-3VZh-qH6.js";
+import { n as StorageBackend } from "./storage-backend-BdVLD0dU.js";
 import { GpsPoint, LatLong, Matrix4, RootState, Vector3 } from "gps-plus-slam-js";
 import * as _$_reduxjs_toolkit0 from "@reduxjs/toolkit";
 import { Middleware, Reducer, ReducersMapObject, configureStore } from "@reduxjs/toolkit";
@@ -18,8 +17,7 @@ interface TrackingQualityReport {
   confidence: number;
   subScores: {
     convergence: number;
-    residualConsensus: number; /** `null` when the device cannot supply an absolute compass heading. */
-    compassAgreement: number | null;
+    residualConsensus: number;
     gpsAccuracy: number;
     coverage: number;
   };
@@ -37,9 +35,7 @@ interface TrackingQualityReport {
     medianResidualM: number;
     medianRecentGpsAccuracyM: number;
     walkedDistanceM: number;
-    directionSpreadDeg: number; /** `null` when §4.3 is unavailable (no absolute compass). */
-    headingDeltaDeg: number | null;
-    compassDriftDetected: boolean;
+    directionSpreadDeg: number;
     observationsSeen: number; /** §4.6 — diagnostic only, never feeds the aggregate. */
     gpsVsFusedMaxDivergenceM: number;
   };
@@ -61,10 +57,6 @@ interface TrackingQualityOptions {
   convergenceRotationWarnDeg?: number;
   /** §4.1 ΣΔtranslation (m) at/below which convergence scores 1.0. Fail ramp ends at 4×. */
   convergenceTranslationWarnM?: number;
-  /** §4.3 EMA threshold (deg) below which compass scores 1.0. */
-  compassWarnDeg?: number;
-  /** §4.3 EMA threshold (deg) above which compass scores 0.0. */
-  compassFailDeg?: number;
   /** Minimum GPS observations before leaving `warming-up`. */
   warmupMinObservations?: number;
   /** Minimum coverage score before leaving `warming-up`. */
@@ -73,8 +65,6 @@ interface TrackingQualityOptions {
   residualConfidenceTargetM?: number;
   /** §4.4 GPS-accuracy floor used to normalise residuals (m). */
   gpsAccuracyFloorM?: number;
-  /** §4.3 consecutive compass-agreeing observations for first agreement. */
-  firstAgreementMinStreak?: number;
   /** §4.8 consecutive sub-threshold observations before ok → degraded. */
   degradedHoldoff?: number;
   /**
@@ -97,7 +87,6 @@ interface AlignmentSnapshot {
 }
 interface TrackingQualitySliceState {
   recentAlignments: AlignmentSnapshot[];
-  firstAgreementObservationIndex: number | null;
   report: TrackingQualityReport | null;
   /** §4.8 — consecutive observations with raw confidence < degradedThreshold. */
   degradedConsecutiveCount: number;
@@ -143,7 +132,8 @@ declare function computeConvergence(snapshots: readonly AlignmentSnapshot[], opt
  * the column-major layout that gl-matrix and the framework use.
  *
  * Rotation: extract the orientation quaternion with `mat4.getRotation`
- * and compute the relative angle via `quat.getAngle` (degrees).
+ * and compute the relative angle via the shared `geodesicAngleRad` kernel
+ * (radians, converted to degrees here).
  * Translation: extract the origin column with `mat4.getTranslation` and
  * compute the Euclidean distance.
  *
@@ -206,25 +196,6 @@ declare function computeCoverage(odometryPositions: readonly Vector3[], options?
   walkedDistanceM?: number;
   directionSpreadDeg?: number;
 }): CoverageResult;
-interface CompassAgreementResult {
-  /** `null` when `absolute !== true` on the sensor orientation. */
-  score: number | null;
-  headingDeltaDeg: number | null;
-}
-/**
- * §4.3 — Compare the alignment matrix's mapping of AR-forward to ENU
- * against the device compass heading. Returns `score = null` whenever
- * the sensor's `absolute !== true` so the aggregate excludes the
- * sub-score (per Q2 in the plan).
- *
- * AR-forward in our `ARPose` convention is `(0, 0, -1)` (right-handed,
- * Y-up). We rotate that by the alignment's 3×3 rotation, take its
- * North/East components, and compare against the compass alpha.
- */
-declare function computeCompassAgreement(alignmentMatrix: Matrix4 | null, sensorOrientation: DeviceOrientation | null, arPose: ARPose | null, options?: {
-  warnDeg?: number;
-  failDeg?: number;
-}): CompassAgreementResult;
 /**
  * §4.6 — Maximum lateral distance between raw GPS positions and the
  * positions you would predict by transforming the matching odometry
@@ -234,14 +205,13 @@ declare function computeCompassAgreement(alignmentMatrix: Matrix4 | null, sensor
 declare function computeGpsVsFusedDivergence(alignmentMatrix: Matrix4 | null, gpsPositions: readonly GpsPoint[], odometryPositions: readonly Vector3[], zeroRef: LatLong | null, windowSize?: number): number;
 declare const snapshotPushed: _$_reduxjs_toolkit0.ActionCreatorWithPayload<AlignmentSnapshot, "trackingQuality/snapshotPushed">, snapshotsTrimmed: _$_reduxjs_toolkit0.ActionCreatorWithPayload<{
     size: number;
-  }, "trackingQuality/snapshotsTrimmed">, reportUpdated: _$_reduxjs_toolkit0.ActionCreatorWithPayload<TrackingQualityReport | null, "trackingQuality/reportUpdated">, firstAgreementReached: _$_reduxjs_toolkit0.ActionCreatorWithPayload<number, "trackingQuality/firstAgreementReached">, degradedCountUpdated: _$_reduxjs_toolkit0.ActionCreatorWithPayload<number, "trackingQuality/degradedCountUpdated">, resetTrackingQuality: _$_reduxjs_toolkit0.ActionCreatorWithoutPayload<"trackingQuality/resetTrackingQuality">;
+  }, "trackingQuality/snapshotsTrimmed">, reportUpdated: _$_reduxjs_toolkit0.ActionCreatorWithPayload<TrackingQualityReport | null, "trackingQuality/reportUpdated">, degradedCountUpdated: _$_reduxjs_toolkit0.ActionCreatorWithPayload<number, "trackingQuality/degradedCountUpdated">, resetTrackingQuality: _$_reduxjs_toolkit0.ActionCreatorWithoutPayload<"trackingQuality/resetTrackingQuality">;
 declare const trackingQualityReducer: _$_reduxjs_toolkit0.Reducer<TrackingQualitySliceState>;
 interface RootWithTrackingQuality {
   trackingQuality?: TrackingQualitySliceState;
 }
 declare function selectTrackingQuality(state: RootWithTrackingQuality): TrackingQualityReport | null;
 declare function selectRecentAlignments(state: RootWithTrackingQuality): readonly AlignmentSnapshot[];
-declare function selectFirstAgreementObservationIndex(state: RootWithTrackingQuality): number | null;
 /**
  * Pure function — produces a {@link TrackingQualityReport} from a root
  * state and options. The Investigation harness imports this directly to
@@ -339,6 +309,46 @@ interface SlamAppStoreOptions<ExtraReducers extends ReducersMapObject = Record<s
    * @see docs/2026-05-16-tracking-quality-metrics-plan.md
    */
   trackingQualityOptions?: Partial<TrackingQualityOptions>;
+  /**
+   * Enable the library's Phase-4 **Stage-0** cold-start compass yaw override.
+   * **Default `true`** — Stage 0 is a field-validated, default-on feature: at
+   * cold start the GPS-derived yaw is unobservable (clustered fixes ⇒ a yaw set
+   * by noise that flips as the user looks around), so the compass heading gives
+   * a roughly-correct, stable orientation immediately ("open app, stand still,
+   * look around" works). It is an observability-gated handover — once a walked
+   * baseline conditions the GPS yaw, the solve hands back to GPS — so it does no
+   * harm once GPS is observable. Pass `false` to opt out (the recorder exposes
+   * this as a settings toggle).
+   *
+   * When enabled the factory dispatches `setColdStartOverrideEnabled(true)` the
+   * first time `gpsData` becomes non-null (right after the first `setZeroPos`,
+   * since the flag lives on that slice and cannot be set before it exists).
+   *
+   * Replay/determinism: the library's `DefaultAlignmentConfig` stays OFF, so
+   * historical recordings replay unchanged; default-on lives here as a recorded
+   * `gpsData` action. A recording made with this on therefore replays with the
+   * override on. **For Stage-A/§6a field-calibration recordings, turn this OFF**
+   * (recorder settings) so the captured compass behaviour is unmodified.
+   *
+   * @see GpsPlusSlamJs_Docs/docs/2026-06-26-stage0-field-collection-and-enablement.md
+   */
+  enableCompassColdStartOverride?: boolean;
+  /**
+   * **Debug/experiment flag** — enable the library's Phase-4 **Stage-C**
+   * trust-gated compass rotation prior (keeps a steady compass vote once GPS yaw
+   * is observable + the compass is trusted; supersedes Stage 0). Dispatches
+   * `setCompassRotationPriorEnabled(true)` once `gpsData` exists. Default `false`
+   * ⇒ byte-identical. Like the Stage-0 flag, the action persists into recordings.
+   */
+  enableCompassRotationPrior?: boolean;
+  /**
+   * **Debug/experiment flag** — enable the library's GPS-free compass↔WebXR
+   * consistency gate. When on, the compass override (Stage 0 / Stage C) abstains
+   * unless the compass is rotating in lock-step with the WebXR pose. Dispatches
+   * `setCompassWebXRConsistencyEnabled(true)` once `gpsData` exists. Default
+   * `false` ⇒ byte-identical. The action persists into recordings.
+   */
+  enableCompassWebXRConsistency?: boolean;
 }
 /**
  * Combined root state: the framework's base state plus any caller-supplied
@@ -368,4 +378,4 @@ interface SlamAppStore<ExtraReducers extends ReducersMapObject = Record<string,
  */
 declare function createSlamAppStore<ExtraReducers extends ReducersMapObject = Record<string, never>>(options: SlamAppStoreOptions<ExtraReducers>): SlamAppStore<ExtraReducers>;
 //#endregion
-export { resetTrackingQuality as A, computeResidualConsensus as C, firstAgreementReached as D, degradedCountUpdated as E, snapshotsTrimmed as F, trackingQualityReducer as I, CombinedRootState as L, selectRecentAlignments as M, selectTrackingQuality as N, matrixDelta as O, snapshotPushed as P, computeGpsVsFusedDivergence as S, createTrackingQualityListenerMiddleware as T, TrackingQualityState as _, SlamAppStoreOptions as a, computeCoverage as b, CompassAgreementResult as c, DEFAULT_TRACKING_QUALITY_OPTIONS as d, GpsAccuracyResult as f, TrackingQualitySliceState as g, TrackingQualityReport as h, SlamAppStore as i, selectFirstAgreementObservationIndex as j, reportUpdated as k, ConvergenceResult as l, TrackingQualityOptions as m, SlamAppMiddleware as n, createSlamAppStore as o, ResidualConsensusResult as p, SlamAppRootState as r, AlignmentSnapshot as s, SlamAppCombinedState as t, CoverageResult as u, computeCompassAgreement as v, computeTrackingQualityReport as w, computeGpsAccuracy as x, computeConvergence as y };
+export { snapshotPushed as A, createTrackingQualityListenerMiddleware as C, resetTrackingQuality as D, reportUpdated as E, trackingQualityReducer as M, CombinedRootState as N, selectRecentAlignments as O, computeTrackingQualityReport as S, matrixDelta as T, computeConvergence as _, SlamAppStoreOptions as a, computeGpsVsFusedDivergence as b, ConvergenceResult as c, GpsAccuracyResult as d, ResidualConsensusResult as f, TrackingQualityState as g, TrackingQualitySliceState as h, SlamAppStore as i, snapshotsTrimmed as j, selectTrackingQuality as k, CoverageResult as l, TrackingQualityReport as m, SlamAppMiddleware as n, createSlamAppStore as o, TrackingQualityOptions as p, SlamAppRootState as r, AlignmentSnapshot as s, SlamAppCombinedState as t, DEFAULT_TRACKING_QUALITY_OPTIONS as u, computeCoverage as v, degradedCountUpdated as w, computeResidualConsensus as x, computeGpsAccuracy as y };

package/dist/{depth-grid-lookup-vMDrGTk_.d.ts → depth-grid-lookup-DQ-IYhO3.d.ts}

@@ -1,4 +1,4 @@
-import { r as DepthPoint } from "./ar-types-BckI1E-O.js";
+import { r as DepthPoint } from "./ar-types-BFX2r1wk.js";
 
 //#region ../src/ar/depth-grid-lookup.d.ts
 interface DepthGridLookup {

package/dist/{depth-sampler-DwfPYzS7.d.ts → depth-sampler-asc8exHt.d.ts}

@@ -1,4 +1,4 @@
-import { a as RgbTuple, i as DepthSample, t as ARPose } from "./ar-types-BckI1E-O.js";
+import { a as RgbTuple, i as DepthSample, t as ARPose } from "./ar-types-BFX2r1wk.js";
 import { Matrix4 } from "gps-plus-slam-js";
 
 //#region ../src/ar/depth-rgb-lookup.d.ts

package/dist/{depth-unprojection-CK3b9htH.d.ts → depth-unprojection-DjsbJW9L.d.ts}

@@ -1,4 +1,4 @@
-import { r as DepthPoint } from "./ar-types-BckI1E-O.js";
+import { r as DepthPoint } from "./ar-types-BFX2r1wk.js";
 import { Matrix4, Quaternion, Vector3 } from "gps-plus-slam-js";
 
 //#region ../src/ar/depth-unprojection.d.ts

package/dist/{enable-gps-ar-CjZ1nEdu.d.ts → enable-gps-ar-DkNhFv4Y.d.ts}

@@ -1,7 +1,7 @@
-import { t as ArCrashIsolationOptions } from "./recording-options-D93kksJU.js";
-import { n as RawDeviceOrientation, t as GpsPosition } from "./gps-C5inWeNV.js";
-import { n as PermissionStatus } from "./permission-checker-CtPtPQRq.js";
-import { r as SessionFeatureOptions } from "./webxr-session-COsOjJwn.js";
+import { t as ArCrashIsolationOptions } from "./recording-options-BPCpMHLK.js";
+import { n as RawDeviceOrientation, t as GpsPosition } from "./gps-BBO3hKfT.js";
+import { n as PermissionStatus } from "./permission-checker-CDuI8BwC.js";
+import { r as SessionFeatureOptions } from "./webxr-session-Do5L6G3B.js";
 
 //#region ../src/ar/enable-gps-ar.d.ts
 /**

package/dist/{frame-conversions-D_Af8Dt3.d.ts → frame-conversions-DObhj8Wf.d.ts}

@@ -1,4 +1,4 @@
-import { i as LatLongAlt, r as LatLong } from "./index-eaI1Z1KR.js";
+import { i as LatLongAlt, r as LatLong } from "./index-_Rhgoqkh.js";
 import * as THREE from "three";
 
 //#region ../src/visualization/frame-conversions.d.ts