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

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

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

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

package/dist/ar/bresenham3d.js

@@ -0,0 +1,81 @@
+//#region ../src/ar/bresenham3d.ts
+/**
+* Main-thread safety cap: the maximum dominant-axis (Chebyshev) span a single
+* trace may cover. The trace runs synchronously, one iteration per
+* dominant-axis step, so an unbounded span freezes the UI. Finite-but-absurd
+* coordinates (a tracking glitch, a corrupt projectionMatrix unprojecting to a
+* huge world point) quantize to safe integers and pass the integer check, so
+* this is the only thing standing between such input and a multi-second
+* (potentially multi-billion-iteration) freeze.
+*
+* Chosen generously — at the grid's 0.15 m cells this is ~150 km, far beyond
+* any real AR scene, so it never trips on legitimate carving or raycasting.
+* It is a circuit breaker against programmer/data error, not a ray-length
+* policy: exceeding it throws (loud — surfaces the upstream bug) rather than
+* silently truncating the trace.
+*/
+const MAX_TRACE_STEPS = 1e6;
+/**
+* Trace the line from `start` to `end`, calling `visitCell` per cell.
+*
+* @param visitCell - return `false` to stop the trace early.
+* @param stopDistance - dominant-axis steps before `end` at which to stop
+*   (default 0 = trace all the way to `end`).
+* @throws TypeError when a coordinate is not a safe integer (cells must be
+*   quantized before tracing — programmer error, not a data error).
+* @throws RangeError when `stopDistance` is not a non-negative safe integer.
+*   The loop terminates on a counter (`i--`) that decrements unconditionally,
+*   so a negative or fractional value still terminates (it merely traces past
+*   `end`); but `NaN`/`-Infinity` never satisfy `i <= stopDistance` and would
+*   spin forever. Rejecting up front both prevents that freeze and enforces
+*   the "dominant-axis steps before end" contract.
+* @throws RangeError when the dominant-axis span exceeds {@link MAX_TRACE_STEPS}
+*   (circuit breaker against a synchronous main-thread freeze from
+*   finite-but-absurd coordinates).
+*/
+function bresenham3d(start, end, visitCell, stopDistance = 0) {
+	assertIntegerCell(start);
+	assertIntegerCell(end);
+	if (!Number.isSafeInteger(stopDistance) || stopDistance < 0) throw new RangeError(`bresenham3d stopDistance must be a non-negative safe integer, got ${stopDistance}`);
+	let [x, y, z] = start;
+	const dx = Math.abs(end[0] - x);
+	const sx = x < end[0] ? 1 : -1;
+	const dy = Math.abs(end[1] - y);
+	const sy = y < end[1] ? 1 : -1;
+	const dz = Math.abs(end[2] - z);
+	const sz = z < end[2] ? 1 : -1;
+	const dm = Math.max(dx, dy, dz);
+	if (dm > 1e6) throw new RangeError(`bresenham3d dominant-axis span ${dm} exceeds MAX_TRACE_STEPS ${MAX_TRACE_STEPS}; cells [${start.join(", ")}]→[${end.join(", ")}] are too far apart to trace synchronously`);
+	let i = dm;
+	let errX = Math.floor(dm / 2);
+	let errY = errX;
+	let errZ = errX;
+	for (;;) {
+		if (!visitCell([
+			x,
+			y,
+			z
+		])) return;
+		if (i-- <= stopDistance) return;
+		errX -= dx;
+		if (errX < 0) {
+			errX += dm;
+			x += sx;
+		}
+		errY -= dy;
+		if (errY < 0) {
+			errY += dm;
+			y += sy;
+		}
+		errZ -= dz;
+		if (errZ < 0) {
+			errZ += dm;
+			z += sz;
+		}
+	}
+}
+function assertIntegerCell(cell) {
+	if (!cell.every((v) => Number.isSafeInteger(v))) throw new TypeError(`bresenham3d requires integer cell coordinates, got [${cell.join(", ")}]`);
+}
+//#endregion
+export { 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-75WWa9Xb.js";
+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 };

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

@@ -118,8 +118,32 @@ var CameraBlitCapture = class {
 	* @returns JPEG Blob, or null if capture fails
 	*/
 	async captureToBlob(renderer, cameraTexture, quality) {
+		if (!this.captureToPixels(renderer, cameraTexture)) return null;
+		try {
+			return await this.pixelsToJpegBlob(quality);
+		} catch (error) {
+			log.error("Blit capture failed:", error);
+			return null;
+		}
+	}
+	/**
+	* Run the blit + readback (steps A+B of {@link captureToBlob}) and return
+	* the raw RGBA pixel buffer without JPEG encoding — the cheap path for
+	* per-point color sampling (occupancy-grid port plan Iter 8).
+	*
+	* IMPORTANT: Must be called within the XR animation frame callback, while
+	* the camera texture is valid. The returned `pixels` is the INTERNAL
+	* buffer — valid only until the next capture or `resizeIfNeeded`; consume
+	* it synchronously (e.g. via `createRgbLookup`) or copy it.
+	*
+	* Note: the buffer is in WebGL readback order (bottom-row-first / RGBA);
+	* `createRgbLookup` handles the y-flip.
+	*
+	* @returns the buffer with its dimensions, or null on failure/dispose.
+	*/
+	captureToPixels(renderer, cameraTexture) {
 		if (this.disposed) {
-			log.warn("captureToBlob called after dispose");
+			log.warn("captureToPixels called after dispose");
 			return null;
 		}
 		try {
@@ -133,7 +157,11 @@ var CameraBlitCapture = class {
 			renderer.setRenderTarget(currentRenderTarget);
 			renderer.xr.enabled = currentXrEnabled;
 			this.blitMaterial.uniforms.tDiffuse.value = null;
-			return await this.pixelsToJpegBlob(quality);
+			return {
+				pixels: this.pixelBuffer,
+				width: this.width,
+				height: this.height
+			};
 		} catch (error) {
 			log.error("Blit capture failed:", error);
 			return null;
@@ -239,6 +267,19 @@ var CameraBlitCapture = class {
 		return true;
 	}
 	/**
+	* Current render-target width in pixels. This is exactly the width of the
+	* JPEG produced by {@link captureToBlob} (the encode canvas is sized to the
+	* render target), so callers can persist it as the captured image's true
+	* pixel width without decoding the blob.
+	*/
+	getWidth() {
+		return this.width;
+	}
+	/** Current render-target height in pixels. See {@link getWidth}. */
+	getHeight() {
+		return this.height;
+	}
+	/**
 	* Dispose GPU resources. Call when AR session ends.
 	*/
 	dispose() {

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-BTCmZRL4.js";
+import { i as isFullySupported, n as CapabilitySupport, r as capabilityMessage, t as CapabilityMessageOptions } from "../capability-checker-CQXJHxXg.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-D4HYJNOj.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-CUeU3L_M.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-MifIwK9x.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-Jqbn0apH.js";
 export { BASELAYER_WINDOW_MAX, BASELAYER_WINDOW_MIN, ChromeVersion, ChromiumProjectionLayerWorkaroundResult, applyChromiumProjectionLayerWorkaround, needsBaseLayerPersistence, parseChromeVersion };

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

@@ -1,3 +1,3 @@
-import { i as DepthSample } from "../ar-types-isPsQptb.js";
-import { i as DepthSamplerConfig, n as DepthSampler, r as DepthSamplerCallbacks, t as DepthInfo } from "../depth-sampler-CqrkRr2N.js";
-export { DepthInfo, DepthSample, DepthSampler, DepthSamplerCallbacks, DepthSamplerConfig };
+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";
+export { DepthInfo, DepthSample, DepthSampler, DepthSamplerCallbacks, DepthSamplerConfig, wrapXRDepthInfo };

package/dist/ar/depth-sampler.js

@@ -1,9 +1,32 @@
 import { extractOdomPosition } from "../state/gps-event-coordinator.js";
 //#region ../src/ar/depth-sampler.ts
+/**
+* Wrap a raw browser XRDepthInformation object into a {@link DepthInfo}.
+*
+* - `getDepthInMeters` is bound to the source object (browser
+*   implementations are this-sensitive).
+* - `projectionMatrix` (typically `XRView.projectionMatrix`, a Float32Array
+*   the UA may reuse across frames) is defensively validated and copied into
+*   a plain serializable 16-tuple; invalid input (wrong length, non-finite
+*   entries) yields a DepthInfo without a matrix rather than an error.
+*/
+function wrapXRDepthInfo(raw, projectionMatrix) {
+	const wrapped = {
+		width: raw.width,
+		height: raw.height,
+		getDepthInMeters: raw.getDepthInMeters.bind(raw)
+	};
+	if (projectionMatrix && projectionMatrix.length === 16) {
+		const copy = Array.from(projectionMatrix);
+		if (copy.every((v) => Number.isFinite(v))) wrapped.projectionMatrix = copy;
+	}
+	return wrapped;
+}
 const DEFAULT_CONFIG = {
 	intervalMs: 1e3,
-	gridSize: 3,
-	unavailabilityThresholdMs: 5e3
+	gridSize: 16,
+	unavailabilityThresholdMs: 5e3,
+	rgb: true
 };
 /**
 * Samples sparse depth points from WebXR depth sensing.
@@ -74,6 +97,18 @@ var DepthSampler = class {
 		return { ...this.config };
 	}
 	/**
+	* Apply partial configuration overrides (e.g. the user's recording
+	* options, plumbed in by `startDepthCapture` just before sampling
+	* starts). Invalid values are ignored defensively: every key requires a
+	* finite positive number, and `gridSize` additionally an integer.
+	*/
+	updateConfig(config) {
+		if (isFinitePositive(config.intervalMs)) this.config.intervalMs = config.intervalMs;
+		if (isFinitePositive(config.gridSize) && Number.isInteger(config.gridSize)) this.config.gridSize = config.gridSize;
+		if (isFinitePositive(config.unavailabilityThresholdMs)) this.config.unavailabilityThresholdMs = config.unavailabilityThresholdMs;
+		if (typeof config.rgb === "boolean") this.config.rgb = config.rgb;
+	}
+	/**
 	* Called each frame with depth information.
 	*
 	* @param timestamp - Current frame timestamp in milliseconds
@@ -89,7 +124,7 @@ var DepthSampler = class {
 		if (timestamp - this.lastSampleTime < this.config.intervalMs) return;
 		const pose = this.callbacks.getCurrentPose();
 		if (!pose) return;
-		const points = this.sampleGrid(depthInfo);
+		const points = this.sampleGrid(depthInfo, this.acquireRgbLookupSafely());
 		const sample = {
 			timestamp: performance.timeOrigin + timestamp,
 			cameraPos: extractOdomPosition(pose),
@@ -99,26 +134,43 @@ var DepthSampler = class {
 				pose.orientation.z,
 				pose.orientation.w
 			],
-			points
+			points,
+			...depthInfo.projectionMatrix ? { projectionMatrix: depthInfo.projectionMatrix } : {}
 		};
 		this.lastSampleTime = timestamp;
 		this.sampleCount++;
 		this.callbacks.onSampleCaptured(sample);
 	}
 	/**
-	* Sample a grid of depth points from the depth buffer.
+	* Acquire the per-sample RGB lookup, gated by `config.rgb` and guarded so
+	* a failing acquisition (e.g. GL context loss during the blit) can never
+	* break the sample emission in the XR frame loop.
+	*/
+	acquireRgbLookupSafely() {
+		if (!this.config.rgb || !this.callbacks.acquireRgbLookup) return null;
+		try {
+			return this.callbacks.acquireRgbLookup();
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Sample a grid of depth points from the depth buffer, attaching the
+	* camera color per point when a lookup is available.
 	*/
-	sampleGrid(depthInfo) {
+	sampleGrid(depthInfo, rgbLookup) {
 		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);
+			const rgb = rgbLookup?.(screenX, screenY);
 			points.push({
 				screenX,
 				screenY,
-				depthM
+				depthM,
+				...rgb ? { rgb } : {}
 			});
 		}
 		return points;
@@ -143,5 +195,8 @@ var DepthSampler = class {
 		return this.depthReceived;
 	}
 };
+function isFinitePositive(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
 //#endregion
-export { DepthSampler };
+export { DepthSampler, wrapXRDepthInfo };

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

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

package/dist/ar/depth-unprojection.js

@@ -0,0 +1,94 @@
+import { mat4, quat, vec3, vec4 } from "gl-matrix";
+//#region ../src/ar/depth-unprojection.ts
+/**
+* Depth Unprojection
+*
+* Pure math: turn a persisted depth read (normalized view coordinates +
+* depth in meters) back into a 3D point in raw WebXR (local-floor) space
+* using the capturing view's projection matrix.
+*
+* Convention (single source of truth for NDC flips, see the 2026-06-11
+* occupancy-grid port plan §6):
+* - screenX/screenY are normalized view coordinates with a TOP-LEFT origin
+*   (screenY grows downward), exactly as fed to `getDepthInMeters`.
+* - NDC: x = 2·sx − 1, y = 1 − 2·sy (flip Y to bottom-up).
+* - View space is the WebXR camera frame: +x right, +y up, −z forward;
+*   `depthM` is the z-depth (distance along −z), not euclidean distance.
+*
+* @see depth-unprojection.ts.md for detailed documentation
+*/
+/**
+* Build a {@link DepthUnprojector} for one depth sample. The projection
+* inverse and camera quaternion/position are sample-invariant, so they are
+* computed once here instead of per point (the per-point hot path then only
+* does the cheap NDC→view→world transform). Callers that fold many points
+* from the same sample — e.g. `OccupancyGrid.addSample` — should build the
+* unprojector once and reuse it for all points.
+*
+* @param cameraPos - camera position, raw WebXR (`DepthSample.cameraPos`)
+* @param cameraRot - camera quaternion [x,y,z,w], raw WebXR (`DepthSample.cameraRot`)
+* @param projectionMatrix - column-major projection matrix of the capturing
+*   view (`DepthSample.projectionMatrix`). `undefined` for recordings made
+*   before intrinsics capture — those points cannot be unprojected.
+* @returns an unprojector, or `null` when the sample cannot be unprojected at
+*   all (missing or singular projection matrix).
+*/
+function createDepthUnprojector(cameraPos, cameraRot, projectionMatrix) {
+	if (!projectionMatrix || projectionMatrix.length !== 16) return null;
+	const invProj = mat4.invert(mat4.create(), projectionMatrix);
+	if (!invProj) return null;
+	const cameraQuat = quat.fromValues(cameraRot[0], cameraRot[1], cameraRot[2], cameraRot[3]);
+	const cameraPosVec = vec3.fromValues(cameraPos[0], cameraPos[1], cameraPos[2]);
+	const ndc = vec4.create();
+	const view = vec4.create();
+	const viewPoint = vec3.create();
+	const world = vec3.create();
+	return { unproject(point) {
+		if (!isUsablePoint(point)) return null;
+		const { screenX, screenY, depthM } = point;
+		vec4.set(ndc, 2 * screenX - 1, 1 - 2 * screenY, -1, 1);
+		vec4.transformMat4(view, ndc, invProj);
+		if (view[3] === 0) return null;
+		const rayX = view[0] / view[3];
+		const rayY = view[1] / view[3];
+		const rayZ = view[2] / view[3];
+		if (rayZ >= 0) return null;
+		const scale = -depthM / rayZ;
+		vec3.set(viewPoint, rayX * scale, rayY * scale, -depthM);
+		vec3.transformQuat(world, viewPoint, cameraQuat);
+		vec3.add(world, world, cameraPosVec);
+		const result = [
+			world[0],
+			world[1],
+			world[2]
+		];
+		return result.every((v) => Number.isFinite(v)) ? result : null;
+	} };
+}
+/**
+* Unproject a single depth point into raw WebXR space. Convenience wrapper
+* over {@link createDepthUnprojector} for one-off callers; when unprojecting
+* many points from the same sample, build the unprojector once instead.
+*
+* @param point - normalized view coordinates + depth in meters
+* @param cameraPos - camera position, raw WebXR (`DepthSample.cameraPos`)
+* @param cameraRot - camera quaternion [x,y,z,w], raw WebXR (`DepthSample.cameraRot`)
+* @param projectionMatrix - column-major projection matrix of the capturing
+*   view (`DepthSample.projectionMatrix`). `undefined` for recordings made
+*   before intrinsics capture — those points cannot be unprojected.
+* @returns the 3D point in raw WebXR space, or `null` when the input is not
+*   usable (missing/singular matrix, non-positive or non-finite depth,
+*   out-of-range screen coordinates).
+*/
+function unprojectDepthPoint(point, cameraPos, cameraRot, projectionMatrix) {
+	const unprojector = createDepthUnprojector(cameraPos, cameraRot, projectionMatrix);
+	return unprojector ? unprojector.unproject(point) : null;
+}
+function isUsablePoint(point) {
+	return Number.isFinite(point.depthM) && point.depthM > 0 && isInUnitRange(point.screenX) && isInUnitRange(point.screenY);
+}
+function isInUnitRange(v) {
+	return Number.isFinite(v) && v >= 0 && v <= 1;
+}
+//#endregion
+export { 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-DNbO0zbg.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-BfUJOgpW.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 { requestGeolocationPermission, requestOrientationPermission, requestWebXRWithDepthPermission } from "../sensors/permission-checker.js";
 import { startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch } from "../sensors/gps.js";
-import { endARSession, initAR, isWebXRSupported } from "./webxr-session.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 = {

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-BTeRpDm4.js";
+import { i as runFrameUpdates, n as clearFrameUpdates, r as registerFrameUpdate, t as FrameUpdate } from "../frame-loop-CMewS8cY.js";
 export { FrameUpdate, clearFrameUpdates, registerFrameUpdate, runFrameUpdates };

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

@@ -1,2 +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-BXZUmj7j.js";
-export { CapturedImage, DEFAULT_CAPTURE_CONFIG, ImageCaptureCallbacks, ImageCaptureConfig, ImageCaptureManager, MIN_VALID_IMAGE_BYTES };
+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 };

package/dist/ar/image-capture.js

@@ -23,7 +23,8 @@ const MIN_VALID_IMAGE_BYTES = 5e3;
 const DEFAULT_CAPTURE_CONFIG = {
 	intervalMs: 2e3,
 	quality: .7,
-	captureTimeoutMs: 5e3
+	captureTimeoutMs: 5e3,
+	resolutionDivisor: 1
 };
 /**
 * Manages periodic image capture from a canvas.
@@ -102,15 +103,15 @@ var ImageCaptureManager = class {
 				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);
+		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, timestamp, frameIndex, pose, screenRotation);
+			this.handleCapturedBlob(blob, this.canvas.width, this.canvas.height, timestamp, frameIndex, pose, screenRotation);
 		}, "image/jpeg", this.config.quality);
 	}
 	/**
@@ -127,7 +128,7 @@ var ImageCaptureManager = class {
 	* 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) {
+	handleCapturedBlob(blob, width, height, timestamp, frameIndex, pose, screenRotation) {
 		this.clearCaptureTimeout();
 		this.captureInProgress = false;
 		if (!blob) {
@@ -144,7 +145,9 @@ var ImageCaptureManager = class {
 			frameIndex,
 			position: pose.position,
 			rotation: pose.orientation,
-			screenRotation
+			screenRotation,
+			...width && width > 0 ? { width } : {},
+			...height && height > 0 ? { height } : {}
 		});
 	}
 };

package/dist/ar/index.d.ts

@@ -1,16 +1,19 @@
-import { i as computeCaptureSize, n as CameraBlitCaptureConfig, r as DEFAULT_BLIT_CONFIG, t as CameraBlitCapture } from "../camera-blit-capture-75WWa9Xb.js";
-import { i as isFullySupported, n as CapabilitySupport, r as capabilityMessage, t as CapabilityMessageOptions } from "../capability-checker-BTCmZRL4.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-D4HYJNOj.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-MifIwK9x.js";
-import { i as DepthSamplerConfig, n as DepthSampler, r as DepthSamplerCallbacks, t as DepthInfo } from "../depth-sampler-CqrkRr2N.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-BXZUmj7j.js";
-import { i as acquireCameraTexture, n as RendererLike, r as XRCameraLike, t as CameraTextureResult } from "../xr-camera-texture-BU5YvKAM.js";
-import { D as setDepthCaptureCallback, I as startDepthCapture, L as startImageCapture, M as setTrackingLostCallback, O as setFrameCallback, P as setTrackingStore, R as stopDepthCapture, d as getCamera, f as getCurrentArPose, g as getScene, h as getLiveCss3dManager, j as setTrackingCallbacks, k as setImageCaptureCallback, m as getImageCaptureFrameCount, o as endARSession, p as getDepthSampleCount, t as SessionFeatureOptions, u as getArWorldGroup, v as initAR, z as stopImageCapture } from "../webxr-session-BnArFCew.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-DNbO0zbg.js";
-import { r as registerFrameUpdate, t as FrameUpdate } from "../frame-loop-BTeRpDm4.js";
-import { i as registerXrFrameUpdate, n as XrFrameUpdate, t as XrFrameContext } from "../xr-frame-loop-BKckC7xC.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-DkNfldPh.js";
-import { t as SCENE_NODE } from "../scene-node-names-IHW7HR4S.js";
-import { t as WEBXR_TO_NUE } from "../index-22v8MXJX.js";
-import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "../xr-error-handler-DcUFshNF.js";
-export { BASELAYER_WINDOW_MAX, BASELAYER_WINDOW_MIN, CAPTURE_FAILURE_WARNING, CameraBlitCapture, CameraBlitCaptureConfig, CameraMode, CameraTextureResult, CapabilityMessageOptions, CapabilitySupport, CaptureFailureTracker, CaptureFailureTrackerConfig, CapturedImage, ChromeVersion, ChromiumProjectionLayerWorkaroundResult, DEFAULT_BLIT_CONFIG, DEFAULT_CAPTURE_CONFIG, DEFAULT_CAPTURE_TRACKER_CONFIG, DepthInfo, DepthSampler, DepthSamplerCallbacks, DepthSamplerConfig, EnableGpsArConfig, EnableGpsArController, EnableGpsArDeps, EnableGpsArResult, EnableGpsArState, EnableGpsArStatus, FrameUpdate, ImageCaptureCallbacks, ImageCaptureConfig, ImageCaptureManager, MIN_VALID_IMAGE_BYTES, RendererLike, ReplaySceneState, SCENE_NODE, SessionFeatureOptions, WEBXR_TO_NUE, XRCameraLike, XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, XrFrameContext, XrFrameUpdate, acquireCameraTexture, applyChromiumProjectionLayerWorkaround, capabilityMessage, computeCaptureSize, createCaptureFailureTracker, createEnableGpsArController, disposeReplayScene, endARSession, getAlignmentLerper, getArWorldGroup, getCamera, getCameraFollower, getCameraMode, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getReplayState, getScene, getXrErrorMessage, initAR, initReplayScene, isFullySupported, needsBaseLayerPersistence, parseChromeVersion, registerFrameUpdate, registerXrFrameUpdate, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setTrackingCallbacks, setTrackingLostCallback, setTrackingStore, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture, toggleCameraMode, updateOrbitTarget };
+import { r as bresenham3d, t as GridCell } from "../bresenham3d-CFfd7n6B.js";
+import { i as computeCaptureSize, n as CameraBlitCaptureConfig, r as DEFAULT_BLIT_CONFIG, t as CameraBlitCapture } from "../camera-blit-capture-CnxUDbKx.js";
+import { i as isFullySupported, n as CapabilitySupport, r as capabilityMessage, t as CapabilityMessageOptions } from "../capability-checker-CQXJHxXg.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-CUeU3L_M.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-Jqbn0apH.js";
+import { a as wrapXRDepthInfo, i as DepthSamplerConfig, n as DepthSampler, r as DepthSamplerCallbacks, t as DepthInfo } from "../depth-sampler-Bhanfwla.js";
+import { n as createDepthUnprojector, r as unprojectDepthPoint, t as DepthUnprojector } from "../depth-unprojection-Y6i_mJuT.js";
+import { a as ImageCaptureConfig, i as ImageCaptureCallbacks, n as CapturedImage, o as ImageCaptureManager, r as DEFAULT_CAPTURE_CONFIG, s as MIN_VALID_IMAGE_BYTES } from "../image-capture-qAZ5Fh5X.js";
+import { i as acquireCameraTexture, n as RendererLike, r as XRCameraLike, t as CameraTextureResult } from "../xr-camera-texture-DBwCaKTd.js";
+import { D as setDepthCaptureCallback, I as startDepthCapture, L as startImageCapture, M as setTrackingLostCallback, O as setFrameCallback, P as setTrackingStore, R as stopDepthCapture, d as getCamera, f as getCurrentArPose, g as getScene, h as getLiveCss3dManager, j as setTrackingCallbacks, k as setImageCaptureCallback, m as getImageCaptureFrameCount, o as endARSession, p as getDepthSampleCount, t as SessionFeatureOptions, u as getArWorldGroup, v as initAR, z as stopImageCapture } from "../webxr-session-GjZ2BIpS.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-BfUJOgpW.js";
+import { r as registerFrameUpdate, t as FrameUpdate } from "../frame-loop-CMewS8cY.js";
+import { n as OccupancyGridOptions, t as OccupancyGrid } from "../occupancy-grid-BRNRaPyT.js";
+import { i as registerXrFrameUpdate, n as XrFrameUpdate, t as XrFrameContext } from "../xr-frame-loop-BtYytZJg.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-Bw58VL6p.js";
+import { t as SCENE_NODE } from "../scene-node-names-Bu0S66H1.js";
+import { t as WEBXR_TO_NUE } from "../webxr-nue-basis-CqKQmZzT.js";
+import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "../xr-error-handler-C0AQRmxs.js";
+export { BASELAYER_WINDOW_MAX, BASELAYER_WINDOW_MIN, CAPTURE_FAILURE_WARNING, CameraBlitCapture, type CameraBlitCaptureConfig, type CameraMode, type CameraTextureResult, type CapabilityMessageOptions, type CapabilitySupport, type CaptureFailureTracker, type CaptureFailureTrackerConfig, type CapturedImage, type ChromeVersion, type ChromiumProjectionLayerWorkaroundResult, DEFAULT_BLIT_CONFIG, DEFAULT_CAPTURE_CONFIG, DEFAULT_CAPTURE_TRACKER_CONFIG, type DepthInfo, DepthSampler, type DepthSamplerCallbacks, type DepthSamplerConfig, type DepthUnprojector, type EnableGpsArConfig, type EnableGpsArController, type EnableGpsArDeps, type EnableGpsArResult, type EnableGpsArState, type EnableGpsArStatus, type FrameUpdate, type GridCell, type ImageCaptureCallbacks, type ImageCaptureConfig, ImageCaptureManager, MIN_VALID_IMAGE_BYTES, OccupancyGrid, type OccupancyGridOptions, type RendererLike, type ReplaySceneState, SCENE_NODE, type SessionFeatureOptions, WEBXR_TO_NUE, type XRCameraLike, XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, type XrFrameContext, type XrFrameUpdate, acquireCameraTexture, applyChromiumProjectionLayerWorkaround, bresenham3d, capabilityMessage, computeCaptureSize, createCaptureFailureTracker, createDepthUnprojector, createEnableGpsArController, disposeReplayScene, endARSession, getAlignmentLerper, getArWorldGroup, getCamera, getCameraFollower, getCameraMode, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getReplayState, getScene, getXrErrorMessage, initAR, initReplayScene, isFullySupported, needsBaseLayerPersistence, parseChromeVersion, registerFrameUpdate, registerXrFrameUpdate, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setTrackingCallbacks, setTrackingLostCallback, setTrackingStore, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture, toggleCameraMode, unprojectDepthPoint, updateOrbitTarget, wrapXRDepthInfo };

package/dist/ar/index.js

@@ -2,15 +2,18 @@ import { CameraBlitCapture, DEFAULT_BLIT_CONFIG, computeCaptureSize } from "./ca
 import { capabilityMessage, isFullySupported } from "./capability-checker.js";
 import { BASELAYER_WINDOW_MAX, BASELAYER_WINDOW_MIN, applyChromiumProjectionLayerWorkaround, needsBaseLayerPersistence, parseChromeVersion } 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 { DepthSampler, wrapXRDepthInfo } from "./depth-sampler.js";
+import { createDepthUnprojector, unprojectDepthPoint } from "./depth-unprojection.js";
+import { bresenham3d } from "./bresenham3d.js";
+import { OccupancyGrid } from "./occupancy-grid.js";
 import { registerFrameUpdate } from "./frame-loop.js";
 import { registerXrFrameUpdate } from "./xr-frame-loop.js";
-import { t as WEBXR_TO_NUE } from "../webxr-nue-basis-BbdqhqY6.js";
+import { WEBXR_TO_NUE } from "./webxr-nue-basis.js";
 import { DEFAULT_CAPTURE_CONFIG, ImageCaptureManager, MIN_VALID_IMAGE_BYTES } from "./image-capture.js";
+import { A as setTrackingLostCallback, D as setImageCaptureCallback, E as setFrameCallback, F as startImageCapture, I as stopDepthCapture, L as stopImageCapture, M as setTrackingStore, P as startDepthCapture, T as setDepthCaptureCallback, c as getArWorldGroup, d as getDepthSampleCount, f as getImageCaptureFrameCount, g as initAR, i as endARSession, k as setTrackingCallbacks, l as getCamera, m as getScene, p as getLiveCss3dManager, u as getCurrentArPose } from "../webxr-session-TIaD883f.js";
 import { acquireCameraTexture } from "./xr-camera-texture.js";
 import { SCENE_NODE } from "./scene-node-names.js";
-import { endARSession, getArWorldGroup, getCamera, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, initAR, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setTrackingCallbacks, setTrackingLostCallback, setTrackingStore, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture } from "./webxr-session.js";
 import { createEnableGpsArController } from "./enable-gps-ar.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 { BASELAYER_WINDOW_MAX, BASELAYER_WINDOW_MIN, CAPTURE_FAILURE_WARNING, CameraBlitCapture, DEFAULT_BLIT_CONFIG, DEFAULT_CAPTURE_CONFIG, DEFAULT_CAPTURE_TRACKER_CONFIG, DepthSampler, ImageCaptureManager, MIN_VALID_IMAGE_BYTES, SCENE_NODE, WEBXR_TO_NUE, XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, acquireCameraTexture, applyChromiumProjectionLayerWorkaround, capabilityMessage, computeCaptureSize, createCaptureFailureTracker, createEnableGpsArController, disposeReplayScene, endARSession, getAlignmentLerper, getArWorldGroup, getCamera, getCameraFollower, getCameraMode, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getReplayState, getScene, getXrErrorMessage, initAR, initReplayScene, isFullySupported, needsBaseLayerPersistence, parseChromeVersion, registerFrameUpdate, registerXrFrameUpdate, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setTrackingCallbacks, setTrackingLostCallback, setTrackingStore, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture, toggleCameraMode, updateOrbitTarget };
+export { BASELAYER_WINDOW_MAX, BASELAYER_WINDOW_MIN, CAPTURE_FAILURE_WARNING, CameraBlitCapture, DEFAULT_BLIT_CONFIG, DEFAULT_CAPTURE_CONFIG, DEFAULT_CAPTURE_TRACKER_CONFIG, DepthSampler, ImageCaptureManager, MIN_VALID_IMAGE_BYTES, OccupancyGrid, SCENE_NODE, WEBXR_TO_NUE, XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, acquireCameraTexture, applyChromiumProjectionLayerWorkaround, bresenham3d, capabilityMessage, computeCaptureSize, createCaptureFailureTracker, createDepthUnprojector, createEnableGpsArController, disposeReplayScene, endARSession, getAlignmentLerper, getArWorldGroup, getCamera, getCameraFollower, getCameraMode, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getReplayState, getScene, getXrErrorMessage, initAR, initReplayScene, isFullySupported, needsBaseLayerPersistence, parseChromeVersion, registerFrameUpdate, registerXrFrameUpdate, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setTrackingCallbacks, setTrackingLostCallback, setTrackingStore, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture, toggleCameraMode, unprojectDepthPoint, updateOrbitTarget, wrapXRDepthInfo };

package/dist/ar/occupancy-grid.d.ts

@@ -0,0 +1,2 @@
+import { n as OccupancyGridOptions, t as OccupancyGrid } from "../occupancy-grid-BRNRaPyT.js";
+export { OccupancyGrid, OccupancyGridOptions };