gps-plus-slam-app-framework 1.0.0

package/dist/storage/file-system.js

@@ -0,0 +1,229 @@
+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";
+//#region ../src/storage/file-system.ts
+const log = createLogger("Storage");
+let storageInitialized = false;
+/**
+* Reset module state - exported for testing only
+* @internal
+*/
+function resetStorageState() {
+	storageInitialized = false;
+	resetOpfsStorage();
+}
+/**
+* Reset session-level state for a new recording.
+*
+* 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() {
+	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()}`;
+	try {
+		const writable = await (await dirHandle.getFileHandle(testFilename, { create: true })).createWritable();
+		await writable.write("write-test");
+		await writable.close();
+		try {
+			await dirHandle.removeEntry(testFilename);
+		} catch (cleanupErr) {
+			log.warn("Write test cleanup failed (non-critical):", cleanupErr);
+		}
+		log.info("Write access verified for:", dirHandle.name);
+		return { success: true };
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err));
+		log.error("Write verification failed:", error);
+		if (error.name === "NoModificationAllowedError") return {
+			success: false,
+			error: "Folder is read-only. Please select a different folder with write access."
+		};
+		return {
+			success: false,
+			error: `Cannot write to folder: ${error.message}`
+		};
+	}
+}
+/**
+* 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
+*/
+async function initStorage() {
+	try {
+		await initOpfsStorage();
+		storageInitialized = true;
+		setFileSystemState({
+			folderSelected: true,
+			writeVerified: true
+		});
+		const scenarios = await listScenarios();
+		log.info("OPFS storage initialized, found scenarios:", scenarios);
+		return scenarios;
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err));
+		log.error("OPFS initialization failed:", error);
+		setFileSystemState({
+			folderSelected: false,
+			writeVerified: false,
+			writeError: error.message
+		});
+		throw error;
+	}
+}
+/**
+* Create or open a scenario folder, then create a new session folder.
+*
+* Now uses OPFS backend instead of showDirectoryPicker.
+*
+* @param scenarioName - Name of the scenario
+*/
+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;
+	result.sessionName;
+	log.info("Session started:", `${result.scenarioName}/${result.sessionName}`);
+	return {
+		scenarioPath: result.scenarioName,
+		sessionPath: result.sessionName
+	};
+}
+/**
+* Write a Redux action to OPFS as a JSON file.
+*/
+async function writeAction(action, index) {
+	await writeAction$1(action, index);
+}
+/**
+* Write a captured frame image to OPFS.
+*/
+async function writeFrame(blob, index) {
+	await writeFrame$1(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.
+*/
+function getCurrentScenarioHandle() {
+	return getScenarioHandle();
+}
+/**
+* Set the current scenario handle (when user selects a scenario).
+* With OPFS, we just store the name - the actual handle is retrieved when needed.
+*/
+async function setCurrentScenario(scenarioName) {
+	const scenariosRoot = getScenariosRootHandle();
+	if (!scenariosRoot) return null;
+	try {
+		return await scenariosRoot.getDirectoryHandle(scenarioName);
+	} catch {
+		log.warn("Scenario not found:", scenarioName);
+		return null;
+	}
+}
+/**
+* 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.
+*/
+async function ensureScenarioDirectory(scenarioName) {
+	const scenariosRoot = getScenariosRootHandle();
+	if (!scenariosRoot) return null;
+	try {
+		return await scenariosRoot.getDirectoryHandle(scenarioName, { create: true });
+	} catch (err) {
+		log.error("Failed to create scenario directory:", err);
+		return null;
+	}
+}
+//#endregion
+export { ensureScenarioDirectory, getCurrentScenarioHandle, initStorage, isRefPointAction, loadScenarioRefPoints, resetForNewSession, resetStorageState, setCurrentScenario, startSession, verifyWriteAccess, writeAction, writeFrame, writeSessionMetadata };

package/dist/storage/index.d.ts

@@ -0,0 +1,11 @@
+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 };

package/dist/storage/index.js

@@ -0,0 +1,10 @@
+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 { 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 };

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

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

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

@@ -0,0 +1,8 @@
+//#region ../src/storage/null-storage-backend.ts
+var NullStorageBackend = class {
+	async writeAction(_action, _index) {}
+	async writeFrame(_blob, _index) {}
+	async writeSessionMetadata(_metadata) {}
+};
+//#endregion
+export { NullStorageBackend };

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

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

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

@@ -0,0 +1,15 @@
+import { writeAction, writeFrame, writeSessionMetadata } from "./file-system.js";
+//#region ../src/storage/opfs-storage-backend.ts
+var OpfsStorageBackend = class {
+	async writeAction(action, index) {
+		await writeAction(action, index);
+	}
+	async writeFrame(blob, index) {
+		await writeFrame(blob, index);
+	}
+	async writeSessionMetadata(metadata) {
+		await writeSessionMetadata(metadata);
+	}
+};
+//#endregion
+export { OpfsStorageBackend };

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

@@ -0,0 +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 };

package/dist/storage/opfs-storage.js

@@ -0,0 +1,242 @@
+import { createLogger } from "../utils/logger.js";
+import { formatActionFilename, formatFrameFilename, formatTimestamp } from "./file-system-utils.js";
+//#region ../src/storage/opfs-storage.ts
+/**
+* OPFS Storage Module
+*
+* Uses the Origin Private File System (OPFS) API to persist recording data.
+* OPFS works consistently on Desktop Chrome, Android Chrome, and iOS Safari,
+* unlike showDirectoryPicker which has write restrictions on Android.
+*
+* Directory structure:
+* /gps-recorder/
+*   └── scenarios/
+*       ├── {scenario-name}/
+*       │   ├── recording-YYYY-MM-DD_HH-MM-SSutc/
+*       │   │   ├── session.json
+*       │   │   ├── actions/
+*       │   │   │   ├── 000001.json
+*       │   │   │   └── ...
+*       │   │   └── frames/
+*       │   │       ├── frame-000001.jpg
+*       │   │       └── ...
+*       │   └── ...
+*       └── ...
+*/
+const log = createLogger("OPFS");
+let opfsRoot = null;
+let gpsRecorderDir = null;
+let scenariosDir = null;
+let currentScenarioHandle = null;
+let currentSessionHandle = null;
+let actionsHandle = null;
+let framesHandle = null;
+/**
+* Reset module state - exported for testing only.
+* @internal
+*/
+function resetOpfsStorage() {
+	opfsRoot = null;
+	gpsRecorderDir = null;
+	scenariosDir = null;
+	currentScenarioHandle = null;
+	currentSessionHandle = null;
+	actionsHandle = null;
+	framesHandle = null;
+}
+/**
+* Reset session-level handles only.
+*
+* Preserves opfsRoot/gpsRecorderDir/scenariosDir (OPFS stays initialized)
+* but clears current scenario/session/actions/frames handles so a new
+* session can be started fresh.
+*
+* Used during soft reset for new recordings (Issue 4, 2026-02-06 user feedback).
+*/
+function resetSessionHandles() {
+	currentScenarioHandle = null;
+	currentSessionHandle = null;
+	actionsHandle = null;
+	framesHandle = null;
+}
+/**
+* Initialize OPFS storage by creating the required directory structure.
+*
+* Creates:
+* - /gps-recorder/
+* - /gps-recorder/scenarios/
+*
+* This is idempotent - calling multiple times is safe.
+*
+* @throws Error if OPFS is not supported
+*/
+async function initOpfsStorage() {
+	if (typeof navigator === "undefined" || !navigator.storage || typeof navigator.storage.getDirectory !== "function") throw new Error("OPFS (Origin Private File System) is not supported in this browser. Please use Chrome 86+, Safari 15.2+, or Firefox 111+.");
+	opfsRoot = await navigator.storage.getDirectory();
+	log.info("OPFS root obtained");
+	gpsRecorderDir = await opfsRoot.getDirectoryHandle("gps-recorder", { create: true });
+	scenariosDir = await gpsRecorderDir.getDirectoryHandle("scenarios", { create: true });
+	log.info("OPFS storage initialized");
+}
+/**
+* Create a new recording session within a scenario.
+*
+* Creates the directory structure:
+* - /gps-recorder/scenarios/{scenarioName}/recording-{timestamp}/
+* - /gps-recorder/scenarios/{scenarioName}/recording-{timestamp}/actions/
+* - /gps-recorder/scenarios/{scenarioName}/recording-{timestamp}/frames/
+*
+* @param scenarioName - Name of the scenario (creates if doesn't exist)
+* @param timestamp - Session start time (used for folder naming)
+* @returns Session information
+* @throws Error if storage not initialized
+*/
+async function createSession(scenarioName, timestamp) {
+	if (!scenariosDir) throw new Error("OPFS storage not initialized. Call initOpfsStorage first.");
+	currentScenarioHandle = await scenariosDir.getDirectoryHandle(scenarioName, { create: true });
+	const sessionName = `recording-${formatTimestamp(timestamp)}`;
+	currentSessionHandle = await currentScenarioHandle.getDirectoryHandle(sessionName, { create: true });
+	actionsHandle = await currentSessionHandle.getDirectoryHandle("actions", { create: true });
+	framesHandle = await currentSessionHandle.getDirectoryHandle("frames", { create: true });
+	log.info("Session created:", `${scenarioName}/${sessionName}`);
+	return {
+		scenarioName,
+		sessionName
+	};
+}
+/**
+* Get the current session directory handle.
+* Useful for test assertions.
+* @internal
+*/
+function getSessionHandle() {
+	return currentSessionHandle;
+}
+/**
+* Get the current scenario directory handle.
+*/
+function getScenarioHandle() {
+	return currentScenarioHandle;
+}
+/**
+* Get the scenarios root directory handle.
+* Used for loading reference points across scenarios.
+*/
+function getScenariosRootHandle() {
+	return scenariosDir;
+}
+/**
+* Safely write data to a file handle with proper cleanup.
+*
+* Uses try/finally to ensure the writable stream is always cleaned up,
+* calling abort() on errors to prevent resource leaks and file locks.
+*
+* @param fileHandle - The file handle to write to
+* @param data - The data to write (string or Blob)
+*/
+async function safeWriteToFile(fileHandle, data) {
+	const writable = await fileHandle.createWritable();
+	let writeError = null;
+	try {
+		await writable.write(data);
+		await writable.close();
+	} catch (error) {
+		writeError = error;
+	} finally {
+		if (writeError !== null) try {
+			await writable.abort();
+		} catch {}
+	}
+	if (writeError !== null) {
+		if (writeError instanceof Error) throw writeError;
+		throw new Error(typeof writeError === "string" ? writeError : "File write failed");
+	}
+}
+/**
+* Write a Redux action to the current session's actions directory.
+*
+* @param action - The action object to write
+* @param index - Sequential action index (1-based)
+* @throws Error if no active session
+*/
+async function writeAction(action, index) {
+	if (!actionsHandle) throw new Error("No active session. Call createSession first.");
+	const filename = formatActionFilename(index);
+	await safeWriteToFile(await actionsHandle.getFileHandle(filename, { create: true }), JSON.stringify(action, null, 2));
+}
+/**
+* Write a frame blob to the current session's frames directory.
+*
+* @param blob - Image blob to write
+* @param index - Sequential frame index (1-based)
+* @throws Error if no active session
+*/
+async function writeFrame(blob, index) {
+	if (!framesHandle) throw new Error("No active session. Call createSession first.");
+	const filename = formatFrameFilename(index);
+	await safeWriteToFile(await framesHandle.getFileHandle(filename, { create: true }), blob);
+}
+/**
+* Write session metadata to session.json in the current session directory.
+*
+* @param metadata - Session metadata object
+* @throws Error if no active session
+*/
+async function writeSessionMetadata(metadata) {
+	if (!currentSessionHandle) throw new Error("No active session. Call createSession first.");
+	await safeWriteToFile(await currentSessionHandle.getFileHandle("session.json", { create: true }), JSON.stringify(metadata, null, 2));
+	log.info("Session metadata written");
+}
+/**
+* List all scenario names in OPFS storage.
+*
+* @returns Array of scenario folder names
+*/
+async function listScenarios() {
+	if (!scenariosDir) return [];
+	const scenarios = [];
+	for await (const entry of scenariosDir.values()) if (entry.kind === "directory") scenarios.push(entry.name);
+	return scenarios;
+}
+/**
+* List all session names within a scenario.
+*
+* @param scenarioName - Name of the scenario
+* @returns Array of session folder names
+*/
+async function listSessions(scenarioName) {
+	if (!scenariosDir) return [];
+	try {
+		const scenarioHandle = await scenariosDir.getDirectoryHandle(scenarioName);
+		const sessions = [];
+		for await (const entry of scenarioHandle.values()) if (entry.kind === "directory") sessions.push(entry.name);
+		return sessions;
+	} catch {
+		return [];
+	}
+}
+/**
+* Check storage quota.
+*
+* Note: Prefer calling `initOpfsStorage()` before this function to ensure
+* the Storage API is available. If the Storage Manager API is not supported,
+* returns a safe default of `{ available: 0, used: 0 }`.
+*
+* @returns Available and used storage in bytes
+*/
+async function checkStorageQuota() {
+	if (typeof navigator === "undefined" || !navigator.storage || typeof navigator.storage.estimate !== "function") {
+		log.warn("Storage Manager API not available, returning zero quota");
+		return {
+			available: 0,
+			used: 0
+		};
+	}
+	const estimate = await navigator.storage.estimate();
+	return {
+		available: estimate.quota ?? 0,
+		used: estimate.usage ?? 0
+	};
+}
+//#endregion
+export { checkStorageQuota, createSession, getScenarioHandle, getScenariosRootHandle, getSessionHandle, initOpfsStorage, listScenarios, listSessions, resetOpfsStorage, resetSessionHandles, writeAction, writeFrame, writeSessionMetadata };

package/dist/storage/ref-point-importer.d.ts

@@ -0,0 +1,2 @@
+import { n as RefPointImportResult, r as importRefPointsFromFolder, t as ImportedRefPoint } from "../ref-point-importer-B_wn5ABk.js";
+export { ImportedRefPoint, RefPointImportResult, importRefPointsFromFolder };