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

package/dist/frame-conversions-D2EYjeNa.d.ts

@@ -0,0 +1,54 @@
+import { i as LatLongAlt, r as LatLong } from "./index--ldLph4V.js";
+import * as THREE from "three";
+
+//#region ../src/visualization/frame-conversions.d.ts
+/**
+ * Convert a GPS-world NUE point into the AR-local position to write into a
+ * direct child of `arWorldGroup`, given the current alignment matrix.
+ *
+ * Computes `alignment⁻¹ · nue`. When the result is later composed back by the
+ * group's matrix (the same `alignment`), the child's WORLD position equals
+ * `nue` exactly.
+ *
+ * @param alignment - The alignment matrix as a 16-element **column-major**
+ *   array (AR-odometry NUE → GPS-world NUE), e.g. from `getAlignmentMatrix()`
+ *   or `THREE.Matrix4.toArray()`. Not mutated.
+ * @param nue - The GPS-world NUE point `[north, up, east]` in metres. Not
+ *   mutated.
+ * @param out - Optional target vector to write into and return (pass a reused
+ *   scratch to avoid allocation on hot paths). Defaults to a fresh
+ *   `THREE.Vector3`.
+ * @returns `out`, set to the AR-local position.
+ */
+declare function nueToArLocal(alignment: readonly number[], nue: readonly [number, number, number], out?: THREE.Vector3): THREE.Vector3;
+/**
+ * Convert an object's **GPS-world NUE world position** back into a GPS
+ * coordinate, for the GPS-anchor bootstrap that medians where an object was
+ * actually placed (mirrors the C# `DetermineAndStoreGpsWorldPose`, which
+ * medians the object's world pose and converts via `zero.CalcGpsCoordsOf`).
+ *
+ * Precondition: `worldNue` must already be in GPS-world NUE — i.e. the object
+ * lives under an `arWorldGroup` whose `.matrix` carries the alignment (see
+ * `enableArWorldGroupAlignment`), so `object3D.getWorldPosition()` is the
+ * GPS-world position. Sampling a pure-VIO (identity-`arWorldGroup`) world
+ * position would yield a wrong GPS coordinate.
+ *
+ * Altitude round-trip: `calcGpsCoords` returns only `lat`/`lon` (it derives
+ * them from the North/East axes and ignores Up). The Up axis (`worldNue.y`,
+ * NUE index 1) is carried through verbatim as `altitude`, so a later
+ * `calcRelativeCoordsInMeters(zero, result, result.altitude, 0)` reproduces the
+ * same Up value — keeping the steady-state vertical target consistent with
+ * where the object was sampled.
+ *
+ * @param worldNue - The object's world position in GPS-world NUE metres
+ *   (`x = North`, `y = Up`, `z = East`). A `THREE.Vector3` satisfies this.
+ * @param zero - The GPS zero reference (origin for the conversion).
+ * @returns The GPS coordinate of `worldNue`, with `altitude = worldNue.y`.
+ */
+declare function worldNueToGps(worldNue: {
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+}, zero: LatLong): LatLongAlt;
+//#endregion
+export { worldNueToGps as n, nueToArLocal as t };

package/dist/frame-loop-BTeRpDm4.d.ts

@@ -0,0 +1,47 @@
+//#region ../src/ar/frame-loop.d.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).
+ */
+type FrameUpdate = (dt: number, elapsed: number) => void;
+/**
+ * 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`).
+ */
+declare function registerFrameUpdate(fn: FrameUpdate): () => void;
+/**
+ * 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`.
+ */
+declare function runFrameUpdates(dt: number, elapsed: number): void;
+/**
+ * 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).
+ */
+declare function clearFrameUpdates(): void;
+//#endregion
+export { runFrameUpdates as i, clearFrameUpdates as n, registerFrameUpdate as r, FrameUpdate as t };

package/dist/frustum-visibility-DGnJqls0.d.ts

@@ -0,0 +1,58 @@
+import * as THREE from "three";
+
+//#region ../src/visualization/frustum-visibility.d.ts
+/**
+ * Build (or refresh) a Three.js `Frustum` from `camera`'s current world
+ * transform and projection matrix. If `out` is provided, the frustum is
+ * written into it and returned; otherwise the module-level scratch frustum
+ * is used. Callers MUST treat the returned frustum as immutable until they
+ * next call this function or use one of the predicates without an injected
+ * frustum (both reuse the same scratch).
+ */
+declare function buildCameraFrustum(camera: THREE.Camera, out?: THREE.Frustum): THREE.Frustum;
+/**
+ * Strictly check whether a single world-space point lies inside all six
+ * frustum planes. Useful for HUD/follow logic where the caller already has
+ * the target world position and wants the cheapest possible check.
+ */
+declare function isPointInCameraFrustum(camera: THREE.Camera, point: THREE.Vector3, frustum?: THREE.Frustum): boolean;
+/**
+ * Check whether a world-space bounding sphere intersects the camera frustum
+ * (returns true even for partial overlap). Useful for callers that maintain
+ * a precomputed bounding sphere (LOD systems, instanced meshes, future
+ * `ArPowerSaver`).
+ */
+declare function isSphereInCameraFrustum(camera: THREE.Camera, sphere: THREE.Sphere, frustum?: THREE.Frustum): boolean;
+/**
+ * Check whether an `Object3D` is currently (at least partially) inside the
+ * camera frustum. The world bounding volume is resolved in tiers, cheapest
+ * first, so each common Three.js object type is gated by where it actually
+ * draws:
+ *
+ *  1. **Sprites** (`isSprite`) are screen-space billboards with no meaningful
+ *     world geometry, so their world-space origin is tested as a point.
+ *  2. **Objects carrying an object-level `boundingSphere`** (`InstancedMesh`,
+ *     `SkinnedMesh`, or any caller that pre-populates one) use that sphere,
+ *     which reflects the instance spread / posed extent — unlike the base
+ *     geometry sphere. It is computed lazily via `computeBoundingSphere()`
+ *     when missing.
+ *  3. **Single renderables carrying a `geometry`** (`Mesh`, `Points`, `Line`,
+ *     …) use the geometry's local bounding sphere × `matrixWorld`.
+ *  4. **Containers with children** (`Group`, `LOD`, …) use the world-space
+ *     union of their descendants' bounding boxes (`Box3.setFromObject`),
+ *     converted to a sphere.
+ *  5. **Truly empty / geometry-less objects** have no bounding volume and are
+ *     treated as visible (`true`) — the conservative default for visibility
+ *     gating.
+ *
+ * This deliberately avoids `Frustum.intersectsObject`, which unconditionally
+ * dereferences `object.geometry.boundingSphere` and therefore throws a
+ * `TypeError` for geometry-less objects such as `Group`s.
+ *
+ * Callers should ensure `object.updateMatrixWorld()` (with descendants, for
+ * containers: `updateMatrixWorld(true)`) has already run this frame (it
+ * normally has, via `renderer.render`).
+ */
+declare function isObjectInCameraFrustum(camera: THREE.Camera, object: THREE.Object3D, frustum?: THREE.Frustum): boolean;
+//#endregion
+export { isSphereInCameraFrustum as i, isObjectInCameraFrustum as n, isPointInCameraFrustum as r, buildCameraFrustum as t };

package/dist/{fused-path-DtqCSqJh.d.ts → fused-path-BdVHmDW9.d.ts}

@@ -1,4 +1,4 @@
-import { t as GpsCoord } from "./geo-types-Xx-LVcnw.js";
+import { t as GpsCoord } from "./geo-types-clgzl8b5.js";
 import { LatLong, Matrix4, Vector3, fusedGpsFromOdom } from "gps-plus-slam-js";
 
 //#region ../src/utils/fused-path.d.ts

package/dist/geo/h3-proximity.d.ts

@@ -1,2 +1,2 @@
-import { a as gpsToH3, i as findNearbyGeoAnchor, n as KnownGeoAnchor, o as h3CellsMatch, r as approxDistanceMetres, s as isH3Index, t as H3_RESOLUTION } from "../h3-proximity-GwesPTFT.js";
+import { a as gpsToH3, i as findNearbyGeoAnchor, n as KnownGeoAnchor, o as h3CellsMatch, r as approxDistanceMetres, s as isH3Index, t as H3_RESOLUTION } from "../h3-proximity-DJnghtir.js";
 export { H3_RESOLUTION, KnownGeoAnchor, approxDistanceMetres, findNearbyGeoAnchor, gpsToH3, h3CellsMatch, isH3Index };

package/dist/geo/index.d.ts

@@ -1,2 +1,2 @@
-import { a as gpsToH3, i as findNearbyGeoAnchor, n as KnownGeoAnchor, o as h3CellsMatch, r as approxDistanceMetres, s as isH3Index, t as H3_RESOLUTION } from "../h3-proximity-GwesPTFT.js";
+import { a as gpsToH3, i as findNearbyGeoAnchor, n as KnownGeoAnchor, o as h3CellsMatch, r as approxDistanceMetres, s as isH3Index, t as H3_RESOLUTION } from "../h3-proximity-DJnghtir.js";
 export { H3_RESOLUTION, type KnownGeoAnchor, approxDistanceMetres, findNearbyGeoAnchor, gpsToH3, h3CellsMatch, isH3Index };

package/dist/{geo-types-Xx-LVcnw.d.ts → geo-types-clgzl8b5.d.ts}

@@ -18,6 +18,21 @@ interface GpsCoord {
   readonly lat: number;
   readonly lng: number;
 }
+/**
+ * A raw GPS sample with optional accuracy (1σ horizontal radius in meters,
+ * mirroring the browser's `GeolocationCoordinates.accuracy`).
+ *
+ * Used for 2D map visualizations that draw a per-event accuracy circle
+ * alongside the GPS polyline so that low-quality fixes (large radius) are
+ * visually distinguishable from accurate fixes (small radius).
+ */
+interface RawGpsSample extends GpsCoord {
+  /**
+   * Horizontal accuracy in meters (1σ / 68% confidence).
+   * `undefined` when the source GPS event lacked the field.
+   */
+  readonly accuracy?: number;
+}
 /**
  * A reference point with GPS location and a human-readable name.
  * Extends GpsCoord so it is usable wherever GpsCoord is expected.
@@ -26,4 +41,4 @@ interface RefPointMarker extends GpsCoord {
   readonly name: string;
 }
 //#endregion
-export { RefPointMarker as n, GpsCoord as t };
+export { RawGpsSample as n, RefPointMarker as r, GpsCoord as t };

package/dist/{gps-GKc6_Cly.d.ts → gps-B7AlMPz5.d.ts}

@@ -17,7 +17,7 @@ interface GpsPosition {
 /**
  * Raw device orientation from the browser's DeviceOrientationEvent API.
  * Fields are nullable because sensors may be unavailable on some devices.
- * See also: DeviceOrientation in ar/tracking-state.ts (resolved, non-nullable).
+ * See also: DeviceOrientation in state/tracking-slice.ts (resolved, non-nullable).
  */
 interface RawDeviceOrientation {
   alpha: number | null;

package/dist/gps-anchor-CISLPQIb.d.ts

@@ -0,0 +1,59 @@
+import { i as LatLongAlt, r as LatLong } from "./index--ldLph4V.js";
+import * as THREE from "three";
+
+//#region ../src/visualization/gps-anchor.d.ts
+type GpsAnchorMode = 'snap-when-offscreen' | 'snap-every-tick';
+type GpsAnchorPhase = 'bootstrap' | 'anchored';
+/**
+ * The minimum shape needed for the bootstrap median — a `LatLong` with
+ * optional altitude. Re-exported as a named alias so the sidecar and
+ * tests can refer to "the kind of point the anchor samples" without
+ * importing core types.
+ */
+type GpsAnchorSamplePoint = LatLong | LatLongAlt;
+interface GpsAnchorOptions {
+  readonly object3D: THREE.Object3D;
+  readonly arWorldGroup: THREE.Object3D;
+  readonly camera: THREE.Camera;
+  readonly gpsPoint: LatLong | LatLongAlt;
+  readonly skipBootstrap?: boolean;
+  readonly getAlignmentMatrix: () => readonly number[] | null;
+  readonly getGpsZeroRef: () => LatLong | null;
+  /** Returns the current GPS reading at "now", or null when no fix yet. */
+  readonly getCurrentGpsPoint: () => GpsAnchorSamplePoint | null;
+  /**
+   * Optional callback invoked whenever the bootstrap median is committed (the
+   * anchor's GPS reference is (re)assigned). Receives the exact committed point
+   * — the same value assigned to `gpsPoint`. Fires once after the initial
+   * bootstrap and again after every re-bootstrap (`markMovedExternally` →
+   * re-accumulate → commit). Never fires when `skipBootstrap` is true (there is
+   * no bootstrap to complete). Lets a host persist the committed reference (e.g.
+   * AnchorStarter writing `?show=`) so the persisted link equals the committed
+   * reference by construction.
+   */
+  readonly onBootstrapComplete?: (gpsPoint: LatLong | LatLongAlt) => void;
+  readonly mode?: GpsAnchorMode;
+  readonly floorY?: () => number | null;
+  readonly distanceThreshold?: number;
+  readonly angleThresholdInDegrees?: number;
+  readonly targetPosRefreshRateInSec?: number;
+  /** Number of 1 Hz samples collected during bootstrap. Default 7. */
+  readonly secondsToAccumulateGpsPose?: number;
+  /** Wait window (seconds) at phase entry during which no samples are taken. Default 0. */
+  readonly settlingSeconds?: number;
+  readonly heightAboveGround?: number | null;
+}
+interface GpsAnchor {
+  readonly phase: GpsAnchorPhase;
+  readonly isFullyAnchored: boolean;
+  /** Current target GPS pose; during `bootstrap` this is the seed, post-bootstrap the median. */
+  readonly gpsPoint: LatLong | LatLongAlt;
+  markMovedExternally(): void;
+  setGpsPoint(point: LatLong | LatLongAlt): void;
+  dispose(): void;
+  /** @internal — testing seam; exposed in lieu of pumping `runFrameUpdates`. */
+  __tickForTests(dt: number, elapsed: number): void;
+}
+declare function createGpsAnchor(options: GpsAnchorOptions): GpsAnchor;
+//#endregion
+export { GpsAnchorSamplePoint as a, GpsAnchorPhase as i, GpsAnchorMode as n, createGpsAnchor as o, GpsAnchorOptions as r, GpsAnchor as t };

package/dist/{gps-ar-pose-sampler-D_Zso40V.d.ts → gps-ar-pose-sampler-BypXZUqC.d.ts}

@@ -1,4 +1,4 @@
-import { t as ARPose } from "./ar-types-B-ORgk6Z.js";
+import { t as ARPose } from "./ar-types-isPsQptb.js";
 import { Quaternion, Vector3 } from "gps-plus-slam-js";
 
 //#region ../src/state/gps-ar-pose-sampler.d.ts

package/dist/{gps-event-coordinator-fwvmVfku.d.ts → gps-event-coordinator-BKVZbS1M.d.ts}

@@ -1,6 +1,6 @@
-import { t as ARPose } from "./ar-types-B-ORgk6Z.js";
-import { n as RawDeviceOrientation, t as GpsPosition } from "./gps-GKc6_Cly.js";
-import { i as SlamAppStore } from "./create-slam-app-store-DBm7g2Zd.js";
+import { t as ARPose } from "./ar-types-isPsQptb.js";
+import { n as RawDeviceOrientation, t as GpsPosition } from "./gps-B7AlMPz5.js";
+import { i as SlamAppStore } from "./create-slam-app-store-B76AGaI0.js";
 import { Quaternion, RawGpsPoint, RecordGpsEventPayload, Vector3, eulerToQuaternion } from "gps-plus-slam-js";
 import { ReducersMapObject } from "@reduxjs/toolkit";
 

package/dist/gps-event-markers-BlHq3jYV.d.ts

@@ -0,0 +1,103 @@
+import { LatLong, Vector3 } from "gps-plus-slam-js";
+
+//#region ../src/visualization/gps-event-markers.d.ts
+/**
+ * Optional GPS-accuracy hints used by {@link GpsEventVisualizer.addGpsEvent}
+ * to render the raw-GPS marker as a non-uniform-scaled ellipsoid.
+ *
+ * Both fields are optional — missing or non-positive values fall back to the
+ * legacy fixed 8 cm sphere (same defensive policy as `preview-map.ts`).
+ */
+interface GpsEventAccuracy {
+  /** Horizontal 1σ accuracy in metres (applied to both X and Z axes). */
+  horizontal?: number;
+  /** Vertical 1σ accuracy in metres (applied to the Y axis). */
+  vertical?: number;
+}
+/**
+ * Manager for GPS event visualization
+ */
+declare class GpsEventVisualizer {
+  private rawGpsMarkers;
+  private fusedMarkers;
+  private snapshotMarkers;
+  private zeroRef;
+  private eventCounter;
+  private snapshotCounter;
+  /**
+   * Set the GPS zero reference (origin for coordinate conversion).
+   * Must be called before adding GPS events.
+   *
+   * @param zero - GPS coordinates of the origin
+   */
+  setZeroRef(zero: LatLong): void;
+  /**
+   * Get the current zero reference
+   */
+  getZeroRef(): LatLong | null;
+  /**
+   * Add a GPS event to the visualization.
+   * Creates both a raw GPS marker and a fused alignment marker.
+   *
+   * @param gpsCoords - GPS position as [x, y, z] meters from zero reference
+   * @param odomPosition - AR odometry position at the time of GPS reading
+   * @param accuracy - Optional 1σ GPS accuracy. When both fields are positive,
+   *   the raw-GPS marker is rendered as a non-uniform-scaled ellipsoid:
+   *   `mesh.scale.set(horizontal, vertical, horizontal)` over a unit sphere.
+   *   When missing, zero, or negative, the marker falls back to the legacy
+   *   fixed 8 cm sphere (same defensive policy as `preview-map.ts`).
+   *   Cyan fused and red snapshot markers are never affected by this argument.
+   */
+  addGpsEvent(gpsCoords: Vector3, odomPosition: Vector3, accuracy?: GpsEventAccuracy): void;
+  /**
+   * Add an alignment snapshot marker at the given NUE position.
+   * Snapshots represent the system's best GPS estimate at each alignment update.
+   * Added to scene root (GPS world space), not arWorldGroup.
+   */
+  addAlignmentSnapshot(nuePosition: Vector3): void;
+  /**
+   * Get the NUE positions of all alignment snapshot markers.
+   * Used at session end to convert to GPS coordinates for the summary map.
+   */
+  getAlignmentSnapshotPositions(): Vector3[];
+  /**
+   * Create a sphere marker mesh with the given color and name.
+   */
+  private createMarkerMesh;
+  /**
+   * Clear all markers from the scene and reset state.
+   */
+  clearAll(): void;
+  /**
+   * Get count of visible markers.
+   */
+  getCounts(): {
+    raw: number;
+    fused: number;
+    snapshots: number;
+  };
+  /**
+   * Diagnostic accessor: returns the world-space size (`THREE.Box3.setFromObject`)
+   * of each raw-GPS marker, in insertion order.
+   *
+   * Used by the rec31 accuracy-ellipsoid Playwright spec (§3c) to verify the
+   * relative scaling of two events with different `latLongAccuracy`. This is
+   * the size of the rendered ellipsoid in scene units (= metres in replay
+   * mode), not the underlying geometry radius — so it correctly reflects the
+   * `mesh.scale.set(h, v, h)` applied for accuracy-aware markers.
+   *
+   * @returns array of `{ x, y, z }` sizes — empty array if there are no markers.
+   */
+  getRawMarkerWorldSizes(): Array<{
+    x: number;
+    y: number;
+    z: number;
+  }>;
+}
+/**
+ * Singleton instance for global use.
+ * Import this to visualize GPS events.
+ */
+declare const gpsEventVisualizer: GpsEventVisualizer;
+//#endregion
+export { GpsEventVisualizer as n, gpsEventVisualizer as r, GpsEventAccuracy as t };

package/dist/hit-test-reticle-BGXOxrUh.d.ts

@@ -0,0 +1,45 @@
+import { Mesh, Object3D } from "three";
+
+//#region ../src/visualization/hit-test-reticle.d.ts
+/** A column-major 4x4 transform, as produced by `XRPose.transform.matrix`. */
+type HitMatrix = Float32Array | number[];
+/**
+ * Build the reticle mesh: a thin ring oriented flat (rotated to lie in the
+ * XZ plane) so it reads as a marker on the ground/wall.
+ *
+ * `matrixAutoUpdate` is disabled because the reticle's world transform is
+ * written wholesale from the hit-test pose every frame; letting Three.js
+ * recompose it from position/quaternion/scale would discard that pose.
+ *
+ * The mesh starts hidden (`visible = false`) — there is no surface yet.
+ */
+declare function createReticleMesh(): Mesh;
+/**
+ * Apply the latest hit-test pose to the reticle.
+ *
+ * - When `matrix` is a 16-element transform, the reticle adopts it (after the
+ *   WebXR→NUE basis change, see below) and becomes visible.
+ * - When `matrix` is `null` (no surface under the screen centre, or the
+ *   hit-test source is not ready yet), the reticle is hidden.
+ *
+ * Frame handling — the part a porting developer must not get wrong. The
+ * hit-test pose is expressed in the **WebXR reference space** (`X=East, Y=Up,
+ * Z=South`), the same frame as the live camera pose. The reticle, however, is
+ * parented under `getArWorldGroup()`, whose local space is **NUE** (`X=North,
+ * Y=Up, Z=East`) — the camera reaches that frame through the static
+ * `basisChangeNode` that holds `WEBXR_TO_NUE`. The reticle has no such
+ * intermediate node, so we apply the same basis change here:
+ * `reticle.matrix = WEBXR_TO_NUE · hitPose`. The reticle's resulting world pose
+ * is then `arWorldGroup.matrix · WEBXR_TO_NUE · hitPose` — identical to the
+ * transform chain the camera rides, so it stays pinned under the screen centre.
+ *
+ * Without the basis change the WebXR coordinates were interpreted as NUE: the
+ * Up axis matched (both are Y) but East/North were swapped, so the reticle
+ * drifted sideways instead of tracking the screen centre.
+ *
+ * Works on any `Object3D` (not just the mesh from `createReticleMesh`) so it can
+ * be unit tested without a WebGL context.
+ */
+declare function updateReticle(reticle: Object3D, matrix: HitMatrix | null): void;
+//#endregion
+export { createReticleMesh as n, updateReticle as r, HitMatrix as t };

package/dist/{image-capture-2pKjYUS6.d.ts → image-capture-BXZUmj7j.d.ts}

@@ -1,4 +1,4 @@
-import { a as WebXRQuaternion, o as WebXRVec3, t as ARPose } from "./ar-types-B-ORgk6Z.js";
+import { a as WebXRQuaternion, o as WebXRVec3, t as ARPose } from "./ar-types-isPsQptb.js";
 
 //#region ../src/ar/image-capture.d.ts
 /**

package/dist/index--ldLph4V.d.ts

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

package/dist/index-22v8MXJX.d.ts

@@ -0,0 +1,23 @@
+import { Matrix4 } from "three";
+
+//#region ../src/ar/webxr-nue-basis.d.ts
+/**
+ * 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).
+ */
+declare const WEBXR_TO_NUE: Matrix4;
+//#endregion
+export { WEBXR_TO_NUE as t };

package/dist/index-BB2KEWbN2.d.ts

@@ -0,0 +1,37 @@
+import { L as CombinedRootState, h as TrackingQualityReport } from "./create-slam-app-store-B76AGaI0.js";
+import { Add2dImagePayload, GpsPoint as GpsPoint$1, LatLong as LatLong$1, RawDeviceOrientation, RawGpsPoint as RawGpsPoint$1, RecordGpsEventPayload as RecordGpsEventPayload$1, add2dImage, calcRelativeCoordsInMeters, recordGpsEvent as recordGpsEvent$1, setZeroPos as setZeroPos$1 } from "gps-plus-slam-js";
+
+//#region ../src/state/onboarding-guidance.d.ts
+/**
+ * Coaching phase derived from the tracking-quality `state`. Ordered from
+ * "no signal yet" to "ready to place an anchor". The order matters: it is
+ * the basis for the monotonic {@link OnboardingGuidance.percentReady}.
+ */
+type OnboardingPhase = 'initializing' | 'ar-lost' | 'move-around' | 'almost-ready' | 'ready';
+interface OnboardingGuidance {
+  /** Coaching phase — maps 1:1 onto the tracking-quality state (+ null). */
+  phase: OnboardingPhase;
+  /**
+   * 0..1 readiness for placing an anchor. Monotonic across phases
+   * (`initializing` = `ar-lost` ≤ `move-around` ≤ `almost-ready` ≤ `ready`)
+   * and, within `move-around`, monotonic in `subScores.coverage`; within
+   * `almost-ready`, monotonic in `confidence`.
+   */
+  percentReady: number;
+  /** Short, user-facing coaching line. */
+  hint: string;
+}
+/**
+ * Map a tracking-quality report (or `null` when none has been produced yet)
+ * to a single onboarding instruction. Never throws; a `null` or malformed
+ * report degrades to the `initializing` phase.
+ */
+declare function computeOnboardingGuidance(report: TrackingQualityReport | null): OnboardingGuidance;
+/**
+ * Store-bound convenience wrapper: read the current tracking-quality report
+ * and map it to onboarding guidance. Returns the `initializing` guidance
+ * when no report exists yet.
+ */
+declare function selectOnboardingGuidance(state: CombinedRootState): OnboardingGuidance;
+//#endregion
+export { RawGpsPoint$1 as a, calcRelativeCoordsInMeters as c, OnboardingGuidance as d, OnboardingPhase as f, RawDeviceOrientation as i, recordGpsEvent$1 as l, selectOnboardingGuidance as m, GpsPoint$1 as n, RecordGpsEventPayload$1 as o, computeOnboardingGuidance as p, LatLong$1 as r, add2dImage as s, Add2dImagePayload as t, setZeroPos$1 as u };