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

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-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 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 { 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 { 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 { 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 { 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, 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, 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-DpAGcAKY.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-6LBjPmwz.js";
+import { t as SCENE_NODE } from "../scene-node-names-IHW7HR4S.js";
 export { SCENE_NODE };

package/dist/ar/webxr-session.d.ts

@@ -1,4 +1,4 @@
-import { i as DepthSample, t as ARPose } from "../ar-types-Ck8LEq8k.js";
-import { t as CapturedImage } from "../image-capture-DZLxHDN9.js";
-import { A as setTrackingCallbacks, C as setArPose, D as setFrameCallback, E as setDepthCaptureCallback, F as startDepthCapture, I as startImageCapture, L as stopDepthCapture, M as setTrackingRecoveredCallback, N as setTrackingStore, O as setImageCaptureCallback, P as shouldLogCameraAccessDiagnostic, R as stopImageCapture, S as resetWebXRState, T as setCamera, _ as initAR, a as endARSession, b as nuePositionToWebXR, c as getArPose, d as getCurrentArPose, f as getDepthSampleCount, g as getXrCameraFromPose, h as getScene, i as createSceneHierarchy, j as setTrackingLostCallback, k as setScene, l as getArWorldGroup, m as getLiveCss3dManager, n as applyAlignmentMatrix, o as extractPoseFromViewer, p as getImageCaptureFrameCount, r as buildSessionOptions, s as extractResetTransformData, t as TrackingSubscribableStore, u as getCamera, v as isWebXRSupported, w as setArWorldGroup, x as nueQuaternionToWebXR, y as isXRCameraLike } from "../webxr-session-DB5cIZnN.js";
-export { ARPose, CapturedImage, DepthSample, TrackingSubscribableStore, applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture };
+import { i as DepthSample, t as ARPose } from "../ar-types-isPsQptb.js";
+import { t as CapturedImage } from "../image-capture-BXZUmj7j.js";
+import { A as setScene, C as resetWebXRState, D as setDepthCaptureCallback, E as setCamera, F as shouldLogCameraAccessDiagnostic, I as startDepthCapture, L as startImageCapture, M as setTrackingLostCallback, N as setTrackingRecoveredCallback, O as setFrameCallback, P as setTrackingStore, R as stopDepthCapture, S as nueQuaternionToWebXR, T as setArWorldGroup, _ as getXrCameraFromPose, a as createSceneHierarchy, b as isXRCameraLike, c as extractResetTransformData, d as getCamera, f as getCurrentArPose, g as getScene, h as getLiveCss3dManager, i as buildSessionOptions, j as setTrackingCallbacks, k as setImageCaptureCallback, l as getArPose, m as getImageCaptureFrameCount, n as TrackingSubscribableStore, o as endARSession, p as getDepthSampleCount, r as applyAlignmentMatrix, s as extractPoseFromViewer, t as SessionFeatureOptions, u as getArWorldGroup, v as initAR, w as setArPose, x as nuePositionToWebXR, y as isWebXRSupported, z as stopImageCapture } from "../webxr-session-BnArFCew.js";
+export { ARPose, CapturedImage, DepthSample, SessionFeatureOptions, TrackingSubscribableStore, applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture };

package/dist/ar/webxr-session.js

@@ -3,9 +3,12 @@ import { CameraBlitCapture, computeCaptureSize } from "./camera-blit-capture.js"
 import { getLastDeviceOrientation } from "../state/gps-event-coordinator.js";
 import { DepthSampler } from "./depth-sampler.js";
 import { clearFrameUpdates, runFrameUpdates } from "./frame-loop.js";
+import { clearXrFrameUpdates, runXrFrameUpdates } from "./xr-frame-loop.js";
+import { t as WEBXR_TO_NUE } from "../webxr-nue-basis-BbdqhqY6.js";
 import { DEFAULT_CAPTURE_CONFIG, ImageCaptureManager } from "./image-capture.js";
 import { clearLastRestartedPayload, originReset, poseLost, poseReceived, resetTracking, selectLastRestartedPayload, selectTrackingPhase } from "../state/tracking-slice.js";
 import { acquireCameraTexture } from "./xr-camera-texture.js";
+import { n as runSessionDisposers } from "../session-disposers-M-oashRH.js";
 import { DEFAULT_RECORDING_OPTIONS, validateArCrashIsolationOptions } from "../state/recording-options.js";
 import { SCENE_NODE } from "./scene-node-names.js";
 import { createCss3dRendererManager } from "../visualization/css3d-renderer-manager.js";
@@ -110,6 +113,8 @@ function resetWebXRState() {
 	latestArPose = null;
 	lastFrameTime = 0;
 	clearFrameUpdates();
+	clearXrFrameUpdates();
+	runSessionDisposers();
 	imageCaptureManager = null;
 	onImageCaptured = null;
 	getScreenRotation = null;
@@ -350,10 +355,14 @@ function getCurrentArPose() {
 * Extracted as a pure function for testability.
 *
 * @param rootElement - The DOM element for DOM overlay
+* @param isolationOptions - Crash-isolation diagnostic flags (DOM overlay,
+*   depth-sensing, camera-access)
+* @param sessionFeatures - Opt-in standard WebXR features that are independent
+*   of crash isolation (currently `requestHitTest`)
 * @returns XRSessionInit options
 * @throws Error if rootElement is null
 */
-function buildSessionOptions(rootElement, isolationOptions = {}) {
+function buildSessionOptions(rootElement, isolationOptions = {}, sessionFeatures = {}) {
 	if (!rootElement) throw new Error("App root element not found");
 	const normalizedOptions = validateArCrashIsolationOptions(isolationOptions);
 	const optionalFeatures = [];
@@ -370,6 +379,7 @@ function buildSessionOptions(rootElement, isolationOptions = {}) {
 		} });
 	}
 	if (normalizedOptions.enableCameraAccess) optionalFeatures.push("camera-access");
+	if (sessionFeatures.requestHitTest) optionalFeatures.push("hit-test");
 	if (optionalFeatures.length > 0) sessionOptions.optionalFeatures = optionalFeatures;
 	return sessionOptions;
 }
@@ -449,8 +459,11 @@ function createSceneHierarchy() {
 /**
 * Initialize the AR session and Three.js renderer.
 * @param container - DOM element to host the AR canvas and CSS3D overlay.
+* @param isolationOptions - Crash-isolation diagnostic flags.
+* @param sessionFeatures - Opt-in standard WebXR features (e.g.
+*   `requestHitTest`) forwarded to the session negotiation.
 */
-async function initAR(container, isolationOptions = {}) {
+async function initAR(container, isolationOptions = {}, sessionFeatures = {}) {
 	if (!navigator.xr) throw new Error("WebXR not available");
 	if (renderer || xrSession) throw new Error("AR session already initialized — call endARSession() before initAR() again");
 	currentArCrashIsolationOptions = validateArCrashIsolationOptions(isolationOptions);
@@ -468,7 +481,7 @@ async function initAR(container, isolationOptions = {}) {
 	arWorldGroup = hierarchy.arWorldGroup;
 	arPoseNode = hierarchy.arpose;
 	camera = hierarchy.camera;
-	const sessionOptions = buildSessionOptions(container, currentArCrashIsolationOptions);
+	const sessionOptions = buildSessionOptions(container, currentArCrashIsolationOptions, sessionFeatures);
 	xrSession = await navigator.xr.requestSession("immersive-ar", sessionOptions);
 	xrSession.addEventListener("end", () => {
 		log.info("Session ended");
@@ -578,6 +591,13 @@ function onXRFrame(time, frame) {
 	const elapsed = time / 1e3;
 	lastFrameTime = time;
 	runFrameUpdates(dt, elapsed);
+	if (xrSession) runXrFrameUpdates({
+		frame,
+		referenceSpace,
+		session: xrSession,
+		dt,
+		elapsed
+	});
 	if (arPose) latestArPose = arPose;
 	latestCameraTexture = null;
 	if (currentArCrashIsolationOptions.enableCameraTextureAcquisition) {
@@ -688,41 +708,6 @@ function setArPose(a) {
 	arPoseNode = a;
 }
 /**
-* Constant matrix converting WebXR local-floor coordinates to the internal
-* NUE (North-Up-East) convention.
-*
-* WebXR: X=East, Y=Up, Z=South (right-handed, toward viewer)
-* NUE:   X=North, Y=Up, Z=East (right-handed)
-*
-* Mapping:  NUE_X = -WebXR_Z,  NUE_Y = WebXR_Y,  NUE_Z = WebXR_X
-*
-* Row-major:
-*   [ 0  0 -1  0 ]
-*   [ 0  1  0  0 ]
-*   [ 1  0  0  0 ]
-*   [ 0  0  0  1 ]
-*
-* Stored column-major (Three.js / gl-matrix convention).
-*/
-const WEBXR_TO_NUE = new THREE.Matrix4().fromArray([
-	0,
-	0,
-	1,
-	0,
-	0,
-	1,
-	0,
-	0,
-	-1,
-	0,
-	0,
-	0,
-	0,
-	0,
-	0,
-	1
-]);
-/**
 * Apply an alignment matrix to the AR world group.
 *
 * The alignment matrix maps odometry positions in NUE space

package/dist/ar/xr-error-handler.d.ts

@@ -1,2 +1,2 @@
-import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "../xr-error-handler-CDY5QxGb.js";
+import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "../xr-error-handler-DcUFshNF.js";
 export { XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, getXrErrorMessage };

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

@@ -0,0 +1,2 @@
+import { a as runXrFrameUpdates, i as registerXrFrameUpdate, n as XrFrameUpdate, r as clearXrFrameUpdates, t as XrFrameContext } from "../xr-frame-loop-BKckC7xC.js";
+export { XrFrameContext, XrFrameUpdate, clearXrFrameUpdates, registerXrFrameUpdate, runXrFrameUpdates };

package/dist/ar/xr-frame-loop.js

@@ -0,0 +1,69 @@
+import { createLogger } from "../utils/logger.js";
+//#region ../src/ar/xr-frame-loop.ts
+/**
+* Per-frame **XR-access** callback registry — the safe seam that lets app
+* code run standard WebXR work (hit-test, light estimation, depth, the WebXR
+* Anchors API, …) without the framework wrapping each capability.
+*
+* The framework owns the single `renderer.setAnimationLoop(onXRFrame)` hook,
+* and the live `XRFrame` never leaves `onXRFrame`. The plain `FrameUpdate`
+* registry (`frame-loop.ts`) only passes `(dt, elapsed)`, which is enough for
+* pose-free ticks but cannot drive hit-test. This registry additionally hands
+* the callback the live `frame`, `referenceSpace`, and `session`.
+*
+* SAFETY CONTRACT (non-negotiable): `frame` / `referenceSpace` / `session` are
+* valid **only synchronously inside the callback**. The `XRFrame` is
+* use-after-frame-unsafe — storing it and reading it on a later tick throws or
+* crashes. Passing them as arguments (never a stashable `getXrFrame()` getter)
+* makes correct use the easy path and stashing the awkward one. Do NOT retain
+* `ctx` or its fields beyond the callback's synchronous execution.
+*
+* See `2026-06-03-threejs-arbutton-minimal-ar-example-user-feedback.md`
+* §6.2/§6.3 (option H-A2) for the design rationale.
+*/
+const log = createLogger("XrFrameLoop");
+const updates = /* @__PURE__ */ new Set();
+/**
+* Register a per-frame XR-access callback. Returns an unregister function.
+*
+* Registration is idempotent — registering the same `fn` twice is a no-op
+* (it remains a single entry in the underlying `Set`).
+*/
+function registerXrFrameUpdate(fn) {
+	updates.add(fn);
+	return () => {
+		updates.delete(fn);
+	};
+}
+/**
+* Invoke all registered XR-access callbacks. Called by the WebXR session's
+* `onXRFrame` once per frame, only when a live `frame` / `referenceSpace` /
+* `session` are all available.
+*
+* The set is snapshotted before iterating so that
+* `registerXrFrameUpdate` / unregister calls made by a handler during the
+* same frame are deferred to the next tick — mirroring `runFrameUpdates`.
+*
+* Each callback is invoked in its own `try/catch`: this registry is the public
+* app seam, so a bug in one app-registered callback (which throws every frame)
+* must not abort the remaining callbacks nor propagate up through `onXRFrame`
+* and kill the scene render for the whole session. Failures are logged and the
+* loop continues — mirroring `runFrameUpdates`.
+*/
+function runXrFrameUpdates(ctx) {
+	const snapshot = Array.from(updates);
+	for (const fn of snapshot) try {
+		fn(ctx);
+	} catch (error) {
+		log.error("A registered XrFrameUpdate threw; continuing the loop", error);
+	}
+}
+/**
+* Clear all registrations. Called from `resetWebXRState()` so a fresh
+* session starts with an empty registry.
+*/
+function clearXrFrameUpdates() {
+	updates.clear();
+}
+//#endregion
+export { clearXrFrameUpdates, registerXrFrameUpdate, runXrFrameUpdates };

package/dist/ar-world-group-alignment-Dn4rQk_c.d.ts

@@ -0,0 +1,43 @@
+import { t as SubscribableStore } from "./subscribe-to-selector--KQpgLXG.js";
+import * as THREE from "three";
+
+//#region ../src/visualization/ar-world-group-alignment.d.ts
+interface ArWorldGroupAlignmentOptions {
+  /** The store whose alignment selector drives the lerper. */
+  readonly store: SubscribableStore;
+  /** The AR world group whose `.matrix` is lerped toward each alignment. */
+  readonly arWorldGroup: THREE.Object3D;
+  /**
+   * Lerp speed multiplier forwarded to {@link createAlignmentLerper}
+   * (default matches the lerper's own `DEFAULT_LERP_RATE`).
+   */
+  readonly lerpRate?: number;
+}
+interface ArWorldGroupAlignmentHandle {
+  /** Stop the subscription and the per-frame update. */
+  dispose(): void;
+}
+/**
+ * Begin applying the store's (lerped) alignment to `arWorldGroup`. Returns a
+ * handle whose `dispose()` removes both the store subscription and the
+ * per-frame update.
+ *
+ * Disposal is tied to the AR session lifecycle: the binding registers itself
+ * with the session-disposer registry that `resetWebXRState()` flushes on
+ * teardown, so a caller can `enableArWorldGroupAlignment(...)` once and never
+ * hold the handle — the binding cannot outlive the session (which is what two
+ * apps independently leaked: the store subscription survives a teardown because
+ * `clearFrameUpdates` only drops the per-frame tick). Because `initAR()` throws
+ * while a prior session is live, every restart passes through that flush. The
+ * handle is still returned for callers that want to stop alignment mid-session,
+ * and is idempotent + self-deregistering so a manual `dispose()` and the
+ * teardown flush never double-run. See
+ * gps-plus-slam/GpsPlusSlamJs_Docs/docs/2026-06-08-arworldgroup-alignment-session-scoped-disposal.md.
+ *
+ * Double-drive is still the caller's concern: the recorder owns its own lerper
+ * and must NOT also call this (it would double-lerp the same group). It does not
+ * call this helper, so flushing the registry on teardown never affects it.
+ */
+declare function enableArWorldGroupAlignment(options: ArWorldGroupAlignmentOptions): ArWorldGroupAlignmentHandle;
+//#endregion
+export { ArWorldGroupAlignmentOptions as n, enableArWorldGroupAlignment as r, ArWorldGroupAlignmentHandle as t };

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

@@ -0,0 +1,43 @@
+//#region ../src/ar/capability-checker.d.ts
+/**
+ * Pure capability-gating helpers, promoted from the AnchorStarter app so the
+ * minimal AR example and AnchorStarter share the *decision* and *message*
+ * without sharing app-specific copy.
+ *
+ * The async feature probing (`isWebXRSupported()` / geolocation availability)
+ * stays in each app's `main.ts`; only the browser-free decision and the
+ * user-facing message live here so they can be unit-tested without a browser.
+ *
+ * See `2026-06-03-threejs-arbutton-minimal-ar-example-user-feedback.md` §6.4.
+ */
+/** The two capabilities every GPS+AR demo requires to run. */
+interface CapabilitySupport {
+  /** Browser supports a WebXR `immersive-ar` session. */
+  readonly webxr: boolean;
+  /** Geolocation API is available. */
+  readonly geolocation: boolean;
+}
+/** Options that let an app flavour the otherwise-neutral gating message. */
+interface CapabilityMessageOptions {
+  /**
+   * App-specific "what this demo lets you do" phrase, appended as
+   * `…outdoors, to try ${contextLabel}.`. Omit for a neutral message that
+   * ends at `…outdoors.`. Example: `'the persistent-anchor flow'`.
+   */
+  readonly contextLabel?: string;
+}
+/** True only when both AR and GPS are available — the demo can run. */
+declare function isFullySupported(support: CapabilitySupport): boolean;
+/**
+ * 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.".
+ */
+declare function capabilityMessage(support: CapabilitySupport, options?: CapabilityMessageOptions): string | null;
+//#endregion
+export { isFullySupported as i, CapabilitySupport as n, capabilityMessage as r, CapabilityMessageOptions as t };

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

@@ -0,0 +1,137 @@
+//#region ../src/ar/chromium-camera-access-workaround.d.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).
+ */
+/**
+ * Parsed Chrome version as `[major, minor, build, patch]`.
+ */
+type ChromeVersion = [number, number, number, number];
+/**
+ * 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.
+ */
+declare const BASELAYER_WINDOW_MIN: ChromeVersion;
+/**
+ * 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
+ */
+declare const BASELAYER_WINDOW_MAX: ChromeVersion;
+/**
+ * Result of {@link applyChromiumProjectionLayerWorkaround}.
+ * Useful for logging and tests.
+ */
+interface ChromiumProjectionLayerWorkaroundResult {
+  /** True if `XRWebGLBinding.prototype.createProjectionLayer` was deleted on this call. */
+  deletedCreateProjectionLayer: boolean;
+  /** True if `XRRenderState.prototype.layers` was deleted on this call. */
+  deletedRenderStateLayers: boolean;
+  /** True if `XRSession.prototype.updateRenderState` was wrapped on this call. */
+  patchedUpdateRenderState: boolean;
+  /** The detected Chrome version (`"major.minor.build.patch"`), or null. */
+  detectedChromeVersion: string | null;
+}
+/**
+ * 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.
+ */
+declare function parseChromeVersion(userAgent: string): ChromeVersion | null;
+/**
+ * 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.
+ */
+declare function needsBaseLayerPersistence(userAgent: string): boolean;
+/**
+ * Apply the Chromium camera-access tab-crash workaround.
+ *
+ * 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.
+ *
+ * @param options.userAgent override the detected user agent (for testing).
+ * @returns which prototype members were actually changed on this call.
+ */
+declare function applyChromiumProjectionLayerWorkaround(options?: {
+  userAgent?: string;
+}): ChromiumProjectionLayerWorkaroundResult;
+//#endregion
+export { applyChromiumProjectionLayerWorkaround as a, ChromiumProjectionLayerWorkaroundResult as i, BASELAYER_WINDOW_MIN as n, needsBaseLayerPersistence as o, ChromeVersion as r, parseChromeVersion as s, BASELAYER_WINDOW_MAX as t };

package/dist/core/index.d.ts

@@ -1,2 +1,2 @@
-import { a as LibraryRootState, c as RootState, d as calcRelativeCoordsInMeters, f as createGpsSlamStore, g as webxrToNUE, h as validateLicenseKey, i as LatLongAlt, l as Vector3, m as odometryTrackingRestarted, n as GpsPoint, o as Matrix4, p as isIdentityMatrix4, r as LatLong, s as Quaternion, t as ArImageCapture, u as calcGpsCoords } from "../index-gzWJMVpo.js";
+import { a as LibraryRootState, c as RootState, d as calcRelativeCoordsInMeters, f as createGpsSlamStore, g as webxrToNUE, h as validateLicenseKey, i as LatLongAlt, l as Vector3, m as odometryTrackingRestarted, n as GpsPoint, o as Matrix4, p as isIdentityMatrix4, r as LatLong, s as Quaternion, t as ArImageCapture, u as calcGpsCoords } from "../index--ldLph4V.js";
 export { ArImageCapture, GpsPoint, LatLong, LatLongAlt, LibraryRootState, Matrix4, Quaternion, RootState, Vector3, calcGpsCoords, calcRelativeCoordsInMeters, createGpsSlamStore, isIdentityMatrix4, odometryTrackingRestarted, validateLicenseKey, webxrToNUE };

package/dist/{create-slam-app-store-CNsZ3rcX.d.ts → create-slam-app-store-B76AGaI0.d.ts}

@@ -1,8 +1,8 @@
-import { t as ARPose } from "./ar-types-Ck8LEq8k.js";
-import { a as TrackingSliceState, t as DeviceOrientation } from "./tracking-slice-utCNND8t.js";
-import { t as RecordingState } from "./recording-slice-d6OtCrza.js";
-import { n as SessionMetadata } from "./opfs-storage-DOPkzgeT.js";
-import { n as StorageBackend } from "./storage-backend-CT0Il_AB.js";
+import { t as ARPose } from "./ar-types-isPsQptb.js";
+import { a as TrackingSliceState, t as DeviceOrientation } from "./tracking-slice-CDREeoZ_.js";
+import { t as RecordingState } from "./recording-slice-Cb888P6d.js";
+import { n as SessionMetadata } from "./opfs-storage-LsLY6VZV.js";
+import { n as StorageBackend } from "./storage-backend-yDSKafAQ.js";
 import { GpsPoint, LatLong, Matrix4, RootState, Vector3 } from "gps-plus-slam-js";
 import * as _$_reduxjs_toolkit0 from "@reduxjs/toolkit";
 import { Middleware, Reducer, ReducersMapObject, configureStore } from "@reduxjs/toolkit";

package/dist/{depth-sampler-xg8vna6c.d.ts → depth-sampler-CqrkRr2N.d.ts}

@@ -1,4 +1,4 @@
-import { i as DepthSample, t as ARPose } from "./ar-types-Ck8LEq8k.js";
+import { i as DepthSample, t as ARPose } from "./ar-types-isPsQptb.js";
 
 //#region ../src/ar/depth-sampler.d.ts
 /**