@safaricom-mxl/effect-sdk 0.0.22 → 0.0.24

package/dist/flushable-CXe-q-GF.js

@@ -0,0 +1,1068 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.js";
+import { Cause, Context, Effect, Exit, Layer, Option, Predicate, Tracer } from "effect";
+import * as ErrorReporter from "effect/ErrorReporter";
+import * as OtlpResource from "effect/observability/OtlpResource";
+import * as WebSdk from "@effect/opentelemetry/WebSdk";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+// src/shared/url-privacy.ts
+const REDACTED = "REDACTED";
+const SENSITIVE_PARAM = /^(access_token|id_token|refresh_token|token|token_hash|auth|authorization|code|oobcode|state|password|passwd|pwd|pass|secret|client_secret|api_key|apikey|key|signature|sig|otp|jwt|session|sessionid|session_id|ticket|__clerk_ticket|reset_token|magic|nonce|x-amz-signature|x-amz-credential|x-amz-security-token|x-goog-signature|x-goog-credential)$/i;
+/** Sanitizers live on `globalThis`, like consent: one page, one policy, however many SDK copies. */
+const SANITIZERS_KEY = "__MXL_URL_SANITIZERS__";
+function sanitizers() {
+	const owner = globalThis;
+	const existing = owner[SANITIZERS_KEY];
+	if (existing instanceof Set) return existing;
+	const fresh = /* @__PURE__ */ new Set();
+	owner[SANITIZERS_KEY] = fresh;
+	return fresh;
+}
+/**
+* Register a host-app sanitizer. Additive, like the consent gates: an SDK
+* initialized without one must not remove the one another SDK was given.
+*/
+function addUrlSanitizer(sanitizer) {
+	sanitizers().add(sanitizer);
+}
+/** Test seam. */
+function resetUrlSanitizersForTests() {
+	sanitizers().clear();
+}
+function redactParams(params) {
+	let changed = false;
+	for (const name of new Set(params.keys())) {
+		if (!SENSITIVE_PARAM.test(name)) continue;
+		params.set(name, REDACTED);
+		changed = true;
+	}
+	return changed;
+}
+/**
+* Implicit-flow tokens ride the fragment as `#access_token=…&…`; a hash-routed
+* app carries them in the route's own query, `#/reset?token=…`. The route path
+* is kept either way.
+*/
+function redactFragment(fragment) {
+	if (fragment.startsWith("/") || fragment.startsWith("!/")) {
+		const queryAt = fragment.indexOf("?");
+		if (queryAt === -1) return fragment;
+		const params = new URLSearchParams(fragment.slice(queryAt + 1));
+		return redactParams(params) ? `${fragment.slice(0, queryAt)}?${params.toString()}` : fragment;
+	}
+	if (!fragment.includes("=")) return fragment;
+	const params = new URLSearchParams(fragment);
+	return redactParams(params) ? params.toString() : fragment;
+}
+const ABSOLUTE = /^[a-z][a-z0-9+.-]*:/i;
+const RELATIVE_BASE = "http://relative.invalid";
+/** Redact credential-shaped query and fragment parameters, keeping the URL's form. */
+function redactUrl(url) {
+	if (!url || !url.includes("?") && !url.includes("#")) return url;
+	const absolute = ABSOLUTE.test(url);
+	let parsed;
+	try {
+		parsed = new URL(url, absolute ? void 0 : RELATIVE_BASE);
+	} catch {
+		return url;
+	}
+	let changed = redactParams(parsed.searchParams);
+	const fragment = parsed.hash.slice(1);
+	const redactedFragment = redactFragment(fragment);
+	if (redactedFragment !== fragment) {
+		parsed.hash = redactedFragment;
+		changed = true;
+	}
+	if (!changed) return url;
+	if (absolute) return parsed.href;
+	if (url.startsWith("//")) return parsed.href.slice(parsed.protocol.length);
+	const tail = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+	return url.startsWith("/") ? tail : tail.replace(/^\//, "");
+}
+/**
+* The URL as it may leave the page: default redaction, then every registered
+* host sanitizer. A sanitizer that throws or returns a non-string yields the
+* default-redacted URL rather than the raw one.
+*/
+function scrubUrl(url) {
+	let out = redactUrl(url);
+	for (const sanitizer of sanitizers()) try {
+		const next = sanitizer(out);
+		if (typeof next === "string") out = next;
+	} catch {}
+	return out;
+}
+// src/shared/identity.ts
+const normalizeIdentity = (input) => {
+	if (input === null || input === void 0) return;
+	if (typeof input === "string") {
+		const id = input.trim();
+		return id.length > 0 ? { id } : void 0;
+	}
+	const id = input.id.trim();
+	if (id.length === 0) return;
+	return {
+		email: input.email,
+		groupId: input.groupId,
+		groupName: input.groupName,
+		id,
+		traits: input.traits
+	};
+};
+const RESERVED_EVENT_NAMES = ["session_start", "session_end"];
+const isReservedEventName = (name) => RESERVED_EVENT_NAMES.some((reserved) => reserved === name);
+const coerceTrackProps = (props) => {
+	if (props === void 0) return {};
+	const attributes = {};
+	for (const [key, value] of Object.entries(props)) {
+		if (value === void 0) continue;
+		attributes[key] = typeof value === "string" ? value : String(value);
+	}
+	return attributes;
+};
+const toEventTimestamp = (value) => (value instanceof Date ? value : new Date(value ?? Date.now())).toISOString();
+const encodeProductEventLine = (input) => {
+	const trimmed = typeof input.name === "string" ? input.name.trim() : "";
+	if (trimmed.length === 0 || isReservedEventName(trimmed)) return;
+	const options = input.options ?? {};
+	return {
+		attributes: coerceTrackProps(options.attributes),
+		group_id: options.groupId ?? "",
+		name: trimmed.slice(0, 80),
+		page_path: options.pagePath ?? "",
+		service_name: input.serviceName,
+		session_id: options.sessionId ?? "",
+		source: input.source,
+		timestamp: toEventTimestamp(options.timestamp),
+		traceparent: options.traceparent,
+		url: options.url ?? "",
+		user_id: options.userId ?? "",
+		visitor_id: options.visitorId ?? ""
+	};
+};
+const encodeNdjson = (lines) => `${lines.map((line) => JSON.stringify(line)).join("\n")}\n`;
+// src/version.ts
+const SDK_NAME = "mxl-effect-sdk";
+const SDK_VERSION = "0.0.24";
+// src/browser/analytics.ts
+const DEFAULT_INGEST_URL = "http://127.0.0.1:8000";
+const MAX_QUEUE = 100;
+let config;
+let identity;
+let consentGranted = true;
+let sessionId = "";
+let queue = [];
+let started = false;
+const randomId = () => {
+	if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+	return `mxl_${Math.random().toString(36).slice(2)}_${Date.now()}`;
+};
+const storageGet = (key) => {
+	try {
+		const value = globalThis.sessionStorage?.getItem(key);
+		return value && value.length > 0 ? value : void 0;
+	} catch {
+		return;
+	}
+};
+const storageSet = (key, value) => {
+	try {
+		globalThis.sessionStorage?.setItem(key, value);
+	} catch {}
+};
+const resolveSessionId = () => {
+	if (sessionId.length > 0) return sessionId;
+	sessionId = storageGet("mxl.session.id") ?? randomId();
+	storageSet("mxl.session.id", sessionId);
+	return sessionId;
+};
+const ingestOrigin = () => (config?.ingestUrl ?? DEFAULT_INGEST_URL).replace(/\/$/, "");
+const headers = () => {
+	const next = {
+		"content-type": "application/json",
+		"mxl-client-id": config?.clientId ?? "",
+		"mxl-sdk-name": SDK_NAME,
+		"mxl-sdk-version": SDK_VERSION
+	};
+	if (config?.apiKey) next["mxl-api-key"] = config.apiKey;
+	return next;
+};
+const post = (path, body, contentType, keepalive = false) => {
+	if (!config?.clientId) return;
+	try {
+		fetch(`${ingestOrigin()}${path}`, {
+			body,
+			headers: {
+				...headers(),
+				"content-type": contentType
+			},
+			keepalive,
+			method: "POST"
+		});
+	} catch {}
+};
+const captureAllowed = () => Boolean(config?.clientId) && consentGranted && started;
+const getCurrentIdentity = () => identity;
+const getCurrentUserId = () => identity?.id;
+const getCurrentSessionId = () => resolveSessionId();
+const configureBrowserAnalytics = (next) => {
+	config = next;
+	consentGranted = next.privacy?.requireConsent !== true;
+	started = true;
+	resolveSessionId();
+	drainQueue();
+};
+const setConsent = (granted) => {
+	consentGranted = granted;
+	if (granted) drainQueue();
+};
+const identify$1 = (input) => {
+	identity = normalizeIdentity(input);
+	if (!captureAllowed() || identity === void 0) return;
+	post("/track", JSON.stringify({
+		payload: {
+			email: identity.email,
+			firstName: typeof identity.traits?.["firstName"] === "string" ? identity.traits["firstName"] : void 0,
+			lastName: typeof identity.traits?.["lastName"] === "string" ? identity.traits["lastName"] : void 0,
+			profileId: identity.id,
+			properties: {
+				...identity.traits,
+				groupId: identity.groupId,
+				groupName: identity.groupName
+			}
+		},
+		type: "identify"
+	}), "application/json");
+};
+const clearIdentity$1 = () => {
+	identity = void 0;
+};
+const postProductAndSession = (name, props, keepalive = false) => {
+	const line = encodeProductEventLine({
+		name,
+		options: {
+			attributes: props,
+			groupId: identity?.groupId,
+			sessionId: resolveSessionId(),
+			userId: identity?.id
+		},
+		serviceName: config?.serviceName ?? "unknown",
+		source: "browser"
+	});
+	if (line === void 0) return;
+	post("/events", encodeNdjson([line]), "application/x-ndjson", keepalive);
+	post("/sessionEvents", `${JSON.stringify({
+		attributes: line.attributes,
+		message: line.name,
+		session_id: line.session_id,
+		timestamp: line.timestamp,
+		type: "custom"
+	})}\n`, "application/x-ndjson", keepalive);
+};
+const drainQueue = (keepalive = false) => {
+	if (!captureAllowed()) return;
+	const pending = queue;
+	queue = [];
+	for (const event of pending) postProductAndSession(event.name, event.props, keepalive);
+};
+const track$1 = (name, props) => {
+	if (!started || !consentGranted || !config?.clientId) {
+		if (queue.length >= MAX_QUEUE) queue.shift();
+		queue.push({
+			name,
+			props
+		});
+		return;
+	}
+	postProductAndSession(name, props);
+};
+const postProfileDelta = (type, property, value) => {
+	if (!captureAllowed() || identity === void 0) return;
+	post("/track", JSON.stringify({
+		payload: {
+			profileId: identity.id,
+			property,
+			value: value ?? 1
+		},
+		type
+	}), "application/json");
+};
+const increment = (property, value) => {
+	postProfileDelta("increment", property, value);
+};
+const decrement = (property, value) => {
+	postProfileDelta("decrement", property, value);
+};
+const flushAnalytics = (keepalive = false) => {
+	drainQueue(keepalive);
+};
+// src/shared/try-sync.ts
+/** Run a throwing synchronous call, `None` if it threw. */
+const trySync = (thunk) => Effect.runSync(Effect.option(Effect.try(thunk)));
+/** Run a throwing synchronous call, `undefined` if it threw. */
+const trySyncOrUndefined = (thunk) => Option.getOrUndefined(trySync(thunk));
+// src/browser/browser-globals.ts
+/**
+* Narrow optional globals for the DOM-free SDK build, which also runs in
+* Workers and Node.
+*/
+const browserNavigator = () => globalThis.navigator;
+const browserDocument = () => globalThis.document;
+/** Resource attributes every browser preset sends: the SDK, the user agent, language and time zone. */
+const browserResourceAttributes = () => {
+	const nav = browserNavigator();
+	const timezone = typeof Intl === "undefined" ? void 0 : trySyncOrUndefined(() => Intl.DateTimeFormat().resolvedOptions().timeZone);
+	return {
+		"telemetry.sdk.name": "@safaricom-mxl/effect-sdk",
+		"telemetry.sdk.language": "webjs",
+		"telemetry.sdk.version": SDK_VERSION,
+		...nav?.userAgent ? { "user_agent.original": nav.userAgent } : void 0,
+		...nav?.language ? { "browser.language": nav.language } : void 0,
+		...timezone ? { "mxl.browser.timezone": timezone } : void 0
+	};
+};
+// src/server/otlp.ts
+function normalizeOtlpBaseUrl(url) {
+	const trimmed = url.replace(/\/$/, "");
+	if (trimmed.endsWith("/v1/traces") || trimmed.endsWith("/v1/logs")) return trimmed.replace(/\/v1\/(traces|logs|metrics)$/, "");
+	return trimmed;
+}
+// src/shared/flush-core.ts
+const COOLDOWN_MS = 6e4;
+const makeSerializedFlush = (flush) => {
+	let pending = Promise.resolve();
+	return (...args) => {
+		pending = pending.then(() => flush(...args), () => flush(...args));
+		return pending;
+	};
+};
+const guardFlush = (prefix, flush, state) => {
+	return async (...args) => {
+		if (state && Date.now() < state.disabledUntil) return;
+		try {
+			await flush(...args);
+		} catch (error) {
+			if (state) state.disabledUntil = Date.now() + COOLDOWN_MS;
+			console.error(`${prefix} flush failed; cooling down 60s`, error);
+		}
+	};
+};
+const fetchTransport = async (input) => {
+	const body = typeof input.body === "string" ? input.body : new Uint8Array(input.body);
+	const response = await fetch(input.url, {
+		body,
+		headers: input.headers,
+		keepalive: input.keepalive,
+		method: "POST"
+	});
+	if (!response.ok) throw new Error(`POST ${input.url} → ${response.status}`);
+};
+// src/shared/span-options.ts
+const prefixMatcher = (prefixes) => {
+	const list = prefixes === void 0 ? [] : [...prefixes];
+	return list.length > 0 ? (name) => list.some((prefix) => name.startsWith(prefix)) : void 0;
+};
+const failureIdentifier = (error) => {
+	if (Predicate.hasProperty(error, "_tag") && typeof error._tag === "string") return error._tag;
+	if (Predicate.hasProperty(error, "name") && typeof error.name === "string") return error.name;
+	const body = Predicate.hasProperty(error, "error") ? error.error : void 0;
+	if (Predicate.hasProperty(body, "_tag") && typeof body._tag === "string") return body._tag;
+};
+const resolveSpanFilter = (input = {}) => {
+	const dropName = prefixMatcher(input.dropSpanNames);
+	const dropPredicate = input.dropSpan;
+	const drop = dropName !== void 0 && dropPredicate !== void 0 ? (span) => dropName(span.name) || dropPredicate(span) : dropName !== void 0 ? (span) => dropName(span.name) : dropPredicate;
+	const identifiers = /* @__PURE__ */ new Set([...input.anticipatedErrorIdentifiers ?? [], ...input.anticipatedErrorTags ?? []]);
+	const byIdentifier = identifiers.size > 0 ? (error) => {
+		const identifier = failureIdentifier(error);
+		return identifier !== void 0 && identifiers.has(identifier);
+	} : void 0;
+	const byPredicate = input.isAnticipatedError;
+	const isAnticipated = byIdentifier !== void 0 && byPredicate !== void 0 ? (error) => byIdentifier(error) || byPredicate(error) : byIdentifier ?? byPredicate;
+	return {
+		dropSubtree: prefixMatcher(input.dropSpanSubtrees),
+		drop,
+		isAnticipated,
+		includeCauseInStack: input.includeCauseInStack ?? false
+	};
+};
+// src/shared/flushable-tracer.ts
+const MAX_BUFFER = 1e4;
+const isIgnoredFailure = (error, anticipated) => Predicate.hasProperty(error, ErrorReporter.ignore) && error[ErrorReporter.ignore] === true && !(anticipated !== void 0 && anticipated(error));
+const isIgnoredExit = (exit, anticipated) => {
+	if (exit._tag !== "Failure") return false;
+	if (exit.cause.reasons.some(Cause.isDieReason)) return false;
+	const failures = exit.cause.reasons.filter(Cause.isFailReason);
+	return failures.length > 0 && failures.every((reason) => isIgnoredFailure(reason.error, anticipated));
+};
+/**
+* Turns a finished span into its OTLP shape, or `undefined` when it must not be
+* exported (unsampled, dropped, or an ignored failure).
+*/
+const makeSpanEncoder = (filter) => {
+	const drop = filter.drop;
+	return (span, connectionLost) => {
+		if (!span.sampled) return void 0;
+		const status = span.status;
+		if (drop !== void 0 && drop({
+			name: span.name,
+			kind: span.kind,
+			attributes: span.attributes,
+			exit: status.exit
+		})) return void 0;
+		if (isIgnoredExit(status.exit, filter.isAnticipated)) return void 0;
+		return makeOtlpSpan(span, filter, connectionLost);
+	};
+};
+/**
+* A Tracer whose finished spans go to `exportFn`. A span matching
+* `dropSpanSubtrees` starts unsampled, which its descendants inherit (Effect
+* only samples a child of a sampled parent), so the whole subtree is skipped.
+* Only ever forced to `false`: trace levels and incoming `00` headers win.
+*/
+const makeMapleTracer = (filter, exportFn, watchConnection) => {
+	const dropSubtree = filter.dropSubtree;
+	return Tracer.make({ span(spanOptions) {
+		const connectionLost = watchConnection?.();
+		return makeSpan({
+			...spanOptions,
+			sampled: spanOptions.sampled && (dropSubtree === void 0 || !dropSubtree(spanOptions.name)),
+			status: {
+				_tag: "Started",
+				startTime: spanOptions.startTime
+			},
+			attributes: /* @__PURE__ */ new Map(),
+			export: (span) => exportFn(span, connectionLost)
+		});
+	} });
+};
+const makeSpanBuffer = (options = {}) => {
+	let buffer = [];
+	let disabled = false;
+	const filter = resolveSpanFilter(options);
+	const encode = makeSpanEncoder(filter);
+	const push = (span, connectionLost) => {
+		if (disabled) return;
+		if (buffer.length >= MAX_BUFFER) return;
+		const otlp = encode(span, connectionLost);
+		if (otlp !== void 0) buffer.push(otlp);
+	};
+	let unsettled = [];
+	const settle = () => {
+		const items = unsettled;
+		unsettled = [];
+		for (const [span, connectionLost] of items) push(span, connectionLost);
+	};
+	const exportFn = (span, connectionLost) => {
+		if (disabled) return;
+		if (connectionLost !== void 0 && connectionLost() === void 0 && isTransportFailure(span)) {
+			if (buffer.length + unsettled.length >= MAX_BUFFER) return;
+			unsettled.push([span, connectionLost]);
+			if (unsettled.length === 1) setTimeout(settle, 0);
+			return;
+		}
+		push(span, connectionLost);
+	};
+	const tracer = makeMapleTracer(filter, exportFn, options.watchConnection);
+	const captureException = (error, captureOptions = {}) => {
+		if (disabled) return;
+		const now = BigInt(Date.now()) * 1000000n;
+		makeSpan({
+			name: captureOptions.name ?? "exception",
+			parent: Option.none(),
+			annotations: Context.empty(),
+			status: {
+				_tag: "Started",
+				startTime: now
+			},
+			attributes: new Map(Object.entries(captureOptions.attributes ?? {})),
+			links: [],
+			sampled: true,
+			kind: "internal",
+			export: exportFn
+		}).end(now, Exit.failCause(Cause.die(error)));
+	};
+	return {
+		tracerLayer: Layer.succeed(Tracer.Tracer, tracer),
+		captureException,
+		drain: () => {
+			settle();
+			const items = buffer;
+			buffer = [];
+			return items;
+		},
+		restore: (items) => {
+			if (disabled || items.length === 0) return;
+			buffer = [...items, ...buffer].slice(0, MAX_BUFFER);
+		},
+		setDisabled: (value) => {
+			disabled = value;
+			if (value) {
+				buffer = [];
+				unsettled = [];
+			}
+		},
+		size: () => buffer.length + unsettled.length
+	};
+};
+const ATTR_EXCEPTION_TYPE = "exception.type";
+const ATTR_EXCEPTION_MESSAGE = "exception.message";
+const ATTR_EXCEPTION_STACKTRACE = "exception.stacktrace";
+const SpanProto = {
+	_tag: "Span",
+	end(endTime, exit) {
+		this.status = {
+			_tag: "Ended",
+			startTime: this.status.startTime,
+			endTime,
+			exit
+		};
+		this.export(this);
+	},
+	attribute(key, value) {
+		this.attributes.set(key, value);
+	},
+	event(name, startTime, attributes) {
+		this.events.push([
+			name,
+			startTime,
+			attributes
+		]);
+	},
+	addLinks(links) {
+		this.links.push(...links);
+	}
+};
+const makeSpan = (options) => {
+	const self = Object.assign(Object.create(SpanProto), options);
+	self.traceId = self.parent._tag === "Some" ? self.parent.value.traceId : generateId(32);
+	self.spanId = generateId(16);
+	self.events = [];
+	return self;
+};
+const generateId = (len) => {
+	const chars = "0123456789abcdef";
+	let result = "";
+	for (let i = 0; i < len; i++) result += chars[Math.floor(Math.random() * 16)];
+	return result;
+};
+const isFullyAnticipated = (cause, isAnticipated) => {
+	if (isAnticipated === void 0) return false;
+	if (cause.reasons.some(Cause.isDieReason)) return false;
+	const failErrors = cause.reasons.filter(Cause.isFailReason).map((reason) => reason.error);
+	return failErrors.length > 0 && failErrors.every(isAnticipated);
+};
+const renderedServerError = (self) => {
+	if (self.kind !== "server") return void 0;
+	const raw = self.attributes.get("http.response.status_code");
+	const code = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : NaN;
+	return Number.isInteger(code) && code >= 500 ? code : void 0;
+};
+const isStatusOnlyResponseError = (error) => Predicate.isTagged(error, "ResponseError") && (!Predicate.hasProperty(error, "cause") || error.cause === void 0) && (!Predicate.hasProperty(error, "description") || error.description === void 0);
+const isResponseFailure = (exit) => {
+	if (exit._tag === "Success") return true;
+	const [reason, ...rest] = exit.cause.reasons;
+	return rest.length === 0 && reason !== void 0 && Cause.isFailReason(reason) && Predicate.isTagged(reason.error, "HttpServerError") && Predicate.hasProperty(reason.error, "reason") && isStatusOnlyResponseError(reason.error.reason);
+};
+const httpClientFailureReason = (exit, reasonTag) => {
+	if (exit._tag === "Success") return void 0;
+	const [reason, ...rest] = exit.cause.reasons;
+	if (rest.length > 0 || reason === void 0 || !Cause.isFailReason(reason)) return void 0;
+	const error = reason.error;
+	if (!Predicate.isTagged(error, "HttpClientError") || !Predicate.hasProperty(error, "reason")) return void 0;
+	return Predicate.isTagged(error.reason, reasonTag) ? error.reason : void 0;
+};
+const isTransportFailure = (span) => span.status._tag === "Ended" && httpClientFailureReason(span.status.exit, "TransportError") !== void 0;
+const isClientStatus4xx = (self, exit) => {
+	if (self.kind !== "client") return false;
+	const reason = httpClientFailureReason(exit, "StatusCodeError");
+	if (!Predicate.hasProperty(reason, "response") || !Predicate.hasProperty(reason.response, "status")) return false;
+	const code = reason.response.status;
+	return typeof code === "number" && code >= 400 && code < 500;
+};
+const errorTypeOf = (self, exit) => {
+	const code = self.attributes.get("http.response.status_code");
+	if (typeof code === "number" && code >= 400) return String(code);
+	if (exit._tag === "Success") return "_OTHER";
+	const [reason] = exit.cause.reasons;
+	if (reason !== void 0 && Cause.isFailReason(reason)) {
+		const error = reason.error;
+		if (Predicate.isTagged(error, "HttpClientError") && Predicate.hasProperty(error, "reason")) {
+			const tag = Predicate.hasProperty(error.reason, "_tag") ? error.reason._tag : void 0;
+			if (typeof tag === "string") return tag;
+		}
+	}
+	return Cause.prettyErrors(exit.cause)[0]?.name || "_OTHER";
+};
+const makeOtlpSpan = (self, filter, connectionLost) => {
+	const status = self.status;
+	const attributes = OtlpResource.entriesToAttributes(self.attributes.entries());
+	const events = self.events.map(([name, startTime, attrs]) => ({
+		name,
+		timeUnixNano: String(startTime),
+		attributes: attrs ? OtlpResource.entriesToAttributes(Object.entries(attrs)) : [],
+		droppedAttributesCount: 0
+	}));
+	let otelStatus;
+	const lostReason = connectionLost !== void 0 && httpClientFailureReason(status.exit, "TransportError") !== void 0 ? connectionLost() : void 0;
+	const serverError = isResponseFailure(status.exit) ? renderedServerError(self) : void 0;
+	if (serverError !== void 0) {
+		const method = self.attributes.get("http.request.method");
+		const path = self.attributes.get("url.path");
+		const message = typeof method === "string" && typeof path === "string" ? `HTTP ${serverError} (${method} ${path})` : `HTTP ${serverError}`;
+		otelStatus = {
+			code: StatusCode.Error,
+			message
+		};
+		if (!events.some((event) => event.name === "exception")) events.push({
+			name: "exception",
+			timeUnixNano: String(status.endTime),
+			droppedAttributesCount: 0,
+			attributes: [{
+				key: ATTR_EXCEPTION_TYPE,
+				value: { stringValue: "HttpServerErrorResponse" }
+			}, {
+				key: ATTR_EXCEPTION_MESSAGE,
+				value: { stringValue: message }
+			}]
+		});
+	} else if (status.exit._tag === "Success") otelStatus = constOtelStatusSuccess;
+	else if (Cause.hasInterruptsOnly(status.exit.cause)) {
+		otelStatus = constOtelStatusSuccess;
+		attributes.push({
+			key: "mxl.interrupted",
+			value: { boolValue: true }
+		});
+	} else if (renderedServerError(self) === void 0 && isFullyAnticipated(status.exit.cause, filter.isAnticipated)) otelStatus = constOtelStatusSuccess;
+	else if (isClientStatus4xx(self, status.exit)) otelStatus = {
+		code: StatusCode.Error,
+		message: Cause.prettyErrors(status.exit.cause)[0]?.message ?? ""
+	};
+	else if (lostReason !== void 0) {
+		otelStatus = { code: StatusCode.Unset };
+		attributes.push({
+			key: "mxl.connection_lost",
+			value: { stringValue: lostReason }
+		});
+	} else {
+		const errors = Cause.prettyErrors(status.exit.cause, { includeCauseInStack: filter.includeCauseInStack });
+		otelStatus = { code: StatusCode.Error };
+		const firstError = errors[0];
+		if (firstError) {
+			otelStatus.message = firstError.message;
+			for (const error of errors) events.push({
+				name: "exception",
+				timeUnixNano: String(status.endTime),
+				droppedAttributesCount: 0,
+				attributes: [
+					{
+						key: ATTR_EXCEPTION_TYPE,
+						value: { stringValue: error.name }
+					},
+					{
+						key: ATTR_EXCEPTION_MESSAGE,
+						value: { stringValue: error.message }
+					},
+					{
+						key: ATTR_EXCEPTION_STACKTRACE,
+						value: { stringValue: error.stack ?? "No stack trace available" }
+					}
+				]
+			});
+		}
+	}
+	if (otelStatus.code === StatusCode.Error && !self.attributes.has("error.type")) attributes.push({
+		key: "error.type",
+		value: { stringValue: errorTypeOf(self, status.exit) }
+	});
+	return {
+		traceId: self.traceId,
+		spanId: self.spanId,
+		parentSpanId: self.parent._tag === "Some" ? self.parent.value.spanId : void 0,
+		name: self.name,
+		kind: SpanKind[self.kind],
+		startTimeUnixNano: String(status.startTime),
+		endTimeUnixNano: String(status.endTime),
+		attributes,
+		droppedAttributesCount: 0,
+		events,
+		droppedEventsCount: 0,
+		status: otelStatus,
+		links: self.links.map((link) => ({
+			traceId: link.span.traceId,
+			spanId: link.span.spanId,
+			attributes: OtlpResource.entriesToAttributes(Object.entries(link.attributes)),
+			droppedAttributesCount: 0
+		})),
+		droppedLinksCount: 0
+	};
+};
+const StatusCode = {
+	Unset: 0,
+	Ok: 1,
+	Error: 2
+};
+const SpanKind = {
+	unspecified: 0,
+	internal: 1,
+	server: 2,
+	client: 3,
+	producer: 4,
+	consumer: 5
+};
+const constOtelStatusSuccess = { code: StatusCode.Ok };
+// src/browser/replay.ts
+const replayRecordOptions = (replay) => ({
+	maskAllInputs: replay?.maskAllInputs ?? true,
+	maskTextSelector: replay?.maskAllText === true ? "*" : void 0,
+	...replay?.canvasFps && replay.canvasFps > 0 && replay.maskAllText !== true ? {
+		recordCanvas: true,
+		sampling: { canvas: replay.canvasFps }
+	} : {}
+});
+let stopRecorder;
+let chunkSeq = 0;
+const ingestHeaders = (clientId, apiKey, contentType) => {
+	const headers = {
+		"content-type": contentType,
+		"mxl-client-id": clientId,
+		"mxl-sdk-name": SDK_NAME,
+		"mxl-sdk-version": SDK_VERSION
+	};
+	if (apiKey) headers["mxl-api-key"] = apiKey;
+	return headers;
+};
+const isWebSdkPresent = () => {
+	const global = globalThis;
+	return Boolean(global.__MXL_WEB_SDK__ || global.MxlWebSdk || global.__MXL_REPLAY_SESSION__);
+};
+const shouldRecordReplay = (replay) => {
+	if (isWebSdkPresent()) return false;
+	if (replay?.enabled === false) return false;
+	const sampleRate = replay?.sampleRate ?? 1;
+	return sampleRate >= 1 || Math.random() < sampleRate;
+};
+const sessionMetaRow = (serviceName) => {
+	const identity = getCurrentIdentity();
+	const started = /* @__PURE__ */ new Date();
+	return {
+		service_name: serviceName,
+		session_id: getCurrentSessionId(),
+		start_time: started.toISOString().replace("T", " ").replace("Z", ""),
+		status: "active",
+		url_initial: typeof globalThis.location?.href === "string" ? globalThis.location.href : "",
+		user_agent: typeof globalThis.navigator?.userAgent === "string" ? globalThis.navigator.userAgent : "",
+		user_id: identity?.id ?? "",
+		version: 1
+	};
+};
+const postSessionReplayMeta = (ingestUrl, clientId, serviceName, apiKey) => {
+	try {
+		fetch(`${ingestUrl.replace(/\/$/, "")}/sessionReplays/meta`, {
+			body: `${JSON.stringify(sessionMetaRow(serviceName))}\n`,
+			headers: ingestHeaders(clientId, apiKey, "application/x-ndjson"),
+			keepalive: true,
+			method: "POST"
+		});
+	} catch {}
+};
+const postSessionReplayBlob = (ingestUrl, clientId, meta, body, apiKey) => {
+	try {
+		fetch(`${ingestUrl.replace(/\/$/, "")}/sessionReplays/blob`, {
+			body,
+			headers: {
+				...ingestHeaders(clientId, apiKey, "application/octet-stream"),
+				"x-mxl-chunk-seq": String(meta.chunkSeq),
+				"x-mxl-duration-ms": String(meta.durationMs),
+				"x-mxl-event-count": String(meta.eventCount),
+				"x-mxl-is-checkpoint": meta.isCheckpoint ? "1" : "0",
+				"x-mxl-session-id": meta.sessionId
+			},
+			keepalive: true,
+			method: "POST"
+		});
+	} catch {}
+};
+const gzipJson = async (value) => {
+	if (typeof CompressionStream === "undefined") return;
+	const encoded = new TextEncoder().encode(JSON.stringify(value));
+	const stream = new Blob([encoded]).stream().pipeThrough(new CompressionStream("gzip"));
+	return new Uint8Array(await new Response(stream).arrayBuffer());
+};
+const stopReplay = () => {
+	stopRecorder?.();
+	stopRecorder = void 0;
+};
+const startReplay = async (config) => {
+	if (!shouldRecordReplay(config.replay)) return;
+	stopReplay();
+	chunkSeq = 0;
+	postSessionReplayMeta(config.ingestUrl, config.clientId, config.serviceName, config.apiKey);
+	try {
+		const rrweb = await import(
+			/* @vite-ignore */
+			"rrweb"
+);
+		if (typeof rrweb.record !== "function") return;
+		const events = [];
+		const startedAt = Date.now();
+		const stop = rrweb.record({
+			emit: (event) => {
+				events.push(event);
+			},
+			...replayRecordOptions(config.replay)
+		});
+		stopRecorder = () => {
+			stop?.();
+			if (events.length === 0) return;
+			gzipJson(events).then((gzipped) => {
+				if (!gzipped) return;
+				postSessionReplayBlob(config.ingestUrl, config.clientId, {
+					chunkSeq: chunkSeq++,
+					durationMs: Date.now() - startedAt,
+					eventCount: events.length,
+					isCheckpoint: true,
+					sessionId: getCurrentSessionId()
+				}, gzipped, config.apiKey);
+			});
+		};
+	} catch {}
+};
+// src/browser/layer.ts
+var layer_exports = /* @__PURE__ */ __exportAll({
+	clearIdentity: () => clearIdentity,
+	identify: () => identify,
+	layer: () => layer,
+	stampUserIdOnSpan: () => stampUserIdOnSpan,
+	track: () => track
+});
+const stampUserIdOnSpan = (span) => {
+	const userId = getCurrentUserId();
+	if (userId) span.setAttribute("user.id", userId);
+};
+var UserIdSpanProcessor = class {
+	inner;
+	constructor(inner) {
+		this.inner = inner;
+	}
+	forceFlush() {
+		return this.inner.forceFlush();
+	}
+	onEnd(span) {
+		this.inner.onEnd(span);
+	}
+	onStart(span, parentContext) {
+		stampUserIdOnSpan(span);
+		this.inner.onStart(span, parentContext);
+	}
+	shutdown() {
+		return this.inner.shutdown();
+	}
+};
+function resolveBrowserEndpoint(config) {
+	if (config.disabled) return;
+	if (config.endpoint && config.endpoint.length > 0) return normalizeOtlpBaseUrl(config.endpoint);
+}
+/**
+* Browser Effect observability layer backed by OpenTelemetry WebSdk.
+*
+* Returns a no-op layer when `disabled` is true or no OTLP endpoint is configured.
+*/
+const layer = (config = {}) => {
+	if (config.clientId) {
+		configureBrowserAnalytics({
+			apiKey: config.apiKey,
+			clientId: config.clientId,
+			ingestUrl: config.ingestUrl,
+			privacy: config.privacy,
+			serviceName: config.serviceName
+		});
+		startReplay({
+			apiKey: config.apiKey,
+			clientId: config.clientId,
+			ingestUrl: config.ingestUrl ?? "http://127.0.0.1:8000",
+			replay: config.replay,
+			serviceName: config.serviceName ?? "unknown"
+		});
+	}
+	const endpoint = resolveBrowserEndpoint(config);
+	if (!endpoint) return Layer.empty;
+	const attributes = {
+		...browserResourceAttributes(),
+		"mxl.sdk.type": "browser",
+		...config.environment ? {
+			"deployment.environment": config.environment,
+			"deployment.environment.name": config.environment
+		} : {},
+		...config.serviceNamespace ? { "service.namespace": config.serviceNamespace } : {},
+		...config.attributes
+	};
+	return WebSdk.layer(() => ({
+		resource: {
+			attributes,
+			serviceName: config.serviceName ?? "unknown",
+			serviceVersion: config.serviceVersion
+		},
+		spanProcessor: new UserIdSpanProcessor(new BatchSpanProcessor(new OTLPTraceExporter({
+			headers: config.headers,
+			url: `${endpoint}/v1/traces`
+		})))
+	}));
+};
+const identify = (input) => Effect.sync(() => identify$1(input));
+const clearIdentity = Effect.sync(() => clearIdentity$1());
+const track = (name, props) => Effect.sync(() => track$1(name, props));
+// src/browser/flushable.ts
+var flushable_exports = /* @__PURE__ */ __exportAll({
+	attachProcessor: () => attachProcessor,
+	make: () => make
+});
+const processors = /* @__PURE__ */ new WeakMap();
+const DEFAULT_AUTO_FLUSH_MS = 5e3;
+const attachProcessor = (telemetry, processor) => {
+	processors.set(telemetry, processor);
+};
+const otlpAnyValue = (value) => {
+	if (Array.isArray(value)) return { arrayValue: { values: value.map(otlpAnyValue) } };
+	switch (typeof value) {
+		case "string": return { stringValue: value };
+		case "boolean": return { boolValue: value };
+		case "number": return Number.isInteger(value) ? { intValue: value } : { doubleValue: value };
+		case "bigint": return { intValue: Number(value) };
+		default: return { stringValue: String(value) };
+	}
+};
+const makeTracesBody = (input) => {
+	const attributes = Object.entries(input.attributes).map(([key, value]) => ({
+		key,
+		value: otlpAnyValue(value)
+	}));
+	attributes.push({
+		key: "service.name",
+		value: { stringValue: input.serviceName }
+	});
+	if (input.serviceVersion) attributes.push({
+		key: "service.version",
+		value: { stringValue: input.serviceVersion }
+	});
+	return { resourceSpans: [{
+		resource: {
+			attributes,
+			droppedAttributesCount: 0
+		},
+		scopeSpans: [{
+			scope: { name: input.serviceName },
+			spans: input.spans
+		}]
+	}] };
+};
+const resolveFlushableEndpoint = (config) => {
+	if (config.disabled) return void 0;
+	if (config.endpoint && config.endpoint.length > 0) return normalizeOtlpBaseUrl(config.endpoint);
+};
+const make = (config = {}) => {
+	const endpoint = resolveFlushableEndpoint(config);
+	const spanBuffer = endpoint ? makeSpanBuffer(config) : void 0;
+	const layer$1 = spanBuffer ? spanBuffer.tracerLayer : layer(config);
+	if (spanBuffer && config.clientId) layer({
+		...config,
+		endpoint: void 0
+	});
+	const resourceAttributes = {
+		...browserResourceAttributes(),
+		"mxl.sdk.type": "browser",
+		...config.environment ? {
+			"deployment.environment": config.environment,
+			"deployment.environment.name": config.environment
+		} : {},
+		...config.serviceNamespace ? { "service.namespace": config.serviceNamespace } : {},
+		...config.attributes
+	};
+	const state = { disabledUntil: 0 };
+	const listeners = [];
+	const telemetry = {
+		captureException: (error, options) => {
+			if (spanBuffer) spanBuffer.captureException(error, options);
+			if (config.clientId) track$1(options?.name ?? "uncaught_error", {
+				...options?.attributes,
+				message: error instanceof Error ? error.message : String(error)
+			});
+		},
+		dispose: async () => {
+			for (const stop of listeners) stop();
+			listeners.length = 0;
+			stopReplay();
+			await telemetry.flush();
+		},
+		flush: makeSerializedFlush(guardFlush("[MxlFlush]", async () => {
+			flushAnalytics(true);
+			await processors.get(telemetry)?.forceFlush();
+			if (spanBuffer && endpoint) {
+				const spans = spanBuffer.drain();
+				if (spans.length > 0) await fetchTransport({
+					body: JSON.stringify(makeTracesBody({
+						attributes: resourceAttributes,
+						serviceName: config.serviceName ?? "unknown",
+						serviceVersion: config.serviceVersion,
+						spans
+					})),
+					headers: {
+						"content-type": "application/json",
+						...config.headers
+					},
+					keepalive: true,
+					url: `${endpoint}/v1/traces`
+				});
+			}
+		}, state)),
+		layer: layer$1
+	};
+	const intervalMs = config.autoFlushInterval === void 0 ? DEFAULT_AUTO_FLUSH_MS : config.autoFlushInterval === false ? 0 : config.autoFlushInterval;
+	if (intervalMs > 0) {
+		const timer = setInterval(() => {
+			telemetry.flush();
+		}, intervalMs);
+		timer.unref?.();
+		listeners.push(() => {
+			clearInterval(timer);
+		});
+	}
+	const documentRef = globalThis.document;
+	if (config.flushOnUnload !== false) {
+		const onHidden = () => {
+			telemetry.flush();
+		};
+		if (documentRef) {
+			const onVisibilityChange = () => {
+				if (documentRef.visibilityState === "hidden") onHidden();
+			};
+			documentRef.addEventListener("visibilitychange", onVisibilityChange);
+			listeners.push(() => {
+				documentRef.removeEventListener("visibilitychange", onVisibilityChange);
+			});
+		}
+		if (typeof globalThis.addEventListener === "function") {
+			globalThis.addEventListener("pagehide", onHidden);
+			listeners.push(() => {
+				globalThis.removeEventListener("pagehide", onHidden);
+			});
+		}
+	}
+	if (config.captureGlobalErrors !== false && typeof globalThis.addEventListener === "function") {
+		const onError = (event) => {
+			const record = event;
+			telemetry.captureException(record.error ?? record.reason ?? event);
+			telemetry.flush();
+		};
+		globalThis.addEventListener("error", onError);
+		globalThis.addEventListener("unhandledrejection", onError);
+		listeners.push(() => {
+			globalThis.removeEventListener("error", onError);
+			globalThis.removeEventListener("unhandledrejection", onError);
+		});
+	}
+	return telemetry;
+};
+export { scrubUrl as _, browserDocument as a, clearIdentity$1 as c, increment as d, setConsent as f, resetUrlSanitizersForTests as g, redactUrl as h, replayRecordOptions as i, decrement as l, addUrlSanitizer as m, make as n, browserNavigator as o, track$1 as p, layer_exports as r, browserResourceAttributes as s, flushable_exports as t, identify$1 as u };
+
+//# sourceMappingURL=flushable-CXe-q-GF.js.map