gps-plus-slam-app-framework 1.0.0

package/dist/storage/ref-point-importer.js

@@ -0,0 +1,163 @@
+import { createLogger } from "../utils/logger.js";
+import { h3RefsMatch, isH3Index } from "../ref-points/h3-ref-point.js";
+import { BlobReader, TextWriter, ZipReader } from "@zip.js/zip.js";
+//#region ../src/storage/ref-point-importer.ts
+/**
+* Reference Point Importer Module
+*
+* Extracts reference points from ZIP files in a folder, enabling reuse of
+* ref points from previous recording sessions.
+*
+* This module:
+* 1. Enumerates all *.zip files in a folder
+* 2. Opens each ZIP and looks for refPoints/*.json files
+* 3. Parses and validates each ref point definition
+* 4. Merges and deduplicates ref points by ID
+*
+* Uses @zip.js/zip.js for ZIP reading (same library as zip-export.ts).
+*/
+const log = createLogger("RefPointImporter");
+/**
+* Check if a file name is a ZIP file (case-insensitive).
+*/
+function isZipFileName(name) {
+	return name.toLowerCase().endsWith(".zip");
+}
+/**
+* Check if a ZIP entry path is a ref point JSON file.
+* Expected path: refPoints/{id}.json
+*/
+function isRefPointEntry(entryPath) {
+	return entryPath.startsWith("refPoints/") && entryPath.endsWith(".json") && entryPath !== "refPoints/";
+}
+/**
+* Type guard to validate parsed JSON matches RefPointDefinition shape.
+* Validates at least one observation exists with required nested properties.
+*/
+function isValidRefPointDefinition(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const obj = value;
+	if (typeof obj.id !== "string" || typeof obj.name !== "string" || typeof obj.createdAt !== "number" || !Array.isArray(obj.observations)) return false;
+	if (obj.observations.length === 0) return true;
+	const firstObs = obj.observations[0];
+	if (typeof firstObs !== "object" || firstObs === null) return false;
+	const gpsPoint = firstObs.gpsPoint;
+	if (typeof gpsPoint !== "object" || gpsPoint === null || typeof gpsPoint.latitude !== "number" || typeof gpsPoint.longitude !== "number") return false;
+	return true;
+}
+/**
+* Convert a RefPointDefinition to an ImportedRefPoint.
+* Extracts GPS coordinates from the first observation.
+*/
+function toImportedRefPoint(def, sourceZipName) {
+	if (def.observations.length === 0) return null;
+	const firstObs = def.observations[0];
+	return {
+		id: def.id,
+		name: def.name,
+		lat: firstObs.gpsPoint.latitude,
+		lon: firstObs.gpsPoint.longitude,
+		alt: firstObs.gpsPoint.altitude,
+		sourceZipName
+	};
+}
+/**
+* Extract reference points from a single ZIP file.
+*
+* @param zipBlob - The ZIP file as a Blob
+* @param zipFileName - Name of the ZIP file (for error messages)
+* @returns Array of imported ref points and any errors
+*/
+async function extractRefPointsFromZip(zipBlob, zipFileName) {
+	const refPoints = [];
+	const errors = [];
+	const zipReader = new ZipReader(new BlobReader(zipBlob));
+	try {
+		const entries = await zipReader.getEntries();
+		for (const entry of entries) {
+			if (entry.directory) continue;
+			if (!isRefPointEntry(entry.filename)) continue;
+			try {
+				const textWriter = new TextWriter();
+				const jsonText = await entry.getData(textWriter);
+				let parsed;
+				try {
+					parsed = JSON.parse(jsonText);
+				} catch (parseErr) {
+					errors.push(`${zipFileName}/${entry.filename}: Invalid JSON - ${parseErr.message}`);
+					continue;
+				}
+				if (!isValidRefPointDefinition(parsed)) {
+					errors.push(`${zipFileName}/${entry.filename}: Invalid ref point schema`);
+					continue;
+				}
+				const imported = toImportedRefPoint(parsed, zipFileName);
+				if (imported) refPoints.push(imported);
+			} catch (entryErr) {
+				errors.push(`${zipFileName}/${entry.filename}: ${entryErr.message}`);
+			}
+		}
+	} finally {
+		await zipReader.close();
+	}
+	return {
+		refPoints,
+		errors
+	};
+}
+/**
+* Import reference points from all ZIP files in a folder.
+*
+* Enumerates all *.zip files in the folder, extracts refPoints/*.json from each,
+* and merges them into a deduplicated list.
+*
+* Deduplication: If the same ref point ID appears in multiple ZIPs, the first
+* occurrence is kept (based on iteration order).
+*
+* @param folderHandle - Read-only directory handle from showDirectoryPicker
+* @returns Result containing merged ref points, scan count, and errors
+*/
+async function importRefPointsFromFolder(folderHandle) {
+	const allRefPoints = [];
+	const seenIds = /* @__PURE__ */ new Set();
+	const allErrors = [];
+	let zipFilesScanned = 0;
+	log.info(`Scanning folder: ${folderHandle.name}`);
+	try {
+		for await (const entry of folderHandle.values()) {
+			if (entry.kind !== "file" || !isZipFileName(entry.name)) continue;
+			log.debug(`Processing ZIP: ${entry.name}`);
+			try {
+				const { refPoints, errors } = await extractRefPointsFromZip(await (await folderHandle.getFileHandle(entry.name)).getFile(), entry.name);
+				zipFilesScanned++;
+				allErrors.push(...errors);
+				for (const refPoint of refPoints) if (!(isH3Index(refPoint.id) ? allRefPoints.some((existing) => isH3Index(existing.id) && h3RefsMatch(existing.id, refPoint.id)) : seenIds.has(refPoint.id))) {
+					seenIds.add(refPoint.id);
+					allRefPoints.push(refPoint);
+				} else log.debug(`Skipping duplicate ref point: ${refPoint.id} from ${entry.name}`);
+			} catch (zipErr) {
+				const errorMsg = `Failed to process ${entry.name}: ${zipErr.message}`;
+				log.warn(errorMsg);
+				allErrors.push(errorMsg);
+			}
+		}
+		log.info(`Imported ${allRefPoints.length} ref points from ${zipFilesScanned} ZIP files`);
+		return {
+			success: true,
+			refPoints: allRefPoints,
+			zipFilesScanned,
+			errors: allErrors
+		};
+	} catch (err) {
+		const errorMsg = `Failed to scan folder: ${err.message}`;
+		log.error(errorMsg);
+		return {
+			success: false,
+			refPoints: allRefPoints,
+			zipFilesScanned,
+			errors: [...allErrors, errorMsg]
+		};
+	}
+}
+//#endregion
+export { importRefPointsFromFolder };

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

@@ -0,0 +1,2 @@
+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, u as writeRefPointDefinition } from "../ref-point-loader-Pt1smgHS.js";
+export { RefPointDefinition, RefPointMark, RefPointObservation, averageGpsPerRefPoint, flattenRefPointsToMarks, listRefPointIds, loadAllRefPoints, loadRefPoint, saveRefPointObservation, writeRefPointDefinition };

package/dist/storage/ref-point-loader.js

@@ -0,0 +1,248 @@
+import { createLogger } from "../utils/logger.js";
+//#region ../src/storage/ref-point-loader.ts
+const log = createLogger("RefPointLoader");
+/**
+* Check if arPose has required position and rotation arrays.
+*/
+function hasValidArPose(o) {
+	if (typeof o.arPose !== "object" || o.arPose === null) return false;
+	const arPose = o.arPose;
+	return Array.isArray(arPose.position) && Array.isArray(arPose.rotation);
+}
+/**
+* Check if gpsPoint has required lat/lon numbers.
+*/
+function hasValidGpsPoint(o) {
+	if (typeof o.gpsPoint !== "object" || o.gpsPoint === null) return false;
+	const gpsPoint = o.gpsPoint;
+	return typeof gpsPoint.latitude === "number" && typeof gpsPoint.longitude === "number";
+}
+/**
+* Type guard to validate a single observation has required nested properties.
+* Prevents runtime errors from accessing arPose.position or gpsPoint.latitude on malformed data.
+*/
+function isValidObservation(obs) {
+	if (typeof obs !== "object" || obs === null) return false;
+	const o = obs;
+	return hasValidArPose(o) && hasValidGpsPoint(o);
+}
+/**
+* Type guard to validate parsed JSON matches RefPointDefinition shape.
+* Prevents runtime errors from malformed or corrupted JSON files.
+* Also validates each observation to ensure nested properties exist.
+*/
+function isRefPointDefinition(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const obj = value;
+	if (typeof obj.id !== "string" || typeof obj.name !== "string" || typeof obj.createdAt !== "number" || !Array.isArray(obj.observations)) return false;
+	return obj.observations.every(isValidObservation);
+}
+/**
+* Parse a single reference point file and validate its schema.
+* Returns null if parsing fails or schema is invalid.
+*/
+async function parseRefPointFile(fileHandle, fileName) {
+	try {
+		const text = await (await fileHandle.getFile()).text();
+		const parsed = JSON.parse(text);
+		if (isRefPointDefinition(parsed)) return parsed;
+		log.warn(`Invalid schema in ${fileName}`);
+		return null;
+	} catch (parseErr) {
+		log.error(`Failed to parse ${fileName}:`, parseErr);
+		return null;
+	}
+}
+/**
+* Load all reference point definitions from the scenario's refPoints/ directory.
+*
+* @param scenarioHandle - File system handle for the scenario folder
+* @returns Array of all reference point definitions
+*/
+async function loadAllRefPoints(scenarioHandle) {
+	try {
+		const refPointsHandle = await scenarioHandle.getDirectoryHandle("refPoints");
+		const refPoints = [];
+		for await (const [name, handle] of refPointsHandle.entries()) {
+			if (handle.kind !== "file" || !name.endsWith(".json")) continue;
+			const parsed = await parseRefPointFile(handle, name);
+			if (parsed) refPoints.push(parsed);
+		}
+		return refPoints;
+	} catch (err) {
+		log.debug("No refPoints directory found (yet):", err);
+		return [];
+	}
+}
+/**
+* Load a specific reference point by ID.
+*
+* @param scenarioHandle - File system handle for the scenario folder
+* @param pointId - Reference point ID
+* @returns Reference point definition or null if not found
+*/
+async function loadRefPoint(scenarioHandle, pointId) {
+	try {
+		const text = await (await (await (await scenarioHandle.getDirectoryHandle("refPoints")).getFileHandle(`${pointId}.json`)).getFile()).text();
+		const parsed = JSON.parse(text);
+		if (!isRefPointDefinition(parsed)) {
+			log.warn(`Invalid schema for ${pointId}`);
+			return null;
+		}
+		return parsed;
+	} catch (err) {
+		log.debug(`Reference point ${pointId} not found:`, err);
+		return null;
+	}
+}
+/**
+* Save or update a reference point observation.
+* Creates the refPoints/ directory if it doesn't exist.
+* If the reference point exists, appends the new observation.
+* If it doesn't exist, creates a new reference point file.
+*
+* @param scenarioHandle - File system handle for the scenario folder
+* @param pointId - Reference point ID
+* @param pointName - Human-readable name for the reference point
+* @param observation - New observation to add
+*/
+async function saveRefPointObservation(scenarioHandle, pointId, pointName, observation) {
+	try {
+		const refPointsHandle = await scenarioHandle.getDirectoryHandle("refPoints", { create: true });
+		const existing = await loadRefPoint(scenarioHandle, pointId);
+		const definition = existing ? {
+			...existing,
+			observations: [...existing.observations, observation]
+		} : {
+			id: pointId,
+			name: pointName,
+			createdAt: observation.timestamp,
+			observations: [observation]
+		};
+		const writable = await (await refPointsHandle.getFileHandle(`${pointId}.json`, { create: true })).createWritable();
+		let writeError = null;
+		try {
+			await writable.write(JSON.stringify(definition, null, 2));
+			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("OPFS write failed");
+		}
+		log.info(`Saved observation for ${pointId} (${definition.observations.length} total observations)`);
+	} catch (err) {
+		log.error(`Failed to save reference point ${pointId}:`, err);
+		throw err;
+	}
+}
+/**
+* Write a complete RefPointDefinition to OPFS.
+* Creates the refPoints/ directory if it doesn't exist.
+* Used by the recovery flow to restore definitions extracted from ZIPs.
+*
+* @param scenarioHandle - File system handle for the scenario folder
+* @param definition - Complete ref point definition to write
+*/
+async function writeRefPointDefinition(scenarioHandle, definition) {
+	const writable = await (await (await scenarioHandle.getDirectoryHandle("refPoints", { create: true })).getFileHandle(`${definition.id}.json`, { create: true })).createWritable();
+	let writeError = null;
+	try {
+		await writable.write(JSON.stringify(definition, null, 2));
+		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("OPFS write failed");
+	}
+}
+/**
+* Get list of all reference point IDs in the scenario.
+* Useful for autocomplete/suggestions.
+*
+* @param scenarioHandle - File system handle for the scenario folder
+* @returns Array of reference point IDs
+*/
+async function listRefPointIds(scenarioHandle) {
+	try {
+		const refPointsHandle = await scenarioHandle.getDirectoryHandle("refPoints");
+		const ids = [];
+		for await (const [name, handle] of refPointsHandle.entries()) if (handle.kind === "file" && name.endsWith(".json")) ids.push(name.slice(0, -5));
+		return ids.sort();
+	} catch (err) {
+		log.debug("No refPoints directory found (yet):", err);
+		return [];
+	}
+}
+/**
+* Flatten an array of RefPointDefinition objects into individual RefPointMark
+* observations suitable for visualization.
+*
+* @param refPointDefs - Array of reference point definitions with observations
+* @returns Flat array of individual marks (one per observation)
+*/
+function flattenRefPointsToMarks(refPointDefs) {
+	return refPointDefs.flatMap((def) => def.observations.map((obs) => {
+		const src = obs.fusedGpsPoint ?? obs.gpsPoint;
+		const gpsPosition = {
+			lat: src.latitude,
+			lon: src.longitude,
+			altitude: src.altitude
+		};
+		return {
+			id: def.id,
+			odomPosition: obs.arPose.position,
+			odomRotation: obs.arPose.rotation,
+			gpsPosition,
+			timestamp: obs.timestamp
+		};
+	}));
+}
+/**
+* Compute one averaged GPS position per reference point ID.
+* For each observation, prefers `fusedGpsPoint` (sub-meter accuracy) when
+* available, falling back to raw `gpsPoint`. Returns the centroid (mean
+* lat/lon) across all observations.
+*/
+function averageGpsPerRefPoint(refPointDefs) {
+	return refPointDefs.filter((def) => def.observations.length > 0).map((def) => {
+		const coords = def.observations.map((obs) => {
+			if (obs.fusedGpsPoint) return {
+				lat: obs.fusedGpsPoint.latitude,
+				lon: obs.fusedGpsPoint.longitude,
+				alt: obs.fusedGpsPoint.altitude
+			};
+			if (typeof obs.gpsPoint.latitude === "number" && typeof obs.gpsPoint.longitude === "number") return {
+				lat: obs.gpsPoint.latitude,
+				lon: obs.gpsPoint.longitude,
+				alt: obs.gpsPoint.altitude
+			};
+			return null;
+		}).filter((c) => c !== null);
+		if (coords.length === 0) return null;
+		const avgLat = coords.reduce((s, c) => s + c.lat, 0) / coords.length;
+		const avgLon = coords.reduce((s, c) => s + c.lon, 0) / coords.length;
+		const alts = coords.filter((c) => c.alt != null);
+		const avgAlt = alts.length > 0 ? alts.reduce((s, c) => s + c.alt, 0) / alts.length : void 0;
+		return {
+			id: def.id,
+			name: def.name,
+			lat: avgLat,
+			lon: avgLon,
+			alt: avgAlt
+		};
+	}).filter((r) => r !== null);
+}
+//#endregion
+export { averageGpsPerRefPoint, flattenRefPointsToMarks, listRefPointIds, loadAllRefPoints, loadRefPoint, saveRefPointObservation, writeRefPointDefinition };

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

@@ -0,0 +1,28 @@
+import { t as RefPointDefinition } from "../ref-point-loader-Pt1smgHS.js";
+
+//#region ../src/storage/ref-point-recovery.d.ts
+/**
+ * Result of recovering ref point definitions from ZIP files.
+ */
+interface RefPointRecoveryResult {
+  /** Merged, deduplicated RefPointDefinition objects from all ZIPs */
+  readonly definitions: RefPointDefinition[];
+  /** Number of ZIP files successfully scanned */
+  readonly zipFilesScanned: number;
+  /** Error messages from failed ZIPs or malformed ref points */
+  readonly errors: string[];
+}
+/**
+ * Extract full RefPointDefinition objects from all ZIPs in a folder,
+ * merge observations by ref point ID, and return the merged definitions.
+ *
+ * Unlike importRefPointsFromFolder() which returns simplified ImportedRefPoint[],
+ * this preserves full observation data (AR poses, GPS, timestamps) needed for
+ * 3D display and OPFS recovery.
+ *
+ * @param folderHandle - Read-only directory handle from showDirectoryPicker
+ * @returns Result containing merged definitions, scan count, and errors
+ */
+declare function recoverRefPointDefinitionsFromZips(folderHandle: FileSystemDirectoryHandle): Promise<RefPointRecoveryResult>;
+//#endregion
+export { RefPointRecoveryResult, recoverRefPointDefinitionsFromZips };

package/dist/storage/ref-point-recovery.js

@@ -0,0 +1,159 @@
+import { createLogger } from "../utils/logger.js";
+import { BlobReader, TextWriter, ZipReader } from "@zip.js/zip.js";
+//#region ../src/storage/ref-point-recovery.ts
+/**
+* Reference Point Recovery Module
+*
+* Extracts full RefPointDefinition objects from ZIP files in a folder and
+* merges observations by ref point ID. Unlike ref-point-importer.ts (which
+* returns simplified ImportedRefPoint with only lat/lon), this module
+* preserves complete observation data (AR poses, GPS, timestamps) needed
+* for 3D display and OPFS restoration after browser data loss.
+*
+* Used by the recovery flow: when OPFS is empty after browser data clear,
+* this module reconstructs the full scenario-level ref point state from
+* session ZIPs so the user can continue recording with prior ref points visible.
+*
+* Uses @zip.js/zip.js for ZIP reading (same library as zip-export.ts
+* and ref-point-importer.ts).
+*/
+const log = createLogger("RefPointRecovery");
+function isZipFileName(name) {
+	return name.toLowerCase().endsWith(".zip");
+}
+function isRefPointEntry(entryPath) {
+	return entryPath.startsWith("refPoints/") && entryPath.endsWith(".json") && entryPath !== "refPoints/";
+}
+/**
+* Validate parsed JSON matches RefPointDefinition shape.
+* Looser than ref-point-loader's validator: accepts empty observations
+* (schema-valid, preserves identity) and doesn't require arPose/gpsPoint
+* validation on every observation (the importer's validator already checks
+* first obs structure).
+*/
+function isValidRefPointDefinition(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const obj = value;
+	if (typeof obj.id !== "string" || typeof obj.name !== "string" || typeof obj.createdAt !== "number" || !Array.isArray(obj.observations)) return false;
+	return true;
+}
+/**
+* Extract full RefPointDefinition objects from a single ZIP file.
+*/
+async function extractDefinitionsFromZip(zipBlob, zipFileName) {
+	const definitions = [];
+	const errors = [];
+	const zipReader = new ZipReader(new BlobReader(zipBlob));
+	try {
+		const entries = await zipReader.getEntries();
+		for (const entry of entries) {
+			if (entry.directory) continue;
+			if (!isRefPointEntry(entry.filename)) continue;
+			try {
+				const textWriter = new TextWriter();
+				const jsonText = await entry.getData(textWriter);
+				let parsed;
+				try {
+					parsed = JSON.parse(jsonText);
+				} catch (parseErr) {
+					errors.push(`${zipFileName}/${entry.filename}: Invalid JSON - ${parseErr.message}`);
+					continue;
+				}
+				if (!isValidRefPointDefinition(parsed)) {
+					errors.push(`${zipFileName}/${entry.filename}: Invalid ref point schema`);
+					continue;
+				}
+				definitions.push(parsed);
+			} catch (entryErr) {
+				errors.push(`${zipFileName}/${entry.filename}: ${entryErr.message}`);
+			}
+		}
+	} finally {
+		await zipReader.close();
+	}
+	return {
+		definitions,
+		errors
+	};
+}
+/**
+* Merge observations from multiple RefPointDefinitions with the same ID.
+* Deduplicates observations by sessionId + timestamp.
+* Uses earliest createdAt and first-encountered name.
+*/
+function mergeDefinitions(allDefs) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const def of allDefs) {
+		let entry = byId.get(def.id);
+		if (!entry) {
+			entry = {
+				def: {
+					id: def.id,
+					name: def.name,
+					createdAt: def.createdAt,
+					observations: []
+				},
+				seen: /* @__PURE__ */ new Set()
+			};
+			byId.set(def.id, entry);
+		} else if (def.createdAt < entry.def.createdAt) entry.def.createdAt = def.createdAt;
+		for (const obs of def.observations) {
+			const key = `${obs.sessionId}:${obs.timestamp}`;
+			if (!entry.seen.has(key)) {
+				entry.seen.add(key);
+				entry.def.observations.push(obs);
+			}
+		}
+	}
+	return Array.from(byId.values()).map((e) => e.def).sort((a, b) => a.createdAt - b.createdAt);
+}
+/**
+* Extract full RefPointDefinition objects from all ZIPs in a folder,
+* merge observations by ref point ID, and return the merged definitions.
+*
+* Unlike importRefPointsFromFolder() which returns simplified ImportedRefPoint[],
+* this preserves full observation data (AR poses, GPS, timestamps) needed for
+* 3D display and OPFS recovery.
+*
+* @param folderHandle - Read-only directory handle from showDirectoryPicker
+* @returns Result containing merged definitions, scan count, and errors
+*/
+async function recoverRefPointDefinitionsFromZips(folderHandle) {
+	const allDefinitions = [];
+	const allErrors = [];
+	let zipFilesScanned = 0;
+	log.info(`Recovery scan: ${folderHandle.name}`);
+	try {
+		for await (const entry of folderHandle.values()) {
+			if (entry.kind !== "file" || !isZipFileName(entry.name)) continue;
+			log.debug(`Processing ZIP: ${entry.name}`);
+			try {
+				const { definitions, errors } = await extractDefinitionsFromZip(await entry.getFile(), entry.name);
+				zipFilesScanned++;
+				allErrors.push(...errors);
+				allDefinitions.push(...definitions);
+			} catch (zipErr) {
+				const errorMsg = `Failed to process ${entry.name}: ${zipErr.message}`;
+				log.warn(errorMsg);
+				allErrors.push(errorMsg);
+			}
+		}
+		const merged = mergeDefinitions(allDefinitions);
+		log.info(`Recovered ${merged.length} ref points from ${zipFilesScanned} ZIP files`);
+		return {
+			definitions: merged,
+			zipFilesScanned,
+			errors: allErrors
+		};
+	} catch (err) {
+		const errorMsg = `Failed to scan folder: ${err.message}`;
+		log.error(errorMsg);
+		return {
+			definitions: mergeDefinitions(allDefinitions),
+			zipFilesScanned,
+			errors: [...allErrors, errorMsg]
+		};
+	}
+}
+//#endregion
+export { recoverRefPointDefinitionsFromZips };

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

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

package/dist/storage/storage-backend.js

@@ -0,0 +1 @@
+export {};

package/dist/storage/zip-export.d.ts

@@ -0,0 +1,2 @@
+import { a as syncToExternalZip, i as exportSessionAsZip, n as downloadZip, r as exportAndDownloadSession, t as ZipExportResult } from "../zip-export-Rtpi75JJ.js";
+export { ZipExportResult, downloadZip, exportAndDownloadSession, exportSessionAsZip, syncToExternalZip };