@maple-dev/browser 0.9.0 → 0.10.1

package/dist/deferred-BDp5NC7U.mjs

@@ -0,0 +1,723 @@
+import { E as selectorOf, F as scrubUrl, l as onSessionEvent, w as sdkHint, x as ingestHeaders } from "./sink-BOR9_z4b.mjs";
+import { _ as consentRevokedAt, a as detachLogSink, c as resourceAttributes, d as attachSpanStash, f as claimPageSignal, g as consentAllowedSince, h as severityOf, i as attachLogSink, l as SDK_NAME, m as Severity, n as navigationSpanAt, o as emitLog, p as onErrorRecorded, r as onDocumentPageload, s as liveMapleTracer, u as SDK_VERSION, v as hasConsent, y as onConsentChange } from "./src-D4e1o0x4.mjs";
+import { t as installConsoleCapture } from "./console-BrjBnOiX.mjs";
+import { ROOT_CONTEXT, TraceFlags, context, trace } from "@opentelemetry/api";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { onCLS, onFCP, onINP, onLCP, onTTFB } from "web-vitals";
+import { JsonLogsSerializer, JsonTraceSerializer } from "@opentelemetry/otlp-transformer";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
+//#region ../sdk-core/src/browser/breadcrumbs.ts
+const MAX_CRUMBS = 50;
+let crumbs = [];
+let emit$1;
+function push(crumb) {
+	const last = crumbs.at(-1);
+	if (crumb.type === "input" && crumb.target !== void 0 && last?.type === "input" && last.target === crumb.target) {
+		crumbs[crumbs.length - 1] = crumb;
+		return;
+	}
+	crumbs.push(crumb);
+	if (crumbs.length > MAX_CRUMBS) crumbs.shift();
+}
+function emitConsole(sink, level, message, timestamp, link) {
+	const severity = severityOf(level);
+	sink({
+		severityNumber: severity.number,
+		severityText: severity.text,
+		body: message,
+		timestamp,
+		link,
+		attributes: {
+			"maple.log.source": "console",
+			...link ? { "maple.breadcrumb.type": "console" } : void 0
+		}
+	});
+}
+/** Start collecting into `sink`. Returns a stop. */
+function startBreadcrumbs(sink, options) {
+	if (!options.breadcrumbs && options.captureConsole.length === 0) return () => {};
+	emit$1 = sink;
+	const live = () => emit$1 === sink;
+	const forwarded = new Set(options.captureConsole);
+	const stopEvents = options.breadcrumbs ? onSessionEvent((ev) => {
+		if (!live() || ev.type !== "click" && ev.type !== "input" && ev.type !== "navigation") return;
+		push({
+			timestamp: ev.timestamp ?? Date.now(),
+			type: ev.type,
+			target: ev.targetSelector,
+			message: ev.targetText,
+			url: ev.url ?? location.href
+		});
+	}) : () => {};
+	const stopConsole = installConsoleCapture((ev) => {
+		if (!live() || ev.message === void 0) return;
+		const timestamp = Date.now();
+		if (ev.level !== void 0 && forwarded.has(ev.level)) {
+			emitConsole(sink, ev.level, ev.message, timestamp);
+			return;
+		}
+		if (options.breadcrumbs) push({
+			timestamp,
+			type: "console",
+			level: ev.level,
+			message: ev.message
+		});
+	});
+	return () => {
+		if (live()) {
+			emit$1 = void 0;
+			crumbs = [];
+		}
+		stopEvents();
+		stopConsole();
+	};
+}
+/** Export the trail so far, linked to the error's span, and start a new one. */
+function flushBreadcrumbs(link) {
+	const sink = emit$1;
+	if (!sink || crumbs.length === 0) return;
+	const trail = crumbs;
+	crumbs = [];
+	for (const crumb of trail) {
+		if (crumb.type === "console") {
+			emitConsole(sink, crumb.level, crumb.message ?? "", crumb.timestamp, link);
+			continue;
+		}
+		sink({
+			eventName: "maple.browser.breadcrumb",
+			severityNumber: Severity.INFO,
+			severityText: "INFO",
+			body: [
+				crumb.type,
+				crumb.target,
+				crumb.message
+			].filter(Boolean).join(" "),
+			timestamp: crumb.timestamp,
+			link,
+			attributes: {
+				"maple.breadcrumb.type": crumb.type,
+				...crumb.target ? { "maple.breadcrumb.target": crumb.target } : void 0,
+				...crumb.url ? { "url.full": scrubUrl(crumb.url) } : void 0
+			}
+		});
+	}
+}
+//#endregion
+//#region ../sdk-core/src/browser/document-timing.ts
+const FETCH_PHASES = [
+	[
+		"dns",
+		(e) => e.domainLookupStart,
+		(e) => e.domainLookupEnd
+	],
+	[
+		"connect",
+		(e) => e.connectStart,
+		(e) => e.connectEnd
+	],
+	[
+		"request",
+		(e) => e.requestStart,
+		(e) => e.responseStart
+	],
+	[
+		"response",
+		(e) => e.responseStart,
+		(e) => e.responseEnd
+	]
+];
+const PAGE_PHASES = [[
+	"domProcessing",
+	(e) => e.responseEnd,
+	(e) => e.domComplete
+], [
+	"loadEvent",
+	(e) => e.loadEventStart,
+	(e) => e.loadEventEnd
+]];
+/** Epoch ms for a Navigation Timing offset. */
+const at = (offset) => performance.timeOrigin + offset;
+function spanPhases(child, parent, entry, phases) {
+	for (const [name, start, end] of phases) {
+		const from = start(entry);
+		const to = end(entry);
+		if (from <= 0 || to <= from) continue;
+		child(parent, name, at(from), at(to));
+	}
+}
+function record(child, pageload) {
+	const [entry] = performance.getEntriesByType("navigation");
+	if (!(entry instanceof PerformanceNavigationTiming) || entry.responseEnd <= 0) return;
+	spanPhases(child, child(pageload, "documentFetch", at(entry.fetchStart), at(entry.responseEnd), {
+		"url.full": scrubUrl(entry.name),
+		...entry.responseStatus > 0 ? { "http.response.status_code": entry.responseStatus } : void 0,
+		...entry.encodedBodySize > 0 ? { "http.response.body.size": entry.encodedBodySize } : void 0
+	}), entry, FETCH_PHASES);
+	spanPhases(child, pageload, entry, PAGE_PHASES);
+}
+/** Span the document's load under `pageload`, now or once the `load` event has finished. */
+function recordDocumentTiming(child, pageload) {
+	if (typeof performance === "undefined" || typeof performance.getEntriesByType !== "function") return;
+	const run = () => void setTimeout(() => {
+		try {
+			record(child, pageload);
+		} catch {}
+	}, 0);
+	if (document.readyState === "complete") run();
+	else window.addEventListener("load", run, { once: true });
+}
+//#endregion
+//#region ../sdk-core/src/browser/offline.ts
+const DB_NAME = "maple-offline";
+const STORE = "batches";
+const MAX_AGE_MS = 864e5;
+const MAX_BATCHES = 100;
+const isStoredBatch = (value) => typeof value === "object" && value !== null && "id" in value && typeof value.id === "number" && "signal" in value && (value.signal === "traces" || value.signal === "logs") && "body" in value && value.body instanceof Uint8Array && "createdAt" in value && typeof value.createdAt === "number";
+const settle = (request) => new Promise((resolve, reject) => {
+	request.onsuccess = () => resolve(request.result);
+	request.onerror = () => reject(request.error);
+});
+function openDb() {
+	if (typeof indexedDB === "undefined") return Promise.resolve(void 0);
+	try {
+		const request = indexedDB.open(DB_NAME, 1);
+		request.onupgradeneeded = () => {
+			request.result.createObjectStore(STORE, {
+				keyPath: "id",
+				autoIncrement: true
+			});
+		};
+		return settle(request).catch(() => void 0);
+	} catch {
+		return Promise.resolve(void 0);
+	}
+}
+/** FNV-1a, hex: identifies the credentials without storing them. */
+function fingerprint(value) {
+	let hash = 2166136261;
+	for (let i = 0; i < value.length; i++) {
+		hash ^= value.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16);
+}
+function startOfflineQueue(config) {
+	const db = openDb();
+	const headers = {
+		...config.headers,
+		"Content-Type": "application/json"
+	};
+	const auth = Object.entries(config.headers).find(([name]) => name.toLowerCase() === "authorization");
+	const target = `${config.endpoint}|${fingerprint(auth?.[1] ?? "")}`;
+	const store = async (mode) => (await db)?.transaction(STORE, mode).objectStore(STORE);
+	const add = async (signal, body, createdAt) => {
+		if (!hasConsent() || createdAt <= consentRevokedAt()) return;
+		const batches = await store("readwrite");
+		if (!batches) return;
+		await settle(batches.add({
+			signal,
+			body,
+			createdAt,
+			target
+		}));
+		const keys = await settle(batches.getAllKeys());
+		for (const key of keys.slice(0, Math.max(0, keys.length - MAX_BATCHES))) await settle(batches.delete(key));
+	};
+	/** Send what is stored, oldest first. Stops at the first failure, keeping the rest. */
+	const drain = async () => {
+		const read = await store("readonly");
+		const stored = read ? (await settle(read.getAll())).filter(isStoredBatch) : [];
+		for (const batch of stored) {
+			if (!hasConsent()) return;
+			const expired = Date.now() - batch.createdAt > MAX_AGE_MS;
+			if (!expired && batch.target !== void 0 && batch.target !== target) continue;
+			if (!expired && batch.createdAt > consentRevokedAt()) {
+				const response = await fetch(`${config.endpoint}/v1/${batch.signal}`, {
+					method: "POST",
+					headers,
+					body: new Uint8Array(batch.body)
+				}).catch(() => void 0);
+				if (!response || response.status >= 500 || response.status === 429) return;
+			}
+			const write = await store("readwrite");
+			if (write) await settle(write.delete(batch.id));
+		}
+	};
+	/** The resend in flight: a second call joins it rather than returning before it is done. */
+	let inflight;
+	const run = async () => {
+		try {
+			if (typeof navigator !== "undefined" && navigator.locks) await navigator.locks.request(`${DB_NAME}-resend`, () => drain());
+			else await drain();
+		} catch {}
+	};
+	const resend = () => {
+		if (!hasConsent() || typeof navigator !== "undefined" && navigator.onLine === false) return Promise.resolve();
+		inflight ??= run().finally(() => {
+			inflight = void 0;
+		});
+		return inflight;
+	};
+	const clear = async () => {
+		const batches = await store("readwrite");
+		if (batches) await settle(batches.clear());
+	};
+	/** Writes in order: a revoke's clear runs after the writes before it, and `stop` closes the database after all of them. */
+	let writes = Promise.resolve();
+	const queue = (write) => {
+		writes = writes.then(write).catch(() => {});
+	};
+	const stash = (signal, body) => {
+		const createdAt = Date.now();
+		if (body && hasConsent()) queue(() => add(signal, body, createdAt));
+	};
+	const onOnline = () => void resend();
+	window.addEventListener("online", onOnline);
+	const stopConsent = onConsentChange((allowed) => {
+		if (!allowed) queue(clear);
+	});
+	resend();
+	return {
+		stash: (signal, body) => {
+			if (body.byteLength > 0) stash(signal, body);
+		},
+		resend,
+		stop: () => {
+			window.removeEventListener("online", onOnline);
+			stopConsent();
+			writes.then(() => db).then((opened) => opened?.close());
+		}
+	};
+}
+//#endregion
+//#region ../sdk-core/src/browser/perf.ts
+/** A frame this long is visible jank; the Long Animation Frames API reports from 50ms. */
+const LONG_FRAME_MS = 100;
+/** INP's "needs improvement" line. */
+const SLOW_INTERACTION_MS = 200;
+const epoch = (offset) => performance.timeOrigin + offset;
+let sink;
+function span(name, start, duration, attributes) {
+	sink?.(name, epoch(start), epoch(start + duration), attributes);
+}
+function scriptsOf(entry) {
+	const scripts = "scripts" in entry ? entry.scripts : void 0;
+	if (!Array.isArray(scripts)) return [];
+	return scripts.flatMap((script) => {
+		if (typeof script !== "object" || script === null || !("duration" in script)) return [];
+		if (typeof script.duration !== "number") return [];
+		const invoker = "invoker" in script ? script.invoker : void 0;
+		const sourceURL = "sourceURL" in script ? script.sourceURL : void 0;
+		const sourceFunctionName = "sourceFunctionName" in script ? script.sourceFunctionName : void 0;
+		return [{
+			duration: script.duration,
+			invoker: typeof invoker === "string" && invoker !== "" ? invoker : void 0,
+			sourceURL: typeof sourceURL === "string" && sourceURL !== "" ? sourceURL : void 0,
+			sourceFunctionName: typeof sourceFunctionName === "string" && sourceFunctionName !== "" ? sourceFunctionName : void 0
+		}];
+	});
+}
+/** Exported for tests: headless Chromium lists LoAF as supported but never renders a frame to report. */
+function onLongFrame(entry) {
+	if (entry.duration < LONG_FRAME_MS) return;
+	const blocking = "blockingDuration" in entry && typeof entry.blockingDuration === "number" ? entry.blockingDuration : void 0;
+	const longest = scriptsOf(entry).sort((a, b) => b.duration - a.duration)[0];
+	span(entry.entryType === "longtask" ? "longtask" : "longAnimationFrame", entry.startTime, entry.duration, {
+		...blocking !== void 0 ? { "maple.browser.frame.blocking_duration_ms": Math.round(blocking) } : void 0,
+		...longest?.sourceURL ? { "code.file.path": scrubUrl(longest.sourceURL) } : void 0,
+		...longest?.sourceFunctionName ? { "code.function.name": longest.sourceFunctionName } : void 0,
+		...longest?.invoker ? { "maple.browser.script.invoker": longest.invoker } : void 0,
+		...longest ? { "maple.browser.script.duration_ms": Math.round(longest.duration) } : void 0
+	});
+}
+function observe(type, onEntries, options = {}) {
+	if (typeof PerformanceObserver === "undefined" || !PerformanceObserver.supportedEntryTypes?.includes(type)) return () => {};
+	const observer = new PerformanceObserver((list) => onEntries(list.getEntries()));
+	observer.observe({
+		type,
+		buffered: true,
+		...options
+	});
+	return () => observer.disconnect();
+}
+const processingOf = (entry) => entry.processingEnd - entry.processingStart;
+/**
+* The interaction an event belongs to. `0` means "not an interaction"; an engine
+* without `interactionId` gets a per-event key, so its slow events are still spanned.
+*/
+function interactionKey(entry) {
+	const id = entry.interactionId;
+	if (id === 0) return void 0;
+	return id === void 0 ? `${entry.name}:${Math.round(entry.startTime)}` : `id:${id}`;
+}
+function spanInteraction(entry) {
+	span(`interaction ${entry.name}`, entry.startTime, entry.duration, {
+		"maple.browser.interaction.input_delay_ms": Math.round(entry.processingStart - entry.startTime),
+		"maple.browser.interaction.processing_ms": Math.round(processingOf(entry)),
+		"maple.browser.interaction.presentation_ms": Math.round(entry.startTime + entry.duration - entry.processingEnd),
+		...entry.target instanceof Element ? { "maple.browser.interaction.target": selectorOf(entry.target) } : void 0
+	});
+}
+function startPerf(startSpan, options) {
+	const stops = [];
+	if (options.longFrames || options.slowInteractions) sink = startSpan;
+	if (options.longFrames) {
+		const hasLoaf = typeof PerformanceObserver !== "undefined" && PerformanceObserver.supportedEntryTypes?.includes("long-animation-frame") === true;
+		stops.push(observe(hasLoaf ? "long-animation-frame" : "longtask", (entries) => {
+			for (const entry of entries) onLongFrame(entry);
+		}));
+	}
+	if (options.slowInteractions) {
+		const seen = /* @__PURE__ */ new Set();
+		stops.push(observe("event", (entries) => {
+			const byInteraction = /* @__PURE__ */ new Map();
+			for (const entry of entries) {
+				if (!(entry instanceof PerformanceEventTiming)) continue;
+				const key = interactionKey(entry);
+				if (key === void 0 || entry.duration < SLOW_INTERACTION_MS || seen.has(key)) continue;
+				const best = byInteraction.get(key);
+				if (!best || processingOf(entry) > processingOf(best)) byInteraction.set(key, entry);
+			}
+			for (const [id, entry] of byInteraction) {
+				seen.add(id);
+				spanInteraction(entry);
+			}
+			if (seen.size > 500) seen.clear();
+		}, { durationThreshold: SLOW_INTERACTION_MS }));
+	}
+	return () => {
+		for (const stop of stops) stop();
+		if (sink === startSpan) sink = void 0;
+	};
+}
+//#endregion
+//#region ../sdk-core/src/browser/reports.ts
+/** Repeats of one report (a blocked image in a loop) are sent once per page, up to this many kinds. */
+const MAX_REPORTS = 50;
+/** Report bodies expose their fields as getters that only `toJSON` serializes. */
+function parseReportBody(body) {
+	const raw = body === null || body === void 0 ? void 0 : JSON.parse(JSON.stringify(body));
+	const fields = new Map(typeof raw === "object" && raw !== null ? Object.entries(raw) : []);
+	const str = (key) => {
+		const value = fields.get(key);
+		return typeof value === "string" && value !== "" ? value : void 0;
+	};
+	const int = (key) => {
+		const value = fields.get(key);
+		return typeof value === "number" && value > 0 ? value : void 0;
+	};
+	return {
+		effectiveDirective: str("effectiveDirective") ?? str("violatedDirective"),
+		blockedURL: str("blockedURL") ?? str("blockedURI"),
+		disposition: str("disposition"),
+		sourceFile: str("sourceFile"),
+		lineNumber: int("lineNumber"),
+		columnNumber: int("columnNumber"),
+		id: str("id"),
+		message: str("message")
+	};
+}
+function sourceAttributes(fields) {
+	return {
+		...fields.sourceFile ? { "code.file.path": scrubUrl(fields.sourceFile) } : void 0,
+		...fields.lineNumber ? { "code.line.number": fields.lineNumber } : void 0,
+		...fields.columnNumber ? { "code.column.number": fields.columnNumber } : void 0
+	};
+}
+function startReports(emitLog, options) {
+	if (!options.csp && !options.browserReports) return () => {};
+	const seen = /* @__PURE__ */ new Set();
+	const once = (key) => {
+		if (seen.has(key) || seen.size >= MAX_REPORTS) return false;
+		seen.add(key);
+		return true;
+	};
+	const csp = (fields) => {
+		const directive = fields.effectiveDirective ?? "unknown";
+		const blocked = scrubUrl(fields.blockedURL ?? "inline");
+		if (!once(`csp ${directive} ${blocked}`)) return;
+		emitLog({
+			eventName: "maple.browser.csp_violation",
+			severityNumber: Severity.WARN,
+			severityText: "WARN",
+			body: `${directive} blocked ${blocked}`,
+			attributes: {
+				"maple.csp.effective_directive": directive,
+				"maple.csp.blocked_uri": blocked,
+				...fields.disposition ? { "maple.csp.disposition": fields.disposition } : void 0,
+				"url.full": scrubUrl(location.href),
+				...sourceAttributes(fields)
+			}
+		});
+	};
+	const browserReport = (type, fields) => {
+		const id = fields.id ?? "unknown";
+		if (!once(`${type} ${id}`)) return;
+		emitLog({
+			eventName: "maple.browser.report",
+			severityNumber: Severity.WARN,
+			severityText: "WARN",
+			body: fields.message ?? `${type}: ${id}`,
+			attributes: {
+				"maple.report.type": type,
+				"maple.report.id": id,
+				...sourceAttributes(fields)
+			}
+		});
+	};
+	const stops = [];
+	if (typeof ReportingObserver === "function") {
+		const types = [...options.csp ? ["csp-violation"] : [], ...options.browserReports ? ["deprecation", "intervention"] : []];
+		const observer = new ReportingObserver((reports) => {
+			for (const report of reports) {
+				const fields = parseReportBody(report.body);
+				if (report.type === "csp-violation") csp(fields);
+				else browserReport(report.type ?? "report", fields);
+			}
+		}, {
+			types,
+			buffered: true
+		});
+		observer.observe();
+		stops.push(() => observer.disconnect());
+	}
+	if (options.csp) {
+		const onViolation = (event) => csp({
+			effectiveDirective: event.effectiveDirective,
+			blockedURL: event.blockedURI || void 0,
+			disposition: event.disposition,
+			sourceFile: event.sourceFile,
+			lineNumber: event.lineNumber,
+			columnNumber: event.columnNumber
+		});
+		document.addEventListener("securitypolicyviolation", onViolation);
+		stops.push(() => document.removeEventListener("securitypolicyviolation", onViolation));
+	}
+	return () => {
+		for (const stop of stops) stop();
+	};
+}
+//#endregion
+//#region ../sdk-core/src/browser/web-vitals.ts
+let registered = false;
+let emit;
+let pageload;
+function report(metric) {
+	emit?.({
+		eventName: "browser.web_vital",
+		severityNumber: Severity.INFO,
+		severityText: "INFO",
+		attributes: {
+			"browser.web_vital.name": metric.name.toLowerCase(),
+			"browser.web_vital.value": metric.value,
+			"browser.web_vital.delta": metric.delta,
+			"browser.web_vital.id": metric.id,
+			"browser.web_vital.rating": metric.rating,
+			"browser.web_vital.navigation_type": metric.navigationType,
+			"url.path": scrubUrl(location.pathname)
+		},
+		link: pageload?.()
+	});
+}
+/** Report vitals through `sink`, linked to the document's pageload span when there is one. Returns a stop. */
+function startWebVitals(sink, getPageload) {
+	emit = sink;
+	pageload = getPageload;
+	if (!registered) {
+		registered = true;
+		for (const on of [
+			onCLS,
+			onFCP,
+			onINP,
+			onLCP,
+			onTTFB
+		]) on(report);
+	}
+	return () => {
+		if (emit !== sink) return;
+		emit = void 0;
+		pageload = void 0;
+	};
+}
+//#endregion
+//#region src/deferred/logs.ts
+/** Same rule as spans: drop records made while consent was absent, even if it is granted by flush time. */
+var ConsentLogExporter = class {
+	inner;
+	constructor(inner) {
+		this.inner = inner;
+	}
+	export(logs, callback) {
+		const since = consentAllowedSince();
+		const eligible = hasConsent() && Number.isFinite(since) ? logs.filter((log) => log.hrTime[0] * 1e3 + log.hrTime[1] / 1e6 >= since) : [];
+		if (eligible.length === 0) {
+			callback({ code: 0 });
+			return;
+		}
+		this.inner.export(eligible, callback);
+	}
+	forceFlush() {
+		return this.inner.forceFlush?.() ?? Promise.resolve();
+	}
+	shutdown() {
+		return this.inner.shutdown();
+	}
+};
+/** Hands batches the exporter gave up on to the offline queue. */
+var OfflineLogExporter = class {
+	inner;
+	stash;
+	constructor(inner, stash) {
+		this.inner = inner;
+		this.stash = stash;
+	}
+	export(logs, callback) {
+		this.inner.export(logs, (result) => {
+			if (result.code !== 0) this.stash(logs);
+			callback(result);
+		});
+	}
+	forceFlush() {
+		return this.inner.forceFlush?.() ?? Promise.resolve();
+	}
+	shutdown() {
+		return this.inner.shutdown();
+	}
+};
+/** Start the OTel logs pipeline and drain the eager queue into it. Returns a shutdown. */
+function startLogs(config, stashOffline) {
+	const otlp = new OTLPLogExporter({
+		url: `${config.endpoint}/v1/logs`,
+		headers: ingestHeaders({
+			ingestKey: config.ingestKey,
+			sdk: sdkHint(SDK_NAME, SDK_VERSION)
+		})
+	});
+	const exporter = new ConsentLogExporter(stashOffline ? new OfflineLogExporter(otlp, stashOffline) : otlp);
+	const provider = new LoggerProvider({
+		resource: resourceFromAttributes(resourceAttributes(config)),
+		processors: [new BatchLogRecordProcessor({
+			exporter,
+			scheduledDelayMillis: 2e3
+		})]
+	});
+	const logger = provider.getLogger(SDK_NAME, SDK_VERSION);
+	attachLogSink((record) => logger.emit({
+		eventName: record.eventName,
+		severityNumber: record.severityNumber,
+		severityText: record.severityText,
+		body: record.body,
+		attributes: record.attributes,
+		timestamp: record.timestamp,
+		context: record.link ? trace.setSpanContext(ROOT_CONTEXT, record.link) : ROOT_CONTEXT
+	}));
+	return async () => {
+		detachLogSink();
+		await provider.shutdown();
+	};
+}
+//#endregion
+//#region src/deferred/index.ts
+/** Jank spans nest under the navigation open when they began, on Maple's own provider. */
+const perfSpan = (name, startMs, endMs, attributes) => {
+	const tracer = hasConsent() ? liveMapleTracer(SDK_NAME, SDK_VERSION) : void 0;
+	if (!tracer) return;
+	const navigation = navigationSpanAt(startMs);
+	const parent = navigation ? trace.setSpan(context.active(), navigation) : context.active();
+	tracer.startSpan(name, {
+		startTime: startMs,
+		attributes
+	}, parent).end(endMs);
+};
+/** Page signals this copy leased; another Maple SDK copy may already collect the rest. */
+function leaseSignals(wanted) {
+	const releases = /* @__PURE__ */ new Map();
+	for (const signal of PAGE_SIGNALS) {
+		const release = wanted[signal] ? claimPageSignal(signal) : void 0;
+		if (release) releases.set(signal, release);
+	}
+	return {
+		has: (signal) => releases.has(signal),
+		release: () => {
+			for (const release of releases.values()) release();
+		}
+	};
+}
+const PAGE_SIGNALS = [
+	"breadcrumbs",
+	"browserReports",
+	"console",
+	"csp",
+	"longFrames",
+	"slowInteractions",
+	"webVitals"
+];
+function startDeferred(config) {
+	let pageload;
+	onDocumentPageload((tracer, span) => {
+		pageload = span.spanContext();
+		if ((span.spanContext().traceFlags & TraceFlags.SAMPLED) === 0) return;
+		const child = (parent, name, startMs, endMs, attributes) => {
+			const next = tracer.startSpan(name, {
+				startTime: startMs,
+				attributes
+			}, trace.setSpan(context.active(), parent));
+			next.end(endMs);
+			return next;
+		};
+		recordDocumentTiming(child, span);
+	});
+	const leased = leaseSignals({
+		webVitals: config.webVitals,
+		breadcrumbs: config.breadcrumbs,
+		console: config.captureConsole.length > 0,
+		csp: config.reportCsp,
+		browserReports: config.reportBrowser,
+		longFrames: config.longFrames,
+		slowInteractions: config.slowInteractions
+	});
+	const stopVitals = leased.has("webVitals") ? startWebVitals(emitLog, () => pageload) : () => {};
+	const stopBreadcrumbs = startBreadcrumbs(emitLog, {
+		breadcrumbs: leased.has("breadcrumbs"),
+		captureConsole: leased.has("console") ? config.captureConsole : []
+	});
+	const stopErrorListener = onErrorRecorded(flushBreadcrumbs);
+	const stopReports = startReports(emitLog, {
+		csp: leased.has("csp"),
+		browserReports: leased.has("browserReports")
+	});
+	const stopPerf = startPerf(perfSpan, {
+		longFrames: leased.has("longFrames"),
+		slowInteractions: leased.has("slowInteractions")
+	});
+	const offline = config.offlineQueue ? startOfflineQueue({
+		endpoint: config.endpoint,
+		headers: ingestHeaders({
+			ingestKey: config.ingestKey,
+			sdk: sdkHint(SDK_NAME, SDK_VERSION)
+		})
+	}) : void 0;
+	attachSpanStash(offline && ((spans) => {
+		const body = spans.length > 0 ? JsonTraceSerializer.serializeRequest(spans) : void 0;
+		if (body) offline.stash("traces", body);
+	}));
+	const stopLogs = startLogs(config, offline && ((logs) => {
+		const body = logs.length > 0 ? JsonLogsSerializer.serializeRequest(logs) : void 0;
+		if (body) offline.stash("logs", body);
+	}));
+	return async () => {
+		stopVitals();
+		onDocumentPageload(void 0);
+		stopErrorListener();
+		stopBreadcrumbs();
+		stopReports();
+		stopPerf();
+		leased.release();
+		await stopLogs();
+		attachSpanStash(void 0);
+		offline?.stop();
+	};
+}
+//#endregion
+export { startDeferred };