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

package/dist/image-capture-DVcuqMtX.js

@@ -0,0 +1,374 @@
+import { createLogger } from "./utils/logger.js";
+import { t as geodesicAngleRad } from "./geodesic-angle-BTldfFgs.js";
+import { n as MotionWindow, r as decideCapture, t as DEFAULT_MOTION_FILTER } from "./capture-motion-gate-_NdTSwKi.js";
+import { DEFAULT_QUALITY_FILTER } from "./ar/image-quality.js";
+import { quat } from "gl-matrix";
+//#region ../src/ar/pose-motion.ts
+/**
+* Pose-motion helpers — stateless angular/linear velocity from two AR poses.
+*
+* The capture motion gate (blurry-frame skipping, see
+* `GpsPlusSlamJs_Docs/docs/2026-06-23-blurry-frame-motion-gating-plan.md` §4.1)
+* rejects frames whose device motion is too fast to yield a sharp image. Motion
+* is derived from consecutive WebXR poses — cheaper than any image-content
+* metric because it needs no GPU readback.
+*
+* This module holds ONLY the pure, stateless math (angle ÷ dt, distance ÷ dt).
+* The stateful policy (sliding window, glitch rejection, the capture decision)
+* lives in `ImageCaptureManager` and `capture-motion-gate.ts` — keeping the
+* reusable atom separate from the capture-specific policy (plan §4.1 "Scope").
+*
+* Angular velocity reuses the shared `geodesicAngleRad` kernel rather than a
+* fresh `acos` (CLAUDE.md: search first, prefer refactor over re-implementation).
+*/
+/**
+* Convert a WebXR object-form quaternion to a normalized gl-matrix quaternion.
+* Normalizing defends against slightly non-unit inputs (the gate must not throw
+* on imperfect tracking data).
+*/
+function toGlQuat(q) {
+	const g = quat.fromValues(q.x, q.y, q.z, q.w);
+	return quat.normalize(g, g);
+}
+/**
+* Angular velocity in radians/second between two orientations.
+*
+* @param qPrev - orientation at the previous frame.
+* @param qCur - orientation at the current frame.
+* @param dtSeconds - elapsed time in seconds (must be > 0).
+* @returns geodesic angle between the orientations divided by `dtSeconds`.
+*   Returns `0` when `dtSeconds <= 0` (degenerate/duplicate frame timestamp) so
+*   a bad delta can never produce `Infinity`/`NaN` and spuriously flip the
+*   motion gate. Double-cover safe (`q` ≡ `−q`) via the shared kernel.
+*/
+function angularVelocity(qPrev, qCur, dtSeconds) {
+	if (!(dtSeconds > 0)) return 0;
+	return geodesicAngleRad(toGlQuat(qPrev), toGlQuat(qCur)) / dtSeconds;
+}
+/**
+* Linear velocity in metres/second between two positions.
+*
+* @param pPrev - position at the previous frame.
+* @param pCur - position at the current frame.
+* @param dtSeconds - elapsed time in seconds (must be > 0).
+* @returns straight-line distance divided by `dtSeconds`. Returns `0` when
+*   `dtSeconds <= 0` (same guard rationale as {@link angularVelocity}).
+*/
+function linearVelocity(pPrev, pCur, dtSeconds) {
+	if (!(dtSeconds > 0)) return 0;
+	const dx = pCur.x - pPrev.x;
+	const dy = pCur.y - pPrev.y;
+	const dz = pCur.z - pPrev.z;
+	return Math.sqrt(dx * dx + dy * dy + dz * dz) / dtSeconds;
+}
+//#endregion
+//#region ../src/ar/image-capture.ts
+/**
+* Image Capture Module
+*
+* Captures periodic JPEG screenshots from the WebGL canvas during AR recording.
+* Uses async toBlob() for better performance (non-blocking).
+*
+* Includes validation to detect suspiciously small images (likely black/empty)
+* which can occur on mobile devices when the WebGL context hasn't composited yet.
+*/
+const log = createLogger("ImageCapture");
+/**
+* Minimum expected blob size in bytes for a valid JPEG image.
+* A black/empty 1920x1080 JPEG still compresses to ~2-3KB due to headers.
+* A real camera frame at 0.7 quality should be 50KB+.
+* We use a conservative threshold to catch obviously broken captures.
+*/
+const MIN_VALID_IMAGE_BYTES = 5e3;
+/**
+* Default capture configuration
+*/
+const DEFAULT_CAPTURE_CONFIG = {
+	intervalMs: 2e3,
+	quality: .7,
+	captureTimeoutMs: 5e3,
+	resolutionDivisor: 1,
+	motionFilter: DEFAULT_MOTION_FILTER,
+	qualityFilter: DEFAULT_QUALITY_FILTER
+};
+/**
+* Manages periodic image capture from a canvas.
+*
+* Usage:
+* 1. Create with canvas and callbacks
+* 2. Call start() when recording begins
+* 3. Call onFrame(time) each XR frame
+* 4. Call stop() when recording ends
+*/
+var ImageCaptureManager = class {
+	canvas;
+	callbacks;
+	config;
+	capturing = false;
+	lastCaptureTime = 0;
+	frameCount = 0;
+	captureInProgress = false;
+	captureTimeoutId = null;
+	/** True while an `analyzeFrame` verdict is in flight; blocks a second capture
+	*  for the same interval without throttling normal cadence (captureInProgress
+	*  is released after encode, NOT held across the round-trip). */
+	awaitingVerdict = false;
+	/** The current interval's capture was rejected by the quality gate; bypass the
+	*  interval guard so the next acceptable frame is grabbed immediately. */
+	retryPending = false;
+	/** Frame time (ms) of the FIRST quality attempt for the current interval; the
+	*  quality `maxWaitMs` fallback measures from here, independent of the motion
+	*  gate's own due clock. `null` between intervals. */
+	qualityDeadlineBase = null;
+	/** Safety timeout for a hung `analyzeFrame` (fail-open). */
+	verdictTimeoutId = null;
+	/** Sliding window of recent per-frame velocities for the motion gate. */
+	motionWindow = new MotionWindow();
+	/** Previous frame's pose, for the per-frame velocity delta. */
+	prevPose = null;
+	/** Previous frame's timestamp (ms), for the per-frame velocity delta. */
+	prevTime = 0;
+	/** Whether THIS frame's velocity sample was rejected as a tracking glitch. */
+	lastSampleWasGlitch = false;
+	/** When the current capture first became due (ms); null while not due. The
+	*  `maxWaitMs` fallback measures from here, not from `lastCaptureTime`. */
+	dueTime = null;
+	constructor(canvas, callbacks, config = DEFAULT_CAPTURE_CONFIG) {
+		this.canvas = canvas;
+		this.callbacks = callbacks;
+		this.config = config;
+	}
+	/**
+	* Start capturing images.
+	* Resets frame counter and last capture time.
+	*/
+	start() {
+		this.capturing = true;
+		this.lastCaptureTime = 0;
+		this.frameCount = 0;
+		this.motionWindow.reset();
+		this.prevPose = null;
+		this.prevTime = 0;
+		this.lastSampleWasGlitch = false;
+		this.dueTime = null;
+		this.clearVerdictTimeout();
+		this.awaitingVerdict = false;
+		this.retryPending = false;
+		this.qualityDeadlineBase = null;
+	}
+	/**
+	* Stop capturing images.
+	* Clears any pending safety timeout and resets in-flight capture state.
+	*/
+	stop() {
+		this.capturing = false;
+		this.clearCaptureTimeout();
+		this.captureInProgress = false;
+		this.clearVerdictTimeout();
+		this.awaitingVerdict = false;
+		this.retryPending = false;
+		this.qualityDeadlineBase = null;
+	}
+	/**
+	* Check if capture manager is active.
+	*/
+	isCapturing() {
+		return this.capturing;
+	}
+	/**
+	* Get the current frame count.
+	*/
+	getFrameCount() {
+		return this.frameCount;
+	}
+	/**
+	* Called each XR frame to check if a capture is needed.
+	*
+	* @param time - Frame timestamp in milliseconds (from requestAnimationFrame)
+	*/
+	onFrame(time) {
+		if (!this.capturing) return;
+		const pose = this.callbacks.getCurrentPose();
+		this.updateMotionWindow(time, pose);
+		if (this.captureInProgress || this.awaitingVerdict) return;
+		const elapsed = time - this.lastCaptureTime;
+		if (!this.retryPending && this.lastCaptureTime > 0 && elapsed < this.config.intervalMs) {
+			this.dueTime = null;
+			return;
+		}
+		if (!pose) return;
+		if (this.dueTime === null) this.dueTime = time;
+		if (!this.shouldCaptureNow(time)) return;
+		this.captureInProgress = true;
+		this.lastCaptureTime = time;
+		this.dueTime = null;
+		const timestamp = performance.timeOrigin + time;
+		const screenRotation = this.callbacks.getScreenRotation();
+		this.captureTimeoutId = setTimeout(() => {
+			if (this.captureInProgress) {
+				log.error(`Capture timeout after ${this.config.captureTimeoutMs}ms — force-resetting captureInProgress`);
+				this.captureInProgress = false;
+				this.captureTimeoutId = null;
+			}
+		}, this.config.captureTimeoutMs);
+		if (this.callbacks.captureFrame) this.callbacks.captureFrame(this.config.quality).then((frame) => {
+			this.handleCapturedBlob(frame?.blob ?? null, frame?.width, frame?.height, timestamp, time, pose, screenRotation);
+		}).catch(() => {
+			this.clearCaptureTimeout();
+			this.captureInProgress = false;
+			this.callbacks.onCaptureFailed?.();
+		});
+		else this.canvas.toBlob((blob) => {
+			this.handleCapturedBlob(blob, this.canvas.width, this.canvas.height, timestamp, time, pose, screenRotation);
+		}, "image/jpeg", this.config.quality);
+	}
+	/**
+	* Sample per-frame device motion into the sliding window. Called every frame
+	* (even during an in-flight capture or before the interval elapses) so the
+	* window reflects truly instantaneous motion the moment a capture becomes
+	* due. A frame with no pose, or a non-positive dt (duplicate timestamp),
+	* records no sample and is treated as "not a glitch".
+	*/
+	updateMotionWindow(time, pose) {
+		if (!pose) {
+			this.lastSampleWasGlitch = false;
+			this.motionWindow.reset();
+			this.prevPose = null;
+			this.prevTime = 0;
+			this.retryPending = false;
+			this.qualityDeadlineBase = null;
+			return;
+		}
+		if (this.prevPose && this.prevTime > 0) {
+			const dt = (time - this.prevTime) / 1e3;
+			if (dt > 0) {
+				const angVel = angularVelocity(this.prevPose.orientation, pose.orientation, dt);
+				const linVel = linearVelocity(this.prevPose.position, pose.position, dt);
+				this.lastSampleWasGlitch = !this.motionWindow.push(angVel, linVel);
+			} else this.lastSampleWasGlitch = false;
+		} else this.lastSampleWasGlitch = false;
+		this.prevPose = pose;
+		this.prevTime = time;
+	}
+	/**
+	* Apply the motion gate to a due capture. Returns `true` to capture now,
+	* `false` to defer to a later frame.
+	*
+	* - Filter disabled → always `true` (legacy behavior).
+	* - `maxWaitMs` elapsed → always `true` (never-calm safety fallback; an
+	*   interval is never silently lost).
+	* - Current frame's sample was a tracking glitch → `false` (don't grab a
+	*   relocalization-teleport frame; the fallback still guarantees progress).
+	* - No measurable motion yet (first capture / all-glitch) → `true` (the very
+	*   first capture is never blocked; only measurable motion defers).
+	* - Otherwise → defer to {@link decideCapture} over the windowed maxima.
+	*/
+	shouldCaptureNow(time) {
+		const mf = this.config.motionFilter;
+		if (!mf || !mf.enabled) return true;
+		const msSinceDue = this.dueTime === null ? 0 : time - this.dueTime;
+		if (msSinceDue >= mf.maxWaitMs) return true;
+		if (this.lastSampleWasGlitch) return false;
+		if (!this.motionWindow.hasSamples()) return true;
+		return decideCapture({
+			windowMaxAngular: this.motionWindow.maxAngular(),
+			windowMaxLinear: this.motionWindow.maxLinear(),
+			maxAngularVelocity: mf.maxAngularVelocity,
+			maxLinearVelocity: mf.maxLinearVelocity,
+			msSinceDue,
+			maxWaitMs: mf.maxWaitMs
+		}) === "capture";
+	}
+	/**
+	* Clear the safety timeout for captureInProgress.
+	* Called when capture completes (success or failure) before the timeout fires.
+	*/
+	clearCaptureTimeout() {
+		if (this.captureTimeoutId !== null) {
+			clearTimeout(this.captureTimeoutId);
+			this.captureTimeoutId = null;
+		}
+	}
+	/** Clear the safety timeout for a hung `analyzeFrame` verdict. */
+	clearVerdictTimeout() {
+		if (this.verdictTimeoutId !== null) {
+			clearTimeout(this.verdictTimeoutId);
+			this.verdictTimeoutId = null;
+		}
+	}
+	/**
+	* Common handler for captured blobs (from either canvas.toBlob or captureFrame).
+	* Releases `captureInProgress` after the synchronous encode, then either saves
+	* immediately (legacy / gate-off) or runs the off-thread image-quality gate.
+	*
+	* @param time - the XR frame time the capture was dispatched at; the quality
+	*   retry-deadline clock and `lastCaptureTime` are measured from it.
+	*/
+	handleCapturedBlob(blob, width, height, timestamp, time, pose, screenRotation) {
+		this.clearCaptureTimeout();
+		this.captureInProgress = false;
+		if (!blob) {
+			this.callbacks.onCaptureFailed?.();
+			return;
+		}
+		const qf = this.config.qualityFilter;
+		const analyze = this.callbacks.analyzeFrame;
+		if (!analyze || !qf || !qf.enabled) {
+			this.saveCapture(blob, width, height, timestamp, pose, screenRotation);
+			return;
+		}
+		if (this.qualityDeadlineBase === null) this.qualityDeadlineBase = time;
+		if (time - this.qualityDeadlineBase >= qf.maxWaitMs) {
+			this.saveCapture(blob, width, height, timestamp, pose, screenRotation);
+			return;
+		}
+		this.awaitingVerdict = true;
+		let settled = false;
+		const finish = (accept, viaTimeout) => {
+			if (settled || !this.capturing) return;
+			settled = true;
+			this.clearVerdictTimeout();
+			this.awaitingVerdict = false;
+			if (viaTimeout) log.error("analyzeFrame verdict timed out — saving frame fail-open to keep the pipeline live");
+			if (accept) this.saveCapture(blob, width, height, timestamp, pose, screenRotation);
+			else this.retryPending = true;
+		};
+		this.verdictTimeoutId = setTimeout(() => finish(true, true), this.config.captureTimeoutMs);
+		analyze({
+			blob,
+			width: width ?? 0,
+			height: height ?? 0
+		}).then((verdict) => finish(verdict.accept, false)).catch((err) => {
+			log.error("analyzeFrame failed — saving frame without quality gate", err);
+			finish(true, false);
+		});
+	}
+	/**
+	* Persist an accepted frame: allocate its 1-based index, run the suspicious-
+	* size belt-and-suspenders check, reset the per-interval gate clocks, and fire
+	* `onCaptured`. Called from the legacy path, the quality fallbacks, and an
+	* accepting verdict — the single place a frame becomes durable.
+	*/
+	saveCapture(blob, width, height, timestamp, pose, screenRotation) {
+		if (!this.capturing) return;
+		this.retryPending = false;
+		this.qualityDeadlineBase = null;
+		const frameIndex = ++this.frameCount;
+		if (blob.size < 5e3) {
+			log.error(`Suspicious image at frame ${frameIndex}: blob size ${blob.size} bytes is below minimum ${MIN_VALID_IMAGE_BYTES} bytes. Image may be black/empty.`);
+			this.callbacks.onSuspiciousImage?.(blob.size, frameIndex);
+		}
+		this.callbacks.onCaptured({
+			blob,
+			timestamp,
+			frameIndex,
+			position: pose.position,
+			rotation: pose.orientation,
+			screenRotation,
+			...width && width > 0 ? { width } : {},
+			...height && height > 0 ? { height } : {}
+		});
+	}
+};
+//#endregion
+export { ImageCaptureManager as n, MIN_VALID_IMAGE_BYTES as r, DEFAULT_CAPTURE_CONFIG as t };

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

@@ -0,0 +1,158 @@
+//#region ../src/ar/image-quality.d.ts
+/**
+ * Image-quality metrics + the drop/retry verdict policy for the image-content
+ * capture gate (blur + blackness), the increment layered ON TOP of the motion
+ * gate (`capture-motion-gate.ts`).
+ *
+ * Everything here is **pure and deterministic** — plain typed-array math plus a
+ * tiny rolling-history class. There is **no DOM and no Web Worker** in this
+ * module: it is fully unit-testable with synthetic buffers, and the recorder's
+ * `image-quality.worker.ts` is a thin shell that decodes a frame to pixels and
+ * calls into these functions. Keeping the verdict/history policy here (rather
+ * than inside the worker, as the original plan §8 sketched) honours the project
+ * rule that no untested logic ships: the worker is the device layer and is not
+ * unit-built, so the median/threshold decision must live where tests can pin it.
+ *
+ * Metrics:
+ *  - {@link sharpnessScore} — variance of the Laplacian over a grayscale buffer
+ *    (the standard Pech-Pacheco focus measure). Scene-dependent in absolute
+ *    terms, so the gate compares it RELATIVE to a rolling median (§5).
+ *  - {@link meanLuminance} — mean Rec. 601 luma of an RGBA buffer. Near-zero ⇒
+ *    black/empty frame; an absolute cutoff is safe because "black is black"
+ *    regardless of scene texture (§5).
+ *
+ * @see GpsPlusSlamJs_Docs/docs/2026-06-24-image-quality-gate-plan.md
+ * @see ./capture-motion-gate.ts — the motion gate this builds on (same shape:
+ *   a shared config type + a small stateful window + a pure decision).
+ */
+/**
+ * User-/consumer-facing configuration for the image-quality gate. 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, exactly as `MotionFilterConfig` is
+ * shared (see `capture-motion-gate.ts` and the motion-gate follow-up §3).
+ */
+interface QualityFilterConfig {
+  /** Master switch for the image-quality gate. Default `false` (see below). */
+  enabled: boolean;
+  /**
+   * Blur cutoff as a fraction `k` of the recent sharpness median: a frame is
+   * judged blurry when its sharpness `< k · median(recent)`. ~0.5 is a sensible
+   * start. Relative (not absolute) because variance-of-Laplacian is
+   * scene-dependent — a correctly-focused blank wall scores low (§5).
+   */
+  blurRelativeThreshold: number;
+  /**
+   * Absolute black cutoff on a 0–255 luma scale: a frame whose mean luminance is
+   * below this is judged black/empty and dropped. Absolute is safe because black
+   * is black regardless of scene (§5). Supersedes the byte-size
+   * `MIN_VALID_IMAGE_BYTES` heuristic for correctness (kept as a cheap
+   * pre-filter).
+   */
+  minMeanLuminance: number;
+  /**
+   * Never-good safety fallback: once a due capture has been retried for this many
+   * ms without an acceptable frame, the next frame is saved regardless of the
+   * image verdict, so a recording interval is never silently lost (mirrors the
+   * motion gate's `maxWaitMs`). A sensible value is ~2× the capture interval.
+   */
+  maxWaitMs: number;
+}
+/**
+ * Default image-quality configuration. **Disabled by default** (plan §10): the
+ * relative blur threshold is unvalidated, and a mis-tuned gate silently dropping
+ * good frames for every consumer app is worse than the motion gate's low-risk
+ * default-on. Flip to `true` once the thresholds are field-tuned. The numeric
+ * values are PLACEHOLDERS pending on-device tuning (record measured values in
+ * implementation-progress.md). `maxWaitMs` of 4000 ms is 2× the default 2000 ms
+ * image interval.
+ */
+declare const DEFAULT_QUALITY_FILTER: QualityFilterConfig;
+/** Default number of recent (non-black) sharpness scores the gate keeps. */
+declare const DEFAULT_SHARPNESS_HISTORY_SIZE = 15;
+/**
+ * Default minimum samples before the relative blur check engages. Below this the
+ * gate is in "cold start" and accepts every non-black frame — the same
+ * "no baseline yet ⇒ don't block" principle the motion gate uses for an empty
+ * window.
+ */
+declare const DEFAULT_SHARPNESS_MIN_SAMPLES = 3;
+/**
+ * Compute the **variance of the Laplacian** of a single-channel grayscale image
+ * — the standard focus measure (higher ⇒ sharper / more in-focus).
+ *
+ * The discrete Laplacian per interior pixel is
+ * `up + down + left + right − 4·centre` (the 4-neighbour kernel); the score is
+ * the variance of that response over all interior pixels. A flat/constant image
+ * yields 0; a focused, textured image yields a large value.
+ *
+ * Defensive: returns `0` (rather than throwing or `NaN`) for any input that has
+ * no interior pixels — non-integer or `< 3` dimensions, or a buffer shorter than
+ * `width · height`. A tiny negative variance from floating-point cancellation is
+ * clamped to 0.
+ *
+ * @param gray  Row-major single-channel intensities, length ≥ `width · height`.
+ * @param width  Image width in pixels.
+ * @param height Image height in pixels.
+ */
+declare function sharpnessScore(gray: Uint8Array | Uint8ClampedArray | readonly number[], width: number, height: number): number;
+/**
+ * Convert an RGBA buffer to a single-channel grayscale (Rec. 601 luma) buffer,
+ * the input {@link sharpnessScore} expects. Pure; ignores the alpha channel. A
+ * partial trailing pixel (length not a multiple of 4) is ignored.
+ */
+declare function rgbaToGrayscale(rgba: Uint8Array | Uint8ClampedArray): Uint8ClampedArray;
+/**
+ * Mean Rec. 601 luma (`0.299R + 0.587G + 0.114B`) over an RGBA buffer, on a
+ * 0–255 scale. Near-zero ⇒ black/empty frame. Alpha is ignored. Returns `0` for
+ * an empty buffer.
+ */
+declare function meanLuminance(rgba: Uint8Array | Uint8ClampedArray): number;
+/** Reason a frame was rejected by the quality gate, or `null` when accepted. */
+type QualityRejectReason = 'black' | 'blurry';
+/** Outcome of evaluating one frame against the quality gate. */
+interface QualityVerdict {
+  /** `true` to save the frame, `false` to drop + retry. */
+  readonly accept: boolean;
+  /** Why it was dropped, or `null` when accepted. */
+  readonly reason: QualityRejectReason | null;
+  /** The frame's variance-of-Laplacian sharpness (for logging/tuning). */
+  readonly sharpness: number;
+  /** The frame's mean luminance (for logging/tuning). */
+  readonly meanLuminance: number;
+}
+/**
+ * The self-calibrating blur+blackness verdict, with the rolling sharpness
+ * history that makes the blur check scene-relative (§5). Stateful but pure (no
+ * DOM/worker): one instance per recording session, fed each analysed frame's
+ * metrics.
+ *
+ * Policy per frame ({@link evaluate}):
+ *  1. **Blackness — absolute.** `meanLuminance < config.minMeanLuminance` ⇒
+ *     reject `'black'`. The score is NOT recorded (a black frame's ~0 sharpness
+ *     must not drag the median down and disarm the blur check).
+ *  2. **Blur — relative.** Once at least `minSamples` non-black frames have been
+ *     seen, reject `'blurry'` when `sharpness < blurRelativeThreshold · median`.
+ *     Before that (cold start) every non-black frame is accepted.
+ *  3. The non-black frame's sharpness is recorded into the rolling window
+ *     (capped at `historySize`) so the median tracks the scene's texture level —
+ *     including a genuinely softening scene, which gradually lowers the bar (the
+ *     §10 "retry storm" regime where the fallback then guarantees progress).
+ */
+declare class ImageQualityGate {
+  private readonly history;
+  private readonly historySize;
+  private readonly minSamples;
+  constructor(historySize?: number, minSamples?: number);
+  /**
+   * Judge one frame from its precomputed metrics + the current config, updating
+   * the rolling history. See the class doc for the policy.
+   */
+  evaluate(sharpness: number, meanLum: number, config: QualityFilterConfig): QualityVerdict;
+  /** Number of (non-black) sharpness samples currently retained. */
+  historyLength(): number;
+  /** Clear the rolling history (e.g. on a new recording session). */
+  reset(): void;
+}
+//#endregion
+export { QualityFilterConfig as a, meanLuminance as c, ImageQualityGate as i, rgbaToGrayscale as l, DEFAULT_SHARPNESS_HISTORY_SIZE as n, QualityRejectReason as o, DEFAULT_SHARPNESS_MIN_SAMPLES as r, QualityVerdict as s, DEFAULT_QUALITY_FILTER as t, sharpnessScore as u };

package/dist/index-D4vrgV4b.d.ts

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

package/dist/index-D74JTX4I.d.ts

@@ -0,0 +1,22 @@
+import { ReadonlyQuat } from "gl-matrix";
+
+//#region ../src/utils/geodesic-angle.d.ts
+/**
+ * Geodesic (shortest-arc) rotation angle in radians between two **unit**
+ * quaternions.
+ *
+ * Uses `cos θ = 2·dot² − 1`, which is invariant to the sign of either input
+ * (`q` ≡ `−q`, the quaternion double cover) because it depends only on `dot²`.
+ * The argument is clamped to `[-1, 1]` before `acos` so float error on a
+ * near-identical pair (where `2·dot² − 1` can drift slightly above 1) returns
+ * `0` rather than `NaN` — this is the guard `matrixDelta` previously applied
+ * explicitly around the raw `quat.getAngle`.
+ *
+ * Precondition: both inputs are (approximately) unit length. Callers that hold
+ * un-normalized quaternions must normalize first (gl-matrix `quat.normalize`).
+ *
+ * @returns angle in radians, in `[0, π]`. Never `NaN` for finite unit inputs.
+ */
+declare function geodesicAngleRad(a: ReadonlyQuat, b: ReadonlyQuat): number;
+//#endregion
+export { geodesicAngleRad as t };

package/dist/{index-m_LneUSi.d.ts → index-DlsOo2IB.d.ts}

@@ -1,4 +1,4 @@
-import { L as CombinedRootState, h as TrackingQualityReport } from "./create-slam-app-store-Ce2FMKCp.js";
+import { N as CombinedRootState, m as TrackingQualityReport } from "./create-slam-app-store-D3nzh9Wb.js";
 import { Add2dImagePayload, GpsPoint as GpsPoint$1, LatLong as LatLong$1, RawDeviceOrientation, RawGpsPoint as RawGpsPoint$1, RecordGpsEventPayload as RecordGpsEventPayload$1, add2dImage, calcRelativeCoordsInMeters, recordGpsEvent as recordGpsEvent$1, setZeroPos as setZeroPos$1 } from "gps-plus-slam-js";
 
 //#region ../src/state/onboarding-guidance.d.ts

package/dist/{index-BvLo2poy.d.ts → index-cCQWuYqy.d.ts}

@@ -1,6 +1,6 @@
-import { t as GridCell } from "./bresenham3d-ByjcmEgM.js";
-import { a as QrPoseSolution, i as Pose, r as Point2, t as CameraIntrinsics } from "./qr-pose-Bt2reSw7.js";
-import { a as QrFrontEnd, o as RgbaImage } from "./qr-frontend-DufZp2xS.js";
+import { t as GridCell } from "./bresenham3d-DGc4nIb-.js";
+import { a as QrPoseSolution, i as Pose, r as Point2, t as CameraIntrinsics } from "./qr-pose-y3vaEd6x.js";
+import { a as QrFrontEnd, o as RgbaImage } from "./qr-frontend-BPURlh3S.js";
 import { Quaternion, RecordGpsEventPayload, Vector3 } from "gps-plus-slam-js";
 
 //#region ../src/ar/qr-gps-vote.d.ts