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

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

@@ -0,0 +1,2 @@
+import { a as TrackingSliceState, c as poseLost, d as selectLastRestartedPayload, f as selectLastSensorOrientation, g as trackingReducer, h as selectTrackingPhase, i as TrackingPhase, l as poseReceived, m as selectLostFrameCount, n as PoseReceivedPayload, o as clearLastRestartedPayload, p as selectLastValidPose, r as ResetTransformData, s as originReset, t as DeviceOrientation, u as resetTracking } from "../tracking-slice-utCNND8t.js";
+export { DeviceOrientation, PoseReceivedPayload, ResetTransformData, TrackingPhase, TrackingSliceState, clearLastRestartedPayload, originReset, poseLost, poseReceived, resetTracking, selectLastRestartedPayload, selectLastSensorOrientation, selectLastValidPose, selectLostFrameCount, selectTrackingPhase, trackingReducer };

package/dist/state/tracking-slice.js

@@ -0,0 +1,147 @@
+import { createSlice } from "@reduxjs/toolkit";
+//#region ../src/state/tracking-slice.ts
+const initialState = {
+	phase: "initializing",
+	lastValidPose: null,
+	lastSensorOrientation: null,
+	lostFrameCount: 0,
+	originResetDuringLoss: false,
+	resetTransform: void 0,
+	lastRestartedPayload: null
+};
+const trackingSlice = createSlice({
+	name: "tracking",
+	initialState,
+	reducers: {
+		/**
+		* A valid AR pose was received this frame. Drives INITIALIZING|LOST →
+		* TRACKING transitions; on LOST → TRACKING with `originResetDuringLoss`
+		* also populates `lastRestartedPayload` (Case 2 of the manager doc).
+		*/
+		poseReceived(state, action) {
+			const { pose, sensorOrientation } = action.payload;
+			if (state.phase === "lost") {
+				const hadReset = state.originResetDuringLoss;
+				const savedResetTransform = state.resetTransform;
+				state.originResetDuringLoss = false;
+				state.resetTransform = void 0;
+				if (hadReset && state.lastValidPose !== null) {
+					const lastOrientation = state.lastSensorOrientation ?? sensorOrientation;
+					state.lastRestartedPayload = {
+						lastValidOdomPos: [
+							state.lastValidPose.position.x,
+							state.lastValidPose.position.y,
+							state.lastValidPose.position.z
+						],
+						lastValidOdomRot: [
+							state.lastValidPose.orientation.x,
+							state.lastValidPose.orientation.y,
+							state.lastValidPose.orientation.z,
+							state.lastValidPose.orientation.w
+						],
+						lastSensorOrientation: {
+							alpha: lastOrientation.alpha,
+							beta: lastOrientation.beta,
+							gamma: lastOrientation.gamma,
+							absolute: lastOrientation.absolute
+						},
+						newOdomRot: [
+							pose.orientation.x,
+							pose.orientation.y,
+							pose.orientation.z,
+							pose.orientation.w
+						],
+						newSensorOrientation: {
+							alpha: sensorOrientation.alpha,
+							beta: sensorOrientation.beta,
+							gamma: sensorOrientation.gamma,
+							absolute: sensorOrientation.absolute
+						},
+						newOdomPos: [
+							pose.position.x,
+							pose.position.y,
+							pose.position.z
+						],
+						resetTransform: savedResetTransform
+					};
+				}
+			}
+			state.phase = "tracking";
+			state.lastValidPose = pose;
+			state.lastSensorOrientation = sensorOrientation;
+			state.lostFrameCount = 0;
+		},
+		/**
+		* Pose was unavailable this frame. TRACKING → LOST on the first call;
+		* subsequent calls only bump `lostFrameCount`.
+		*/
+		poseLost(state) {
+			state.lostFrameCount += 1;
+			if (state.phase === "tracking") state.phase = "lost";
+		},
+		/**
+		* `XRReferenceSpace` reset event fired. Only meaningful while LOST.
+		* The payload distinguishes three cases:
+		*   - `ResetTransformData` — runtime supplied the transform.
+		*   - `null` — runtime could not determine the delta.
+		*   - `undefined` (action with no payload) — backwards compat for
+		*     callers without an event reference.
+		*/
+		originReset: {
+			reducer(state, action) {
+				if (state.phase !== "lost") return state;
+				return {
+					...state,
+					originResetDuringLoss: true,
+					resetTransform: action.payload
+				};
+			},
+			prepare(transform) {
+				return { payload: transform };
+			}
+		},
+		/**
+		* Drops the manager back to its initial state. Host calls on new XR
+		* session start.
+		*/
+		resetTracking() {
+			return initialState;
+		},
+		/**
+		* Host calls this after firing its `onTrackingRestarted` callback with
+		* the contents of `selectLastRestartedPayload`. Failure to call it would
+		* leave a stale payload; the test matrix locks this in.
+		*/
+		clearLastRestartedPayload(state) {
+			state.lastRestartedPayload = null;
+		}
+	}
+});
+const { poseReceived, poseLost, originReset, resetTracking, clearLastRestartedPayload } = trackingSlice.actions;
+const trackingReducer = trackingSlice.reducer;
+function selectTrackingPhase(state) {
+	return state.tracking.phase;
+}
+function selectLastValidPose(state) {
+	return state.tracking.lastValidPose;
+}
+function selectLostFrameCount(state) {
+	return state.tracking.lostFrameCount;
+}
+function selectLastRestartedPayload(state) {
+	return state.tracking.lastRestartedPayload;
+}
+/**
+* Selector for the last `DeviceOrientation` captured alongside a valid
+* AR pose. Used by the §4.3 compass / alignment heading cross-check in
+* the tracking-quality reporter (see
+* docs/2026-05-16-tracking-quality-metrics-plan.md).
+*
+* Returns `null` before any pose has been received and after
+* `resetTracking` clears the slice.
+*/
+function selectLastSensorOrientation(state) {
+	return state.tracking.lastSensorOrientation;
+}
+//#endregion
+export { clearLastRestartedPayload, originReset, poseLost, poseReceived, resetTracking, selectLastRestartedPayload, selectLastSensorOrientation, selectLastValidPose, selectLostFrameCount, selectTrackingPhase, trackingReducer };

package/dist/storage/file-system-utils.d.ts

@@ -1,2 +1,2 @@
-import { n as formatFrameFilename, r as formatTimestamp, t as formatActionFilename } from "../file-system-utils-5cWO8Xyv.js";
+import { n as formatFrameFilename, r as formatTimestamp, t as formatActionFilename } from "../file-system-utils-CtKiiw27.js";
 export { formatActionFilename, formatFrameFilename, formatTimestamp };

package/dist/storage/file-system.d.ts

@@ -1,2 +1,2 @@
-import { a as initStorage, c as resetForNewSession, d as startSession, f as verifyWriteAccess, h as writeSessionMetadata, i as getCurrentScenarioHandle, l as resetStorageState, m as writeFrame, n as WriteAccessResult, o as isRefPointAction, p as writeAction, r as ensureScenarioDirectory, s as loadScenarioRefPoints, t as RefPointRecord, u as setCurrentScenario } from "../file-system-BsQgYCU3.js";
-export { RefPointRecord, WriteAccessResult, ensureScenarioDirectory, getCurrentScenarioHandle, initStorage, isRefPointAction, loadScenarioRefPoints, resetForNewSession, resetStorageState, setCurrentScenario, startSession, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata };
+import { a as getCurrentScenarioHandle, c as resetForNewSession, d as startSession, f as verifyWriteAccess, h as writeSessionMetadata, i as ensureScenarioDirectory, l as resetStorageState, m as writeFrame, n as WriteAccessResult, o as initStorage, p as writeAction, r as clearRefPointsCacheForAllScenarios, s as listSessions, t as ClearRefPointsCacheResult, u as setCurrentScenario } from "../file-system-DTApEv_Q.js";
+export { ClearRefPointsCacheResult, WriteAccessResult, clearRefPointsCacheForAllScenarios, ensureScenarioDirectory, getCurrentScenarioHandle, initStorage, listSessions, resetForNewSession, resetStorageState, setCurrentScenario, startSession, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata };

package/dist/storage/file-system.js

@@ -1,15 +1,34 @@
 import { createLogger } from "../utils/logger.js";
 import { setFileSystemState } from "../sensors/permission-checker.js";
-import { createSession, getScenarioHandle, getScenariosRootHandle, initOpfsStorage, listScenarios, resetOpfsStorage, resetSessionHandles, writeAction as writeAction$1, writeFrame as writeFrame$1, writeSessionMetadata as writeSessionMetadata$1 } from "./opfs-storage.js";
+import { formatTimestamp } from "./file-system-utils.js";
+import { createSession, getAppRootHandle, initOpfsStorage, listSessions as listSessions$1, resetOpfsStorage, resetSessionHandles, setSessionHandles, writeAction as writeAction$1, writeFrame as writeFrame$1, writeSessionMetadata as writeSessionMetadata$1 } from "./opfs-storage.js";
 //#region ../src/storage/file-system.ts
+/**
+* File System Storage Module
+*
+* Facade over the OPFS storage module. Provides session lifecycle, write
+* operations, and backwards-compatible scenario management for the recorder.
+*
+* The core OPFS module (opfs-storage.ts) is scenario-free — it manages
+* flat sessions/{timestamp}/ directories. This module bridges the gap by
+* managing scenario directory handles for consumers that still need them
+* (recorder, ref-point loader, etc.) until those are migrated to
+* ScenarioWrappingStorageBackend in later iterations.
+*/
 const log = createLogger("Storage");
+let _currentScenarioName = null;
 let storageInitialized = false;
+let scenariosDir = null;
+let currentScenarioHandle = null;
 /**
 * Reset module state - exported for testing only
 * @internal
 */
 function resetStorageState() {
+	_currentScenarioName = null;
 	storageInitialized = false;
+	scenariosDir = null;
+	currentScenarioHandle = null;
 	resetOpfsStorage();
 }
 /**
@@ -18,25 +37,14 @@ function resetStorageState() {
 * Clears scenario/session names and OPFS session handles, but preserves
 * `storageInitialized` and the OPFS root so `initStorage()` doesn't need
 * to be called again.
-*
-* Used during soft reset for new recordings (Issue 4, 2026-02-06 user feedback).
 */
 function resetForNewSession() {
+	_currentScenarioName = null;
+	currentScenarioHandle = null;
 	resetSessionHandles();
 }
 /**
 * Verify that we have actual write access to a directory.
-*
-* This probes the directory by creating a test file, writing content,
-* and cleaning up. This catches cases where showDirectoryPicker grants
-* a handle but the underlying file system is read-only.
-*
-* User Feedback Issue #1: Even with mode: 'readwrite', Android can
-* return a handle where getFileHandle({create: true}) succeeds but
-* createWritable() fails with NoModificationAllowedError.
-*
-* @param dirHandle - Directory handle to verify
-* @returns Success status and optional error message
 */
 async function verifyWriteAccess(dirHandle) {
 	const testFilename = `.write-test-${Date.now()}`;
@@ -64,12 +72,27 @@ async function verifyWriteAccess(dirHandle) {
 		};
 	}
 }
+async function ensureScenariosDir() {
+	if (scenariosDir) return scenariosDir;
+	const appRoot = getAppRootHandle();
+	if (!appRoot) return null;
+	scenariosDir = await appRoot.getDirectoryHandle("scenarios", { create: true });
+	return scenariosDir;
+}
+/**
+* List all scenario names in OPFS storage.
+* Legacy: scenarios are managed by the recorder, not the framework.
+*/
+async function listScenarios() {
+	const dir = await ensureScenariosDir();
+	if (!dir) return [];
+	const scenarios = [];
+	for await (const entry of dir.values()) if (entry.kind === "directory") scenarios.push(entry.name);
+	return scenarios;
+}
 /**
 * Initialize storage using OPFS.
 *
-* This replaces the old showDirectoryPicker approach which failed on Android Chrome.
-* OPFS is automatically available and doesn't require user folder selection.
-*
 * @returns List of existing scenario folder names
 * @throws Error if OPFS is not supported
 */
@@ -81,6 +104,7 @@ async function initStorage() {
 			folderSelected: true,
 			writeVerified: true
 		});
+		await ensureScenariosDir();
 		const scenarios = await listScenarios();
 		log.info("OPFS storage initialized, found scenarios:", scenarios);
 		return scenarios;
@@ -96,24 +120,61 @@ async function initStorage() {
 	}
 }
 /**
-* Create or open a scenario folder, then create a new session folder.
+* Create a new session folder.
 *
-* Now uses OPFS backend instead of showDirectoryPicker.
+* When scenarioName is provided, creates under the scenario directory
+* (legacy scenario layout for the recorder). When omitted, creates under
+* the flat sessions/ directory.
 *
-* @param scenarioName - Name of the scenario
+* @param scenarioName - Optional name of the scenario (omit for flat layout)
 */
 async function startSession(scenarioName) {
 	if (!storageInitialized) throw new Error("Storage not initialized. Call initStorage first.");
-	const result = await createSession(scenarioName, /* @__PURE__ */ new Date());
-	result.scenarioName;
+	if (scenarioName) {
+		const dir = await ensureScenariosDir();
+		if (!dir) throw new Error("Failed to access scenarios directory.");
+		const scenarioHandle = await dir.getDirectoryHandle(scenarioName, { create: true });
+		currentScenarioHandle = scenarioHandle;
+		const sessionName = `recording-${formatTimestamp(/* @__PURE__ */ new Date())}`;
+		const sessionHandle = await scenarioHandle.getDirectoryHandle(sessionName, { create: true });
+		setSessionHandles(sessionHandle, await sessionHandle.getDirectoryHandle("actions", { create: true }), await sessionHandle.getDirectoryHandle("frames", { create: true }));
+		_currentScenarioName = scenarioName;
+		log.info("Session started:", `${scenarioName}/${sessionName}`);
+		return {
+			scenarioPath: scenarioName,
+			sessionPath: sessionName
+		};
+	}
+	const result = await createSession(/* @__PURE__ */ new Date());
+	_currentScenarioName = "";
 	result.sessionName;
-	log.info("Session started:", `${result.scenarioName}/${result.sessionName}`);
+	log.info("Session started:", result.sessionName);
 	return {
-		scenarioPath: result.scenarioName,
+		scenarioPath: "",
 		sessionPath: result.sessionName
 	};
 }
 /**
+* List all session names.
+* When scenarioName is provided, lists sessions under that scenario.
+* Otherwise lists flat sessions.
+*/
+async function listSessions(scenarioName) {
+	if (scenarioName) {
+		const dir = await ensureScenariosDir();
+		if (!dir) return [];
+		try {
+			const scenarioHandle = await dir.getDirectoryHandle(scenarioName);
+			const sessions = [];
+			for await (const entry of scenarioHandle.values()) if (entry.kind === "directory") sessions.push(entry.name);
+			return sessions;
+		} catch {
+			return [];
+		}
+	}
+	return listSessions$1();
+}
+/**
 * Write a Redux action to OPFS as a JSON file.
 */
 async function writeAction(action, index) {
@@ -127,82 +188,30 @@ async function writeFrame(blob, index) {
 }
 /**
 * Write session metadata (session.json) to OPFS.
-* Contains timing, counts, and user agent for the recording session.
 */
 async function writeSessionMetadata(metadata) {
 	await writeSessionMetadata$1(metadata);
 }
 /**
-* Type guard for reference point actions
-* Exported for testing
-*/
-function isRefPointAction(action) {
-	if (typeof action !== "object" || action === null) return false;
-	const obj = action;
-	const payload = obj.payload;
-	return obj.type === "recorder/markRefPoint" && typeof payload === "object" && payload !== null && !Array.isArray(payload);
-}
-/**
-* Parse action files from a session's actions directory
-*/
-async function parseSessionRefPoints(actionsDir, sessionName) {
-	const refPoints = [];
-	for await (const actionEntry of actionsDir.values()) {
-		if (actionEntry.kind !== "file" || !actionEntry.name.endsWith(".json")) continue;
-		const text = await (await (await actionsDir.getFileHandle(actionEntry.name)).getFile()).text();
-		try {
-			const action = JSON.parse(text);
-			if (isRefPointAction(action)) refPoints.push({
-				id: action.payload.id,
-				sessionName,
-				gpsPosition: action.payload.gpsPosition,
-				arPose: action.payload.arPose
-			});
-		} catch {}
-	}
-	return refPoints;
-}
-/**
-* Load existing reference points from a scenario (across all sessions).
-* Now uses OPFS storage backend.
-*/
-async function loadScenarioRefPoints(scenarioName) {
-	const scenariosRoot = getScenariosRootHandle();
-	if (!scenariosRoot) return [];
-	const refPoints = [];
-	try {
-		const scenarioHandle = await scenariosRoot.getDirectoryHandle(scenarioName);
-		for await (const sessionEntry of scenarioHandle.values()) {
-			if (sessionEntry.kind !== "directory") continue;
-			const sessionHandle = await scenarioHandle.getDirectoryHandle(sessionEntry.name);
-			let actionsDir;
-			try {
-				actionsDir = await sessionHandle.getDirectoryHandle("actions");
-			} catch {
-				continue;
-			}
-			const sessionRefPoints = await parseSessionRefPoints(actionsDir, sessionEntry.name);
-			refPoints.push(...sessionRefPoints);
-		}
-	} catch {}
-	return refPoints;
-}
-/**
 * Get the current scenario handle (for loading prior sessions).
-* Now delegates to OPFS storage backend.
+* Legacy: uses scenario directory layout.
 */
 function getCurrentScenarioHandle() {
-	return getScenarioHandle();
+	if (!_currentScenarioName) return null;
+	return currentScenarioHandle;
 }
 /**
 * Set the current scenario handle (when user selects a scenario).
-* With OPFS, we just store the name - the actual handle is retrieved when needed.
+* Legacy: uses scenario directory layout.
 */
 async function setCurrentScenario(scenarioName) {
-	const scenariosRoot = getScenariosRootHandle();
-	if (!scenariosRoot) return null;
+	const scenRoot = await ensureScenariosDir();
+	if (!scenRoot) return null;
 	try {
-		return await scenariosRoot.getDirectoryHandle(scenarioName);
+		const handle = await scenRoot.getDirectoryHandle(scenarioName);
+		_currentScenarioName = scenarioName;
+		currentScenarioHandle = handle;
+		return handle;
 	} catch {
 		log.warn("Scenario not found:", scenarioName);
 		return null;
@@ -210,20 +219,71 @@ async function setCurrentScenario(scenarioName) {
 }
 /**
 * Ensure a scenario directory exists in OPFS, creating it if necessary.
-* Used during OPFS recovery when the scenario directory was lost but ZIP
-* data is available for restoration.
-*
-* Unlike setCurrentScenario() which only reads, this creates on demand.
+* Legacy: used during OPFS recovery.
 */
 async function ensureScenarioDirectory(scenarioName) {
-	const scenariosRoot = getScenariosRootHandle();
-	if (!scenariosRoot) return null;
+	const scenRoot = await ensureScenariosDir();
+	if (!scenRoot) return null;
 	try {
-		return await scenariosRoot.getDirectoryHandle(scenarioName, { create: true });
+		const handle = await scenRoot.getDirectoryHandle(scenarioName, { create: true });
+		_currentScenarioName = scenarioName;
+		currentScenarioHandle = handle;
+		return handle;
 	} catch (err) {
 		log.error("Failed to create scenario directory:", err);
 		return null;
 	}
 }
+/**
+* Clear the cached `refPoints/` directory for every scenario in OPFS.
+*
+* Used by the "Clear Reference Point Cache" maintenance action so that the
+* next scenario load re-imports ref points from the read folder's `*.zip`
+* recordings (see ref-point-recovery in the recorder app).
+*
+* Failures for individual scenarios are collected in `errors` rather than
+* aborting the whole operation — partial progress is still useful.
+*
+* @throws Error if OPFS storage is unavailable (e.g. `initStorage()` not yet
+*   called, or browser does not support OPFS). Surfacing this loudly avoids
+*   reporting a silent "0 scenarios cleared" success that would mask the
+*   real failure to the user.
+*/
+async function clearRefPointsCacheForAllScenarios() {
+	const dir = await ensureScenariosDir();
+	if (!dir) throw new Error("clearRefPointsCacheForAllScenarios: OPFS scenarios directory is unavailable — call initStorage() first or check OPFS support");
+	const errors = [];
+	let scenariosCleared = 0;
+	let scenariosScanned = 0;
+	const scenarios = await listScenarios();
+	for (const scenarioName of scenarios) {
+		scenariosScanned++;
+		try {
+			const handle = await dir.getDirectoryHandle(scenarioName);
+			if (!handle) continue;
+			try {
+				await handle.removeEntry("refPoints", { recursive: true });
+				scenariosCleared++;
+			} catch (err) {
+				if ((err instanceof Error ? err.name : String(err?.name)) === "NotFoundError") continue;
+				errors.push({
+					scenarioName,
+					reason: err instanceof Error ? err.message : String(err)
+				});
+			}
+		} catch (err) {
+			errors.push({
+				scenarioName,
+				reason: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
+	log.info(`Cleared ref-point cache for ${scenariosCleared}/${scenariosScanned} scenarios (${errors.length} errors)`);
+	return {
+		scenariosCleared,
+		scenariosScanned,
+		errors
+	};
+}
 //#endregion
-export { ensureScenarioDirectory, getCurrentScenarioHandle, initStorage, isRefPointAction, loadScenarioRefPoints, resetForNewSession, resetStorageState, setCurrentScenario, startSession, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata };
+export { clearRefPointsCacheForAllScenarios, ensureScenarioDirectory, getCurrentScenarioHandle, initStorage, listSessions, resetForNewSession, resetStorageState, setCurrentScenario, startSession, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata };

package/dist/storage/index.d.ts

@@ -1,11 +1,9 @@
-import { a as getScenarioHandle, c as initOpfsStorage, d as resetOpfsStorage, f as resetSessionHandles, h as writeSessionMetadata$1, i as createSession, n as SessionMetadata, 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 { n as RefPointImportResult, r as importRefPointsFromFolder, t as ImportedRefPoint } from "../ref-point-importer-B_wn5ABk.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 { a as ZipActionEntry, c as loadSessionMetadata, i as RecordedAction, l as loadSessionMetadataFromBlob, n as GpsPathCoord, o as loadActionsFromZip, r as MAX_ACTION_FILE_SIZE, s as loadGpsPathFromBlob, t as Entry, u as readZipEntries } from "../zip-reader-D7pkpX8K.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, f as verifyWriteAccess, h as writeSessionMetadata, i as getCurrentScenarioHandle, l as resetStorageState, m as writeFrame, n as WriteAccessResult, o as isRefPointAction, p as writeAction, s as loadScenarioRefPoints, u as setCurrentScenario } 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";
-export { type CreateSessionResult, type Entry, type GpsPathCoord, type ImportedRefPoint, MAX_ACTION_FILE_SIZE, NullStorageBackend, OpfsStorageBackend, type RecordedAction, type RefPointDefinition, type RefPointImportResult, type RefPointMark, type RefPointObservation, type SessionMetadata, type StorageBackend, type WriteAccessResult, type ZipActionEntry, type ZipExportResult, averageGpsPerRefPoint, checkStorageQuota, createSession, downloadZip, exportAndDownloadSession, exportSessionAsZip, flattenRefPointsToMarks, formatActionFilename, formatFrameFilename, formatTimestamp, getCurrentScenarioHandle, getScenarioHandle, getScenariosRootHandle, getSessionHandle, importRefPointsFromFolder, initOpfsStorage, initStorage, isRefPointAction, listRefPointIds, listSessions, loadActionsFromZip, loadAllRefPoints, loadGpsPathFromBlob, loadRefPoint, loadScenarioRefPoints, loadSessionMetadataFromBlob, loadSessionMetadata as loadSessionMetadataFromZip, readZipEntries, resetForNewSession, resetOpfsStorage, resetSessionHandles, resetStorageState, saveRefPointObservation, setCurrentScenario, startSession as startStorageSession, syncToExternalZip, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata as writeSessionMeta, writeSessionMetadata$1 as writeSessionMetadata };
+import { a as getAppRootHandle, c as initOpfsStorage, d as resetSessionHandles, h as writeSessionMetadata$1, i as createSession, l as listSessions, n as SessionMetadata, o as getSessionHandle, r as checkStorageQuota, s as getSessionsRootHandle, u as resetOpfsStorage } from "../opfs-storage-DOPkzgeT.js";
+import { n as StorageBackend, t as CreateSessionResult } from "../storage-backend-CT0Il_AB.js";
+import { a as ZipActionEntry, c as loadEntriesFromSubdir, d as loadSessionMetadataFromBlob, f as readZipEntries, i as RecordedAction, l as loadGpsPathFromBlob, n as GpsPathCoord, o as ZipSubdirEntry, r as MAX_ACTION_FILE_SIZE, s as loadActionsFromZip, t as Entry, u as loadSessionMetadata } from "../zip-reader-D1105idz.js";
+import { t as NullStorageBackend } from "../null-storage-backend-BKOS7JpL.js";
+import { t as OpfsStorageBackend } from "../opfs-storage-backend-Cj_7PWoq.js";
+import { a as getCurrentScenarioHandle, c as resetForNewSession, d as startSession, f as verifyWriteAccess, h as writeSessionMetadata, i as ensureScenarioDirectory, l as resetStorageState, m as writeFrame, n as WriteAccessResult, o as initStorage, p as writeAction, s as listSessions$1, u as setCurrentScenario } from "../file-system-DTApEv_Q.js";
+import { n as formatFrameFilename, r as formatTimestamp, t as formatActionFilename } from "../file-system-utils-CtKiiw27.js";
+import { a as downloadZip, c as syncToExternalZip, i as ZipExportResult, n as ZipContributorAddFile, o as exportAndDownloadSession, r as ZipExportContributor, s as exportSessionAsZip, t as ExportSessionAsZipOptions } from "../zip-export-QO4iLIi7.js";
+export { type CreateSessionResult, type Entry, type ExportSessionAsZipOptions, type GpsPathCoord, MAX_ACTION_FILE_SIZE, NullStorageBackend, OpfsStorageBackend, type RecordedAction, type SessionMetadata, type StorageBackend, type WriteAccessResult, type ZipActionEntry, type ZipContributorAddFile, type ZipExportContributor, type ZipExportResult, type ZipSubdirEntry, checkStorageQuota, createSession, downloadZip, ensureScenarioDirectory, exportAndDownloadSession, exportSessionAsZip, formatActionFilename, formatFrameFilename, formatTimestamp, getAppRootHandle, getCurrentScenarioHandle, getSessionHandle, getSessionsRootHandle, initOpfsStorage, initStorage, listSessions, listSessions$1 as listSessionsFromFileSystem, loadActionsFromZip, loadEntriesFromSubdir, loadGpsPathFromBlob, loadSessionMetadataFromBlob, loadSessionMetadata as loadSessionMetadataFromZip, readZipEntries, resetForNewSession, resetOpfsStorage, resetSessionHandles, resetStorageState, setCurrentScenario, startSession as startStorageSession, syncToExternalZip, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata as writeSessionMeta, writeSessionMetadata$1 as writeSessionMetadata };

package/dist/storage/index.js

@@ -1,10 +1,8 @@
+import { MAX_ACTION_FILE_SIZE, loadActionsFromZip, loadEntriesFromSubdir, loadGpsPathFromBlob, loadSessionMetadata, loadSessionMetadataFromBlob, readZipEntries } from "./zip-reader.js";
 import { formatActionFilename, formatFrameFilename, formatTimestamp } from "./file-system-utils.js";
-import { checkStorageQuota, createSession, getScenarioHandle, getScenariosRootHandle, getSessionHandle, initOpfsStorage, listSessions, resetOpfsStorage, resetSessionHandles, writeSessionMetadata as writeSessionMetadata$1 } from "./opfs-storage.js";
-import { getCurrentScenarioHandle, initStorage, isRefPointAction, loadScenarioRefPoints, resetForNewSession, resetStorageState, setCurrentScenario, startSession, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata } from "./file-system.js";
-import { OpfsStorageBackend } from "./opfs-storage-backend.js";
-import { MAX_ACTION_FILE_SIZE, loadActionsFromZip, loadGpsPathFromBlob, loadSessionMetadata, loadSessionMetadataFromBlob, readZipEntries } from "./zip-reader.js";
 import { NullStorageBackend } from "./null-storage-backend.js";
-import { importRefPointsFromFolder } from "./ref-point-importer.js";
-import { averageGpsPerRefPoint, flattenRefPointsToMarks, listRefPointIds, loadAllRefPoints, loadRefPoint, saveRefPointObservation } from "./ref-point-loader.js";
+import { checkStorageQuota, createSession, getAppRootHandle, getSessionHandle, getSessionsRootHandle, initOpfsStorage, listSessions, resetOpfsStorage, resetSessionHandles, writeSessionMetadata as writeSessionMetadata$1 } from "./opfs-storage.js";
+import { ensureScenarioDirectory, getCurrentScenarioHandle, initStorage, listSessions as listSessions$1, resetForNewSession, resetStorageState, setCurrentScenario, startSession, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata } from "./file-system.js";
+import { OpfsStorageBackend } from "./opfs-storage-backend.js";
 import { downloadZip, exportAndDownloadSession, exportSessionAsZip, syncToExternalZip } from "./zip-export.js";
-export { MAX_ACTION_FILE_SIZE, NullStorageBackend, OpfsStorageBackend, averageGpsPerRefPoint, checkStorageQuota, createSession, downloadZip, exportAndDownloadSession, exportSessionAsZip, flattenRefPointsToMarks, formatActionFilename, formatFrameFilename, formatTimestamp, getCurrentScenarioHandle, getScenarioHandle, getScenariosRootHandle, getSessionHandle, importRefPointsFromFolder, initOpfsStorage, initStorage, isRefPointAction, listRefPointIds, listSessions, loadActionsFromZip, loadAllRefPoints, loadGpsPathFromBlob, loadRefPoint, loadScenarioRefPoints, loadSessionMetadataFromBlob, loadSessionMetadata as loadSessionMetadataFromZip, readZipEntries, resetForNewSession, resetOpfsStorage, resetSessionHandles, resetStorageState, saveRefPointObservation, setCurrentScenario, startSession as startStorageSession, syncToExternalZip, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata as writeSessionMeta, writeSessionMetadata$1 as writeSessionMetadata };
+export { MAX_ACTION_FILE_SIZE, NullStorageBackend, OpfsStorageBackend, checkStorageQuota, createSession, downloadZip, ensureScenarioDirectory, exportAndDownloadSession, exportSessionAsZip, formatActionFilename, formatFrameFilename, formatTimestamp, getAppRootHandle, getCurrentScenarioHandle, getSessionHandle, getSessionsRootHandle, initOpfsStorage, initStorage, listSessions, listSessions$1 as listSessionsFromFileSystem, loadActionsFromZip, loadEntriesFromSubdir, loadGpsPathFromBlob, loadSessionMetadataFromBlob, loadSessionMetadata as loadSessionMetadataFromZip, readZipEntries, resetForNewSession, resetOpfsStorage, resetSessionHandles, resetStorageState, setCurrentScenario, startSession as startStorageSession, syncToExternalZip, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata as writeSessionMeta, writeSessionMetadata$1 as writeSessionMetadata };

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

@@ -1,2 +1,2 @@
-import { t as NullStorageBackend } from "../null-storage-backend-CsWvQwN8.js";
+import { t as NullStorageBackend } from "../null-storage-backend-BKOS7JpL.js";
 export { NullStorageBackend };

package/dist/storage/null-storage-backend.js

@@ -1,5 +1,12 @@
+import { formatTimestamp } from "./file-system-utils.js";
 //#region ../src/storage/null-storage-backend.ts
 var NullStorageBackend = class {
+	createSession(timestamp, _contextTag) {
+		return Promise.resolve({ sessionName: `recording-${formatTimestamp(timestamp)}` });
+	}
+	listSessions() {
+		return Promise.resolve([]);
+	}
 	async writeAction(_action, _index) {}
 	async writeFrame(_blob, _index) {}
 	async writeSessionMetadata(_metadata) {}

package/dist/storage/opfs-storage-backend.d.ts

@@ -1,2 +1,2 @@
-import { t as OpfsStorageBackend } from "../opfs-storage-backend-CVcmfJHN.js";
+import { t as OpfsStorageBackend } from "../opfs-storage-backend-Cj_7PWoq.js";
 export { OpfsStorageBackend };

package/dist/storage/opfs-storage-backend.js

@@ -1,6 +1,12 @@
-import { writeAction, writeFrame, writeSessionMetadata } from "./file-system.js";
+import { listSessions, startSession, writeAction, writeFrame, writeSessionMetadata } from "./file-system.js";
 //#region ../src/storage/opfs-storage-backend.ts
 var OpfsStorageBackend = class {
+	async createSession(_timestamp, _contextTag) {
+		return { sessionName: (await startSession()).sessionPath };
+	}
+	async listSessions() {
+		return listSessions();
+	}
 	async writeAction(action, index) {
 		await writeAction(action, index);
 	}

package/dist/storage/opfs-storage.d.ts

@@ -1,2 +1,2 @@
-import { a as getScenarioHandle, c as initOpfsStorage, d as resetOpfsStorage, f as resetSessionHandles, h as writeSessionMetadata, i as createSession, l as listScenarios, m as writeFrame, n as SessionMetadata, o as getScenariosRootHandle, p as writeAction, r as checkStorageQuota, s as getSessionHandle, t as CreateSessionResult, u as listSessions } from "../opfs-storage-ChOzF_Wp.js";
-export { CreateSessionResult, SessionMetadata, checkStorageQuota, createSession, getScenarioHandle, getScenariosRootHandle, getSessionHandle, initOpfsStorage, listScenarios, listSessions, resetOpfsStorage, resetSessionHandles, writeAction, writeFrame, writeSessionMetadata };
+import { a as getAppRootHandle, c as initOpfsStorage, d as resetSessionHandles, f as setSessionHandles, h as writeSessionMetadata, i as createSession, l as listSessions, m as writeFrame, n as SessionMetadata, o as getSessionHandle, p as writeAction, r as checkStorageQuota, s as getSessionsRootHandle, t as CreateSessionResult, u as resetOpfsStorage } from "../opfs-storage-DOPkzgeT.js";
+export { CreateSessionResult, SessionMetadata, checkStorageQuota, createSession, getAppRootHandle, getSessionHandle, getSessionsRootHandle, initOpfsStorage, listSessions, resetOpfsStorage, resetSessionHandles, setSessionHandles, writeAction, writeFrame, writeSessionMetadata };