@loggerjs/browser 0.6.0 → 0.7.0

package/dist/index.js

@@ -1,4137 +1,27 @@
-import { addContextProvider, applyPayloadTransforms, encodedPayloadToUint8Array, formatBaggage, formatTraceparent, incrementLoggerMetaCounter, normalizeValue, parseBaggage, parseTraceparent, recordToEvent, retryTransport, safeJsonCodec, safeJsonStringify, toLevelValue } from "@loggerjs/core";
+import { browserBroadcastChannelTransport } from "./broadcast-channel-transport.js";
+import { browserHttpTransport, memoryBrowserHttpOfflineQueue } from "./http-transport.js";
+import { browserCompressionPayloadTransform } from "./payload-transforms.js";
+import { browserServiceWorkerTransport } from "./service-worker-transport.js";
+import { browserWebSocketTransport } from "./websocket-transport.js";
+import { indexedDbBrowserHttpOfflineQueue } from "./indexeddb-offline-queue.js";
+import { indexedDbTransport } from "./indexeddb-transport.js";
+import { offlineFirstTransport } from "./offline-first-transport.js";
+import { createLogZipBlob, downloadBlob, exportLogsToZip } from "./zip-export.js";
+import { captureConsoleIntegration } from "./console-integration.js";
+import { browserContextPropagationIntegration } from "./context-propagation-integration.js";
+import { captureBrowserErrorsIntegration } from "./error-integration.js";
+import { captureFetchIntegration } from "./fetch-integration.js";
+import { captureXHRIntegration } from "./xhr-integration.js";
+import { captureFrameworkErrorsIntegration } from "./framework-error-integration.js";
+import { nextRouterIntegration, nuxtRouterIntegration, reactRouterIntegration, vueRouterIntegration } from "./framework-router-integrations.js";
+import { captureReportingIntegration } from "./reporting-integration.js";
+import { captureRouterIntegration } from "./router-integration.js";
+import { captureRuntimeHostIntegration } from "./runtime-host-integration.js";
+import { captureServiceWorkerIntegration } from "./service-worker-integration.js";
+import { captureUserActionsIntegration } from "./user-action-integration.js";
+import { captureWebSocketIntegration } from "./websocket-integration.js";
+import { captureWebVitalsIntegration } from "./web-vitals-integration.js";
+import { capturePerformanceIntegration, normalizeBrowserPerformanceEntry } from "./performance-integration.js";
+import { pageLifecycleIntegration } from "./page-lifecycle.js";
 export * from "@loggerjs/core";
-//#region src/broadcast-channel-transport.ts
-let sourceSequence$1 = 0;
-function createSourceId$1() {
-	sourceSequence$1 += 1;
-	return `loggerjs-${Date.now().toString(36)}-${sourceSequence$1.toString(36)}`;
-}
-function defaultChannelFactory(channelName) {
-	if (typeof BroadcastChannel === "undefined") throw new Error("BroadcastChannel is not available");
-	return new BroadcastChannel(channelName);
-}
-function defaultMapEvent$1(event, context) {
-	return {
-		type: "loggerjs.event",
-		source: context.source,
-		event
-	};
-}
-function defaultMapBatch$1(events, context) {
-	return {
-		type: "loggerjs.batch",
-		source: context.source,
-		events
-	};
-}
-function browserBroadcastChannelTransport(options) {
-	const transportName = options.name ?? "browser-broadcast-channel";
-	const source = options.source ?? createSourceId$1();
-	const mapContext = {
-		channelName: options.channelName,
-		source
-	};
-	const mapEvent = options.mapEvent ?? defaultMapEvent$1;
-	const mapBatch = options.mapBatch ?? defaultMapBatch$1;
-	const channelFactory = options.channelFactory ?? defaultChannelFactory;
-	const closeChannelOnClose = options.closeChannelOnClose ?? true;
-	let channel;
-	let closed = false;
-	const reportError = (error, context, detail) => {
-		if (detail.droppedEvents > 0) {
-			incrementLoggerMetaCounter("transport.dropped", detail.droppedEvents);
-			incrementLoggerMetaCounter(`transport.dropped.${detail.operation}`, detail.droppedEvents);
-		}
-		try {
-			options.onError?.(error, detail);
-		} catch (onErrorError) {
-			context?.reportInternalError(onErrorError, {
-				operation: "on-error",
-				phase: "transport",
-				transport: transportName
-			});
-		}
-		context?.reportInternalError(error, {
-			operation: detail.operation,
-			phase: "transport",
-			transport: transportName
-		});
-	};
-	const getChannel = (context) => {
-		if (closed) return void 0;
-		if (channel) return channel;
-		try {
-			channel = channelFactory(options.channelName);
-			return channel;
-		} catch (error) {
-			reportError(error, context, {
-				droppedEvents: 1,
-				operation: "create-channel"
-			});
-			return;
-		}
-	};
-	const postMessage = (message, context, droppedEvents) => {
-		const currentChannel = getChannel(context);
-		if (!currentChannel) return;
-		try {
-			currentChannel.postMessage(message);
-		} catch (error) {
-			reportError(error, context, {
-				droppedEvents,
-				operation: "post-message"
-			});
-		}
-	};
-	return {
-		name: transportName,
-		minLevel: options.minLevel,
-		log(event, context) {
-			postMessage(mapEvent(event, mapContext), context, 1);
-		},
-		logBatch(events, context) {
-			if (events.length === 0) return;
-			postMessage(mapBatch(events, mapContext), context, events.length);
-		},
-		async close() {
-			closed = true;
-			if (!channel || !closeChannelOnClose) return;
-			try {
-				channel.close?.();
-			} catch (error) {
-				reportError(error, void 0, {
-					droppedEvents: 0,
-					operation: "close-channel"
-				});
-			} finally {
-				channel = void 0;
-			}
-		}
-	};
-}
-//#endregion
-//#region src/http-transport.ts
-const DEFAULT_BEACON_MAX_BYTES = 60 * 1024;
-const sleep = (delayMs) => delayMs <= 0 ? Promise.resolve() : new Promise((resolve) => setTimeout(resolve, delayMs));
-function memoryBrowserHttpOfflineQueue(options = {}) {
-	const entries = [];
-	const maxEntries = options.maxEntries ?? 1e3;
-	const dropPolicy = options.dropPolicy ?? "drop-oldest";
-	const drop = (entry, reason) => {
-		incrementLoggerMetaCounter("transport.offline.dropped");
-		incrementLoggerMetaCounter(`transport.offline.dropped.${reason}`);
-		options.onDrop?.(entry, reason);
-	};
-	return {
-		enqueue(entry) {
-			if (entries.length >= maxEntries) {
-				if (dropPolicy === "drop-newest") {
-					drop(entry, "queue-full");
-					return;
-				}
-				const dropped = entries.shift();
-				if (dropped) drop(dropped, "queue-full");
-			}
-			entries.push(entry);
-		},
-		async replay(send) {
-			while (entries.length > 0) {
-				const entry = entries[0];
-				if (!entry) return;
-				await send(entry);
-				entries.shift();
-			}
-		},
-		size() {
-			return entries.length;
-		}
-	};
-}
-function payloadToBody(payload) {
-	if (typeof payload === "string") return payload;
-	return Uint8Array.from(payload);
-}
-function payloadByteLength$1(payload) {
-	if (typeof payload !== "string") return payload.byteLength;
-	if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(payload).byteLength;
-	return new Blob([payload]).size;
-}
-function payloadToBeaconBody(payload, contentType) {
-	return new Blob([typeof payload === "string" ? payload : Uint8Array.from(payload)], { type: contentType });
-}
-function remainingEvents(chunks, startIndex) {
-	const events = [];
-	for (let index = startIndex; index < chunks.length; index++) {
-		const chunk = chunks[index];
-		if (chunk) events.push(...chunk.events);
-	}
-	return events;
-}
-function browserHttpTransport(options) {
-	const codec = options.codec ?? safeJsonCodec();
-	const beaconCodec = options.beaconCodec ?? codec;
-	const queue = [];
-	const maxBatchSize = options.maxBatchSize ?? 50;
-	if (!Number.isSafeInteger(maxBatchSize) || maxBatchSize <= 0) throw new RangeError("maxBatchSize must be a positive safe integer");
-	const flushIntervalMs = options.flushIntervalMs ?? 2e3;
-	const maxQueueSize = options.maxQueueSize ?? 1e3;
-	const dropPolicy = options.dropPolicy ?? "drop-oldest";
-	const beaconMaxBytes = options.beaconMaxBytes ?? DEFAULT_BEACON_MAX_BYTES;
-	const offlineQueue = options.offlineQueue;
-	const offlineReplayMaxRetries = options.offlineReplayMaxRetries ?? 3;
-	const offlineReplayBaseDelayMs = options.offlineReplayBaseDelayMs ?? 250;
-	const offlineReplayMaxDelayMs = options.offlineReplayMaxDelayMs ?? 5e3;
-	const random = options.random ?? Math.random;
-	const fetchFn = options.fetchFn ?? globalThis.fetch?.bind(globalThis);
-	let offlineEntrySeq = 0;
-	let timer;
-	let activeFlush;
-	let flushingBeacon = false;
-	let replayPromise;
-	let lastContext;
-	const headers = (payloadHeaders, contentType = codec.contentType) => ({
-		"content-type": contentType,
-		...payloadHeaders,
-		...options.headers
-	});
-	const clearTimer = () => {
-		if (timer) clearTimeout(timer);
-		timer = void 0;
-	};
-	const reportDrop = (event, reason) => {
-		incrementLoggerMetaCounter("transport.dropped");
-		incrementLoggerMetaCounter(`transport.dropped.${reason}`);
-		options.onDrop?.(event, reason);
-	};
-	const reportInternalError = (error, operation) => {
-		lastContext?.reportInternalError(error, {
-			phase: "transport",
-			transport: options.name ?? "browser-http",
-			operation
-		});
-	};
-	const createBeaconChunks = (batch) => {
-		const chunks = [];
-		const oversized = [];
-		let currentEvents = [];
-		let currentPayload;
-		for (const event of batch) {
-			if (currentEvents.length === maxBatchSize && currentPayload !== void 0) {
-				chunks.push({
-					events: currentEvents,
-					payload: currentPayload
-				});
-				currentEvents = [];
-				currentPayload = void 0;
-			}
-			const candidateEvents = [...currentEvents, event];
-			const candidatePayload = beaconCodec.encode(candidateEvents);
-			if (payloadByteLength$1(candidatePayload) <= beaconMaxBytes) {
-				currentEvents = candidateEvents;
-				currentPayload = candidatePayload;
-				continue;
-			}
-			if (currentEvents.length > 0 && currentPayload !== void 0) chunks.push({
-				events: currentEvents,
-				payload: currentPayload
-			});
-			const singlePayload = beaconCodec.encode([event]);
-			if (payloadByteLength$1(singlePayload) <= beaconMaxBytes) {
-				currentEvents = [event];
-				currentPayload = singlePayload;
-			} else {
-				currentEvents = [];
-				currentPayload = void 0;
-				oversized.push(event);
-			}
-		}
-		if (currentEvents.length > 0 && currentPayload !== void 0) chunks.push({
-			events: currentEvents,
-			payload: currentPayload
-		});
-		for (const event of oversized) reportDrop(event, "beacon-too-large");
-		return chunks;
-	};
-	const sendBeaconBatch = (batch) => {
-		if (typeof navigator === "undefined" || !navigator.sendBeacon) return { remaining: batch };
-		const chunks = createBeaconChunks(batch);
-		for (let index = 0; index < chunks.length; index++) {
-			const chunk = chunks[index];
-			if (!chunk) continue;
-			try {
-				if (!navigator.sendBeacon(options.url, payloadToBeaconBody(chunk.payload, beaconCodec.contentType))) return { remaining: remainingEvents(chunks, index) };
-			} catch (error) {
-				return {
-					remaining: remainingEvents(chunks, index),
-					failure: { error }
-				};
-			}
-		}
-		return { remaining: [] };
-	};
-	const sendPayload = async (entry) => {
-		if (!fetchFn) throw new Error("fetch is not available for browserHttpTransport");
-		const response = await fetchFn(entry.url, {
-			method: entry.method,
-			headers: entry.headers,
-			body: payloadToBody(entry.body),
-			credentials: entry.credentials,
-			keepalive: entry.keepalive
-		});
-		if (!response.ok) throw new Error(`browserHttpTransport failed with status ${response.status}`);
-	};
-	const encodeTransformedPayload = async (batch) => {
-		return applyPayloadTransforms(codec.encode(batch), {
-			contentType: codec.contentType,
-			events: batch,
-			transport: options.name ?? "browser-http"
-		}, options.transformPayload);
-	};
-	const createOfflineEntry = (payload, payloadHeaders, contentType) => ({
-		id: `${Date.now().toString(36)}-${(offlineEntrySeq++).toString(36)}`,
-		url: options.url,
-		method: options.method ?? "POST",
-		headers: headers(payloadHeaders, contentType),
-		body: payload,
-		credentials: options.credentials,
-		keepalive: options.keepalive ?? true,
-		createdAt: Date.now()
-	});
-	const enqueueOfflinePayload = async (payload, payloadHeaders, contentType) => {
-		if (!offlineQueue) return false;
-		await offlineQueue.enqueue(createOfflineEntry(payload, payloadHeaders, contentType));
-		incrementLoggerMetaCounter("transport.offline.queued");
-		return true;
-	};
-	const isOnline = () => typeof navigator === "undefined" || navigator.onLine !== false;
-	const sendFetchBatch = async (batch) => {
-		const transformed = await encodeTransformedPayload(batch);
-		if (offlineQueue && !isOnline()) {
-			await enqueueOfflinePayload(transformed.payload, transformed.headers, transformed.contentType);
-			return "queued";
-		}
-		try {
-			await sendPayload(createOfflineEntry(transformed.payload, transformed.headers, transformed.contentType));
-			return "sent";
-		} catch (error) {
-			if (await enqueueOfflinePayload(transformed.payload, transformed.headers, transformed.contentType)) return "queued";
-			throw error;
-		}
-	};
-	const replayRetryDelay = (attempt) => {
-		const cap = Math.min(offlineReplayMaxDelayMs, offlineReplayBaseDelayMs * 2 ** attempt);
-		return cap <= 0 ? 0 : random() * cap;
-	};
-	const sendOfflineEntryWithRetry = async (entry) => {
-		for (let attempt = 0;; attempt++) try {
-			await sendPayload(entry);
-			incrementLoggerMetaCounter("transport.offline.replayed");
-			return;
-		} catch (error) {
-			if (attempt >= offlineReplayMaxRetries) {
-				incrementLoggerMetaCounter("transport.offline.replay.failed");
-				throw error;
-			}
-			incrementLoggerMetaCounter("transport.offline.retry");
-			await sleep(replayRetryDelay(attempt));
-		}
-	};
-	const replayOfflineQueue = () => {
-		if (!offlineQueue) return Promise.resolve();
-		replayPromise ??= (async () => {
-			try {
-				await offlineQueue.replay(sendOfflineEntryWithRetry);
-			} finally {
-				replayPromise = void 0;
-			}
-		})();
-		return replayPromise;
-	};
-	const replayOfflineQueueSafely = async (operation) => {
-		if (!offlineQueue || !isOnline()) return;
-		try {
-			await replayOfflineQueue();
-		} catch (error) {
-			reportInternalError(error, operation);
-		}
-	};
-	const flushBeaconQueue = () => {
-		if (flushingBeacon || options.transformPayload || queue.length === 0) return;
-		flushingBeacon = true;
-		let pending = queue.splice(0, queue.length);
-		try {
-			const result = sendBeaconBatch(pending);
-			pending = result.remaining;
-			if (result.failure) throw result.failure.error;
-		} finally {
-			if (pending.length > 0) queue.unshift(...pending);
-			flushingBeacon = false;
-		}
-	};
-	const flush = (preferBeacon = false) => {
-		if (activeFlush) {
-			if (preferBeacon) try {
-				flushBeaconQueue();
-			} catch (error) {
-				return activeFlush.then(() => {
-					throw error;
-				});
-			}
-			return activeFlush;
-		}
-		if (queue.length === 0) return preferBeacon ? Promise.resolve() : replayOfflineQueueSafely("replay");
-		clearTimer();
-		let resolve;
-		let reject;
-		const task = new Promise((onResolve, onReject) => {
-			resolve = onResolve;
-			reject = onReject;
-		});
-		activeFlush = task;
-		(async () => {
-			try {
-				if (preferBeacon) flushBeaconQueue();
-				let sent = false;
-				let queued = false;
-				while (queue.length > 0) {
-					const batch = queue.splice(0, maxBatchSize);
-					try {
-						if (await sendFetchBatch(batch) === "sent") sent = true;
-						else queued = true;
-					} catch (error) {
-						queue.unshift(...batch);
-						throw error;
-					}
-				}
-				if (!preferBeacon && sent && !queued) await replayOfflineQueueSafely("replay");
-				resolve();
-			} catch (error) {
-				reject(error);
-			} finally {
-				activeFlush = void 0;
-				if (queue.length > 0) schedule();
-			}
-		})();
-		return task;
-	};
-	const schedule = () => {
-		if (activeFlush || timer || flushIntervalMs <= 0) return;
-		timer = setTimeout(() => {
-			timer = void 0;
-			flush(false).catch((error) => reportInternalError(error, "flush"));
-		}, flushIntervalMs);
-	};
-	const onPageHide = () => {
-		flush(true).catch((error) => reportInternalError(error, "pagehide-flush"));
-	};
-	const onVisibilityChange = () => {
-		if (typeof document !== "undefined" && document.visibilityState === "hidden") flush(true).catch((error) => reportInternalError(error, "visibility-flush"));
-	};
-	const onOnline = () => {
-		replayOfflineQueue().catch((error) => reportInternalError(error, "replay"));
-	};
-	if (options.useBeaconOnPageHide ?? true) {
-		globalThis.addEventListener?.("pagehide", onPageHide);
-		globalThis.addEventListener?.("visibilitychange", onVisibilityChange);
-	}
-	if (offlineQueue) {
-		globalThis.addEventListener?.("online", onOnline);
-		if (options.offlineReplayOnStart ?? true) setTimeout(() => void replayOfflineQueueSafely("startup-replay"), 0);
-	}
-	return {
-		name: options.name ?? "browser-http",
-		minLevel: options.minLevel,
-		log(event, context) {
-			if (options.minLevel !== void 0 && event.level < toLevelValue(options.minLevel)) return;
-			lastContext = context;
-			if (queue.length >= maxQueueSize) {
-				if (dropPolicy === "drop-newest") {
-					reportDrop(event, "queue-full");
-					return;
-				}
-				const dropped = queue.shift();
-				if (dropped) reportDrop(dropped, "queue-full");
-			}
-			queue.push(event);
-			if (activeFlush) return;
-			if (queue.length >= maxBatchSize) flush(false).catch((error) => reportInternalError(error, "flush"));
-			else schedule();
-		},
-		flush() {
-			return flush(false);
-		},
-		close() {
-			globalThis.removeEventListener?.("pagehide", onPageHide);
-			globalThis.removeEventListener?.("visibilitychange", onVisibilityChange);
-			globalThis.removeEventListener?.("online", onOnline);
-			return flush(true);
-		}
-	};
-}
-//#endregion
-//#region src/payload-transforms.ts
-async function compressWithStream(payload, format, streamFactory) {
-	const stream = (streamFactory ?? ((nextFormat) => {
-		if (typeof CompressionStream === "undefined") throw new Error("CompressionStream is not available in this browser");
-		return new CompressionStream(nextFormat);
-	}))(format);
-	const writer = stream.writable.getWriter();
-	await writer.write(Uint8Array.from(payload));
-	await writer.close();
-	return new Uint8Array(await new Response(stream.readable).arrayBuffer());
-}
-function browserCompressionPayloadTransform(options = {}) {
-	const format = options.format ?? "gzip";
-	return async (payload, context) => ({
-		payload: await (options.compress ? options.compress(encodedPayloadToUint8Array(payload), {
-			...context,
-			format
-		}) : compressWithStream(encodedPayloadToUint8Array(payload), format, options.streamFactory)),
-		headers: {
-			"content-encoding": format,
-			...options.headers
-		}
-	});
-}
-//#endregion
-//#region src/service-worker-transport.ts
-let sourceSequence = 0;
-function createSourceId() {
-	sourceSequence += 1;
-	return `loggerjs-${Date.now().toString(36)}-${sourceSequence.toString(36)}`;
-}
-function defaultMapEvent(event, context) {
-	return {
-		type: "loggerjs.event",
-		source: context.source,
-		event
-	};
-}
-function defaultMapBatch(events, context) {
-	return {
-		type: "loggerjs.batch",
-		source: context.source,
-		events
-	};
-}
-function serviceWorkerContainer() {
-	return typeof navigator === "undefined" ? void 0 : navigator.serviceWorker;
-}
-function workerFromRegistration(registration) {
-	return registration.active ?? registration.waiting ?? registration.installing ?? void 0;
-}
-function browserServiceWorkerTransport(options = {}) {
-	const transportName = options.name ?? "browser-service-worker";
-	const target = options.target ?? "controller";
-	const source = options.source ?? createSourceId();
-	const maxQueueSize = options.maxQueueSize ?? 1e3;
-	const dropPolicy = options.dropPolicy ?? "drop-oldest";
-	const mapContext = {
-		source,
-		target
-	};
-	const mapEvent = options.mapEvent ?? defaultMapEvent;
-	const mapBatch = options.mapBatch ?? defaultMapBatch;
-	const queue = [];
-	let readyWorker;
-	let readyPromise;
-	let lastContext;
-	const reportError = (error, context, operation, droppedEvents = 0) => {
-		try {
-			options.onError?.(error, {
-				droppedEvents,
-				operation
-			});
-		} catch (onErrorError) {
-			context?.reportInternalError(onErrorError, {
-				operation: "on-error",
-				phase: "transport",
-				transport: transportName
-			});
-		}
-		context?.reportInternalError(error, {
-			operation,
-			phase: "transport",
-			transport: transportName
-		});
-	};
-	const reportDrop = (item, reason) => {
-		incrementLoggerMetaCounter("transport.dropped", item.events.length);
-		incrementLoggerMetaCounter(`transport.dropped.${reason}`, item.events.length);
-		for (const event of item.events) options.onDrop?.(event, reason);
-	};
-	const currentWorker = () => {
-		const container = options.serviceWorker ?? serviceWorkerContainer();
-		if (!container) return void 0;
-		if (target === "controller") return container.controller ?? void 0;
-		return readyWorker;
-	};
-	const post = (worker, item, context) => {
-		try {
-			worker.postMessage(item.message, options.transfer?.(item.message));
-			return true;
-		} catch (error) {
-			reportDrop(item, "post-message");
-			reportError(error, context, "post-message", item.events.length);
-			return false;
-		}
-	};
-	const drain = (context = lastContext) => {
-		const worker = currentWorker();
-		if (!worker || !context) return;
-		while (queue.length > 0) {
-			const item = queue.shift();
-			if (!item) return;
-			post(worker, item, context);
-		}
-	};
-	const dropQueued = (reason) => {
-		const pending = queue.splice(0);
-		for (const item of pending) reportDrop(item, reason);
-		return pending.reduce((total, item) => total + item.events.length, 0);
-	};
-	const waitForReady = (context) => {
-		if (currentWorker()) return Promise.resolve();
-		if (target !== "ready") return Promise.reject(/* @__PURE__ */ new Error("service worker controller is not available"));
-		if (readyPromise) return readyPromise;
-		const container = options.serviceWorker ?? serviceWorkerContainer();
-		if (!container?.ready) {
-			const error = /* @__PURE__ */ new Error("serviceWorker.ready is not available");
-			reportError(error, context, "ready", dropQueued("ready"));
-			return Promise.reject(error);
-		}
-		readyPromise = container.ready.then((registration) => {
-			readyWorker = workerFromRegistration(registration);
-			if (!readyWorker) throw new Error("service worker registration has no active worker");
-			drain(context ?? lastContext);
-		}).catch((error) => {
-			readyPromise = void 0;
-			const droppedEvents = dropQueued("ready");
-			reportError(error, context ?? lastContext, "ready", droppedEvents);
-			throw error;
-		});
-		return readyPromise;
-	};
-	const startReady = (context) => {
-		waitForReady(context).catch(() => {});
-	};
-	const enqueue = (item) => {
-		if (queue.length >= maxQueueSize) {
-			if (dropPolicy === "drop-newest") {
-				reportDrop(item, "queue-full");
-				return false;
-			}
-			const dropped = queue.shift();
-			if (dropped) reportDrop(dropped, "queue-full");
-		}
-		queue.push(item);
-		return true;
-	};
-	const send = (item, context) => {
-		lastContext = context;
-		const worker = currentWorker();
-		if (worker) {
-			post(worker, item, context);
-			return;
-		}
-		if (target === "ready") {
-			if (enqueue(item)) startReady(context);
-			return;
-		}
-		reportDrop(item, "unavailable");
-		reportError(/* @__PURE__ */ new Error("service worker controller is not available"), context, "unavailable", item.events.length);
-	};
-	return {
-		name: transportName,
-		minLevel: options.minLevel,
-		queueSize() {
-			return queue.length;
-		},
-		ready() {
-			return waitForReady();
-		},
-		log(event, context) {
-			send({
-				events: [event],
-				message: mapEvent(event, mapContext)
-			}, context);
-		},
-		logBatch(events, context) {
-			if (events.length === 0) return;
-			send({
-				events,
-				message: mapBatch(events, mapContext)
-			}, context);
-		},
-		flush() {
-			drain();
-		},
-		close() {
-			const pending = queue.splice(0);
-			for (const item of pending) reportDrop(item, "closed");
-		}
-	};
-}
-//#endregion
-//#region src/websocket-transport.ts
-const WS_CONNECTING = 0;
-const WS_OPEN = 1;
-function defaultWebSocketFactory(url, protocols) {
-	if (typeof WebSocket === "undefined") throw new Error("WebSocket is not available");
-	return new WebSocket(url, protocols);
-}
-function toSendPayload(payload) {
-	if (typeof payload === "string") return payload;
-	return Uint8Array.from(payload);
-}
-function browserWebSocketTransport(options) {
-	const transportName = options.name ?? "browser-websocket";
-	const codec = options.codec ?? safeJsonCodec();
-	const maxQueueSize = options.maxQueueSize ?? 1e3;
-	const dropPolicy = options.dropPolicy ?? "drop-oldest";
-	const webSocketFactory = options.webSocketFactory ?? defaultWebSocketFactory;
-	const queue = [];
-	let active;
-	let closed = false;
-	let lastContext;
-	const reportDrop = (item, reason) => {
-		incrementLoggerMetaCounter("transport.dropped", item.events.length);
-		incrementLoggerMetaCounter(`transport.dropped.${reason}`, item.events.length);
-		for (const event of item.events) options.onDrop?.(event, reason);
-	};
-	const reportError = (error, context, detail) => {
-		try {
-			options.onError?.(error, detail);
-		} catch (onErrorError) {
-			context?.reportInternalError(onErrorError, {
-				operation: "on-error",
-				phase: "transport",
-				transport: transportName
-			});
-		}
-		context?.reportInternalError(error, {
-			operation: detail.operation,
-			phase: "transport",
-			transport: transportName
-		});
-	};
-	const detachSocket = () => {
-		if (!active) return;
-		const current = active;
-		current.socket.removeEventListener("open", current.onOpen);
-		current.socket.removeEventListener("close", current.onClose);
-		current.socket.removeEventListener("error", current.onError);
-		active = void 0;
-	};
-	const drainQueue = (context = lastContext) => {
-		const socket = active?.socket;
-		if (!socket || socket.readyState !== WS_OPEN) return;
-		while (queue.length > 0) {
-			const item = queue.shift();
-			if (!item) return;
-			try {
-				socket.send(toSendPayload(item.payload));
-			} catch (error) {
-				reportDrop(item, "send");
-				reportError(error, context, {
-					droppedEvents: item.events.length,
-					operation: "send"
-				});
-				return;
-			}
-		}
-	};
-	const createSocket = (context, droppedEvents) => {
-		if (closed) return void 0;
-		if (active && (active.socket.readyState === WS_CONNECTING || active.socket.readyState === WS_OPEN)) return active.socket;
-		detachSocket();
-		try {
-			const socket = webSocketFactory(options.url, options.protocols);
-			const nextActive = {
-				socket,
-				onOpen() {
-					drainQueue(context);
-				},
-				onClose() {
-					if (active?.socket === socket) detachSocket();
-				},
-				onError(errorEvent) {
-					reportError(errorEvent, context, {
-						droppedEvents: 0,
-						operation: "socket-error"
-					});
-				}
-			};
-			active = nextActive;
-			socket.addEventListener("open", nextActive.onOpen);
-			socket.addEventListener("close", nextActive.onClose);
-			socket.addEventListener("error", nextActive.onError);
-			return socket;
-		} catch (error) {
-			reportError(error, context, {
-				droppedEvents,
-				operation: "create-socket"
-			});
-			return;
-		}
-	};
-	const enqueue = (item) => {
-		if (queue.length >= maxQueueSize) {
-			if (dropPolicy === "drop-newest") {
-				reportDrop(item, "queue-full");
-				return false;
-			}
-			const dropped = queue.shift();
-			if (dropped) reportDrop(dropped, "queue-full");
-		}
-		queue.push(item);
-		return true;
-	};
-	const sendOrQueue = (item, context) => {
-		lastContext = context;
-		if (closed) {
-			reportDrop(item, "closed");
-			return;
-		}
-		const socket = createSocket(context, item.events.length);
-		if (!socket) {
-			reportDrop(item, "create-socket");
-			return;
-		}
-		if (socket.readyState === WS_OPEN) {
-			try {
-				socket.send(toSendPayload(item.payload));
-			} catch (error) {
-				reportDrop(item, "send");
-				reportError(error, context, {
-					droppedEvents: item.events.length,
-					operation: "send"
-				});
-			}
-			return;
-		}
-		enqueue(item);
-	};
-	return {
-		name: transportName,
-		minLevel: options.minLevel,
-		queueSize() {
-			return queue.length;
-		},
-		log(event, context) {
-			sendOrQueue({
-				events: [event],
-				payload: codec.encode(event)
-			}, context);
-		},
-		logBatch(events, context) {
-			if (events.length === 0) return;
-			sendOrQueue({
-				events,
-				payload: codec.encode(events)
-			}, context);
-		},
-		flush() {
-			drainQueue();
-		},
-		async close() {
-			closed = true;
-			while (queue.length > 0) {
-				const item = queue.shift();
-				if (item) reportDrop(item, "closed");
-			}
-			const socket = active?.socket;
-			detachSocket();
-			if (!socket) return;
-			try {
-				socket.close(options.closeCode, options.closeReason);
-			} catch (error) {
-				reportError(error, lastContext, {
-					droppedEvents: 0,
-					operation: "close-socket"
-				});
-			}
-		}
-	};
-}
-//#endregion
-//#region src/indexeddb-offline-queue.ts
-const DEFAULT_DB_NAME$1 = "loggerjs";
-const DEFAULT_STORE_NAME$1 = "browser-http-offline";
-function normalizeMaxEntries(value) {
-	if (value === void 0 || !Number.isFinite(value)) return 1e3;
-	return Math.max(0, Math.floor(value));
-}
-function requestToPromise$1(request) {
-	return new Promise((resolve, reject) => {
-		request.addEventListener("success", () => resolve(request.result), { once: true });
-		request.addEventListener("error", () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB request failed")), { once: true });
-	});
-}
-function compareEntries$1(a, b) {
-	if (a.createdAt !== b.createdAt) return a.createdAt - b.createdAt;
-	return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-}
-function orderEntries$1(entries) {
-	const ordered = [];
-	for (const entry of entries) {
-		let index = 0;
-		while (index < ordered.length && compareEntries$1(ordered[index], entry) <= 0) index += 1;
-		ordered.splice(index, 0, entry);
-	}
-	return ordered;
-}
-function indexedDbBrowserHttpOfflineQueue(options = {}) {
-	const dbName = options.dbName ?? DEFAULT_DB_NAME$1;
-	const storeName = options.storeName ?? DEFAULT_STORE_NAME$1;
-	const maxEntries = normalizeMaxEntries(options.maxEntries);
-	const dropPolicy = options.dropPolicy ?? "drop-oldest";
-	const idb = options.indexedDB ?? globalThis.indexedDB;
-	let dbPromise;
-	const drop = (entry, reason) => {
-		incrementLoggerMetaCounter("transport.offline.dropped");
-		incrementLoggerMetaCounter(`transport.offline.dropped.${reason}`);
-		options.onDrop?.(entry, reason);
-	};
-	const openDb = () => {
-		if (!idb) throw new Error("IndexedDB is not available for loggerjs offline queue");
-		dbPromise ??= new Promise((resolve, reject) => {
-			const request = idb.open(dbName, 1);
-			request.addEventListener("upgradeneeded", () => {
-				const db = request.result;
-				if (!db.objectStoreNames.contains(storeName)) db.createObjectStore(storeName, { keyPath: "id" });
-			});
-			request.addEventListener("success", () => resolve(request.result), { once: true });
-			request.addEventListener("error", () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB open failed")), { once: true });
-		});
-		return dbPromise;
-	};
-	const withStore = async (mode, run) => {
-		return run((await openDb()).transaction(storeName, mode).objectStore(storeName));
-	};
-	const getEntries = async () => orderEntries$1(await withStore("readonly", (store) => requestToPromise$1(store.getAll())));
-	const putEntry = (entry) => withStore("readwrite", (store) => requestToPromise$1(store.put(entry)));
-	const deleteEntry = (id) => withStore("readwrite", (store) => requestToPromise$1(store.delete(id)));
-	return {
-		async enqueue(entry) {
-			if (maxEntries === 0) {
-				drop(entry, "queue-full");
-				return;
-			}
-			const entries = await getEntries();
-			if (entries.length >= maxEntries) {
-				if (dropPolicy === "drop-newest") {
-					drop(entry, "queue-full");
-					return;
-				}
-				const dropCount = entries.length - maxEntries + 1;
-				for (let index = 0; index < dropCount; index += 1) {
-					const dropped = entries[index];
-					if (!dropped) continue;
-					await deleteEntry(dropped.id);
-					drop(dropped, "queue-full");
-				}
-			}
-			await putEntry(entry);
-		},
-		async replay(send) {
-			const entries = await getEntries();
-			for (const entry of entries) {
-				await send(entry);
-				await deleteEntry(entry.id);
-			}
-		},
-		async size() {
-			return (await getEntries()).length;
-		},
-		clear() {
-			return withStore("readwrite", (store) => requestToPromise$1(store.clear()));
-		},
-		close() {
-			const promise = dbPromise;
-			dbPromise = void 0;
-			promise?.then((db) => db.close());
-		}
-	};
-}
-//#endregion
-//#region src/indexeddb-transport.ts
-const DEFAULT_DB_NAME = "loggerjs";
-const DEFAULT_STORE_NAME = "logs";
-const DEFAULT_SESSION_CONTEXT_KEY$1 = "sessionId";
-const DEFAULT_SPILL_MAX_ENTRIES = 200;
-const DEFAULT_SPILL_MAX_BYTES = 512 * 1024;
-const DEFAULT_SPILL_MAX_ORIGIN_BYTES = 5 * 1024 * 1024;
-const DB_VERSION = 4;
-const ORDER_INDEX_NAME = "createdAtSeq";
-const SESSION_INDEX_NAME = "sessionId";
-const SESSION_ORDER_INDEX_NAME = "sessionIdCreatedAtSeq";
-const SESSION_STORE_SUFFIX = "__sessions";
-const SESSION_LAST_SEEN_INDEX_NAME = "lastSeenSessionId";
-const SPILL_SCHEMA = "loggerjs.indexeddb-spill.v1";
-function normalizePositiveInteger(value, fallback) {
-	if (value === void 0 || !Number.isFinite(value)) return fallback;
-	return Math.max(0, Math.floor(value));
-}
-let fallbackSessionSeq = 0;
-function defaultPageSessionId() {
-	const randomUUID = globalThis.crypto?.randomUUID;
-	if (randomUUID) return randomUUID.call(globalThis.crypto);
-	return `${Date.now().toString(36)}-${(fallbackSessionSeq++).toString(36)}`;
-}
-function normalizeSessionId(value) {
-	if (typeof value !== "string") return void 0;
-	const normalized = value.trim();
-	return normalized.length > 0 ? normalized : void 0;
-}
-function normalizeSessionOptions(session) {
-	if (session === false) return void 0;
-	if (typeof session === "string") return {
-		contextKey: DEFAULT_SESSION_CONTEXT_KEY$1,
-		id: normalizeSessionId(session) ?? defaultPageSessionId()
-	};
-	return {
-		contextKey: session?.contextKey ?? DEFAULT_SESSION_CONTEXT_KEY$1,
-		getId: session?.getId,
-		id: normalizeSessionId(session?.id) ?? defaultPageSessionId()
-	};
-}
-function resolveLocalStorage(storage) {
-	if (storage) return storage;
-	try {
-		return globalThis.localStorage;
-	} catch {
-		return;
-	}
-}
-function normalizeLocalStorageSpillOptions(spill, dbName, storeName) {
-	if (!spill) return void 0;
-	const storage = resolveLocalStorage(spill.storage);
-	if (!storage) return void 0;
-	const namespace = spill.namespace ?? `${dbName}:${storeName}`;
-	return {
-		drainOnCreate: spill.drainOnCreate ?? true,
-		key: `loggerjs:spill:v1:${namespace}`,
-		maxBytes: normalizePositiveInteger(spill.maxBytes, DEFAULT_SPILL_MAX_BYTES),
-		maxEntries: normalizePositiveInteger(spill.maxEntries, DEFAULT_SPILL_MAX_ENTRIES),
-		maxOriginBytes: normalizePositiveInteger(spill.maxOriginBytes, DEFAULT_SPILL_MAX_ORIGIN_BYTES),
-		minLevelValue: spill.minLevel === void 0 ? void 0 : toLevelValue(spill.minLevel),
-		onDrop: spill.onDrop,
-		spillOnPageHide: spill.spillOnPageHide ?? true,
-		storage
-	};
-}
-function storageByteLength(key, value) {
-	return 2 * (key.length + value.length);
-}
-function estimateLocalStorageBytes(storage) {
-	try {
-		let total = 0;
-		for (let index = 0; index < storage.length; index += 1) {
-			const key = storage.key(index);
-			if (key === null) continue;
-			total += storageByteLength(key, storage.getItem(key) ?? "");
-		}
-		return total;
-	} catch {
-		return;
-	}
-}
-function isQuotaExceededError(error) {
-	return typeof DOMException !== "undefined" && error instanceof DOMException && (error.name === "QuotaExceededError" || error.name === "NS_ERROR_DOM_QUOTA_REACHED");
-}
-function isSpillLogEvent(value) {
-	if (!value || typeof value !== "object") return false;
-	const event = value;
-	return typeof event.id === "string" && typeof event.time === "number" && typeof event.seq === "number" && typeof event.level === "number" && typeof event.levelName === "string" && typeof event.logger === "string" && typeof event.message === "string";
-}
-function parseSpillPayload(raw) {
-	const parsed = JSON.parse(raw);
-	if (parsed.schema !== SPILL_SCHEMA || !Array.isArray(parsed.entries)) return void 0;
-	return parsed.entries.filter(isSpillLogEvent);
-}
-function nowMs$1() {
-	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
-}
-function incrementRecord(record, key, amount = 1) {
-	record[key] = (record[key] ?? 0) + amount;
-}
-function requestToPromise(request) {
-	return new Promise((resolve, reject) => {
-		request.addEventListener("success", () => resolve(request.result), { once: true });
-		request.addEventListener("error", () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB request failed")), { once: true });
-	});
-}
-function transactionToPromise(transaction) {
-	return new Promise((resolve, reject) => {
-		transaction.addEventListener("complete", () => resolve(), { once: true });
-		transaction.addEventListener("abort", () => reject(transaction.error ?? /* @__PURE__ */ new Error("IndexedDB transaction aborted")), { once: true });
-		transaction.addEventListener("error", () => reject(transaction.error ?? /* @__PURE__ */ new Error("IndexedDB transaction failed")), { once: true });
-	});
-}
-function payloadByteLength(payload) {
-	if (typeof payload !== "string") return payload.byteLength;
-	if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(payload).byteLength;
-	return new Blob([payload]).size;
-}
-function compareEntries(a, b) {
-	if (a.createdAt !== b.createdAt) return a.createdAt - b.createdAt;
-	if (a.seq !== b.seq) return a.seq - b.seq;
-	return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-}
-function orderEntries(entries, order = "asc") {
-	const sorted = [...entries].sort(compareEntries);
-	if (order === "asc") return sorted;
-	const reversed = [];
-	for (let index = sorted.length - 1; index >= 0; index -= 1) reversed.push(sorted[index]);
-	return reversed;
-}
-function indexExists(store, name) {
-	return store.indexNames.contains(name);
-}
-function ensureIndex(store, name, keyPath) {
-	if (!indexExists(store, name)) store.createIndex(name, keyPath);
-}
-function sessionStoreNameFor(storeName) {
-	return `${storeName}${SESSION_STORE_SUFFIX}`;
-}
-function getStoreIndex(store, name) {
-	const maybeStore = store;
-	if (typeof maybeStore.index !== "function" || !indexExists(store, name)) return void 0;
-	return maybeStore.index(name);
-}
-function getStorageBucketManager() {
-	return globalThis.navigator?.storageBuckets;
-}
-function storageBucketOpenOptions(options) {
-	if (options.storageBucketDurability === void 0 && options.storageBucketPersisted === void 0) return;
-	return {
-		durability: options.storageBucketDurability,
-		persisted: options.storageBucketPersisted
-	};
-}
-function decodeEntry(entry, codec) {
-	if (!codec.decode) throw new Error("indexedDbTransport query requires a codec with decode");
-	const decoded = codec.decode(entry.payload);
-	return Array.isArray(decoded) ? decoded[0] : decoded;
-}
-function shouldKeepEntry(entry, options) {
-	if (options.from !== void 0 && entry.createdAt < options.from) return false;
-	if (options.to !== void 0 && entry.createdAt > options.to) return false;
-	if (options.sessionId !== void 0 && entry.sessionId !== options.sessionId) return false;
-	if (options.minLevel !== void 0 && entry.level < toLevelValue(options.minLevel)) return false;
-	if (options.logger !== void 0 && entry.logger !== options.logger) return false;
-	if (options.type !== void 0 && entry.type !== options.type) return false;
-	return true;
-}
-function addSessionSummary(sessions, entry) {
-	if (!entry.sessionId) return;
-	const current = sessions.get(entry.sessionId);
-	if (current) {
-		current.firstSeen = Math.min(current.firstSeen, entry.createdAt);
-		current.lastSeen = Math.max(current.lastSeen, entry.createdAt);
-		current.count += 1;
-		current.byteLength += entry.byteLength;
-		return;
-	}
-	sessions.set(entry.sessionId, {
-		byteLength: entry.byteLength,
-		count: 1,
-		firstSeen: entry.createdAt,
-		lastSeen: entry.createdAt,
-		sessionId: entry.sessionId
-	});
-}
-function mergeSessionSummary(current, incoming) {
-	if (!current) return incoming;
-	return {
-		byteLength: current.byteLength + incoming.byteLength,
-		count: current.count + incoming.count,
-		firstSeen: Math.min(current.firstSeen, incoming.firstSeen),
-		lastSeen: Math.max(current.lastSeen, incoming.lastSeen),
-		sessionId: incoming.sessionId
-	};
-}
-function orderSessions(sessions, order = "desc") {
-	const sorted = [...sessions].sort((left, right) => {
-		if (left.lastSeen !== right.lastSeen) return left.lastSeen - right.lastSeen;
-		return left.sessionId < right.sessionId ? -1 : left.sessionId > right.sessionId ? 1 : 0;
-	});
-	if (order === "asc") return sorted;
-	const reversed = [];
-	for (let index = sorted.length - 1; index >= 0; index -= 1) reversed.push(sorted[index]);
-	return reversed;
-}
-function orderRangeForQuery(options) {
-	if (typeof IDBKeyRange === "undefined") return void 0;
-	if (options.sessionId !== void 0) {
-		const lower = [
-			options.sessionId,
-			options.from ?? Number.MIN_SAFE_INTEGER,
-			Number.MIN_SAFE_INTEGER,
-			""
-		];
-		const upper = [
-			options.sessionId,
-			options.to ?? Number.MAX_SAFE_INTEGER,
-			Number.MAX_SAFE_INTEGER,
-			"￿"
-		];
-		return IDBKeyRange.bound(lower, upper);
-	}
-	const lower = options.from === void 0 ? void 0 : [
-		options.from,
-		Number.MIN_SAFE_INTEGER,
-		""
-	];
-	const upper = options.to === void 0 ? void 0 : [
-		options.to,
-		Number.MAX_SAFE_INTEGER,
-		"￿"
-	];
-	if (lower && upper) return IDBKeyRange.bound(lower, upper);
-	if (lower) return IDBKeyRange.lowerBound(lower);
-	if (upper) return IDBKeyRange.upperBound(upper);
-}
-function orderRangeForSessionId(sessionId) {
-	if (typeof IDBKeyRange === "undefined") return void 0;
-	return IDBKeyRange.bound([
-		sessionId,
-		Number.MIN_SAFE_INTEGER,
-		Number.MIN_SAFE_INTEGER,
-		""
-	], [
-		sessionId,
-		Number.MAX_SAFE_INTEGER,
-		Number.MAX_SAFE_INTEGER,
-		"￿"
-	]);
-}
-function migrateSessionSummaries(logStore, sessionStore) {
-	const summaries = /* @__PURE__ */ new Map();
-	const request = logStore.openCursor();
-	request.addEventListener("success", () => {
-		const cursor = request.result;
-		if (!cursor) {
-			for (const summary of summaries.values()) sessionStore.put(summary);
-			return;
-		}
-		addSessionSummary(summaries, cursor.value);
-		cursor.continue();
-	});
-}
-function iterateCursor(request, visit) {
-	return new Promise((resolve, reject) => {
-		request.addEventListener("success", () => {
-			const cursor = request.result;
-			if (!cursor) {
-				resolve();
-				return;
-			}
-			try {
-				if (visit(cursor) === false) {
-					resolve();
-					return;
-				}
-				cursor.continue();
-			} catch (error) {
-				reject(error);
-			}
-		}, false);
-		request.addEventListener("error", () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB cursor failed")), { once: true });
-	});
-}
-function indexedDbTransport(options = {}) {
-	const dbName = options.dbName ?? DEFAULT_DB_NAME;
-	const storeName = options.storeName ?? DEFAULT_STORE_NAME;
-	const sessionStoreName = sessionStoreNameFor(storeName);
-	const codec = options.codec ?? safeJsonCodec();
-	const batchSize = normalizePositiveInteger(options.batchSize, 100);
-	const flushIntervalMs = normalizePositiveInteger(options.flushIntervalMs, 1e3);
-	const maxBufferSize = normalizePositiveInteger(options.maxBufferSize, 1e3);
-	const maxEntries = normalizePositiveInteger(options.maxEntries, 5e4);
-	const maxBytes = normalizePositiveInteger(options.maxBytes, 50 * 1024 * 1024);
-	const dropPolicy = options.dropPolicy ?? "drop-oldest";
-	const flushOnPageHide = options.flushOnPageHide ?? true;
-	const durability = options.durability ?? "default";
-	const rootIndexedDB = options.indexedDB ?? globalThis.indexedDB;
-	const sessionOptions = normalizeSessionOptions(options.session);
-	const spillOptions = normalizeLocalStorageSpillOptions(options.localStorageSpill, dbName, storeName);
-	const transactionOptions = durability === "default" ? void 0 : { durability };
-	const buffer = [];
-	let dbPromise;
-	let indexedDBFactoryPromise;
-	let timer;
-	let flushPromise;
-	let clearPromise;
-	let pendingFlushBatch;
-	let spillDrainPromise;
-	let localStorageSpillClearCandidate;
-	let lastContext;
-	let closed = false;
-	const statsState = {
-		bufferDepth: 0,
-		maxBufferDepth: 0,
-		pendingFlush: false,
-		enqueued: 0,
-		persisted: 0,
-		dropped: 0,
-		droppedByReason: {},
-		persistedDropped: 0,
-		persistedDroppedByReason: {},
-		flushes: 0,
-		flushErrors: 0,
-		lastFlushBatchSize: 0,
-		lastFlushDurationMs: 0,
-		prunes: 0,
-		pruneFallbacks: 0,
-		lastPruneDurationMs: 0,
-		queries: 0,
-		queryFallbacks: 0,
-		lastQueryDurationMs: 0,
-		databaseOpenCount: 0,
-		storageBucketFallbacks: 0,
-		transactionOptionFallbacks: 0,
-		errors: 0,
-		errorsByOperation: {},
-		localStorageSpillWrites: 0,
-		localStorageSpillEntries: 0,
-		localStorageSpillDrains: 0,
-		localStorageSpillDrainedEntries: 0,
-		localStorageSpillDropped: 0,
-		localStorageSpillDroppedByReason: {},
-		localStorageSpillErrors: 0,
-		localStorageSpillErrorsByOperation: {}
-	};
-	const snapshotStats = () => ({
-		...statsState,
-		bufferDepth: buffer.length,
-		droppedByReason: { ...statsState.droppedByReason },
-		errorsByOperation: { ...statsState.errorsByOperation },
-		localStorageSpillDroppedByReason: { ...statsState.localStorageSpillDroppedByReason },
-		localStorageSpillErrorsByOperation: { ...statsState.localStorageSpillErrorsByOperation },
-		pendingFlush: flushPromise !== void 0,
-		persistedDroppedByReason: { ...statsState.persistedDroppedByReason }
-	});
-	const reportInternalError = (error, operation) => {
-		statsState.errors += 1;
-		incrementRecord(statsState.errorsByOperation, operation);
-		lastContext?.reportInternalError(error, {
-			operation,
-			phase: "transport",
-			transport: options.name ?? "indexeddb"
-		});
-	};
-	const dropEvent = (event, reason) => {
-		statsState.dropped += 1;
-		incrementRecord(statsState.droppedByReason, reason);
-		incrementLoggerMetaCounter("transport.indexeddb.dropped");
-		incrementLoggerMetaCounter(`transport.indexeddb.dropped.${reason}`);
-		options.onDrop?.(event, reason);
-	};
-	const dropPersistedEntry = (entry, reason) => {
-		statsState.persistedDropped += 1;
-		incrementRecord(statsState.persistedDroppedByReason, reason);
-		incrementLoggerMetaCounter("transport.indexeddb.persisted.dropped");
-		incrementLoggerMetaCounter(`transport.indexeddb.persisted.dropped.${reason}`);
-		options.onPersistedDrop?.(entry, reason);
-	};
-	const reportSpillError = (error, operation) => {
-		statsState.localStorageSpillErrors += 1;
-		incrementRecord(statsState.localStorageSpillErrorsByOperation, operation);
-		reportInternalError(error, `localstorage-spill-${operation}`);
-	};
-	const dropSpillEvent = (event, reason) => {
-		statsState.localStorageSpillDropped += 1;
-		incrementRecord(statsState.localStorageSpillDroppedByReason, reason);
-		incrementLoggerMetaCounter("transport.indexeddb.localstorage_spill.dropped");
-		incrementLoggerMetaCounter(`transport.indexeddb.localstorage_spill.dropped.${reason}`);
-		spillOptions?.onDrop?.(event, reason);
-	};
-	const resolveIndexedDBFactory = async () => {
-		if (options.indexedDB || !options.storageBucketName) return rootIndexedDB;
-		indexedDBFactoryPromise ??= (async () => {
-			const manager = getStorageBucketManager();
-			if (!manager) {
-				statsState.storageBucketFallbacks += 1;
-				return rootIndexedDB;
-			}
-			try {
-				const bucket = await manager.open(options.storageBucketName, storageBucketOpenOptions(options));
-				if (bucket.indexedDB) return bucket.indexedDB;
-				statsState.storageBucketFallbacks += 1;
-				return rootIndexedDB;
-			} catch (error) {
-				statsState.storageBucketFallbacks += 1;
-				reportInternalError(error, "storage-bucket-open");
-				return rootIndexedDB;
-			}
-		})();
-		return indexedDBFactoryPromise;
-	};
-	const openDb = () => {
-		dbPromise ??= resolveIndexedDBFactory().then((idb) => {
-			if (!idb) throw new Error("IndexedDB is not available for indexedDbTransport");
-			return new Promise((resolve, reject) => {
-				const request = idb.open(dbName, DB_VERSION);
-				request.addEventListener("upgradeneeded", (event) => {
-					const db = request.result;
-					const store = db.objectStoreNames.contains(storeName) ? request.transaction?.objectStore(storeName) : db.createObjectStore(storeName, { keyPath: "id" });
-					if (!store) return;
-					ensureIndex(store, "createdAt", "createdAt");
-					ensureIndex(store, "level", "level");
-					ensureIndex(store, "logger", "logger");
-					ensureIndex(store, "type", "type");
-					ensureIndex(store, ORDER_INDEX_NAME, [
-						"createdAt",
-						"seq",
-						"id"
-					]);
-					ensureIndex(store, SESSION_INDEX_NAME, "sessionId");
-					ensureIndex(store, SESSION_ORDER_INDEX_NAME, [
-						"sessionId",
-						"createdAt",
-						"seq",
-						"id"
-					]);
-					const sessionStore = db.objectStoreNames.contains(sessionStoreName) ? request.transaction?.objectStore(sessionStoreName) : db.createObjectStore(sessionStoreName, { keyPath: "sessionId" });
-					if (!sessionStore) return;
-					ensureIndex(sessionStore, SESSION_LAST_SEEN_INDEX_NAME, ["lastSeen", "sessionId"]);
-					if (event.oldVersion < 4) migrateSessionSummaries(store, sessionStore);
-				});
-				request.addEventListener("success", () => {
-					statsState.databaseOpenCount += 1;
-					resolve(request.result);
-				}, { once: true });
-				request.addEventListener("error", () => reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB open failed")), { once: true });
-			});
-		});
-		return dbPromise;
-	};
-	const createTransaction = (db, mode, stores = storeName) => {
-		if (mode !== "readwrite" || !transactionOptions) return db.transaction(stores, mode);
-		try {
-			return db.transaction(stores, mode, transactionOptions);
-		} catch {
-			statsState.transactionOptionFallbacks += 1;
-			return db.transaction(stores, mode);
-		}
-	};
-	const withStore = async (mode, run) => {
-		const tx = createTransaction(await openDb(), mode);
-		const settled = transactionToPromise(tx);
-		try {
-			const result = await run(tx.objectStore(storeName), tx);
-			await settled;
-			return result;
-		} catch (error) {
-			if (tx.error === null) try {
-				tx.abort();
-			} catch {}
-			throw error;
-		}
-	};
-	const withLogAndSessionStores = async (mode, run) => {
-		const tx = createTransaction(await openDb(), mode, [storeName, sessionStoreName]);
-		const settled = transactionToPromise(tx);
-		try {
-			const result = await run(tx.objectStore(storeName), tx.objectStore(sessionStoreName), tx);
-			await settled;
-			return result;
-		} catch (error) {
-			if (tx.error === null) try {
-				tx.abort();
-			} catch {}
-			throw error;
-		}
-	};
-	const withSessionStore = async (mode, run) => {
-		const tx = createTransaction(await openDb(), mode, sessionStoreName);
-		const settled = transactionToPromise(tx);
-		try {
-			const result = await run(tx.objectStore(sessionStoreName), tx);
-			await settled;
-			return result;
-		} catch (error) {
-			if (tx.error === null) try {
-				tx.abort();
-			} catch {}
-			throw error;
-		}
-	};
-	const mergeSessionSummaries = async (sessionStore, entries) => {
-		const summaries = /* @__PURE__ */ new Map();
-		for (const entry of entries) addSessionSummary(summaries, entry);
-		for (const summary of summaries.values()) {
-			const current = await requestToPromise(sessionStore.get(summary.sessionId));
-			await requestToPromise(sessionStore.put(mergeSessionSummary(current, summary)));
-		}
-	};
-	const rebuildSessionSummaries = async (store, sessionStore, sessionIds) => {
-		if (sessionIds.size === 0) return;
-		const index = getStoreIndex(store, SESSION_ORDER_INDEX_NAME);
-		for (const sessionId of sessionIds) {
-			const summaries = /* @__PURE__ */ new Map();
-			const range = orderRangeForSessionId(sessionId);
-			await iterateCursor(index && range ? index.openCursor(range) : store.openCursor(), (cursor) => {
-				const entry = cursor.value;
-				if (entry.sessionId === sessionId) addSessionSummary(summaries, entry);
-			});
-			const summary = summaries.get(sessionId);
-			if (summary) await requestToPromise(sessionStore.put(summary));
-			else await requestToPromise(sessionStore.delete(sessionId));
-		}
-	};
-	const getEntries = async () => orderEntries(await withStore("readonly", (store) => requestToPromise(store.getAll())));
-	const countEntries = async () => withStore("readonly", (store) => {
-		const maybeStore = store;
-		if (typeof maybeStore.count !== "function") return void 0;
-		return requestToPromise(maybeStore.count.call(store));
-	});
-	const deleteEntries = async (entries, reason) => {
-		if (entries.length === 0) return;
-		await withLogAndSessionStores("readwrite", async (store, sessionStore) => {
-			const affectedSessionIds = /* @__PURE__ */ new Set();
-			for (const entry of entries) {
-				await requestToPromise(store.delete(entry.id));
-				if (entry.sessionId) affectedSessionIds.add(entry.sessionId);
-				dropPersistedEntry(entry, reason);
-			}
-			await rebuildSessionSummaries(store, sessionStore, affectedSessionIds);
-		});
-	};
-	const deleteByCursor = async (reason, openCursor, shouldDelete) => withLogAndSessionStores("readwrite", async (store, sessionStore) => {
-		const request = openCursor(store);
-		if (!request) return void 0;
-		let deleted = 0;
-		const affectedSessionIds = /* @__PURE__ */ new Set();
-		await iterateCursor(request, (cursor) => {
-			const entry = cursor.value;
-			if (!shouldDelete(entry, deleted)) return false;
-			cursor.delete();
-			deleted += 1;
-			if (entry.sessionId) affectedSessionIds.add(entry.sessionId);
-			dropPersistedEntry(entry, reason);
-			return true;
-		});
-		await rebuildSessionSummaries(store, sessionStore, affectedSessionIds);
-		return deleted;
-	});
-	const deleteExpiredByCursor = async (cutoff) => {
-		if (typeof IDBKeyRange === "undefined") return void 0;
-		const range = IDBKeyRange.upperBound(cutoff, true);
-		return deleteByCursor("ttl", (store) => getStoreIndex(store, "createdAt")?.openCursor(range), () => true);
-	};
-	const deleteOldestByCursor = async (reason, count) => {
-		if (count <= 0) return 0;
-		return deleteByCursor(reason, (store) => getStoreIndex(store, ORDER_INDEX_NAME)?.openCursor(), (_entry, deleted) => deleted < count);
-	};
-	const deleteOldestBytesByCursor = async (bytesToFree) => {
-		if (bytesToFree <= 0) return 0;
-		let freed = 0;
-		return deleteByCursor("max-bytes", (store) => getStoreIndex(store, ORDER_INDEX_NAME)?.openCursor(), (entry) => {
-			if (freed >= bytesToFree) return false;
-			freed += entry.byteLength;
-			return true;
-		});
-	};
-	const sumBytesByCursor = async () => withStore("readonly", async (store) => {
-		const index = getStoreIndex(store, ORDER_INDEX_NAME);
-		if (!index) return void 0;
-		let total = 0;
-		await iterateCursor(index.openCursor(), (cursor) => {
-			total += cursor.value.byteLength;
-		});
-		return total;
-	});
-	const queryEntriesByCursor = async (queryOptions) => withStore("readonly", async (store) => {
-		const index = getStoreIndex(store, queryOptions.sessionId === void 0 ? ORDER_INDEX_NAME : SESSION_ORDER_INDEX_NAME);
-		if (!index) return void 0;
-		const entries = [];
-		const limit = queryOptions.limit;
-		if (limit !== void 0 && limit <= 0) return entries;
-		await iterateCursor(index.openCursor(orderRangeForQuery(queryOptions), queryOptions.order === "desc" ? "prev" : "next"), (cursor) => {
-			const entry = cursor.value;
-			if (!shouldKeepEntry(entry, queryOptions)) return true;
-			entries.push(entry);
-			return limit === void 0 || entries.length < limit;
-		});
-		return entries;
-	});
-	const listSessions = async (sessionQueryOptions = {}) => {
-		const limit = sessionQueryOptions.limit;
-		if (limit !== void 0 && limit <= 0) return [];
-		return withSessionStore("readonly", async (sessionStore) => {
-			const sessions = [];
-			const index = getStoreIndex(sessionStore, SESSION_LAST_SEEN_INDEX_NAME);
-			if (!index) return orderSessions(await requestToPromise(sessionStore.getAll()), sessionQueryOptions.order).slice(0, limit);
-			await iterateCursor(index.openCursor(void 0, sessionQueryOptions.order === "asc" ? "next" : "prev"), (cursor) => {
-				sessions.push(cursor.value);
-				return limit === void 0 || sessions.length < limit;
-			});
-			return sessions;
-		});
-	};
-	const pruneWithEntries = async () => {
-		const now = Date.now();
-		let entries = await getEntries();
-		const expired = options.ttlMs === void 0 ? [] : entries.filter((entry) => now - entry.createdAt > options.ttlMs);
-		if (expired.length > 0) {
-			await deleteEntries(expired, "ttl");
-			const expiredIds = new Set(expired.map((entry) => entry.id));
-			entries = entries.filter((entry) => !expiredIds.has(entry.id));
-		}
-		if (maxEntries >= 0 && entries.length > maxEntries) {
-			await deleteEntries(entries.slice(0, entries.length - maxEntries), "max-entries");
-			entries = entries.slice(entries.length - maxEntries);
-		}
-		if (maxBytes >= 0) {
-			let total = entries.reduce((sum, entry) => sum + entry.byteLength, 0);
-			const dropped = [];
-			for (const entry of entries) {
-				if (total <= maxBytes) break;
-				total -= entry.byteLength;
-				dropped.push(entry);
-			}
-			await deleteEntries(dropped, "max-bytes");
-		}
-	};
-	const pruneWithCursors = async () => {
-		if (options.ttlMs !== void 0) {
-			if (await deleteExpiredByCursor(Date.now() - options.ttlMs) === void 0) return false;
-		}
-		if (maxEntries >= 0) {
-			const persistedCount = await countEntries();
-			if (persistedCount === void 0) return false;
-			if (persistedCount > maxEntries) {
-				if (await deleteOldestByCursor("max-entries", persistedCount - maxEntries) === void 0) return false;
-			}
-		}
-		if (maxBytes >= 0) {
-			const totalBytes = await sumBytesByCursor();
-			if (totalBytes === void 0) return false;
-			if (totalBytes > maxBytes) {
-				if (await deleteOldestBytesByCursor(totalBytes - maxBytes) === void 0) return false;
-			}
-		}
-		return true;
-	};
-	const prune = async () => {
-		const startedAt = nowMs$1();
-		try {
-			if (await pruneWithCursors()) return;
-			statsState.pruneFallbacks += 1;
-			await pruneWithEntries();
-		} finally {
-			statsState.prunes += 1;
-			statsState.lastPruneDurationMs = nowMs$1() - startedAt;
-		}
-	};
-	const sessionIdForEvent = (event) => {
-		if (!sessionOptions) return void 0;
-		return normalizeSessionId(sessionOptions.getId?.(event)) ?? normalizeSessionId(event.context?.[sessionOptions.contextKey]) ?? sessionOptions.id;
-	};
-	const eventWithSessionContext = (event, sessionId) => {
-		if (!sessionId || !sessionOptions?.contextKey) return event;
-		if (event.context?.[sessionOptions.contextKey] === sessionId) return event;
-		return {
-			...event,
-			context: {
-				...event.context,
-				[sessionOptions.contextKey]: sessionId
-			}
-		};
-	};
-	const eventWithResolvedSession = (event) => {
-		const sessionId = sessionIdForEvent(event);
-		return {
-			event: eventWithSessionContext(event, sessionId),
-			sessionId
-		};
-	};
-	const eventToEntry = (event) => {
-		const resolved = eventWithResolvedSession(event);
-		const payload = codec.encode(resolved.event);
-		return {
-			id: event.id,
-			sessionId: resolved.sessionId,
-			seq: event.seq,
-			createdAt: event.time,
-			level: event.level,
-			levelName: event.levelName,
-			logger: event.logger,
-			type: event.type,
-			byteLength: payloadByteLength(payload),
-			payload
-		};
-	};
-	const clearLocalStorageSpill = (expectedValue) => {
-		if (!spillOptions) return false;
-		try {
-			if (expectedValue !== void 0 && spillOptions.storage.getItem(spillOptions.key) !== expectedValue) return false;
-			spillOptions.storage.removeItem(spillOptions.key);
-			if (expectedValue === void 0 || localStorageSpillClearCandidate?.value === expectedValue) localStorageSpillClearCandidate = void 0;
-			return true;
-		} catch (error) {
-			reportSpillError(error, "clear");
-			return false;
-		}
-	};
-	const rememberLocalStorageSpill = (value, events) => {
-		localStorageSpillClearCandidate = {
-			pendingIds: new Set(events.map((event) => event.id)),
-			value
-		};
-	};
-	const markLocalStorageSpillPersisted = (events) => {
-		const candidate = localStorageSpillClearCandidate;
-		if (!candidate || events.length === 0) return;
-		for (const event of events) candidate.pendingIds.delete(event.id);
-		if (candidate.pendingIds.size === 0) clearLocalStorageSpill(candidate.value);
-	};
-	const writeBatch = async (events) => {
-		if (events.length === 0) return;
-		const startedAt = nowMs$1();
-		statsState.lastFlushBatchSize = events.length;
-		const entries = events.map(eventToEntry);
-		try {
-			await withLogAndSessionStores("readwrite", async (store, sessionStore) => {
-				const rebuildSessionIds = /* @__PURE__ */ new Set();
-				for (const entry of entries) {
-					const existing = await requestToPromise(store.get(entry.id));
-					if (existing?.sessionId) rebuildSessionIds.add(existing.sessionId);
-					if (existing && entry.sessionId) rebuildSessionIds.add(entry.sessionId);
-					await requestToPromise(store.put(entry));
-				}
-				await rebuildSessionSummaries(store, sessionStore, rebuildSessionIds);
-				await mergeSessionSummaries(sessionStore, entries.filter((entry) => !entry.sessionId || !rebuildSessionIds.has(entry.sessionId)));
-			});
-			statsState.persisted += entries.length;
-			incrementLoggerMetaCounter("transport.indexeddb.persisted", entries.length);
-			markLocalStorageSpillPersisted(events);
-			await prune();
-			statsState.flushes += 1;
-		} catch (error) {
-			statsState.flushErrors += 1;
-			throw error;
-		} finally {
-			statsState.lastFlushDurationMs = nowMs$1() - startedAt;
-		}
-	};
-	const stringifySpillPayload = (events) => safeJsonStringify({
-		createdAt: Date.now(),
-		entries: events,
-		schema: SPILL_SCHEMA
-	}, { maxArrayLength: spillOptions?.maxEntries ?? DEFAULT_SPILL_MAX_ENTRIES });
-	const spillStorageBudget = (currentValue) => {
-		if (!spillOptions) return 0;
-		const ownBytes = currentValue ? storageByteLength(spillOptions.key, currentValue) : 0;
-		const originBytes = estimateLocalStorageBytes(spillOptions.storage);
-		if (originBytes === void 0) return spillOptions.maxBytes;
-		return Math.max(0, Math.min(spillOptions.maxBytes, spillOptions.maxOriginBytes - originBytes + ownBytes));
-	};
-	const pendingEventsForSpill = () => {
-		const events = [...pendingFlushBatch ?? [], ...buffer];
-		const seen = /* @__PURE__ */ new Set();
-		const deduped = [];
-		for (const event of events) {
-			if (seen.has(event.id)) continue;
-			seen.add(event.id);
-			if (spillOptions?.minLevelValue !== void 0 && event.level < spillOptions.minLevelValue) continue;
-			deduped.push(eventWithResolvedSession(event).event);
-		}
-		return deduped;
-	};
-	const trimSpillEventsToBudget = (events, budget) => {
-		if (!spillOptions) return void 0;
-		while (events.length > spillOptions.maxEntries) {
-			const dropped = events.shift();
-			if (dropped) dropSpillEvent(dropped, "max-entries");
-		}
-		while (events.length > 0) {
-			const value = stringifySpillPayload(events);
-			if (storageByteLength(spillOptions.key, value) <= budget) return value;
-			const dropped = events.shift();
-			if (dropped) dropSpillEvent(dropped, "max-bytes");
-		}
-	};
-	const writeLocalStorageSpill = () => {
-		if (!spillOptions) return;
-		const pendingEvents = pendingEventsForSpill();
-		if (pendingEvents.length === 0) return;
-		try {
-			const currentValue = spillOptions.storage.getItem(spillOptions.key);
-			let events = pendingEvents;
-			if (currentValue) {
-				const merged = /* @__PURE__ */ new Map();
-				try {
-					for (const event of parseSpillPayload(currentValue) ?? []) merged.set(event.id, event);
-				} catch {}
-				for (const event of pendingEvents) merged.set(event.id, event);
-				events = [...merged.values()];
-			}
-			const budget = spillStorageBudget(currentValue);
-			const value = trimSpillEventsToBudget(events, budget);
-			if (!value) return;
-			try {
-				spillOptions.storage.setItem(spillOptions.key, value);
-			} catch (error) {
-				if (!isQuotaExceededError(error)) throw error;
-				while (events.length > 0) {
-					const dropped = events.shift();
-					if (dropped) dropSpillEvent(dropped, "quota");
-					const retryValue = trimSpillEventsToBudget(events, budget);
-					if (!retryValue) return;
-					try {
-						spillOptions.storage.setItem(spillOptions.key, retryValue);
-						rememberLocalStorageSpill(retryValue, events);
-						statsState.localStorageSpillWrites += 1;
-						statsState.localStorageSpillEntries += events.length;
-						return;
-					} catch (retryError) {
-						if (!isQuotaExceededError(retryError)) throw retryError;
-					}
-				}
-				return;
-			}
-			rememberLocalStorageSpill(value, events);
-			statsState.localStorageSpillWrites += 1;
-			statsState.localStorageSpillEntries += events.length;
-		} catch (error) {
-			reportSpillError(error, "write");
-		}
-	};
-	const drainLocalStorageSpill = async () => {
-		if (!spillOptions) return;
-		let raw;
-		try {
-			raw = spillOptions.storage.getItem(spillOptions.key);
-		} catch (error) {
-			reportSpillError(error, "read");
-			return;
-		}
-		if (!raw) return;
-		let events;
-		try {
-			events = parseSpillPayload(raw);
-		} catch (error) {
-			reportSpillError(error, "parse");
-			clearLocalStorageSpill();
-			return;
-		}
-		if (!events || events.length === 0) {
-			clearLocalStorageSpill();
-			return;
-		}
-		await writeBatch(events);
-		clearLocalStorageSpill(raw);
-		statsState.localStorageSpillDrains += 1;
-		statsState.localStorageSpillDrainedEntries += events.length;
-	};
-	const ensureSpillDrained = async () => {
-		const promise = spillDrainPromise;
-		if (!promise) return;
-		await promise;
-	};
-	if (spillOptions?.drainOnCreate) spillDrainPromise = drainLocalStorageSpill().catch((error) => reportSpillError(error, "drain")).finally(() => {
-		spillDrainPromise = void 0;
-	});
-	const clearTimer = () => {
-		if (timer) clearTimeout(timer);
-		timer = void 0;
-	};
-	const flushPending = async () => {
-		if (flushPromise) return flushPromise;
-		clearTimer();
-		const batch = buffer.splice(0, buffer.length);
-		pendingFlushBatch = batch;
-		const clearBarrier = clearPromise;
-		flushPromise = (async () => {
-			await clearBarrier;
-			await ensureSpillDrained();
-			await writeBatch(batch);
-		})().finally(() => {
-			if (pendingFlushBatch === batch) pendingFlushBatch = void 0;
-			flushPromise = void 0;
-			if (buffer.length > 0 && !closed) schedule();
-		});
-		return flushPromise;
-	};
-	const schedule = () => {
-		if (timer || flushIntervalMs <= 0 || closed) return;
-		timer = setTimeout(() => {
-			flushPending().catch((error) => reportInternalError(error, "flush"));
-		}, flushIntervalMs);
-	};
-	const onPageHide = () => {
-		if (spillOptions?.spillOnPageHide) writeLocalStorageSpill();
-		if (flushOnPageHide) flushPending().catch((error) => reportInternalError(error, "pagehide-flush"));
-	};
-	const onVisibilityChange = () => {
-		if (typeof document !== "undefined" && document.visibilityState === "hidden") {
-			if (spillOptions?.spillOnPageHide) writeLocalStorageSpill();
-			if (flushOnPageHide) flushPending().catch((error) => reportInternalError(error, "visibility-flush"));
-		}
-	};
-	const addVisibilityChangeListener = () => {
-		if (typeof document !== "undefined" && typeof document.addEventListener === "function") {
-			document.addEventListener("visibilitychange", onVisibilityChange);
-			return () => document.removeEventListener("visibilitychange", onVisibilityChange);
-		}
-		if (typeof globalThis.addEventListener !== "function") return void 0;
-		globalThis.addEventListener("visibilitychange", onVisibilityChange);
-		return () => globalThis.removeEventListener?.("visibilitychange", onVisibilityChange);
-	};
-	let removeVisibilityChangeListener;
-	if (flushOnPageHide || spillOptions?.spillOnPageHide) {
-		globalThis.addEventListener?.("pagehide", onPageHide);
-		removeVisibilityChangeListener = addVisibilityChangeListener();
-	}
-	return {
-		name: options.name ?? "indexeddb",
-		minLevel: options.minLevel,
-		log(event, context) {
-			if (closed) return;
-			if (options.minLevel !== void 0 && event.level < toLevelValue(options.minLevel)) return;
-			lastContext = context;
-			if (maxBufferSize === 0 || buffer.length >= maxBufferSize) {
-				if (dropPolicy === "drop-newest") {
-					dropEvent(event, "buffer-full");
-					return;
-				}
-				const dropped = buffer.shift();
-				if (dropped) dropEvent(dropped, "buffer-full");
-			}
-			buffer.push(event);
-			statsState.enqueued += 1;
-			statsState.maxBufferDepth = Math.max(statsState.maxBufferDepth, buffer.length);
-			if (buffer.length >= batchSize || flushIntervalMs === 0) flushPending().catch((error) => reportInternalError(error, "flush"));
-			else schedule();
-		},
-		flush() {
-			return flushPending();
-		},
-		async count() {
-			await flushPending();
-			return await countEntries() ?? (await getEntries()).length;
-		},
-		async clear() {
-			if (clearPromise) return clearPromise;
-			const inFlightFlush = flushPromise;
-			const inFlightDrain = spillDrainPromise;
-			buffer.length = 0;
-			clearTimer();
-			clearLocalStorageSpill();
-			clearPromise = (async () => {
-				await inFlightFlush;
-				await inFlightDrain;
-				await withLogAndSessionStores("readwrite", async (store, sessionStore) => {
-					await requestToPromise(store.clear());
-					await requestToPromise(sessionStore.clear());
-				});
-			})().finally(() => {
-				clearPromise = void 0;
-			});
-			return clearPromise;
-		},
-		async remove(ids) {
-			await flushPending();
-			const items = typeof ids === "string" ? [ids] : ids;
-			if (items.length === 0) return;
-			await withLogAndSessionStores("readwrite", async (store, sessionStore) => {
-				const affectedSessionIds = /* @__PURE__ */ new Set();
-				for (const id of items) {
-					const entry = await requestToPromise(store.get(id));
-					if (entry?.sessionId) affectedSessionIds.add(entry.sessionId);
-					await requestToPromise(store.delete(id));
-				}
-				await rebuildSessionSummaries(store, sessionStore, affectedSessionIds);
-			});
-		},
-		async *query(queryOptions = {}) {
-			await flushPending();
-			const startedAt = nowMs$1();
-			const cursorEntries = await queryEntriesByCursor(queryOptions);
-			if (cursorEntries === void 0) statsState.queryFallbacks += 1;
-			const entries = cursorEntries ?? orderEntries(await getEntries(), queryOptions.order ?? "asc").filter((entry) => shouldKeepEntry(entry, queryOptions)).slice(0, queryOptions.limit);
-			statsState.queries += 1;
-			statsState.lastQueryDurationMs = nowMs$1() - startedAt;
-			for (const entry of entries) {
-				const event = decodeEntry(entry, codec);
-				if (event) yield event;
-			}
-		},
-		async sessions(sessionQueryOptions = {}) {
-			await flushPending();
-			return listSessions(sessionQueryOptions);
-		},
-		stats() {
-			return snapshotStats();
-		},
-		close() {
-			closed = true;
-			clearTimer();
-			globalThis.removeEventListener?.("pagehide", onPageHide);
-			removeVisibilityChangeListener?.();
-			removeVisibilityChangeListener = void 0;
-			return flushPending().finally(() => {
-				const promise = dbPromise;
-				dbPromise = void 0;
-				return promise?.then((db) => db.close());
-			});
-		}
-	};
-}
-//#endregion
-//#region src/offline-first-transport.ts
-function normalizeBatchSize(value) {
-	if (value === void 0 || !Number.isFinite(value) || value <= 0) return 100;
-	return Math.floor(value);
-}
-async function collectBatch(queue, replayBatchSize) {
-	const events = [];
-	for await (const event of queue.query({
-		order: "asc",
-		limit: replayBatchSize
-	})) events.push(event);
-	return events;
-}
-function isBrowserOnline(options) {
-	if (options.online) return options.online();
-	if (typeof navigator === "undefined") return true;
-	return navigator.onLine !== false;
-}
-function offlineFirstTransport(remote, options = {}) {
-	const name = options.name ?? `offline-first(${remote.name ?? "transport"})`;
-	const replayBatchSize = normalizeBatchSize(options.replayBatchSize);
-	const queueOptions = options.queueOptions;
-	const queue = options.queue ?? indexedDbTransport({
-		dbName: "loggerjs-offline",
-		flushIntervalMs: 0,
-		name: `${name}:queue`,
-		storeName: "offline-events",
-		...queueOptions,
-		session: queueOptions?.session ?? false
-	});
-	const reliableRemote = retryTransport(remote, {
-		maxRetries: 2,
-		retryBaseDelayMs: 250,
-		retryMaxDelayMs: 5e3,
-		...options.retry,
-		name: `${name}:remote`
-	});
-	let lastContext;
-	let replayPromise;
-	const replayContext = {
-		loggerName: name,
-		now: () => Date.now(),
-		toEvent: recordToEvent,
-		reportInternalError() {}
-	};
-	const contextForReplay = () => lastContext ?? replayContext;
-	const reportInternalError = (error, operation) => {
-		contextForReplay().reportInternalError(error, {
-			phase: "transport",
-			transport: name,
-			operation
-		});
-	};
-	const queueEvent = async (event, context, error) => {
-		await queue.log(event, context);
-		await queue.flush?.();
-		incrementLoggerMetaCounter("transport.offline.queued");
-		options.onQueued?.(event, error);
-	};
-	const sendRemoteBatch = async (events, context) => {
-		await reliableRemote.logBatch?.([...events], context);
-	};
-	const sendOrQueue = async (event, context) => {
-		lastContext = context;
-		if (!isBrowserOnline(options)) {
-			await queueEvent(event, context);
-			return;
-		}
-		try {
-			await reliableRemote.log?.(event, context);
-		} catch (error) {
-			incrementLoggerMetaCounter("transport.offline.remote.failed");
-			await queueEvent(event, context, error);
-		}
-	};
-	const replay = async () => {
-		if (replayPromise) return replayPromise;
-		replayPromise = (async () => {
-			if (!isBrowserOnline(options)) return;
-			const context = contextForReplay();
-			await queue.flush?.();
-			for (;;) {
-				const batch = await collectBatch(queue, replayBatchSize);
-				if (batch.length === 0) return;
-				try {
-					await sendRemoteBatch(batch, context);
-					await queue.remove(batch.map((event) => event.id));
-					incrementLoggerMetaCounter("transport.offline.replayed", batch.length);
-					options.onReplayed?.(batch);
-				} catch (error) {
-					incrementLoggerMetaCounter("transport.offline.replay.failed");
-					reportInternalError(error, "replay");
-					throw error;
-				}
-			}
-		})().finally(() => {
-			replayPromise = void 0;
-		});
-		return replayPromise;
-	};
-	const onOnline = () => {
-		replay().catch((error) => reportInternalError(error, "online-replay"));
-	};
-	if (options.replayOnOnline ?? true) globalThis.addEventListener?.("online", onOnline);
-	return {
-		name,
-		minLevel: options.minLevel ?? remote.minLevel,
-		queue,
-		ready: remote.ready && (() => remote.ready?.()),
-		write(record, context) {
-			return sendOrQueue(context.toEvent(record), context);
-		},
-		writeBatch(records, context) {
-			return Promise.all(records.map((record) => sendOrQueue(context.toEvent(record), context))).then(() => void 0);
-		},
-		log(event, context) {
-			if (options.minLevel !== void 0 && event.level < toLevelValue(options.minLevel)) return;
-			return sendOrQueue(event, context);
-		},
-		logBatch(events, context) {
-			return Promise.all(events.map((event) => options.minLevel !== void 0 && event.level < toLevelValue(options.minLevel) ? void 0 : sendOrQueue(event, context))).then(() => void 0);
-		},
-		replay,
-		async flush() {
-			await replay();
-			await reliableRemote.flush?.();
-			await queue.flush?.();
-		},
-		flushSync() {
-			reliableRemote.flushSync?.();
-		},
-		async close() {
-			globalThis.removeEventListener?.("online", onOnline);
-			await replay();
-			await reliableRemote.close?.();
-			await queue.close?.();
-		},
-		async queuedCount() {
-			await queue.flush?.();
-			return queue.count?.();
-		},
-		async clearQueue() {
-			await queue.clear?.();
-		}
-	};
-}
-//#endregion
-//#region src/zip-export.ts
-const ZIP_UTF8_FLAG = 2048;
-const ZIP_STORE_METHOD = 0;
-const ZIP_VERSION = 20;
-const ZIP_MAX_UINT16 = 65535;
-const ZIP_MAX_UINT32 = 4294967295;
-const LOCAL_FILE_HEADER_SIGNATURE = 67324752;
-const CENTRAL_DIRECTORY_SIGNATURE = 33639248;
-const END_OF_CENTRAL_DIRECTORY_SIGNATURE = 101010256;
-const DEFAULT_SESSION_CONTEXT_KEY = "sessionId";
-let crc32Table;
-function getCrc32Table() {
-	if (crc32Table) return crc32Table;
-	const table = new Uint32Array(256);
-	for (let index = 0; index < table.length; index += 1) {
-		let crc = index;
-		for (let bit = 0; bit < 8; bit += 1) crc = crc & 1 ? 3988292384 ^ crc >>> 1 : crc >>> 1;
-		table[index] = crc >>> 0;
-	}
-	crc32Table = table;
-	return table;
-}
-function crc32(bytes) {
-	const table = getCrc32Table();
-	let crc = 4294967295;
-	for (const byte of bytes) crc = crc >>> 8 ^ (table[(crc ^ byte) & 255] ?? 0);
-	return (crc ^ 4294967295) >>> 0;
-}
-function encodeText(value) {
-	return new TextEncoder().encode(value);
-}
-function normalizeFileContent(content) {
-	if (typeof content === "string") return encodeText(content);
-	if (content instanceof Uint8Array) return content;
-	return new Uint8Array(content);
-}
-function normalizeZipFileName(name) {
-	const normalized = name.replace(/\\/g, "/").split("/").filter((part) => part.length > 0 && part !== "." && part !== "..").join("/");
-	if (!normalized) throw new Error("ZIP file name cannot be empty");
-	return normalized;
-}
-function toDosDateTime(timestamp) {
-	const date = new Date(Number.isFinite(timestamp) ? timestamp : Date.now());
-	const year = Math.min(2107, Math.max(1980, date.getFullYear()));
-	return {
-		time: date.getHours() << 11 | date.getMinutes() << 5 | Math.floor(date.getSeconds() / 2),
-		date: year - 1980 << 9 | date.getMonth() + 1 << 5 | date.getDate()
-	};
-}
-function assertZipUint16(value, label) {
-	if (!Number.isSafeInteger(value) || value < 0 || value > ZIP_MAX_UINT16) throw new Error(`${label} exceeds ZIP32 limit`);
-}
-function assertZipUint32(value, label) {
-	if (!Number.isSafeInteger(value) || value < 0 || value > ZIP_MAX_UINT32) throw new Error(`${label} exceeds ZIP32 limit`);
-}
-function createLocalFileHeader(file) {
-	const header = new Uint8Array(30);
-	const view = new DataView(header.buffer);
-	view.setUint32(0, LOCAL_FILE_HEADER_SIGNATURE, true);
-	view.setUint16(4, ZIP_VERSION, true);
-	view.setUint16(6, ZIP_UTF8_FLAG, true);
-	view.setUint16(8, ZIP_STORE_METHOD, true);
-	view.setUint16(10, file.modifiedTime, true);
-	view.setUint16(12, file.modifiedDate, true);
-	view.setUint32(14, file.crc32, true);
-	view.setUint32(18, file.contentBytes.byteLength, true);
-	view.setUint32(22, file.contentBytes.byteLength, true);
-	view.setUint16(26, file.nameBytes.byteLength, true);
-	view.setUint16(28, 0, true);
-	return header;
-}
-function createCentralDirectoryHeader(file) {
-	const header = new Uint8Array(46);
-	const view = new DataView(header.buffer);
-	view.setUint32(0, CENTRAL_DIRECTORY_SIGNATURE, true);
-	view.setUint16(4, ZIP_VERSION, true);
-	view.setUint16(6, ZIP_VERSION, true);
-	view.setUint16(8, ZIP_UTF8_FLAG, true);
-	view.setUint16(10, ZIP_STORE_METHOD, true);
-	view.setUint16(12, file.modifiedTime, true);
-	view.setUint16(14, file.modifiedDate, true);
-	view.setUint32(16, file.crc32, true);
-	view.setUint32(20, file.contentBytes.byteLength, true);
-	view.setUint32(24, file.contentBytes.byteLength, true);
-	view.setUint16(28, file.nameBytes.byteLength, true);
-	view.setUint16(30, 0, true);
-	view.setUint16(32, 0, true);
-	view.setUint16(34, 0, true);
-	view.setUint16(36, 0, true);
-	view.setUint32(38, 0, true);
-	view.setUint32(42, file.localHeaderOffset, true);
-	return header;
-}
-function createEndOfCentralDirectory(fileCount, centralDirectorySize, centralDirectoryOffset) {
-	assertZipUint16(fileCount, "ZIP file count");
-	assertZipUint32(centralDirectorySize, "ZIP central directory size");
-	assertZipUint32(centralDirectoryOffset, "ZIP central directory offset");
-	const footer = new Uint8Array(22);
-	const view = new DataView(footer.buffer);
-	view.setUint32(0, END_OF_CENTRAL_DIRECTORY_SIGNATURE, true);
-	view.setUint16(4, 0, true);
-	view.setUint16(6, 0, true);
-	view.setUint16(8, fileCount, true);
-	view.setUint16(10, fileCount, true);
-	view.setUint32(12, centralDirectorySize, true);
-	view.setUint32(16, centralDirectoryOffset, true);
-	view.setUint16(20, 0, true);
-	return footer;
-}
-function createNormalizedZipFiles(files, options) {
-	const names = /* @__PURE__ */ new Set();
-	let offset = 0;
-	return files.map((file) => {
-		const name = normalizeZipFileName(file.name);
-		if (names.has(name)) throw new Error(`Duplicate ZIP file name: ${name}`);
-		names.add(name);
-		const nameBytes = encodeText(name);
-		const contentBytes = normalizeFileContent(file.content);
-		assertZipUint16(nameBytes.byteLength, `ZIP file name ${name}`);
-		assertZipUint32(contentBytes.byteLength, `ZIP file ${name}`);
-		assertZipUint32(offset, "ZIP local header offset");
-		const modified = toDosDateTime(file.lastModified ?? options.lastModified ?? Date.now());
-		const normalized = {
-			name,
-			nameBytes,
-			contentBytes,
-			crc32: crc32(contentBytes),
-			modifiedTime: modified.time,
-			modifiedDate: modified.date,
-			localHeaderOffset: offset
-		};
-		offset += 30 + nameBytes.byteLength + contentBytes.byteLength;
-		assertZipUint32(offset, "ZIP local data size");
-		return normalized;
-	});
-}
-function isQuerySource(source) {
-	return "query" in source && typeof source.query === "function";
-}
-function resolveSource(source, query) {
-	if (isQuerySource(source)) return source.query(query);
-	if (query) throw new Error("Log ZIP export query options require a source with query()");
-	return source;
-}
-function normalizeMaxEvents(value) {
-	if (value === void 0) return void 0;
-	if (!Number.isFinite(value)) return void 0;
-	return Math.max(0, Math.floor(value));
-}
-function normalizeSessionExportOptions(value, logFileName) {
-	if (!value) return void 0;
-	const options = value === true ? {} : value;
-	return {
-		contextKey: options.contextKey ?? DEFAULT_SESSION_CONTEXT_KEY,
-		directory: options.directory ?? "sessions",
-		fallbackSessionId: options.fallbackSessionId ?? "unknown",
-		logFileName: options.logFileName ?? logFileName
-	};
-}
-function normalizeRecentExportOptions(value, format) {
-	if (!value) return void 0;
-	const options = value === true ? {} : value;
-	return {
-		logFileName: options.logFileName ?? (format === "json" ? "recent.json" : "recent.ndjson"),
-		maxEvents: normalizeMaxEvents(options.maxEvents) ?? 100
-	};
-}
-function logContentForLines(lines, format) {
-	if (format === "json") return `[${lines.join(",")}]`;
-	return lines.length > 0 ? `${lines.join("\n")}\n` : "";
-}
-function eventTimeRange(items) {
-	let from;
-	let to;
-	for (const item of items) {
-		from = from === void 0 ? item.event.time : Math.min(from, item.event.time);
-		to = to === void 0 ? item.event.time : Math.max(to, item.event.time);
-	}
-	return from === void 0 || to === void 0 ? void 0 : {
-		from,
-		to
-	};
-}
-function sessionIdForEvent(event, options) {
-	const value = event.context?.[options.contextKey];
-	return typeof value === "string" && value.length > 0 ? value : options.fallbackSessionId;
-}
-function safeZipPathSegment(value) {
-	const encoded = encodeURIComponent(value).replace(/%/g, "_");
-	if (!encoded || encoded === "." || encoded === "..") return "_";
-	return encoded;
-}
-function sortByEventTime(items) {
-	return [...items].sort((left, right) => {
-		if (left.event.time !== right.event.time) return left.event.time - right.event.time;
-		if (left.event.seq !== right.event.seq) return left.event.seq - right.event.seq;
-		return left.event.id < right.event.id ? -1 : left.event.id > right.event.id ? 1 : 0;
-	});
-}
-function createLogZipBlob(files, options = {}) {
-	const normalizedFiles = createNormalizedZipFiles(files, options);
-	const parts = [];
-	let centralDirectoryOffset = 0;
-	for (const file of normalizedFiles) {
-		parts.push(createLocalFileHeader(file), file.nameBytes, file.contentBytes);
-		centralDirectoryOffset += 30 + file.nameBytes.byteLength + file.contentBytes.byteLength;
-	}
-	let centralDirectorySize = 0;
-	for (const file of normalizedFiles) {
-		const header = createCentralDirectoryHeader(file);
-		parts.push(header, file.nameBytes);
-		centralDirectorySize += header.byteLength + file.nameBytes.byteLength;
-	}
-	parts.push(createEndOfCentralDirectory(normalizedFiles.length, centralDirectorySize, centralDirectoryOffset));
-	return new Blob(parts, { type: options.type ?? "application/zip" });
-}
-async function exportLogsToZip(source, options = {}) {
-	const format = options.format ?? "ndjson";
-	const createdAt = options.createdAt ?? Date.now();
-	const logFileName = options.logFileName ?? (format === "json" ? "logs.json" : "logs.ndjson");
-	const maxEvents = normalizeMaxEvents(options.maxEvents);
-	const sessionExportOptions = normalizeSessionExportOptions(options.groupBySession, logFileName);
-	const recentExportOptions = normalizeRecentExportOptions(options.includeRecent, format);
-	const serialize = options.serializeEvent ?? ((event) => safeJsonStringify(event, options.stringify ?? {}));
-	const exported = [];
-	let skippedCount = 0;
-	for await (const event of resolveSource(source, options.query)) {
-		if (maxEvents !== void 0 && exported.length >= maxEvents) break;
-		const mapped = options.mapEvent ? options.mapEvent(event) : event;
-		if (!mapped) {
-			skippedCount += 1;
-			continue;
-		}
-		exported.push({
-			event: mapped,
-			line: serialize(mapped)
-		});
-	}
-	const files = [{
-		name: logFileName,
-		content: logContentForLines(exported.map((item) => item.line), format),
-		lastModified: createdAt
-	}];
-	const sessionManifests = [];
-	if (sessionExportOptions) {
-		const groups = /* @__PURE__ */ new Map();
-		for (const item of exported) {
-			const sessionId = sessionIdForEvent(item.event, sessionExportOptions);
-			const group = groups.get(sessionId) ?? [];
-			group.push(item);
-			groups.set(sessionId, group);
-		}
-		const usedFileNames = new Set(files.map((file) => normalizeZipFileName(file.name)));
-		const sortedGroups = [...groups.entries()];
-		sortedGroups.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
-		for (const [sessionId, group] of sortedGroups) {
-			let fileName = normalizeZipFileName(`${sessionExportOptions.directory}/${safeZipPathSegment(sessionId)}/${sessionExportOptions.logFileName}`);
-			let suffix = 1;
-			while (usedFileNames.has(fileName)) {
-				fileName = normalizeZipFileName(`${sessionExportOptions.directory}/${safeZipPathSegment(sessionId)}-${suffix}/${sessionExportOptions.logFileName}`);
-				suffix += 1;
-			}
-			usedFileNames.add(fileName);
-			const orderedGroup = sortByEventTime(group);
-			files.push({
-				name: fileName,
-				content: logContentForLines(orderedGroup.map((item) => item.line), format),
-				lastModified: createdAt
-			});
-			sessionManifests.push({
-				logCount: orderedGroup.length,
-				logFileName: fileName,
-				sessionId,
-				timeRange: eventTimeRange(orderedGroup)
-			});
-		}
-	}
-	let recentLogFileName;
-	if (recentExportOptions) {
-		const recentItems = recentExportOptions.maxEvents <= 0 ? [] : sortByEventTime(exported).slice(-recentExportOptions.maxEvents);
-		recentLogFileName = normalizeZipFileName(recentExportOptions.logFileName);
-		files.push({
-			name: recentLogFileName,
-			content: logContentForLines(recentItems.map((item) => item.line), format),
-			lastModified: createdAt
-		});
-	}
-	if (options.includeManifest ?? true) {
-		const manifest = {
-			schema: "loggerjs.log-export.v1",
-			createdAt: new Date(createdAt).toISOString(),
-			source: options.source,
-			format,
-			logFileName: normalizeZipFileName(logFileName),
-			logCount: exported.length,
-			skippedCount,
-			query: options.query,
-			recentLogFileName,
-			sessionCount: sessionExportOptions ? sessionManifests.length : void 0,
-			sessions: sessionExportOptions ? sessionManifests : void 0,
-			timeRange: eventTimeRange(exported)
-		};
-		files.push({
-			name: options.manifestFileName ?? "manifest.json",
-			content: `${safeJsonStringify(manifest, { space: 2 })}\n`,
-			lastModified: createdAt
-		});
-	}
-	return createLogZipBlob(files, { lastModified: createdAt });
-}
-function downloadBlob(blob, filenameOrOptions = {}) {
-	const options = typeof filenameOrOptions === "string" ? { filename: filenameOrOptions } : filenameOrOptions;
-	const documentRef = options.document ?? globalThis.document;
-	const urlRef = options.url ?? globalThis.URL;
-	if (!documentRef?.body || !urlRef?.createObjectURL || !urlRef.revokeObjectURL) throw new Error("downloadBlob requires document and URL.createObjectURL");
-	const href = urlRef.createObjectURL(blob);
-	const anchor = documentRef.createElement("a");
-	anchor.href = href;
-	anchor.download = options.filename ?? "loggerjs-logs.zip";
-	anchor.style.display = "none";
-	documentRef.body.appendChild(anchor);
-	anchor.click();
-	anchor.remove();
-	const revoke = () => urlRef.revokeObjectURL(href);
-	const revokeDelayMs = options.revokeDelayMs ?? 1e3;
-	if (revokeDelayMs <= 0) revoke();
-	else setTimeout(revoke, revokeDelayMs);
-	return href;
-}
-//#endregion
-//#region src/console-integration.ts
-const defaultLevels = [
-	"debug",
-	"info",
-	"log",
-	"trace",
-	"warn",
-	"error"
-];
-const levelMap = {
-	debug: "debug",
-	info: "info",
-	log: "info",
-	trace: "trace",
-	warn: "warn",
-	error: "error"
-};
-function formatConsoleMessage(args) {
-	return args.map((arg) => {
-		if (typeof arg === "string") return arg;
-		if (arg instanceof Error) return arg.message;
-		try {
-			return JSON.stringify(normalizeValue(arg, {
-				maxDepth: 3,
-				maxArrayLength: 20,
-				maxObjectKeys: 40
-			}));
-		} catch {
-			return String(arg);
-		}
-	}).join(" ");
-}
-function reportRateLimitDrop() {
-	incrementLoggerMetaCounter("integration.dropped");
-	incrementLoggerMetaCounter("integration.dropped.rate-limit");
-}
-function captureConsoleIntegration(options = {}) {
-	const levels = options.levels ?? defaultLevels;
-	const preserveConsole = options.preserveConsole ?? true;
-	const captureArguments = options.captureArguments ?? false;
-	const maxCapturesPerSecond = options.maxCapturesPerSecond ?? 100;
-	return {
-		name: "capture-console",
-		setup(api) {
-			if (typeof console === "undefined") return;
-			const originals = {};
-			const boundOriginals = {};
-			let windowStarted = Date.now();
-			let capturesInWindow = 0;
-			let disposed = false;
-			const shouldCapture = () => {
-				const now = Date.now();
-				if (now - windowStarted >= 1e3) {
-					windowStarted = now;
-					capturesInWindow = 0;
-				}
-				if (capturesInWindow >= maxCapturesPerSecond) {
-					reportRateLimitDrop();
-					return false;
-				}
-				capturesInWindow += 1;
-				return true;
-			};
-			for (const level of levels) {
-				const original = console[level] ?? console.log.bind(console);
-				originals[level] = original;
-				const unpatched = api.unpatched.console[level] ?? original;
-				api.unpatched.console[level] ??= original;
-				boundOriginals[level] = unpatched.bind(console);
-				const capture = api.guard((args) => {
-					if (!shouldCapture()) return;
-					const consoleData = { level };
-					if (captureArguments) consoleData.arguments = normalizeValue(args, { maxDepth: 4 });
-					api.capture({
-						level: levelMap[level],
-						message: formatConsoleMessage(args),
-						props: { console: consoleData }
-					});
-				});
-				console[level] = (...args) => {
-					capture(args);
-					if (preserveConsole) boundOriginals[level]?.(...args);
-				};
-			}
-			return () => {
-				if (disposed) return;
-				disposed = true;
-				for (const level of levels) if (originals[level]) console[level] = originals[level];
-			};
-		}
-	};
-}
-//#endregion
-//#region src/context-propagation-integration.ts
-const defaultActionEvents = [
-	"click",
-	"input",
-	"change",
-	"submit"
-];
-let fallbackIdSeq = 0;
-function defaultIdFactory() {
-	const cryptoRandomUUID = globalThis.crypto?.randomUUID;
-	if (cryptoRandomUUID) return cryptoRandomUUID.call(globalThis.crypto);
-	return `${Date.now().toString(36)}-${(fallbackIdSeq++).toString(36)}`;
-}
-function resolveValue(value) {
-	return typeof value === "function" ? value() : value;
-}
-function normalizeBaggage(value) {
-	if (typeof value === "string") return parseBaggage(value);
-	return value;
-}
-function actionTargetName(target) {
-	const item = target;
-	if (!item) return void 0;
-	return item.id || item.name || item.tagName?.toLowerCase();
-}
-function browserContextPropagationIntegration(options = {}) {
-	const actionEvents = options.actionEvents ?? defaultActionEvents;
-	const actionTtlMs = Math.max(0, Math.floor(options.actionTtlMs ?? 5e3));
-	const clock = options.clock ?? Date.now;
-	const idFactory = options.idFactory ?? defaultIdFactory;
-	let lastAction;
-	return {
-		name: "browser-context-propagation",
-		setup() {
-			const root = options.root ?? globalThis.document;
-			const disposeProvider = addContextProvider(() => {
-				const sessionId = resolveValue(options.sessionId);
-				const requestId = options.requestId?.();
-				const trace = resolveValue(options.trace) ?? parseTraceparent(resolveValue(options.traceparent));
-				const baggage = normalizeBaggage(resolveValue(options.baggage)) ?? trace?.baggage;
-				const traceparent = formatTraceparent(trace);
-				const now = clock();
-				const action = lastAction && now - lastAction.time <= actionTtlMs ? {
-					actionId: lastAction.id,
-					actionType: lastAction.type,
-					actionTarget: lastAction.target
-				} : void 0;
-				return {
-					sessionId,
-					requestId,
-					traceparent,
-					baggage: formatBaggage(baggage),
-					...action
-				};
-			});
-			if (!root?.addEventListener || !root.removeEventListener || actionEvents.length === 0) return disposeProvider;
-			const onAction = (event) => {
-				lastAction = {
-					id: idFactory(),
-					type: event.type,
-					target: actionTargetName(event.target),
-					time: clock()
-				};
-			};
-			for (const event of actionEvents) root.addEventListener(event, onAction, true);
-			return () => {
-				for (const event of actionEvents) root.removeEventListener(event, onAction, true);
-				disposeProvider();
-			};
-		}
-	};
-}
-//#endregion
-//#region src/error-integration.ts
-function resourceInfo(target) {
-	const element = target;
-	return {
-		tagName: element?.tagName,
-		url: element?.src || element?.currentSrc || element?.href,
-		html: element?.outerHTML?.slice(0, 500)
-	};
-}
-function reportDrop(reason) {
-	incrementLoggerMetaCounter("integration.dropped");
-	incrementLoggerMetaCounter(`integration.dropped.${reason}`);
-}
-function captureBrowserErrorsIntegration(options = {}) {
-	const captureWindowError = options.captureWindowError ?? true;
-	const captureUnhandledRejection = options.captureUnhandledRejection ?? true;
-	const captureResourceErrors = options.captureResourceErrors ?? true;
-	const captureSecurityPolicyViolation = options.captureSecurityPolicyViolation ?? false;
-	const scriptErrorDedupeWindowMs = options.scriptErrorDedupeWindowMs ?? 1e3;
-	return {
-		name: "capture-browser-errors",
-		setup(api) {
-			const disposers = [];
-			let lastScriptErrorAt = 0;
-			let disposed = false;
-			const shouldDropScriptError = (message) => {
-				if (message !== "Script error.") return false;
-				const now = Date.now();
-				if (now - lastScriptErrorAt <= scriptErrorDedupeWindowMs) {
-					reportDrop("script-error-duplicate");
-					return true;
-				}
-				lastScriptErrorAt = now;
-				return false;
-			};
-			if (captureWindowError && typeof addEventListener !== "undefined") {
-				const onError = api.guard((event) => {
-					const errorEvent = event;
-					if ("message" in errorEvent && shouldDropScriptError(errorEvent.message)) return;
-					if ("error" in errorEvent && errorEvent.error) {
-						api.capture({
-							level: "error",
-							message: errorEvent.message || errorEvent.error.message,
-							error: errorEvent.error,
-							props: { browser: {
-								kind: "script-error",
-								file: errorEvent.filename,
-								line: errorEvent.lineno,
-								column: errorEvent.colno
-							} }
-						});
-						return;
-					}
-					if ("message" in errorEvent && errorEvent.message) {
-						api.capture({
-							level: "error",
-							message: errorEvent.message,
-							props: { browser: {
-								kind: "script-error",
-								file: errorEvent.filename,
-								line: errorEvent.lineno,
-								column: errorEvent.colno
-							} }
-						});
-						return;
-					}
-					if (captureResourceErrors) api.capture({
-						level: "error",
-						message: "Browser resource load error",
-						props: { browser: {
-							kind: "resource-error",
-							...resourceInfo(event.target)
-						} }
-					});
-				});
-				addEventListener("error", onError, true);
-				disposers.push(() => removeEventListener("error", onError, true));
-			}
-			if (captureUnhandledRejection && typeof addEventListener !== "undefined") {
-				const onUnhandledRejection = api.guard((event) => {
-					const reason = event.reason;
-					api.capture({
-						level: "error",
-						message: reason instanceof Error ? reason.message : "Unhandled promise rejection",
-						error: reason,
-						props: {
-							browser: { kind: "unhandledrejection" },
-							reason: normalizeValue(reason, { maxDepth: 5 })
-						}
-					});
-				});
-				addEventListener("unhandledrejection", onUnhandledRejection);
-				disposers.push(() => removeEventListener("unhandledrejection", onUnhandledRejection));
-			}
-			if (captureSecurityPolicyViolation && typeof addEventListener !== "undefined") {
-				const onSecurityPolicyViolation = api.guard((event) => {
-					api.capture({
-						level: "warn",
-						message: `Security policy violation: ${event.violatedDirective}`,
-						props: { browser: {
-							kind: "securitypolicyviolation",
-							blockedURI: event.blockedURI,
-							documentURI: event.documentURI,
-							file: event.sourceFile,
-							line: event.lineNumber,
-							column: event.columnNumber,
-							originalPolicy: event.originalPolicy,
-							effectiveDirective: event.effectiveDirective
-						} }
-					});
-				});
-				addEventListener("securitypolicyviolation", onSecurityPolicyViolation);
-				disposers.push(() => removeEventListener("securitypolicyviolation", onSecurityPolicyViolation));
-			}
-			return () => {
-				if (disposed) return;
-				disposed = true;
-				for (const dispose of disposers) dispose();
-			};
-		}
-	};
-}
-//#endregion
-//#region src/http-capture-utils.ts
-function nowMs() {
-	return typeof performance !== "undefined" ? performance.now() : Date.now();
-}
-function durationMs(started) {
-	return nowMs() - started;
-}
-function sanitizeHttpUrl(rawUrl, sanitizer) {
-	const stripped = stripSensitiveUrlParts(rawUrl);
-	return sanitizer ? sanitizer(stripped) : stripped;
-}
-function pickAllowedHeaders(headers, allowList) {
-	if (!headers || !allowList || allowList.length === 0) return void 0;
-	const out = {};
-	for (const name of allowList) {
-		const value = headers.get(name);
-		if (value !== null) out[name.toLowerCase()] = value;
-	}
-	return Object.keys(out).length > 0 ? out : void 0;
-}
-function headersFromInit(headers) {
-	if (!headers) return void 0;
-	try {
-		return new Headers(headers);
-	} catch {
-		return;
-	}
-}
-function shouldSample(sampleRate, random) {
-	if (sampleRate >= 1) return true;
-	if (sampleRate <= 0) return false;
-	return random() < sampleRate;
-}
-function stripSensitiveUrlParts(rawUrl) {
-	if (!/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(rawUrl)) return rawUrl.split(/[?#]/, 1)[0] ?? rawUrl;
-	try {
-		const url = new URL(rawUrl);
-		url.search = "";
-		url.hash = "";
-		return url.toString();
-	} catch {
-		return rawUrl.split(/[?#]/, 1)[0] ?? rawUrl;
-	}
-}
-//#endregion
-//#region src/fetch-integration.ts
-function requestUrl(input) {
-	if (typeof input === "string") return input;
-	if (input instanceof URL) return input.toString();
-	return input.url;
-}
-function requestMethod(input, init) {
-	if (init?.method) return init.method.toUpperCase();
-	if (typeof input === "object" && "method" in input && input.method) return input.method.toUpperCase();
-	return "GET";
-}
-function captureFetchIntegration(options = {}) {
-	const minStatus = options.minStatus ?? 400;
-	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
-	const sampleRate = options.sampleRate ?? 1;
-	const random = options.random ?? Math.random;
-	return {
-		name: "capture-fetch",
-		setup(api) {
-			const current = globalThis.fetch;
-			if (!current) return;
-			const original = api.unpatched.fetch ?? current.bind(globalThis);
-			api.unpatched.fetch ??= original;
-			const capture = api.guard((input) => api.capture(input));
-			globalThis.fetch = async (input, init) => {
-				const started = nowMs();
-				const url = sanitizeHttpUrl(requestUrl(input), options.sanitizeUrl);
-				const method = requestMethod(input, init);
-				try {
-					const response = await original(input, init);
-					if (response.status >= minStatus || captureAll && shouldSample(sampleRate, random)) capture({
-						level: response.status >= minStatus ? "warn" : "debug",
-						message: `Fetch ${response.status} ${method} ${url}`,
-						props: { http: {
-							kind: "fetch",
-							method,
-							url,
-							status: response.status,
-							ok: response.ok,
-							durationMs: durationMs(started),
-							requestHeaders: pickAllowedHeaders(headersFromInit(init?.headers), options.captureRequestHeaders),
-							responseHeaders: pickAllowedHeaders(response.headers, options.captureResponseHeaders)
-						} }
-					});
-					return response;
-				} catch (error) {
-					capture({
-						level: "error",
-						message: `Fetch network error ${method} ${url}`,
-						error,
-						props: {
-							http: {
-								kind: "fetch",
-								method,
-								url,
-								durationMs: durationMs(started)
-							},
-							input: normalizeValue(input, { maxDepth: 3 })
-						}
-					});
-					throw error;
-				}
-			};
-			return () => {
-				globalThis.fetch = current;
-			};
-		}
-	};
-}
-//#endregion
-//#region src/xhr-integration.ts
-const XHR_META = "__LOGGERJS_XHR_META__";
-function captureXHRIntegration(options = {}) {
-	const minStatus = options.minStatus ?? 400;
-	const captureAll = options.captureAll ?? options.captureSuccessful ?? false;
-	const sampleRate = options.sampleRate ?? 1;
-	const random = options.random ?? Math.random;
-	return {
-		name: "capture-xhr",
-		setup(api) {
-			if (typeof XMLHttpRequest === "undefined") return;
-			const proto = XMLHttpRequest.prototype;
-			const originalOpen = proto.open;
-			const originalSend = proto.send;
-			api.unpatched.XMLHttpRequest ??= XMLHttpRequest;
-			const capture = api.guard((input) => api.capture(input));
-			proto.open = function patchedOpen(method, url, ...rest) {
-				this[XHR_META] = {
-					method: method.toUpperCase(),
-					url: sanitizeHttpUrl(String(url), options.sanitizeUrl),
-					started: 0
-				};
-				return originalOpen.apply(this, [
-					method,
-					url,
-					...rest
-				]);
-			};
-			proto.send = function patchedSend(body) {
-				const meta = this[XHR_META];
-				if (meta) meta.started = nowMs();
-				let captured = false;
-				const onLoadEnd = () => {
-					if (!meta || captured) return;
-					if (this.status >= minStatus || captureAll && shouldSample(sampleRate, random)) {
-						captured = true;
-						capture({
-							level: this.status >= minStatus ? "warn" : "debug",
-							message: `XHR ${this.status} ${meta.method} ${meta.url}`,
-							props: { http: {
-								kind: "xhr",
-								method: meta.method,
-								url: meta.url,
-								status: this.status,
-								durationMs: durationMs(meta.started)
-							} }
-						});
-					}
-				};
-				const onError = () => {
-					if (!meta || captured) return;
-					captured = true;
-					capture({
-						level: "error",
-						message: `XHR network error ${meta.method} ${meta.url}`,
-						props: { http: {
-							kind: "xhr",
-							method: meta.method,
-							url: meta.url,
-							durationMs: durationMs(meta.started)
-						} }
-					});
-				};
-				this.addEventListener("loadend", onLoadEnd, { once: true });
-				this.addEventListener("error", onError, { once: true });
-				return originalSend.apply(this, [body]);
-			};
-			return () => {
-				proto.open = originalOpen;
-				proto.send = originalSend;
-			};
-		}
-	};
-}
-//#endregion
-//#region src/framework-error-integration.ts
-function errorMessage(error) {
-	return error instanceof Error ? error.message : "Framework error";
-}
-function instanceComponentName(instance) {
-	const record = instance;
-	return record?.$options?.name ?? record?.type?.displayName ?? record?.type?.name ?? record?.constructor?.name;
-}
-function normalizeFrameworkInfo(input, fallbackFramework) {
-	if (typeof input === "string") return {
-		framework: fallbackFramework,
-		info: input
-	};
-	return {
-		framework: fallbackFramework,
-		...input
-	};
-}
-function captureFrameworkErrorsIntegration(options = {}) {
-	const integrationName = options.name ?? "capture-framework-errors";
-	const fallbackFramework = options.framework ?? "framework";
-	const level = options.level ?? "error";
-	const maxPending = Math.max(0, Math.floor(options.maxPending ?? 10));
-	const infoMaxDepth = options.infoMaxDepth ?? 6;
-	const pending = [];
-	let api;
-	let started = false;
-	let disposed = false;
-	const emit = (error, rawInfo) => {
-		const info = normalizeFrameworkInfo(rawInfo, fallbackFramework);
-		const message = options.getMessage?.(error, info) ?? errorMessage(error);
-		api?.capture({
-			level,
-			message,
-			error,
-			props: { browser: {
-				kind: "framework-error",
-				framework: info.framework,
-				componentName: info.componentName,
-				componentStack: info.componentStack,
-				info: normalizeValue(info.info, {
-					maxDepth: infoMaxDepth,
-					maxObjectKeys: 80
-				}),
-				props: normalizeValue(info.props, {
-					maxDepth: infoMaxDepth,
-					maxObjectKeys: 80
-				})
-			} }
-		});
-	};
-	const capture = (error, info) => {
-		if (api) {
-			emit(error, info);
-			return;
-		}
-		if (started || disposed || pending.length >= maxPending) return;
-		pending.push({
-			error,
-			info
-		});
-	};
-	return {
-		name: integrationName,
-		setup(nextApi) {
-			api = nextApi;
-			started = true;
-			disposed = false;
-			for (const item of pending.splice(0)) emit(item.error, item.info);
-			return () => {
-				api = void 0;
-				disposed = true;
-			};
-		},
-		capture,
-		reactComponentDidCatch(error, errorInfo) {
-			capture(error, {
-				framework: "react",
-				componentStack: errorInfo?.componentStack
-			});
-		},
-		vueErrorHandler(error, instance, info) {
-			capture(error, {
-				framework: "vue",
-				componentName: instanceComponentName(instance),
-				info
-			});
-		},
-		solidErrorHandler(error) {
-			capture(error, { framework: "solid" });
-		},
-		svelteErrorHandler(error, info) {
-			capture(error, normalizeFrameworkInfo(info, "svelte"));
-		}
-	};
-}
-//#endregion
-//#region src/framework-router-integrations.ts
-function routePath(input) {
-	if (typeof input === "string") return input;
-	if (input && typeof input === "object") {
-		const route = input;
-		if (typeof route.fullPath === "string") return route.fullPath;
-		if (typeof route.pathname === "string") return route.pathname;
-		if (typeof route.path === "string") return route.path;
-		if (route.location) return routePath(route.location);
-	}
-	return "";
-}
-function emitRouteChange(api, framework, level, to, from, options) {
-	const sanitize = options.sanitizeUrl;
-	const toPath = sanitize ? sanitize(routePath(to)) : routePath(to);
-	const fromPath = from === void 0 ? void 0 : sanitize ? sanitize(routePath(from)) : routePath(from);
-	api.capture({
-		level,
-		message: `${framework} route ${toPath}`,
-		props: { browser: {
-			kind: "framework-route-change",
-			framework,
-			route: {
-				to: toPath,
-				from: fromPath,
-				state: options.includeState ? normalizeValue(to, { maxDepth: 4 }) : void 0
-			}
-		} }
-	});
-}
-function nextRouterIntegration(options) {
-	const level = options.level ?? "info";
-	return {
-		name: "next-router",
-		setup(api) {
-			const router = options.router;
-			if (!router.events?.on || !router.events.off) return;
-			const onRoute = api.guard((url) => emitRouteChange(api, "next", level, url, router.asPath, options));
-			router.events.on("routeChangeComplete", onRoute);
-			router.events.on("hashChangeComplete", onRoute);
-			return () => {
-				router.events?.off?.("routeChangeComplete", onRoute);
-				router.events?.off?.("hashChangeComplete", onRoute);
-			};
-		}
-	};
-}
-function reactRouterIntegration(options) {
-	const level = options.level ?? "info";
-	return {
-		name: "react-router",
-		setup(api) {
-			let previous = options.history.location;
-			const dispose = options.history.listen?.(api.guard((update) => {
-				const next = update?.location ?? update;
-				emitRouteChange(api, "react-router", level, next, previous, options);
-				previous = next;
-			}));
-			return typeof dispose === "function" ? dispose : void 0;
-		}
-	};
-}
-function vueRouterIntegration(options) {
-	const level = options.level ?? "info";
-	const framework = options.framework ?? "vue-router";
-	return {
-		name: framework,
-		setup(api) {
-			const dispose = options.router.afterEach?.(api.guard((to, from) => emitRouteChange(api, framework, level, to, from, options)));
-			return typeof dispose === "function" ? dispose : void 0;
-		}
-	};
-}
-function nuxtRouterIntegration(options) {
-	return vueRouterIntegration({
-		...options,
-		framework: "nuxt"
-	});
-}
-//#endregion
-//#region src/reporting-integration.ts
-const defaultReportTypes = [
-	"csp-violation",
-	"deprecation",
-	"intervention",
-	"crash"
-];
-function levelFor$1(level, report) {
-	if (typeof level === "function") return level(report);
-	if (level) return level;
-	return report.type === "deprecation" ? "info" : "warn";
-}
-function maybeSanitize(url, sanitizeUrl) {
-	return url && sanitizeUrl ? sanitizeUrl(url) : url;
-}
-function normalizeReport(report, sanitizeUrl) {
-	const raw = typeof report.toJSON === "function" ? report.toJSON() : report;
-	const record = raw && typeof raw === "object" ? raw : {};
-	const body = "body" in record ? record.body : report.body;
-	const url = typeof record.url === "string" ? record.url : report.url;
-	return {
-		type: typeof record.type === "string" ? record.type : report.type ?? "unknown",
-		url: maybeSanitize(url, sanitizeUrl),
-		body: normalizeValue(body, {
-			maxDepth: 6,
-			maxObjectKeys: 80
-		})
-	};
-}
-function normalizeCspViolation(event, sanitizeUrl) {
-	return {
-		type: "securitypolicyviolation",
-		blockedURI: maybeSanitize(event.blockedURI, sanitizeUrl),
-		documentURI: maybeSanitize(event.documentURI, sanitizeUrl),
-		effectiveDirective: event.effectiveDirective,
-		violatedDirective: event.violatedDirective,
-		disposition: event.disposition,
-		sourceFile: maybeSanitize(event.sourceFile, sanitizeUrl),
-		lineNumber: event.lineNumber,
-		columnNumber: event.columnNumber,
-		statusCode: event.statusCode,
-		sample: event.sample
-	};
-}
-function captureReportingIntegration(options = {}) {
-	const captureSecurityPolicyViolation = options.captureSecurityPolicyViolation ?? true;
-	const captureReportingObserver = options.captureReportingObserver ?? true;
-	const reportTypes = options.reportTypes ?? defaultReportTypes;
-	const buffered = options.buffered ?? true;
-	return {
-		name: "capture-reporting",
-		setup(api) {
-			const add = options.addEventListener ?? globalThis.addEventListener?.bind(globalThis);
-			const remove = options.removeEventListener ?? globalThis.removeEventListener?.bind(globalThis);
-			const Observer = options.ReportingObserver ?? globalThis.ReportingObserver;
-			const disposers = [];
-			let disposed = false;
-			const captureReport = api.guard((report) => {
-				if (disposed) return;
-				api.capture({
-					level: levelFor$1(options.level, report),
-					message: `Browser report ${report.type}`,
-					props: { browser: {
-						kind: "report",
-						report
-					} }
-				});
-			});
-			if (captureSecurityPolicyViolation && add && remove) {
-				const onViolation = api.guard((event) => {
-					const report = normalizeCspViolation(event, options.sanitizeUrl);
-					api.capture({
-						level: levelFor$1(options.level, report),
-						message: `Security policy violation: ${report.effectiveDirective ?? report.violatedDirective ?? "unknown"}`,
-						props: { browser: {
-							kind: "securitypolicyviolation",
-							report
-						} }
-					});
-				});
-				add("securitypolicyviolation", onViolation);
-				disposers.push(() => remove("securitypolicyviolation", onViolation));
-			}
-			if (captureReportingObserver && Observer) try {
-				const observer = new Observer((reports) => {
-					for (const report of reports) captureReport(normalizeReport(report, options.sanitizeUrl));
-				}, {
-					buffered,
-					types: reportTypes
-				});
-				observer.observe();
-				disposers.push(() => {
-					for (const report of observer.takeRecords?.() ?? []) captureReport(normalizeReport(report, options.sanitizeUrl));
-					observer.disconnect();
-				});
-			} catch {}
-			return () => {
-				if (disposed) return;
-				for (const dispose of disposers) dispose();
-				disposed = true;
-			};
-		}
-	};
-}
-//#endregion
-//#region src/router-integration.ts
-function locationHref(location) {
-	if (!location) return "http://localhost/";
-	if (location.href) return location.href;
-	return `${location.pathname ?? "/"}${location.search ?? ""}${location.hash ?? ""}`;
-}
-function normalizeRouteUrl(url, location, mode, sanitizeUrl) {
-	const fallback = locationHref(location);
-	const raw = url === void 0 || url === null ? fallback : String(url);
-	let normalized = raw;
-	try {
-		const parsed = new URL(raw, fallback);
-		normalized = mode === "href" ? parsed.href : `${parsed.pathname}${parsed.search}${parsed.hash}`;
-	} catch {
-		normalized = raw;
-	}
-	return sanitizeUrl ? sanitizeUrl(normalized) : normalized;
-}
-function routeState(includeState, state, maxDepth) {
-	return includeState ? normalizeValue(state, {
-		maxDepth,
-		maxObjectKeys: 80
-	}) : void 0;
-}
-function captureRouterIntegration(options = {}) {
-	const level = options.level ?? "info";
-	const captureInitial = options.captureInitial ?? true;
-	const includeState = options.includeState ?? false;
-	const stateMaxDepth = options.stateMaxDepth ?? 4;
-	const urlMode = options.urlMode ?? "path";
-	return {
-		name: "capture-router",
-		setup(api) {
-			const history = options.history ?? globalThis.history;
-			const location = options.location ?? globalThis.location;
-			const add = options.addEventListener ?? globalThis.addEventListener?.bind(globalThis);
-			const remove = options.removeEventListener ?? globalThis.removeEventListener?.bind(globalThis);
-			const originalPushState = history?.pushState;
-			const originalReplaceState = history?.replaceState;
-			let current = normalizeRouteUrl(void 0, location, urlMode, options.sanitizeUrl);
-			let disposed = false;
-			const capture = (trigger, to, state) => {
-				if (disposed) return;
-				const previous = current;
-				current = to;
-				if (trigger !== "initial" && previous === to) return;
-				const route = {
-					trigger,
-					from: trigger === "initial" ? void 0 : previous,
-					to,
-					state: routeState(includeState, state, stateMaxDepth)
-				};
-				api.capture({
-					level,
-					message: trigger === "initial" ? `Route initial ${to}` : `Route change ${to}`,
-					props: { browser: {
-						kind: "route-change",
-						route
-					} }
-				});
-			};
-			if (captureInitial) capture("initial", current, history?.state);
-			if (history && originalPushState) history.pushState = function pushState(data, unused, url) {
-				const result = originalPushState.call(this, data, unused, url);
-				capture("pushState", normalizeRouteUrl(url, location, urlMode, options.sanitizeUrl), data);
-				return result;
-			};
-			if (history && originalReplaceState) history.replaceState = function replaceState(data, unused, url) {
-				const result = originalReplaceState.call(this, data, unused, url);
-				capture("replaceState", normalizeRouteUrl(url, location, urlMode, options.sanitizeUrl), data);
-				return result;
-			};
-			const onPopState = api.guard((event) => {
-				capture("popstate", normalizeRouteUrl(void 0, location, urlMode, options.sanitizeUrl), event.state);
-			});
-			const onHashChange = api.guard((event) => {
-				capture("hashchange", normalizeRouteUrl(event.newURL, location, urlMode, options.sanitizeUrl), history?.state);
-			});
-			add?.("popstate", onPopState);
-			add?.("hashchange", onHashChange);
-			return () => {
-				if (disposed) return;
-				disposed = true;
-				if (history && originalPushState) history.pushState = originalPushState;
-				if (history && originalReplaceState) history.replaceState = originalReplaceState;
-				remove?.("popstate", onPopState);
-				remove?.("hashchange", onHashChange);
-			};
-		}
-	};
-}
-//#endregion
-//#region src/runtime-host-integration.ts
-const textEncoder$2 = new TextEncoder();
-function byteLength(value) {
-	if (typeof value === "string") return textEncoder$2.encode(value).byteLength;
-	if (value instanceof ArrayBuffer) return value.byteLength;
-	if (ArrayBuffer.isView(value)) return value.byteLength;
-}
-function valueSummary(value, includeData) {
-	return {
-		dataType: typeof value === "object" && value ? value.constructor?.name ?? "object" : typeof value,
-		byteLength: byteLength(value),
-		data: includeData ? normalizeValue(value, {
-			maxDepth: 4,
-			maxObjectKeys: 80
-		}) : void 0
-	};
-}
-function senderInfo(sender, sanitizeUrl) {
-	if (!sender) return void 0;
-	const sanitize = (url) => url && sanitizeUrl ? sanitizeUrl(url) : url;
-	return {
-		id: sender.id,
-		origin: sender.origin,
-		url: sanitize(sender.url),
-		tab: sender.tab ? {
-			id: sender.tab.id,
-			url: sanitize(sender.tab.url)
-		} : void 0
-	};
-}
-function defaultExtensionRuntime() {
-	const global = globalThis;
-	return global.browser?.runtime ?? global.chrome?.runtime;
-}
-function defaultIpcRenderer() {
-	const global = globalThis;
-	if (global.electron?.ipcRenderer) return global.electron.ipcRenderer;
-	try {
-		return (global.require?.("electron"))?.ipcRenderer;
-	} catch {
-		return;
-	}
-}
-function captureRuntimeHostIntegration(options = {}) {
-	const level = options.level ?? "debug";
-	const captureExtensionMessages = options.captureExtensionMessages ?? true;
-	const captureExtensionInstalled = options.captureExtensionInstalled ?? true;
-	const captureExtensionMessageData = options.captureExtensionMessageData ?? false;
-	const captureElectronMessages = options.captureElectronMessages ?? true;
-	const captureElectronSend = options.captureElectronSend ?? true;
-	const captureElectronInvoke = options.captureElectronInvoke ?? true;
-	const captureElectronMessageData = options.captureElectronMessageData ?? false;
-	const electronChannels = options.electronChannels ?? [];
-	return {
-		name: "capture-runtime-host",
-		setup(api) {
-			const extensionRuntime = options.extensionRuntime ?? defaultExtensionRuntime();
-			const ipcRenderer = options.ipcRenderer ?? defaultIpcRenderer();
-			const disposers = [];
-			let disposed = false;
-			const capture = api.guard((input) => {
-				if (!disposed) api.capture(input);
-			});
-			if (extensionRuntime) {
-				const manifest = extensionRuntime.getManifest?.();
-				if (captureExtensionMessages && extensionRuntime.onMessage?.addListener) {
-					const onMessage = (message, sender) => {
-						capture({
-							level,
-							message: "Browser extension message",
-							props: { browser: {
-								kind: "extension-message",
-								extension: {
-									id: extensionRuntime.id,
-									name: manifest?.name,
-									version: manifest?.version
-								},
-								message: valueSummary(message, captureExtensionMessageData),
-								sender: senderInfo(sender, options.sanitizeUrl)
-							} }
-						});
-					};
-					extensionRuntime.onMessage.addListener(onMessage);
-					disposers.push(() => extensionRuntime.onMessage?.removeListener?.(onMessage));
-				}
-				if (captureExtensionInstalled && extensionRuntime.onInstalled?.addListener) {
-					const onInstalled = (details) => {
-						capture({
-							level,
-							message: "Browser extension installed",
-							props: { browser: {
-								kind: "extension-installed",
-								extension: {
-									id: extensionRuntime.id,
-									name: manifest?.name,
-									version: manifest?.version
-								},
-								details: normalizeValue(details, {
-									maxDepth: 4,
-									maxObjectKeys: 80
-								})
-							} }
-						});
-					};
-					extensionRuntime.onInstalled.addListener(onInstalled);
-					disposers.push(() => extensionRuntime.onInstalled?.removeListener?.(onInstalled));
-				}
-			}
-			if (ipcRenderer) {
-				if (captureElectronMessages && ipcRenderer.on) for (const channel of electronChannels) {
-					const listener = (_event, ...args) => {
-						capture({
-							level,
-							message: `Electron IPC message ${channel}`,
-							props: { browser: {
-								kind: "electron-ipc",
-								direction: "incoming",
-								channel,
-								args: args.map((arg) => valueSummary(arg, captureElectronMessageData))
-							} }
-						});
-					};
-					ipcRenderer.on(channel, listener);
-					disposers.push(() => {
-						if (ipcRenderer.off) ipcRenderer.off(channel, listener);
-						else ipcRenderer.removeListener?.(channel, listener);
-					});
-				}
-				if (captureElectronSend && ipcRenderer.send) {
-					const originalSend = ipcRenderer.send;
-					ipcRenderer.send = (channel, ...args) => {
-						capture({
-							level,
-							message: `Electron IPC send ${channel}`,
-							props: { browser: {
-								kind: "electron-ipc",
-								direction: "outgoing",
-								channel,
-								args: args.map((arg) => valueSummary(arg, captureElectronMessageData))
-							} }
-						});
-						return originalSend.call(ipcRenderer, channel, ...args);
-					};
-					disposers.push(() => {
-						ipcRenderer.send = originalSend;
-					});
-				}
-				if (captureElectronInvoke && ipcRenderer.invoke) {
-					const originalInvoke = ipcRenderer.invoke;
-					ipcRenderer.invoke = (channel, ...args) => {
-						capture({
-							level,
-							message: `Electron IPC invoke ${channel}`,
-							props: { browser: {
-								kind: "electron-ipc",
-								direction: "invoke",
-								channel,
-								args: args.map((arg) => valueSummary(arg, captureElectronMessageData))
-							} }
-						});
-						return originalInvoke.call(ipcRenderer, channel, ...args);
-					};
-					disposers.push(() => {
-						ipcRenderer.invoke = originalInvoke;
-					});
-				}
-			}
-			return () => {
-				if (disposed) return;
-				disposed = true;
-				for (const dispose of disposers) dispose();
-			};
-		}
-	};
-}
-//#endregion
-//#region src/service-worker-integration.ts
-const textEncoder$1 = new TextEncoder();
-function dataType$1(data) {
-	if (typeof data === "string") return "string";
-	if (data instanceof ArrayBuffer) return "arraybuffer";
-	if (ArrayBuffer.isView(data)) return data.constructor.name;
-	return data?.constructor?.name ?? typeof data;
-}
-function dataByteLength$1(data) {
-	if (typeof data === "string") return textEncoder$1.encode(data).byteLength;
-	if (data instanceof ArrayBuffer) return data.byteLength;
-	if (ArrayBuffer.isView(data)) return data.byteLength;
-	const size = data?.size;
-	return typeof size === "number" && Number.isFinite(size) ? size : void 0;
-}
-function controllerInfo(controller, sanitizeUrl) {
-	if (!controller) return void 0;
-	return {
-		scriptURL: controller.scriptURL && sanitizeUrl ? sanitizeUrl(controller.scriptURL) : controller.scriptURL,
-		state: controller.state
-	};
-}
-function messagePayload$1(event, captureMessageData) {
-	return {
-		dataType: dataType$1(event.data),
-		byteLength: dataByteLength$1(event.data),
-		data: captureMessageData ? normalizeValue(event.data, {
-			maxDepth: 4,
-			maxObjectKeys: 80
-		}) : void 0,
-		origin: event.origin,
-		lastEventId: event.lastEventId
-	};
-}
-function captureServiceWorkerIntegration(options = {}) {
-	const level = options.level ?? "debug";
-	const captureControllerChange = options.captureControllerChange ?? true;
-	const captureMessages = options.captureMessages ?? true;
-	const captureMessageErrors = options.captureMessageErrors ?? true;
-	const captureMessageData = options.captureMessageData ?? false;
-	return {
-		name: "capture-service-worker",
-		setup(api) {
-			const serviceWorker = options.serviceWorker ?? (typeof navigator === "undefined" ? void 0 : navigator.serviceWorker);
-			if (!serviceWorker?.addEventListener || !serviceWorker.removeEventListener) return;
-			const disposers = [];
-			let disposed = false;
-			const capture = api.guard((input) => {
-				if (!disposed) api.capture(input);
-			});
-			if (captureControllerChange) {
-				const onControllerChange = () => {
-					capture({
-						level,
-						message: "Service worker controller change",
-						props: { browser: {
-							kind: "service-worker",
-							event: "controllerchange",
-							controller: controllerInfo(serviceWorker.controller, options.sanitizeUrl)
-						} }
-					});
-				};
-				serviceWorker.addEventListener("controllerchange", onControllerChange);
-				disposers.push(() => serviceWorker.removeEventListener("controllerchange", onControllerChange));
-			}
-			if (captureMessages) {
-				const onMessage = (event) => {
-					capture({
-						level,
-						message: "Service worker message",
-						props: { browser: {
-							kind: "service-worker",
-							event: "message",
-							message: messagePayload$1(event, captureMessageData)
-						} }
-					});
-				};
-				serviceWorker.addEventListener("message", onMessage);
-				disposers.push(() => serviceWorker.removeEventListener("message", onMessage));
-			}
-			if (captureMessageErrors) {
-				const onMessageError = (event) => {
-					capture({
-						level: "warn",
-						message: "Service worker message error",
-						props: { browser: {
-							kind: "service-worker",
-							event: "messageerror",
-							type: event.type
-						} }
-					});
-				};
-				serviceWorker.addEventListener("messageerror", onMessageError);
-				disposers.push(() => serviceWorker.removeEventListener("messageerror", onMessageError));
-			}
-			return () => {
-				if (disposed) return;
-				disposed = true;
-				for (const dispose of disposers) dispose();
-			};
-		}
-	};
-}
-//#endregion
-//#region src/user-action-integration.ts
-const defaultEvents = [
-	"click",
-	"input",
-	"change",
-	"submit"
-];
-const defaultLabelAttributes = [
-	"data-loggerjs-label",
-	"aria-label",
-	"name",
-	"id"
-];
-function truncate(value, maxLength) {
-	if (!value) return void 0;
-	return value.length > maxLength ? value.slice(0, maxLength) : value;
-}
-function readAttribute(target, name) {
-	return target.getAttribute?.(name) || void 0;
-}
-function sanitizeField(value, field, sanitize) {
-	if (!value) return void 0;
-	return sanitize ? sanitize(value, field) : value;
-}
-function firstLabel(target, attributes) {
-	for (const name of attributes) {
-		const value = readAttribute(target, name) ?? target[name];
-		if (typeof value === "string" && value) return value;
-	}
-}
-function targetInfo(target, options) {
-	const element = target;
-	if (!element || typeof element !== "object") return {};
-	const maxTextLength = options.maxTextLength ?? 120;
-	const sanitize = options.sanitize;
-	const info = {
-		tagName: sanitizeField(element.tagName?.toLowerCase(), "tagName", sanitize),
-		id: sanitizeField(element.id, "id", sanitize),
-		name: sanitizeField(element.name, "name", sanitize),
-		role: sanitizeField(element.role ?? readAttribute(element, "role"), "role", sanitize),
-		type: sanitizeField(element.type, "type", sanitize),
-		href: sanitizeField(element.href, "href", sanitize),
-		label: sanitizeField(firstLabel(element, options.labelAttributes ?? defaultLabelAttributes), "label", sanitize)
-	};
-	if (options.captureText) info.text = sanitizeField(truncate(element.textContent ?? void 0, maxTextLength), "text", sanitize);
-	if (options.captureValue) info.value = sanitizeField(truncate(element.value, maxTextLength), "value", sanitize);
-	return info;
-}
-function throttleKey(event, target) {
-	return `${event.type}:${target.tagName ?? ""}:${target.id ?? ""}:${target.name ?? ""}:${target.label ?? ""}`;
-}
-function captureUserActionsIntegration(options = {}) {
-	const events = options.events ?? defaultEvents;
-	const level = options.level ?? "info";
-	const listenerCapture = options.listenerCapture ?? true;
-	const throttleMs = Math.max(0, Math.floor(options.throttleMs ?? 250));
-	const clock = options.clock ?? Date.now;
-	return {
-		name: "capture-user-actions",
-		setup(api) {
-			const root = options.root ?? globalThis.document;
-			if (!root?.addEventListener || !root.removeEventListener) return;
-			const lastSeen = /* @__PURE__ */ new Map();
-			let disposed = false;
-			const onAction = api.guard((event) => {
-				if (disposed) return;
-				const target = targetInfo(event.target, options);
-				if (options.ignore?.(event, target)) return;
-				const now = clock();
-				const key = throttleKey(event, target);
-				const last = lastSeen.get(key) ?? 0;
-				if (throttleMs > 0 && now - last < throttleMs) return;
-				lastSeen.set(key, now);
-				const action = {
-					type: event.type,
-					target
-				};
-				api.capture({
-					level,
-					message: `User action ${event.type}${target.label ? ` ${target.label}` : ""}`,
-					props: { browser: {
-						kind: "user-action",
-						action
-					} }
-				});
-			});
-			for (const event of events) root.addEventListener(event, onAction, listenerCapture);
-			return () => {
-				if (disposed) return;
-				disposed = true;
-				for (const event of events) root.removeEventListener(event, onAction, listenerCapture);
-			};
-		}
-	};
-}
-//#endregion
-//#region src/websocket-integration.ts
-const registryKey = "browser.WebSocket";
-const textEncoder = new TextEncoder();
-function dataType(data) {
-	if (typeof data === "string") return "string";
-	if (data instanceof ArrayBuffer) return "arraybuffer";
-	if (ArrayBuffer.isView(data)) return data.constructor.name;
-	return data?.constructor?.name ?? typeof data;
-}
-function dataByteLength(data) {
-	if (typeof data === "string") return textEncoder.encode(data).byteLength;
-	if (data instanceof ArrayBuffer) return data.byteLength;
-	if (ArrayBuffer.isView(data)) return data.byteLength;
-	const size = data?.size;
-	return typeof size === "number" && Number.isFinite(size) ? size : void 0;
-}
-function messagePayload(direction, data, captureMessageData) {
-	return {
-		direction,
-		dataType: dataType(data),
-		byteLength: dataByteLength(data),
-		data: captureMessageData ? normalizeValue(data, {
-			maxDepth: 4,
-			maxObjectKeys: 80
-		}) : void 0
-	};
-}
-function closeEventPayload(event) {
-	const close = event;
-	return {
-		code: close.code,
-		reason: close.reason,
-		wasClean: close.wasClean
-	};
-}
-function copyStaticConstants(target, source) {
-	for (const key of [
-		"CONNECTING",
-		"OPEN",
-		"CLOSING",
-		"CLOSED"
-	]) if (source[key] !== void 0) target[key] = source[key];
-}
-function captureWebSocketIntegration(options = {}) {
-	const level = options.level ?? "debug";
-	const captureConnect = options.captureConnect ?? true;
-	const captureOpen = options.captureOpen ?? true;
-	const captureClose = options.captureClose ?? true;
-	const captureError = options.captureError ?? true;
-	const captureMessages = options.captureMessages ?? false;
-	const captureSentMessages = options.captureSentMessages ?? false;
-	const captureMessageData = options.captureMessageData ?? false;
-	const sampleRate = options.sampleRate ?? 1;
-	const random = options.random ?? Math.random;
-	return {
-		name: "capture-websocket",
-		setup(api) {
-			const globalWebSocket = globalThis.WebSocket;
-			const current = options.WebSocket ?? globalWebSocket;
-			if (!current) return;
-			const original = api.unpatched.get(registryKey) ?? current;
-			api.unpatched.set(registryKey, original);
-			const capture = api.guard((input) => api.capture(input));
-			const PatchedWebSocket = function WebSocket(url, protocols) {
-				const started = nowMs();
-				const sanitizedUrl = sanitizeHttpUrl(String(url), options.sanitizeUrl);
-				const socket = new original(url, protocols);
-				const captureLifecycle = (event, extra = {}, error) => {
-					if (!shouldSample(sampleRate, random)) return;
-					capture({
-						level: event === "error" ? "error" : level,
-						message: `WebSocket ${event} ${sanitizedUrl}`,
-						error,
-						props: { websocket: {
-							kind: "websocket",
-							event,
-							url: sanitizedUrl,
-							durationMs: durationMs(started),
-							...extra
-						} }
-					});
-				};
-				if (captureConnect) captureLifecycle("connect");
-				if (captureOpen) socket.addEventListener?.("open", () => captureLifecycle("open"));
-				if (captureClose) socket.addEventListener?.("close", (event) => captureLifecycle("close", closeEventPayload(event)));
-				if (captureError) socket.addEventListener?.("error", (event) => captureLifecycle("error", { type: event.type }, event));
-				if (captureMessages) socket.addEventListener?.("message", (event) => {
-					const message = event;
-					capture({
-						level,
-						message: `WebSocket message ${sanitizedUrl}`,
-						props: { websocket: {
-							kind: "websocket-message",
-							url: sanitizedUrl,
-							message: messagePayload("incoming", message.data, captureMessageData)
-						} }
-					});
-				});
-				if (captureSentMessages && socket.send) {
-					const originalSend = socket.send.bind(socket);
-					socket.send = (data) => {
-						capture({
-							level,
-							message: `WebSocket send ${sanitizedUrl}`,
-							props: { websocket: {
-								kind: "websocket-message",
-								url: sanitizedUrl,
-								message: messagePayload("outgoing", data, captureMessageData)
-							} }
-						});
-						return originalSend(data);
-					};
-				}
-				return socket;
-			};
-			PatchedWebSocket.prototype = original.prototype;
-			copyStaticConstants(PatchedWebSocket, original);
-			globalThis.WebSocket = PatchedWebSocket;
-			return () => {
-				globalThis.WebSocket = current;
-			};
-		}
-	};
-}
-//#endregion
-//#region src/web-vitals-integration.ts
-const defaultMetrics = [
-	"CLS",
-	"FCP",
-	"INP",
-	"LCP",
-	"TTFB"
-];
-const thresholds = {
-	CLS: [.1, .25],
-	FCP: [1800, 3e3],
-	INP: [200, 500],
-	LCP: [2500, 4e3],
-	TTFB: [800, 1800]
-};
-function ratingFor(name, value) {
-	const [good, needsImprovement] = thresholds[name];
-	if (value <= good) return "good";
-	if (value <= needsImprovement) return "needs-improvement";
-	return "poor";
-}
-function metricId(name) {
-	return `${name.toLowerCase()}-${Date.now().toString(36)}`;
-}
-function entryValue(entry, field) {
-	const value = entry[field];
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function hasMetric(metrics, name) {
-	return metrics.includes(name);
-}
-function supportsEntryType$1(Observer, type) {
-	const supported = Observer?.supportedEntryTypes;
-	return !supported || supported.includes(type);
-}
-function captureWebVitalsIntegration(options = {}) {
-	const metrics = options.metrics ?? defaultMetrics;
-	const level = options.level ?? "info";
-	const reportAllChanges = options.reportAllChanges ?? false;
-	const flushOnHidden = options.flushOnHidden ?? true;
-	return {
-		name: "capture-web-vitals",
-		setup(api) {
-			const Observer = options.PerformanceObserver ?? globalThis.PerformanceObserver;
-			const perf = options.performance ?? globalThis.performance;
-			const add = options.addEventListener ?? globalThis.addEventListener?.bind(globalThis);
-			const remove = options.removeEventListener ?? globalThis.removeEventListener?.bind(globalThis);
-			const disposers = [];
-			const currentValues = /* @__PURE__ */ new Map();
-			const reportedValues = /* @__PURE__ */ new Map();
-			const emitted = /* @__PURE__ */ new Set();
-			let disposed = false;
-			const emit = (name, value, final) => {
-				if (!Number.isFinite(value)) return;
-				const finalKey = `${name}:final`;
-				if (final && emitted.has(finalKey)) return;
-				const previous = reportedValues.get(name) ?? 0;
-				currentValues.set(name, value);
-				reportedValues.set(name, value);
-				if (final) emitted.add(finalKey);
-				const metric = {
-					name,
-					value,
-					delta: value - previous,
-					rating: ratingFor(name, value),
-					id: metricId(name),
-					final
-				};
-				api.capture({
-					level,
-					message: `Web vital ${metric.name} ${metric.value}`,
-					props: { webVital: metric }
-				});
-			};
-			const observe = (type, callback, init = {
-				type,
-				buffered: true
-			}) => {
-				if (!Observer || !supportsEntryType$1(Observer, type)) return;
-				try {
-					const observer = new Observer((list) => {
-						for (const entry of list.getEntries()) callback(entry);
-					});
-					observer.observe(init);
-					disposers.push(() => observer.disconnect());
-				} catch {}
-			};
-			if (hasMetric(metrics, "TTFB") && perf) {
-				const navigation = perf.getEntriesByType("navigation")[0];
-				if (navigation) {
-					const responseStart = entryValue(navigation, "responseStart");
-					const startTime = entryValue(navigation, "startTime") ?? 0;
-					if (responseStart !== void 0) emit("TTFB", responseStart - startTime, true);
-				}
-			}
-			if (hasMetric(metrics, "FCP") && perf) {
-				const existing = perf.getEntriesByName("first-contentful-paint")[0];
-				if (existing) emit("FCP", existing.startTime, true);
-				observe("paint", (entry) => {
-					if (entry.name === "first-contentful-paint") emit("FCP", entry.startTime, true);
-				});
-			}
-			if (hasMetric(metrics, "CLS")) observe("layout-shift", (entry) => {
-				if (entry.hadRecentInput === true) return;
-				const value = entryValue(entry, "value") ?? 0;
-				const next = (currentValues.get("CLS") ?? 0) + value;
-				if (reportAllChanges) emit("CLS", next, false);
-				else currentValues.set("CLS", next);
-			});
-			if (hasMetric(metrics, "LCP")) observe("largest-contentful-paint", (entry) => {
-				currentValues.set("LCP", entry.startTime);
-				if (reportAllChanges) emit("LCP", entry.startTime, false);
-			});
-			if (hasMetric(metrics, "INP")) observe("event", (entry) => {
-				const duration = entryValue(entry, "duration") ?? 0;
-				if (duration <= (currentValues.get("INP") ?? 0)) return;
-				currentValues.set("INP", duration);
-				if (reportAllChanges) emit("INP", duration, false);
-			}, {
-				type: "event",
-				buffered: true,
-				durationThreshold: 40
-			});
-			const flushFinal = api.guard(() => {
-				const cls = currentValues.get("CLS");
-				if (cls !== void 0 && cls > 0) emit("CLS", cls, true);
-				const lcp = currentValues.get("LCP");
-				if (lcp !== void 0) emit("LCP", lcp, true);
-				const inp = currentValues.get("INP");
-				if (inp !== void 0) emit("INP", inp, true);
-			});
-			if (flushOnHidden && add && remove) {
-				const onPageHide = () => flushFinal();
-				const onVisibilityChange = () => {
-					if (typeof document !== "undefined" && document.visibilityState === "hidden") flushFinal();
-				};
-				add("pagehide", onPageHide);
-				add("visibilitychange", onVisibilityChange);
-				disposers.push(() => {
-					remove("pagehide", onPageHide);
-					remove("visibilitychange", onVisibilityChange);
-				});
-			}
-			return () => {
-				if (disposed) return;
-				disposed = true;
-				flushFinal();
-				for (const dispose of disposers) dispose();
-			};
-		}
-	};
-}
-//#endregion
-//#region src/performance-integration.ts
-const defaultEntryTypes = [
-	"navigation",
-	"resource",
-	"longtask",
-	"measure",
-	"mark"
-];
-const numberFields = [
-	"transferSize",
-	"encodedBodySize",
-	"decodedBodySize",
-	"workerStart",
-	"redirectStart",
-	"redirectEnd",
-	"fetchStart",
-	"domainLookupStart",
-	"domainLookupEnd",
-	"connectStart",
-	"connectEnd",
-	"requestStart",
-	"responseStart",
-	"responseEnd"
-];
-function supportsEntryType(Observer, type) {
-	const supported = Observer?.supportedEntryTypes;
-	return !supported || supported.includes(type);
-}
-function finiteNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function stringValue(value) {
-	return typeof value === "string" && value ? value : void 0;
-}
-function normalizeBrowserPerformanceEntry(entry, options = {}) {
-	const raw = entry;
-	const payload = {
-		name: options.sanitizeName ? options.sanitizeName(entry.name, entry.entryType) : entry.name,
-		entryType: entry.entryType,
-		startTime: entry.startTime,
-		duration: entry.duration
-	};
-	for (const field of numberFields) {
-		const value = finiteNumber(raw[field]);
-		if (value !== void 0) payload[field] = value;
-	}
-	const responseStatus = finiteNumber(raw.responseStatus);
-	if (responseStatus !== void 0) payload.responseStatus = responseStatus;
-	const initiatorType = stringValue(raw.initiatorType);
-	if (initiatorType) payload.initiatorType = initiatorType;
-	const nextHopProtocol = stringValue(raw.nextHopProtocol);
-	if (nextHopProtocol) payload.nextHopProtocol = nextHopProtocol;
-	const renderBlockingStatus = stringValue(raw.renderBlockingStatus);
-	if (renderBlockingStatus) payload.renderBlockingStatus = renderBlockingStatus;
-	if (options.captureDetail && raw.detail !== void 0) payload.detail = raw.detail;
-	return payload;
-}
-function minDurationFor(value, entryType) {
-	if (typeof value === "number") return value;
-	return value?.[entryType] ?? 0;
-}
-function levelFor(value, entry) {
-	if (typeof value === "function") return value(entry);
-	if (value) return value;
-	return entry.entryType === "longtask" ? "warn" : "info";
-}
-function entryKey(entry) {
-	return `${entry.entryType}:${entry.name}:${entry.startTime}:${entry.duration}`;
-}
-function capturePerformanceIntegration(options = {}) {
-	const entryTypes = options.entryTypes ?? defaultEntryTypes;
-	const buffered = options.buffered ?? true;
-	const emitExisting = options.emitExisting ?? true;
-	const maxEntries = Math.max(0, Math.floor(options.maxEntries ?? 200));
-	const sampleRate = options.sampleRate ?? 1;
-	const random = options.random ?? Math.random;
-	return {
-		name: "capture-performance",
-		setup(api) {
-			const Observer = options.PerformanceObserver ?? globalThis.PerformanceObserver;
-			const perf = options.performance ?? globalThis.performance;
-			const seen = /* @__PURE__ */ new Set();
-			const disposers = [];
-			let emitted = 0;
-			let disposed = false;
-			const capture = api.guard((entry) => {
-				if (disposed || emitted >= maxEntries) return;
-				const payload = normalizeBrowserPerformanceEntry(entry, options);
-				if (payload.duration < minDurationFor(options.minDurationMs, payload.entryType)) return;
-				if (sampleRate < 1 && random() >= sampleRate) return;
-				if (options.ignore?.(payload)) return;
-				const key = entryKey(payload);
-				if (seen.has(key)) return;
-				seen.add(key);
-				emitted += 1;
-				api.capture({
-					level: levelFor(options.level, payload),
-					message: `Performance ${payload.entryType} ${payload.name}`,
-					props: { performance: payload }
-				});
-			});
-			const emitExistingEntries = (type) => {
-				if (!emitExisting || !perf) return;
-				try {
-					for (const entry of perf.getEntriesByType(type)) capture(entry);
-				} catch {}
-			};
-			for (const type of entryTypes) {
-				emitExistingEntries(type);
-				if (!Observer || !supportsEntryType(Observer, type)) continue;
-				try {
-					const observer = new Observer((list) => {
-						for (const entry of list.getEntries()) capture(entry);
-					});
-					observer.observe({
-						type,
-						buffered
-					});
-					disposers.push(() => observer.disconnect());
-				} catch {}
-			}
-			return () => {
-				if (disposed) return;
-				disposed = true;
-				for (const dispose of disposers) dispose();
-			};
-		}
-	};
-}
-//#endregion
-//#region src/page-lifecycle.ts
-function pageLifecycleIntegration(options = {}) {
-	const flushOnPageHide = options.flushOnPageHide ?? true;
-	const flushOnHidden = options.flushOnHidden ?? true;
-	const coalesceMs = options.coalesceMs ?? 250;
-	return {
-		name: "page-lifecycle",
-		setup(api) {
-			if (typeof addEventListener === "undefined") return;
-			let disposed = false;
-			let flushInFlight;
-			let lastFlushAt = 0;
-			const flush = () => {
-				const now = Date.now();
-				if (flushInFlight || now - lastFlushAt < coalesceMs) return;
-				lastFlushAt = now;
-				flushInFlight = Promise.resolve(api.flush()).catch(() => {}).finally(() => {
-					flushInFlight = void 0;
-				});
-			};
-			const onVisibility = () => {
-				if (typeof document !== "undefined" && document.visibilityState === "hidden") flush();
-			};
-			if (flushOnPageHide) addEventListener("pagehide", flush);
-			if (flushOnHidden) addEventListener("visibilitychange", onVisibility);
-			return () => {
-				if (disposed) return;
-				disposed = true;
-				if (flushOnPageHide) removeEventListener("pagehide", flush);
-				if (flushOnHidden) removeEventListener("visibilitychange", onVisibility);
-			};
-		}
-	};
-}
-//#endregion
 export { browserBroadcastChannelTransport, browserCompressionPayloadTransform, browserContextPropagationIntegration, browserHttpTransport, browserServiceWorkerTransport, browserWebSocketTransport, captureBrowserErrorsIntegration, captureConsoleIntegration, captureFetchIntegration, captureFrameworkErrorsIntegration, capturePerformanceIntegration, captureReportingIntegration, captureRouterIntegration, captureRuntimeHostIntegration, captureServiceWorkerIntegration, captureUserActionsIntegration, captureWebSocketIntegration, captureWebVitalsIntegration, captureXHRIntegration, createLogZipBlob, downloadBlob, exportLogsToZip, indexedDbBrowserHttpOfflineQueue, indexedDbTransport, memoryBrowserHttpOfflineQueue, nextRouterIntegration, normalizeBrowserPerformanceEntry, nuxtRouterIntegration, offlineFirstTransport, pageLifecycleIntegration, reactRouterIntegration, vueRouterIntegration };
-
-//# sourceMappingURL=index.js.map