@reopt-ai/data-sdk-client 0.1.6 → 0.2.0

package/dist/registry-CGqrOtf4.cjs

@@ -0,0 +1,1810 @@
+let _reopt_ai_data_contract_identity = require("@reopt-ai/data-contract/identity");
+let _reopt_ai_data_contract_ingest = require("@reopt-ai/data-contract/ingest");
+let _reopt_ai_data_contract_events = require("@reopt-ai/data-contract/events");
+//#region ../data-sdk-core/src/circuit-breaker.ts
+const DEFAULT_CIRCUIT_BREAKER = {
+	failureThreshold: 5,
+	recoveryTimeout: 6e4
+};
+var CircuitBreaker = class {
+	state = "closed";
+	consecutiveFailures = 0;
+	openedAt = 0;
+	failureThreshold;
+	recoveryTimeout;
+	now;
+	constructor(config, now) {
+		this.failureThreshold = config?.failureThreshold ?? DEFAULT_CIRCUIT_BREAKER.failureThreshold;
+		this.recoveryTimeout = config?.recoveryTimeout ?? DEFAULT_CIRCUIT_BREAKER.recoveryTimeout;
+		this.now = now;
+	}
+	getState() {
+		return this.state;
+	}
+	allowRequest() {
+		if (this.state !== "open") return true;
+		if (this.now() - this.openedAt < this.recoveryTimeout) return false;
+		this.state = "half-open";
+		return true;
+	}
+	recordSuccess() {
+		this.state = "closed";
+		this.consecutiveFailures = 0;
+	}
+	recordFailure() {
+		this.consecutiveFailures++;
+		if (this.state === "half-open" || this.consecutiveFailures >= this.failureThreshold) {
+			const wasOpen = this.state === "open";
+			this.state = "open";
+			this.openedAt = this.now();
+			return !wasOpen;
+		}
+		return false;
+	}
+	recordRejection() {
+		if (this.state === "half-open") this.state = "closed";
+		this.consecutiveFailures = 0;
+	}
+};
+const CONSENT_STORAGE_KEY = "consent";
+var ConsentManager = class {
+	state = {};
+	paused = false;
+	storage;
+	onChange;
+	constructor(config, storage, onChange) {
+		const persist = config?.persist ?? true;
+		this.storage = persist ? storage : void 0;
+		this.onChange = onChange;
+		const defaultConsent = config?.defaultConsent ?? true;
+		for (const category of config?.categories ?? ["analytics"]) this.state[category] = defaultConsent;
+		const stored = this.storage ? readStoredConsent(this.storage) : null;
+		if (stored) Object.assign(this.state, stored);
+	}
+	get(category) {
+		return this.state[category] ?? false;
+	}
+	set(category, allowed) {
+		this.state[category] = allowed;
+		this.persist();
+	}
+	setAll(allowed) {
+		for (const key of Object.keys(this.state)) this.state[key] = allowed;
+		this.persist();
+	}
+	snapshot() {
+		return { ...this.state };
+	}
+	replace(state) {
+		this.state = {
+			...this.state,
+			...state
+		};
+		this.persist();
+	}
+	pause() {
+		this.paused = true;
+	}
+	resume() {
+		this.paused = false;
+	}
+	isPaused() {
+		return this.paused;
+	}
+	enqueueBlockReason(category) {
+		if (this.paused) return "tracking_paused";
+		if (!this.get(category)) return "consent_denied";
+		return null;
+	}
+	flushBlockReason() {
+		if (this.paused) return "tracking_paused";
+		if (!Object.values(this.state).some((allowed) => allowed === true)) return "consent_denied";
+		return null;
+	}
+	persist() {
+		this.onChange?.(this.snapshot());
+		if (!this.storage) return;
+		try {
+			this.storage.setItem(CONSENT_STORAGE_KEY, JSON.stringify(this.state));
+		} catch {}
+	}
+};
+function readStoredConsent(storage) {
+	try {
+		const raw = storage.getItem(CONSENT_STORAGE_KEY);
+		if (!raw) return null;
+		const parsed = JSON.parse(raw);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+		const state = {};
+		for (const [category, allowed] of Object.entries(parsed)) if (typeof allowed === "boolean") state[category] = allowed;
+		return state;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region ../data-sdk-core/src/validate.ts
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isId = (value, required) => value === void 0 ? !required : typeof value === "number" || typeof value === "string" && value.length <= 500 && (!required || value.length > 0);
+const isName = (value, max = 200) => typeof value === "string" && value.length > 0 && value.length <= max;
+function validateStructurally(event) {
+	const bad = [];
+	if (!isRecord(event)) return [{
+		field: "",
+		message: "not an object"
+	}];
+	if (!UUID.test(String(event.eventId))) bad.push("eventId");
+	if (!Number.isInteger(event.timestamp) || event.timestamp < 0) bad.push("timestamp");
+	const p = event.payload;
+	if (!isRecord(p)) return [...bad, "payload"].map(field);
+	switch (event.type) {
+		case "track":
+			if (!isName(p.name)) bad.push("payload.name");
+			else if (_reopt_ai_data_contract_events.RESERVED_EVENT_NAMES.includes(p.name)) bad.push("payload.name:reserved");
+			if (!isId(p.profileId, false)) bad.push("payload.profileId");
+			break;
+		case "identify":
+			if (!isId(p.profileId, true)) bad.push("payload.profileId");
+			break;
+		case "increment":
+		case "decrement":
+			if (!isId(p.profileId, true)) bad.push("payload.profileId");
+			if (!isName(p.property)) bad.push("payload.property");
+			if (p.value !== void 0 && !(typeof p.value === "number" && p.value > 0)) bad.push("payload.value");
+			break;
+		default: bad.push("type");
+	}
+	if (p.properties !== void 0 && !isRecord(p.properties)) bad.push("payload.properties");
+	return bad.map(field);
+}
+function field(name) {
+	const [path, reason] = name.split(":");
+	return {
+		field: path,
+		message: reason ?? "invalid"
+	};
+}
+//#endregion
+//#region ../data-sdk-core/src/events.ts
+function validateEvent(event) {
+	const errors = validateStructurally(event);
+	if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+		const result = _reopt_ai_data_contract_ingest.zTrackHandlerPayload.safeParse(event);
+		if (!result.success) return {
+			valid: false,
+			errors: result.error.issues.map((issue) => ({
+				field: issue.path.join("."),
+				message: issue.message
+			}))
+		};
+		if (errors.length > 0) {
+			console.warn("[reopt] structural validator disagrees with the contract schema — report this", errors);
+			return { valid: true };
+		}
+	}
+	return errors.length === 0 ? { valid: true } : {
+		valid: false,
+		errors
+	};
+}
+function stamp(deps, draft) {
+	return {
+		...draft,
+		eventId: deps.createId(),
+		timestamp: deps.now()
+	};
+}
+function buildTrackEvent(deps, options, fallbackProfileId) {
+	return stamp(deps, {
+		type: "track",
+		payload: {
+			name: options.name,
+			properties: options.properties,
+			profileId: options.profileId ?? fallbackProfileId ?? void 0
+		}
+	});
+}
+function buildIdentifyEvent(deps, options) {
+	return stamp(deps, {
+		type: "identify",
+		payload: {
+			profileId: options.profileId,
+			...options.firstName && { firstName: options.firstName },
+			...options.lastName && { lastName: options.lastName },
+			...options.email && { email: options.email },
+			...options.avatar && { avatar: options.avatar },
+			properties: options.properties
+		}
+	});
+}
+function buildCounterEvent(deps, type, options, fallbackProfileId) {
+	return stamp(deps, {
+		type,
+		payload: {
+			profileId: options.profileId ?? fallbackProfileId ?? "",
+			property: options.property,
+			value: options.value ?? 1
+		}
+	});
+}
+function buildPageViewOptions(options, context) {
+	const utm = options.utm ?? context.utm ?? {};
+	return {
+		name: "$pageview",
+		consentCategory: options.consentCategory,
+		identity: options.identity,
+		properties: {
+			path: options.path ?? context.path ?? "/",
+			origin: options.origin ?? context.origin ?? "",
+			title: options.title ?? context.title ?? "",
+			referrer: options.referrer ?? context.referrer ?? "",
+			...Object.fromEntries(Object.entries(utm).filter(([, value]) => value)),
+			...context.properties,
+			...options.properties
+		}
+	};
+}
+function normalizePersistedEvent(deps, event) {
+	if (!event || typeof event !== "object") return null;
+	const candidate = event;
+	if (candidate.type !== "track" && candidate.type !== "identify" && candidate.type !== "increment" && candidate.type !== "decrement") return null;
+	if (!candidate.payload || typeof candidate.payload !== "object") return null;
+	return {
+		...candidate,
+		eventId: candidate.eventId ?? deps.createId(),
+		timestamp: candidate.timestamp ?? deps.now()
+	};
+}
+//#endregion
+//#region ../data-sdk-core/src/ids.ts
+let lastTimestamp = -1;
+let sequence = 0;
+const HEX = "0123456789abcdef";
+function randomBytes(length) {
+	const bytes = new Uint8Array(length);
+	const cryptoApi = globalThis.crypto;
+	if (cryptoApi && typeof cryptoApi.getRandomValues === "function") {
+		cryptoApi.getRandomValues(bytes);
+		return bytes;
+	}
+	for (let index = 0; index < length; index++) bytes[index] = Math.floor(Math.random() * 256);
+	return bytes;
+}
+function hex(bytes) {
+	let out = "";
+	for (const byte of bytes) out += HEX[byte >> 4] + HEX[byte & 15];
+	return out;
+}
+function uuidv7(now = Date.now()) {
+	let timestamp = Math.max(0, Math.floor(now));
+	if (timestamp === lastTimestamp) {
+		sequence = sequence + 1 & 4095;
+		if (sequence === 0) {
+			timestamp = lastTimestamp + 1;
+			lastTimestamp = timestamp;
+		}
+	} else if (timestamp < lastTimestamp) {
+		timestamp = lastTimestamp;
+		sequence = sequence + 1 & 4095;
+		if (sequence === 0) {
+			timestamp = lastTimestamp + 1;
+			lastTimestamp = timestamp;
+		}
+	} else {
+		lastTimestamp = timestamp;
+		sequence = randomBytes(2)[0] & 15;
+	}
+	const bytes = new Uint8Array(16);
+	bytes[0] = timestamp / 2 ** 40 & 255;
+	bytes[1] = timestamp / 2 ** 32 & 255;
+	bytes[2] = timestamp / 2 ** 24 & 255;
+	bytes[3] = timestamp / 2 ** 16 & 255;
+	bytes[4] = timestamp / 256 & 255;
+	bytes[5] = timestamp & 255;
+	bytes[6] = 112 | sequence >> 8;
+	bytes[7] = sequence & 255;
+	const random = randomBytes(8);
+	bytes[8] = 128 | random[0] & 63;
+	for (let index = 1; index < 8; index++) bytes[8 + index] = random[index];
+	const text = hex(bytes);
+	return `${text.slice(0, 8)}-${text.slice(8, 12)}-${text.slice(12, 16)}-${text.slice(16, 20)}-${text.slice(20)}`;
+}
+function uuidv4() {
+	const cryptoApi = globalThis.crypto;
+	if (cryptoApi && typeof cryptoApi.randomUUID === "function") return cryptoApi.randomUUID();
+	const bytes = randomBytes(16);
+	bytes[6] = 64 | bytes[6] & 15;
+	bytes[8] = 128 | bytes[8] & 63;
+	const text = hex(bytes);
+	return `${text.slice(0, 8)}-${text.slice(8, 12)}-${text.slice(12, 16)}-${text.slice(16, 20)}-${text.slice(20)}`;
+}
+//#endregion
+//#region ../data-sdk-core/src/queue.ts
+const QUEUE_STORAGE_KEY = "queue";
+const PERSIST_DEBOUNCE_MS = 250;
+function serializedSize(value) {
+	const text = JSON.stringify(value);
+	if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(text).length;
+	let bytes = 0;
+	for (let index = 0; index < text.length; index++) {
+		const code = text.charCodeAt(index);
+		bytes += code < 128 ? 1 : code < 2048 ? 2 : 3;
+	}
+	return bytes;
+}
+function identityKey(identity) {
+	if (!identity) return "";
+	return `${identity.deviceId ?? ""}${identity.sessionId ?? ""}`;
+}
+var EventQueue = class {
+	entries = [];
+	inFlight = [];
+	persistTimeout = null;
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	get length() {
+		return this.entries.length;
+	}
+	push(entry) {
+		let dropped = 0;
+		if (this.entries.length >= this.options.maxSize) {
+			dropped = this.entries.length - this.options.maxSize + 1;
+			this.entries.splice(0, dropped);
+		}
+		this.entries.push(entry);
+		this.schedulePersist();
+		return dropped;
+	}
+	take(maxCount, maxBytes) {
+		if (this.entries.length === 0) return [];
+		const key = identityKey(this.entries[0].identity);
+		let count = 0;
+		let bytes = 2;
+		while (count < this.entries.length && count < maxCount) {
+			const entry = this.entries[count];
+			if (count > 0 && identityKey(entry.identity) !== key) break;
+			const size = serializedSize(entry.event) + (count > 0 ? 1 : 0);
+			if (count > 0 && bytes + size > maxBytes) break;
+			bytes += size;
+			count++;
+		}
+		this.inFlight = this.entries.splice(0, count);
+		return this.inFlight;
+	}
+	settle() {
+		this.inFlight = [];
+	}
+	requeue(entries) {
+		this.entries.unshift(...entries);
+		this.inFlight = [];
+	}
+	clear() {
+		this.entries = [];
+	}
+	peekAll() {
+		return this.entries;
+	}
+	schedulePersist() {
+		if (!this.options.persist || !this.options.storage) return;
+		if (this.persistTimeout) return;
+		this.persistTimeout = setTimeout(() => {
+			this.persistTimeout = null;
+			this.persistNow();
+		}, PERSIST_DEBOUNCE_MS);
+	}
+	persistNow() {
+		if (this.persistTimeout) {
+			clearTimeout(this.persistTimeout);
+			this.persistTimeout = null;
+		}
+		if (!this.options.persist || !this.options.storage) return;
+		try {
+			this.options.storage.setItem(QUEUE_STORAGE_KEY, JSON.stringify([...this.inFlight, ...this.entries].map((entry) => entry.event)));
+		} catch {
+			this.options.log?.("Failed to persist queue");
+		}
+	}
+	restore() {
+		if (!this.options.persist || !this.options.storage) return 0;
+		try {
+			const raw = this.options.storage.getItem(QUEUE_STORAGE_KEY);
+			if (!raw) return 0;
+			const payloads = JSON.parse(raw);
+			if (!Array.isArray(payloads)) return 0;
+			const restored = payloads.flatMap((payload) => {
+				const event = this.options.normalize(payload);
+				return event ? [{ event }] : [];
+			});
+			this.entries.push(...restored);
+			this.options.storage.removeItem(QUEUE_STORAGE_KEY);
+			return restored.length;
+		} catch {
+			this.options.log?.("Failed to load persisted queue");
+			return 0;
+		}
+	}
+	dispose() {
+		if (this.persistTimeout) {
+			clearTimeout(this.persistTimeout);
+			this.persistTimeout = null;
+		}
+	}
+};
+//#endregion
+//#region ../data-sdk-core/src/retry.ts
+var TransportError = class extends Error {
+	status;
+	preserveBatch;
+	constructor(message, status, preserveBatch = false) {
+		super(message);
+		this.name = "TransportError";
+		this.status = status;
+		this.preserveBatch = preserveBatch;
+	}
+};
+function isRetryableTransportError(error) {
+	if (error instanceof TransportError && typeof error.status === "number") {
+		if (error.status === 429) return true;
+		if (error.status >= 400 && error.status < 500) return false;
+	}
+	return true;
+}
+const DEFAULT_RETRY = {
+	maxRetries: 3,
+	baseDelay: 1e3,
+	maxDelay: 3e4,
+	jitter: .1
+};
+function resolveRetryConfig(config) {
+	return {
+		maxRetries: config?.maxRetries ?? DEFAULT_RETRY.maxRetries,
+		baseDelay: config?.baseDelay ?? DEFAULT_RETRY.baseDelay,
+		maxDelay: config?.maxDelay ?? DEFAULT_RETRY.maxDelay,
+		jitter: config?.jitter ?? DEFAULT_RETRY.jitter
+	};
+}
+function computeBackoff(attempt, config, random = Math.random) {
+	const delay = Math.min(Math.pow(2, attempt) * config.baseDelay, config.maxDelay);
+	const jitterAmount = delay * config.jitter * (random() * 2 - 1);
+	return Math.max(0, delay + jitterAmount);
+}
+async function withRetry(operation, config, hooks = {}) {
+	for (let attempt = 0; attempt <= config.maxRetries; attempt++) try {
+		return await operation(attempt);
+	} catch (error) {
+		if (!isRetryableTransportError(error) || attempt === config.maxRetries) throw error;
+		const waitMs = computeBackoff(attempt, config, hooks.random);
+		hooks.onRetry?.(attempt + 1, waitMs, error);
+		await new Promise((resolve) => setTimeout(resolve, waitMs));
+	}
+	throw new TransportError("Retry loop exhausted", 500, true);
+}
+//#endregion
+//#region ../data-sdk-core/src/storage.ts
+function memoryStorage() {
+	const store = new Map();
+	return {
+		getItem: (key) => store.get(key) ?? null,
+		setItem: (key, value) => {
+			store.set(key, value);
+		},
+		removeItem: (key) => {
+			store.delete(key);
+		}
+	};
+}
+function safeStorage(backend, onError) {
+	return {
+		getItem: (key) => {
+			try {
+				return backend.getItem(key);
+			} catch (error) {
+				onError?.("getItem", error);
+				return null;
+			}
+		},
+		setItem: (key, value) => {
+			try {
+				backend.setItem(key, value);
+			} catch (error) {
+				onError?.("setItem", error);
+			}
+		},
+		removeItem: (key) => {
+			try {
+				backend.removeItem(key);
+			} catch (error) {
+				onError?.("removeItem", error);
+			}
+		}
+	};
+}
+function prefixedStorage(backend, prefix) {
+	return {
+		getItem: (key) => backend.getItem(prefix + key),
+		setItem: (key, value) => backend.setItem(prefix + key, value),
+		removeItem: (key) => backend.removeItem(prefix + key)
+	};
+}
+//#endregion
+//#region ../data-sdk-core/src/types.ts
+function isWriteKeyAuth(auth) {
+	return "writeKey" in auth;
+}
+//#endregion
+//#region ../data-sdk-core/src/transport.ts
+function readIngestCounts(rawBody) {
+	let body;
+	try {
+		body = JSON.parse(rawBody);
+	} catch (error) {
+		throw new TransportError(`Track response did not match contract: ${error instanceof Error ? error.message : String(error)}`, 409, true);
+	}
+	const record = typeof body === "object" && body !== null ? body : null;
+	const count = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+	if (!record || record.status !== "ok" && record.status !== "accepted" || !count(record.accepted) || !count(record.duplicates) || !Array.isArray(record.rejected)) throw new TransportError("Track response did not match contract: unexpected shape", 409, true);
+	const session = record.session;
+	const credential = session && typeof session.id === "string" && typeof session.token === "string" ? {
+		id: session.id,
+		token: session.token
+	} : void 0;
+	return {
+		accepted: record.accepted,
+		duplicates: record.duplicates,
+		rejected: record.rejected.length,
+		...credential ? { session: credential } : {}
+	};
+}
+function resolveBaseUrl(value) {
+	if (!value) throw new Error("[reopt] `baseUrl` is required (your reopt-data origin, or the /ingest proxy prefix)");
+	return value.replace(/\/+$/, "");
+}
+function createTransport(options) {
+	const url = `${resolveBaseUrl(options.baseUrl)}/api/track`;
+	const headers = (identity) => {
+		const result = { "Content-Type": "application/json" };
+		const deviceId = identity?.deviceId ?? options.getDeviceId();
+		if (deviceId) result[_reopt_ai_data_contract_identity.DEVICE_ID_HEADER] = deviceId;
+		const sessionId = identity?.sessionId !== void 0 ? identity.sessionId : options.getSessionId?.();
+		if (sessionId) result[_reopt_ai_data_contract_identity.SESSION_ID_HEADER] = sessionId;
+		if (isWriteKeyAuth(options.auth)) result[_reopt_ai_data_contract_identity.WRITE_KEY_HEADER] = options.auth.writeKey;
+		else {
+			result[_reopt_ai_data_contract_identity.CLIENT_ID_HEADER] = options.auth.clientId;
+			result[_reopt_ai_data_contract_identity.CLIENT_SECRET_HEADER] = options.auth.clientSecret;
+		}
+		return result;
+	};
+	let reportedVersion;
+	const send = async (batch, sendOptions = {}) => {
+		const fetchImpl = options.fetch ?? globalThis.fetch;
+		if (!fetchImpl) throw new TransportError("No fetch implementation available", void 0, true);
+		const response = await fetchImpl(url, {
+			method: "POST",
+			headers: headers(sendOptions.identity),
+			body: JSON.stringify(batch),
+			...sendOptions.keepalive ? { keepalive: true } : {}
+		});
+		const rawBody = await response.text();
+		if (!response.ok) {
+			let code;
+			try {
+				const parsed = JSON.parse(rawBody);
+				if (typeof parsed.code === "string") code = parsed.code;
+			} catch {}
+			const preserveBatch = code === "quota_exceeded";
+			const effectiveStatus = code === "quota_exceeded" ? 402 : response.status;
+			throw new TransportError(`Failed to send batch: ${rawBody}`, effectiveStatus, preserveBatch);
+		}
+		const serverVersion = response.headers.get(_reopt_ai_data_contract_identity.CONTRACT_VERSION_HEADER);
+		if (serverVersion !== _reopt_ai_data_contract_identity.CONTRACT_VERSION && reportedVersion !== serverVersion) {
+			reportedVersion = serverVersion;
+			options.onVersionMismatch?.(serverVersion);
+		}
+		const counts = readIngestCounts(rawBody);
+		if (counts.accepted + counts.duplicates + counts.rejected !== batch.length) throw new TransportError("Track response counts do not reconcile with the submitted batch", 409, true);
+		return {
+			sent: counts.accepted + counts.duplicates,
+			failed: counts.rejected,
+			...counts.session ? { session: counts.session } : {}
+		};
+	};
+	return {
+		url,
+		headers,
+		send
+	};
+}
+//#endregion
+//#region ../data-sdk-core/src/client.ts
+const DEFAULT_BATCH = {
+	size: 100,
+	intervalMs: 1e3,
+	maxBytes: 4e5
+};
+const KEEPALIVE_MAX_BYTES = 6e4;
+var ReoptCore = class {
+	runtime;
+	transport;
+	queue;
+	consent;
+	breaker;
+	retry;
+	batch;
+	factory;
+	debug;
+	deviceId;
+	profileId = null;
+	globalProperties = {};
+	activeFlush = null;
+	flushTimeout = null;
+	removeFlushSignal = null;
+	closed = false;
+	generation = 0;
+	lastFlushRequeued = false;
+	constructor(config) {
+		this.runtime = config.runtime;
+		this.debug = config.debug ?? false;
+		this.deviceId = config.runtime.deviceId;
+		const now = config.runtime.now ?? (() => Date.now());
+		this.factory = {
+			now,
+			createId: config.runtime.createId ?? (() => uuidv7(now()))
+		};
+		const rawStorage = config.runtime.storage;
+		const storage = rawStorage ? prefixedStorage(safeStorage(rawStorage, (operation) => this.log(`storage ${operation} failed`)), config.storagePrefix ?? "reopt_") : void 0;
+		this.batch = {
+			size: config.batch?.size ?? DEFAULT_BATCH.size,
+			intervalMs: config.batch?.intervalMs ?? DEFAULT_BATCH.intervalMs,
+			maxBytes: config.batch?.maxBytes ?? DEFAULT_BATCH.maxBytes
+		};
+		this.retry = resolveRetryConfig(config.retry);
+		this.breaker = new CircuitBreaker(config.circuitBreaker, now);
+		this.transport = createTransport({
+			baseUrl: config.baseUrl,
+			auth: config.auth,
+			getDeviceId: () => this.deviceId,
+			getSessionId: config.runtime.getSessionId,
+			fetch: config.runtime.fetch,
+			onVersionMismatch: (serverVersion) => this.log("server contract version", serverVersion)
+		});
+		this.consent = new ConsentManager(config.consent, storage);
+		this.queue = new EventQueue({
+			maxSize: config.maxQueueSize ?? 1e4,
+			storage,
+			persist: config.enableOfflineBuffer ?? storage !== void 0,
+			normalize: (entry) => normalizePersistedEvent(this.factory, entry),
+			log: (...args) => this.log(...args)
+		});
+		const restored = this.queue.restore();
+		if (restored > 0) {
+			this.log(`restored ${restored}`);
+			this.scheduleFlush();
+		}
+		if ((config.autoFlushOnUnload ?? config.runtime.onFlushSignal !== void 0) && config.runtime.onFlushSignal) this.removeFlushSignal = config.runtime.onFlushSignal(() => this.flushOnSignal());
+	}
+	log(...args) {
+		if (this.debug) console.log("[reopt]", ...args);
+	}
+	getDeviceId() {
+		return this.deviceId;
+	}
+	setDeviceId(deviceId) {
+		this.deviceId = deviceId;
+	}
+	setProfileId(profileId) {
+		this.profileId = profileId;
+		this.log("profile", profileId);
+	}
+	getProfileId() {
+		return this.profileId;
+	}
+	setConsent(category, allowed) {
+		this.consent.set(category, allowed);
+		this.log("consent", category, allowed);
+	}
+	getConsent(category) {
+		return this.consent.get(category);
+	}
+	setAllConsent(allowed) {
+		this.consent.setAll(allowed);
+		this.log("consent all", allowed);
+	}
+	getConsentState() {
+		return this.consent.snapshot();
+	}
+	replaceConsentState(state) {
+		this.consent.replace(state);
+	}
+	pauseTracking() {
+		this.consent.pause();
+		this.log("paused");
+	}
+	resumeTracking() {
+		this.consent.resume();
+		this.log("resumed");
+		if (this.queue.length > 0) this.scheduleFlush();
+	}
+	register(properties) {
+		this.globalProperties = {
+			...this.globalProperties,
+			...properties
+		};
+	}
+	unregister(...keys) {
+		for (const key of keys) delete this.globalProperties[key];
+	}
+	getGlobalProperties() {
+		return { ...this.globalProperties };
+	}
+	track(options) {
+		const merged = Object.keys(this.globalProperties).length > 0 ? {
+			...options,
+			properties: {
+				...this.globalProperties,
+				...options.properties
+			}
+		} : options;
+		const event = buildTrackEvent(this.factory, merged, options.identity ? null : this.profileId);
+		return this.enqueue(event, options.consentCategory ?? "analytics", options.identity);
+	}
+	identify(options) {
+		if (!options.identity) this.profileId = options.profileId;
+		const event = buildIdentifyEvent(this.factory, options);
+		return this.enqueue(event, options.consentCategory ?? "analytics", options.identity);
+	}
+	increment(options) {
+		const event = buildCounterEvent(this.factory, "increment", options, options.identity ? null : this.profileId);
+		return this.enqueue(event, options.consentCategory ?? "analytics", options.identity);
+	}
+	decrement(options) {
+		const event = buildCounterEvent(this.factory, "decrement", options, options.identity ? null : this.profileId);
+		return this.enqueue(event, options.consentCategory ?? "analytics", options.identity);
+	}
+	pageView(options = {}) {
+		return this.track(buildPageViewOptions(options, this.runtime.getPageContext?.() ?? {}));
+	}
+	screenView(screenName, properties, identity) {
+		return this.track({
+			name: "$screen_view",
+			properties: {
+				screen_name: screenName,
+				...properties
+			},
+			identity
+		});
+	}
+	get pending() {
+		return this.queue.length;
+	}
+	enqueue(event, category, identity) {
+		const blockReason = this.consent.enqueueBlockReason(category);
+		if (blockReason) {
+			this.log("dropped:", blockReason);
+			return {
+				eventId: event.eventId,
+				queued: false,
+				reason: blockReason
+			};
+		}
+		const validation = validateEvent(event);
+		if (!validation.valid) {
+			this.log("invalid:", validation.errors);
+			return {
+				eventId: event.eventId,
+				queued: false,
+				reason: "validation_failed",
+				errors: validation.errors
+			};
+		}
+		if (serializedSize(event) + 2 > this.batch.maxBytes) {
+			this.log("too large");
+			return {
+				eventId: event.eventId,
+				queued: false,
+				reason: "payload_too_large",
+				errors: [{
+					field: "payload",
+					message: `serialized event exceeds ${this.batch.maxBytes} bytes`
+				}]
+			};
+		}
+		const entry = identity ? {
+			event,
+			identity
+		} : { event };
+		const dropped = this.queue.push(entry);
+		if (dropped > 0) this.log("queue full, dropped", dropped);
+		if (this.queue.length >= this.batch.size) this.flush();
+		else this.scheduleFlush();
+		return {
+			eventId: event.eventId,
+			queued: true
+		};
+	}
+	scheduleFlush() {
+		if (this.flushTimeout || this.closed) return;
+		this.flushTimeout = setTimeout(() => {
+			this.flushTimeout = null;
+			this.flush();
+		}, this.batch.intervalMs);
+	}
+	clearScheduledFlush() {
+		if (!this.flushTimeout) return;
+		clearTimeout(this.flushTimeout);
+		this.flushTimeout = null;
+	}
+	flush(options = {}) {
+		return options.drain ? this.flushAll(options) : this.flushExclusive(options);
+	}
+	flushOnSignal() {
+		this.queue.persistNow();
+		if (this.queue.length === 0 || this.consent.flushBlockReason()) return;
+		const lastChance = this.runtime.sendLastChance;
+		if (lastChance) {
+			const batch = this.queue.take(this.batch.size, KEEPALIVE_MAX_BYTES);
+			const body = JSON.stringify(batch.map((entry) => entry.event));
+			if (lastChance(this.transport.url, body, this.transport.headers(batch[0]?.identity))) {
+				this.queue.settle();
+				this.queue.persistNow();
+				if (this.queue.length > 0) this.flushOnSignal();
+				return;
+			}
+			this.queue.requeue(batch);
+		}
+		while (this.queue.length > 0) {
+			const batch = this.queue.take(this.batch.size, Math.min(this.batch.maxBytes, KEEPALIVE_MAX_BYTES));
+			const events = batch.map((entry) => entry.event);
+			const identity = this.identityFor(batch);
+			this.queue.settle();
+			this.transport.send(events, {
+				keepalive: true,
+				identity
+			}).catch((error) => {
+				this.log("keepalive failed", error);
+			});
+		}
+		this.queue.persistNow();
+	}
+	identityFor(batch) {
+		return batch[0]?.identity ?? { deviceId: this.deviceId };
+	}
+	flushExclusive(options) {
+		if (this.activeFlush) return this.activeFlush;
+		const activeFlush = this.flushOnce(options).finally(() => {
+			if (this.activeFlush === activeFlush) this.activeFlush = null;
+		});
+		this.activeFlush = activeFlush;
+		return activeFlush;
+	}
+	async flushAll(options) {
+		let sent = 0;
+		let failed = 0;
+		let status = "idle";
+		while (this.queue.length > 0) {
+			const pendingBefore = this.queue.length;
+			const result = await this.flushExclusive({
+				...options,
+				drain: true
+			});
+			sent += result.sent;
+			failed += result.failed;
+			status = result.status;
+			if (!(!this.lastFlushRequeued && (result.sent > 0 || this.queue.length < pendingBefore))) return {
+				status,
+				sent,
+				failed,
+				pending: result.pending
+			};
+		}
+		return {
+			status: sent > 0 ? "success" : status,
+			sent,
+			failed,
+			pending: this.queue.length
+		};
+	}
+	async flushOnce(options) {
+		if (this.queue.length === 0) {
+			this.clearScheduledFlush();
+			return {
+				status: "idle",
+				sent: 0,
+				failed: 0,
+				pending: 0
+			};
+		}
+		if (this.consent.flushBlockReason()) return {
+			status: "skipped",
+			sent: 0,
+			failed: 0,
+			pending: this.queue.length
+		};
+		if (!this.breaker.allowRequest()) {
+			this.log("breaker open");
+			return {
+				status: "skipped",
+				sent: 0,
+				failed: 0,
+				pending: this.queue.length
+			};
+		}
+		if (this.breaker.getState() === "half-open") this.log("breaker half-open");
+		const maxBytes = options.keepalive ? Math.min(this.batch.maxBytes, KEEPALIVE_MAX_BYTES) : this.batch.maxBytes;
+		const batch = this.queue.take(this.batch.size, maxBytes);
+		const events = batch.map((entry) => entry.event);
+		const identity = this.identityFor(batch);
+		const generation = this.generation;
+		this.lastFlushRequeued = false;
+		try {
+			const delivery = await withRetry(() => this.transport.send(events, {
+				...options,
+				identity
+			}), this.retry, { onRetry: (attempt, waitMs) => this.log("retry", attempt, Math.round(waitMs)) });
+			this.log("flushed", delivery.sent, delivery.failed);
+			if (delivery.session && !batch[0]?.identity) this.runtime.onSession?.(delivery.session);
+			if (this.breaker.getState() === "half-open") this.log("breaker closed");
+			this.breaker.recordSuccess();
+			this.queue.settle();
+			this.queue.persistNow();
+			this.continueOrSettle(options);
+			return {
+				status: delivery.failed > 0 ? "failed" : "success",
+				sent: delivery.sent,
+				failed: delivery.failed,
+				pending: this.queue.length
+			};
+		} catch (error) {
+			const preserve = error instanceof TransportError && error.preserveBatch;
+			if (!isRetryableTransportError(error) && !preserve) {
+				this.log("rejected", batch.length, error);
+				this.breaker.recordRejection();
+				this.queue.settle();
+				this.queue.persistNow();
+				this.continueOrSettle(options);
+				return {
+					status: "failed",
+					sent: 0,
+					failed: batch.length,
+					pending: this.queue.length
+				};
+			}
+			this.log("flush failed", error);
+			if (generation !== this.generation) {
+				this.queue.settle();
+				return {
+					status: "failed",
+					sent: 0,
+					failed: batch.length,
+					pending: this.queue.length
+				};
+			}
+			this.lastFlushRequeued = true;
+			this.queue.requeue(batch);
+			this.queue.persistNow();
+			if (!isRetryableTransportError(error)) return {
+				status: "failed",
+				sent: 0,
+				failed: batch.length,
+				pending: this.queue.length
+			};
+			if (this.breaker.recordFailure()) this.log("breaker opened");
+			return {
+				status: "failed",
+				sent: 0,
+				failed: batch.length,
+				pending: this.queue.length
+			};
+		}
+	}
+	continueOrSettle(options) {
+		if (!options.drain && this.queue.length > 0) this.scheduleFlush();
+		else if (this.queue.length === 0) this.clearScheduledFlush();
+	}
+	reset() {
+		this.generation += 1;
+		this.profileId = null;
+		this.globalProperties = {};
+		this.queue.clear();
+		this.queue.settle();
+		this.queue.persistNow();
+		const regenerate = this.runtime.regenerateDeviceId;
+		if (regenerate) this.deviceId = regenerate();
+		this.log("reset");
+	}
+	async close() {
+		this.closed = true;
+		this.removeFlushSignal?.();
+		this.removeFlushSignal = null;
+		this.clearScheduledFlush();
+		this.queue.dispose();
+		this.queue.persistNow();
+		const result = await this.flush({ drain: true });
+		this.clearScheduledFlush();
+		return result;
+	}
+};
+//#endregion
+//#region src/capture/exception-properties.ts
+const MAX_STACK_CHARS = 8e3;
+function describeErrorFlat(value, source) {
+	const path = typeof location !== "undefined" ? location.pathname : "";
+	const handled = source === "captureException";
+	if (value instanceof Error) return {
+		$exception_type: value.name || "Error",
+		$exception_message: value.message,
+		...value.stack ? { $exception_stack: value.stack.slice(0, MAX_STACK_CHARS) } : {},
+		$exception_source: source,
+		$exception_handled: handled,
+		path
+	};
+	return {
+		$exception_type: typeof value === "object" && value !== null ? "UnknownError" : typeof value,
+		$exception_message: safeString(value),
+		$exception_source: source,
+		$exception_handled: handled,
+		path
+	};
+}
+function safeString(value) {
+	try {
+		return typeof value === "string" ? value : JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+//#region src/steps.ts
+const MAX_STEPS = 20;
+const MAX_MESSAGE_CHARS = 200;
+const MAX_DATA_BYTES = 1024;
+const steps = [];
+function boundData(data) {
+	if (!data) return void 0;
+	try {
+		const json = JSON.stringify(data);
+		return json && json.length <= MAX_DATA_BYTES ? data : void 0;
+	} catch {
+		return;
+	}
+}
+function addExceptionStep(step) {
+	const data = boundData(step.data);
+	steps.push({
+		timestamp: Date.now(),
+		category: step.category,
+		message: step.message.slice(0, MAX_MESSAGE_CHARS),
+		...data ? { data } : {}
+	});
+	if (steps.length > MAX_STEPS) steps.splice(0, steps.length - MAX_STEPS);
+}
+function readExceptionSteps() {
+	return steps.slice();
+}
+//#endregion
+//#region src/capture/pageleave.ts
+var PageLeaveTracker = class {
+	current = null;
+	now;
+	constructor(now) {
+		this.now = now;
+	}
+	enter(path, origin, scrollDepth) {
+		const left = this.leave(scrollDepth);
+		this.current = {
+			path,
+			origin,
+			startedAt: this.now()
+		};
+		return left;
+	}
+	leave(scrollDepth) {
+		const page = this.current;
+		if (!page) return null;
+		this.current = null;
+		const seconds = Math.max(0, Math.round((this.now() - page.startedAt) / 1e3));
+		return {
+			path: page.path,
+			origin: page.origin,
+			duration: seconds,
+			...scrollDepth !== null ? {
+				scroll_depth: scrollDepth,
+				scroll_depth_bucket: (0, _reopt_ai_data_contract_events.scrollDepthBucket)(scrollDepth)
+			} : {}
+		};
+	}
+	resume() {}
+	peek() {
+		return this.current;
+	}
+};
+//#endregion
+//#region src/capture/scroll-depth.ts
+function currentDepth() {
+	if (typeof window === "undefined" || typeof document === "undefined") return null;
+	const root = document.documentElement;
+	const scrollable = Math.max(root.scrollHeight, document.body?.scrollHeight ?? 0) - window.innerHeight;
+	if (!Number.isFinite(scrollable) || scrollable <= 0) return 100;
+	const scrolled = window.scrollY ?? root.scrollTop ?? 0;
+	return Math.max(0, Math.min(100, Math.round(scrolled / scrollable * 100)));
+}
+function startScrollDepth() {
+	let max = null;
+	const sample = () => {
+		const depth = currentDepth();
+		if (depth !== null && (max === null || depth > max)) max = depth;
+	};
+	if (typeof window !== "undefined") {
+		window.addEventListener("scroll", sample, { passive: true });
+		window.addEventListener("resize", sample, { passive: true });
+	}
+	sample();
+	return {
+		read: () => {
+			sample();
+			return max;
+		},
+		reset: () => {
+			max = null;
+			sample();
+		},
+		stop: () => {
+			if (typeof window === "undefined") return;
+			window.removeEventListener("scroll", sample);
+			window.removeEventListener("resize", sample);
+		}
+	};
+}
+//#endregion
+//#region src/capture/utm.ts
+const UTM_KEYS = [
+	"utm_source",
+	"utm_medium",
+	"utm_campaign",
+	"utm_term",
+	"utm_content"
+];
+function extractUTMParams(search = typeof location !== "undefined" ? location.search : "") {
+	try {
+		const params = new URLSearchParams(search);
+		const utm = {};
+		for (const key of UTM_KEYS) {
+			const value = params.get(key);
+			if (value) utm[key] = value;
+		}
+		return utm;
+	} catch {
+		return {};
+	}
+}
+//#endregion
+//#region src/capture/web-vitals.ts
+function webVitalProperties(metric, path) {
+	return {
+		metric_name: metric.name,
+		metric_id: metric.id,
+		value: metric.value,
+		...metric.delta !== void 0 ? { delta: metric.delta } : {},
+		...metric.rating ? { rating: metric.rating } : {},
+		...metric.navigationType ? { navigation_type: metric.navigationType } : {},
+		path
+	};
+}
+//#endregion
+//#region src/config.ts
+function resolveCapture(config, pageviewDefault) {
+	return {
+		pageview: config?.pageview ?? pageviewDefault,
+		pageleave: config?.pageleave ?? true,
+		scrollDepth: config?.scrollDepth ?? true,
+		exceptions: config?.exceptions ?? false,
+		exceptionRateLimit: config?.exceptionRateLimit ?? {},
+		exceptionSteps: config?.exceptionSteps ?? false
+	};
+}
+function resolveTracingHosts(option) {
+	if (!option) return [];
+	if (Array.isArray(option)) return option;
+	if (typeof location === "undefined" || !location.hostname) return [];
+	return [location.hostname];
+}
+//#endregion
+//#region src/identity/cookie-storage.ts
+function readCookie(name) {
+	if (typeof document === "undefined") return null;
+	const prefix = `${name}=`;
+	for (const part of document.cookie.split(";")) {
+		const trimmed = part.trim();
+		if (trimmed.startsWith(prefix)) return trimmed.slice(prefix.length);
+	}
+	return null;
+}
+function writeCookie(name, value, options = {}) {
+	if (typeof document === "undefined") return;
+	let cookie = `${name}=${value}; Path=/; Max-Age=${options.maxAgeSeconds ?? _reopt_ai_data_contract_identity.COOKIE_MAX_AGE_SECONDS}; SameSite=Lax`;
+	if (options.domain) cookie += `; Domain=${options.domain}`;
+	if (typeof location !== "undefined" && location.protocol === "https:") cookie += "; Secure";
+	document.cookie = cookie;
+}
+function deleteCookie(name, options = {}) {
+	if (typeof document === "undefined") return;
+	let cookie = `${name}=; Path=/; Max-Age=0; SameSite=Lax`;
+	if (options.domain) cookie += `; Domain=${options.domain}`;
+	document.cookie = cookie;
+}
+function cookiesAvailable() {
+	if (typeof document === "undefined") return false;
+	try {
+		const probe = "reopt_probe";
+		document.cookie = `${probe}=1; Path=/; Max-Age=60; SameSite=Lax`;
+		const ok = readCookie(probe) === "1";
+		document.cookie = `${probe}=; Path=/; Max-Age=0; SameSite=Lax`;
+		return ok;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/identity/device.ts
+const LEGACY_DEVICE_KEY = "device_id";
+function localStorageBackend() {
+	try {
+		if (typeof window === "undefined" || !window.localStorage) return null;
+		const storage = window.localStorage;
+		const probe = "reopt_probe";
+		storage.setItem(probe, "1");
+		storage.removeItem(probe);
+		return storage;
+	} catch {
+		return null;
+	}
+}
+function makeStore(kind, writeKey, backend) {
+	const deviceName = (0, _reopt_ai_data_contract_identity.deviceCookieName)(writeKey);
+	const consentName = (0, _reopt_ai_data_contract_identity.consentCookieName)(writeKey);
+	const readConsent = () => (0, _reopt_ai_data_contract_identity.parseConsentCookie)(backend.getItem(consentName));
+	return {
+		kind,
+		readDevice: () => (0, _reopt_ai_data_contract_identity.parseDeviceCookie)(backend.getItem(deviceName)),
+		writeDevice: (state) => backend.setItem(deviceName, (0, _reopt_ai_data_contract_identity.serializeDeviceCookie)(state)),
+		clearDevice: () => backend.removeItem(deviceName),
+		readConsent,
+		writeConsent: (state) => backend.setItem(consentName, (0, _reopt_ai_data_contract_identity.serializeConsentCookie)(state)),
+		consentBackend: () => ({
+			getItem: () => {
+				const state = readConsent();
+				return state ? JSON.stringify(state) : null;
+			},
+			setItem: (_key, value) => backend.setItem(consentName, encodeURIComponent(value)),
+			removeItem: () => backend.removeItem(consentName)
+		})
+	};
+}
+function cookieBackend(cookie) {
+	return {
+		getItem: readCookie,
+		setItem: (name, value) => writeCookie(name, value, cookie),
+		removeItem: (name) => deleteCookie(name, cookie)
+	};
+}
+function createIdentityStore(writeKey, config) {
+	const kind = config?.storage ?? "auto";
+	const cookie = {
+		domain: config?.cookieDomain,
+		maxAgeSeconds: config?.cookieMaxAgeSeconds
+	};
+	if (kind === "cookie" || kind === "auto" && cookiesAvailable()) return makeStore("cookie", writeKey, cookieBackend(cookie));
+	const local = kind === "memory" ? null : localStorageBackend();
+	if (local) return makeStore("localStorage", writeKey, local);
+	return makeStore("memory", writeKey, memoryStorage());
+}
+function resolveDeviceId(store, bootstrapDeviceId, storagePrefix) {
+	const stored = store.readDevice();
+	if (stored) return {
+		deviceId: stored.deviceId,
+		source: "store"
+	};
+	if ((0, _reopt_ai_data_contract_identity.isValidIdentityId)(bootstrapDeviceId)) {
+		store.writeDevice({ deviceId: bootstrapDeviceId });
+		return {
+			deviceId: bootstrapDeviceId,
+			source: "bootstrap"
+		};
+	}
+	const local = localStorageBackend();
+	const legacy = local?.getItem(`${storagePrefix}${LEGACY_DEVICE_KEY}`);
+	if ((0, _reopt_ai_data_contract_identity.isValidIdentityId)(legacy)) {
+		store.writeDevice({ deviceId: legacy });
+		local?.removeItem(`${storagePrefix}${LEGACY_DEVICE_KEY}`);
+		return {
+			deviceId: legacy,
+			source: "legacy"
+		};
+	}
+	const generated = uuidv4();
+	store.writeDevice({ deviceId: generated });
+	return {
+		deviceId: generated,
+		source: "generated"
+	};
+}
+function regenerateDeviceId(store) {
+	const deviceId = uuidv4();
+	store.writeDevice({ deviceId });
+	return deviceId;
+}
+//#endregion
+//#region src/client.ts
+const CLOCK_SKEW_THRESHOLD_MS = 3e4;
+const MAX_CLOCK_SKEW_MS = 864e5;
+function routedStorage(consentKey, consent, rest) {
+	const pick = (key) => key === consentKey ? consent : rest;
+	return {
+		getItem: (key) => pick(key).getItem(key),
+		setItem: (key, value) => pick(key).setItem(key, value),
+		removeItem: (key) => pick(key).removeItem(key)
+	};
+}
+function normalizedPath(normalize, pathname) {
+	if (!normalize) return { path: pathname };
+	try {
+		const result = normalize(pathname);
+		if (typeof result === "string") return { path: result || pathname };
+		if (result && typeof result.path === "string" && result.path) return result;
+	} catch {}
+	return { path: pathname };
+}
+function pageContext(normalize) {
+	const hasWindow = typeof window !== "undefined";
+	const hasDocument = typeof document !== "undefined";
+	const normalized = normalizedPath(normalize, hasWindow ? window.location.pathname : "/");
+	return {
+		path: normalized.path,
+		origin: hasWindow ? window.location.origin : "",
+		title: hasDocument ? document.title : "",
+		referrer: hasDocument ? document.referrer : "",
+		utm: hasWindow ? extractUTMParams(window.location.search) : {},
+		...normalized.properties ? { properties: normalized.properties } : {}
+	};
+}
+const DISABLED_BASE_URL = "https://reopt.invalid";
+function readCaptureExceptionOptions(value) {
+	if (!value) return {};
+	if ("fingerprint" in value || "level" in value || "properties" in value) return value;
+	return { properties: value };
+}
+var ReoptClient = class extends ReoptCore {
+	writeKey;
+	capture;
+	store;
+	pageLeave;
+	scroll;
+	uninstallers = [];
+	torndown = false;
+	exceptionChunk;
+	exceptionChunkPromise;
+	session;
+	optedOut;
+	normalize;
+	observer;
+	disabled;
+	constructor(config, defaults = { pageview: true }) {
+		const disabled = !config.writeKey || !config.baseUrl;
+		if (disabled) console.warn(`[reopt] ${!config.writeKey ? "writeKey" : "baseUrl"} missing — analytics disabled`);
+		const writeKey = config.writeKey || "disabled";
+		const storagePrefix = config.storagePrefix ?? "reopt_";
+		const rawStore = createIdentityStore(writeKey, {
+			...config.identity,
+			...disabled ? { storage: "memory" } : {}
+		});
+		const optedOut = { value: (0, _reopt_ai_data_contract_identity.isOptedOut)(rawStore.readConsent() ?? config.bootstrap?.consent ?? null) || config.consent?.defaultConsent === false };
+		const store = {
+			...rawStore,
+			writeDevice: (state) => {
+				if (!optedOut.value) rawStore.writeDevice(state);
+			}
+		};
+		const identity = resolveDeviceId(store, config.bootstrap?.deviceId, storagePrefix);
+		const now = correctedClock(config.bootstrap);
+		const queueStorage = disabled ? memoryStorage() : config.queueStorage ?? localStorageBackend() ?? memoryStorage();
+		const transportFetch = config.fetch ?? (typeof window !== "undefined" ? window.fetch.bind(window) : void 0);
+		const box = {};
+		const session = { header: store.readDevice()?.sessionId ?? null };
+		const runtime = {
+			deviceId: identity.deviceId,
+			getSessionId: () => (0, _reopt_ai_data_contract_identity.parseSessionHeader)(session.header) ? session.header : null,
+			onSession: (credential) => {
+				session.header = (0, _reopt_ai_data_contract_identity.formatSessionHeader)(credential);
+				const current = store.readDevice();
+				store.writeDevice({
+					...current,
+					deviceId: current?.deviceId ?? identity.deviceId,
+					sessionId: session.header
+				});
+			},
+			storage: routedStorage(`${storagePrefix}consent`, store.consentBackend(), queueStorage),
+			now,
+			fetch: transportFetch,
+			getPageContext: () => pageContext(config.normalizePath),
+			regenerateDeviceId: () => regenerateDeviceId(store),
+			onFlushSignal: (flush) => {
+				if (typeof window === "undefined") return () => {};
+				const onHide = () => {
+					box.leave?.();
+					flush();
+				};
+				const onVisibility = () => {
+					if (document.visibilityState === "hidden") onHide();
+				};
+				window.addEventListener("pagehide", onHide);
+				document.addEventListener("visibilitychange", onVisibility);
+				return () => {
+					window.removeEventListener("pagehide", onHide);
+					document.removeEventListener("visibilitychange", onVisibility);
+				};
+			}
+		};
+		super({
+			auth: { writeKey },
+			baseUrl: disabled ? DISABLED_BASE_URL : config.baseUrl,
+			runtime,
+			debug: config.debug,
+			batch: config.batch,
+			maxQueueSize: config.maxQueueSize,
+			retry: config.retry,
+			circuitBreaker: config.circuitBreaker,
+			consent: config.consent,
+			storagePrefix
+		});
+		this.writeKey = config.writeKey;
+		this.disabled = disabled;
+		this.session = session;
+		this.optedOut = optedOut;
+		this.normalize = config.normalizePath;
+		this.store = store;
+		this.capture = resolveCapture(config.capture, defaults.pageview);
+		if (config.observe) {
+			const pending = [];
+			let sink = (fact) => pending.push(fact);
+			this.observer = (fact) => sink(fact);
+			Promise.resolve().then(() => require("./observe-D-BHMwrO.cjs")).then(({ createObservationSink }) => {
+				sink = createObservationSink(config.observe);
+				for (const fact of pending.splice(0)) sink(fact);
+			}).catch(() => {
+				pending.length = 0;
+			});
+		}
+		this.pageLeave = new PageLeaveTracker(now);
+		this.scroll = !disabled && this.capture.scrollDepth && typeof window !== "undefined" ? startScrollDepth() : null;
+		this.observe([
+			"config",
+			Date.now(),
+			disabled,
+			config.baseUrl,
+			Boolean(config.writeKey),
+			config.debug ?? false,
+			this.capture,
+			config.consent?.persist ?? true,
+			config.batch?.intervalMs ?? 1e3
+		]);
+		this.observeIdentity("initialized");
+		if (disabled) {
+			this.pauseTracking();
+			return;
+		}
+		if (config.properties) this.register(config.properties);
+		const release = (config.release ?? globalThis.__REOPT_RELEASE__)?.trim();
+		if (release) this.register({ $release_id: release });
+		box.leave = () => this.emitPageLeave();
+		this.log(`Device ${identity.deviceId} (${identity.source}, ${store.kind})`);
+		if (config.bootstrap?.consent && !store.readConsent() && Object.keys(config.bootstrap.consent).length > 0) this.replaceConsentState(config.bootstrap.consent);
+		const hosts = resolveTracingHosts(config.tracingHeaders);
+		if (hosts.length > 0) Promise.resolve().then(() => require("./tracing-DAhaKkl0.cjs")).then(({ installTracingHeaders }) => {
+			if (!this.torndown) this.uninstallers.push(installTracingHeaders({
+				hosts,
+				getDeviceId: () => this.getDeviceId()
+			}));
+		});
+		if (this.capture.exceptions) this.loadExceptionChunk().then((chunk) => {
+			if (!this.torndown) this.uninstallers.push(chunk.installExceptionCapture((properties) => this.trackException(properties), {
+				rateLimit: this.capture.exceptionRateLimit,
+				onThrottled: (type) => this.log(`exception rate limit reached for ${type} — further ones are dropped`)
+			}));
+		});
+		if (typeof document !== "undefined") {
+			const onVisible = () => {
+				if (document.visibilityState === "visible" && !this.pageLeave.peek()) {
+					const context = pageContext(this.normalize);
+					this.pageLeave.enter(context.path ?? "/", context.origin ?? "", null);
+					this.scroll?.reset();
+				}
+			};
+			document.addEventListener("visibilitychange", onVisible);
+			this.uninstallers.push(() => document.removeEventListener("visibilitychange", onVisible));
+		}
+		if (this.capture.pageview && typeof document !== "undefined") this.pageView();
+	}
+	get identityStorage() {
+		return this.store.kind;
+	}
+	observe(fact) {
+		this.observer?.(fact);
+	}
+	observeIdentity(action) {
+		this.observe([
+			"identity",
+			Date.now(),
+			action,
+			this.getDeviceId(),
+			this.getProfileId(),
+			this.store.kind
+		]);
+	}
+	observeEvent(eventType, name, result) {
+		if (this.disabled) return;
+		this.observe([
+			"event",
+			Date.now(),
+			eventType,
+			name,
+			result,
+			this.pending
+		]);
+	}
+	track(options) {
+		const result = super.track(options);
+		this.observeEvent("track", options.name, result);
+		return result;
+	}
+	pageView(options = {}) {
+		const context = pageContext(this.normalize);
+		const path = options.path ?? context.path ?? "/";
+		const origin = options.origin ?? context.origin ?? "";
+		if (this.capture.exceptionSteps) addExceptionStep({
+			category: "navigation",
+			message: path
+		});
+		if (this.capture.pageleave) {
+			const left = this.pageLeave.enter(path, origin, this.scroll?.read() ?? null);
+			if (left) this.track({
+				name: "$pageleave",
+				properties: left
+			});
+		}
+		this.scroll?.reset();
+		return super.pageView(options);
+	}
+	setConsent(category, allowed) {
+		super.setConsent(category, allowed);
+		this.syncOptOut();
+		this.observe([
+			"consent",
+			Date.now(),
+			category,
+			allowed
+		]);
+	}
+	setAllConsent(allowed) {
+		super.setAllConsent(allowed);
+		this.syncOptOut();
+		this.observe([
+			"consent",
+			Date.now(),
+			"all",
+			allowed
+		]);
+	}
+	replaceConsentState(state) {
+		super.replaceConsentState(state);
+		this.syncOptOut();
+		for (const [category, allowed] of Object.entries(state)) this.observe([
+			"consent",
+			Date.now(),
+			category,
+			allowed
+		]);
+	}
+	pauseTracking() {
+		super.pauseTracking();
+		this.observe([
+			"tracking",
+			Date.now(),
+			true
+		]);
+	}
+	resumeTracking() {
+		super.resumeTracking();
+		this.observe([
+			"tracking",
+			Date.now(),
+			false
+		]);
+	}
+	setProfileId(profileId) {
+		super.setProfileId(profileId);
+		this.observeIdentity("profile_changed");
+	}
+	syncOptOut() {
+		const now = (0, _reopt_ai_data_contract_identity.isOptedOut)(this.getConsentState());
+		if (now === this.optedOut.value) return;
+		this.optedOut.value = now;
+		if (now) {
+			this.store.clearDevice();
+			this.session.header = null;
+		} else this.store.writeDevice({ deviceId: this.getDeviceId() });
+	}
+	identify(options) {
+		const result = super.identify(options);
+		if (!options.identity && result.queued) this.store.writeDevice({
+			deviceId: this.getDeviceId(),
+			profileId: String(options.profileId)
+		});
+		this.observeEvent("identify", "identify", result);
+		this.observeIdentity("identified");
+		return result;
+	}
+	increment(options) {
+		const result = super.increment(options);
+		this.observeEvent("increment", "increment", result);
+		return result;
+	}
+	decrement(options) {
+		const result = super.decrement(options);
+		this.observeEvent("decrement", "decrement", result);
+		return result;
+	}
+	captureWebVital(metric) {
+		const { path, properties } = this.currentPath();
+		return this.track({
+			name: "$web_vitals",
+			properties: {
+				...properties,
+				...webVitalProperties(metric, path)
+			}
+		});
+	}
+	currentPath() {
+		return normalizedPath(this.normalize, typeof location !== "undefined" ? location.pathname : "/");
+	}
+	captureException(error, optionsOrProperties) {
+		const options = readCaptureExceptionOptions(optionsOrProperties);
+		const described = this.exceptionChunk ? this.exceptionChunk.describeError(error, "captureException") : describeErrorFlat(error, "captureException");
+		this.loadExceptionChunk();
+		const extra = { ...options?.properties };
+		if (options?.level) extra.$exception_level = options.level;
+		if (options?.fingerprint) extra.$exception_fingerprint = options.fingerprint;
+		return this.trackException({
+			...described,
+			...extra,
+			$exception_handled: true
+		});
+	}
+	addExceptionStep(step) {
+		addExceptionStep(step);
+	}
+	loadExceptionChunk() {
+		this.exceptionChunkPromise ??= Promise.resolve().then(() => require("./exceptions-CuhGo9A5.cjs")).then((chunk) => {
+			this.exceptionChunk = chunk;
+			return chunk;
+		});
+		return this.exceptionChunkPromise;
+	}
+	trackException(properties) {
+		const current = this.currentPath();
+		const steps = readExceptionSteps();
+		return this.track({
+			name: "$exception",
+			properties: {
+				...current.properties,
+				...properties,
+				...steps.length > 0 ? { $exception_steps: steps } : {},
+				path: current.path
+			}
+		});
+	}
+	emitPageLeave() {
+		if (!this.capture.pageleave) return;
+		const left = this.pageLeave.leave(this.scroll?.read() ?? null);
+		if (left) this.track({
+			name: "$pageleave",
+			properties: left
+		});
+	}
+	reset() {
+		super.reset();
+		this.session.header = null;
+		this.store.writeDevice({ deviceId: this.getDeviceId() });
+		this.observeIdentity("reset");
+	}
+	async close() {
+		this.torndown = true;
+		this.emitPageLeave();
+		this.scroll?.stop();
+		for (const uninstall of this.uninstallers.splice(0)) uninstall();
+		return super.close();
+	}
+};
+function correctedClock(bootstrap) {
+	if (!bootstrap || !Number.isFinite(bootstrap.serverTimeMs)) return () => Date.now();
+	const skew = bootstrap.serverTimeMs - Date.now();
+	if (Math.abs(skew) < CLOCK_SKEW_THRESHOLD_MS || Math.abs(skew) > MAX_CLOCK_SKEW_MS) return () => Date.now();
+	return () => Date.now() + skew;
+}
+function usableBootstrap(bootstrap) {
+	if (!bootstrap) return null;
+	if (bootstrap.deviceId && !(0, _reopt_ai_data_contract_identity.isValidIdentityId)(bootstrap.deviceId)) return {
+		...bootstrap,
+		deviceId: ""
+	};
+	return bootstrap;
+}
+//#endregion
+//#region src/registry.ts
+function registry() {
+	if (typeof window === "undefined") return null;
+	const holder = window;
+	if (!holder.__reopt) holder.__reopt = { clients: new Map() };
+	return holder.__reopt;
+}
+function getOrCreateClient(config, defaults) {
+	const store = registry();
+	const existing = store?.clients.get(config.writeKey);
+	if (existing) return existing;
+	const client = new ReoptClient({
+		...config,
+		bootstrap: usableBootstrap(config.bootstrap)
+	}, defaults);
+	store?.clients.set(config.writeKey, client);
+	return client;
+}
+function getClient(writeKey) {
+	const store = registry();
+	if (!store) return null;
+	if (writeKey) return store.clients.get(writeKey) ?? null;
+	const first = store.clients.values().next();
+	return first.done ? null : first.value;
+}
+function forgetClient(client) {
+	registry()?.clients.delete(client.writeKey);
+}
+//#endregion
+Object.defineProperty(exports, "MAX_STACK_CHARS", {
+	enumerable: true,
+	get: function() {
+		return MAX_STACK_CHARS;
+	}
+});
+Object.defineProperty(exports, "ReoptClient", {
+	enumerable: true,
+	get: function() {
+		return ReoptClient;
+	}
+});
+Object.defineProperty(exports, "extractUTMParams", {
+	enumerable: true,
+	get: function() {
+		return extractUTMParams;
+	}
+});
+Object.defineProperty(exports, "forgetClient", {
+	enumerable: true,
+	get: function() {
+		return forgetClient;
+	}
+});
+Object.defineProperty(exports, "getClient", {
+	enumerable: true,
+	get: function() {
+		return getClient;
+	}
+});
+Object.defineProperty(exports, "getOrCreateClient", {
+	enumerable: true,
+	get: function() {
+		return getOrCreateClient;
+	}
+});
+
+//# sourceMappingURL=registry-CGqrOtf4.cjs.map