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

package/dist/ar/tracking-state.js

@@ -1,164 +0,0 @@
-import { createLogger } from "../utils/logger.js";
-import { extractOdomPosition } from "../state/gps-event-coordinator.js";
-//#region ../src/ar/tracking-state.ts
-/**
-* Tracking State Manager
-*
-* Detects AR tracking loss and restart events, maintaining state
-* about the last valid odometry pose for alignment correction.
-*
-* ARCHITECTURE NOTE: See docs/architecture-ar-gps-pose-separation.md
-*
-* When WebXR tracking is lost and restarted, the odometry frame resets
-* to a new origin. To maintain GPS+AR alignment, we need to:
-* 1. Store the last valid pose before tracking was lost
-* 2. Detect when tracking resumes with a new pose
-* 3. Dispatch odometryTrackingRestarted with both poses for offset calculation
-*/
-const log = createLogger("TrackingState");
-/**
-* Possible tracking states
-*/
-let TrackingState = /* @__PURE__ */ function(TrackingState) {
-	/** AR session started but no pose received yet */
-	TrackingState["INITIALIZING"] = "initializing";
-	/** Actively receiving valid poses */
-	TrackingState["TRACKING"] = "tracking";
-	/** Pose became unavailable (tracking lost) */
-	TrackingState["LOST"] = "lost";
-	return TrackingState;
-}({});
-/**
-* Manages AR tracking state and detects loss/restart events.
-*/
-var TrackingStateManager = class {
-	state = "initializing";
-	lastValidPose = null;
-	lastSensorOrientation = null;
-	lostFrameCount = 0;
-	originResetDuringLoss = false;
-	resetTransform = void 0;
-	callbacks;
-	constructor(callbacks) {
-		this.callbacks = callbacks;
-	}
-	/**
-	* Get current tracking state.
-	*/
-	getState() {
-		return this.state;
-	}
-	/**
-	* Get the last valid AR pose (before tracking was lost).
-	*/
-	getLastValidPose() {
-		return this.lastValidPose;
-	}
-	/**
-	* Get count of consecutive frames without pose (during LOST state).
-	*/
-	getLostFrameCount() {
-		return this.lostFrameCount;
-	}
-	/**
-	* Flag that an XRReferenceSpace reset event occurred during tracking loss.
-	* Only meaningful while in LOST state — ignored otherwise.
-	*
-	* @param transform — Serialized XRReferenceSpaceEvent.transform (post-reset
-	*   origin in pre-reset coordinates).  Pass `null` when the event's
-	*   transform property is null (runtime can't determine delta).
-	*   Omit entirely for backwards-compat with callers that don't have it.
-	*/
-	markOriginReset(transform) {
-		if (this.state === "lost") {
-			this.originResetDuringLoss = true;
-			this.resetTransform = transform;
-		}
-	}
-	/**
-	* Called when a valid pose is received from WebXR.
-	*/
-	onPoseReceived(pose) {
-		if (this.state === "lost") this.handleTrackingRestarted(pose);
-		this.state = "tracking";
-		this.lastValidPose = pose;
-		this.lastSensorOrientation = this.callbacks.getDeviceOrientation();
-		this.lostFrameCount = 0;
-	}
-	/**
-	* Called when pose is null/unavailable from WebXR.
-	*/
-	onPoseLost() {
-		this.lostFrameCount++;
-		if (this.state === "tracking") {
-			this.state = "lost";
-			this.callbacks.onTrackingLost();
-			log.warn("AR tracking lost");
-		}
-	}
-	/**
-	* Reset the manager to initial state.
-	* Call this when starting a new session.
-	*/
-	reset() {
-		this.state = "initializing";
-		this.lastValidPose = null;
-		this.lastSensorOrientation = null;
-		this.lostFrameCount = 0;
-		this.originResetDuringLoss = false;
-		this.resetTransform = void 0;
-	}
-	/**
-	* Handle the transition from LOST to TRACKING (restart detected).
-	*/
-	handleTrackingRestarted(newPose) {
-		const hadReset = this.originResetDuringLoss;
-		const savedResetTransform = this.resetTransform;
-		this.originResetDuringLoss = false;
-		this.resetTransform = void 0;
-		if (!hadReset) {
-			log.info("AR tracking recovered (same coordinate frame)");
-			this.callbacks.onTrackingRecovered?.();
-			return;
-		}
-		if (!this.lastValidPose) {
-			log.warn("Tracking restarted but no previous pose available");
-			return;
-		}
-		const currentSensorOrientation = this.callbacks.getDeviceOrientation();
-		const lastOrientation = this.lastSensorOrientation ?? currentSensorOrientation;
-		const payload = {
-			lastValidOdomPos: extractOdomPosition(this.lastValidPose),
-			lastValidOdomRot: [
-				this.lastValidPose.orientation.x,
-				this.lastValidPose.orientation.y,
-				this.lastValidPose.orientation.z,
-				this.lastValidPose.orientation.w
-			],
-			lastSensorOrientation: {
-				alpha: lastOrientation.alpha,
-				beta: lastOrientation.beta,
-				gamma: lastOrientation.gamma,
-				absolute: lastOrientation.absolute
-			},
-			newOdomRot: [
-				newPose.orientation.x,
-				newPose.orientation.y,
-				newPose.orientation.z,
-				newPose.orientation.w
-			],
-			newSensorOrientation: {
-				alpha: currentSensorOrientation.alpha,
-				beta: currentSensorOrientation.beta,
-				gamma: currentSensorOrientation.gamma,
-				absolute: currentSensorOrientation.absolute
-			},
-			newOdomPos: extractOdomPosition(newPose),
-			resetTransform: savedResetTransform
-		};
-		log.info("AR tracking restarted (origin reset), dispatching alignment correction");
-		this.callbacks.onTrackingRestarted(payload);
-	}
-};
-//#endregion
-export { TrackingState, TrackingStateManager };

package/dist/combined-root-state-B3SvPNjU.d.ts

@@ -1,6 +0,0 @@
-import { t as SlamAppCombinedState } from "./create-slam-app-store-DBm7g2Zd.js";
-
-//#region ../src/state/combined-root-state.d.ts
-type CombinedRootState = SlamAppCombinedState;
-//#endregion
-export { CombinedRootState as t };

package/dist/create-slam-app-store-DBm7g2Zd.d.ts

@@ -1,85 +0,0 @@
-import { t as RecordingState } from "./recording-slice-BiktUIWF.js";
-import { n as SessionMetadata } from "./opfs-storage-Dlq1I_Gb.js";
-import { n as StorageBackend } from "./storage-backend-yVnuWGTr.js";
-import { RootState } from "gps-plus-slam-js";
-import { Middleware, Reducer, ReducersMapObject, configureStore } from "@reduxjs/toolkit";
-
-//#region ../src/state/create-slam-app-store.d.ts
-/**
- * Base shape produced by `createSlamAppStore` with no `extraReducers`.
- *
- * Library state (`gpsData` / `gpsElements` / `arElements`) plus the
- * framework recording slice (`recording`).
- */
-interface SlamAppRootState extends RootState {
-  recording: RecordingState;
-}
-/** A bare-minimum middleware signature compatible with RTK's middleware list. */
-type SlamAppMiddleware = Middleware<any, any, any>;
-/**
- * Options for {@link createSlamAppStore}.
- */
-interface SlamAppStoreOptions<ExtraReducers extends ReducersMapObject = Record<string, never>> {
-  /**
-   * Persistence backend used to bridge Redux actions to durable storage.
-   * Tests / replay paths should pass `NullStorageBackend`.
-   */
-  storageBackend: StorageBackend;
-  /**
-   * Caller-supplied reducers added alongside the framework's built-ins.
-   * Use this seam to plug recorder slices (routing, refPoints, scenario)
-   * or any app-specific state without forking the factory.
-   */
-  extraReducers?: ExtraReducers;
-  /**
-   * Caller-supplied middlewares appended after RTK defaults and the
-   * persistence middleware.
-   */
-  extraMiddleware?: ReadonlyArray<SlamAppMiddleware>;
-  /**
-   * Invoked when the persistence middleware fails to durably write an action.
-   */
-  onWriteFailure?: (error: Error) => void;
-  /**
-   * Disables RTK's expensive dev-only middleware (Serializable / Immutable
-   * checks). Default `true`; set `false` for high-throughput replay scenarios.
-   */
-  enableDevChecks?: boolean;
-  /**
-   * License key for the core library. Defaults to the bundled community key.
-   * Apps with a paid license override here. Validation always runs and throws
-   * on invalid / expired / empty keys.
-   *
-   * @see EULA.md §3 — License Key
-   */
-  licenseKey?: string;
-}
-/**
- * Combined root state: the framework's base state plus any caller-supplied
- * extras. Generic so consumers get exact typing for the slices they add.
- */
-type SlamAppCombinedState<ExtraReducers extends ReducersMapObject = Record<never, never>> = SlamAppRootState & { [K in keyof ExtraReducers]: ExtraReducers[K] extends Reducer<infer S> ? S : never };
-/**
- * The store object returned by {@link createSlamAppStore}.
- *
- * Wraps RTK's store and adds storage-delegation helpers so consumers can
- * issue frame / metadata writes without holding a separate handle to the
- * `StorageBackend`.
- */
-interface SlamAppStore<ExtraReducers extends ReducersMapObject = Record<string, never>> {
-  getState: () => SlamAppCombinedState<ExtraReducers>;
-  dispatch: ReturnType<typeof configureStore>['dispatch'];
-  subscribe: (listener: () => void) => () => void;
-  /** Persist a captured camera frame via the configured backend. */
-  writeFrame: (blob: Blob, index: number) => Promise<void>;
-  /** Persist session metadata (`session.json`) via the configured backend. */
-  writeSessionMetadata: (metadata: SessionMetadata) => Promise<void>;
-}
-/**
- * Build a Redux store wired with library + recording slices, persistence
- * middleware, and any caller-supplied extras. See module docstring for the
- * design rationale.
- */
-declare function createSlamAppStore<ExtraReducers extends ReducersMapObject = Record<string, never>>(options: SlamAppStoreOptions<ExtraReducers>): SlamAppStore<ExtraReducers>;
-//#endregion
-export { SlamAppStoreOptions as a, SlamAppStore as i, SlamAppMiddleware as n, createSlamAppStore as o, SlamAppRootState as r, SlamAppCombinedState as t };

package/dist/gps-anchored-mesh-manager-CovAFK4g.d.ts

@@ -1,56 +0,0 @@
-import { LatLong } from "gps-plus-slam-js";
-
-//#region ../src/visualization/gps-anchored-mesh-manager.d.ts
-/**
- * Plain GPS-anchored item consumed by the manager. Callers project their
- * domain types (ref points, POIs, anchors, …) onto this shape.
- */
-interface GpsAnchoredItem {
-  readonly id: string;
-  readonly lat: number;
-  readonly lon: number;
-  readonly altitude?: number;
-}
-interface GpsAnchoredMeshManagerOptions {
-  /** Hex color for the shared material (e.g. `0x00ff00`). */
-  readonly color: number;
-  /** Sphere radius in meters. Defaults to `0.1` (10 cm). */
-  readonly radius?: number;
-  /** Mesh `name` prefix. Mesh names become `${namePrefix}-${item.id}`. */
-  readonly namePrefix: string;
-  /** Logger label. Defaults to `'GpsAnchoredMeshManager'`. */
-  readonly loggerLabel?: string;
-}
-/**
- * Manages a single colored mesh group anchored to GPS coordinates.
- * One instance == one color/group.
- */
-declare class GpsAnchoredMeshManager {
-  private readonly color;
-  private readonly radius;
-  private readonly namePrefix;
-  private readonly log;
-  private meshes;
-  private zeroRef;
-  private geometry;
-  private material;
-  constructor(options: GpsAnchoredMeshManagerOptions);
-  /** Set the GPS origin used to project items into local meters. */
-  setZeroRef(zero: LatLong): void;
-  getZeroRef(): LatLong | null;
-  /**
-   * Replace the entire mesh group with one mesh per provided item.
-   * Items without GPS or before `setZeroRef` are skipped.
-   */
-  setItems(items: readonly GpsAnchoredItem[]): void;
-  /** Append a single item to the existing mesh group. */
-  addItem(item: GpsAnchoredItem): void;
-  /** Remove all meshes and dispose the shared geometry/material. */
-  clear(): void;
-  /** Number of meshes currently rendered. */
-  getCount(): number;
-  /** Convenience: clear and forget the zero reference. */
-  dispose(): void;
-}
-//#endregion
-export { GpsAnchoredMeshManager as n, GpsAnchoredMeshManagerOptions as r, GpsAnchoredItem as t };

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

@@ -1,67 +0,0 @@
-import { LatLong, Vector3 } from "gps-plus-slam-js";
-
-//#region ../src/visualization/gps-event-markers.d.ts
-/**
- * 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
-   */
-  addGpsEvent(gpsCoords: Vector3, odomPosition: Vector3): 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;
-  };
-}
-/**
- * Singleton instance for global use.
- * Import this to visualize GPS events.
- */
-declare const gpsEventVisualizer: GpsEventVisualizer;
-//#endregion
-export { gpsEventVisualizer as n, GpsEventVisualizer as t };

package/dist/persistence-middleware-z-75iisb.d.ts

@@ -1,31 +0,0 @@
-import { n as StorageBackend } from "./storage-backend-yVnuWGTr.js";
-import { Middleware } from "@reduxjs/toolkit";
-
-//#region ../src/state/persistence-middleware.d.ts
-interface PersistenceMiddlewareOptions {
-  /**
-   * StorageBackend to use for action persistence.
-   */
-  storageBackend: StorageBackend;
-  /**
-   * Callback invoked when a write operation fails during persistence.
-   * User Feedback Issue #1 Part B: Used to show toast notifications.
-   */
-  onWriteFailure?: (error: Error) => void;
-}
-/**
- * Create a Redux middleware that persists qualifying actions to storage
- * during active recording sessions.
- *
- * Persistence rules:
- * - Only persists when `state.recording.isRecording` is true (checked AFTER
- *   the action is reduced, so `startSession` itself is included).
- * - Persists `gpsData/*` and `recording/*` actions.
- * - Excludes `recording/recordWriteFailure` to prevent recursive persistence.
- * - Excludes `routing/*`, `refPoints/*`, and any other non-recording actions.
- * - Uses 1-based indexing for action files (000001.json, 000002.json, …).
- * - Each middleware instance maintains its own action index (Bug 10 fix).
- */
-declare function createPersistenceMiddleware(options: PersistenceMiddlewareOptions): Middleware;
-//#endregion
-export { createPersistenceMiddleware as n, PersistenceMiddlewareOptions as t };

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

@@ -1,101 +0,0 @@
-import { t as ARPose } from "./ar-types-B-ORgk6Z.js";
-import { OdometryTrackingRestartedPayload, Quaternion, Vector3 } from "gps-plus-slam-js";
-
-//#region ../src/ar/tracking-state.d.ts
-/**
- * Possible tracking states
- */
-declare enum TrackingState {
-  /** AR session started but no pose received yet */
-  INITIALIZING = "initializing",
-  /** Actively receiving valid poses */
-  TRACKING = "tracking",
-  /** Pose became unavailable (tracking lost) */
-  LOST = "lost"
-}
-/**
- * Device orientation from sensors (for sensor rotation in restart payload)
- */
-interface DeviceOrientation {
-  alpha: number;
-  beta: number;
-  gamma: number;
-  absolute: boolean;
-}
-/**
- * Serialized representation of the XRReferenceSpaceEvent.transform.
- * The position and orientation of the new native origin expressed in
- * the pre-reset coordinate system.  `null` when the runtime cannot
- * determine the delta.
- */
-interface ResetTransformData {
-  position: Vector3;
-  orientation: Quaternion;
-}
-/**
- * Callbacks for tracking state changes
- */
-interface TrackingStateCallbacks {
-  /** Called when tracking is lost (pose became null) */
-  onTrackingLost: () => void;
-  /** Called when tracking resumes after a coordinate-frame reset (Case 2: relocalization) */
-  onTrackingRestarted: (payload: OdometryTrackingRestartedPayload) => void;
-  /** Called when tracking resumes seamlessly without origin reset (Case 1) */
-  onTrackingRecovered?: () => void;
-  /** Get current device orientation for sensor rotation */
-  getDeviceOrientation: () => DeviceOrientation;
-}
-/**
- * Manages AR tracking state and detects loss/restart events.
- */
-declare class TrackingStateManager {
-  private state;
-  private lastValidPose;
-  private lastSensorOrientation;
-  private lostFrameCount;
-  private originResetDuringLoss;
-  private resetTransform;
-  private callbacks;
-  constructor(callbacks: TrackingStateCallbacks);
-  /**
-   * Get current tracking state.
-   */
-  getState(): TrackingState;
-  /**
-   * Get the last valid AR pose (before tracking was lost).
-   */
-  getLastValidPose(): ARPose | null;
-  /**
-   * Get count of consecutive frames without pose (during LOST state).
-   */
-  getLostFrameCount(): number;
-  /**
-   * Flag that an XRReferenceSpace reset event occurred during tracking loss.
-   * Only meaningful while in LOST state — ignored otherwise.
-   *
-   * @param transform — Serialized XRReferenceSpaceEvent.transform (post-reset
-   *   origin in pre-reset coordinates).  Pass `null` when the event's
-   *   transform property is null (runtime can't determine delta).
-   *   Omit entirely for backwards-compat with callers that don't have it.
-   */
-  markOriginReset(transform?: ResetTransformData | null): void;
-  /**
-   * Called when a valid pose is received from WebXR.
-   */
-  onPoseReceived(pose: ARPose): void;
-  /**
-   * Called when pose is null/unavailable from WebXR.
-   */
-  onPoseLost(): void;
-  /**
-   * Reset the manager to initial state.
-   * Call this when starting a new session.
-   */
-  reset(): void;
-  /**
-   * Handle the transition from LOST to TRACKING (restart detected).
-   */
-  private handleTrackingRestarted;
-}
-//#endregion
-export { TrackingStateManager as a, TrackingStateCallbacks as i, ResetTransformData as n, TrackingState as r, DeviceOrientation as t };

package/dist/visualization/gps-anchored-mesh-manager.d.ts

@@ -1,2 +0,0 @@
-import { n as GpsAnchoredMeshManager, r as GpsAnchoredMeshManagerOptions, t as GpsAnchoredItem } from "../gps-anchored-mesh-manager-CovAFK4g.js";
-export { GpsAnchoredItem, GpsAnchoredMeshManager, GpsAnchoredMeshManagerOptions };

package/dist/visualization/gps-anchored-mesh-manager.js

@@ -1,128 +0,0 @@
-import { createLogger } from "../utils/logger.js";
-import { disposeMeshArray } from "./three-dispose.js";
-import { getScene } from "../ar/webxr-session.js";
-import * as THREE from "three";
-import { calcRelativeCoordsInMeters } from "gps-plus-slam-js";
-//#region ../src/visualization/gps-anchored-mesh-manager.ts
-/**
-* GPS-Anchored Mesh Manager
-*
-* Generic mechanism for placing Three.js meshes at GPS coordinates relative
-* to a configured GPS zero reference. This is the recorder-agnostic core
-* that was extracted in Iter 4 from the recorder-flavoured
-* `RefPointVisualizer` (which now lives in the RecorderApp and composes two
-* instances of this manager — prior=green, current=red).
-*
-* The manager is intentionally narrow: it knows how to convert
-* `{ lat, lon, altitude? }` into local meters via the framework's GPS zero
-* reference, allocate a single shared geometry + material per instance, and
-* keep the resulting mesh group in sync with caller-provided items. It does
-* not know anything about ref points, sessions, or recorder semantics.
-*/
-const DEFAULT_RADIUS = .1;
-/**
-* Manages a single colored mesh group anchored to GPS coordinates.
-* One instance == one color/group.
-*/
-var GpsAnchoredMeshManager = class {
-	color;
-	radius;
-	namePrefix;
-	log;
-	meshes = [];
-	zeroRef = null;
-	geometry = null;
-	material = null;
-	constructor(options) {
-		this.color = options.color;
-		this.radius = options.radius ?? DEFAULT_RADIUS;
-		this.namePrefix = options.namePrefix;
-		this.log = createLogger(options.loggerLabel ?? "GpsAnchoredMeshManager");
-	}
-	/** Set the GPS origin used to project items into local meters. */
-	setZeroRef(zero) {
-		this.zeroRef = zero;
-	}
-	getZeroRef() {
-		return this.zeroRef;
-	}
-	/**
-	* Replace the entire mesh group with one mesh per provided item.
-	* Items without GPS or before `setZeroRef` are skipped.
-	*/
-	setItems(items) {
-		if (!this.zeroRef) {
-			this.log.warn("No zero reference set");
-			return;
-		}
-		const scene = getScene();
-		if (!scene) {
-			this.log.warn("Scene not available");
-			return;
-		}
-		this.clear();
-		const geometry = this.geometry ??= new THREE.SphereGeometry(this.radius, 16, 16);
-		const material = this.material ??= new THREE.MeshBasicMaterial({ color: this.color });
-		let visibleCount = 0;
-		for (const item of items) {
-			const coords = calcRelativeCoordsInMeters(this.zeroRef, {
-				lat: item.lat,
-				lon: item.lon
-			}, item.altitude ?? 0, 0);
-			const mesh = new THREE.Mesh(geometry, material);
-			mesh.position.set(coords[0], coords[1], coords[2]);
-			mesh.name = `${this.namePrefix}-${item.id}`;
-			scene.add(mesh);
-			this.meshes.push(mesh);
-			visibleCount++;
-		}
-		this.log.info(`Displayed ${visibleCount}/${items.length} anchored meshes`);
-	}
-	/** Append a single item to the existing mesh group. */
-	addItem(item) {
-		if (!this.zeroRef) {
-			this.log.warn("Cannot add item — no zero reference");
-			return;
-		}
-		const scene = getScene();
-		if (!scene) {
-			this.log.warn("Scene not available");
-			return;
-		}
-		const geometry = this.geometry ??= new THREE.SphereGeometry(this.radius, 16, 16);
-		const material = this.material ??= new THREE.MeshBasicMaterial({ color: this.color });
-		const coords = calcRelativeCoordsInMeters(this.zeroRef, {
-			lat: item.lat,
-			lon: item.lon
-		}, item.altitude ?? 0, 0);
-		const mesh = new THREE.Mesh(geometry, material);
-		mesh.position.set(coords[0], coords[1], coords[2]);
-		mesh.name = `${this.namePrefix}-${item.id}`;
-		scene.add(mesh);
-		this.meshes.push(mesh);
-		this.log.info(`Added anchored mesh: ${item.id}`);
-	}
-	/** Remove all meshes and dispose the shared geometry/material. */
-	clear() {
-		const scene = getScene();
-		disposeMeshArray(this.meshes, scene, {
-			skipGeometry: true,
-			skipMaterial: true
-		});
-		this.geometry?.dispose();
-		this.geometry = null;
-		this.material?.dispose();
-		this.material = null;
-	}
-	/** Number of meshes currently rendered. */
-	getCount() {
-		return this.meshes.length;
-	}
-	/** Convenience: clear and forget the zero reference. */
-	dispose() {
-		this.clear();
-		this.zeroRef = null;
-	}
-};
-//#endregion
-export { GpsAnchoredMeshManager };