@maple-dev/browser 0.3.0 → 0.4.0

package/dist/sink-DHTfvFgl.mjs

@@ -0,0 +1,1149 @@
+//#region ../browser-session/src/visitor.ts
+/**
+* A persistent per-browser visitor id.
+*
+* Sessions rotate after 30 minutes idle (see `session.ts`), which makes them
+* useless for "how many people visited" — every long gap mints a new one. The
+* visitor id is the stable identifier that `uniq(VisitorId)` counts, and the
+* only place that knows whether a visitor is new (a self-join against earlier
+* sessions is both a second full scan and wrong past the warehouse's 30-day
+* TTL, which drops the history the join would need).
+*
+* This is a first-party persistent identifier: it requires a cookie/consent
+* notice under ePrivacy, and it is the one thing here that `persistVisitorId:
+* false` and Global Privacy Control turn off.
+*
+* ## Why two stores
+*
+* The id lives in **both** localStorage and a cookie, the same hybrid posthog-js
+* uses for its `localStorage+cookie` persistence:
+*
+* - localStorage is the durable copy. Safari's ITP caps the lifetime of any
+*   cookie set from `document.cookie` at 7 days, so a cookie alone would silently
+*   turn returning visitors into new ones every week.
+* - The cookie is the *cross-subdomain carrier*. localStorage is origin-scoped,
+*   so a marketing site on `example.com` and an app on `app.example.com` can
+*   never see each other's id; a cookie scoped to the registered domain can.
+*   That is what links an anonymous pre-signup visit to the account it becomes.
+*
+* Reads prefer the cookie and mirror the winner back, so an existing
+* localStorage-only visitor converges onto the shared id instead of being reset.
+*
+* ## What is deliberately *not* shared
+*
+* The **session** id stays origin-scoped (sessionStorage, `session.ts`). Unlike
+* PostHog, our `session_replays` table is a ReplacingMergeTree keyed
+* `(OrgId, SessionId)` whose fields resolve by `argMax(field, Version)` over the
+* whole row — two origins posting different ServiceName/EntryPath under one
+* session id would overwrite each other rather than merge. Sessions stay
+* per-surface; `VisitorId` is the join key between them.
+*/
+const STORAGE_KEY$1 = "maple.visitor";
+/**
+* Cookie names cannot contain `.` per RFC 6265's token grammar, so this is not
+* simply `maple.visitor`.
+*/
+const COOKIE_NAME = "maple_visitor";
+/**
+* Match the ~13-month ceiling browsers and privacy regimes settled on for
+* first-party identifiers. Cheap to enforce from the start; retrofitting an
+* expiry onto ids already in the wild is not.
+*/
+const MAX_AGE_MS = 3456e7;
+let enabled = true;
+/** Memoized so the hot path never re-reads storage. */
+let cached;
+let persisted = false;
+let mintedThisLoad = false;
+/** Scope the cookie to the registered domain so subdomains share the id. */
+let crossSubdomainCookie = true;
+/** Explicit `Domain=` override; `""` forces a host-only cookie. */
+let cookieDomainOverride;
+/** Memoized probe result. `undefined` = not resolved yet. */
+let probedCookieDomain;
+/**
+* Apply the host app's cookie configuration. Called from `configurePrivacy`, so
+* both SDKs get it from the single call they already make.
+*
+* Like the consent gates, this only ever *tightens*: an app that initializes two
+* SDKs, only one of which passes a `privacy` block, must not have the other's
+* absent option widen the cookie back out to every subdomain.
+*
+* "Tighter" for `cookieDomain` means *narrower scope*, which is why this is not
+* first-write-wins: `""` (host-only) is the tightest value there is, and a
+* second SDK asking for it has to win over an earlier `"example.com"`. Between
+* two non-empty domains the shorter one is the broader — `example.com` covers
+* `app.example.com` and not the reverse — so the longer string wins.
+*/
+function configureVisitorCookie(options) {
+	if (options.crossSubdomainCookie === false) crossSubdomainCookie = false;
+	if (options.cookieDomain !== void 0) cookieDomainOverride = tighterCookieDomain(cookieDomainOverride, options.cookieDomain);
+	probedCookieDomain = void 0;
+}
+/** The narrower of two `Domain=` values, treating `undefined` as "unset". */
+function tighterCookieDomain(current, next) {
+	if (current === void 0) return next;
+	if (current === "" || next === "") return "";
+	return next.length > current.length ? next : current;
+}
+function readRawCookie(name) {
+	if (typeof document === "undefined") return void 0;
+	try {
+		for (const part of document.cookie.split(";")) {
+			const raw = part.trim();
+			if (!raw.startsWith(`${name}=`)) continue;
+			return decodeURIComponent(raw.slice(name.length + 1));
+		}
+	} catch {}
+}
+function setRawCookie(name, value, domain, maxAgeSeconds) {
+	if (typeof document === "undefined") return false;
+	const attributes = [
+		`${name}=${encodeURIComponent(value)}`,
+		"path=/",
+		`max-age=${Math.max(0, Math.floor(maxAgeSeconds))}`,
+		"SameSite=Lax"
+	];
+	if (domain) attributes.push(`domain=.${domain}`);
+	if (typeof location !== "undefined" && location.protocol === "https:") attributes.push("Secure");
+	try {
+		document.cookie = attributes.join("; ");
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* The broadest domain this browser will actually accept a cookie for, found by
+* probing rather than by carrying a public-suffix list — the same trick
+* posthog-js uses. Candidates start at the broadest (the last two labels) and
+* narrow a label at a time, with the first that sticks winning — so
+* `app.example.co.uk` tries the rejected `co.uk`, then lands on `example.co.uk`.
+*
+* Returns `""` (host-only cookie) for single-label hosts like `localhost` and
+* for bare IPs, neither of which can carry a `Domain=` attribute.
+*/
+function probeCookieDomain() {
+	if (typeof document === "undefined" || typeof location === "undefined") return "";
+	const hostname = location.hostname;
+	if (!hostname || /^[\d.]+$/.test(hostname) || hostname.includes(":")) return "";
+	const parts = hostname.split(".");
+	if (parts.length < 2) return "";
+	for (let i = parts.length - 2; i >= 0; i--) {
+		const candidate = parts.slice(i).join(".");
+		const probe = "__maple_probe";
+		if (setRawCookie(probe, "1", candidate, 60) && readRawCookie(probe) === "1") {
+			setRawCookie(probe, "", candidate, 0);
+			return candidate;
+		}
+	}
+	return "";
+}
+function cookieDomain() {
+	if (cookieDomainOverride !== void 0) return cookieDomainOverride;
+	if (!crossSubdomainCookie) return "";
+	if (probedCookieDomain === void 0) probedCookieDomain = probeCookieDomain();
+	return probedCookieDomain;
+}
+function parseRecord(raw) {
+	if (!raw) return void 0;
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.id !== "string" || typeof parsed.mintedAt !== "number") return void 0;
+		if (Date.now() - parsed.mintedAt > MAX_AGE_MS) return void 0;
+		return parsed;
+	} catch {
+		return;
+	}
+}
+function readFromStorage() {
+	try {
+		return parseRecord(window.localStorage.getItem(STORAGE_KEY$1) ?? void 0);
+	} catch {
+		return;
+	}
+}
+function readFromCookie() {
+	return parseRecord(readRawCookie(COOKIE_NAME));
+}
+function writeToStorage(record) {
+	try {
+		window.localStorage.setItem(STORAGE_KEY$1, JSON.stringify(record));
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Mirror the record into the cookie. The max-age is the id's *remaining* life,
+* not a fresh 400 days, so re-writing it on every page load can't turn the
+* expiry into a sliding window that never fires.
+*/
+function writeToCookie(record) {
+	const remainingMs = MAX_AGE_MS - (Date.now() - record.mintedAt);
+	if (remainingMs <= 0) return false;
+	return setRawCookie(COOKIE_NAME, JSON.stringify(record), cookieDomain(), remainingMs / 1e3);
+}
+function write(record) {
+	const inStorage = writeToStorage(record);
+	const inCookie = writeToCookie(record);
+	persisted = inStorage || inCookie;
+}
+/**
+* The current visitor id, minting one on first use. `undefined` when visitor
+* tracking is off or outside a browser.
+*/
+function getVisitorId() {
+	if (!enabled || typeof window === "undefined") return void 0;
+	if (cached) return cached.id;
+	const fromCookie = readFromCookie();
+	const fromStorage = readFromStorage();
+	const existing = fromCookie ?? fromStorage;
+	if (existing) {
+		cached = existing;
+		persisted = true;
+		if (!fromCookie) writeToCookie(existing);
+		if (!fromStorage || fromStorage.id !== existing.id) writeToStorage(existing);
+		return existing.id;
+	}
+	const record = {
+		id: crypto.randomUUID(),
+		mintedAt: Date.now()
+	};
+	cached = record;
+	mintedThisLoad = true;
+	write(record);
+	return record.id;
+}
+/**
+* Claim the "this visitor was minted just now" flag for the session being
+* created — drives new vs returning without a self-join. Reading it mints the
+* id if needed, so callers get an answer consistent with `getVisitorId()`.
+*
+* One-shot on purpose. The flag is page-load scoped, but sessions are not: a
+* page load can both start a session and (30 minutes idle later) rotate into a
+* second one, and only the first of those belongs to a new visitor. The
+* claimed value is persisted on the session record, which is also what keeps a
+* reload from re-answering the question — see `session.ts`.
+*/
+function claimNewVisitor() {
+	getVisitorId();
+	if (!mintedThisLoad) return false;
+	mintedThisLoad = false;
+	return true;
+}
+/**
+* Whether the id actually survives this page load. `false` means both stores
+* were blocked and the id is in-memory only, so uniques would be over-counted;
+* the metadata row carries this as `maple.visitor.persisted` so the analytics
+* layer can flag it rather than quietly inflate.
+*/
+function isVisitorIdPersisted() {
+	return persisted;
+}
+/**
+* Turn persistent visitor tracking on or off. Turning it off also purges any
+* id already stored — an opt-out that leaves the identifier behind is not one.
+*/
+function setVisitorTracking(nextEnabled) {
+	enabled = nextEnabled;
+	if (nextEnabled) return;
+	cached = void 0;
+	persisted = false;
+	mintedThisLoad = false;
+	try {
+		window.localStorage.removeItem(STORAGE_KEY$1);
+	} catch {}
+	const domain = cookieDomain();
+	setRawCookie(COOKIE_NAME, "", domain, 0);
+	if (domain) setRawCookie(COOKIE_NAME, "", "", 0);
+}
+//#endregion
+//#region ../browser-session/src/user-agent.ts
+let memo;
+/** Best-effort UA parse — enough to populate filterable session facets. */
+function parseUserAgent(ua) {
+	if (memo?.ua === ua) return memo.parsed;
+	const parsed = parse(ua);
+	memo = {
+		parsed,
+		ua
+	};
+	return parsed;
+}
+function parse(ua) {
+	return {
+		browserName: /edg/i.test(ua) ? "Edge" : /opr|opera/i.test(ua) ? "Opera" : /chrome|crios/i.test(ua) ? "Chrome" : /firefox|fxios/i.test(ua) ? "Firefox" : /safari/i.test(ua) ? "Safari" : "Unknown",
+		osName: /windows/i.test(ua) ? "Windows" : /iphone|ipad|ios/i.test(ua) ? "iOS" : /mac os|macintosh/i.test(ua) ? "macOS" : /android/i.test(ua) ? "Android" : /linux/i.test(ua) ? "Linux" : "Unknown",
+		deviceType: /mobile|iphone|android.*mobile/i.test(ua) ? "mobile" : /ipad|tablet/i.test(ua) ? "tablet" : "desktop"
+	};
+}
+//#endregion
+//#region ../browser-session/src/meta-row.ts
+/** ClickHouse-style `YYYY-MM-DD HH:MM:SS.mmm` in UTC (matches the ingest gateway). */
+function formatCHDateTime(date) {
+	const pad = (n, width = 2) => String(n).padStart(width, "0");
+	return `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())} ${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}.${pad(date.getUTCMilliseconds(), 3)}`;
+}
+/**
+* Build one `/v1/sessionReplays/meta` NDJSON row. Shared by `@maple-dev/browser`
+* and the Effect client SDK so a session looks identical no matter which SDK
+* posted it. UA/URL facets come from the live browser globals; absent (tests,
+* exotic embedders) they fall back to empty strings.
+*/
+function buildSessionMetaRow(input) {
+	const g = globalThis;
+	const userAgent = g["navigator"]?.userAgent ?? "";
+	const ua = parseUserAgent(userAgent);
+	const now = /* @__PURE__ */ new Date();
+	const location = g["window"]?.location;
+	const identity = input.identity;
+	const entryUrl = input.entry?.entryUrl ?? location?.href ?? "";
+	const referrer = input.entry?.referrer ?? "";
+	const utm = input.entry?.utm ?? {};
+	const row = {
+		session_id: input.sessionId,
+		start_time: formatCHDateTime(input.startedAt),
+		status: input.status,
+		version: input.version,
+		user_id: identity?.id ?? input.userId ?? "",
+		url_initial: location?.href ?? "",
+		user_agent: userAgent,
+		browser_name: ua.browserName,
+		os_name: ua.osName,
+		device_type: ua.deviceType,
+		service_name: input.serviceName,
+		resource_attributes: {
+			"maple.session.recorded": input.recorded ? "true" : "false",
+			...input.visitorId && input.visitorIdPersisted === false ? { "maple.visitor.persisted": "false" } : {},
+			...input.environment ? {
+				"deployment.environment": input.environment,
+				"deployment.environment.name": input.environment
+			} : {},
+			...input.serviceVersion ? { "deployment.commit_sha": input.serviceVersion } : {}
+		},
+		visitor_id: input.visitorId ?? "",
+		visitor_is_new: input.visitorIsNew ? 1 : 0,
+		user_email: (input.captureUserEmail === false ? void 0 : identity?.email) ?? "",
+		user_name: identity?.username ?? "",
+		group_id: identity?.groupId ?? "",
+		group_name: identity?.groupName ?? "",
+		user_traits: identity?.traits ?? {},
+		referrer,
+		utm_source: utm.utm_source ?? "",
+		utm_medium: utm.utm_medium ?? "",
+		utm_campaign: utm.utm_campaign ?? "",
+		utm_term: utm.utm_term ?? "",
+		utm_content: utm.utm_content ?? "",
+		host: location?.host ?? "",
+		entry_path: pathOf(entryUrl),
+		exit_path: pathOf(input.lastUrl ?? location?.href ?? ""),
+		language: g["navigator"]?.language ?? "",
+		last_activity_at: formatCHDateTime(now),
+		click_count: input.clickCount ?? 0,
+		page_views: input.pageViews ?? 0,
+		error_count: input.errorCount ?? 0
+	};
+	if (input.status === "ended") {
+		row.end_time = formatCHDateTime(now);
+		row.duration_ms = Math.max(0, now.getTime() - input.startedAt.getTime());
+		row.trace_ids = input.traceIds ? Array.from(input.traceIds) : [];
+	}
+	return row;
+}
+/**
+* Pathname of a URL, without query string or hash.
+*
+* Query strings are the most common accidental PII carrier (`?email=`,
+* `?token=`), and paths are the analytics dimension — nobody groups by
+* `/pricing?ref=twitter` separately from `/pricing`.
+*/
+function pathOf(url) {
+	if (!url) return "";
+	try {
+		return new URL(url).pathname;
+	} catch {
+		return "";
+	}
+}
+/** POST one session metadata row (NDJSON). Best-effort — never throws. */
+async function postSessionMetaRow(endpoint, ingestKey, row, keepalive = false) {
+	await fetch(`${endpoint.replace(/\/$/, "")}/v1/sessionReplays/meta`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${ingestKey}`,
+			"content-type": "application/x-ndjson"
+		},
+		body: `${JSON.stringify(row)}\n`,
+		keepalive
+	}).catch(() => {});
+}
+//#endregion
+//#region ../browser-session/src/replay/transport.ts
+let lastWarnAt = 0;
+function warnDropped(what, error) {
+	const now = Date.now();
+	if (now - lastWarnAt < 3e4) return;
+	lastWarnAt = now;
+	console.warn(`[maple] session replay ${what} failed (dropping; will retry on next chunk):`, error);
+}
+/** gzip a byte buffer using the native CompressionStream (no library). */
+async function gzip(bytes) {
+	const stream = new CompressionStream("gzip");
+	const writer = stream.writable.getWriter();
+	writer.write(bytes);
+	writer.close();
+	const buffer = await new Response(stream.readable).arrayBuffer();
+	return new Uint8Array(buffer);
+}
+/** POST session metadata (NDJSON, single row). `keepalive` for the final unload write. */
+async function postSessionMeta(config, row, keepalive = false) {
+	const body = `${JSON.stringify(row)}\n`;
+	await fetch(`${config.endpoint}/v1/sessionReplays/meta`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${config.ingestKey}`,
+			"content-type": "application/x-ndjson"
+		},
+		body,
+		keepalive
+	}).catch((error) => {
+		warnDropped("metadata POST", error);
+	});
+}
+/** POST distilled session events (NDJSON, one row per event). Best-effort. */
+async function postSessionEvents(config, rows, keepalive = false) {
+	if (rows.length === 0) return;
+	const body = `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`;
+	await fetch(`${config.endpoint}/v1/sessionEvents`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${config.ingestKey}`,
+			"content-type": "application/x-ndjson"
+		},
+		body,
+		keepalive
+	}).catch((error) => {
+		warnDropped("events POST", error);
+	});
+}
+/** PUT a gzipped rrweb event chunk. */
+async function postSessionBlob(config, meta, gzipped, keepalive = false) {
+	await fetch(`${config.endpoint}/v1/sessionReplays/blob`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${config.ingestKey}`,
+			"content-type": "application/octet-stream",
+			"x-maple-session-id": meta.sessionId,
+			"x-maple-chunk-seq": String(meta.chunkSeq),
+			"x-maple-is-checkpoint": meta.isCheckpoint ? "1" : "0",
+			"x-maple-event-count": String(meta.eventCount),
+			"x-maple-duration-ms": String(meta.durationMs)
+		},
+		body: gzipped,
+		keepalive
+	}).catch((error) => {
+		warnDropped("blob PUT", error);
+	});
+}
+//#endregion
+//#region ../browser-session/src/replay/util.ts
+/** Approximate byte size of an event for flush-threshold accounting. Falls back
+*  to a fixed estimate for values that can't be serialized (e.g. cycles). */
+function approximateSize(value) {
+	try {
+		return JSON.stringify(value).length;
+	} catch {
+		return 256;
+	}
+}
+//#endregion
+//#region ../browser-session/src/session.ts
+const STORAGE_KEY = "maple.session";
+/** Rotate the session after this much inactivity (PostHog's default). */
+const IDLE_TIMEOUT_MS = 18e5;
+/** Hard cap on a single session's lifetime regardless of activity. */
+const MAX_SESSION_MS = 864e5;
+/**
+* The activity path runs per span creation (`getSessionId`) and per captured
+* event (`markActivity` — every console call, keystroke, click, fetch);
+* persisting the bump on every call would hammer sessionStorage for no benefit
+* — rotation correctness only needs sub-idle-timeout granularity.
+*/
+const ACTIVITY_TOUCH_THROTTLE_MS = 5e3;
+const UTM_KEYS = [
+	"utm_source",
+	"utm_medium",
+	"utm_campaign",
+	"utm_term",
+	"utm_content"
+];
+/** In-memory fallback when sessionStorage is unavailable (private mode). */
+let ephemeral;
+const rotationListeners = /* @__PURE__ */ new Set();
+/**
+* Read the entry URL/referrer/UTM of the current page.
+*
+* Guarded for non-DOM runtimes: `freshRecord` is reachable from `getSessionId`
+* on the span path and from the `nextChunkSeq`/`nextMetaVersion` fallbacks, so
+* this must not assume `location`/`document` exist.
+*/
+function readEntryContext() {
+	if (typeof window === "undefined" || typeof location === "undefined") return {};
+	const utm = {};
+	try {
+		const params = new URLSearchParams(location.search);
+		for (const key of UTM_KEYS) {
+			const value = params.get(key)?.trim();
+			if (value) utm[key] = value.slice(0, 128);
+		}
+	} catch {}
+	return {
+		entryUrl: location.href,
+		entryReferrer: typeof document !== "undefined" ? document.referrer : "",
+		utm,
+		lastUrl: location.href,
+		pageViews: 0,
+		clickCount: 0,
+		errorCount: 0
+	};
+}
+function freshRecord(now) {
+	return {
+		id: crypto.randomUUID(),
+		startedAt: now,
+		lastActivityAt: now,
+		chunkSeq: 0,
+		metaVersion: 0,
+		visitorIsNew: claimNewVisitor(),
+		...readEntryContext()
+	};
+}
+function readRecord() {
+	try {
+		const raw = window.sessionStorage.getItem(STORAGE_KEY);
+		if (!raw) return void 0;
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.id === "string" && typeof parsed.startedAt === "number" && typeof parsed.lastActivityAt === "number" && typeof parsed.chunkSeq === "number") return parsed;
+		return;
+	} catch {
+		return ephemeral;
+	}
+}
+function writeRecord(record) {
+	ephemeral = record;
+	try {
+		window.sessionStorage.setItem(STORAGE_KEY, JSON.stringify(record));
+	} catch {}
+}
+function isSessionExpired(record, now = Date.now()) {
+	return now - record.lastActivityAt > IDLE_TIMEOUT_MS || now - record.startedAt > MAX_SESSION_MS;
+}
+/** Observe genuine idle/lifetime rotation. Invoked before the new record is installed. */
+function onSessionRotate(listener) {
+	rotationListeners.add(listener);
+	return () => rotationListeners.delete(listener);
+}
+/**
+* Upgrade an in-flight session written by an older SDK. The visitor feature
+* can land while a tab still has the old record in sessionStorage; claiming
+* newness here makes that current session the new visitor's session and
+* consumes the one-shot claim so a later idle rotation cannot steal it.
+*/
+function migrateRecord(record) {
+	return record.visitorIsNew === void 0 ? {
+		...record,
+		visitorIsNew: claimNewVisitor()
+	} : record;
+}
+function installRotatedRecord(previous, next) {
+	if (previous) for (const listener of rotationListeners) try {
+		listener(previous, next);
+	} catch {}
+	writeRecord(next);
+}
+/**
+* Resolve the active session, rotating to a fresh one if the previous session
+* has gone idle (or hit the lifetime cap). Touches `lastActivityAt` so calling
+* it on page load keeps a live session alive. The id is the correlation key
+* shared by OTel traces and replay events.
+*/
+function getSession() {
+	const now = Date.now();
+	const existing = readRecord();
+	if (existing && !isSessionExpired(existing, now)) {
+		const record = {
+			...migrateRecord(existing),
+			lastActivityAt: now
+		};
+		writeRecord(record);
+		return record;
+	}
+	const record = freshRecord(now);
+	installRotatedRecord(existing, record);
+	return record;
+}
+/** Force a new session boundary (used after a consent revoke/re-grant cycle). */
+function rotateSession() {
+	if (typeof window === "undefined") return void 0;
+	const previous = readRecord();
+	const next = freshRecord(Date.now());
+	installRotatedRecord(previous, next);
+	return next;
+}
+/**
+* Resolve the active session, rotating when the stored one has expired, and
+* persist the activity bump only once it has gone stale by
+* `ACTIVITY_TOUCH_THROTTLE_MS`. Shared by the two hot-path entry points so a
+* chatty page doesn't pay a sessionStorage read *and* write per span/event.
+*/
+function touchSession(now) {
+	const existing = readRecord();
+	if (existing && !isSessionExpired(existing, now)) {
+		const migrated = migrateRecord(existing);
+		const touched = {
+			...migrated,
+			lastActivityAt: now
+		};
+		if (migrated !== existing || now - existing.lastActivityAt > ACTIVITY_TOUCH_THROTTLE_MS) writeRecord(touched);
+		return touched;
+	}
+	const record = freshRecord(now);
+	installRotatedRecord(existing, record);
+	return record;
+}
+/**
+* Mark activity, rotating first when the stored session has expired. Called per
+* captured event, so it shares `getSessionId`'s throttled touch — callers read
+* the returned record's `id` to detect that rotation.
+*/
+function markActivity() {
+	if (typeof window === "undefined") return void 0;
+	return touchSession(Date.now());
+}
+/**
+* Record a page view. Persisted on the session record rather than held in the
+* capture loop's memory so the count survives reloads within the session — a
+* two-page visit split by a refresh is not a bounce.
+*/
+function noteNavigation(url) {
+	if (typeof window === "undefined") return;
+	const now = Date.now();
+	const record = touchSession(now);
+	writeRecord({
+		...record,
+		lastUrl: url,
+		pageViews: (record.pageViews ?? 0) + 1,
+		lastActivityAt: now
+	});
+}
+/** Accumulate interaction/error counts onto the persisted session record. */
+function noteCounts(counts) {
+	const record = readRecord();
+	if (!record) return;
+	writeRecord({
+		...record,
+		clickCount: counts.clickCount ?? record.clickCount ?? 0,
+		errorCount: counts.errorCount ?? record.errorCount ?? 0
+	});
+}
+/**
+* The persisted session record as-is — no activity touch, no rotation. Use
+* this to read counters when posting a metadata row; `getSession()` would
+* rotate an idle session out from under the row being written.
+*/
+function peekSession() {
+	return readRecord();
+}
+/**
+* The acquisition context carried by a record. Takes the record rather than
+* re-reading storage, because every caller already holds one — the metadata
+* lifecycle posts from it.
+*/
+function entryContextOf(record) {
+	return {
+		entryUrl: record.entryUrl ?? "",
+		referrer: record.entryReferrer ?? "",
+		utm: record.utm ?? {}
+	};
+}
+/**
+* Take the next replay chunk sequence number for the current session. Monotonic
+* across reloads (persisted on the session record), so a refresh continues the
+* sequence instead of restarting at 0 and overwriting the previous load's blobs.
+*/
+function nextChunkSeq() {
+	const record = readRecord() ?? freshRecord(Date.now());
+	const seq = record.chunkSeq;
+	writeRecord({
+		...record,
+		chunkSeq: seq + 1
+	});
+	return seq;
+}
+/**
+* Take the next session-metadata row version for the current session.
+* Monotonic per session across reloads, hide/resume cycles, and writers (both
+* SDKs share the persisted counter), so `argMax(field, Version)` on the
+* backend always resolves to the most recently posted row. Records written by
+* older SDKs (no `metaVersion`) already posted versions 1 and 2, so the
+* counter resumes at 3 for them; a fresh session starts at 1.
+*/
+function nextMetaVersion() {
+	const record = readRecord() ?? freshRecord(Date.now());
+	const version = (record.metaVersion ?? 2) + 1;
+	writeRecord({
+		...record,
+		metaVersion: version
+	});
+	return version;
+}
+//#endregion
+//#region ../browser-session/src/events-sink.ts
+const FLUSH_INTERVAL_MS = 5e3;
+const FLUSH_BYTES = 65536;
+const ZERO_TRACE_ID = "00000000000000000000000000000000";
+let traceIdProvider = () => void 0;
+/** Wire the host SDK's active-trace-id lookup into event capture. */
+function setActiveTraceIdProvider(provider) {
+	traceIdProvider = provider;
+}
+/** The trace id of the active span, or undefined when none is active. */
+function activeTraceId() {
+	const id = traceIdProvider();
+	return id && id !== ZERO_TRACE_ID ? id : void 0;
+}
+/**
+* The sink is a per-session singleton, published on `globalThis` rather than a
+* module-level variable.
+*
+* Two consumers can end up with separate copies of this module in one page (an
+* app bundling both `@maple-dev/browser` and the Effect SDK, or a
+* lazily-imported replay chunk). Two sinks would mean two `seq` counters
+* starting at 0, and `Seq` is part of the `session_events` sorting key — the
+* rows would collide. One global owner avoids that.
+*/
+const SINK_KEY = "__MAPLE_SESSION_EVENT_SINK__";
+function holder() {
+	return globalThis;
+}
+/** The live sink, if one has been started. */
+function getActiveSink() {
+	return holder()[SINK_KEY]?.sink;
+}
+/**
+* Start (or reuse) the distilled-event sink for a session.
+*
+* Runs on **every** page load, not just sampled-for-replay ones: page views and
+* `track()` calls are the analytics substrate, and gating them behind replay
+* sampling would make unique visitors and top pages a sample rather than a
+* count. The rrweb recorder stays sampled — it is the expensive part.
+*/
+function startEventSink(config, sessionId) {
+	const existing = holder()[SINK_KEY];
+	if (existing && existing.sessionId === sessionId) return existing.sink;
+	if (existing) {
+		existing.sink.flush();
+		existing.sink.stop();
+	}
+	let buffer = [];
+	let bufferBytes = 0;
+	let seq = 0;
+	let pageViews = 0;
+	let clickCount = 0;
+	let errorCount = 0;
+	const flush = async (keepalive = false) => {
+		if (buffer.length === 0) return;
+		const batch = buffer;
+		buffer = [];
+		bufferBytes = 0;
+		await postSessionEvents(config, batch.map(({ ev, seq }) => toRow(sessionId, ev, seq)), keepalive);
+	};
+	const emit = (ev) => {
+		const session = markActivity();
+		if (session && session.id !== sessionId) {
+			const nextSink = startEventSink(config, session.id);
+			if (ev.type !== "navigation") nextSink.emit(ev);
+			return;
+		}
+		if (ev.type === "navigation") {
+			pageViews++;
+			noteNavigation(ev.url ?? (typeof location !== "undefined" ? location.href : ""));
+		} else if (ev.type === "click") clickCount++;
+		else if (ev.type === "error" || ev.type === "console" && ev.level === "error") errorCount++;
+		buffer.push({
+			ev,
+			seq: seq++
+		});
+		bufferBytes += approximateSize(ev);
+		if (bufferBytes >= FLUSH_BYTES) flush();
+	};
+	const stopNavigation = installNavigationObserver((url) => {
+		emit({
+			type: "navigation",
+			url
+		});
+	});
+	const flushTimer = setInterval(() => void flush(), FLUSH_INTERVAL_MS);
+	const sink = {
+		sessionId,
+		emit,
+		flush,
+		stop: () => {
+			clearInterval(flushTimer);
+			stopNavigation();
+			if (holder()[SINK_KEY]?.sink === sink) holder()[SINK_KEY] = void 0;
+		},
+		getPageViews: () => pageViews,
+		getClickCount: () => clickCount,
+		getErrorCount: () => errorCount,
+		ignoreUrl: (url) => url.startsWith(`${config.endpoint}/v1/`)
+	};
+	holder()[SINK_KEY] = {
+		sessionId,
+		sink
+	};
+	drainPending(sink);
+	return sink;
+}
+/**
+* Watch page views: the initial load plus every SPA navigation (history
+* pushState/replaceState, popstate, hashchange).
+*/
+function installNavigationObserver(onNavigate) {
+	if (typeof window === "undefined" || typeof history === "undefined") return () => {};
+	let lastUrl = "";
+	const emitNav = () => {
+		const url = location.href;
+		if (url === lastUrl) return;
+		lastUrl = url;
+		onNavigate(url);
+	};
+	emitNav();
+	const origPush = history.pushState;
+	const origReplace = history.replaceState;
+	history.pushState = function(...args) {
+		const result = origPush.apply(this, args);
+		emitNav();
+		return result;
+	};
+	history.replaceState = function(...args) {
+		const result = origReplace.apply(this, args);
+		emitNav();
+		return result;
+	};
+	window.addEventListener("popstate", emitNav);
+	window.addEventListener("hashchange", emitNav);
+	return () => {
+		history.pushState = origPush;
+		history.replaceState = origReplace;
+		window.removeEventListener("popstate", emitNav);
+		window.removeEventListener("hashchange", emitNav);
+	};
+}
+const PENDING_KEY = "__MAPLE_SESSION_EVENT_PENDING__";
+const MAX_PENDING_EVENTS = 100;
+const MAX_PENDING_BYTES = 65536;
+function pending() {
+	const global = globalThis;
+	let state = global[PENDING_KEY];
+	if (!state) {
+		state = {
+			events: [],
+			bytes: 0,
+			warned: false
+		};
+		global[PENDING_KEY] = state;
+	}
+	return state;
+}
+/**
+* Buffer an event until a sink exists. Drops oldest-first at the cap: an app
+* that calls `track()` in a loop before init should not be able to grow this
+* without bound.
+*/
+function queuePending(ev) {
+	const state = pending();
+	state.events.push(ev);
+	state.bytes += approximateSize(ev);
+	while (state.events.length > MAX_PENDING_EVENTS || state.bytes > MAX_PENDING_BYTES && state.events.length > 1) {
+		const dropped = state.events.shift();
+		if (!dropped) break;
+		state.bytes -= approximateSize(dropped);
+		if (!state.warned) {
+			state.warned = true;
+			console.warn("[maple] dropping session events queued before init — call Maple.init/identify earlier, or track() less before the SDK is ready.");
+		}
+	}
+}
+/** Discard events captured before a consent-gated SDK was configured. */
+function clearPendingEvents() {
+	const state = pending();
+	state.events = [];
+	state.bytes = 0;
+}
+/** Hand everything queued before init to the sink, oldest first. */
+function drainPending(sink) {
+	const state = pending();
+	if (state.events.length === 0) return;
+	const queued = state.events;
+	state.events = [];
+	state.bytes = 0;
+	for (const ev of queued) sink.emit(ev);
+}
+/** Map an internal event to the snake_case ingest row (org_id is added server-side). */
+function toRow(sessionId, ev, seq) {
+	return {
+		session_id: sessionId,
+		timestamp: formatCHDateTime(new Date(ev.timestamp ?? Date.now())),
+		seq,
+		type: ev.type,
+		url: ev.url ?? (typeof location !== "undefined" ? location.href : ""),
+		trace_id: ev.traceId ?? activeTraceId() ?? "",
+		level: ev.level ?? "",
+		message: ev.message ?? "",
+		target_selector: ev.targetSelector ?? "",
+		target_text: ev.targetText ?? "",
+		net_method: ev.net?.method ?? "",
+		net_url: ev.net?.url ?? "",
+		net_status: ev.net?.status ?? 0,
+		net_duration_ms: ev.net?.durationMs ?? 0,
+		error_stack: ev.errorStack ?? "",
+		attributes: ev.attrs ?? {}
+	};
+}
+//#endregion
+//#region ../browser-session/src/session-lifecycle.ts
+/**
+* How often a visible tab re-posts its `active` row.
+*
+* This is what makes exit page, page views and duration survive a tab killed
+* without an unload beacon — otherwise the only surviving row is the v1 row
+* posted at session start, whose counters are all zero and therefore read as a
+* bounce. 60s is the floor worth using: the table is a ReplacingMergeTree, so
+* every heartbeat is an unmerged part until the next merge. Billing meters only
+* `version == 1` rows, so heartbeats do not double-bill.
+*/
+const HEARTBEAT_INTERVAL_MS = 6e4;
+/**
+* Drive one session's metadata lifecycle. Returns undefined outside a browser;
+* sampling and consent are the caller's decisions.
+*/
+function startSessionLifecycle(options, hooks) {
+	if (typeof window === "undefined") return void 0;
+	let current = getSession();
+	let stopped = false;
+	/** Whether a run is live: capture started, `active` posted, heartbeat armed. */
+	let running = false;
+	let heartbeat;
+	let clickCountBase = 0;
+	let errorCountBase = 0;
+	let sinkClickCountAtStart = 0;
+	let sinkErrorCountAtStart = 0;
+	/**
+	* The persisted record of the session this lifecycle owns.
+	*
+	* `current` fixes only the identity of the run — counters, `lastUrl` and
+	* `lastActivityAt` move underneath it as the page is used, so a row built
+	* from the captured object alone reports the exit path and page views of the
+	* session's *first* page forever. Reading storage back per row keeps them
+	* live, and the id check keeps a rotation from attributing the incoming
+	* session's context to the outgoing session's `ended` row.
+	*/
+	const liveRecord = () => {
+		const stored = peekSession();
+		return stored?.id === current.id ? stored : current;
+	};
+	/**
+	* Re-baseline the cumulative counters against the persisted record.
+	*
+	* The record is what carries counts across a reload and across a hide/resume
+	* cycle (each `ended` row writes them back via `noteCounts`), while live
+	* capture restarts from zero every run — so a run's row is the persisted base
+	* plus what capture has seen since this run began.
+	*/
+	const rebaseCounts = (record) => {
+		clickCountBase = record.clickCount ?? 0;
+		errorCountBase = record.errorCount ?? 0;
+		const sink = getActiveSink();
+		sinkClickCountAtStart = sink?.getClickCount() ?? 0;
+		sinkErrorCountAtStart = sink?.getErrorCount() ?? 0;
+	};
+	const countsFor = (record) => {
+		const sink = getActiveSink();
+		const sinkMatches = sink !== void 0 && sink.sessionId === record.id;
+		const clicks = hooks.clicksSinceStart?.() ?? (sinkMatches ? sink.getClickCount() - sinkClickCountAtStart : 0);
+		const errors = sinkMatches ? sink.getErrorCount() - sinkErrorCountAtStart : 0;
+		const counts = {
+			clickCount: clickCountBase + Math.max(0, clicks),
+			errorCount: errorCountBase + Math.max(0, errors),
+			pageViews: record.pageViews ?? (sinkMatches ? sink.getPageViews() : 0)
+		};
+		if (peekSession()?.id === record.id) noteCounts({
+			clickCount: counts.clickCount,
+			errorCount: counts.errorCount
+		});
+		return counts;
+	};
+	const post = (status, keepalive) => {
+		const record = liveRecord();
+		const counts = countsFor(record);
+		hooks.post(buildSessionMetaRow({
+			sessionId: record.id,
+			startedAt: new Date(record.startedAt),
+			version: nextMetaVersion(),
+			status,
+			serviceName: options.serviceName,
+			identity: options.getIdentity?.(),
+			captureUserEmail: options.captureUserEmail,
+			environment: options.environment,
+			serviceVersion: options.serviceVersion,
+			visitorId: getVisitorId(),
+			visitorIsNew: record.visitorIsNew === true,
+			visitorIdPersisted: isVisitorIdPersisted(),
+			entry: entryContextOf(record),
+			lastUrl: record.lastUrl,
+			clickCount: counts.clickCount,
+			pageViews: counts.pageViews,
+			errorCount: counts.errorCount,
+			traceIds: status === "ended" ? options.getTraceIds?.(record.id) : void 0,
+			recorded: hooks.recorded
+		}), keepalive);
+	};
+	const stopHeartbeat = () => {
+		if (heartbeat === void 0) return;
+		clearInterval(heartbeat);
+		heartbeat = void 0;
+	};
+	const startRun = () => {
+		if (stopped || running) return;
+		running = true;
+		const record = liveRecord();
+		rebaseCounts(record);
+		hooks.onStart?.(record);
+		post("active", false);
+		heartbeat = setInterval(() => {
+			if (typeof document !== "undefined" && document.visibilityState !== "visible") return;
+			if (isSessionExpired(liveRecord())) {
+				endRun({
+					flush: true,
+					keepalive: false
+				});
+				return;
+			}
+			post("active", false);
+		}, HEARTBEAT_INTERVAL_MS);
+	};
+	const endRun = (suspend) => {
+		if (!running) return;
+		running = false;
+		stopHeartbeat();
+		if (suspend.flush) post("ended", suspend.keepalive);
+		return hooks.onSuspend?.(suspend);
+	};
+	const stopRotationListener = onSessionRotate((previous, next) => {
+		if (stopped || previous.id !== current.id) return;
+		endRun({
+			flush: true,
+			keepalive: false
+		});
+		current = next;
+		hooks.onSessionChange?.(next.id);
+		queueMicrotask(() => startRun());
+	});
+	const onPageHide = () => void endRun({
+		flush: true,
+		keepalive: true
+	});
+	const onVisibilityChange = () => {
+		const doc = globalThis["document"];
+		if (!doc) return;
+		if (doc.visibilityState === "hidden") {
+			endRun({
+				flush: true,
+				keepalive: true
+			});
+			return;
+		}
+		if (isSessionExpired(liveRecord())) {
+			getSession();
+			return;
+		}
+		startRun();
+	};
+	const visibilityTarget = typeof document !== "undefined" && typeof document.addEventListener === "function" ? document : typeof globalThis.addEventListener === "function" ? globalThis : void 0;
+	const pageHideTarget = typeof globalThis.addEventListener === "function" ? globalThis : void 0;
+	startRun();
+	visibilityTarget?.addEventListener("visibilitychange", onVisibilityChange);
+	pageHideTarget?.addEventListener("pagehide", onPageHide);
+	return {
+		get sessionId() {
+			return current.id;
+		},
+		shutdown: async (shutdownOptions) => {
+			if (stopped) return;
+			stopped = true;
+			stopRotationListener();
+			visibilityTarget?.removeEventListener("visibilitychange", onVisibilityChange);
+			pageHideTarget?.removeEventListener("pagehide", onPageHide);
+			const flush = shutdownOptions?.flush ?? true;
+			await endRun({
+				flush,
+				keepalive: flush
+			});
+		}
+	};
+}
+//#endregion
+//#region ../browser-session/src/sink.ts
+const SESSION_SINK_KEY = "__MAPLE_BROWSER_SESSION__";
+const observedTraceIdsBySession = /* @__PURE__ */ new Map();
+/** Record a trace id seen during the session. Idempotent per id. */
+function recordTraceId(traceId, sessionId = readSessionSink()?.sessionId) {
+	if (!sessionId) return;
+	let ids = observedTraceIdsBySession.get(sessionId);
+	if (!ids) {
+		ids = /* @__PURE__ */ new Set();
+		observedTraceIdsBySession.set(sessionId, ids);
+	}
+	ids.add(traceId);
+}
+function getObservedTraceIds(sessionId = readSessionSink()?.sessionId) {
+	return sessionId ? Array.from(observedTraceIdsBySession.get(sessionId) ?? []) : [];
+}
+/**
+* Drop the trace ids of every session but `sessionId`. Called when the sink is
+* republished under a rotated id — the outgoing session's `ended` row, the only
+* reader of its ids, has already been built by then. Without this a tab left
+* open for a day accumulates one id Set per 30-minute rotation, forever.
+*/
+function forgetOtherSessions(sessionId) {
+	for (const key of observedTraceIdsBySession.keys()) if (key !== sessionId) observedTraceIdsBySession.delete(key);
+}
+/**
+* Publish the session sink on `globalThis` so other tracers in the page can
+* attach their trace ids to the active replay session without a direct
+* dependency on the publishing SDK. Reads are lazy/per-span on the consumer
+* side, so init ordering between SDKs does not matter.
+*/
+function publishSessionSink(sessionId) {
+	globalThis[SESSION_SINK_KEY] = {
+		sessionId,
+		recordTraceId: (traceId) => recordTraceId(traceId, sessionId)
+	};
+	forgetOtherSessions(sessionId);
+}
+/** Remove a sink published by this SDK runtime without clobbering a newer one. */
+function clearSessionSink(sessionId) {
+	const owner = globalThis;
+	const current = owner[SESSION_SINK_KEY];
+	if (!current || sessionId !== void 0 && current.sessionId !== sessionId) return;
+	delete owner[SESSION_SINK_KEY];
+	observedTraceIdsBySession.delete(current.sessionId);
+}
+/** Look up the published sink, if any page-level replay session is active. */
+function readSessionSink() {
+	return globalThis[SESSION_SINK_KEY];
+}
+//#endregion
+export { setVisitorTracking as S, gzip as _, recordTraceId as a, postSessionMetaRow as b, clearPendingEvents as c, setActiveTraceIdProvider as d, startEventSink as f, rotateSession as g, nextChunkSeq as h, readSessionSink as i, getActiveSink as l, markActivity as m, getObservedTraceIds as n, startSessionLifecycle as o, getSession as p, publishSessionSink as r, activeTraceId as s, clearSessionSink as t, queuePending as u, postSessionBlob as v, configureVisitorCookie as x, postSessionMeta as y };