@loggerjs/browser 0.5.0 → 0.5.2

package/dist/offline-first-transport.js

@@ -0,0 +1,674 @@
+import { incrementLoggerMetaCounter, recordToEvent, retryTransport, safeJsonCodec, toLevelValue } from "@loggerjs/core";
+//#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() {
+	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();
+		try {
+			if (await pruneWithCursors()) return;
+			statsState.pruneFallbacks += 1;
+			await pruneWithEntries();
+		} finally {
+			statsState.prunes += 1;
+			statsState.lastPruneDurationMs = nowMs() - 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();
+		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() - 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 remove(ids) {
+			await flushPending();
+			const items = typeof ids === "string" ? [ids] : ids;
+			if (items.length === 0) return;
+			await withStore("readwrite", async (store) => {
+				for (const id of items) await requestToPromise(store.delete(id));
+			});
+		},
+		async *query(queryOptions = {}) {
+			await flushPending();
+			const startedAt = nowMs();
+			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() - 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/offline-first-transport.ts
+function normalizeBatchSize(value) {
+	if (value === void 0 || !Number.isFinite(value) || value <= 0) return 100;
+	return Math.floor(value);
+}
+async function collectBatch(queue, replayBatchSize) {
+	const events = [];
+	for await (const event of queue.query({
+		order: "asc",
+		limit: replayBatchSize
+	})) events.push(event);
+	return events;
+}
+function isBrowserOnline(options) {
+	if (options.online) return options.online();
+	if (typeof navigator === "undefined") return true;
+	return navigator.onLine !== false;
+}
+function offlineFirstTransport(remote, options = {}) {
+	const name = options.name ?? `offline-first(${remote.name ?? "transport"})`;
+	const replayBatchSize = normalizeBatchSize(options.replayBatchSize);
+	const queue = options.queue ?? indexedDbTransport({
+		dbName: "loggerjs-offline",
+		flushIntervalMs: 0,
+		name: `${name}:queue`,
+		storeName: "offline-events",
+		...options.queueOptions
+	});
+	const reliableRemote = retryTransport(remote, {
+		maxRetries: 2,
+		retryBaseDelayMs: 250,
+		retryMaxDelayMs: 5e3,
+		...options.retry,
+		name: `${name}:remote`
+	});
+	let lastContext;
+	let replayPromise;
+	const replayContext = {
+		loggerName: name,
+		now: () => Date.now(),
+		toEvent: recordToEvent,
+		reportInternalError() {}
+	};
+	const contextForReplay = () => lastContext ?? replayContext;
+	const reportInternalError = (error, operation) => {
+		contextForReplay().reportInternalError(error, {
+			phase: "transport",
+			transport: name,
+			operation
+		});
+	};
+	const queueEvent = async (event, context, error) => {
+		await queue.log(event, context);
+		await queue.flush?.();
+		incrementLoggerMetaCounter("transport.offline.queued");
+		options.onQueued?.(event, error);
+	};
+	const sendRemoteBatch = async (events, context) => {
+		await reliableRemote.logBatch?.([...events], context);
+	};
+	const sendOrQueue = async (event, context) => {
+		lastContext = context;
+		if (!isBrowserOnline(options)) {
+			await queueEvent(event, context);
+			return;
+		}
+		try {
+			await reliableRemote.log?.(event, context);
+		} catch (error) {
+			incrementLoggerMetaCounter("transport.offline.remote.failed");
+			await queueEvent(event, context, error);
+		}
+	};
+	const replay = async () => {
+		if (replayPromise) return replayPromise;
+		replayPromise = (async () => {
+			if (!isBrowserOnline(options)) return;
+			const context = contextForReplay();
+			await queue.flush?.();
+			for (;;) {
+				const batch = await collectBatch(queue, replayBatchSize);
+				if (batch.length === 0) return;
+				try {
+					await sendRemoteBatch(batch, context);
+					await queue.remove(batch.map((event) => event.id));
+					incrementLoggerMetaCounter("transport.offline.replayed", batch.length);
+					options.onReplayed?.(batch);
+				} catch (error) {
+					incrementLoggerMetaCounter("transport.offline.replay.failed");
+					reportInternalError(error, "replay");
+					throw error;
+				}
+			}
+		})().finally(() => {
+			replayPromise = void 0;
+		});
+		return replayPromise;
+	};
+	const onOnline = () => {
+		replay().catch((error) => reportInternalError(error, "online-replay"));
+	};
+	if (options.replayOnOnline ?? true) globalThis.addEventListener?.("online", onOnline);
+	return {
+		name,
+		minLevel: options.minLevel ?? remote.minLevel,
+		queue,
+		write(record, context) {
+			return sendOrQueue(context.toEvent(record), context);
+		},
+		writeBatch(records, context) {
+			return Promise.all(records.map((record) => sendOrQueue(context.toEvent(record), context))).then(() => void 0);
+		},
+		log(event, context) {
+			if (options.minLevel !== void 0 && event.level < toLevelValue(options.minLevel)) return;
+			return sendOrQueue(event, context);
+		},
+		logBatch(events, context) {
+			return Promise.all(events.map((event) => options.minLevel !== void 0 && event.level < toLevelValue(options.minLevel) ? void 0 : sendOrQueue(event, context))).then(() => void 0);
+		},
+		replay,
+		async flush() {
+			await replay();
+			await reliableRemote.flush?.();
+			await queue.flush?.();
+		},
+		flushSync() {
+			reliableRemote.flushSync?.();
+		},
+		async close() {
+			globalThis.removeEventListener?.("online", onOnline);
+			await replay();
+			await reliableRemote.close?.();
+			await queue.close?.();
+		},
+		async queuedCount() {
+			await queue.flush?.();
+			return queue.count?.();
+		},
+		async clearQueue() {
+			await queue.clear?.();
+		}
+	};
+}
+//#endregion
+export { offlineFirstTransport };
+
+//# sourceMappingURL=offline-first-transport.js.map