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

package/dist/visualization/map-data.js

@@ -0,0 +1,33 @@
+import { computeFusedPath } from "../utils/fused-path.js";
+//#region ../src/visualization/map-data.ts
+/**
+* Build a {@link MapData} snapshot from store-derived inputs.
+*
+* Pure and free of Leaflet/Three dependencies. The fused path is always
+* derived via {@link computeFusedPath} (D2); when the matrix or zero reference
+* is missing it is an empty array.
+*
+* @param input - Optional trajectory slices (see {@link MapDataInput}).
+* @returns A fully-resolved {@link MapData} with all arrays defensively copied.
+*/
+function buildMapData(input) {
+	const rawGpsPath = input.rawGpsPath ? [...input.rawGpsPath] : [];
+	const alignmentSnapshots = input.alignmentSnapshots ? [...input.alignmentSnapshots] : [];
+	const fusedPath = computeFusedPath({
+		odometryPositions: input.odometryPositions ?? [],
+		alignmentMatrix: input.alignmentMatrix ?? null,
+		zeroRef: input.zeroRef ?? null
+	});
+	const lastRaw = rawGpsPath[rawGpsPath.length - 1];
+	return {
+		userPosition: input.userPosition !== void 0 ? input.userPosition : lastRaw ? {
+			lat: lastRaw.lat,
+			lng: lastRaw.lng
+		} : null,
+		rawGpsPath,
+		fusedPath,
+		alignmentSnapshots
+	};
+}
+//#endregion
+export { buildMapData };

package/dist/visualization/map-overlay-draw.d.ts

@@ -0,0 +1,2 @@
+import { a as MAP_PATH_POLYLINE_OPACITY, c as USER_POSITION_COLOR, i as FUSED_PATH_COLOR, l as drawMapData, n as DrawMapDataOptions, o as MAP_PATH_POLYLINE_WEIGHT, r as DrawnMapData, s as RAW_GPS_COLOR, t as ALIGNMENT_SNAPSHOT_COLOR } from "../map-overlay-draw-DcGs9UV3.js";
+export { ALIGNMENT_SNAPSHOT_COLOR, DrawMapDataOptions, DrawnMapData, FUSED_PATH_COLOR, MAP_PATH_POLYLINE_OPACITY, MAP_PATH_POLYLINE_WEIGHT, RAW_GPS_COLOR, USER_POSITION_COLOR, drawMapData };

package/dist/visualization/map-overlay-draw.js

@@ -0,0 +1,107 @@
+import { VIS_COLORS } from "./vis-colors.js";
+import { addAccuracyCircles } from "./accuracy-circles.js";
+import L from "leaflet";
+//#region ../src/visualization/map-overlay-draw.ts
+/**
+* Shared map-overlay-drawing module.
+*
+* `drawMapData` is the SINGLE Leaflet drawing routine rendered by BOTH map
+* consumers — the live/replay 3D overlay (`LeafletMapOverlay`) and the 2D
+* session-summary map (`createSummaryMap`). Centralising the drawing here is
+* Phase 3 of the map-system review and the fix for Findings 1 & 4 of the
+* unified-trajectory-map user feedback: previously each renderer drew the
+* trajectory by hand and the two visibly diverged.
+*
+* It consumes the resolved {@link MapData} produced by `buildMapData` and adds,
+* in this order:
+*   1. per-event accuracy circles for the raw GPS path (drawn first so the
+*      polyline stays on top), then the raw GPS polyline;
+*   2. the fused (SLAM+GPS) polyline;
+*   3. the alignment-snapshot polyline;
+*   4. (optional) a user-position marker.
+*
+* SCOPE: this module draws only the genuinely-shared SLAM/GPS trajectory
+* layers. Reference-point markers are a RECORDER concept and are drawn by the
+* recorder-owned `ui/draw-ref-point-markers.ts` helper (called from both the
+* summary map and the live overlay wiring), so the two maps stay identical
+* while the framework remains ref-point-agnostic. See
+* gps-plus-slam/GpsPlusSlamJs_Docs/docs/2026-05-31-unified-trajectory-map-phase3-plan.md
+* § Step 5.
+*
+* The caller owns map creation, tile layer, `fitBounds`, resize handling and
+* fullscreen — this module only draws data layers and reports the accumulated
+* bounds so the caller can frame the view.
+*/
+/** Raw GPS polyline + accuracy-circle color (yellow). */
+const RAW_GPS_COLOR = VIS_COLORS.RAW_GPS.css;
+/** Fused SLAM+GPS polyline color (cyan). */
+const FUSED_PATH_COLOR = VIS_COLORS.FUSED_VIO.css;
+/** Alignment-snapshot polyline color (red). */
+const ALIGNMENT_SNAPSHOT_COLOR = VIS_COLORS.ALIGNMENT_SNAPSHOT.css;
+/** User-position marker color (blue). */
+const USER_POSITION_COLOR = VIS_COLORS.USER_POSITION.css;
+/** Polyline weight (px) — matches the recorder's `PATH_POLYLINE_WEIGHT`. */
+const MAP_PATH_POLYLINE_WEIGHT = 3;
+/** Polyline opacity — matches the recorder's `PATH_POLYLINE_OPACITY`. */
+const MAP_PATH_POLYLINE_OPACITY = .8;
+/**
+* Draw a {@link MapData} snapshot onto an existing Leaflet map.
+*
+* @param map - Target map (already created with a tile layer by the caller).
+* @param data - Resolved trajectory data from `buildMapData`.
+* @param options - Optional layer toggles (see {@link DrawMapDataOptions}).
+* @returns The created layers and the bounds spanning every drawn coordinate.
+*/
+function drawMapData(map, data, options = {}) {
+	const layers = [];
+	const bounds = L.latLngBounds([]);
+	if (data.rawGpsPath.length > 0) {
+		const rawLatLngs = data.rawGpsPath.map((p) => [p.lat, p.lng]);
+		const circles = addAccuracyCircles(map, data.rawGpsPath, RAW_GPS_COLOR);
+		layers.push(...circles);
+		const rawPolyline = L.polyline(rawLatLngs, {
+			color: RAW_GPS_COLOR,
+			weight: 3,
+			opacity: MAP_PATH_POLYLINE_OPACITY
+		}).addTo(map);
+		layers.push(rawPolyline);
+		for (const ll of rawLatLngs) bounds.extend(ll);
+	}
+	if (data.fusedPath.length > 0) {
+		const fusedLatLngs = data.fusedPath.map((p) => [p.lat, p.lng]);
+		const fusedPolyline = L.polyline(fusedLatLngs, {
+			color: FUSED_PATH_COLOR,
+			weight: 3,
+			opacity: MAP_PATH_POLYLINE_OPACITY
+		}).addTo(map);
+		layers.push(fusedPolyline);
+		for (const ll of fusedLatLngs) bounds.extend(ll);
+	}
+	if (data.alignmentSnapshots.length > 0) {
+		const snapshotLatLngs = data.alignmentSnapshots.map((p) => [p.lat, p.lng]);
+		const snapshotPolyline = L.polyline(snapshotLatLngs, {
+			color: ALIGNMENT_SNAPSHOT_COLOR,
+			weight: 3,
+			opacity: MAP_PATH_POLYLINE_OPACITY
+		}).addTo(map);
+		layers.push(snapshotPolyline);
+		for (const ll of snapshotLatLngs) bounds.extend(ll);
+	}
+	if (options.showUserPosition && data.userPosition) {
+		const icon = L.divIcon({
+			className: "map-overlay-user-position",
+			html: `<div style="background:${USER_POSITION_COLOR};width:14px;height:14px;border-radius:50%;border:2px solid white;"></div>`,
+			iconSize: [18, 18],
+			iconAnchor: [9, 9]
+		});
+		const marker = L.marker([data.userPosition.lat, data.userPosition.lng], { icon }).addTo(map);
+		layers.push(marker);
+		bounds.extend([data.userPosition.lat, data.userPosition.lng]);
+	}
+	return {
+		layers,
+		bounds
+	};
+}
+//#endregion
+export { ALIGNMENT_SNAPSHOT_COLOR, FUSED_PATH_COLOR, MAP_PATH_POLYLINE_OPACITY, MAP_PATH_POLYLINE_WEIGHT, RAW_GPS_COLOR, USER_POSITION_COLOR, drawMapData };

package/dist/visualization/map-overlay.d.ts

@@ -1,2 +1,2 @@
-import { a as MapOverlayOptions, c as tileXYToLatLon, i as MapOverlay, n as DEFAULT_MAP_SIZE, o as TextureLoaderInterface, r as DEFAULT_ZOOM, s as latLonToTileXY, t as DEFAULT_HEIGHT_OFFSET } from "../map-overlay-C9ifl_4-.js";
+import { a as MapOverlayOptions, c as tileXYToLatLon, i as MapOverlay, n as DEFAULT_MAP_SIZE, o as TextureLoaderInterface, r as DEFAULT_ZOOM, s as latLonToTileXY, t as DEFAULT_HEIGHT_OFFSET } from "../map-overlay-yrFsUtGv.js";
 export { DEFAULT_HEIGHT_OFFSET, DEFAULT_MAP_SIZE, DEFAULT_ZOOM, MapOverlay, MapOverlayOptions, TextureLoaderInterface, latLonToTileXY, tileXYToLatLon };

package/dist/visualization/three-dispose.d.ts

@@ -1,2 +1,2 @@
-import { n as disposeMeshArray, r as disposeObject3D, t as DisposeOptions } from "../three-dispose-qt_r5wR1.js";
+import { n as disposeMeshArray, r as disposeObject3D, t as DisposeOptions } from "../three-dispose-WTBAfaWU.js";
 export { DisposeOptions, disposeMeshArray, disposeObject3D };

package/dist/visualization/vis-colors.d.ts

@@ -1,2 +1,2 @@
-import { t as VIS_COLORS } from "../vis-colors-BKkdTIKb.js";
+import { t as VIS_COLORS } from "../vis-colors-Djnyg_UH.js";
 export { VIS_COLORS };

package/dist/webxr-nue-basis-BbdqhqY6.js

@@ -0,0 +1,54 @@
+import { Matrix4 } from "three";
+//#region ../src/ar/webxr-nue-basis.ts
+/**
+* `webxr-nue-basis` — the single source of truth for the WebXR↔NUE basis
+* change.
+*
+* The framework's scene graph keeps GPS-world content in the **NUE**
+* convention (X=North, Y=Up, Z=East) while WebXR reports poses in its own
+* convention (X=East, Y=Up, Z=South). `WEBXR_TO_NUE` converts a transform
+* expressed in the WebXR reference space into the NUE frame.
+*
+* It lives in its own tiny module (depending only on three) so it can be shared
+* by both `webxr-session.ts` (which parents it permanently as the static
+* `basisChangeNode`) and `visualization/hit-test-reticle.ts` (which applies it
+* to the live hit-test pose) without either pulling the other's heavy
+* transitive dependencies into a unit-test import graph.
+*/
+/**
+* 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 = /* @__PURE__ */ new Matrix4().fromArray([
+	0,
+	0,
+	1,
+	0,
+	0,
+	1,
+	0,
+	0,
+	-1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1
+]);
+//#endregion
+export { WEBXR_TO_NUE as t };

package/dist/{webxr-session-COlSrXdL.d.ts → webxr-session-BnArFCew.d.ts}

@@ -1,13 +1,30 @@
-import { i as DepthSample, t as ARPose } from "./ar-types-B-ORgk6Z.js";
-import { i as ImageCaptureConfig, t as CapturedImage } from "./image-capture-2pKjYUS6.js";
-import { t as Css3dRendererManager } from "./css3d-renderer-manager-rgLMVAvd.js";
-import { n as ResetTransformData } from "./tracking-state-B9QfuZCg.js";
-import { t as ArCrashIsolationOptions } from "./recording-options-BYUFX8iU.js";
-import { r as XRCameraLike } from "./xr-camera-texture-BbukNE79.js";
+import { i as DepthSample, t as ARPose } from "./ar-types-isPsQptb.js";
+import { t as ArCrashIsolationOptions } from "./recording-options-BSFpBSZH.js";
+import { i as ImageCaptureConfig, t as CapturedImage } from "./image-capture-BXZUmj7j.js";
+import { a as TrackingSliceState, r as ResetTransformData } from "./tracking-slice-CDREeoZ_.js";
+import { t as Css3dRendererManager } from "./css3d-renderer-manager-EDED3nvg.js";
+import { r as XRCameraLike } from "./xr-camera-texture-BU5YvKAM.js";
 import * as THREE from "three";
 import { OdometryTrackingRestartedPayload } from "gps-plus-slam-js";
 
 //#region ../src/ar/webxr-session.d.ts
+/**
+ * Minimal subscribable-store contract the tracking pipeline needs:
+ * dispatch the slice actions, read the slice for the restart payload, and
+ * subscribe to phase transitions. Structurally compatible with the full
+ * `SlamAppStore` (and any test double) without coupling this module to the
+ * factory's exact generics.
+ */
+interface TrackingSubscribableStore {
+  dispatch: (action: {
+    type: string;
+    payload?: unknown;
+  }) => unknown;
+  getState: () => {
+    tracking: TrackingSliceState;
+  };
+  subscribe: (listener: () => void) => () => void;
+}
 declare function isXRCameraLike(value: unknown): value is XRCameraLike;
 /**
  * Extract a validated XRCameraLike from an XRViewerPose.
@@ -85,15 +102,33 @@ declare function extractPoseFromViewer(pose: XRViewerPose | null): ARPose | null
  * @returns The latest AR pose, or null if no pose available yet
  */
 declare function getCurrentArPose(): ARPose | null;
+/**
+ * Opt-in standard WebXR session features that are independent of the
+ * crash-isolation diagnostic flags. Kept separate from
+ * `ArCrashIsolationOptions` because requesting `hit-test` is a normal app
+ * capability, not a crash-isolation toggle.
+ */
+interface SessionFeatureOptions {
+  /**
+   * Request the WebXR `hit-test` feature (as an *optional* feature) so app
+   * code can drive a reticle via `registerXrFrameUpdate`. Default `false` —
+   * existing recorder/anchor sessions are unaffected.
+   */
+  requestHitTest?: boolean;
+}
 /**
  * Build XR session init options.
  * 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
  */
-declare function buildSessionOptions(rootElement: Element | null, isolationOptions?: Partial<ArCrashIsolationOptions>): XRSessionInit;
+declare function buildSessionOptions(rootElement: Element | null, isolationOptions?: Partial<ArCrashIsolationOptions>, sessionFeatures?: SessionFeatureOptions): XRSessionInit;
 /**
  * Check if WebXR immersive-ar is supported
  */
@@ -114,8 +149,18 @@ declare function isWebXRSupported(): Promise<boolean>;
  * basisChangeNode is a static scene-graph node that holds the WEBXR_TO_NUE
  * basis-change matrix permanently (matrixAutoUpdate=false). Moving it here
  * instead of composing it in applyAlignmentMatrix() keeps arWorldGroup's
- * local space as NUE: objects added directly to arWorldGroup can be placed
- * at [1,0,0]=North, [0,0,1]=East without any WebXR↔NUE conversion.
+ * local space in the **NUE axis convention** (X=North, Y=Up, Z=East), so no
+ * WebXR↔NUE swizzle is needed for children.
+ *
+ * CAUTION — two NUE frames: arWorldGroup's local space is the *AR-odometry*
+ * NUE frame, i.e. the **domain** of the alignment matrix, NOT the GPS-world
+ * NUE frame of the scene root. Only content authored in AR-odometry
+ * coordinates (e.g. the camera subtree) may be placed with raw local values.
+ * GPS-world content (a lat/lon → NUE point) is expressed in the scene-root
+ * frame and must be pre-multiplied by alignment⁻¹ before being used as a
+ * local position under arWorldGroup — see createGpsAnchor and the
+ * alignment-frame bug doc
+ * (GpsPlusSlamJs_Docs/docs/2026-05-31-gps-anchor-alignment-frame-bug.md).
  *
  * - Recording: arpose stays at identity; WebXRManager writes to camera.
  * - Replay: arpose receives recorded odomPosition/odomRotation;
@@ -132,8 +177,11 @@ declare 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.
  */
-declare function initAR(container: HTMLElement, isolationOptions?: Partial<ArCrashIsolationOptions>): Promise<void>;
+declare function initAR(container: HTMLElement, isolationOptions?: Partial<ArCrashIsolationOptions>, sessionFeatures?: SessionFeatureOptions): Promise<void>;
 /**
  * Get the current Three.js scene (for adding objects like map)
  */
@@ -225,9 +273,12 @@ declare function nueQuaternionToWebXR$1(nue: readonly number[]): readonly [numbe
 /**
  * End the current XR session and clean up all resources.
  *
- * Stops the animation loop, disposes the WebGL renderer, removes the
- * canvas from the DOM, and tears down the CSS3D overlay. This is the
- * production cleanup path — call it when the AR experience is finished.
+ * Stops the animation loop, ends the XR session, then delegates the full
+ * teardown to {@link resetWebXRState} so every module-level reference is
+ * cleared (renderer/scene/camera, image-capture, depth, the tracking-phase
+ * subscription, the frame-update registry, diagnostics, blit resources).
+ * This is the production cleanup path — call it when the AR experience is
+ * finished.
  */
 declare function endARSession(): Promise<void>;
 /**
@@ -255,6 +306,17 @@ declare function stopImageCapture(): void;
  * Get the current image capture frame count.
  */
 declare function getImageCaptureFrameCount(): number;
+/**
+ * Inject the Redux store used by the tracking-state slice pipeline.
+ *
+ * MUST be called before `initAR()` whenever the host also wires tracking
+ * callbacks via `setTrackingCallbacks`. Without a store the tracking
+ * pipeline silently no-ops.
+ *
+ * @param store — any store satisfying {@link TrackingSubscribableStore}.
+ *   `null` clears the binding (useful for teardown in tests).
+ */
+declare function setTrackingStore(store: TrackingSubscribableStore | null): void;
 /**
  * Set up tracking state callbacks.
  * Call this BEFORE initAR() to enable tracking restart detection.
@@ -313,4 +375,4 @@ declare function setFrameCallback(callback: (() => void) | null): void;
  */
 declare function getLiveCss3dManager(): Css3dRendererManager | null;
 //#endregion
-export { setTrackingLostCallback as A, setArWorldGroup as C, setImageCaptureCallback as D, setFrameCallback as E, stopDepthCapture as F, stopImageCapture as I, shouldLogCameraAccessDiagnostic as M, startDepthCapture as N, setScene as O, startImageCapture as P, setArPose as S, setDepthCaptureCallback as T, isWebXRSupported as _, extractPoseFromViewer as a, nueQuaternionToWebXR$1 as b, getArWorldGroup as c, getDepthSampleCount as d, getImageCaptureFrameCount as f, initAR as g, getXrCameraFromPose as h, endARSession as i, setTrackingRecoveredCallback as j, setTrackingCallbacks as k, getCamera as l, getScene as m, buildSessionOptions as n, extractResetTransformData as o, getLiveCss3dManager as p, createSceneHierarchy as r, getArPose as s, applyAlignmentMatrix as t, getCurrentArPose as u, isXRCameraLike as v, setCamera as w, resetWebXRState as x, nuePositionToWebXR as y };
+export { setScene as A, resetWebXRState as C, setDepthCaptureCallback as D, setCamera as E, shouldLogCameraAccessDiagnostic as F, startDepthCapture as I, startImageCapture as L, setTrackingLostCallback as M, setTrackingRecoveredCallback as N, setFrameCallback as O, setTrackingStore as P, stopDepthCapture as R, nueQuaternionToWebXR$1 as S, setArWorldGroup as T, getXrCameraFromPose as _, createSceneHierarchy as a, isXRCameraLike as b, extractResetTransformData as c, getCamera as d, getCurrentArPose as f, getScene as g, getLiveCss3dManager as h, buildSessionOptions as i, setTrackingCallbacks as j, setImageCaptureCallback as k, getArPose as l, getImageCaptureFrameCount as m, TrackingSubscribableStore as n, endARSession as o, getDepthSampleCount as p, applyAlignmentMatrix as r, extractPoseFromViewer as s, SessionFeatureOptions as t, getArWorldGroup as u, initAR as v, setArPose as w, nuePositionToWebXR as x, isWebXRSupported as y, stopImageCapture as z };

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

@@ -0,0 +1,70 @@
+//#region ../src/ar/xr-frame-loop.d.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.
+ */
+/**
+ * Live, frame-scoped WebXR context. Valid only synchronously inside the
+ * `XrFrameUpdate` callback it is passed to.
+ */
+interface XrFrameContext {
+  /** The live `XRFrame` for this animation-frame. Use-after-frame-unsafe. */
+  readonly frame: XRFrame;
+  /** The session's reference space (e.g. for `frame.getPose` / hit-test results). */
+  readonly referenceSpace: XRReferenceSpace;
+  /** The active `XRSession` (e.g. to call `requestHitTestSource` once). */
+  readonly session: XRSession;
+  /** Seconds since the previous frame (0 on the first frame after a reset). */
+  readonly dt: number;
+  /** Seconds since the session started. */
+  readonly elapsed: number;
+}
+/** A per-frame callback that needs live XR access. See the safety contract. */
+type XrFrameUpdate = (ctx: XrFrameContext) => void;
+/**
+ * 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`).
+ */
+declare function registerXrFrameUpdate(fn: XrFrameUpdate): () => void;
+/**
+ * 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`.
+ */
+declare function runXrFrameUpdates(ctx: XrFrameContext): void;
+/**
+ * Clear all registrations. Called from `resetWebXRState()` so a fresh
+ * session starts with an empty registry.
+ */
+declare function clearXrFrameUpdates(): void;
+//#endregion
+export { runXrFrameUpdates as a, registerXrFrameUpdate as i, XrFrameUpdate as n, clearXrFrameUpdates as r, XrFrameContext as t };

package/dist/{zip-reader-KgJEXbca.d.ts → zip-reader-B2lzN8F5.d.ts}

@@ -77,6 +77,11 @@ declare function loadSessionMetadataFromBlob(blob: Blob, maxFileSize?: number):
 interface GpsPathCoord {
   readonly lat: number;
   readonly lng: number;
+  /**
+   * Horizontal accuracy in meters (1σ), if the source GPS event included it.
+   * Used by 2D-map previews to draw a per-event accuracy circle.
+   */
+  readonly accuracy?: number;
 }
 /**
  * Extract GPS coordinates from a recording zip provided as a Blob.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gps-plus-slam-app-framework",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Reusable AR+GPS app framework layer — WebXR session management, Three.js visualization, GPS sensors, storage abstractions, replay engine, and store wiring for gps-plus-slam-js.",
   "type": "module",
   "files": [
@@ -36,7 +36,7 @@
   "dependencies": {
     "@reduxjs/toolkit": "^2.11.2",
     "gl-matrix": "3.4.4",
-    "gps-plus-slam-js": "^1.0.6"
+    "gps-plus-slam-js": "^1.0.7"
   },
   "peerDependencies": {
     "@sentry/browser": ">=10.0.0",
@@ -55,27 +55,27 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@sentry/browser": "^10.49.0",
+    "@sentry/browser": "^10.53.1",
     "@types/leaflet": "^1.9.21",
-    "@types/node": "^25.6.0",
-    "@types/three": "^0.184.0",
-    "@vitest/coverage-v8": "^4.1.5",
-    "@vitest/eslint-plugin": "^1.6.16",
+    "@types/node": "^25.7.0",
+    "@types/three": "^0.184.1",
+    "@vitest/coverage-v8": "^4.1.6",
+    "@vitest/eslint-plugin": "^1.6.17",
     "@zip.js/zip.js": "^2.8.26",
-    "dpdm": "^4.0.1",
-    "eslint": "^10.2.1",
+    "dpdm": "^4.2.0",
+    "eslint": "^10.3.0",
     "eslint-config-prettier": "^10.1.8",
-    "fast-check": "^4.7.0",
-    "globals": "^17.5.0",
+    "fast-check": "^4.8.0",
+    "globals": "^17.6.0",
     "h3-js": "^4.4.0",
-    "jsdom": "^29.0.2",
+    "jsdom": "^29.1.1",
     "leaflet": "^1.9.4",
     "prettier": "^3.8.3",
     "three": "^0.184.0",
-    "tsdown": "^0.21.9",
+    "tsdown": "^0.22.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.59.0",
-    "vitest": "^4.1.5"
+    "typescript-eslint": "^8.59.3",
+    "vitest": "^4.1.6"
   },
   "keywords": [
     "ar",
@@ -105,7 +105,7 @@
     "verify:pack": "pnpm pack --dry-run",
     "verify:community-key-lifetime": "node scripts/verify-community-key-lifetime.mjs",
     "test:unit": "vitest run --coverage --config config/vitest.config.ts",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.app.json --noEmit",
     "typecheck:tests": "tsc -p tsconfig.vitest.json --noEmit",
     "lint": "eslint . --config config/eslint.config.mjs",
     "test:watch": "vitest --config config/vitest.config.ts",

package/dist/ar/tracking-state.d.ts

@@ -1,2 +0,0 @@
-import { a as TrackingStateManager, i as TrackingStateCallbacks, n as ResetTransformData, r as TrackingState, t as DeviceOrientation } from "../tracking-state-B9QfuZCg.js";
-export { DeviceOrientation, ResetTransformData, TrackingState, TrackingStateCallbacks, TrackingStateManager };