gps-plus-slam-app-framework 1.0.0

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

@@ -0,0 +1,253 @@
+import { createLogger } from "../utils/logger.js";
+import { disposeObject3D } from "../visualization/three-dispose.js";
+import * as THREE from "three";
+//#region ../src/ar/camera-blit-capture.ts
+/**
+* Camera Blit Capture Module
+*
+* Implements the "blit" technique to read WebXR opaque camera textures.
+*
+* Problem: In WebXR AR mode, the camera texture provided by
+* renderer.xr.getCameraTexture() is an "opaque texture" backed by a
+* protected GPU buffer (OES_external_image). Standard canvas.toBlob()
+* or gl.readPixels() return all-black data.
+*
+* Solution: Render the opaque texture onto a fullscreen quad targeting
+* an intermediate WebGLRenderTarget (standard RGBA). This GPU draw call
+* forces conversion from the opaque format to a readable texture.
+* Then readRenderTargetPixels() successfully extracts the pixel data.
+*
+* See: docs/2026-02-06-bug-camera-frames-black.md
+*/
+const log = createLogger("CameraBlitCapture");
+/**
+* Default blit capture config.
+* 512×512 is a good balance between quality and readPixels performance on mobile.
+*/
+const DEFAULT_BLIT_CONFIG = {
+	width: 512,
+	height: 512
+};
+/**
+* Compute the capture dimensions from the native camera resolution
+* and a user-configurable resolution divisor.
+*
+* @param cameraWidth  - Native camera width in pixels (from XRCamera)
+* @param cameraHeight - Native camera height in pixels (from XRCamera)
+* @param divisor      - Resolution divisor: 1 = full, 2 = half, 4 = quarter, etc.
+*                        Values ≤ 0 are treated as 1. Fractional values < 1 are treated as 1.
+* @returns Integer pixel dimensions, clamped to at least 1×1.
+*          Falls back to DEFAULT_BLIT_CONFIG when inputs are invalid (≤ 0).
+*/
+function computeCaptureSize(cameraWidth, cameraHeight, divisor) {
+	if (cameraWidth <= 0 || cameraHeight <= 0) return {
+		width: DEFAULT_BLIT_CONFIG.width,
+		height: DEFAULT_BLIT_CONFIG.height
+	};
+	const safeDivisor = divisor >= 1 ? divisor : 1;
+	return {
+		width: Math.max(1, Math.floor(cameraWidth / safeDivisor)),
+		height: Math.max(1, Math.floor(cameraHeight / safeDivisor))
+	};
+}
+/**
+* Number of sampled pixels to check in isBlackFrame.
+* We sample a subset rather than checking every pixel for speed.
+*/
+const BLACK_CHECK_SAMPLE_COUNT = 100;
+/**
+* Captures readable pixel data from WebXR opaque camera textures
+* using the intermediate render target "blit" technique.
+*
+* Usage:
+* 1. Create once when AR session starts
+* 2. Call captureToBlob() when a frame needs to be captured
+* 3. Call dispose() when AR session ends
+*/
+var CameraBlitCapture = class {
+	renderTarget;
+	blitScene;
+	blitCamera;
+	blitMaterial;
+	quad;
+	pixelBuffer;
+	width;
+	height;
+	disposed = false;
+	constructor(config = DEFAULT_BLIT_CONFIG) {
+		this.width = config.width;
+		this.height = config.height;
+		this.renderTarget = new THREE.WebGLRenderTarget(this.width, this.height, {
+			format: THREE.RGBAFormat,
+			type: THREE.UnsignedByteType
+		});
+		this.pixelBuffer = new Uint8Array(this.width * this.height * 4);
+		this.blitScene = new THREE.Scene();
+		this.blitCamera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+		this.blitMaterial = new THREE.ShaderMaterial({
+			uniforms: { tDiffuse: { value: null } },
+			vertexShader: `
+        varying vec2 vUv;
+        void main() {
+          vUv = uv;
+          gl_Position = vec4(position, 1.0);
+        }
+      `,
+			fragmentShader: `
+        uniform sampler2D tDiffuse;
+        varying vec2 vUv;
+        void main() {
+          gl_FragColor = texture2D(tDiffuse, vUv);
+        }
+      `,
+			depthTest: false,
+			depthWrite: false
+		});
+		this.quad = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), this.blitMaterial);
+		this.blitScene.add(this.quad);
+	}
+	/**
+	* Capture the WebXR camera texture to a JPEG Blob via the blit technique.
+	*
+	* IMPORTANT: Must be called within the XR animation frame callback,
+	* while the camera texture is valid.
+	*
+	* @param renderer - The Three.js WebGL renderer
+	* @param cameraTexture - The opaque camera texture from renderer.xr.getCameraTexture()
+	* @param quality - JPEG quality 0.0-1.0
+	* @returns JPEG Blob, or null if capture fails
+	*/
+	async captureToBlob(renderer, cameraTexture, quality) {
+		if (this.disposed) {
+			log.warn("captureToBlob called after dispose");
+			return null;
+		}
+		try {
+			this.blitMaterial.uniforms.tDiffuse.value = cameraTexture;
+			const currentRenderTarget = renderer.getRenderTarget();
+			const currentXrEnabled = renderer.xr.enabled;
+			renderer.xr.enabled = false;
+			renderer.setRenderTarget(this.renderTarget);
+			renderer.render(this.blitScene, this.blitCamera);
+			renderer.readRenderTargetPixels(this.renderTarget, 0, 0, this.width, this.height, this.pixelBuffer);
+			renderer.setRenderTarget(currentRenderTarget);
+			renderer.xr.enabled = currentXrEnabled;
+			this.blitMaterial.uniforms.tDiffuse.value = null;
+			return await this.pixelsToJpegBlob(quality);
+		} catch (error) {
+			log.error("Blit capture failed:", error);
+			return null;
+		}
+	}
+	/**
+	* Check if a pixel buffer is entirely black (all zeros).
+	* Uses sampling for performance (checks BLACK_CHECK_SAMPLE_COUNT evenly-spaced pixels).
+	*
+	* This is useful to detect if the blit technique failed to convert
+	* the opaque texture (different from a legitimately dark scene).
+	*
+	* @param pixels - RGBA pixel buffer
+	* @returns true if all sampled pixels are zero
+	*/
+	static isBlackFrame(pixels) {
+		if (pixels.length === 0) return true;
+		const step = Math.max(1, Math.floor(pixels.length / (BLACK_CHECK_SAMPLE_COUNT * 4)));
+		for (let i = 0; i < pixels.length; i += step * 4) {
+			const r = pixels[i];
+			const g = pixels[i + 1];
+			const b = pixels[i + 2];
+			if (r > 0 || g > 0 || b > 0) return false;
+		}
+		return true;
+	}
+	/**
+	* Convert the internal pixel buffer to a JPEG Blob using OffscreenCanvas
+	* (or fallback to regular Canvas).
+	*/
+	async pixelsToJpegBlob(quality) {
+		if (typeof OffscreenCanvas !== "undefined") return this.pixelsToJpegViaOffscreenCanvas(quality);
+		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;
+	}
+	async pixelsToJpegViaOffscreenCanvas(quality) {
+		const offscreen = new OffscreenCanvas(this.width, this.height);
+		const ctx = offscreen.getContext("2d");
+		if (!ctx) return null;
+		const imageData = this.getFlippedImageData();
+		ctx.putImageData(imageData, 0, 0);
+		return offscreen.convertToBlob({
+			type: "image/jpeg",
+			quality
+		});
+	}
+	pixelsToJpegViaCanvas(quality) {
+		return new Promise((resolve) => {
+			const canvas = document.createElement("canvas");
+			canvas.width = this.width;
+			canvas.height = this.height;
+			const ctx = canvas.getContext("2d");
+			if (!ctx) {
+				resolve(null);
+				return;
+			}
+			const imageData = this.getFlippedImageData();
+			ctx.putImageData(imageData, 0, 0);
+			canvas.toBlob((blob) => resolve(blob), "image/jpeg", quality);
+		});
+	}
+	/**
+	* Flip ImageData vertically in-place.
+	* WebGL readPixels returns bottom-row-first; canvas expects top-row-first.
+	*/
+	flipImageDataVertically(imageData) {
+		const { data, width, height } = imageData;
+		const rowSize = width * 4;
+		const tempRow = new Uint8ClampedArray(rowSize);
+		for (let y = 0; y < Math.floor(height / 2); y++) {
+			const topOffset = y * rowSize;
+			const bottomOffset = (height - 1 - y) * rowSize;
+			tempRow.set(data.subarray(topOffset, topOffset + rowSize));
+			data.copyWithin(topOffset, bottomOffset, bottomOffset + rowSize);
+			data.set(tempRow, bottomOffset);
+		}
+	}
+	/**
+	* Resize the render target and pixel buffer to match new dimensions.
+	* Call this when the camera resolution is first known or changes.
+	*
+	* No-op when dimensions already match (avoids per-frame reallocation).
+	* Returns false if disposed, dimensions unchanged, or dimensions invalid.
+	*
+	* @param newWidth  - Desired capture width in pixels
+	* @param newHeight - Desired capture height in pixels
+	* @returns true if resources were actually resized
+	*/
+	resizeIfNeeded(newWidth, newHeight) {
+		if (this.disposed) return false;
+		if (newWidth <= 0 || newHeight <= 0) return false;
+		if (newWidth === this.width && newHeight === this.height) return false;
+		this.width = newWidth;
+		this.height = newHeight;
+		this.renderTarget.setSize(this.width, this.height);
+		this.pixelBuffer = new Uint8Array(this.width * this.height * 4);
+		log.info(`Render target resized to ${this.width}×${this.height}`);
+		return true;
+	}
+	/**
+	* Dispose GPU resources. Call when AR session ends.
+	*/
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.renderTarget.dispose();
+		disposeObject3D(this.quad);
+		log.info("CameraBlitCapture disposed");
+	}
+};
+//#endregion
+export { CameraBlitCapture, DEFAULT_BLIT_CONFIG, computeCaptureSize };

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

@@ -0,0 +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-2Q6oI2uQ.js";
+export { CAPTURE_FAILURE_WARNING, CaptureFailureTracker, CaptureFailureTrackerConfig, DEFAULT_CAPTURE_TRACKER_CONFIG, createCaptureFailureTracker };

package/dist/ar/capture-failure-tracker.js

@@ -0,0 +1,45 @@
+import { createFailureTracker } from "../utils/failure-tracker.js";
+//#region ../src/ar/capture-failure-tracker.ts
+/**
+* Capture Failure Tracker
+*
+* Tracks consecutive image capture failures and notifies users when
+* multiple frames fail to capture (e.g., low memory on mobile devices).
+*
+* Field Test Readiness Issue #11: Silent image capture failures
+*
+* Thin wrapper around the generic failure tracker factory.
+*/
+/**
+* Default configuration values.
+*/
+const DEFAULT_CAPTURE_TRACKER_CONFIG = { failureThreshold: 5 };
+/**
+* User-facing warning message when threshold is exceeded.
+*/
+const CAPTURE_FAILURE_WARNING = "Multiple image captures failed. Device may be low on memory.";
+/**
+* Create a new capture failure tracker.
+*
+* @param config - Configuration with warning callback and optional threshold
+* @returns CaptureFailureTracker instance
+*/
+function createCaptureFailureTracker(config) {
+	const tracker = createFailureTracker({
+		label: "CaptureFailure",
+		warningMessage: CAPTURE_FAILURE_WARNING,
+		defaultThreshold: DEFAULT_CAPTURE_TRACKER_CONFIG.failureThreshold,
+		onWarning: config.onWarning,
+		failureThreshold: config.failureThreshold,
+		logLevel: "warn"
+	});
+	return {
+		recordSuccess: () => tracker.recordSuccess(),
+		recordFailure: () => tracker.recordFailure(),
+		getFailureCount: () => tracker.getFailureCount(),
+		hasWarned: () => tracker.hasWarned(),
+		reset: () => tracker.reset()
+	};
+}
+//#endregion
+export { CAPTURE_FAILURE_WARNING, DEFAULT_CAPTURE_TRACKER_CONFIG, createCaptureFailureTracker };

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

@@ -0,0 +1,2 @@
+import { n as applyChromiumProjectionLayerWorkaround, t as ChromiumProjectionLayerWorkaroundResult } from "../chromium-camera-access-workaround-CU5zSKNr.js";
+export { ChromiumProjectionLayerWorkaroundResult, applyChromiumProjectionLayerWorkaround };

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

@@ -0,0 +1,32 @@
+//#region ../src/ar/chromium-camera-access-workaround.ts
+/**
+* Apply the Chromium camera-access tab-crash workaround.
+*
+* Removes `XRWebGLBinding.prototype.createProjectionLayer` (three.js r184)
+* and `XRRenderState.prototype.layers` (three.js r158) so three.js falls
+* back to `XRWebGLLayer`, which avoids the renderer-process crash that
+* happens when both projection layers and `camera-access` are enabled.
+*
+* Call once during bootstrap, before any `requestSession()` call.
+*
+* @returns which prototype members were actually deleted on this call.
+*/
+function applyChromiumProjectionLayerWorkaround() {
+	const result = {
+		deletedCreateProjectionLayer: false,
+		deletedRenderStateLayers: false
+	};
+	const binding = globalThis.XRWebGLBinding;
+	if (binding && "createProjectionLayer" in binding.prototype) {
+		delete binding.prototype.createProjectionLayer;
+		result.deletedCreateProjectionLayer = true;
+	}
+	const renderState = globalThis.XRRenderState;
+	if (renderState && "layers" in renderState.prototype) {
+		delete renderState.prototype.layers;
+		result.deletedRenderStateLayers = true;
+	}
+	return result;
+}
+//#endregion
+export { applyChromiumProjectionLayerWorkaround };

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

@@ -0,0 +1,3 @@
+import { i as DepthSample } from "../ar-types-B-ORgk6Z.js";
+import { i as DepthSamplerConfig, n as DepthSampler, r as DepthSamplerCallbacks, t as DepthInfo } from "../depth-sampler-BNCtnEoP.js";
+export { DepthInfo, DepthSample, DepthSampler, DepthSamplerCallbacks, DepthSamplerConfig };

package/dist/ar/depth-sampler.js

@@ -0,0 +1,147 @@
+import { extractOdomPosition } from "../state/recording-coordinator.js";
+//#region ../src/ar/depth-sampler.ts
+const DEFAULT_CONFIG = {
+	intervalMs: 1e3,
+	gridSize: 3,
+	unavailabilityThresholdMs: 5e3
+};
+/**
+* Samples sparse depth points from WebXR depth sensing.
+*
+* Usage:
+* ```ts
+* const sampler = new DepthSampler({
+*   onSampleCaptured: (sample) => saveSample(sample),
+*   getCurrentPose: () => arSession.getCurrentPose(),
+* });
+* sampler.start();
+* // In frame loop:
+* sampler.onFrame(timestamp, depthInfo);
+* ```
+*/
+var DepthSampler = class {
+	callbacks;
+	config;
+	running = false;
+	sampleCount = 0;
+	lastSampleTime = -Infinity;
+	/** Timestamp when sampling started (for unavailability detection) */
+	startTime = -Infinity;
+	/** Whether we've ever received valid depth data */
+	depthReceived = false;
+	/** Whether we've already fired the unavailable callback */
+	unavailableCallbackFired = false;
+	constructor(callbacks, config) {
+		this.callbacks = callbacks;
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Start depth sampling.
+	*/
+	start() {
+		this.running = true;
+		this.sampleCount = 0;
+		this.lastSampleTime = -Infinity;
+		this.startTime = performance.now();
+		this.depthReceived = false;
+		this.unavailableCallbackFired = false;
+	}
+	/**
+	* Stop depth sampling.
+	*/
+	stop() {
+		this.running = false;
+	}
+	/**
+	* Check if sampler is currently running.
+	*/
+	isRunning() {
+		return this.running;
+	}
+	/**
+	* Get the number of samples captured since start.
+	*/
+	getSampleCount() {
+		return this.sampleCount;
+	}
+	/**
+	* Get the current configuration.
+	*/
+	getConfig() {
+		return { ...this.config };
+	}
+	/**
+	* Called each frame with depth information.
+	*
+	* @param timestamp - Current frame timestamp in milliseconds
+	* @param depthInfo - WebXR depth information, or null if unavailable
+	*/
+	onFrame(timestamp, depthInfo) {
+		if (!this.running) return;
+		if (!depthInfo) {
+			this.checkDepthUnavailability();
+			return;
+		}
+		this.depthReceived = true;
+		if (timestamp - this.lastSampleTime < this.config.intervalMs) return;
+		const pose = this.callbacks.getCurrentPose();
+		if (!pose) return;
+		const points = this.sampleGrid(depthInfo);
+		const sample = {
+			timestamp: performance.timeOrigin + timestamp,
+			cameraPos: extractOdomPosition(pose),
+			cameraRot: [
+				pose.orientation.x,
+				pose.orientation.y,
+				pose.orientation.z,
+				pose.orientation.w
+			],
+			points
+		};
+		this.lastSampleTime = timestamp;
+		this.sampleCount++;
+		this.callbacks.onSampleCaptured(sample);
+	}
+	/**
+	* Sample a grid of depth points from the depth buffer.
+	*/
+	sampleGrid(depthInfo) {
+		const points = [];
+		const gridSize = this.config.gridSize;
+		for (let row = 0; row < gridSize; row++) for (let col = 0; col < gridSize; col++) {
+			const screenX = (col + 1) / (gridSize + 1);
+			const screenY = (row + 1) / (gridSize + 1);
+			const depthM = depthInfo.getDepthInMeters(screenX, screenY);
+			points.push({
+				screenX,
+				screenY,
+				depthM
+			});
+		}
+		return points;
+	}
+	/**
+	* Check if depth has been unavailable for longer than the threshold.
+	* If so, fire the onDepthUnavailable callback (once).
+	*/
+	checkDepthUnavailability() {
+		if (this.depthReceived || this.unavailableCallbackFired) return;
+		if (!this.callbacks.onDepthUnavailable) return;
+		if (performance.now() - this.startTime >= this.config.unavailabilityThresholdMs) {
+			this.unavailableCallbackFired = true;
+			this.callbacks.onDepthUnavailable();
+		}
+	}
+	/**
+	* Check if depth data has ever been received.
+	* Useful for testing and status display.
+	*/
+	hasReceivedDepth() {
+		return this.depthReceived;
+	}
+};
+//#endregion
+export { DepthSampler };

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

@@ -0,0 +1,2 @@
+import { a as ImageCaptureManager, i as ImageCaptureConfig, n as DEFAULT_CAPTURE_CONFIG, o as MIN_VALID_IMAGE_BYTES, r as ImageCaptureCallbacks, t as CapturedImage } from "../image-capture-2pKjYUS6.js";
+export { CapturedImage, DEFAULT_CAPTURE_CONFIG, ImageCaptureCallbacks, ImageCaptureConfig, ImageCaptureManager, MIN_VALID_IMAGE_BYTES };

package/dist/ar/image-capture.js

@@ -0,0 +1,152 @@
+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
+};
+/**
+* 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 = Date.now();
+		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((blob) => {
+			this.handleCapturedBlob(blob, timestamp, frameIndex, pose, screenRotation);
+		}).catch(() => {
+			this.clearCaptureTimeout();
+			this.captureInProgress = false;
+			this.callbacks.onCaptureFailed?.();
+		});
+		else this.canvas.toBlob((blob) => {
+			this.handleCapturedBlob(blob, 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, 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
+		});
+	}
+};
+//#endregion
+export { DEFAULT_CAPTURE_CONFIG, ImageCaptureManager, MIN_VALID_IMAGE_BYTES };

package/dist/ar/index.d.ts

@@ -0,0 +1,12 @@
+import { i as computeCaptureSize, n as CameraBlitCaptureConfig, r as DEFAULT_BLIT_CONFIG, t as CameraBlitCapture } from "../camera-blit-capture-DHuyrrxr.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-2Q6oI2uQ.js";
+import { n as applyChromiumProjectionLayerWorkaround, t as ChromiumProjectionLayerWorkaroundResult } from "../chromium-camera-access-workaround-CU5zSKNr.js";
+import { i as DepthSamplerConfig, n as DepthSampler, r as DepthSamplerCallbacks, t as DepthInfo } from "../depth-sampler-BNCtnEoP.js";
+import { a as ImageCaptureManager, i as ImageCaptureConfig, n as DEFAULT_CAPTURE_CONFIG, o as MIN_VALID_IMAGE_BYTES, r as ImageCaptureCallbacks, t as CapturedImage } from "../image-capture-2pKjYUS6.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, t as CameraMode, u as toggleCameraMode } from "../replay-scene-DtUm6bsr.js";
+import { t as SCENE_NODE } from "../scene-node-names-DPsaE2z3.js";
+import { a as TrackingStateManager, i as TrackingStateCallbacks, r as TrackingState, t as DeviceOrientation } from "../tracking-state-B9QfuZCg.js";
+import { i as acquireCameraTexture, n as RendererLike, r as XRCameraLike, t as CameraTextureResult } from "../xr-camera-texture-BbukNE79.js";
+import { A as setTrackingLostCallback, D as setImageCaptureCallback, E as setFrameCallback, F as stopDepthCapture, I as stopImageCapture, N as startDepthCapture, P as startImageCapture, T as setDepthCaptureCallback, d as getDepthSampleCount, f as getImageCaptureFrameCount, g as initAR, i as endARSession, k as setTrackingCallbacks, p as getLiveCss3dManager } from "../webxr-session-COlSrXdL.js";
+import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "../xr-error-handler-DTHfmvrl.js";
+export { CAPTURE_FAILURE_WARNING, CameraBlitCapture, type CameraBlitCaptureConfig, type CameraMode, type CameraTextureResult, type CaptureFailureTracker, type CaptureFailureTrackerConfig, type CapturedImage, type ChromiumProjectionLayerWorkaroundResult, DEFAULT_BLIT_CONFIG, DEFAULT_CAPTURE_CONFIG, DEFAULT_CAPTURE_TRACKER_CONFIG, type DepthInfo, DepthSampler, type DepthSamplerCallbacks, type DepthSamplerConfig, type DeviceOrientation, type ImageCaptureCallbacks, type ImageCaptureConfig, ImageCaptureManager, MIN_VALID_IMAGE_BYTES, type RendererLike, type ReplaySceneState, SCENE_NODE, TrackingState, type TrackingStateCallbacks, TrackingStateManager, type XRCameraLike, XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, acquireCameraTexture, applyChromiumProjectionLayerWorkaround, computeCaptureSize, createCaptureFailureTracker, disposeReplayScene, endARSession, getAlignmentLerper, getCameraFollower, getCameraMode, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getReplayState, getXrErrorMessage, initAR, initReplayScene, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setTrackingCallbacks, setTrackingLostCallback, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture, toggleCameraMode, updateOrbitTarget };

package/dist/ar/index.js

@@ -0,0 +1,12 @@
+import { CameraBlitCapture, DEFAULT_BLIT_CONFIG, computeCaptureSize } from "./camera-blit-capture.js";
+import { applyChromiumProjectionLayerWorkaround } from "./chromium-camera-access-workaround.js";
+import { CAPTURE_FAILURE_WARNING, DEFAULT_CAPTURE_TRACKER_CONFIG, createCaptureFailureTracker } from "./capture-failure-tracker.js";
+import { DepthSampler } from "./depth-sampler.js";
+import { DEFAULT_CAPTURE_CONFIG, ImageCaptureManager, MIN_VALID_IMAGE_BYTES } from "./image-capture.js";
+import { TrackingState, TrackingStateManager } from "./tracking-state.js";
+import { acquireCameraTexture } from "./xr-camera-texture.js";
+import { SCENE_NODE } from "./scene-node-names.js";
+import { endARSession, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, initAR, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setTrackingCallbacks, setTrackingLostCallback, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture } from "./webxr-session.js";
+import { disposeReplayScene, getAlignmentLerper, getCameraFollower, getCameraMode, getReplayState, initReplayScene, toggleCameraMode, updateOrbitTarget } from "./replay-scene.js";
+import { XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, getXrErrorMessage } from "./xr-error-handler.js";
+export { CAPTURE_FAILURE_WARNING, CameraBlitCapture, DEFAULT_BLIT_CONFIG, DEFAULT_CAPTURE_CONFIG, DEFAULT_CAPTURE_TRACKER_CONFIG, DepthSampler, ImageCaptureManager, MIN_VALID_IMAGE_BYTES, SCENE_NODE, TrackingState, TrackingStateManager, XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, acquireCameraTexture, applyChromiumProjectionLayerWorkaround, computeCaptureSize, createCaptureFailureTracker, disposeReplayScene, endARSession, getAlignmentLerper, getCameraFollower, getCameraMode, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getReplayState, getXrErrorMessage, initAR, initReplayScene, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setTrackingCallbacks, setTrackingLostCallback, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture, toggleCameraMode, updateOrbitTarget };

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

@@ -0,0 +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-DtUm6bsr.js";
+export { CameraMode, ReplaySceneState, disposeReplayScene, getAlignmentLerper, getCameraFollower, getCameraMode, getCss3dManager, getReplayState, initReplayScene, toggleCameraMode, updateOrbitTarget };