gps-plus-slam-app-framework 1.0.0

package/dist/test-utils/zip-round-trip-helpers.js

@@ -0,0 +1,207 @@
+import { createSession, initOpfsStorage, resetOpfsStorage, writeAction, writeFrame, writeSessionMetadata } from "../storage/opfs-storage.js";
+import { exportSessionAsZip } from "../storage/zip-export.js";
+import { installOPFSMocks } from "./browser-mocks.js";
+//#region ../src/test-utils/zip-round-trip-helpers.ts
+/**
+* Round-Trip Test Helpers — Produce realistic recording zips programmatically.
+*
+* Why this exists: Tests need recording zip files for the replay pipeline,
+* zip-reader, and state verification. Rather than depending on static
+* pre-recorded zips (which go stale as the app evolves), this helper
+* produces zips using the real OPFS mock + export pipeline, ensuring the
+* test data always matches the current production format.
+*
+* The helper writes actions via writeAction(), writes frames via writeFrame(),
+* writes session metadata via writeSessionMetadata(), and exports via
+* exportSessionAsZip(). OPFS mocks are installed and cleaned up internally
+* — no side effects leak to the calling test.
+*
+* DESIGN BOUNDARY — VALID ZIPS ONLY
+*
+* This helper intentionally produces only valid, realistic zips. Do NOT add
+* options to generate broken/incomplete zips (missing session.json, malformed
+* JSON, missing actions, etc.). Its value comes from exercising the real
+* production pipeline end-to-end — mixing in "intentionally broken" modes
+* would undermine that contract.
+*
+* For error-handling / robustness tests, use hand-crafted zips via ZipWriter
+* directly — see createZipWithActions() in zip-reader.test.ts for the
+* established pattern. That approach gives precise byte-level control over
+* exactly what's broken, which is strictly better for negative test cases.
+*/
+const DEFAULTS = {
+	scenarioName: "TestScenario",
+	sessionTimestamp: /* @__PURE__ */ new Date("2026-03-01T09:00:00Z"),
+	gpsEventCount: 10,
+	imagesBeforeSetZero: 2,
+	imagesAfterSetZero: 5,
+	frameCount: 2,
+	deviceInfo: "TestDevice Android 14",
+	zeroPos: {
+		lat: 50,
+		lon: 8
+	}
+};
+/**
+* Produce a realistic recording zip using the real OPFS mock + export pipeline.
+*
+* Action sequence produced (with defaults):
+*   1. recorder/startSession        (index 1)
+*   2. gpsData/add2dImage × 2       (indices 2-3, before setZeroPos — dropped on replay)
+*   3. gpsData/setZeroPos            (index 4)
+*   4. gpsData/recordGpsEvent × 10   (indices 5-14)
+*   5. gpsData/add2dImage × 5        (indices 15-19, after setZeroPos — kept on replay)
+*
+* GPS events use varied odom/GPS positions that produce a non-identity
+* alignment matrix when replayed through the library store.
+*
+* OPFS mocks are installed and cleaned up within this function.
+*/
+async function produceTestZip(opts) {
+	const options = {
+		...DEFAULTS,
+		...opts
+	};
+	const { cleanup } = installOPFSMocks();
+	try {
+		await initOpfsStorage();
+		const { scenarioName, sessionName } = await createSession(options.scenarioName, options.sessionTimestamp);
+		const allActions = [];
+		let actionIndex = 0;
+		/** Increment index, persist to OPFS, and record for later assertions. */
+		const writeAndRecordAction = async (action) => {
+			actionIndex++;
+			await writeAction(action, actionIndex);
+			allActions.push(action);
+		};
+		await writeAndRecordAction({
+			type: "recorder/startSession",
+			payload: {
+				scenarioName: options.scenarioName,
+				sessionName,
+				startTime: options.sessionTimestamp.getTime(),
+				deviceInfo: options.deviceInfo
+			}
+		});
+		for (let i = 0; i < options.imagesBeforeSetZero; i++) await writeAndRecordAction({
+			type: "gpsData/add2dImage",
+			payload: {
+				imageFile: `frames/frame-${String(actionIndex + 1).padStart(6, "0")}.jpg`,
+				position: [
+					i * .5,
+					0,
+					0
+				],
+				rotation: [
+					0,
+					0,
+					0,
+					1
+				],
+				screenRotation: 0,
+				capturedAt: options.sessionTimestamp.getTime() + actionIndex * 1e3
+			}
+		});
+		await writeAndRecordAction({
+			type: "gpsData/setZeroPos",
+			payload: {
+				lat: options.zeroPos.lat,
+				lon: options.zeroPos.lon
+			}
+		});
+		for (let i = 0; i < options.gpsEventCount; i++) {
+			const t = options.sessionTimestamp.getTime() + (actionIndex + 1) * 1e3;
+			const angle = i / Math.max(options.gpsEventCount - 1, 1) * Math.PI * .5;
+			const radius = (i + 1) * 2;
+			await writeAndRecordAction({
+				type: "gpsData/recordGpsEvent",
+				payload: {
+					odomPosition: [
+						radius * Math.cos(angle),
+						0,
+						radius * Math.sin(angle)
+					],
+					odomRotation: [
+						0,
+						0,
+						0,
+						1
+					],
+					rawGpsPoint: {
+						id: `gps-event-${i + 1}`,
+						latitude: options.zeroPos.lat + (i + 1) * 1e-4,
+						longitude: options.zeroPos.lon + (i + 1) * 1e-4,
+						timestamp: t
+					}
+				}
+			});
+		}
+		const postZeroImageOffset = options.imagesBeforeSetZero;
+		for (let i = 0; i < options.imagesAfterSetZero; i++) {
+			const imgIdx = postZeroImageOffset + i + 1;
+			await writeAndRecordAction({
+				type: "gpsData/add2dImage",
+				payload: {
+					imageFile: `frames/frame-${String(imgIdx).padStart(6, "0")}.jpg`,
+					position: [
+						(i + 1) * 1,
+						(i + 1) * .5,
+						0
+					],
+					rotation: [
+						0,
+						0,
+						0,
+						1
+					],
+					screenRotation: i % 4,
+					capturedAt: options.sessionTimestamp.getTime() + actionIndex * 1e3
+				}
+			});
+		}
+		for (let i = 0; i < options.frameCount; i++) {
+			const jpegHeader = [
+				255,
+				216,
+				255,
+				224
+			];
+			const body = Array.from({ length: 10 }, (_, j) => i * 10 + j & 255);
+			const frameBytes = new Uint8Array([...jpegHeader, ...body]);
+			await writeFrame(new Blob([frameBytes], { type: "image/jpeg" }), i + 1);
+		}
+		await writeSessionMetadata({
+			version: 1,
+			startedAt: options.sessionTimestamp.toISOString(),
+			endedAt: new Date(options.sessionTimestamp.getTime() + actionIndex * 1e3 + 5e3).toISOString(),
+			scenarioName: options.scenarioName,
+			actionCount: actionIndex,
+			frameCount: options.frameCount,
+			userAgent: options.deviceInfo
+		});
+		const { blob } = await exportSessionAsZip(scenarioName, sessionName);
+		return {
+			zipData: new Uint8Array(await blob.arrayBuffer()),
+			totalActionCount: actionIndex,
+			gpsEventCount: options.gpsEventCount,
+			imageActions: {
+				totalCount: options.imagesBeforeSetZero + options.imagesAfterSetZero,
+				beforeSetZero: options.imagesBeforeSetZero,
+				afterSetZero: options.imagesAfterSetZero
+			},
+			scenarioName: options.scenarioName,
+			sessionName,
+			startTime: options.sessionTimestamp.getTime(),
+			deviceInfo: options.deviceInfo,
+			hasSessionJson: true,
+			zeroPos: options.zeroPos,
+			actions: allActions,
+			frameCount: options.frameCount
+		};
+	} finally {
+		resetOpfsStorage();
+		cleanup();
+	}
+}
+//#endregion
+export { produceTestZip };

package/dist/three-dispose-CCBHjE_a.d.ts

@@ -0,0 +1,30 @@
+import * as THREE from "three";
+
+//#region ../src/visualization/three-dispose.d.ts
+interface DisposeOptions {
+  /** When true, skip geometry.dispose() — useful for shared geometries. */
+  readonly skipGeometry?: boolean;
+  /** When true, skip material.dispose() (and its map texture) — useful for shared materials. */
+  readonly skipMaterial?: boolean;
+}
+/**
+ * Traverse an Object3D and all its descendants, disposing GPU resources:
+ * geometries (Mesh), materials (Mesh + Sprite), and material textures.
+ *
+ * Does NOT remove root from its parent — callers handle that.
+ *
+ * @param root The Object3D tree root to clean up.
+ * @param opts Optional flags (e.g. skipGeometry for shared geometries).
+ */
+declare function disposeObject3D(root: THREE.Object3D, opts?: DisposeOptions): void;
+/**
+ * Remove meshes from a parent, dispose their GPU resources, and clear
+ * the array in-place.
+ *
+ * @param meshes Array of meshes (mutated — emptied after disposal).
+ * @param parent The Object3D to remove meshes from. Pass null/undefined to skip removal.
+ * @param opts   Optional flags (e.g. skipGeometry for shared geometries).
+ */
+declare function disposeMeshArray(meshes: THREE.Mesh[], parent?: THREE.Object3D | null, opts?: DisposeOptions): void;
+//#endregion
+export { disposeMeshArray as n, disposeObject3D as r, DisposeOptions as t };

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

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

package/dist/types/ar-types.d.ts

@@ -0,0 +1,2 @@
+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";
+export { ARPose, ArPoseTuples, DepthPoint, DepthSample, WebXRQuaternion, WebXRVec3 };

package/dist/types/ar-types.js

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

package/dist/types/geo-types.d.ts

@@ -0,0 +1,2 @@
+import { n as RefPointMarker, t as GpsCoord } from "../geo-types-Xx-LVcnw.js";
+export { GpsCoord, RefPointMarker };

package/dist/types/geo-types.js

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

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+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 { n as RefPointMarker, t as GpsCoord } from "../geo-types-Xx-LVcnw.js";
+export { ARPose, ArPoseTuples, DepthPoint, DepthSample, GpsCoord, RefPointMarker, WebXRQuaternion, WebXRVec3 };

package/dist/types/index.js

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

package/dist/utils/concurrency.d.ts

@@ -0,0 +1,2 @@
+import { t as mapWithConcurrencyLimit } from "../concurrency-p6gB30fT.js";
+export { mapWithConcurrencyLimit };

package/dist/utils/concurrency.js

@@ -0,0 +1,40 @@
+//#region ../src/utils/concurrency.ts
+/**
+* Concurrency Utilities
+*
+* Provides helpers for limiting the number of concurrent async operations.
+* Used to prevent excessive memory consumption when scanning many files
+* in parallel (e.g., reading zip metadata during scenario discovery).
+*/
+/**
+* Map over an array with a concurrency limit on the async mapper function.
+*
+* Behaves like `Promise.all(items.map(fn))` but limits how many mapper
+* invocations run simultaneously. Results are returned in the same order
+* as the input items.
+*
+* @param items - Array of items to process
+* @param limit - Maximum number of concurrent mapper invocations
+* @param mapper - Async function to apply to each item
+* @returns Array of results in the same order as input items
+* @throws Re-throws the first error from any mapper invocation (fail-fast)
+*/
+async function mapWithConcurrencyLimit(items, limit, mapper) {
+	if (limit < 1) throw new RangeError(`Concurrency limit must be >= 1, got ${limit}`);
+	const results = new Array(items.length);
+	if (items.length === 0) return results;
+	let nextIndex = 0;
+	const worker = async () => {
+		while (nextIndex < items.length) {
+			const currentIndex = nextIndex++;
+			results[currentIndex] = await mapper(items[currentIndex], currentIndex);
+		}
+	};
+	const workerCount = Math.min(limit, items.length);
+	const workers = [];
+	for (let i = 0; i < workerCount; i++) workers.push(worker());
+	await Promise.all(workers);
+	return results;
+}
+//#endregion
+export { mapWithConcurrencyLimit };

package/dist/utils/failure-tracker.d.ts

@@ -0,0 +1,2 @@
+import { n as FailureTrackerConfig, r as createFailureTracker, t as FailureTracker } from "../failure-tracker-1sQ_Cgyw.js";
+export { FailureTracker, FailureTrackerConfig, createFailureTracker };

package/dist/utils/failure-tracker.js

@@ -0,0 +1,48 @@
+import { createLogger } from "./logger.js";
+//#region ../src/utils/failure-tracker.ts
+/**
+* Generic Failure Tracker Factory
+*
+* Shared pattern extracted from capture-failure-tracker and write-failure-tracker.
+* Tracks consecutive failures, warns the user once when a threshold is exceeded,
+* and supports session-level reset.
+*/
+/**
+* Create a generic failure tracker.
+*
+* @param config - Tracker configuration
+* @returns A FailureTracker instance
+*/
+function createFailureTracker(config) {
+	const { label, warningMessage, defaultThreshold, onWarning, logLevel = "warn" } = config;
+	const threshold = config.failureThreshold ?? defaultThreshold;
+	const log = createLogger(label);
+	let consecutiveFailures = 0;
+	let warningShown = false;
+	return {
+		recordSuccess() {
+			consecutiveFailures = 0;
+		},
+		recordFailure(error) {
+			consecutiveFailures++;
+			if (logLevel === "error") log.error(`${label} failure #${consecutiveFailures}:`, error);
+			else log.warn(`${label} failure #${consecutiveFailures}`);
+			if (consecutiveFailures >= threshold && !warningShown) {
+				warningShown = true;
+				onWarning(warningMessage);
+			}
+		},
+		getFailureCount() {
+			return consecutiveFailures;
+		},
+		hasWarned() {
+			return warningShown;
+		},
+		reset() {
+			consecutiveFailures = 0;
+			warningShown = false;
+		}
+	};
+}
+//#endregion
+export { createFailureTracker };

package/dist/utils/format-file-size.d.ts

@@ -0,0 +1,2 @@
+import { t as formatFileSize } from "../format-file-size-onGq0k1Q.js";
+export { formatFileSize };

package/dist/utils/format-file-size.js

@@ -0,0 +1,41 @@
+//#region ../src/utils/format-file-size.ts
+/**
+* Format File Size Utility
+*
+* Converts byte counts to human-readable file size strings (B, KB, MB, GB).
+* Used by session summary to display ZIP file statistics.
+*
+* @see 2026-02-06 User Feedback Issue #3: ZIP stats on summary screen
+*/
+const UNITS = [
+	"B",
+	"KB",
+	"MB",
+	"GB"
+];
+const THRESHOLD = 1024;
+/**
+* Format a byte count into a human-readable string.
+*
+* @param bytes - Number of bytes (non-negative integer expected)
+* @returns Formatted string like "512 B", "1.5 KB", "23.4 MB", "1.0 GB"
+*
+* @example
+* formatFileSize(0)          // "0 B"
+* formatFileSize(512)        // "512 B"
+* formatFileSize(1048576)    // "1.0 MB"
+* formatFileSize(2500000000) // "2.3 GB"
+*/
+function formatFileSize(bytes) {
+	if (bytes <= 0) return "0 B";
+	let value = bytes;
+	let unitIndex = 0;
+	while (value >= THRESHOLD && unitIndex < UNITS.length - 1) {
+		value /= THRESHOLD;
+		unitIndex++;
+	}
+	if (unitIndex === 0) return `${Math.round(value)} B`;
+	return `${value.toFixed(1)} ${UNITS[unitIndex]}`;
+}
+//#endregion
+export { formatFileSize };

package/dist/utils/fused-path.d.ts

@@ -0,0 +1,2 @@
+import { n as computeFusedPath, r as fusedGpsFromOdom, t as FusedPathInput } from "../fused-path-DtqCSqJh.js";
+export { FusedPathInput, computeFusedPath, fusedGpsFromOdom };

package/dist/utils/fused-path.js

@@ -0,0 +1,44 @@
+import { calcGpsCoords, fusedGpsFromOdom } from "gps-plus-slam-js";
+import { mat4, vec3 } from "gl-matrix";
+//#region ../src/utils/fused-path.ts
+/**
+* Fused Path Calculation
+*
+* Transforms AR odometry positions into GPS coordinates using the alignment matrix.
+* This enables displaying the "fused" SLAM+GPS trajectory on the session summary map.
+*
+* The alignment matrix (computed by the alignment solver in the library) transforms
+* AR-local odometry positions into NUE (North-Up-East) meters relative to a
+* GPS zero reference point. We then convert NUE to lat/lng for Leaflet.
+*
+* Internal coordinate convention: X=North, Y=Up, Z=East (right-handed).
+*
+* @see docs/2026-01-27-user-feedback.md Issue #4b
+*/
+/**
+* Compute the fused GPS path from odometry positions using the alignment matrix.
+*
+* Each odometry position is transformed by the alignment matrix to get ENU
+* coordinates (meters relative to zeroRef), then converted to GPS lat/lng.
+*
+* @param input - Odometry positions, alignment matrix, and GPS zero reference
+* @returns Array of GPS coordinates suitable for Leaflet polyline
+*/
+function computeFusedPath(input) {
+	const { odometryPositions, alignmentMatrix, zeroRef } = input;
+	if (!alignmentMatrix || !zeroRef || odometryPositions.length === 0) return [];
+	const matrix = mat4.fromValues(...alignmentMatrix);
+	const odomVec = vec3.create();
+	const alignedVec = vec3.create();
+	return odometryPositions.map((odomPos) => {
+		vec3.set(odomVec, odomPos[0], odomPos[1], odomPos[2]);
+		vec3.transformMat4(alignedVec, odomVec, matrix);
+		const gpsCoord = calcGpsCoords(zeroRef, alignedVec);
+		return {
+			lat: gpsCoord.lat,
+			lng: gpsCoord.lon
+		};
+	});
+}
+//#endregion
+export { computeFusedPath, fusedGpsFromOdom };

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+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 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";
+export { type FailureTracker, type FailureTrackerConfig, type FusedPathInput, type LogEntry, LogLevel, type Logger, clearLogBuffer, computeFusedPath, createFailureTracker, createLogger, formatFileSize, fusedGpsFromOdom, getGlobalLogLevel, getLogBuffer, listFormatter, mapWithConcurrencyLimit, setGlobalLogLevel, subscribeToLogs };

package/dist/utils/index.js

@@ -0,0 +1,7 @@
+import { LogLevel, clearLogBuffer, createLogger, getGlobalLogLevel, getLogBuffer, setGlobalLogLevel, subscribeToLogs } from "./logger.js";
+import { createFailureTracker } from "./failure-tracker.js";
+import { computeFusedPath, fusedGpsFromOdom } from "./fused-path.js";
+import { mapWithConcurrencyLimit } from "./concurrency.js";
+import { formatFileSize } from "./format-file-size.js";
+import { listFormatter } from "./list-formatter.js";
+export { LogLevel, clearLogBuffer, computeFusedPath, createFailureTracker, createLogger, formatFileSize, fusedGpsFromOdom, getGlobalLogLevel, getLogBuffer, listFormatter, mapWithConcurrencyLimit, setGlobalLogLevel, subscribeToLogs };

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

@@ -0,0 +1,2 @@
+import { t as listFormatter } from "../list-formatter-DKQQVLcl.js";
+export { listFormatter };

package/dist/utils/list-formatter.js

@@ -0,0 +1,17 @@
+//#region ../src/utils/list-formatter.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"
+*/
+const listFormatter = new Intl.ListFormat("en", {
+	style: "long",
+	type: "conjunction"
+});
+//#endregion
+export { listFormatter };

package/dist/utils/logger.d.ts

@@ -0,0 +1,2 @@
+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";
+export { LogEntry, LogLevel, Logger, clearLogBuffer, createLogger, getGlobalLogLevel, getLogBuffer, setGlobalLogLevel, subscribeToLogs };