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

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

@@ -1,7 +1,6 @@
-import { r as SlamAppRootState } from "./create-slam-app-store-DBm7g2Zd.js";
-import { t as CombinedRootState } from "./combined-root-state-B3SvPNjU.js";
+import { L as CombinedRootState, r as SlamAppRootState } from "./create-slam-app-store-B76AGaI0.js";
 import * as _$gps_plus_slam_js0 from "gps-plus-slam-js";
-import { GpsPoint, LatLong, Matrix4, Quaternion, ReferencePoint, Vector3 } from "gps-plus-slam-js";
+import { ArImageCapture, GpsPoint, LatLong, Matrix4, Quaternion, Vector3 } from "gps-plus-slam-js";
 import * as _$_reduxjs_toolkit0 from "@reduxjs/toolkit";
 
 //#region ../src/state/app-selectors.d.ts
@@ -115,20 +114,19 @@ declare const selectZeroReference: ((state: SlamAppRootState & {}) => LatLong |
   memoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
-/** User-defined reference points for ground truth validation. */
-declare const selectReferencePoints: ((state: SlamAppRootState & {}) => readonly ReferencePoint[]) & {
+declare const selectFrameTilesInWebXR: ((state: SlamAppRootState & {}) => readonly ArImageCapture[]) & {
   clearCache: () => void;
   resultsCount: () => number;
   resetResultsCount: () => void;
 } & {
-  resultFunc: (resultFuncArgs_0: _$gps_plus_slam_js0.GpsModel | null) => readonly ReferencePoint[];
-  memoizedResultFunc: ((resultFuncArgs_0: _$gps_plus_slam_js0.GpsModel | null) => readonly ReferencePoint[]) & {
+  resultFunc: (resultFuncArgs_0: ArImageCapture[] | undefined) => readonly ArImageCapture[];
+  memoizedResultFunc: ((resultFuncArgs_0: ArImageCapture[] | undefined) => readonly ArImageCapture[]) & {
     clearCache: () => void;
     resultsCount: () => number;
     resetResultsCount: () => void;
   };
-  lastResult: () => readonly ReferencePoint[];
-  dependencies: [(state: CombinedRootState) => _$gps_plus_slam_js0.GpsModel | null];
+  lastResult: () => readonly ArImageCapture[];
+  dependencies: [(state: CombinedRootState) => ArImageCapture[] | undefined];
   recomputations: () => number;
   resetRecomputations: () => void;
   dependencyRecomputations: () => number;
@@ -138,4 +136,4 @@ declare const selectReferencePoints: ((state: SlamAppRootState & {}) => readonly
   argsMemoize: typeof _$_reduxjs_toolkit0.weakMapMemoize;
 };
 //#endregion
-export { selectReferencePoints as a, selectOdometryRotations as i, selectGpsPositions as n, selectZeroReference as o, selectOdometryPositions as r, selectAlignmentMatrix as t };
+export { selectOdometryRotations as a, selectOdometryPositions as i, selectFrameTilesInWebXR as n, selectZeroReference as o, selectGpsPositions as r, selectAlignmentMatrix as t };

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-DHuyrrxr.js";
+import { i as computeCaptureSize, n as CameraBlitCaptureConfig, r as DEFAULT_BLIT_CONFIG, t as CameraBlitCapture } from "../camera-blit-capture-75WWa9Xb.js";
 export { CameraBlitCapture, CameraBlitCaptureConfig, DEFAULT_BLIT_CONFIG, computeCaptureSize };

package/dist/ar/capability-checker.d.ts

@@ -0,0 +1,2 @@
+import { i as isFullySupported, n as CapabilitySupport, r as capabilityMessage, t as CapabilityMessageOptions } from "../capability-checker-BTCmZRL4.js";
+export { CapabilityMessageOptions, CapabilitySupport, capabilityMessage, isFullySupported };

package/dist/ar/capability-checker.js

@@ -0,0 +1,25 @@
+//#region ../src/ar/capability-checker.ts
+/** True only when both AR and GPS are available — the demo can run. */
+function isFullySupported(support) {
+	return support.webxr && support.geolocation;
+}
+/**
+* Build the capability-gated message shown when the demo cannot run. Names
+* exactly which capabilities are missing so the user understands *why*, and
+* always points them at the supported environment (an AR phone, outdoors).
+* Returns `null` when everything is supported (no message needed).
+*
+* The trailing "to try …" clause is app-specific and supplied via
+* `options.contextLabel`; without it the message ends neutrally at
+* "…outdoors.".
+*/
+function capabilityMessage(support, options = {}) {
+	if (isFullySupported(support)) return null;
+	const missing = [];
+	if (!support.webxr) missing.push("WebXR augmented reality");
+	if (!support.geolocation) missing.push("GPS / geolocation");
+	const suffix = options.contextLabel ? `, to try ${options.contextLabel}` : "";
+	return `This demo needs ${missing.join(" and ")}, which this device or browser does not provide. Open it on an AR-capable phone (e.g. Chrome on Android with ARCore), outdoors${suffix}.`;
+}
+//#endregion
+export { 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-2Q6oI2uQ.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";
 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 { n as applyChromiumProjectionLayerWorkaround, t as ChromiumProjectionLayerWorkaroundResult } from "../chromium-camera-access-workaround-CU5zSKNr.js";
-export { ChromiumProjectionLayerWorkaroundResult, applyChromiumProjectionLayerWorkaround };
+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";
+export { BASELAYER_WINDOW_MAX, BASELAYER_WINDOW_MIN, ChromeVersion, ChromiumProjectionLayerWorkaroundResult, applyChromiumProjectionLayerWorkaround, needsBaseLayerPersistence, parseChromeVersion };

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

@@ -1,20 +1,207 @@
+import { createLogger } from "../utils/logger.js";
 //#region ../src/ar/chromium-camera-access-workaround.ts
 /**
+* Chromium WebXR camera-access tab-crash workaround.
+*
+* Background:
+* Requesting `camera-access` as an optional WebXR feature on Android Chrome
+* 147+ causes a fatal renderer-process crash (`CrRendererMain`) 1–2 seconds
+* after entering AR. The crash reproduces in the upstream three.js
+* `webxr_ar_hittest.html` example with `optionalFeatures: ['camera-access']`
+* added — i.e. it is not specific to this app's session setup. See:
+*
+*   - GpsPlusSlamJs_Docs/docs/2026-04-22-camera-access-reproducer-plan.md
+*   - GpsPlusSlamJs_Docs/docs/2026-06-04-camera-access-crash-regression-chrome-148.md
+*   - https://github.com/mrdoob/three.js/issues/33404
+*   - https://issues.chromium.org/issues/507508099 (root-cause, marked Fixed)
+*
+* There is NOT a single crash here — the Chromium tracker notes the crash on
+* Chrome 147 is different from the crash on 148+, and the simple workaround
+* below only helped on a subset of versions. The empirically-verified
+* (on-device) timeline is:
+*
+*   - 147 : deleting `createProjectionLayer` / `layers` forces three.js onto
+*       `XRWebGLLayer` and sidesteps the crash (deletes-only is sufficient).
+*   - 148.0.7778.12 .. 149.0.7821 : the delete-only trick is NOT sufficient on
+*       its own. An ADDITIONAL patch is needed: persist the `baseLayer`
+*       reference across `XRSession.prototype.updateRenderState` so three.js's
+*       later `depthNear`/`depthFar` update does not drop the active
+*       `glBaseLayer`. (Confirmed on-device on `148.0.7778.215`: BOTH the
+*       deletes and the baseLayer patch are required for the page not to
+*       crash. Earlier 148 builds (`< .7778.12`) are below the window per the
+*       tracker, which reported delete-only worked there.)
+*   - > 149.0.7821 (incl. Chrome 150) : the delete-only path is STILL required
+*       (confirmed on-device: Chrome 150 only stops crashing when the deletes
+*       are applied), but the extra baseLayer-persistence patch is NOT needed.
+*       The earlier assumption that Chromium fully fixed this on patched
+*       builds did not hold on real devices, so we no longer skip the
+*       workaround on "patched" Chrome.
+*
+* Resulting policy (see {@link applyChromiumProjectionLayerWorkaround}):
+*   - ALWAYS apply the deletes (every Chrome build, and unknown/non-Chromium
+*     environments — restoring the original always-on behavior).
+*   - Apply the baseLayer-persistence patch ONLY when a detected Chrome build
+*     falls inside the affected window
+*     [{@link BASELAYER_WINDOW_MIN} .. {@link BASELAYER_WINDOW_MAX}].
+*
+* Caveats:
+* - This is a Chromium-specific hack and the upstream comment explicitly
+*   warns it "might break webxr on other devices" — keep it opt-in.
+* - Must run BEFORE any WebXR session setup. Three.js reads these prototype
+*   members lazily when the first session starts, so calling this at app
+*   bootstrap (before `initAR()`) is sufficient.
+* - Idempotent: safe to call repeatedly. Safe on environments where the
+*   prototypes do not exist (e.g. desktop browsers, jsdom).
+*/
+const log = createLogger("chromium-camera-access");
+/** Marker set on our patched `updateRenderState` so we never double-wrap it. */
+const BASE_LAYER_PATCH_MARKER = "__gpsBaseLayerPersistencePatch";
+/**
+* Inclusive lower bound of the Chrome window that additionally needs the
+* `baseLayer`-persistence patch (on top of the deletes).
+*
+* Set to `148.0.7778.12`, the issue tracker's figure for when the delete-only
+* trick stopped being sufficient. On-device confirmation: `148.0.7778.215`
+* (well inside this window) crashes with deletes-only and needs BOTH patches.
+* Earlier 148 builds (`< .7778.12`) and all of Chrome 147 stay below this
+* bound (deletes-only) per the documented timeline — we have no on-device
+* evidence that they need the baseLayer patch, so we do not apply it there.
+*/
+const BASELAYER_WINDOW_MIN = [
+	148,
+	0,
+	7778,
+	12
+];
+/**
+* Inclusive upper bound of the Chrome window that additionally needs the
+* `baseLayer`-persistence patch. The crash is fixed after `149.0.7819.0` and
+* the camera image is correctly populated after `149.0.7821.0`; above this
+* build the extra patch is no longer required (the deletes still are — see
+* the module header and the on-device matrix for Chrome 150).
+*
+* @see https://github.com/mrdoob/three.js/issues/33404
+*/
+const BASELAYER_WINDOW_MAX = [
+	149,
+	0,
+	7821,
+	0
+];
+/**
+* Parse a Chrome/Chromium version from a user-agent string.
+*
+* Matches the `Chrome/<major>.<minor>.<build>.<patch>` token (and the iOS
+* `CriOS/...` variant). Returns null for non-Chromium user agents.
+*/
+function parseChromeVersion(userAgent) {
+	const match = /(?:Chrome|CriOS)\/(\d+)\.(\d+)\.(\d+)\.(\d+)/.exec(userAgent);
+	if (!match) return null;
+	return [
+		Number(match[1]),
+		Number(match[2]),
+		Number(match[3]),
+		Number(match[4])
+	];
+}
+/** Lexicographically compare two version tuples: returns true if `a` > `b`. */
+function isVersionAfter(a, b) {
+	for (let i = 0; i < a.length; i++) {
+		const av = a[i] ?? 0;
+		const bv = b[i] ?? 0;
+		if (av !== bv) return av > bv;
+	}
+	return false;
+}
+/** True if `a` >= `b` (lexicographic). */
+function isVersionAtLeast(a, b) {
+	return !isVersionAfter(b, a);
+}
+/**
+* True when the detected Chrome build falls inside the affected window
+* [{@link BASELAYER_WINDOW_MIN} .. {@link BASELAYER_WINDOW_MAX}] (inclusive)
+* and therefore additionally needs the `baseLayer`-persistence patch. Outside
+* the window (including non-Chromium user agents) returns false — only the
+* deletes are needed there.
+*/
+function needsBaseLayerPersistence(userAgent) {
+	const version = parseChromeVersion(userAgent);
+	if (version === null) return false;
+	return isVersionAtLeast(version, BASELAYER_WINDOW_MIN) && isVersionAtLeast(BASELAYER_WINDOW_MAX, version);
+}
+function getUserAgent() {
+	return globalThis.navigator?.userAgent ?? "";
+}
+/**
+* Wrap `XRSession.prototype.updateRenderState` so the `baseLayer` reference is
+* persisted across calls. Three.js calls `updateRenderState({ depthNear,
+* depthFar })` after the base layer was set; on affected Chrome builds that
+* second call drops the active `glBaseLayer`, which leads to the crash on
+* camera-texture access. Re-supplying the last-seen `baseLayer` keeps it
+* alive.
+*
+* The last-seen `baseLayer` is tracked **per `XRSession` instance** via a
+* `WeakMap` keyed on the call's `this`. A single shared variable would leak a
+* previous session's `baseLayer` into a later session: an `XRWebGLLayer` is
+* bound to the session it was created for, so re-supplying a stale layer to a
+* different session throws `InvalidStateError`. Keying per session also lets
+* the entries be garbage-collected with their sessions.
+*
+* Idempotent: a marker on the wrapper prevents double-wrapping.
+*
+* @returns true if the prototype was wrapped on this call.
+*/
+function patchUpdateRenderStateForBaseLayerPersistence() {
+	const session = globalThis.XRSession;
+	const original = session?.prototype.updateRenderState;
+	if (!session || typeof original !== "function") return false;
+	if (original[BASE_LAYER_PATCH_MARKER]) return false;
+	const lastBaseLayerBySession = /* @__PURE__ */ new WeakMap();
+	const patched = function(rawInit) {
+		const init = typeof rawInit === "object" && rawInit !== null ? rawInit : {};
+		if (typeof this !== "object" || this === null) return original.call(this, init);
+		if (init.baseLayer !== void 0) lastBaseLayerBySession.set(this, init.baseLayer);
+		const remembered = lastBaseLayerBySession.get(this);
+		return original.call(this, remembered !== void 0 ? {
+			...init,
+			baseLayer: remembered
+		} : init);
+	};
+	patched[BASE_LAYER_PATCH_MARKER] = true;
+	session.prototype.updateRenderState = patched;
+	return true;
+}
+/**
 * 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.
+* Policy (derived from on-device testing — see the module header):
+*
+*  - ALWAYS removes `XRWebGLBinding.prototype.createProjectionLayer`
+*    (three.js r184) and `XRRenderState.prototype.layers` (three.js r158) so
+*    three.js falls back to `XRWebGLLayer`. This is required on every affected
+*    Chrome build observed so far, including Chrome 150, and is also applied
+*    on unknown/non-Chromium environments (restoring the original always-on
+*    behavior).
+*  - ADDITIONALLY persists the `baseLayer` across
+*    `XRSession.prototype.updateRenderState`, but ONLY when a detected Chrome
+*    build falls inside the affected window
+*    [{@link BASELAYER_WINDOW_MIN} .. {@link BASELAYER_WINDOW_MAX}]. Outside
+*    that window the extra patch is unnecessary (and is skipped on unknown
+*    environments to avoid touching projection-layer devices like Quest).
 *
 * Call once during bootstrap, before any `requestSession()` call.
 *
-* @returns which prototype members were actually deleted on this call.
+* @param options.userAgent override the detected user agent (for testing).
+* @returns which prototype members were actually changed on this call.
 */
-function applyChromiumProjectionLayerWorkaround() {
+function applyChromiumProjectionLayerWorkaround(options) {
+	const userAgent = options?.userAgent ?? getUserAgent();
+	const version = parseChromeVersion(userAgent);
 	const result = {
 		deletedCreateProjectionLayer: false,
-		deletedRenderStateLayers: false
+		deletedRenderStateLayers: false,
+		patchedUpdateRenderState: false,
+		detectedChromeVersion: version ? version.join(".") : null
 	};
 	const binding = globalThis.XRWebGLBinding;
 	if (binding && "createProjectionLayer" in binding.prototype) {
@@ -26,7 +213,9 @@ function applyChromiumProjectionLayerWorkaround() {
 		delete renderState.prototype.layers;
 		result.deletedRenderStateLayers = true;
 	}
+	if (needsBaseLayerPersistence(userAgent)) result.patchedUpdateRenderState = patchUpdateRenderStateForBaseLayerPersistence();
+	log.info("applied workaround", result);
 	return result;
 }
 //#endregion
-export { applyChromiumProjectionLayerWorkaround };
+export { BASELAYER_WINDOW_MAX, BASELAYER_WINDOW_MIN, applyChromiumProjectionLayerWorkaround, needsBaseLayerPersistence, parseChromeVersion };

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

@@ -1,3 +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";
+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 };

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-DNbO0zbg.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 { endARSession, initAR, isWebXRSupported } from "./webxr-session.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

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

package/dist/ar/frame-loop.js

@@ -0,0 +1,63 @@
+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.
+*
+* Registration is idempotent — calling with the same `fn` twice is a no-op
+* (it remains a single entry in the underlying `Set`).
+*/
+function registerFrameUpdate(fn) {
+	updates.add(fn);
+	return () => {
+		updates.delete(fn);
+	};
+}
+/**
+* Invoke all registered callbacks. Called by the WebXR session's
+* `onXRFrame` once per frame with the XR-derived `dt` (seconds since the
+* previous frame; 0 on the first frame after a reset) and `elapsed`
+* (seconds since the session started).
+*
+* The set is snapshotted before iterating so that
+* `registerFrameUpdate` / unregister calls made by a handler during the
+* 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) 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
+* session starts with an empty registry (any callbacks from the previous
+* session are dropped along with their owning components).
+*/
+function clearFrameUpdates() {
+	updates.clear();
+}
+//#endregion
+export { 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-2pKjYUS6.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";
 export { CapturedImage, DEFAULT_CAPTURE_CONFIG, ImageCaptureCallbacks, ImageCaptureConfig, ImageCaptureManager, MIN_VALID_IMAGE_BYTES };

package/dist/ar/image-capture.js

@@ -92,7 +92,7 @@ var ImageCaptureManager = class {
 		if (!pose) return;
 		this.captureInProgress = true;
 		this.lastCaptureTime = time;
-		const timestamp = Date.now();
+		const timestamp = performance.timeOrigin + time;
 		const screenRotation = this.callbacks.getScreenRotation();
 		const frameIndex = ++this.frameCount;
 		this.captureTimeoutId = setTimeout(() => {

package/dist/ar/index.d.ts

@@ -1,12 +1,16 @@
-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 };
+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 };

package/dist/ar/index.js

@@ -1,12 +1,16 @@
 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 { 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 { 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 { 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 { 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 };
+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 };

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

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

package/dist/ar/scene-node-names.d.ts

@@ -1,2 +1,2 @@
-import { t as SCENE_NODE } from "../scene-node-names-DPsaE2z3.js";
+import { t as SCENE_NODE } from "../scene-node-names-IHW7HR4S.js";
 export { SCENE_NODE };