@clue-ai/browser-sdk 0.0.1

package/dist/core/sdk.js

@@ -0,0 +1,831 @@
+import { resolveAuthoringBaseEndpoint, startBusinessEventAuthoringOverlay, } from "../authoring/overlay";
+import { createAuthoringRecordingController } from "../authoring/recording";
+import { readPersistedBusinessEventAuthoringToken } from "../authoring/session";
+import { isWithinAuthoringSurface } from "../authoring/surface";
+import { startActionCapture } from "../capture/action";
+import { startDragCapture } from "../capture/drag";
+import { startErrorCapture } from "../capture/error";
+import { startFormCapture } from "../capture/form";
+import { startFrustrationCapture } from "../capture/frustration";
+import { startInputCapture } from "../capture/input";
+import { startNavigationCapture } from "../capture/navigation";
+import { startNetworkCapture } from "../capture/network";
+import { startPageCapture } from "../capture/page";
+import { startPerformanceCapture } from "../capture/performance";
+import { AccountManager } from "../context/account";
+import { EnvironmentManager } from "../context/environment";
+import { IdentityManager } from "../context/identity";
+import { SessionManager } from "../context/session";
+import { TabManager } from "../context/tab";
+import { TraceManager } from "../context/trace";
+import { InternalMetricsStore } from "../internal/metrics";
+import { buildCanonicalEvent, buildDegradedCanonicalCandidates, } from "../normalize/builders";
+import { generateViewId } from "../normalize/event-id";
+import { BatchTransport } from "../transport/batch";
+import { IngestClient } from "../transport/client";
+import { isConfigValid, resolveConfig, validateConfig } from "./config";
+import { DEFAULT_CONSENT, DEFAULT_INTERACTION_PROPAGATION_WINDOW_MS, DEFAULT_MAX_BATCH_QUEUE_BYTES, SDK_VERSION, } from "./constants";
+import { FRONTEND_EVENT_CATEGORY, FRONTEND_EVENT_NAME } from "./contracts";
+import { DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK, hasUsageGovernorFeedbackChanged, isCostCapabilityDisabled, normalizeIngestUsageGovernorFeedback, } from "./usage-governor";
+const TRACE_ROOT_EVENTS = new Set([
+    "page_view",
+    "route_change",
+    "element_clicked",
+    "form_submitted",
+    "input_committed",
+    "toggle_changed",
+    "selection_committed",
+    "file_selected",
+    "drag_drop_completed",
+    "custom_emitted",
+]);
+const INTERACTION_ANCHOR_EVENTS = new Set([
+    "element_clicked",
+    "form_submitted",
+    "input_committed",
+    "toggle_changed",
+    "selection_committed",
+    "file_selected",
+    "drag_drop_completed",
+    "custom_emitted",
+]);
+const OFFICIAL_CUSTOM_EVENT_NAME = {
+    accountAssociated: "account_associated",
+    identityIdentified: "identity_identified",
+    identityLoggedOut: "identity_logged_out",
+    sdkInitialized: "sdk_initialized",
+};
+const OFFICIAL_CUSTOM_EVENT_NAMES = new Set(Object.values(OFFICIAL_CUSTOM_EVENT_NAME));
+const SUMMARY_EVENT_NAMES = new Set([
+    FRONTEND_EVENT_NAME.performanceSummaryObserved,
+    FRONTEND_EVENT_NAME.browserReportSummaryObserved,
+    FRONTEND_EVENT_NAME.uiLifecycleSummaryObserved,
+    FRONTEND_EVENT_NAME.streamLifecycleSummaryObserved,
+]);
+const createNoopLogger = () => {
+    return {
+        debug: () => undefined,
+        warn: () => undefined,
+        error: () => undefined,
+    };
+};
+const hasBusinessEventAuthoringToken = () => {
+    if (typeof window === "undefined") {
+        return false;
+    }
+    return readPersistedBusinessEventAuthoringToken() !== null;
+};
+const resolveEffectiveBatchConfig = (config) => {
+    if (hasBusinessEventAuthoringToken()) {
+        return {
+            ...config.batch,
+            transportProfile: "authoring_realtime",
+        };
+    }
+    if (config.transportProfile === "authoring_realtime") {
+        return {
+            ...config.batch,
+            transportProfile: "authoring_realtime",
+        };
+    }
+    return {
+        ...config.batch,
+        transportProfile: "standard",
+    };
+};
+const toStringOrNull = (value) => {
+    return typeof value === "string" ? value : null;
+};
+const isOfficialCustomLifecycleEvent = (event) => {
+    if (event.type !== "custom_emitted") {
+        return false;
+    }
+    const customEventName = event.payload.eventName;
+    return (typeof customEventName === "string" &&
+        OFFICIAL_CUSTOM_EVENT_NAMES.has(customEventName));
+};
+const toSubjectProfile = (traits) => {
+    const displayName = toStringOrNull(traits.display_name ?? traits.displayName);
+    const avatarUrl = toStringOrNull(traits.avatar_url ?? traits.avatarUrl);
+    const email = toStringOrNull(traits.email ?? traits.email_address ?? traits.emailAddress);
+    const role = toStringOrNull(traits.role);
+    const plan = toStringOrNull(traits.plan);
+    if (displayName === null &&
+        avatarUrl === null &&
+        email === null &&
+        role === null &&
+        plan === null) {
+        return null;
+    }
+    return {
+        display_name: displayName,
+        avatar_url: avatarUrl,
+        email,
+        role,
+        plan,
+    };
+};
+class ClueBrowserSdkImpl {
+    constructor(logger = createNoopLogger()) {
+        this.config = null;
+        this.initialized = false;
+        this.initSignature = null;
+        this.consent = DEFAULT_CONSENT;
+        this.identityManager = null;
+        this.sessionManager = null;
+        this.tabManager = null;
+        this.accountManager = null;
+        this.environmentManager = null;
+        this.traceManager = null;
+        this.transport = null;
+        this.captureHandles = [];
+        this.authoringOverlayHandle = null;
+        this.authoringRecording = createAuthoringRecordingController();
+        this.unloadHandlers = [];
+        this.usageGovernorFeedback = DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK;
+        this.currentViewId = null;
+        this.sessionCaptureEligible = true;
+        this.logger = logger;
+        this.internalMetrics = new InternalMetricsStore();
+    }
+    getInternalMetrics() {
+        return this.internalMetrics.getSnapshot();
+    }
+    init(options) {
+        try {
+            const resolved = resolveConfig(options);
+            const issues = validateConfig(resolved);
+            if (!isConfigValid(resolved)) {
+                this.logger.warn("Clue Browser SDK init validation failed", {
+                    issues,
+                });
+                return;
+            }
+            const nextSignature = JSON.stringify({
+                endpoint: resolved.endpoint,
+                originalEndpoint: resolved.originalEndpoint,
+                localSetupCheckEndpoint: resolved.localSetupCheckEndpoint,
+                projectKey: resolved.projectKey,
+                environment: resolved.environment,
+                serviceKey: resolved.serviceKey,
+                producerId: resolved.producerId,
+                browserTokenProvider: resolved.browserTokenProvider !== null,
+                transportProfile: resolved.transportProfile,
+                autocapture: resolved.autocapture,
+                captureNetwork: resolved.captureNetwork,
+                captureErrors: resolved.captureErrors,
+                captureFrustration: resolved.captureFrustration,
+                capturePerformance: resolved.capturePerformance,
+                network: resolved.network,
+                batch: resolved.batch,
+                privacy: resolved.privacy,
+                sampling: resolved.sampling,
+                collection: resolved.collection,
+                release: resolved.release,
+            });
+            if (this.initialized && this.initSignature === nextSignature) {
+                this.logger.debug("Clue Browser SDK init skipped", {
+                    reason: "same_config",
+                });
+                return;
+            }
+            this.shutdown();
+            this.internalMetrics.reset();
+            this.config = resolved;
+            this.usageGovernorFeedback = DEFAULT_INGEST_USAGE_GOVERNOR_FEEDBACK;
+            this.initSignature = nextSignature;
+            this.identityManager = new IdentityManager();
+            this.sessionManager = new SessionManager();
+            this.tabManager = new TabManager();
+            this.accountManager = new AccountManager();
+            this.traceManager = new TraceManager();
+            this.environmentManager = new EnvironmentManager({
+                environment: resolved.environment,
+                frontendRelease: resolved.release.frontendRelease,
+                featureFlagsProvider: resolved.featureFlagsProvider,
+                experimentVariantProvider: resolved.experimentVariantProvider,
+            });
+            this.currentViewId = generateViewId();
+            const effectiveBatch = resolveEffectiveBatchConfig(resolved);
+            const ingestClient = new IngestClient({
+                endpoint: resolved.endpoint,
+                projectKey: resolved.projectKey,
+                environment: resolved.environment,
+                serviceKey: resolved.serviceKey,
+                producerId: resolved.producerId,
+                browserTokenProvider: resolved.browserTokenProvider ?? undefined,
+                sdkType: "browser",
+                sdkVersion: SDK_VERSION,
+                schemaVersion: 1,
+                metrics: this.internalMetrics,
+            });
+            this.transport = new BatchTransport({
+                client: ingestClient,
+                enabled: effectiveBatch.enabled,
+                flushIntervalMs: effectiveBatch.flushIntervalMs,
+                maxPayloadBytes: effectiveBatch.maxPayloadBytes,
+                queueMaxBytes: DEFAULT_MAX_BATCH_QUEUE_BYTES,
+                metrics: this.internalMetrics,
+                onGovernorFeedback: (feedback) => {
+                    this.applyUsageGovernorFeedback(feedback);
+                },
+            });
+            this.transport.start();
+            this.installUnloadHandlers();
+            this.initialized = true;
+            this.refreshSessionCaptureEligibility();
+            const sessionLifecycle = this.sessionManager.ensureActiveSession(Date.now());
+            if (sessionLifecycle.started) {
+                this.enqueueRawEvent({
+                    type: "session_started",
+                    occurredAtMs: Date.now(),
+                    payload: {
+                        entryUrl: typeof window !== "undefined" ? window.location.href : null,
+                    },
+                }, true);
+            }
+            if (effectiveBatch.transportProfile !== "authoring_realtime") {
+                this.enqueueOfficialCustomEvent(OFFICIAL_CUSTOM_EVENT_NAME.sdkInitialized, {
+                    sdk_action: "init",
+                    sdk_scope: "lifecycle",
+                }, true);
+            }
+            if (resolved.autocapture && this.consent !== "denied") {
+                this.startCaptureModules();
+            }
+            this.authoringOverlayHandle = startBusinessEventAuthoringOverlay({
+                ingestEndpoint: resolved.endpoint,
+                recording: this.authoringRecording,
+                onExit: () => {
+                    this.authoringRecording.reset();
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error("Clue Browser SDK init failed", {
+                error: String(error),
+            });
+        }
+    }
+    identify(userId, traits) {
+        if (!this.identityManager) {
+            return;
+        }
+        try {
+            this.identityManager.identify(userId, traits);
+            this.enqueueOfficialCustomEvent(OFFICIAL_CUSTOM_EVENT_NAME.identityIdentified, {
+                identity_action: "identify",
+                profile_keys: Object.keys(traits ?? {}).sort(),
+            });
+        }
+        catch (error) {
+            this.logger.error("identify failed", {
+                error: String(error),
+            });
+        }
+    }
+    setAccount(accountId, traits) {
+        if (!this.accountManager) {
+            return;
+        }
+        try {
+            this.accountManager.setAccount(accountId, traits);
+            this.enqueueOfficialCustomEvent(OFFICIAL_CUSTOM_EVENT_NAME.accountAssociated, {
+                account_action: "associate",
+                profile_keys: Object.keys(traits ?? {}).sort(),
+            });
+        }
+        catch (error) {
+            this.logger.error("setAccount failed", {
+                error: String(error),
+            });
+        }
+    }
+    reset() {
+        if (!this.initialized) {
+            return;
+        }
+        try {
+            const ended = this.sessionManager?.endSession(Date.now());
+            if (ended) {
+                this.enqueueRawEvent({
+                    type: "session_ended",
+                    occurredAtMs: Date.now(),
+                    payload: {
+                        sessionId: ended.sessionId,
+                        exitUrl: typeof window !== "undefined" ? window.location.href : null,
+                        durationMs: ended.durationMs,
+                    },
+                }, true);
+            }
+            this.identityManager?.reset();
+            this.accountManager?.reset();
+            this.traceManager?.reset();
+            this.sessionManager?.reset(Date.now());
+            this.currentViewId = generateViewId();
+            this.enqueueRawEvent({
+                type: "session_started",
+                occurredAtMs: Date.now(),
+                payload: {
+                    entryUrl: typeof window !== "undefined" ? window.location.href : null,
+                },
+            }, true);
+        }
+        catch (error) {
+            this.logger.error("reset failed", {
+                error: String(error),
+            });
+        }
+    }
+    logout() {
+        this.enqueueOfficialCustomEvent(OFFICIAL_CUSTOM_EVENT_NAME.identityLoggedOut, {
+            identity_action: "logout",
+        });
+        this.reset();
+    }
+    track(eventName, properties, metrics) {
+        this.enqueueRawEvent({
+            type: "custom_emitted",
+            occurredAtMs: Date.now(),
+            payload: {
+                eventName,
+                properties: properties ?? {},
+                metrics: metrics ?? {},
+            },
+        });
+    }
+    setConsent(consent) {
+        this.consent = consent;
+        if (!this.initialized) {
+            return;
+        }
+        if (consent === "denied") {
+            this.stopCaptureModules();
+            this.transport?.clear();
+            return;
+        }
+        if (this.config?.autocapture && this.captureHandles.length === 0) {
+            this.startCaptureModules();
+        }
+    }
+    enqueueOfficialCustomEvent(eventName, properties, skipSessionTouch = false) {
+        this.enqueueRawEvent({
+            type: "custom_emitted",
+            occurredAtMs: Date.now(),
+            payload: {
+                eventName,
+                metrics: {
+                    count: 1,
+                },
+                properties,
+            },
+        }, skipSessionTouch);
+    }
+    enqueueRawEvent(event, skipSessionTouch = false) {
+        if (!this.initialized || !this.config || !this.transport) {
+            return;
+        }
+        if (this.consent === "denied") {
+            return;
+        }
+        if (!skipSessionTouch &&
+            event.type !== "session_started" &&
+            event.type !== "session_ended") {
+            this.handleSessionLifecycle(Date.now());
+        }
+        const eventWithInteraction = this.attachInteractionContext(event);
+        if (eventWithInteraction.type === "page_view") {
+            const nextViewId = toStringOrNull(eventWithInteraction.payload.viewId);
+            if (nextViewId) {
+                this.currentViewId = nextViewId;
+            }
+        }
+        try {
+            const context = this.buildContext(eventWithInteraction.occurredAtMs);
+            if (SUMMARY_EVENT_NAMES.has(eventWithInteraction.type)) {
+                const summaryCount = eventWithInteraction.payload.summaryCount;
+                const droppedCount = eventWithInteraction.payload.droppedCount;
+                if (typeof summaryCount === "number" && summaryCount > 0) {
+                    this.internalMetrics.increment("events_summarized_count", summaryCount);
+                }
+                if (typeof droppedCount === "number" && droppedCount > 0) {
+                    this.internalMetrics.increment("sampling_dropped_count", droppedCount);
+                }
+            }
+            if (isCostCapabilityDisabled(this.usageGovernorFeedback, "event_collection")) {
+                this.internalMetrics.increment("dropped_count");
+                return;
+            }
+            const canonical = buildCanonicalEvent(eventWithInteraction, {
+                context,
+                deniedKeys: this.config.privacy.deniedKeys,
+                allowedValuePaths: this.config.privacy.allowedValuePaths,
+                onMaskingError: () => {
+                    this.internalMetrics.increment("masking_error_count");
+                },
+            });
+            if (!canonical) {
+                return;
+            }
+            if (!this.shouldCaptureEvent(eventWithInteraction, canonical)) {
+                this.internalMetrics.increment("dropped_count");
+                return;
+            }
+            let canonicalEvent = canonical;
+            let eventBytes = this.measureSerializedBytes(canonicalEvent);
+            if (eventBytes > this.config.batch.maxEventBytes) {
+                let degradedStage = null;
+                for (const candidate of buildDegradedCanonicalCandidates(canonicalEvent)) {
+                    const candidateBytes = this.measureSerializedBytes(candidate.event);
+                    if (candidateBytes <= this.config.batch.maxEventBytes) {
+                        canonicalEvent = candidate.event;
+                        eventBytes = candidateBytes;
+                        degradedStage = candidate.stage;
+                        break;
+                    }
+                }
+                if (degradedStage) {
+                    this.internalMetrics.increment("snapshot_truncated_count");
+                    this.logger.warn("browser sdk degraded oversized event", {
+                        eventType: eventWithInteraction.type,
+                        eventBytes,
+                        maxEventBytes: this.config.batch.maxEventBytes,
+                        degradedStage,
+                    });
+                }
+            }
+            if (eventBytes > this.config.batch.maxEventBytes) {
+                this.internalMetrics.increment("dropped_count");
+                this.internalMetrics.increment("oversized_event_count");
+                this.internalMetrics.increment("oversized_event_dropped_count");
+                if (canonical.event_category === FRONTEND_EVENT_CATEGORY.request) {
+                    this.internalMetrics.increment("parameter_snapshot_oversized_dropped");
+                }
+                this.logger.warn("browser sdk dropped oversized event", {
+                    eventType: eventWithInteraction.type,
+                    eventBytes,
+                    maxEventBytes: this.config.batch.maxEventBytes,
+                });
+                return;
+            }
+            this.updateActiveTraceSpan(eventWithInteraction, canonicalEvent.event_id);
+            this.transport.enqueue(canonicalEvent);
+        }
+        catch (error) {
+            this.logger.error("enqueueRawEvent failed", {
+                eventType: eventWithInteraction.type,
+                error: String(error),
+            });
+        }
+    }
+    attachInteractionContext(event) {
+        if (isOfficialCustomLifecycleEvent(event)) {
+            return event;
+        }
+        const nowMs = event.occurredAtMs ?? Date.now();
+        const payloadInteractionId = toStringOrNull(event.payload.interactionId);
+        if (INTERACTION_ANCHOR_EVENTS.has(event.type)) {
+            const interactionId = this.traceManager?.startInteraction({
+                interactionId: payloadInteractionId,
+                nowMs,
+                propagationWindowMs: this.config?.network.interactionPropagationWindowMs ??
+                    DEFAULT_INTERACTION_PROPAGATION_WINDOW_MS,
+            }) ?? payloadInteractionId;
+            if (interactionId && interactionId !== payloadInteractionId) {
+                return {
+                    ...event,
+                    payload: {
+                        ...event.payload,
+                        interactionId,
+                    },
+                };
+            }
+            return event;
+        }
+        const activeInteractionId = payloadInteractionId ??
+            this.traceManager?.getActiveInteractionId(nowMs) ??
+            null;
+        if (!activeInteractionId || activeInteractionId === payloadInteractionId) {
+            return event;
+        }
+        return {
+            ...event,
+            payload: {
+                ...event.payload,
+                interactionId: activeInteractionId,
+            },
+        };
+    }
+    buildCaptureContext() {
+        return {
+            onEvent: (event) => {
+                this.enqueueRawEvent(event);
+            },
+            onInternalError: (source, error) => {
+                this.internalMetrics.increment("capture_error_count");
+                this.logger.error("capture module error", {
+                    source,
+                    error: String(error),
+                });
+            },
+            getViewId: () => {
+                if (!this.currentViewId) {
+                    this.currentViewId = generateViewId();
+                }
+                return this.currentViewId;
+            },
+            getConsent: () => this.consent,
+            getObservationContext: () => {
+                const identity = this.identityManager?.getContext();
+                const account = this.accountManager?.getContext();
+                const session = this.sessionManager?.getContext();
+                return {
+                    anonymousId: identity?.anonymousId ?? null,
+                    userId: identity?.userId ?? null,
+                    accountId: account?.accountId ?? null,
+                    organizationId: account?.organizationId ?? null,
+                    sessionId: session?.sessionId ?? null,
+                    tabId: this.tabManager?.getTabId() ?? null,
+                };
+            },
+            shouldIgnoreElement: (element) => {
+                return isWithinAuthoringSurface(element);
+            },
+        };
+    }
+    startCaptureModules() {
+        if (!this.config) {
+            return;
+        }
+        const captureContext = this.buildCaptureContext();
+        const handles = [];
+        handles.push(startPageCapture(captureContext));
+        handles.push(startNavigationCapture(captureContext));
+        handles.push(startActionCapture(captureContext));
+        handles.push(startFormCapture(captureContext));
+        handles.push(startInputCapture(captureContext));
+        handles.push(startDragCapture(captureContext));
+        if (this.config.captureNetwork) {
+            handles.push(startNetworkCapture(captureContext, {
+                ignoreUrlPrefixes: [
+                    this.config.endpoint,
+                    resolveAuthoringBaseEndpoint(this.config.endpoint),
+                ],
+                tracePropagationOrigins: this.config.network.tracePropagationOrigins,
+                important4xxPathPrefixes: this.config.network.important4xxPathPrefixes,
+                createRequestTraceContext: () => {
+                    if (this.traceManager) {
+                        return this.traceManager.createRequestContext();
+                    }
+                    return new TraceManager().createRequestContext();
+                },
+            }));
+        }
+        if (this.config.capturePerformance) {
+            handles.push(startPerformanceCapture(captureContext));
+        }
+        if (this.config.captureErrors) {
+            handles.push(startErrorCapture(captureContext));
+        }
+        if (this.config.captureFrustration) {
+            handles.push(startFrustrationCapture(captureContext));
+        }
+        this.captureHandles = handles;
+    }
+    stopCaptureModules() {
+        for (const handle of this.captureHandles) {
+            try {
+                handle.stop();
+            }
+            catch (error) {
+                this.logger.warn("failed to stop capture module", {
+                    error: String(error),
+                });
+            }
+        }
+        this.captureHandles = [];
+    }
+    applyUsageGovernorFeedback(feedback) {
+        const nextFeedback = normalizeIngestUsageGovernorFeedback(feedback);
+        if (!hasUsageGovernorFeedbackChanged(this.usageGovernorFeedback, nextFeedback)) {
+            return;
+        }
+        this.usageGovernorFeedback = nextFeedback;
+    }
+    handleSessionLifecycle(nowMs) {
+        if (!this.sessionManager) {
+            return;
+        }
+        const lifecycle = this.sessionManager.ensureActiveSession(nowMs);
+        if (lifecycle.ended) {
+            this.enqueueRawEvent({
+                type: "session_ended",
+                occurredAtMs: nowMs,
+                payload: {
+                    sessionId: lifecycle.ended.sessionId,
+                    exitUrl: typeof window !== "undefined" ? window.location.href : null,
+                    durationMs: lifecycle.ended.durationMs,
+                },
+            }, true);
+        }
+        if (lifecycle.started) {
+            this.traceManager?.reset();
+            this.currentViewId = generateViewId();
+            this.refreshSessionCaptureEligibility();
+            this.enqueueRawEvent({
+                type: "session_started",
+                occurredAtMs: nowMs,
+                payload: {
+                    entryUrl: typeof window !== "undefined" ? window.location.href : null,
+                },
+            }, true);
+        }
+    }
+    buildContext(occurredAtMs) {
+        if (!this.config ||
+            !this.identityManager ||
+            !this.sessionManager ||
+            !this.tabManager ||
+            !this.accountManager ||
+            !this.environmentManager) {
+            throw new Error("SDK is not initialized");
+        }
+        const identity = this.identityManager.getContext();
+        const session = this.sessionManager.getContext();
+        const account = this.accountManager.getContext();
+        const environment = this.environmentManager.getContext();
+        const trace = this.traceManager?.getSnapshot();
+        const plan = toStringOrNull(identity.traits.plan);
+        const role = toStringOrNull(identity.traits.role);
+        const accountStatus = toStringOrNull(account.traits.account_status ?? account.traits.accountStatus);
+        const billingStatus = toStringOrNull(account.traits.billing_status ?? account.traits.billingStatus);
+        const customerLifecycleStage = toStringOrNull(account.traits.customer_lifecycle_stage ??
+            account.traits.customerLifecycleStage);
+        const organizationSizeBucket = toStringOrNull(account.traits.organization_size_bucket ??
+            account.traits.organizationSizeBucket);
+        const permissionGroup = toStringOrNull(identity.traits.permission_group ??
+            identity.traits.permissionGroup ??
+            account.traits.permission_group ??
+            account.traits.permissionGroup);
+        const onboardingState = toStringOrNull(identity.traits.onboarding_state ??
+            identity.traits.onboardingState ??
+            account.traits.onboarding_state ??
+            account.traits.onboardingState);
+        const trialDaysRemainingBucket = toStringOrNull(account.traits.trial_days_remaining_bucket ??
+            account.traits.trialDaysRemainingBucket);
+        const customerHealthBucket = toStringOrNull(account.traits.customer_health_bucket ??
+            account.traits.customerHealthBucket);
+        return {
+            producer_id: this.config.producerId,
+            anonymous_id: identity.anonymousId,
+            user_id: identity.userId,
+            account_id: account.accountId,
+            organization_id: account.organizationId,
+            user_profile: toSubjectProfile(identity.traits),
+            account_profile: toSubjectProfile(account.traits),
+            workspace_id: account.workspaceId,
+            session_id: session.sessionId,
+            tab_id: this.tabManager.getTabId(),
+            trace_id: trace?.traceId ?? null,
+            request_id: null,
+            request_span_id: null,
+            interaction_id: this.traceManager?.getActiveInteractionId(occurredAtMs ?? Date.now()) ??
+                null,
+            correlation_id: null,
+            environment: environment.environment,
+            sdk_collection_mode: this.config.collection.mode,
+            frontend_release: environment.frontendRelease,
+            feature_flags: environment.featureFlags,
+            experiment_variant: environment.experimentVariant,
+            plan,
+            role,
+            locale: environment.locale,
+            country: environment.country,
+            device_type: environment.deviceType,
+            browser: environment.browser,
+            os: environment.os,
+            referrer: environment.referrer,
+            browser_family: environment.browserFamily,
+            browser_major_version: environment.browserMajorVersion,
+            browser_engine: environment.browserEngine,
+            os_family: environment.osFamily,
+            os_major_version: environment.osMajorVersion,
+            timezone: environment.timezone,
+            pointer_type_candidate: environment.pointerTypeCandidate,
+            touch_capable: environment.touchCapable,
+            cookies_enabled: environment.cookiesEnabled,
+            local_storage_available: environment.localStorageAvailable,
+            session_storage_available: environment.sessionStorageAvailable,
+            service_worker_supported: environment.serviceWorkerSupported,
+            webgl_supported: environment.webglSupported,
+            reduced_motion: environment.reducedMotion,
+            color_scheme: environment.colorScheme,
+            account_status: accountStatus,
+            plan_tier: plan,
+            billing_status: billingStatus,
+            customer_lifecycle_stage: customerLifecycleStage,
+            organization_size_bucket: organizationSizeBucket,
+            user_role: role,
+            permission_group: permissionGroup,
+            onboarding_state: onboardingState,
+            trial_days_remaining_bucket: trialDaysRemainingBucket,
+            customer_health_bucket: customerHealthBucket,
+        };
+    }
+    installUnloadHandlers() {
+        if (typeof window === "undefined") {
+            return;
+        }
+        let handled = false;
+        const handler = () => {
+            if (handled) {
+                return;
+            }
+            handled = true;
+            const ended = this.sessionManager?.endSession(Date.now());
+            if (ended) {
+                this.enqueueRawEvent({
+                    type: "session_ended",
+                    occurredAtMs: Date.now(),
+                    payload: {
+                        sessionId: ended.sessionId,
+                        exitUrl: typeof window !== "undefined" ? window.location.href : null,
+                        durationMs: ended.durationMs,
+                    },
+                }, true);
+            }
+            this.transport?.flushOnUnload();
+        };
+        const visibilityHandler = () => {
+            if (document.visibilityState !== "hidden") {
+                return;
+            }
+            this.transport?.flushOnUnload();
+        };
+        window.addEventListener("pagehide", handler, { capture: true });
+        window.addEventListener("beforeunload", handler, { capture: true });
+        document.addEventListener("visibilitychange", visibilityHandler, {
+            capture: true,
+        });
+        this.unloadHandlers.push(() => {
+            window.removeEventListener("pagehide", handler, true);
+            window.removeEventListener("beforeunload", handler, true);
+            document.removeEventListener("visibilitychange", visibilityHandler, true);
+        });
+    }
+    refreshSessionCaptureEligibility() {
+        if (!this.config) {
+            this.sessionCaptureEligible = true;
+            return;
+        }
+        const rate = this.config.sampling.sessionSampleRate;
+        this.sessionCaptureEligible = rate >= 1 || Math.random() <= rate;
+    }
+    shouldCaptureEvent(event, _canonical) {
+        if (this.sessionCaptureEligible) {
+            return true;
+        }
+        if (event.type === "session_started" || event.type === "session_ended") {
+            return true;
+        }
+        this.internalMetrics.increment("sampling_dropped_count");
+        return false;
+    }
+    measureSerializedBytes(event) {
+        return new TextEncoder().encode(JSON.stringify(event)).byteLength;
+    }
+    shutdown() {
+        this.stopCaptureModules();
+        for (const dispose of this.unloadHandlers) {
+            try {
+                dispose();
+            }
+            catch {
+                // Ignore.
+            }
+        }
+        this.unloadHandlers = [];
+        this.authoringOverlayHandle?.stop();
+        this.authoringOverlayHandle = null;
+        this.authoringRecording.reset();
+        if (this.transport) {
+            this.transport.stop();
+            this.transport.flushOnUnload();
+            this.transport = null;
+        }
+        this.traceManager = null;
+        this.initialized = false;
+        this.initSignature = null;
+    }
+    updateActiveTraceSpan(event, eventId) {
+        if (!this.traceManager ||
+            isOfficialCustomLifecycleEvent(event) ||
+            !TRACE_ROOT_EVENTS.has(event.type)) {
+            return;
+        }
+        this.traceManager.setActiveSpan(eventId);
+    }
+}
+export const createClueBrowserSdk = () => {
+    return new ClueBrowserSdkImpl();
+};