gps-plus-slam-app-framework 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+import { i as computeCaptureSize, n as CameraBlitCaptureConfig, r as DEFAULT_BLIT_CONFIG, t as CameraBlitCapture } from "./camera-blit-capture-DHuyrrxr.js";
+import { a as createCaptureFailureTracker, i as DEFAULT_CAPTURE_TRACKER_CONFIG, n as CaptureFailureTracker, r as CaptureFailureTrackerConfig, t as CAPTURE_FAILURE_WARNING } from "./capture-failure-tracker-2Q6oI2uQ.js";
+import { n as applyChromiumProjectionLayerWorkaround, t as ChromiumProjectionLayerWorkaroundResult } from "./chromium-camera-access-workaround-CU5zSKNr.js";
+import { a as WebXRQuaternion, i as DepthSample, n as ArPoseTuples, o as WebXRVec3, r as DepthPoint, t as ARPose } from "./ar-types-B-ORgk6Z.js";
+import { i as DepthSamplerConfig, n as DepthSampler, r as DepthSamplerCallbacks, t as DepthInfo } from "./depth-sampler-BNCtnEoP.js";
+import { a as ImageCaptureManager, i as ImageCaptureConfig, n as DEFAULT_CAPTURE_CONFIG, o as MIN_VALID_IMAGE_BYTES, r as ImageCaptureCallbacks, t as CapturedImage } from "./image-capture-2pKjYUS6.js";
+import { n as createCameraFollower, t as CameraFollower } from "./camera-follower-BMqPddxx.js";
+import { n as createAlignmentLerper, t as AlignmentLerper } from "./alignment-lerper-D9BeDwZX.js";
+import { n as createCss3dRendererManager, t as Css3dRendererManager } from "./css3d-renderer-manager-rgLMVAvd.js";
+import { a as getCameraFollower, c as getReplayState, d as updateOrbitTarget, i as getAlignmentLerper, l as initReplayScene, n as ReplaySceneState, o as getCameraMode, r as disposeReplayScene, t as CameraMode, u as toggleCameraMode } from "./replay-scene-DtUm6bsr.js";
+import { t as SCENE_NODE } from "./scene-node-names-DPsaE2z3.js";
+import { a as TrackingStateManager, i as TrackingStateCallbacks, r as TrackingState, t as DeviceOrientation } from "./tracking-state-B9QfuZCg.js";
+import { _ as validateRecordingOptions, a as IMAGE_CONSTRAINTS, c as RecordingOptionsInput, d as loadRecordingOptions, f as resetRecordingOptions, g as validateImageOptions, h as validateDepthOptions, i as DepthCaptureOptions, l as STORAGE_KEY, n as DEFAULT_RECORDING_OPTIONS, o as ImageCaptureOptions, p as saveRecordingOptions, r as DEPTH_CONSTRAINTS, s as RecordingOptions, u as cloneRecordingOptions } from "./recording-options-BYUFX8iU.js";
+import { i as acquireCameraTexture, n as RendererLike, r as XRCameraLike, t as CameraTextureResult } from "./xr-camera-texture-BbukNE79.js";
+import { A as setTrackingLostCallback, D as setImageCaptureCallback, E as setFrameCallback, F as stopDepthCapture, I as stopImageCapture, N as startDepthCapture, P as startImageCapture, T as setDepthCaptureCallback, d as getDepthSampleCount, f as getImageCaptureFrameCount, g as initAR, i as endARSession, k as setTrackingCallbacks, p as getLiveCss3dManager } from "./webxr-session-COlSrXdL.js";
+import { n as XR_ERROR_MESSAGE_UNKNOWN, r as getXrErrorMessage, t as XR_ERROR_MESSAGES } from "./xr-error-handler-DTHfmvrl.js";
+import { a as startOrientationWatch, i as startGpsWatch, n as RawDeviceOrientation, o as stopGpsWatch, r as requestOrientationPermission, s as stopOrientationWatch, t as GpsPosition } from "./gps-Ddzr2KlX.js";
+import { a as getGpsErrorMessage, i as createGpsErrorHandler, n as GPS_ERROR_MESSAGES, r as GPS_ERROR_MESSAGE_UNKNOWN, t as GPS_ERROR_CODES } from "./gps-error-handler-VPuNOuf8.js";
+import { a as checkFileSystemPermission, c as checkWebXRSupport, d as requestGeolocationPermission, f as requestOrientationPermission$1, h as setFileSystemState, i as checkCameraPermission, l as requestAllPermissions, m as resetFileSystemState, n as PermissionStatus, o as checkGeolocationPermission, p as requestWebXRWithDepthPermission, r as checkAllPermissions, s as checkOrientationPermission, t as PermissionCheckResult, u as requestCameraPermission } from "./permission-checker-jO2ziCWC.js";
+import { a as gpsToH3, i as findNearbyRefPoint, n as KnownRefPoint, o as h3RefsMatch, r as approxDistanceMetres, s as isH3Index, t as H3_RESOLUTION } from "./h3-ref-point-CFhayNSZ.js";
+import { a as createLogger, c as setGlobalLogLevel, i as clearLogBuffer, l as subscribeToLogs, n as LogLevel, o as getGlobalLogLevel, r as Logger, s as getLogBuffer, t as LogEntry } from "./logger-B81iwxx0.js";
+import { n as RefPointMarker, t as GpsCoord } from "./geo-types-Xx-LVcnw.js";
+import { n as computeFusedPath, r as fusedGpsFromOdom, t as FusedPathInput } from "./fused-path-DtqCSqJh.js";
+import { n as FailureTrackerConfig, r as createFailureTracker, t as FailureTracker } from "./failure-tracker-1sQ_Cgyw.js";
+import { t as mapWithConcurrencyLimit } from "./concurrency-p6gB30fT.js";
+import { t as formatFileSize } from "./format-file-size-onGq0k1Q.js";
+import { t as listFormatter } from "./list-formatter-DKQQVLcl.js";
+import { a as getScenarioHandle, c as initOpfsStorage, d as resetOpfsStorage, f as resetSessionHandles, i as createSession, o as getScenariosRootHandle, r as checkStorageQuota, s as getSessionHandle, t as CreateSessionResult, u as listSessions } from "./opfs-storage-ChOzF_Wp.js";
+import { t as StorageBackend } from "./storage-backend-BcEItnFr.js";
+import { a as recordWriteFailure, c as startSession, i as recordDepthSample, r as endSession, s as setCurrentScenarioName, t as RecorderState } from "./recorder-slice-fcwAXrsh.js";
+import { n as RefPointImportResult, r as importRefPointsFromFolder, t as ImportedRefPoint } from "./ref-point-importer-B_wn5ABk.js";
+import { a as resetRefPointsState, i as refPointsReducer, n as clearSessionRefPointUsage, o as selectCachedKnownRefPoints, r as incrementRefPointUsage, s as setImportedRefPoints } from "./ref-points-slice-tC-Wd6XJ.js";
+import { n as RoutingState, r as navigateTo, t as AppScreen } from "./routing-slice-BlHTM8eh.js";
+import { a as flattenRefPointsToMarks, c as loadRefPoint, i as averageGpsPerRefPoint, l as saveRefPointObservation, n as RefPointMark, o as listRefPointIds, r as RefPointObservation, s as loadAllRefPoints, t as RefPointDefinition } from "./ref-point-loader-Pt1smgHS.js";
+import { _ as setZeroPos, d as RootState, f as add2dImage, g as recordGpsEvent, h as markReferencePoint, l as RecorderStore, m as createRecorderStore, n as CombinedRootState, p as calcRelativeCoordsInMeters, t as AppDispatch, u as RecorderStoreOptions } from "./store-C7PKOj8S.js";
+import { a as eulerToQuaternion, c as getLastDeviceOrientation, i as createGpsPositionHandler, l as resetCoordinatorState, n as buildRawGpsPoint, o as extractOdomPosition, r as buildRecordGpsEventPayload, s as extractOdomRotation, t as RecordingCoordinatorConfig, u as updateDeviceOrientation } from "./recording-coordinator-DzflP07_.js";
+import { a as ZipActionEntry, i as RecordedAction, l as loadSessionMetadataFromBlob, n as GpsPathCoord, o as loadActionsFromZip, r as MAX_ACTION_FILE_SIZE, s as loadGpsPathFromBlob, u as readZipEntries } from "./zip-reader-D7pkpX8K.js";
+import { n as replayRecording } from "./recording-replayer-oOzPITrd.js";
+import { a as ReplayAction, c as computeInterActionDelay, i as ProgressCallback, l as extractActionTimestamp, n as DEFAULT_MAX_DELAY_MS, o as ReplayEngine, r as ErrorCallback, s as ReplayState, t as CompleteCallback } from "./replay-engine-DuX316ae.js";
+import { t as SubscribableStore } from "./subscribe-to-selector-UTZ0KkAc.js";
+import { n as wireStoreSubscribers, t as StoreSubscriberDeps } from "./store-subscribers-CuoIzB5T.js";
+import { t as NullStorageBackend } from "./null-storage-backend-CsWvQwN8.js";
+import { t as OpfsStorageBackend } from "./opfs-storage-backend-CVcmfJHN.js";
+import { a as initStorage, c as resetForNewSession, d as startSession$1, f as verifyWriteAccess, l as resetStorageState, m as writeFrame, n as WriteAccessResult, p as writeAction } from "./file-system-BsQgYCU3.js";
+import { n as formatFrameFilename, r as formatTimestamp, t as formatActionFilename } from "./file-system-utils-5cWO8Xyv.js";
+import { a as syncToExternalZip, i as exportSessionAsZip, n as downloadZip, r as exportAndDownloadSession, t as ZipExportResult } from "./zip-export-Rtpi75JJ.js";
+import { i as createGpsCompassCubes, n as COMPASS_CUBE_SIZE, r as GpsCompassCubes, t as COMPASS_CUBE_DISTANCE } from "./gps-compass-cubes-C-6JEnpR.js";
+import { n as gpsEventVisualizer, t as GpsEventVisualizer } from "./gps-event-markers-DpEy2qRd.js";
+import { a as DEFAULT_Z_OFFSET, n as DEFAULT_LEAFLET_MAP_SIZE_PX, o as LeafletMapOverlay, r as DEFAULT_WORLD_SIZE, s as LeafletMapOverlayOptions } from "./leaflet-map-overlay-CvfQXTye.js";
+import { n as clampedAlpha, t as DEFAULT_LERP_RATE } from "./lerp-utils-87NWjUOD.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-DuiZuCTx.js";
+import { n as refPointVisualizer, t as RefPointVisualizer } from "./reference-points-CFWy8_wj.js";
+import { n as disposeMeshArray, r as disposeObject3D, t as DisposeOptions } from "./three-dispose-CCBHjE_a.js";
+import { t as VIS_COLORS } from "./vis-colors-Qi2vlRGt.js";
+import { t as COMMUNITY_LICENSE_KEY } from "./community-license-key-ChZLCJyO.js";
+export { ARPose, AlignmentLerper, type AppDispatch, type AppScreen, ArPoseTuples, CAPTURE_FAILURE_WARNING, COMMUNITY_LICENSE_KEY, COMPASS_CUBE_DISTANCE, COMPASS_CUBE_SIZE, CameraBlitCapture, CameraBlitCaptureConfig, CameraFollower, CameraMode, CameraTextureResult, CaptureFailureTracker, CaptureFailureTrackerConfig, CapturedImage, ChromiumProjectionLayerWorkaroundResult, type CombinedRootState, type CompleteCallback, type CreateSessionResult, Css3dRendererManager, DEFAULT_BLIT_CONFIG, DEFAULT_CAPTURE_CONFIG, DEFAULT_CAPTURE_TRACKER_CONFIG, DEFAULT_HEIGHT_OFFSET, DEFAULT_LEAFLET_MAP_SIZE_PX, DEFAULT_LERP_RATE, DEFAULT_MAP_SIZE, DEFAULT_MAX_DELAY_MS, DEFAULT_RECORDING_OPTIONS, DEFAULT_WORLD_SIZE, DEFAULT_ZOOM, DEFAULT_Z_OFFSET, DEPTH_CONSTRAINTS, type DepthCaptureOptions, DepthInfo, DepthPoint, DepthSample, DepthSampler, DepthSamplerCallbacks, DepthSamplerConfig, DeviceOrientation, DisposeOptions, type ErrorCallback, FailureTracker, FailureTrackerConfig, FusedPathInput, GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, GpsCompassCubes, GpsCoord, GpsEventVisualizer, type GpsPathCoord, GpsPosition, H3_RESOLUTION, IMAGE_CONSTRAINTS, ImageCaptureCallbacks, ImageCaptureConfig, ImageCaptureManager, type ImageCaptureOptions, type ImportedRefPoint, KnownRefPoint, LeafletMapOverlay, LeafletMapOverlayOptions, LogEntry, LogLevel, Logger, MAX_ACTION_FILE_SIZE, MIN_VALID_IMAGE_BYTES, MapOverlay, MapOverlayOptions, NullStorageBackend, OpfsStorageBackend, PermissionCheckResult, PermissionStatus, type ProgressCallback, RawDeviceOrientation, type RecordedAction, type RecorderState, type RecorderStore, type RecorderStoreOptions, type RecordingCoordinatorConfig, type RecordingOptions, type RecordingOptionsInput, type RefPointDefinition, type RefPointImportResult, type RefPointMark, RefPointMarker, type RefPointObservation, RefPointVisualizer, RendererLike, type ReplayAction, ReplayEngine, ReplaySceneState, type ReplayState, type RootState, type RoutingState, SCENE_NODE, STORAGE_KEY, type StorageBackend, type StoreSubscriberDeps, type SubscribableStore, TextureLoaderInterface, TrackingState, TrackingStateCallbacks, TrackingStateManager, VIS_COLORS, WebXRQuaternion, WebXRVec3, type WriteAccessResult, XRCameraLike, XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, type ZipActionEntry, type ZipExportResult, acquireCameraTexture, add2dImage, applyChromiumProjectionLayerWorkaround, approxDistanceMetres, averageGpsPerRefPoint, buildRawGpsPoint, buildRecordGpsEventPayload, calcRelativeCoordsInMeters, checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkStorageQuota, checkWebXRSupport, clampedAlpha, clearLogBuffer, clearSessionRefPointUsage, cloneRecordingOptions, computeCaptureSize, computeFusedPath, computeInterActionDelay, createAlignmentLerper, createCameraFollower, createCaptureFailureTracker, createCss3dRendererManager, createFailureTracker, createGpsCompassCubes, createGpsErrorHandler, createGpsPositionHandler, createLogger, createRecorderStore, createSession, disposeMeshArray, disposeObject3D, disposeReplayScene, downloadZip, endARSession, endSession, eulerToQuaternion, exportAndDownloadSession, exportSessionAsZip, extractActionTimestamp, extractOdomPosition, extractOdomRotation, findNearbyRefPoint, flattenRefPointsToMarks, formatActionFilename, formatFileSize, formatFrameFilename, formatTimestamp, fusedGpsFromOdom, getAlignmentLerper, getCameraFollower, getCameraMode, getDepthSampleCount, getGlobalLogLevel, getGpsErrorMessage, getImageCaptureFrameCount, getLastDeviceOrientation, getLiveCss3dManager, getLogBuffer, getReplayState, getScenarioHandle, getScenariosRootHandle, getSessionHandle, getXrErrorMessage, gpsEventVisualizer, gpsToH3, h3RefsMatch, importRefPointsFromFolder, incrementRefPointUsage, initAR, initOpfsStorage, initReplayScene, initStorage, isH3Index, latLonToTileXY, listFormatter, listRefPointIds, listSessions, loadActionsFromZip, loadAllRefPoints, loadGpsPathFromBlob, loadRecordingOptions, loadRefPoint, loadSessionMetadataFromBlob, mapWithConcurrencyLimit, markReferencePoint, navigateTo, readZipEntries, recordDepthSample, recordGpsEvent, recordWriteFailure, refPointVisualizer, refPointsReducer, replayRecording, requestAllPermissions, requestCameraPermission, requestOrientationPermission as requestDeviceOrientationPermission, requestGeolocationPermission, requestOrientationPermission$1 as requestOrientationPermission, requestWebXRWithDepthPermission, resetCoordinatorState, resetFileSystemState, resetForNewSession, resetOpfsStorage, resetRecordingOptions, resetRefPointsState, resetSessionHandles, resetStorageState, saveRecordingOptions, saveRefPointObservation, selectCachedKnownRefPoints, setCurrentScenarioName, setDepthCaptureCallback, setFileSystemState, setFrameCallback, setGlobalLogLevel, setImageCaptureCallback, setImportedRefPoints, setTrackingCallbacks, setTrackingLostCallback, setZeroPos, startDepthCapture, startGpsWatch, startImageCapture, startOrientationWatch, startSession, startSession$1 as startStorageSession, stopDepthCapture, stopGpsWatch, stopImageCapture, stopOrientationWatch, subscribeToLogs, syncToExternalZip, tileXYToLatLon, toggleCameraMode, updateDeviceOrientation, updateOrbitTarget, validateDepthOptions, validateImageOptions, validateRecordingOptions, verifyWriteAccess, wireStoreSubscribers, writeAction, writeFrame };

package/dist/index.js

@@ -0,0 +1,61 @@
+import { LogLevel, clearLogBuffer, createLogger, getGlobalLogLevel, getLogBuffer, setGlobalLogLevel, subscribeToLogs } from "./utils/logger.js";
+import { disposeMeshArray, disposeObject3D } from "./visualization/three-dispose.js";
+import { CameraBlitCapture, DEFAULT_BLIT_CONFIG, computeCaptureSize } from "./ar/camera-blit-capture.js";
+import { applyChromiumProjectionLayerWorkaround } from "./ar/chromium-camera-access-workaround.js";
+import { createFailureTracker } from "./utils/failure-tracker.js";
+import { CAPTURE_FAILURE_WARNING, DEFAULT_CAPTURE_TRACKER_CONFIG, createCaptureFailureTracker } from "./ar/capture-failure-tracker.js";
+import { endSession, recordDepthSample, recordWriteFailure, setCurrentScenarioName, startSession } from "./state/recorder-slice.js";
+import { H3_RESOLUTION, approxDistanceMetres, findNearbyRefPoint, gpsToH3, h3RefsMatch, isH3Index } from "./ref-points/h3-ref-point.js";
+import { clearSessionRefPointUsage, incrementRefPointUsage, refPointsReducer, resetRefPointsState, selectCachedKnownRefPoints, setImportedRefPoints } from "./state/ref-points-slice.js";
+import { navigateTo } from "./state/routing-slice.js";
+import { checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkWebXRSupport, requestAllPermissions, requestCameraPermission, requestGeolocationPermission, requestOrientationPermission as requestOrientationPermission$1, requestWebXRWithDepthPermission, resetFileSystemState, setFileSystemState } from "./sensors/permission-checker.js";
+import { formatActionFilename, formatFrameFilename, formatTimestamp } from "./storage/file-system-utils.js";
+import { checkStorageQuota, createSession, getScenarioHandle, getScenariosRootHandle, getSessionHandle, initOpfsStorage, listSessions, resetOpfsStorage, resetSessionHandles } from "./storage/opfs-storage.js";
+import { initStorage, resetForNewSession, resetStorageState, startSession as startSession$1, verifyWriteAccess, writeAction, writeFrame } from "./storage/file-system.js";
+import { OpfsStorageBackend } from "./storage/opfs-storage-backend.js";
+import { COMMUNITY_LICENSE_KEY } from "./licensing/community-license-key.js";
+import { add2dImage, calcRelativeCoordsInMeters, createRecorderStore, markReferencePoint, recordGpsEvent, setZeroPos } from "./state/store.js";
+import { buildRawGpsPoint, buildRecordGpsEventPayload, createGpsPositionHandler, eulerToQuaternion, extractOdomPosition, extractOdomRotation, getLastDeviceOrientation, resetCoordinatorState, updateDeviceOrientation } from "./state/recording-coordinator.js";
+import { DepthSampler } from "./ar/depth-sampler.js";
+import { DEFAULT_CAPTURE_CONFIG, ImageCaptureManager, MIN_VALID_IMAGE_BYTES } from "./ar/image-capture.js";
+import { TrackingState, TrackingStateManager } from "./ar/tracking-state.js";
+import { acquireCameraTexture } from "./ar/xr-camera-texture.js";
+import { DEFAULT_RECORDING_OPTIONS, DEPTH_CONSTRAINTS, IMAGE_CONSTRAINTS, STORAGE_KEY, cloneRecordingOptions, loadRecordingOptions, resetRecordingOptions, saveRecordingOptions, validateDepthOptions, validateImageOptions, validateRecordingOptions } from "./state/recording-options.js";
+import { SCENE_NODE } from "./ar/scene-node-names.js";
+import { createCss3dRendererManager } from "./visualization/css3d-renderer-manager.js";
+import { endARSession, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, initAR, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setTrackingCallbacks, setTrackingLostCallback, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture } from "./ar/webxr-session.js";
+import { DEFAULT_LERP_RATE, clampedAlpha } from "./visualization/lerp-utils.js";
+import { createCameraFollower } from "./visualization/camera-follower.js";
+import { createAlignmentLerper } from "./visualization/alignment-lerper.js";
+import { VIS_COLORS } from "./visualization/vis-colors.js";
+import { COMPASS_CUBE_DISTANCE, COMPASS_CUBE_SIZE, createGpsCompassCubes } from "./visualization/gps-compass-cubes.js";
+import { disposeReplayScene, getAlignmentLerper, getCameraFollower, getCameraMode, getReplayState, initReplayScene, toggleCameraMode, updateOrbitTarget } from "./ar/replay-scene.js";
+import { XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, getXrErrorMessage } from "./ar/xr-error-handler.js";
+import "./ar/index.js";
+import { requestOrientationPermission, startGpsWatch, startOrientationWatch, stopGpsWatch, stopOrientationWatch } from "./sensors/gps.js";
+import { GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, createGpsErrorHandler, getGpsErrorMessage } from "./sensors/gps-error-handler.js";
+import "./sensors/index.js";
+import "./ref-points/index.js";
+import { computeFusedPath, fusedGpsFromOdom } from "./utils/fused-path.js";
+import { mapWithConcurrencyLimit } from "./utils/concurrency.js";
+import { formatFileSize } from "./utils/format-file-size.js";
+import { listFormatter } from "./utils/list-formatter.js";
+import "./utils/index.js";
+import "./types/index.js";
+import { MAX_ACTION_FILE_SIZE, loadActionsFromZip, loadGpsPathFromBlob, loadSessionMetadataFromBlob, readZipEntries } from "./storage/zip-reader.js";
+import { NullStorageBackend } from "./storage/null-storage-backend.js";
+import { replayRecording } from "./state/recording-replayer.js";
+import { DEFAULT_MAX_DELAY_MS, ReplayEngine, computeInterActionDelay, extractActionTimestamp } from "./state/replay-engine.js";
+import { wireStoreSubscribers } from "./state/store-subscribers.js";
+import "./state/index.js";
+import { importRefPointsFromFolder } from "./storage/ref-point-importer.js";
+import { averageGpsPerRefPoint, flattenRefPointsToMarks, listRefPointIds, loadAllRefPoints, loadRefPoint, saveRefPointObservation } from "./storage/ref-point-loader.js";
+import { downloadZip, exportAndDownloadSession, exportSessionAsZip, syncToExternalZip } from "./storage/zip-export.js";
+import "./storage/index.js";
+import { GpsEventVisualizer, gpsEventVisualizer } from "./visualization/gps-event-markers.js";
+import { DEFAULT_LEAFLET_MAP_SIZE_PX, DEFAULT_WORLD_SIZE, DEFAULT_Z_OFFSET, LeafletMapOverlay } from "./visualization/leaflet-map-overlay.js";
+import { DEFAULT_HEIGHT_OFFSET, DEFAULT_MAP_SIZE, DEFAULT_ZOOM, MapOverlay, latLonToTileXY, tileXYToLatLon } from "./visualization/map-overlay.js";
+import { RefPointVisualizer, refPointVisualizer } from "./visualization/reference-points.js";
+import "./visualization/index.js";
+import "./licensing/index.js";
+export { CAPTURE_FAILURE_WARNING, COMMUNITY_LICENSE_KEY, COMPASS_CUBE_DISTANCE, COMPASS_CUBE_SIZE, CameraBlitCapture, DEFAULT_BLIT_CONFIG, DEFAULT_CAPTURE_CONFIG, DEFAULT_CAPTURE_TRACKER_CONFIG, DEFAULT_HEIGHT_OFFSET, DEFAULT_LEAFLET_MAP_SIZE_PX, DEFAULT_LERP_RATE, DEFAULT_MAP_SIZE, DEFAULT_MAX_DELAY_MS, DEFAULT_RECORDING_OPTIONS, DEFAULT_WORLD_SIZE, DEFAULT_ZOOM, DEFAULT_Z_OFFSET, DEPTH_CONSTRAINTS, DepthSampler, GPS_ERROR_CODES, GPS_ERROR_MESSAGES, GPS_ERROR_MESSAGE_UNKNOWN, GpsEventVisualizer, H3_RESOLUTION, IMAGE_CONSTRAINTS, ImageCaptureManager, LeafletMapOverlay, LogLevel, MAX_ACTION_FILE_SIZE, MIN_VALID_IMAGE_BYTES, MapOverlay, NullStorageBackend, OpfsStorageBackend, RefPointVisualizer, ReplayEngine, SCENE_NODE, STORAGE_KEY, TrackingState, TrackingStateManager, VIS_COLORS, XR_ERROR_MESSAGES, XR_ERROR_MESSAGE_UNKNOWN, acquireCameraTexture, add2dImage, applyChromiumProjectionLayerWorkaround, approxDistanceMetres, averageGpsPerRefPoint, buildRawGpsPoint, buildRecordGpsEventPayload, calcRelativeCoordsInMeters, checkAllPermissions, checkCameraPermission, checkFileSystemPermission, checkGeolocationPermission, checkOrientationPermission, checkStorageQuota, checkWebXRSupport, clampedAlpha, clearLogBuffer, clearSessionRefPointUsage, cloneRecordingOptions, computeCaptureSize, computeFusedPath, computeInterActionDelay, createAlignmentLerper, createCameraFollower, createCaptureFailureTracker, createCss3dRendererManager, createFailureTracker, createGpsCompassCubes, createGpsErrorHandler, createGpsPositionHandler, createLogger, createRecorderStore, createSession, disposeMeshArray, disposeObject3D, disposeReplayScene, downloadZip, endARSession, endSession, eulerToQuaternion, exportAndDownloadSession, exportSessionAsZip, extractActionTimestamp, extractOdomPosition, extractOdomRotation, findNearbyRefPoint, flattenRefPointsToMarks, formatActionFilename, formatFileSize, formatFrameFilename, formatTimestamp, fusedGpsFromOdom, getAlignmentLerper, getCameraFollower, getCameraMode, getDepthSampleCount, getGlobalLogLevel, getGpsErrorMessage, getImageCaptureFrameCount, getLastDeviceOrientation, getLiveCss3dManager, getLogBuffer, getReplayState, getScenarioHandle, getScenariosRootHandle, getSessionHandle, getXrErrorMessage, gpsEventVisualizer, gpsToH3, h3RefsMatch, importRefPointsFromFolder, incrementRefPointUsage, initAR, initOpfsStorage, initReplayScene, initStorage, isH3Index, latLonToTileXY, listFormatter, listRefPointIds, listSessions, loadActionsFromZip, loadAllRefPoints, loadGpsPathFromBlob, loadRecordingOptions, loadRefPoint, loadSessionMetadataFromBlob, mapWithConcurrencyLimit, markReferencePoint, navigateTo, readZipEntries, recordDepthSample, recordGpsEvent, recordWriteFailure, refPointVisualizer, refPointsReducer, replayRecording, requestAllPermissions, requestCameraPermission, requestOrientationPermission as requestDeviceOrientationPermission, requestGeolocationPermission, requestOrientationPermission$1 as requestOrientationPermission, requestWebXRWithDepthPermission, resetCoordinatorState, resetFileSystemState, resetForNewSession, resetOpfsStorage, resetRecordingOptions, resetRefPointsState, resetSessionHandles, resetStorageState, saveRecordingOptions, saveRefPointObservation, selectCachedKnownRefPoints, setCurrentScenarioName, setDepthCaptureCallback, setFileSystemState, setFrameCallback, setGlobalLogLevel, setImageCaptureCallback, setImportedRefPoints, setTrackingCallbacks, setTrackingLostCallback, setZeroPos, startDepthCapture, startGpsWatch, startImageCapture, startOrientationWatch, startSession, startSession$1 as startStorageSession, stopDepthCapture, stopGpsWatch, stopImageCapture, stopOrientationWatch, subscribeToLogs, syncToExternalZip, tileXYToLatLon, toggleCameraMode, updateDeviceOrientation, updateOrbitTarget, validateDepthOptions, validateImageOptions, validateRecordingOptions, verifyWriteAccess, wireStoreSubscribers, writeAction, writeFrame };

package/dist/leaflet-map-overlay-CvfQXTye.d.ts

@@ -0,0 +1,114 @@
+import * as THREE from "three";
+import { LatLong } from "gps-plus-slam-js";
+import L from "leaflet";
+
+//#region ../src/visualization/leaflet-map-overlay.d.ts
+/** Default pixel size of the Leaflet map container */
+declare const DEFAULT_LEAFLET_MAP_SIZE_PX = 600;
+/** Default world-space size in meters (matches old MapOverlay) */
+declare const DEFAULT_WORLD_SIZE = 10;
+/** Default height offset below camera (negative = below) */
+declare const DEFAULT_HEIGHT_OFFSET = -4;
+/** Default forward offset from parent (negative = forward in parent-local Z) */
+declare const DEFAULT_Z_OFFSET = -1;
+/** Default zoom level for the Leaflet map */
+declare const DEFAULT_ZOOM = 17;
+/**
+ * Configuration options for the Leaflet map overlay.
+ */
+interface LeafletMapOverlayOptions {
+  /** Pixel dimensions of the Leaflet map container (default: 600). */
+  readonly mapSizePx?: number;
+  /** World-space size in meters (default: 10). */
+  readonly worldSize?: number;
+  /** Height offset below parent in meters (default: -4). */
+  readonly heightOffset?: number;
+  /** Initial Leaflet zoom level (default: 17). */
+  readonly zoomLevel?: number;
+  /** Tile server URL template (default: OSM). */
+  readonly tileServerUrl?: string;
+  /**
+   * Object3D to attach the CSS3DObject to instead of the camera.
+   * Use CameraFollower.object3D for GPS-world-aligned map.
+   */
+  readonly mapParent?: THREE.Object3D;
+  /** Called when a map tile fails to load (e.g., offline, server error). */
+  readonly onTileError?: (error: unknown) => void;
+  /**
+   * DOM element to append the off-screen Leaflet container to.
+   * Defaults to `document.body`. In multi-instance or shadow-DOM scenarios
+   * pass a scoped element to avoid injecting nodes into `<body>`.
+   */
+  readonly offscreenRoot?: HTMLElement;
+}
+declare class LeafletMapOverlay {
+  private scene;
+  private camera;
+  private readonly mapParent;
+  private readonly worldSize;
+  private readonly heightOffset;
+  private readonly mapSizePx;
+  private readonly tileServerUrl;
+  private readonly onTileError?;
+  private readonly offscreenRoot;
+  private zoomLevel;
+  private gpsPosition;
+  private visible;
+  private mapContainer;
+  private leafletMap;
+  private tileLayer;
+  private cssObject;
+  private rawGpsPoints;
+  private fusedPoints;
+  private snapshotPoints;
+  private refPoints;
+  private userMarker;
+  private rawGpsPolyline;
+  private fusedPolyline;
+  private snapshotPolyline;
+  constructor(scene: THREE.Scene, camera: THREE.Camera, options?: LeafletMapOverlayOptions);
+  setGpsPosition(lat: number, lon: number): void;
+  getGpsPosition(): LatLong | null;
+  show(): void;
+  hide(): void;
+  toggle(): void;
+  isVisible(): boolean;
+  addRawGpsPoint(lat: number, lon: number): void;
+  addFusedPoint(lat: number, lon: number): void;
+  addAlignmentSnapshot(lat: number, lon: number): void;
+  addRefPoint(lat: number, lon: number, name: string): void;
+  addPriorRefPoint(lat: number, lon: number, name: string): void;
+  addPriorRefPoints(refPoints: Array<{
+    lat: number;
+    lon: number;
+    name: string;
+  }>): void;
+  clearPriorRefPoints(): void;
+  setZoomLevel(zoom: number): void;
+  getZoomLevel(): number;
+  /** Increment zoom level by 1 (clamped at MAX_ZOOM). */
+  zoomIn(): void;
+  /** Decrement zoom level by 1 (clamped at MIN_ZOOM). */
+  zoomOut(): void;
+  getWorldSize(): number;
+  getHeightOffset(): number;
+  getMapSizePx(): number;
+  /** Expose the Leaflet map instance for testing and advanced usage. */
+  getLeafletMap(): L.Map | null;
+  /**
+   * No-op — kept for backward compatibility with the frame-loop call
+   * in main.ts. The CSS3DObject is a child of the parent, so Three.js
+   * scene graph propagation handles positioning automatically.
+   */
+  updatePosition(): void;
+  dispose(): void;
+  private createLeafletMap;
+  private destroyLeafletMap;
+  private createCssObject;
+  private removeCssObject;
+  private applyBufferedOverlays;
+  private updateUserMarker;
+  private createRefPointMarker;
+}
+//#endregion
+export { DEFAULT_Z_OFFSET as a, DEFAULT_ZOOM as i, DEFAULT_LEAFLET_MAP_SIZE_PX as n, LeafletMapOverlay as o, DEFAULT_WORLD_SIZE as r, LeafletMapOverlayOptions as s, DEFAULT_HEIGHT_OFFSET as t };

package/dist/lerp-utils-87NWjUOD.d.ts

@@ -0,0 +1,20 @@
+//#region ../src/visualization/lerp-utils.d.ts
+/**
+ * Shared lerp utilities for visualization modules.
+ *
+ * Both alignment-lerper and camera-follower need the same smoothing
+ * rate constant and clamped-alpha formula. Centralised here (R3) to
+ * keep the two modules in sync.
+ */
+/** Default speed multiplier — ~90 % convergence in ~0.3 s at 60 fps. */
+declare const DEFAULT_LERP_RATE = 8;
+/**
+ * Compute a frame-rate-independent lerp/slerp factor clamped to [0, 1].
+ *
+ * @param lerpRate Speed multiplier (higher = faster convergence).
+ * @param dt       Delta time in seconds since last frame.
+ * @returns The interpolation alpha, guaranteed ≤ 1.0.
+ */
+declare function clampedAlpha(lerpRate: number, dt: number): number;
+//#endregion
+export { clampedAlpha as n, DEFAULT_LERP_RATE as t };

package/dist/licensing/community-license-key.d.ts

@@ -0,0 +1,2 @@
+import { t as COMMUNITY_LICENSE_KEY } from "../community-license-key-ChZLCJyO.js";
+export { COMMUNITY_LICENSE_KEY };

package/dist/licensing/community-license-key.js

@@ -0,0 +1,21 @@
+//#region ../src/licensing/community-license-key.ts
+/**
+* Community license key for the gps-plus-slam-js core library.
+*
+* Generated by the core library maintainers and bundled with the open-source
+* `gps-plus-slam-app-framework` package so that every example app (and any
+* downstream app built on the framework) automatically uses a valid license
+* without per-developer registration.
+*
+* The key has a rolling expiration of 12 months. Each release of the
+* open-source packages renews it. Active users who regularly update their
+* dependencies will never be affected by the expiration.
+*
+* For licenses with extended validity beyond the community key's scope,
+* contact support@csutil.com.
+*
+* @see GpsPlusSlamJs/EULA.md §3 — License Key
+*/
+const COMMUNITY_LICENSE_KEY = "eyJ0eXBlIjoiY29tbXVuaXR5IiwiZXhwIjoxODA4NzcyNDI3fQ.YYNf0IdqniZdMzRXCuvewxsQQ01XNywrKsfL5IpiJotfFJfqtrGg4u9z0QFhXeszPtUhnvgC8_oOnbOkbXPuAw";
+//#endregion
+export { COMMUNITY_LICENSE_KEY };

package/dist/licensing/index.d.ts

@@ -0,0 +1,2 @@
+import { t as COMMUNITY_LICENSE_KEY } from "../community-license-key-ChZLCJyO.js";
+export { COMMUNITY_LICENSE_KEY };

package/dist/licensing/index.js

@@ -0,0 +1,2 @@
+import { COMMUNITY_LICENSE_KEY } from "./community-license-key.js";
+export { COMMUNITY_LICENSE_KEY };

package/dist/list-formatter-DKQQVLcl.d.ts

@@ -0,0 +1,14 @@
+//#region ../src/utils/list-formatter.d.ts
+/**
+ * Shared list formatter for displaying comma-separated lists with "and".
+ *
+ * Uses English locale to match the app's UI language. If i18n support is added
+ * in the future, this should be updated to use the user's preferred locale.
+ *
+ * @example
+ * listFormatter.format(['Camera', 'Location']) // "Camera and Location"
+ * listFormatter.format(['A', 'B', 'C']) // "A, B, and C"
+ */
+declare const listFormatter: Intl.ListFormat;
+//#endregion
+export { listFormatter as t };

package/dist/logger-B81iwxx0.d.ts

@@ -0,0 +1,74 @@
+//#region ../src/utils/logger.d.ts
+/**
+ * Configurable Logger Utility
+ *
+ * Provides a simple logging API with configurable log levels.
+ * This allows disabling verbose logging in production while keeping
+ * it available for development and debugging.
+ *
+ * Also maintains an in-memory ring buffer of recent log entries
+ * for display in the expandable log panel UI.
+ *
+ * Sentry Integration:
+ * - All log levels add Sentry breadcrumbs for debugging context
+ * - log.error() with Error objects automatically reports to Sentry
+ */
+/**
+ * Log levels in order of verbosity (lower = more verbose)
+ */
+declare enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+  SILENT = 4
+}
+/**
+ * Structure for a single log entry in the buffer
+ */
+interface LogEntry {
+  readonly timestamp: number;
+  readonly level: LogLevel;
+  readonly tag: string;
+  readonly message: string;
+}
+/**
+ * Subscribers that get notified when new log entries are added
+ */
+type LogSubscriber = (entry: LogEntry) => void;
+/**
+ * Get a copy of the current log buffer
+ * @returns Array of log entries (copy to prevent external mutation)
+ */
+declare function getLogBuffer(): LogEntry[];
+/**
+ * Clear all entries from the log buffer
+ */
+declare function clearLogBuffer(): void;
+/**
+ * Subscribe to new log entries
+ * @param callback - Function called when a new log entry is added
+ * @returns Unsubscribe function
+ */
+declare function subscribeToLogs(callback: LogSubscriber): () => void;
+/**
+ * Set the global log level
+ * @param level - The minimum level to log
+ */
+declare function setGlobalLogLevel(level: LogLevel): void;
+/**
+ * Get the current global log level
+ */
+declare function getGlobalLogLevel(): LogLevel;
+/**
+ * Logger interface for type safety
+ */
+interface Logger {
+  debug: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+}
+declare function createLogger(tag: string): Logger;
+//#endregion
+export { createLogger as a, setGlobalLogLevel as c, clearLogBuffer as i, subscribeToLogs as l, LogLevel as n, getGlobalLogLevel as o, Logger as r, getLogBuffer as s, LogEntry as t };

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

@@ -0,0 +1,153 @@
+import * as THREE from "three";
+import { LatLong } from "gps-plus-slam-js";
+
+//#region ../src/visualization/map-overlay.d.ts
+/** Default zoom level for OSM tiles (higher = more detail, smaller area) */
+declare const DEFAULT_ZOOM = 17;
+/** Default map size in meters */
+declare const DEFAULT_MAP_SIZE = 10;
+/** Default height offset below camera (negative = below) */
+declare const DEFAULT_HEIGHT_OFFSET = -4;
+/**
+ * Interface for loading textures (allows mocking in tests).
+ */
+interface TextureLoaderInterface {
+  load(url: string, onLoad?: (texture: THREE.Texture) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): THREE.Texture;
+}
+/**
+ * Configuration options for the map overlay.
+ */
+interface MapOverlayOptions {
+  /** Size of the map in meters (default: 10) */
+  readonly mapSize?: number;
+  /** Height offset below camera in meters (default: -4) */
+  readonly heightOffset?: number;
+  /** OSM zoom level 0-19 (default: 17) */
+  readonly zoomLevel?: number;
+  /** Base URL for tile server (default: OSM) */
+  readonly tileServerUrl?: string;
+  /** Custom texture loader (for testing) */
+  readonly textureLoader?: TextureLoaderInterface;
+  /** Called when a map tile fails to load (e.g., offline, server error) */
+  readonly onTileError?: (error: unknown) => void;
+  /**
+   * Object3D to attach the map mesh to instead of the camera.
+   * When provided, the mesh is added to mapParent (e.g., a CameraFollower)
+   * so the map stays GPS-world-aligned and does not rotate with the camera.
+   * Defaults to camera when not provided (backward-compatible).
+   */
+  readonly mapParent?: THREE.Object3D;
+}
+/**
+ * Convert latitude/longitude to tile X/Y coordinates.
+ * Uses Web Mercator projection (EPSG:3857).
+ *
+ * @param lat - Latitude in degrees
+ * @param lon - Longitude in degrees
+ * @param zoom - Zoom level (0-19)
+ * @returns [tileX, tileY] as integers
+ */
+declare function latLonToTileXY(lat: number, lon: number, zoom: number): [number, number];
+/**
+ * Convert tile X/Y coordinates back to latitude/longitude.
+ * Returns the top-left corner of the tile.
+ *
+ * @param x - Tile X coordinate
+ * @param y - Tile Y coordinate
+ * @param zoom - Zoom level
+ * @returns [lat, lon] in degrees
+ */
+declare function tileXYToLatLon(x: number, y: number, zoom: number): [number, number];
+/**
+ * Interactive 3D map overlay that displays OSM tiles in the AR scene.
+ * The map floats below the user and follows their horizontal movement.
+ */
+declare class MapOverlay {
+  private scene;
+  private camera;
+  private options;
+  private onTileError?;
+  private mapParent;
+  private mesh;
+  private material;
+  private geometry;
+  private textureLoader;
+  private gpsPosition;
+  private currentTile;
+  private visible;
+  /**
+   * Create a new map overlay.
+   *
+   * @param scene - The Three.js scene to add the map to
+   * @param camera - The camera to follow (for positioning)
+   * @param options - Configuration options
+   */
+  constructor(scene: THREE.Scene, camera: THREE.Camera, options?: MapOverlayOptions);
+  /**
+   * Set the current GPS position for tile loading.
+   *
+   * @param lat - Latitude in degrees
+   * @param lon - Longitude in degrees
+   */
+  setGpsPosition(lat: number, lon: number): void;
+  /**
+   * Get the current GPS position.
+   */
+  getGpsPosition(): LatLong | null;
+  /**
+   * Show the map overlay.
+   * Requires GPS position to be set first.
+   */
+  show(): void;
+  /**
+   * Hide the map overlay.
+   */
+  hide(): void;
+  /**
+   * Toggle map visibility.
+   */
+  toggle(): void;
+  /**
+   * Check if the map is currently visible.
+   */
+  isVisible(): boolean;
+  /**
+   * Get the map size in meters.
+   */
+  getMapSize(): number;
+  /**
+   * Get the height offset below camera.
+   */
+  getHeightOffset(): number;
+  /**
+   * Get the mesh (for testing).
+   */
+  getMesh(): THREE.Mesh | null;
+  /**
+   * Update the map position to follow the camera.
+   *
+   * Since the mesh is now a child of the camera, Three.js handles
+   * world-space transforms automatically. This method is kept for
+   * backward compatibility but is a no-op (position is set once in
+   * createMesh and doesn't need per-frame updates).
+   */
+  updatePosition(): void;
+  /**
+   * Clean up resources.
+   */
+  dispose(): void;
+  /**
+   * Create the map mesh (plane facing up).
+   */
+  private createMesh;
+  /**
+   * Remove the mesh from the camera.
+   */
+  private removeMesh;
+  /**
+   * Update the tile texture based on current GPS position.
+   */
+  private updateTile;
+}
+//#endregion
+export { MapOverlayOptions as a, tileXYToLatLon as c, MapOverlay as i, DEFAULT_MAP_SIZE as n, TextureLoaderInterface as o, DEFAULT_ZOOM as r, latLonToTileXY as s, DEFAULT_HEIGHT_OFFSET as t };

package/dist/null-storage-backend-CsWvQwN8.d.ts

@@ -0,0 +1,11 @@
+import { n as SessionMetadata } from "./opfs-storage-ChOzF_Wp.js";
+import { t as StorageBackend } from "./storage-backend-BcEItnFr.js";
+
+//#region ../src/storage/null-storage-backend.d.ts
+declare class NullStorageBackend implements StorageBackend {
+  writeAction(_action: unknown, _index: number): Promise<void>;
+  writeFrame(_blob: Blob, _index: number): Promise<void>;
+  writeSessionMetadata(_metadata: SessionMetadata): Promise<void>;
+}
+//#endregion
+export { NullStorageBackend as t };