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

package/dist/absolute-orientation-CAEh840t.d.ts

@@ -0,0 +1,54 @@
+//#region ../src/sensors/absolute-orientation.d.ts
+/**
+ * AbsoluteOrientationSensor capture (Generic Sensor API).
+ *
+ * Phase 1 of the AbsoluteOrientationSensor plan
+ * (GpsPlusSlamJs_Docs/docs/2026-06-25-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.
+ *
+ * Platform: Chrome Android only. Safari / Firefox / desktop / iOS lack the
+ * sensor → this module degrades to a clean, reported no-op.
+ *
+ * The raw `'device'` reference frame is recorded together with the screen angle
+ * so either the device- or screen-compensated form can be reconstructed offline
+ * (plan §8 Q1).
+ */
+/** A single absolute-orientation reading, snapshotted into the GPS event payload. */
+interface AbsoluteOrientationReading {
+  /** [x,y,z,w] quaternion mapping device-frame → Earth ENU (+X East, +Y North, +Z Up). */
+  quaternion: [number, number, number, number];
+  /** Reference frame the quaternion is expressed in. We record raw 'device'. */
+  referenceFrame: 'device' | 'screen';
+  /** screen.orientation.angle at sample time — needed to reconstruct the 'device' frame. */
+  screenAngleDeg: number;
+  /** Capture time (epoch ms) — pairs with the GPS event; lets warm-up be detected offline. */
+  timestamp: number;
+}
+/** Lifecycle status surfaced to the caller (HUD/observability). */
+type AbsoluteOrientationStatus = {
+  state: 'active';
+} | {
+  state: 'unavailable';
+  reason: string;
+} | {
+  state: 'error';
+  reason: string;
+};
+/** True when the sensor can plausibly run here (secure context + API present). */
+declare function isAbsoluteOrientationAvailable(): boolean;
+/**
+ * Start capturing absolute orientation. Idempotent (stops any prior watch first).
+ *
+ * On platforms without the sensor — or when permissions are denied — it reports
+ * `unavailable`/`error` via `onStatus` and stays a no-op; the recorder keeps
+ * working unchanged. Never throws.
+ */
+declare function startAbsoluteOrientationWatch(onStatus?: (status: AbsoluteOrientationStatus) => void): Promise<void>;
+/** Latest reading, or null when unavailable/not-yet-warmed-up. Mirrors getLastDeviceOrientation. */
+declare function getLatestAbsoluteOrientation(): AbsoluteOrientationReading | null;
+/** Stop the watch and clear cached state. Idempotent. */
+declare function stopAbsoluteOrientationWatch(): void;
+//#endregion
+export { startAbsoluteOrientationWatch as a, isAbsoluteOrientationAvailable as i, AbsoluteOrientationStatus as n, stopAbsoluteOrientationWatch as o, getLatestAbsoluteOrientation as r, AbsoluteOrientationReading as t };

package/dist/{app-selectors-B8VQoMDY.d.ts → app-selectors-ikTUQZpe.d.ts}

@@ -1,4 +1,4 @@
-import { L as CombinedRootState, r as SlamAppRootState } from "./create-slam-app-store-BljusOua.js";
+import { N as CombinedRootState, r as SlamAppRootState } from "./create-slam-app-store-n_VF63D5.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";

package/dist/ar/bresenham3d.d.ts

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

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

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

package/dist/ar/camera-blit-capture.js

@@ -51,6 +51,36 @@ function computeCaptureSize(cameraWidth, cameraHeight, divisor) {
 	};
 }
 /**
+* Compute blit dimensions that PRESERVE the camera aspect ratio with the
+* **longer edge fixed at `maxEdge`**. Unlike {@link computeCaptureSize} (which
+* divides the native resolution by a user divisor), this fits the frame into a
+* fixed pixel budget, so a 4:3 camera becomes e.g. 512×384 — NOT a stretched
+* 512×512. Used by the QR-detection blit (B2) so the detector sees an
+* undistorted code while the readback cost stays bounded by `maxEdge²`.
+*
+* @param cameraWidth  - Native camera width in pixels (from XRCamera)
+* @param cameraHeight - Native camera height in pixels (from XRCamera)
+* @param maxEdge      - Target length (px) of the longer output edge.
+* @returns Integer dimensions, longer edge == `maxEdge`, aspect preserved
+*   (within rounding), each clamped to ≥ 1. When `maxEdge` itself is invalid
+*   (< 1 / NaN / Infinity) the longer edge falls back to
+*   `DEFAULT_BLIT_CONFIG.width` (still aspect-preserving). When the camera
+*   dimensions are invalid (≤ 0 / NaN / Infinity) the aspect is unknown, so it
+*   returns a square at the (possibly defaulted) edge.
+*/
+function computeAspectFitSize(cameraWidth, cameraHeight, maxEdge) {
+	const safeEdge = maxEdge >= 1 && Number.isFinite(maxEdge) ? Math.floor(maxEdge) : DEFAULT_BLIT_CONFIG.width;
+	if (!(cameraWidth > 0) || !Number.isFinite(cameraWidth) || !(cameraHeight > 0) || !Number.isFinite(cameraHeight)) return {
+		width: safeEdge,
+		height: safeEdge
+	};
+	const scale = safeEdge / Math.max(cameraWidth, cameraHeight);
+	return {
+		width: Math.max(1, Math.round(cameraWidth * scale)),
+		height: Math.max(1, Math.round(cameraHeight * scale))
+	};
+}
+/**
 * Number of sampled pixels to check in isBlackFrame.
 * We sample a subset rather than checking every pixel for speed.
 */
@@ -168,6 +198,32 @@ var CameraBlitCapture = class {
 		}
 	}
 	/**
+	* Capture the camera texture as **top-left-origin** RGBA — the orientation
+	* QR detection (and `BarcodeDetector`) expects — returning a FRESH copy that
+	* is safe to retain beyond the next capture.
+	*
+	* This is the efficient replacement for the demo's old JPEG round-trip: blit
+	* + readback (shared with {@link captureToBlob} / {@link captureToPixels}),
+	* then the same vertical flip the JPEG encoder applies, but with no encode →
+	* decode. Unlike {@link captureToPixels} (which returns the reusable internal
+	* buffer in WebGL bottom-row-first order), this returns an owned,
+	* correctly-oriented `Uint8ClampedArray`.
+	*
+	* IMPORTANT: Must be called within the XR animation frame callback, while the
+	* camera texture is valid.
+	*
+	* @returns `{ data, width, height }` (top-left RGBA), or null on
+	*   failure/dispose.
+	*/
+	captureToRgba(renderer, cameraTexture) {
+		if (!this.captureToPixels(renderer, cameraTexture)) return null;
+		return {
+			data: this.flippedPixelCopy(),
+			width: this.width,
+			height: this.height
+		};
+	}
+	/**
 	* Check if a pixel buffer is entirely black (all zeros).
 	* Uses sampling for performance (checks BLACK_CHECK_SAMPLE_COUNT evenly-spaced pixels).
 	*
@@ -197,10 +253,19 @@ var CameraBlitCapture = class {
 		return this.pixelsToJpegViaCanvas(quality);
 	}
 	getFlippedImageData() {
-		const clampedBuffer = new Uint8ClampedArray(this.pixelBuffer);
-		const imageData = new ImageData(clampedBuffer, this.width, this.height);
-		this.flipImageDataVertically(imageData);
-		return imageData;
+		return new ImageData(this.flippedPixelCopy(), this.width, this.height);
+	}
+	/**
+	* Produce a FRESH, top-left-origin RGBA copy of the internal readback buffer.
+	* WebGL `readPixels` returns bottom-row-first; this copies (so the internal
+	* buffer stays y-flipped for a subsequent capture) and swaps rows. Shared by
+	* the JPEG encode path ({@link getFlippedImageData}) and {@link captureToRgba}.
+	*/
+	flippedPixelCopy() {
+		const copy = new Uint8ClampedArray(this.pixelBuffer.length);
+		copy.set(this.pixelBuffer);
+		this.flipRowsVertically(copy, this.width, this.height);
+		return copy;
 	}
 	async pixelsToJpegViaOffscreenCanvas(quality) {
 		const offscreen = new OffscreenCanvas(this.width, this.height);
@@ -229,11 +294,11 @@ var CameraBlitCapture = class {
 		});
 	}
 	/**
-	* Flip ImageData vertically in-place.
-	* WebGL readPixels returns bottom-row-first; canvas expects top-row-first.
+	* Flip an RGBA buffer vertically in-place (row swap).
+	* WebGL readPixels returns bottom-row-first; canvas / detectors expect
+	* top-row-first.
 	*/
-	flipImageDataVertically(imageData) {
-		const { data, width, height } = imageData;
+	flipRowsVertically(data, width, height) {
 		const rowSize = width * 4;
 		const tempRow = new Uint8ClampedArray(rowSize);
 		for (let y = 0; y < Math.floor(height / 2); y++) {
@@ -291,4 +356,4 @@ var CameraBlitCapture = class {
 	}
 };
 //#endregion
-export { CameraBlitCapture, DEFAULT_BLIT_CONFIG, computeCaptureSize };
+export { CameraBlitCapture, 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-CQXJHxXg.js";
+import { i as isFullySupported, n as CapabilitySupport, r as capabilityMessage, t as CapabilityMessageOptions } from "../capability-checker-DUQLg6gq.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-CUeU3L_M.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-gsm8q7yi.js";
 export { CAPTURE_FAILURE_WARNING, CaptureFailureTracker, CaptureFailureTrackerConfig, DEFAULT_CAPTURE_TRACKER_CONFIG, createCaptureFailureTracker };

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-Jqbn0apH.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-D4K2uwwQ.js";
 export { BASELAYER_WINDOW_MAX, BASELAYER_WINDOW_MIN, ChromeVersion, ChromiumProjectionLayerWorkaroundResult, applyChromiumProjectionLayerWorkaround, needsBaseLayerPersistence, parseChromeVersion };

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

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

package/dist/ar/depth-grid-lookup.js

@@ -0,0 +1,43 @@
+//#region ../src/ar/depth-grid-lookup.ts
+/** A node's depth if finite and positive, else `null` (a grid hole). */
+function validDepth(points, index) {
+	const p = points[index];
+	if (!p) return null;
+	const d = p.depthM;
+	return Number.isFinite(d) && d > 0 ? d : null;
+}
+/**
+* Build a bilinear lookup over a depth-sampler grid.
+*
+* @param points - the grid `DepthPoint`s (row-major, `row·g + col`).
+* @param gridSize - points-per-side; inferred as `round(√points.length)` when
+*   omitted (the sampler always emits a full `g²` grid).
+*/
+function createDepthGridLookup(points, gridSize) {
+	const g = gridSize ?? Math.round(Math.sqrt(points.length));
+	if (g < 2 || points.length < g * g) return { depthAt() {
+		for (let i = 0; i < points.length; i++) {
+			const d = validDepth(points, i);
+			if (d !== null) return d;
+		}
+		return null;
+	} };
+	return { depthAt(screenX, screenY) {
+		const gx = screenX * (g + 1) - 1;
+		const gy = screenY * (g + 1) - 1;
+		if (gx < 0 || gx > g - 1 || gy < 0 || gy > g - 1) return null;
+		const col0 = Math.min(Math.floor(gx), g - 2);
+		const row0 = Math.min(Math.floor(gy), g - 2);
+		const fx = gx - col0;
+		const fy = gy - row0;
+		const d00 = validDepth(points, row0 * g + col0);
+		const d10 = validDepth(points, row0 * g + col0 + 1);
+		const d01 = validDepth(points, (row0 + 1) * g + col0);
+		const d11 = validDepth(points, (row0 + 1) * g + col0 + 1);
+		if (d00 === null || d10 === null || d01 === null || d11 === null) return null;
+		const top = d00 + (d10 - d00) * fx;
+		return top + (d01 + (d11 - d01) * fx - top) * fy;
+	} };
+}
+//#endregion
+export { createDepthGridLookup };

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

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

package/dist/ar/depth-sampler.js

@@ -56,10 +56,8 @@ var DepthSampler = class {
 	unavailableCallbackFired = false;
 	constructor(callbacks, config) {
 		this.callbacks = callbacks;
-		this.config = {
-			...DEFAULT_CONFIG,
-			...config
-		};
+		this.config = { ...DEFAULT_CONFIG };
+		if (config) this.updateConfig(config);
 	}
 	/**
 	* Start depth sampling.

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

@@ -1,2 +1,2 @@
-import { n as createDepthUnprojector, r as unprojectDepthPoint, t as DepthUnprojector } from "../depth-unprojection-Y6i_mJuT.js";
+import { n as createDepthUnprojector, r as unprojectDepthPoint, t as DepthUnprojector } from "../depth-unprojection-DjsbJW9L.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-BfUJOgpW.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-DkNhFv4Y.js";
 export { EnableGpsArConfig, EnableGpsArController, EnableGpsArDeps, EnableGpsArResult, EnableGpsArState, EnableGpsArStatus, createEnableGpsArController };

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

@@ -1,7 +1,7 @@
 import { createLogger } from "../utils/logger.js";
+import { a as endARSession, b as isWebXRSupported, y as initAR } from "../webxr-session-DG-eNfny.js";
 import { requestGeolocationPermission, requestOrientationPermission, requestWebXRWithDepthPermission } from "../sensors/permission-checker.js";
 import { startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch } from "../sensors/gps.js";
-import { _ as isWebXRSupported, g as initAR, i as endARSession } from "../webxr-session-TIaD883f.js";
 //#region ../src/ar/enable-gps-ar.ts
 const log = createLogger("EnableGpsAr");
 const defaultDeps = {
@@ -74,10 +74,12 @@ function createEnableGpsArController(deps = {}) {
 			error: "AR is already starting, running or stopping."
 		};
 		setState({ status: "starting" });
+		let sessionStarted = false;
 		try {
 			const permissionError = await requestPermissions(config);
 			if (permissionError !== null) return fail(permissionError);
 			await resolved.initAR(config.container, config.isolationOptions, { requestHitTest: config.requestHitTest });
+			sessionStarted = true;
 			if (config.onGpsPosition) {
 				resolved.startGpsWatch(config.onGpsPosition);
 				gpsWatchActive = true;
@@ -89,6 +91,29 @@ function createEnableGpsArController(deps = {}) {
 			setState({ status: "running" });
 			return { ok: true };
 		} catch (err) {
+			if (sessionStarted) {
+				if (gpsWatchActive) {
+					try {
+						resolved.stopGpsWatch();
+					} catch (cleanupErr) {
+						log.error("stopGpsWatch during enable() cleanup threw:", cleanupErr);
+					}
+					gpsWatchActive = false;
+				}
+				if (orientationWatchActive) {
+					try {
+						resolved.stopOrientationWatch();
+					} catch (cleanupErr) {
+						log.error("stopOrientationWatch during enable() cleanup threw:", cleanupErr);
+					}
+					orientationWatchActive = false;
+				}
+				try {
+					await resolved.endARSession();
+				} catch (cleanupErr) {
+					log.error("Cleanup after enable() failure threw; continuing:", cleanupErr);
+				}
+			}
 			return fail(err instanceof Error ? err.message : String(err));
 		}
 	}

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

@@ -1,2 +1,2 @@
-import { i as runFrameUpdates, n as clearFrameUpdates, r as registerFrameUpdate, t as FrameUpdate } from "../frame-loop-CMewS8cY.js";
+import { i as runFrameUpdates, n as clearFrameUpdates, r as registerFrameUpdate, t as FrameUpdate } from "../frame-loop-CpVjQ1dH.js";
 export { FrameUpdate, clearFrameUpdates, registerFrameUpdate, runFrameUpdates };

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

@@ -1,2 +1,2 @@
-import { a as ImageCaptureConfig, i as ImageCaptureCallbacks, n as CapturedImage, o as ImageCaptureManager, r as DEFAULT_CAPTURE_CONFIG, s as MIN_VALID_IMAGE_BYTES, t as CapturedFrame } from "../image-capture-qAZ5Fh5X.js";
-export { CapturedFrame, CapturedImage, DEFAULT_CAPTURE_CONFIG, ImageCaptureCallbacks, ImageCaptureConfig, ImageCaptureManager, MIN_VALID_IMAGE_BYTES };
+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-CNZDrQXG.js";
+export { CapturedFrame, CapturedImage, DEFAULT_CAPTURE_CONFIG, FrameQualityVerdict, ImageCaptureCallbacks, ImageCaptureConfig, ImageCaptureManager, MIN_VALID_IMAGE_BYTES };

package/dist/ar/image-capture.js

@@ -1,155 +1,2 @@
-import { createLogger } from "../utils/logger.js";
-//#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
-};
-/**
-* 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;
-	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;
-	}
-	/**
-	* Stop capturing images.
-	* Clears any pending safety timeout and resets in-flight capture state.
-	*/
-	stop() {
-		this.capturing = false;
-		this.clearCaptureTimeout();
-		this.captureInProgress = false;
-	}
-	/**
-	* 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;
-		if (this.captureInProgress) return;
-		const elapsed = time - this.lastCaptureTime;
-		if (this.lastCaptureTime > 0 && elapsed < this.config.intervalMs) return;
-		const pose = this.callbacks.getCurrentPose();
-		if (!pose) return;
-		this.captureInProgress = true;
-		this.lastCaptureTime = time;
-		const timestamp = performance.timeOrigin + time;
-		const screenRotation = this.callbacks.getScreenRotation();
-		const frameIndex = ++this.frameCount;
-		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, frameIndex, 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, frameIndex, pose, screenRotation);
-		}, "image/jpeg", this.config.quality);
-	}
-	/**
-	* 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;
-		}
-	}
-	/**
-	* Common handler for captured blobs (from either canvas.toBlob or captureFrame).
-	* Handles null blobs, suspicious image detection, and dispatching onCaptured.
-	*/
-	handleCapturedBlob(blob, width, height, timestamp, frameIndex, pose, screenRotation) {
-		this.clearCaptureTimeout();
-		this.captureInProgress = false;
-		if (!blob) {
-			this.callbacks.onCaptureFailed?.();
-			return;
-		}
-		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
+import { n as ImageCaptureManager, r as MIN_VALID_IMAGE_BYTES, t as DEFAULT_CAPTURE_CONFIG } from "../image-capture-B2-b6tKK.js";
 export { DEFAULT_CAPTURE_CONFIG, ImageCaptureManager, MIN_VALID_IMAGE_BYTES };

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

@@ -0,0 +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-smCBoFj1.js";
+export { DEFAULT_QUALITY_FILTER, DEFAULT_SHARPNESS_HISTORY_SIZE, DEFAULT_SHARPNESS_MIN_SAMPLES, ImageQualityGate, QualityFilterConfig, QualityRejectReason, QualityVerdict, meanLuminance, rgbaToGrayscale, sharpnessScore };