@loggerjs/browser 0.0.1

package/dist/index.js

@@ -0,0 +1,3119 @@
+import { incrementLoggerMetaCounter, normalizeValue, safeJsonCodec, safeJsonStringify, toLevelValue } from "@loggerjs/core";
+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 queue = [];
+	const maxBatchSize = options.maxBatchSize ?? 50;
+	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 flushing = false;
+	let replayingOffline = false;
+	let lastContext;
+	const headers = () => ({
+		"content-type": codec.contentType,
+		...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 = [];
+		let currentEvents = [];
+		let currentPayload;
+		for (const event of batch) {
+			const candidateEvents = [...currentEvents, event];
+			const candidatePayload = codec.encode(candidateEvents);
+			if (payloadByteLength$1(candidatePayload) <= beaconMaxBytes) {
+				currentEvents = candidateEvents;
+				currentPayload = candidatePayload;
+				continue;
+			}
+			if (currentEvents.length > 0 && currentPayload) chunks.push({
+				events: currentEvents,
+				payload: currentPayload
+			});
+			const singlePayload = codec.encode([event]);
+			if (payloadByteLength$1(singlePayload) <= beaconMaxBytes) {
+				currentEvents = [event];
+				currentPayload = singlePayload;
+			} else {
+				currentEvents = [];
+				currentPayload = void 0;
+				reportDrop(event, "beacon-too-large");
+			}
+		}
+		if (currentEvents.length > 0 && currentPayload) chunks.push({
+			events: currentEvents,
+			payload: currentPayload
+		});
+		return chunks;
+	};
+	const sendBeaconBatch = (batch) => {
+		if (typeof navigator === "undefined" || !navigator.sendBeacon) return {
+			ok: false,
+			remaining: batch
+		};
+		const chunks = createBeaconChunks(batch);
+		for (let index = 0; index < chunks.length; index++) {
+			const chunk = chunks[index];
+			if (!chunk) continue;
+			if (!navigator.sendBeacon(options.url, payloadToBeaconBody(chunk.payload, codec.contentType))) return {
+				ok: false,
+				remaining: remainingEvents(chunks, index)
+			};
+		}
+		return {
+			ok: true,
+			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 createOfflineEntry = (payload) => ({
+		id: `${Date.now().toString(36)}-${(offlineEntrySeq++).toString(36)}`,
+		url: options.url,
+		method: options.method ?? "POST",
+		headers: headers(),
+		body: payload,
+		credentials: options.credentials,
+		keepalive: options.keepalive ?? true,
+		createdAt: Date.now()
+	});
+	const enqueueOfflinePayload = async (payload) => {
+		if (!offlineQueue) return false;
+		await offlineQueue.enqueue(createOfflineEntry(payload));
+		incrementLoggerMetaCounter("transport.offline.queued");
+		return true;
+	};
+	const sendFetchBatch = async (batch) => {
+		if (batch.length === 0) return;
+		const payload = codec.encode(batch);
+		if (offlineQueue && typeof navigator !== "undefined" && navigator.onLine === false) {
+			await enqueueOfflinePayload(payload);
+			return;
+		}
+		try {
+			await sendPayload(createOfflineEntry(payload));
+		} catch (error) {
+			if (await enqueueOfflinePayload(payload)) return;
+			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 = async () => {
+		if (!offlineQueue || replayingOffline) return;
+		replayingOffline = true;
+		try {
+			await offlineQueue.replay(sendOfflineEntryWithRetry);
+		} finally {
+			replayingOffline = false;
+		}
+	};
+	const flush = async (preferBeacon = false) => {
+		if (flushing || queue.length === 0) return;
+		flushing = true;
+		clearTimer();
+		const batch = queue.splice(0, queue.length);
+		try {
+			let fetchBatch = batch;
+			if (preferBeacon) {
+				const beaconResult = sendBeaconBatch(batch);
+				if (beaconResult.ok || beaconResult.remaining.length === 0) return;
+				fetchBatch = beaconResult.remaining;
+			}
+			await sendFetchBatch(fetchBatch);
+		} finally {
+			flushing = false;
+			if (queue.length > 0) schedule();
+		}
+	};
+	const schedule = () => {
+		if (timer || flushIntervalMs <= 0) return;
+		timer = setTimeout(() => {
+			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);
+	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 (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/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 readyStarted = false;
+	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 startReady = (context) => {
+		if (target !== "ready" || readyStarted) return;
+		readyStarted = true;
+		const container = options.serviceWorker ?? serviceWorkerContainer();
+		if (!container?.ready) {
+			reportError(/* @__PURE__ */ new Error("serviceWorker.ready is not available"), context, "ready");
+			return;
+		}
+		container.ready.then((registration) => {
+			readyWorker = workerFromRegistration(registration);
+			if (!readyWorker) {
+				const pending = queue.splice(0);
+				for (const item of pending) reportDrop(item, "unavailable");
+				return;
+			}
+			drain(context);
+		}).catch((error) => {
+			const pending = queue.splice(0);
+			for (const item of pending) reportDrop(item, "ready");
+			reportError(error, context, "ready", pending.reduce((total, item) => total + item.events.length, 0));
+		});
+	};
+	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;
+		},
+		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 DB_VERSION = 2;
+const ORDER_INDEX_NAME = "createdAtSeq";
+function normalizePositiveInteger(value, fallback) {
+	if (value === void 0 || !Number.isFinite(value)) return fallback;
+	return Math.max(0, Math.floor(value));
+}
+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 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.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 orderRangeForQuery(options) {
+	if (typeof IDBKeyRange === "undefined") return void 0;
+	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 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 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 transactionOptions = durability === "default" ? void 0 : { durability };
+	const buffer = [];
+	let dbPromise;
+	let indexedDBFactoryPromise;
+	let timer;
+	let flushPromise;
+	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: {}
+	};
+	const snapshotStats = () => ({
+		...statsState,
+		bufferDepth: buffer.length,
+		droppedByReason: { ...statsState.droppedByReason },
+		errorsByOperation: { ...statsState.errorsByOperation },
+		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 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", () => {
+					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"
+					]);
+				});
+				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) => {
+		if (mode !== "readwrite" || !transactionOptions) return db.transaction(storeName, mode);
+		try {
+			return db.transaction(storeName, mode, transactionOptions);
+		} catch {
+			statsState.transactionOptionFallbacks += 1;
+			return db.transaction(storeName, 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 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 withStore("readwrite", async (store) => {
+			for (const entry of entries) {
+				await requestToPromise(store.delete(entry.id));
+				dropPersistedEntry(entry, reason);
+			}
+		});
+	};
+	const deleteByCursor = async (reason, openCursor, shouldDelete) => withStore("readwrite", async (store) => {
+		const request = openCursor(store);
+		if (!request) return void 0;
+		let deleted = 0;
+		await iterateCursor(request, (cursor) => {
+			const entry = cursor.value;
+			if (!shouldDelete(entry, deleted)) return false;
+			cursor.delete();
+			deleted += 1;
+			dropPersistedEntry(entry, reason);
+			return true;
+		});
+		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, 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 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 eventToEntry = (event) => {
+		const payload = codec.encode(event);
+		return {
+			id: event.id,
+			seq: event.seq,
+			createdAt: event.time,
+			level: event.level,
+			levelName: event.levelName,
+			logger: event.logger,
+			type: event.type,
+			byteLength: payloadByteLength(payload),
+			payload
+		};
+	};
+	const writeBatch = async (events) => {
+		if (events.length === 0) return;
+		const startedAt = nowMs$1();
+		statsState.lastFlushBatchSize = events.length;
+		const entries = events.map(eventToEntry);
+		try {
+			await withStore("readwrite", (store) => {
+				for (const entry of entries) store.put(entry);
+			});
+			statsState.persisted += entries.length;
+			incrementLoggerMetaCounter("transport.indexeddb.persisted", entries.length);
+			await prune();
+			statsState.flushes += 1;
+		} catch (error) {
+			statsState.flushErrors += 1;
+			throw error;
+		} finally {
+			statsState.lastFlushDurationMs = nowMs$1() - startedAt;
+		}
+	};
+	const clearTimer = () => {
+		if (timer) clearTimeout(timer);
+		timer = void 0;
+	};
+	const flushPending = async () => {
+		if (flushPromise) return flushPromise;
+		clearTimer();
+		flushPromise = writeBatch(buffer.splice(0, buffer.length)).finally(() => {
+			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 = () => {
+		flushPending().catch((error) => reportInternalError(error, "pagehide-flush"));
+	};
+	const onVisibilityChange = () => {
+		if (typeof document !== "undefined" && document.visibilityState === "hidden") flushPending().catch((error) => reportInternalError(error, "visibility-flush"));
+	};
+	if (flushOnPageHide) {
+		globalThis.addEventListener?.("pagehide", onPageHide);
+		globalThis.addEventListener?.("visibilitychange", onVisibilityChange);
+	}
+	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() {
+			buffer.length = 0;
+			clearTimer();
+			await withStore("readwrite", (store) => requestToPromise(store.clear()));
+		},
+		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;
+			}
+		},
+		stats() {
+			return snapshotStats();
+		},
+		close() {
+			closed = true;
+			clearTimer();
+			globalThis.removeEventListener?.("pagehide", onPageHide);
+			globalThis.removeEventListener?.("visibilitychange", onVisibilityChange);
+			const flushed = flushPending();
+			const promise = dbPromise;
+			dbPromise = void 0;
+			return flushed.finally(() => {
+				promise?.then((db) => db.close());
+			});
+		}
+	};
+}
+//#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;
+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 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 serialize = options.serializeEvent ?? ((event) => safeJsonStringify(event, options.stringify ?? {}));
+	const lines = [];
+	let skippedCount = 0;
+	let from;
+	let to;
+	for await (const event of resolveSource(source, options.query)) {
+		if (maxEvents !== void 0 && lines.length >= maxEvents) break;
+		const mapped = options.mapEvent ? options.mapEvent(event) : event;
+		if (!mapped) {
+			skippedCount += 1;
+			continue;
+		}
+		lines.push(serialize(mapped));
+		from = from === void 0 ? mapped.time : Math.min(from, mapped.time);
+		to = to === void 0 ? mapped.time : Math.max(to, mapped.time);
+	}
+	const files = [{
+		name: logFileName,
+		content: format === "json" ? `[${lines.join(",")}]` : lines.length > 0 ? `${lines.join("\n")}\n` : "",
+		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: lines.length,
+			skippedCount,
+			query: options.query,
+			timeRange: from === void 0 || to === void 0 ? void 0 : {
+				from,
+				to
+			}
+		};
+		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/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/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, browserHttpTransport, browserServiceWorkerTransport, browserWebSocketTransport, captureBrowserErrorsIntegration, captureConsoleIntegration, captureFetchIntegration, captureFrameworkErrorsIntegration, capturePerformanceIntegration, captureReportingIntegration, captureRouterIntegration, captureRuntimeHostIntegration, captureServiceWorkerIntegration, captureUserActionsIntegration, captureWebSocketIntegration, captureWebVitalsIntegration, captureXHRIntegration, createLogZipBlob, downloadBlob, exportLogsToZip, indexedDbBrowserHttpOfflineQueue, indexedDbTransport, memoryBrowserHttpOfflineQueue, normalizeBrowserPerformanceEntry, pageLifecycleIntegration };
+
+//# sourceMappingURL=index.js.map