gps-plus-slam-app-framework 1.0.7 → 1.2.0

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

@@ -0,0 +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-CapmADVN.js";
+export { EnableGpsArConfig, EnableGpsArController, EnableGpsArDeps, EnableGpsArResult, EnableGpsArState, EnableGpsArStatus, createEnableGpsArController };

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

@@ -0,0 +1,137 @@
+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 { _ as isWebXRSupported, g as initAR, i as endARSession } from "../webxr-session-QhcSSub5.js";
+//#region ../src/ar/enable-gps-ar.ts
+const log = createLogger("EnableGpsAr");
+const defaultDeps = {
+	isWebXRSupported,
+	requestGeolocationPermission,
+	requestOrientationPermission,
+	requestWebXRWithDepthPermission,
+	startGpsWatch,
+	startOrientationWatch,
+	initAR,
+	stopGpsWatch,
+	stopOrientationWatch,
+	endARSession
+};
+/**
+* Create an "Enable GPS AR" controller. Pass partial `deps` in tests to inject
+* fakes; production callers use the defaults.
+*/
+function createEnableGpsArController(deps = {}) {
+	const resolved = {
+		...defaultDeps,
+		...deps
+	};
+	let state = { status: "checking" };
+	const listeners = /* @__PURE__ */ new Set();
+	let gpsWatchActive = false;
+	let orientationWatchActive = false;
+	function setState(next) {
+		state = next;
+		for (const listener of [...listeners]) try {
+			listener(state);
+		} catch (err) {
+			log.error("State listener threw; continuing dispatch:", err);
+		}
+	}
+	async function refreshSupport() {
+		if (state.status === "starting" || state.status === "running" || state.status === "stopping") return;
+		setState({ status: "checking" });
+		const supported = await probeSupport();
+		if (state.status !== "checking") return;
+		setState({ status: supported ? "ready" : "unsupported" });
+	}
+	async function probeSupport() {
+		try {
+			return await resolved.isWebXRSupported();
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Request the configured permissions. Returns an error message when a
+	* *blocking* permission (geolocation, or depth when opted in) is not granted,
+	* or `null` on success. Orientation is best-effort and never blocks.
+	*/
+	async function requestPermissions(config) {
+		const geolocation = await resolved.requestGeolocationPermission();
+		if (geolocation.granted !== true) return geolocation.error ?? "Location permission is required for GPS AR.";
+		try {
+			await resolved.requestOrientationPermission();
+		} catch {}
+		if (config.requestDepth) {
+			const depth = await resolved.requestWebXRWithDepthPermission();
+			if (depth.granted !== true) return depth.error ?? "Depth (3D map) permission was denied.";
+		}
+		return null;
+	}
+	async function enable(config) {
+		if (state.status === "starting" || state.status === "running" || state.status === "stopping") return {
+			ok: false,
+			error: "AR is already starting, running or stopping."
+		};
+		setState({ status: "starting" });
+		try {
+			const permissionError = await requestPermissions(config);
+			if (permissionError !== null) return fail(permissionError);
+			await resolved.initAR(config.container, config.isolationOptions, { requestHitTest: config.requestHitTest });
+			if (config.onGpsPosition) {
+				resolved.startGpsWatch(config.onGpsPosition);
+				gpsWatchActive = true;
+			}
+			if (config.onOrientation) {
+				resolved.startOrientationWatch(config.onOrientation);
+				orientationWatchActive = true;
+			}
+			setState({ status: "running" });
+			return { ok: true };
+		} catch (err) {
+			return fail(err instanceof Error ? err.message : String(err));
+		}
+	}
+	function fail(error) {
+		setState({
+			status: "error",
+			error
+		});
+		return {
+			ok: false,
+			error
+		};
+	}
+	async function disable() {
+		if (state.status !== "running") return;
+		setState({ status: "stopping" });
+		if (gpsWatchActive) {
+			resolved.stopGpsWatch();
+			gpsWatchActive = false;
+		}
+		if (orientationWatchActive) {
+			resolved.stopOrientationWatch();
+			orientationWatchActive = false;
+		}
+		try {
+			await resolved.endARSession();
+		} catch (err) {
+			log.error("endARSession threw during disable; continuing teardown:", err);
+		}
+		setState({ status: "ready" });
+	}
+	return {
+		getState: () => state,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		refreshSupport,
+		enable,
+		disable
+	};
+}
+//#endregion
+export { createEnableGpsArController };

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-QJIxLin0.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/frame-loop.js

@@ -1,4 +1,18 @@
+import { createLogger } from "../utils/logger.js";
 //#region ../src/ar/frame-loop.ts
+/**
+* Per-frame callback registry. The WebXR session owns the single
+* `renderer.setAnimationLoop(...)` hook for the page; components that need
+* a per-frame tick register here and the session's `onXRFrame` invokes
+* `runFrameUpdates(dt, elapsed)` once per frame.
+*
+* Plain functions, not a class: there is exactly one frame loop per session
+* and singletons-of-singletons add no value. See
+* `2026-05-13-ecs-migration-plan.md` for the design rationale and the
+* rules new `FrameUpdate` bodies must follow (pure function of `dt` plus
+* selectors; no direct Redux dispatch from inside a tick).
+*/
+const log = createLogger("FrameLoop");
 const updates = /* @__PURE__ */ new Set();
 /**
 * Register a per-frame callback. Returns an unregister function.
@@ -23,10 +37,19 @@ function registerFrameUpdate(fn) {
 * same frame are deferred to the next tick. Iterating the live `Set`
 * would otherwise skip a not-yet-visited entry that an earlier handler
 * unregistered — a hard-to-debug source of non-determinism.
+*
+* Each callback is invoked in its own `try/catch` so a throwing handler is
+* isolated: it cannot abort the remaining callbacks nor propagate up through
+* `onXRFrame` and kill the scene render for the whole frame. Failures are
+* logged and the loop continues — mirrored by `runXrFrameUpdates`.
 */
 function runFrameUpdates(dt, elapsed) {
 	const snapshot = Array.from(updates);
-	for (const fn of snapshot) fn(dt, elapsed);
+	for (const fn of snapshot) try {
+		fn(dt, elapsed);
+	} catch (error) {
+		log.error("A registered FrameUpdate threw; continuing the loop", error);
+	}
 }
 /**
 * Clear all registrations. Called from `resetWebXRState()` so a fresh

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-DZLxHDN9.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-DZ4HFRgS.js";
 export { 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.

package/dist/ar/index.d.ts

@@ -1,12 +1,19 @@
-import { i as computeCaptureSize, n as CameraBlitCaptureConfig, r as DEFAULT_BLIT_CONFIG, t as CameraBlitCapture } from "../camera-blit-capture-C1V9I1Z6.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-JKb1ST8E.js";
-import { n as applyChromiumProjectionLayerWorkaround, t as ChromiumProjectionLayerWorkaroundResult } from "../chromium-camera-access-workaround-NvChXsi8.js";
-import { i as DepthSamplerConfig, n as DepthSampler, r as DepthSamplerCallbacks, t as DepthInfo } from "../depth-sampler-xg8vna6c.js";
-import { r as registerFrameUpdate, t as FrameUpdate } from "../frame-loop-QJIxLin0.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-DZLxHDN9.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-DpAGcAKY.js";
-import { t as SCENE_NODE } from "../scene-node-names-6LBjPmwz.js";
-import { i as acquireCameraTexture, n as RendererLike, r as XRCameraLike, t as CameraTextureResult } from "../xr-camera-texture-BU5YvKAM.js";
-import { A as setTrackingCallbacks, D as setFrameCallback, E as setDepthCaptureCallback, F as startDepthCapture, I as startImageCapture, L as stopDepthCapture, N as setTrackingStore, O as setImageCaptureCallback, R as stopImageCapture, _ as initAR, a as endARSession, f as getDepthSampleCount, j as setTrackingLostCallback, m as getLiveCss3dManager, p as getImageCaptureFrameCount } from "../webxr-session-DB5cIZnN.js";
-import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "../xr-error-handler-CDY5QxGb.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 FrameUpdate, type ImageCaptureCallbacks, type ImageCaptureConfig, ImageCaptureManager, MIN_VALID_IMAGE_BYTES, type RendererLike, type ReplaySceneState, SCENE_NODE, 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, registerFrameUpdate, 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-D5_mNhla.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 ImageCaptureManager, i as ImageCaptureConfig, n as DEFAULT_CAPTURE_CONFIG, o as MIN_VALID_IMAGE_BYTES, r as ImageCaptureCallbacks, t as CapturedImage } from "../image-capture-DZ4HFRgS.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-DtAG9srK.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-CapmADVN.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

@@ -1,12 +1,19 @@
 import { CameraBlitCapture, DEFAULT_BLIT_CONFIG, computeCaptureSize } from "./camera-blit-capture.js";
-import { applyChromiumProjectionLayerWorkaround } from "./chromium-camera-access-workaround.js";
+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 { 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-QhcSSub5.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, 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 { CAPTURE_FAILURE_WARNING, CameraBlitCapture, DEFAULT_BLIT_CONFIG, DEFAULT_CAPTURE_CONFIG, DEFAULT_CAPTURE_TRACKER_CONFIG, DepthSampler, ImageCaptureManager, MIN_VALID_IMAGE_BYTES, SCENE_NODE, XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, acquireCameraTexture, applyChromiumProjectionLayerWorkaround, computeCaptureSize, createCaptureFailureTracker, disposeReplayScene, endARSession, getAlignmentLerper, getCameraFollower, getCameraMode, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getReplayState, getXrErrorMessage, initAR, initReplayScene, registerFrameUpdate, 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 };

package/dist/ar/occupancy-grid.js

@@ -0,0 +1,164 @@
+import { createDepthUnprojector } from "./depth-unprojection.js";
+import { bresenham3d } from "./bresenham3d.js";
+//#region ../src/ar/occupancy-grid.ts
+var OccupancyGrid = class {
+	cellSizeM;
+	carveStopCells;
+	cells = /* @__PURE__ */ new Map();
+	constructor(options) {
+		const cellSizeM = options?.cellSizeM ?? .15;
+		const carveStopCells = options?.carveStopCells ?? 2;
+		if (!Number.isFinite(cellSizeM) || cellSizeM <= 0) throw new RangeError(`cellSizeM must be a positive number, got ${cellSizeM}`);
+		if (!Number.isSafeInteger(carveStopCells) || carveStopCells < 0) throw new RangeError(`carveStopCells must be a non-negative integer, got ${carveStopCells}`);
+		this.cellSizeM = cellSizeM;
+		this.carveStopCells = carveStopCells;
+	}
+	/** Number of occupied cells. */
+	get size() {
+		return this.cells.size;
+	}
+	/**
+	* Fold one depth sample into the grid: unproject each point, carve free
+	* space from the camera cell to the point cell, then count the point's
+	* cell as occupied. Points that cannot be unprojected (no
+	* projectionMatrix on old recordings, invalid depth/coords) are skipped.
+	*
+	* Carving and incrementing run as two separate passes over the sample's
+	* points: all rays are carved first, then every endpoint is incremented.
+	* A single interleaved pass would be order-dependent — a deeper point's
+	* carve could erase the endpoint a nearer point added earlier in the same
+	* sample. Splitting the passes makes the result deterministic and lets an
+	* endpoint observed within a sample survive other rays in that same
+	* sample. (Deeper-carves-nearer still applies ACROSS samples: a later
+	* sample's ray carves an earlier sample's endpoint as before.)
+	*
+	* @returns the number of points actually added.
+	*/
+	addSample(sample) {
+		if (!isFiniteTriple(sample.cameraPos)) return 0;
+		const unprojector = createDepthUnprojector(sample.cameraPos, sample.cameraRot, sample.projectionMatrix);
+		if (!unprojector) return 0;
+		const cameraCell = this.cellForPosition(sample.cameraPos);
+		const endpoints = [];
+		for (const point of sample.points) {
+			const world = unprojector.unproject(point);
+			if (!world) continue;
+			const cell = this.cellForPosition(world);
+			if (!cellsEqual(cameraCell, cell)) this.carve(cameraCell, cell);
+			endpoints.push({
+				cell,
+				rgb: point.rgb
+			});
+		}
+		for (const endpoint of endpoints) this.increment(endpoint.cell, endpoint.rgb);
+		return endpoints.length;
+	}
+	/** Occupied cells observed at least `minObservations` times (default 1). */
+	getOccupiedCells(minObservations = 1) {
+		const result = [];
+		for (const record of this.cells.values()) if (record.count >= minObservations) result.push(record.cell);
+		return result;
+	}
+	/** Quantize a raw-WebXR position to its grid cell (round per axis). */
+	cellForPosition(pos) {
+		return [
+			Math.round(pos[0] / this.cellSizeM) + 0,
+			Math.round(pos[1] / this.cellSizeM) + 0,
+			Math.round(pos[2] / this.cellSizeM) + 0
+		];
+	}
+	/** Center of a cell in raw WebXR space (round-consistent: cell · cellSizeM). */
+	getCellCenter(cell) {
+		return [
+			cell[0] * this.cellSizeM,
+			cell[1] * this.cellSizeM,
+			cell[2] * this.cellSizeM
+		];
+	}
+	/**
+	* Running-average color of the cell's colored observations (Iter 8), or
+	* null when the cell is unknown or was only ever observed without color
+	* (rgb option off / pre-Iter-8 recordings) — consumers fall back to
+	* height-based coloring. Channels are rounded and clamped to 0–255.
+	*/
+	getCellColor(cell) {
+		const record = this.cells.get(cellKey(cell));
+		if (!record || record.colorCount === 0) return null;
+		const average = (sum) => Math.min(255, Math.max(0, Math.round(sum / record.colorCount)));
+		return [
+			average(record.colorSum[0]),
+			average(record.colorSum[1]),
+			average(record.colorSum[2])
+		];
+	}
+	/**
+	* Walk the grid from `startPos` to `endPos` and return the center of the
+	* first cell occupied at least `minObservations` times, or null.
+	* Port of Unity's `TryRaycast` (hook for cursor/floor-detection parity).
+	*/
+	raycast(startPos, endPos, minObservations = 1) {
+		if (!isFiniteTriple(startPos) || !isFiniteTriple(endPos)) return null;
+		let hit = null;
+		bresenham3d(this.cellForPosition(startPos), this.cellForPosition(endPos), (cell) => {
+			const record = this.cells.get(cellKey(cell));
+			if (record && record.count >= minObservations) {
+				hit = cell;
+				return false;
+			}
+			return true;
+		});
+		return hit ? this.getCellCenter(hit) : null;
+	}
+	/** Remove all occupied cells (e.g. on store swap / new session). */
+	clear() {
+		this.cells.clear();
+	}
+	/**
+	* Delete occupied cells along the camera→point ray (the space was seen
+	* through, so it must be free), stopping `carveStopCells` dominant-axis
+	* steps before the endpoint. The endpoint cell itself is additionally
+	* protected so a current observation is never erased (relevant for
+	* carveStopCells = 0 and for the unconditional start-cell visit).
+	*/
+	carve(cameraCell, pointCell) {
+		bresenham3d(cameraCell, pointCell, (cell) => {
+			if (!cellsEqual(cell, pointCell)) this.cells.delete(cellKey(cell));
+			return true;
+		}, this.carveStopCells);
+	}
+	increment(cell, rgb) {
+		const key = cellKey(cell);
+		let record = this.cells.get(key);
+		if (!record) {
+			record = {
+				cell,
+				count: 0,
+				colorCount: 0,
+				colorSum: [
+					0,
+					0,
+					0
+				]
+			};
+			this.cells.set(key, record);
+		}
+		record.count++;
+		if (rgb && isFiniteTriple(rgb)) {
+			record.colorCount++;
+			record.colorSum[0] += rgb[0];
+			record.colorSum[1] += rgb[1];
+			record.colorSum[2] += rgb[2];
+		}
+	}
+};
+function cellKey(cell) {
+	return `${cell[0]},${cell[1]},${cell[2]}`;
+}
+function cellsEqual(a, b) {
+	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+function isFiniteTriple(v) {
+	return Number.isFinite(v[0]) && Number.isFinite(v[1]) && Number.isFinite(v[2]);
+}
+//#endregion
+export { OccupancyGrid };