@debugbundle/sdk-browser 0.1.0-next.0

package/dist/index.js

@@ -0,0 +1,918 @@
+import { redact } from "@debugbundle/redaction";
+import { createEventEnvelope } from "@debugbundle/shared-types";
+import { collectDeviceInfo, installConsoleHook, installNetworkHook } from "./hooks.js";
+import { EventSuppressionTracker } from "./suppression.js";
+import { validateBrowserTriggerToken } from "./trigger-token.js";
+import { buildSelector, buildBrowserTransportRequestBody, createFetchTransport, deriveSdkConfigEndpoint, getConsoleSource, getDocumentSource, getFetchSource, getHistorySource, getLocationSource, getNavigatorSource, getWindowSource, matchesBrowserPattern, matchesStatusCodeFilter, normalizeBoolean, normalizeError, normalizeLogLevel, normalizeNetworkFilter, normalizePositiveNumber, normalizeSampleRate, normalizeTracePropagationTargets, normalizeUnknownRecord, parseIngestionProbeDirectives, parseRemoteProbeConfigPayload, resolveBrowserTransport, } from "./runtime.js";
+import { DEFAULT_BATCH_SIZE, DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_LOG_LEVEL, DEFAULT_MAX_BREADCRUMBS, DEFAULT_MAX_EVENTS_PER_SESSION, DEFAULT_REQUEST_TIMEOUT_MS, DEFAULT_SAMPLE_RATE, DEFAULT_SESSION_SAMPLE_RATE, LOG_LEVEL_ORDER, SDK_NAME, SDK_SCHEMA_VERSION, SDK_VERSION } from "./types.js";
+export class BrowserSdk {
+    config = null;
+    bufferedEvents = [];
+    breadcrumbs = [];
+    persistentContext = {};
+    deviceInfo = null;
+    flushPromise = null;
+    flushTimer = null;
+    nextRetryAt = null;
+    _lastEventAt = null;
+    _consecutiveFailures = 0;
+    registeredListeners = [];
+    originalPushState = null;
+    originalReplaceState = null;
+    originalFetch = null;
+    originalXmlHttpRequest = null;
+    originalConsoleError = null;
+    originalConsoleWarn = null;
+    sessionSampledIn = true;
+    sessionEventCount = 0;
+    probeBuffers = new Map();
+    suppressionTracker = new EventSuppressionTracker();
+    remoteProbeState = {
+        probesEnabled: false,
+        remoteProbesEnabled: false,
+        directives: [],
+        triggerTokenKey: null
+    };
+    pendingTriggerToken = null;
+    activeTriggerDirective = null;
+    get status() {
+        if (this.config === null) {
+            return "disconnected";
+        }
+        if (this._consecutiveFailures >= 3) {
+            return "disconnected";
+        }
+        if (this.nextRetryAt !== null) {
+            return "degraded";
+        }
+        return "healthy";
+    }
+    get lastEventAt() {
+        return this._lastEventAt;
+    }
+    init(config) {
+        this.dispose();
+        const enabled = config.enabled ?? true;
+        const resolvedTransport = resolveBrowserTransport({
+            endpoint: config.endpoint,
+            projectToken: config.projectToken
+        });
+        if (!enabled || resolvedTransport.mode === "disabled" || resolvedTransport.endpoint === null) {
+            return;
+        }
+        this.config = {
+            projectToken: resolvedTransport.projectToken,
+            environment: config.environment?.trim() || "development",
+            service: config.service?.trim() || "browser-app",
+            enabled,
+            redactFields: config.redactFields ?? ["password", "secret", "token", "authorization", "cookie", "ssn", "credit_card"],
+            tracePropagationTargets: normalizeTracePropagationTargets(config.tracePropagationTargets),
+            sampleRate: normalizeSampleRate(config.sampleRate, DEFAULT_SAMPLE_RATE),
+            batchSize: normalizePositiveNumber(config.batchSize, DEFAULT_BATCH_SIZE),
+            flushInterval: normalizePositiveNumber(config.flushInterval, DEFAULT_FLUSH_INTERVAL_MS),
+            endpoint: resolvedTransport.endpoint,
+            logLevel: normalizeLogLevel(config.logLevel ?? DEFAULT_LOG_LEVEL),
+            maxBreadcrumbs: normalizePositiveNumber(config.maxBreadcrumbs, DEFAULT_MAX_BREADCRUMBS),
+            breadcrumbsOnErrorOnly: normalizeBoolean(config.breadcrumbsOnErrorOnly, true),
+            captureNetwork: normalizeBoolean(config.captureNetwork, true),
+            captureClicks: normalizeBoolean(config.captureClicks, true),
+            captureRouteChanges: normalizeBoolean(config.captureRouteChanges, true),
+            captureConsole: normalizeBoolean(config.captureConsole, false),
+            networkFilter: normalizeNetworkFilter(config.networkFilter),
+            sessionSampleRate: normalizeSampleRate(config.sessionSampleRate, DEFAULT_SESSION_SAMPLE_RATE),
+            maxEventsPerSession: normalizePositiveNumber(config.maxEventsPerSession, DEFAULT_MAX_EVENTS_PER_SESSION),
+            maxProbeLabels: normalizePositiveNumber(config.maxProbeLabels, 50),
+            maxProbeEntriesPerLabel: normalizePositiveNumber(config.maxProbeEntriesPerLabel, 10),
+            probeFlushOnError: normalizeBoolean(config.probeFlushOnError, true),
+            requestTimeoutMs: normalizePositiveNumber(config.requestTimeoutMs, DEFAULT_REQUEST_TIMEOUT_MS),
+            fetchImpl: getFetchSource(),
+            transport: config.transport ?? createFetchTransport(),
+            transportMode: resolvedTransport.mode
+        };
+        this.sessionSampledIn = this.config.sessionSampleRate >= 1 || Math.random() < this.config.sessionSampleRate;
+        this.sessionEventCount = 0;
+        this.deviceInfo = collectDeviceInfo();
+        this.pendingTriggerToken = this.consumeTriggerTokenFromLocation();
+        void this.refreshRemoteProbeConfig();
+        this.installBrowserHooks();
+    }
+    captureException(error, context = {}) {
+        const config = this.config;
+        if (config === null) {
+            return;
+        }
+        try {
+            const normalizedError = normalizeError(error);
+            const device = this.deviceInfo;
+            const browser = device?.browser ?? { name: "Unknown", version: "0" };
+            const breadcrumbs = this.consumeBreadcrumbs();
+            const probeData = config.probeFlushOnError ? this.consumeProbeData() : { version: 1, items: [] };
+            const domContext = typeof context.target?.outerHTML === "string" && context.target.outerHTML.length > 0
+                ? {
+                    mode: "lightweight",
+                    html_excerpt: context.target.outerHTML
+                }
+                : null;
+            const event = createEventEnvelope({
+                schema_version: SDK_SCHEMA_VERSION,
+                event_type: "frontend_exception",
+                ...this.getProjectTokenFields(config),
+                sdk_name: SDK_NAME,
+                sdk_version: SDK_VERSION,
+                service: {
+                    name: config.service,
+                    runtime: "browser",
+                    framework: null,
+                    environment: config.environment
+                },
+                occurred_at: new Date().toISOString(),
+                correlation: this.createCorrelation(),
+                payload: {
+                    name: normalizedError.name,
+                    message: normalizedError.message,
+                    stack: normalizedError.stack,
+                    route: context.route ?? this.getCurrentRoute(),
+                    browser,
+                    breadcrumbs,
+                    probe_data: probeData,
+                    device: device === null
+                        ? null
+                        : {
+                            user_agent: device.user_agent,
+                            os: device.os,
+                            device_type: device.device_type,
+                            screen: device.screen,
+                            viewport: device.viewport,
+                            device_pixel_ratio: device.device_pixel_ratio,
+                            touch_capable: device.touch_capable,
+                            language: device.language,
+                            connection_type: device.connection_type,
+                            color_scheme_preference: device.color_scheme_preference
+                        },
+                    dom_context: domContext
+                }
+            });
+            this.removeEmptyProjectToken(event, config);
+            this.enqueueEvent(event);
+        }
+        catch {
+            return;
+        }
+    }
+    captureError(error, context = {}) {
+        this.captureException(error, context);
+    }
+    captureLog(message, level, context = {}) {
+        const config = this.config;
+        if (config === null || !this.shouldCaptureNonExceptionEvent()) {
+            return;
+        }
+        if (LOG_LEVEL_ORDER[level] < LOG_LEVEL_ORDER[config.logLevel]) {
+            return;
+        }
+        try {
+            const attributes = redact({
+                ...this.persistentContext,
+                ...normalizeUnknownRecord(context)
+            }, {
+                sensitiveKeys: config.redactFields
+            }).redacted;
+            const event = createEventEnvelope({
+                schema_version: SDK_SCHEMA_VERSION,
+                event_type: "log_event",
+                ...this.getProjectTokenFields(config),
+                sdk_name: SDK_NAME,
+                sdk_version: SDK_VERSION,
+                service: {
+                    name: config.service,
+                    runtime: "browser",
+                    framework: null,
+                    environment: config.environment
+                },
+                occurred_at: new Date().toISOString(),
+                correlation: this.createCorrelation(),
+                payload: {
+                    level,
+                    message,
+                    attributes
+                }
+            });
+            this.removeEmptyProjectToken(event, config);
+            this.enqueueEvent(event);
+        }
+        catch {
+            return;
+        }
+    }
+    captureRequest(request, response, context) {
+        void request;
+        void response;
+        void context;
+    }
+    captureMessage(message, level = "info", context = {}) {
+        this.captureLog(message, normalizeLogLevel(level), context);
+    }
+    setContext(key, value) {
+        const config = this.config;
+        if (config === null || key.trim().length === 0) {
+            return;
+        }
+        const redacted = redact({ [key]: value }, {
+            sensitiveKeys: config.redactFields
+        }).redacted;
+        this.persistentContext[key] = redacted[key] ?? null;
+    }
+    probe(label, data) {
+        const config = this.config;
+        const normalizedLabel = label.trim();
+        if (config === null || normalizedLabel.length === 0) {
+            return;
+        }
+        try {
+            const redacted = redact(this.normalizeProbeInput(data), {
+                sensitiveKeys: config.redactFields
+            }).redacted;
+            const probeData = normalizeUnknownRecord(redacted);
+            this.bufferProbe(normalizedLabel, probeData);
+            const matchingDirectives = this.getMatchingRemoteProbeDirectives(normalizedLabel, Date.now());
+            if (!this.sessionSampledIn || matchingDirectives.length === 0) {
+                return;
+            }
+            for (const directive of matchingDirectives) {
+                this.enqueueEvent(this.createSdkEventEnvelope(config, {
+                    schema_version: SDK_SCHEMA_VERSION,
+                    event_type: "probe_event",
+                    ...this.getProjectTokenFields(config),
+                    sdk_name: SDK_NAME,
+                    sdk_version: SDK_VERSION,
+                    service: {
+                        name: config.service,
+                        runtime: "browser",
+                        framework: null,
+                        environment: config.environment
+                    },
+                    occurred_at: new Date().toISOString(),
+                    correlation: this.createCorrelation(),
+                    payload: {
+                        label: normalizedLabel,
+                        data: probeData,
+                        activation_id: directive.activationId,
+                        probe_label_pattern: directive.labelPattern
+                    }
+                }), false);
+            }
+        }
+        catch {
+            return;
+        }
+    }
+    async flush() {
+        const config = this.config;
+        if (config === null) {
+            return;
+        }
+        this.enqueueSuppressionAggregates();
+        if (this.bufferedEvents.length === 0) {
+            return;
+        }
+        if (this.flushPromise !== null) {
+            return this.flushPromise;
+        }
+        if (this.nextRetryAt !== null && Date.now() < this.nextRetryAt) {
+            return;
+        }
+        this.clearFlushTimer();
+        const events = [...this.bufferedEvents];
+        this.flushPromise = (async () => {
+            try {
+                const response = await config.transport({
+                    endpoint: config.endpoint,
+                    headers: this.getTransportHeaders(config),
+                    events,
+                    timeout_ms: config.requestTimeoutMs
+                });
+                if (response.status >= 200 && response.status < 300) {
+                    this.updateRemoteProbeStateFromIngestionResponse(response.body);
+                    this.nextRetryAt = null;
+                    this._lastEventAt = Date.now();
+                    this._consecutiveFailures = 0;
+                    if (this.bufferedEvents === events || this.sameLeadingEvents(events)) {
+                        this.bufferedEvents.splice(0, events.length);
+                    }
+                    return;
+                }
+                this._consecutiveFailures++;
+                if (response.status === 429) {
+                    this.nextRetryAt = Date.now() + (response.retry_after_ms ?? 1_000);
+                }
+            }
+            catch {
+                this._consecutiveFailures++;
+                return;
+            }
+            finally {
+                this.flushPromise = null;
+                if (this.bufferedEvents.length > 0) {
+                    const retryDelay = this.nextRetryAt === null ? undefined : Math.max(0, this.nextRetryAt - Date.now());
+                    this.scheduleFlush(retryDelay);
+                }
+            }
+        })();
+        return this.flushPromise;
+    }
+    dispose() {
+        this.clearFlushTimer();
+        this.flushPromise = null;
+        this.bufferedEvents = [];
+        this.breadcrumbs = [];
+        this.probeBuffers = new Map();
+        this.persistentContext = {};
+        this.deviceInfo = null;
+        this.config = null;
+        this.sessionSampledIn = true;
+        this.sessionEventCount = 0;
+        this.nextRetryAt = null;
+        this._lastEventAt = null;
+        this._consecutiveFailures = 0;
+        this.suppressionTracker.reset();
+        this.remoteProbeState = {
+            probesEnabled: false,
+            remoteProbesEnabled: false,
+            directives: [],
+            triggerTokenKey: null
+        };
+        this.pendingTriggerToken = null;
+        this.activeTriggerDirective = null;
+        while (this.registeredListeners.length > 0) {
+            this.registeredListeners.pop()?.();
+        }
+        const historySource = getHistorySource();
+        if (this.originalPushState !== null && historySource !== null) {
+            historySource.pushState = this.originalPushState;
+            this.originalPushState = null;
+        }
+        if (this.originalReplaceState !== null && historySource !== null) {
+            historySource.replaceState = this.originalReplaceState;
+            this.originalReplaceState = null;
+        }
+        const consoleSource = getConsoleSource();
+        if (consoleSource !== null && this.originalConsoleError !== null) {
+            consoleSource.error = this.originalConsoleError;
+            this.originalConsoleError = null;
+        }
+        if (consoleSource !== null && this.originalConsoleWarn !== null) {
+            consoleSource.warn = this.originalConsoleWarn;
+            this.originalConsoleWarn = null;
+        }
+        if (this.originalFetch !== null) {
+            globalThis["fetch"] = this.originalFetch;
+            this.originalFetch = null;
+        }
+        if (this.originalXmlHttpRequest !== null) {
+            globalThis["XMLHttpRequest"] = this.originalXmlHttpRequest;
+            this.originalXmlHttpRequest = null;
+        }
+    }
+    installBrowserHooks() {
+        const windowSource = getWindowSource();
+        if (windowSource !== null) {
+            const onPageHide = () => {
+                this.flushViaBeacon();
+            };
+            const onError = (event) => {
+                const maybeError = normalizeUnknownRecord(event);
+                this.captureException(maybeError["error"] ?? maybeError["message"] ?? new Error("Window error"));
+            };
+            const onUnhandledRejection = (event) => {
+                const maybeError = normalizeUnknownRecord(event);
+                this.captureException(maybeError["reason"] ?? new Error("Unhandled promise rejection"));
+            };
+            windowSource.addEventListener("pagehide", onPageHide);
+            windowSource.addEventListener("error", onError);
+            windowSource.addEventListener("unhandledrejection", onUnhandledRejection);
+            this.registeredListeners.push(() => windowSource.removeEventListener("pagehide", onPageHide));
+            this.registeredListeners.push(() => windowSource.removeEventListener("error", onError));
+            this.registeredListeners.push(() => windowSource.removeEventListener("unhandledrejection", onUnhandledRejection));
+        }
+        const documentSource = getDocumentSource();
+        if (documentSource !== null) {
+            const onClick = (event) => {
+                if (this.config?.captureClicks !== true) {
+                    return;
+                }
+                const target = normalizeUnknownRecord(normalizeUnknownRecord(event)["target"]);
+                const selector = buildSelector(target);
+                if (selector === null) {
+                    return;
+                }
+                this.addBreadcrumb({
+                    ts: new Date().toISOString(),
+                    breadcrumb_type: "click",
+                    data: {
+                        selector
+                    }
+                });
+            };
+            const onSubmit = (event) => {
+                const target = normalizeUnknownRecord(normalizeUnknownRecord(event)["target"]);
+                const selector = buildSelector(target) ?? "form";
+                const elements = Array.isArray(target["elements"]) ? target["elements"] : [];
+                const fieldCount = elements
+                    .map((entry) => normalizeUnknownRecord(entry))
+                    .filter((entry) => typeof entry["name"] === "string" && entry["name"].length > 0).length;
+                this.addBreadcrumb({
+                    ts: new Date().toISOString(),
+                    breadcrumb_type: "form_submit",
+                    data: {
+                        form: selector,
+                        field_count: fieldCount
+                    }
+                });
+            };
+            const onVisibilityChange = () => {
+                if (documentSource.visibilityState === "hidden") {
+                    this.flushViaBeacon();
+                }
+            };
+            documentSource.addEventListener("click", onClick);
+            documentSource.addEventListener("submit", onSubmit);
+            documentSource.addEventListener("visibilitychange", onVisibilityChange);
+            this.registeredListeners.push(() => documentSource.removeEventListener("click", onClick));
+            this.registeredListeners.push(() => documentSource.removeEventListener("submit", onSubmit));
+            this.registeredListeners.push(() => documentSource.removeEventListener("visibilitychange", onVisibilityChange));
+        }
+        const historySource = getHistorySource();
+        if (historySource !== null) {
+            this.originalPushState = historySource.pushState.bind(historySource);
+            this.originalReplaceState = historySource.replaceState.bind(historySource);
+            historySource.pushState = (state, title, url) => {
+                this.originalPushState?.(state, title, url);
+                this.captureRouteChange(url);
+            };
+            historySource.replaceState = (state, title, url) => {
+                this.originalReplaceState?.(state, title, url);
+                this.captureRouteChange(url);
+            };
+        }
+        const consoleHooks = installConsoleHook(this.config, (breadcrumb) => {
+            this.addBreadcrumb(breadcrumb);
+        });
+        this.originalConsoleError = consoleHooks.originalConsoleError;
+        this.originalConsoleWarn = consoleHooks.originalConsoleWarn;
+        const networkHooks = installNetworkHook(this.config, (breadcrumb) => {
+            this.addBreadcrumb(breadcrumb);
+        }, (url, statusCode, durationMs) => this.shouldCaptureNetworkRequest(url, statusCode, durationMs), () => this.getCurrentRoute());
+        this.originalFetch = networkHooks.originalFetch;
+        this.originalXmlHttpRequest = networkHooks.originalXmlHttpRequest;
+    }
+    createCorrelation() {
+        return {
+            request_id: null,
+            trace_id: null,
+            session_id: null,
+            user_id_hash: null
+        };
+    }
+    addBreadcrumb(breadcrumb) {
+        const config = this.config;
+        if (config === null || !this.shouldCaptureBreadcrumb()) {
+            return;
+        }
+        if (config.breadcrumbsOnErrorOnly !== true) {
+            this.enqueueEvent(this.createBreadcrumbEvent(breadcrumb));
+            return;
+        }
+        this.breadcrumbs.push(breadcrumb);
+        this.sessionEventCount += 1;
+        while (this.breadcrumbs.length > config.maxBreadcrumbs) {
+            this.breadcrumbs.shift();
+        }
+    }
+    bufferProbe(label, data) {
+        const config = this.config;
+        if (config === null) {
+            return;
+        }
+        if (!this.probeBuffers.has(label) && this.probeBuffers.size >= config.maxProbeLabels) {
+            return;
+        }
+        const buffer = this.probeBuffers.get(label) ?? [];
+        buffer.push({
+            label,
+            data,
+            timestamp: new Date().toISOString(),
+            activation_id: null
+        });
+        while (buffer.length > config.maxProbeEntriesPerLabel) {
+            buffer.shift();
+        }
+        this.probeBuffers.set(label, buffer);
+    }
+    consumeProbeData() {
+        const items = Array.from(this.probeBuffers.values()).flatMap((buffer) => buffer);
+        this.probeBuffers.clear();
+        return {
+            version: 1,
+            items
+        };
+    }
+    consumeBreadcrumbs() {
+        const breadcrumbs = [...this.breadcrumbs];
+        this.breadcrumbs = [];
+        return breadcrumbs;
+    }
+    captureRouteChange(url) {
+        if (this.config?.captureRouteChanges !== true) {
+            return;
+        }
+        const route = typeof url === "string"
+            ? url
+            : url instanceof URL
+                ? url.pathname
+                : this.getCurrentRoute();
+        if (route === null) {
+            return;
+        }
+        this.addBreadcrumb({
+            ts: new Date().toISOString(),
+            breadcrumb_type: "route_change",
+            route,
+            data: {
+                route
+            }
+        });
+    }
+    createBreadcrumbEvent(breadcrumb) {
+        const config = this.config;
+        if (config === null) {
+            throw new Error("Browser SDK not initialized");
+        }
+        return this.createSdkEventEnvelope(config, {
+            schema_version: SDK_SCHEMA_VERSION,
+            event_type: "frontend_breadcrumb",
+            ...this.getProjectTokenFields(config),
+            sdk_name: SDK_NAME,
+            sdk_version: SDK_VERSION,
+            service: {
+                name: config.service,
+                runtime: "browser",
+                framework: null,
+                environment: config.environment
+            },
+            occurred_at: breadcrumb.ts,
+            correlation: this.createCorrelation(),
+            payload: {
+                breadcrumb_type: breadcrumb.breadcrumb_type,
+                route: breadcrumb.route ?? this.getCurrentRoute(),
+                data: breadcrumb.data
+            }
+        });
+    }
+    getCurrentRoute() {
+        const locationSource = getLocationSource();
+        if (locationSource === null) {
+            return null;
+        }
+        return typeof locationSource.pathname === "string" ? locationSource.pathname : null;
+    }
+    enqueueEvent(event, countTowardSession = true) {
+        if (!this.shouldCaptureBySampleRate(event)) {
+            return;
+        }
+        const suppressionKey = this.buildSuppressionKey(event);
+        if (suppressionKey !== null && !this.suppressionTracker.shouldCapture(suppressionKey, Date.now())) {
+            this.scheduleFlush();
+            return;
+        }
+        this.enqueueInternalEvent(event, countTowardSession);
+    }
+    enqueueInternalEvent(event, countTowardSession = true) {
+        const config = this.config;
+        if (config === null) {
+            return;
+        }
+        this.bufferedEvents.push(event);
+        if (countTowardSession && event.event_type !== "frontend_exception") {
+            this.sessionEventCount += 1;
+        }
+        if (this.bufferedEvents.length >= config.batchSize) {
+            queueMicrotask(() => {
+                void this.flush();
+            });
+            return;
+        }
+        this.scheduleFlush();
+    }
+    buildSuppressionKey(event) {
+        if (event.event_type === "frontend_exception") {
+            const stackFrame = event.payload.stack.split("\n")[1]?.trim() ?? null;
+            return JSON.stringify({
+                event_type: event.event_type,
+                name: event.payload.name,
+                message: event.payload.message,
+                stack_frame: stackFrame,
+                route: event.payload.route
+            });
+        }
+        if (event.event_type === "log_event") {
+            return JSON.stringify({
+                event_type: event.event_type,
+                level: event.payload.level,
+                message: event.payload.message,
+                attributes: event.payload.attributes
+            });
+        }
+        return null;
+    }
+    shouldCaptureBySampleRate(event) {
+        const config = this.config;
+        if (config === null) {
+            return false;
+        }
+        if (event.event_type === "frontend_exception" || event.event_type === "error_suppressed") {
+            return true;
+        }
+        return config.sampleRate >= 1 || Math.random() <= config.sampleRate;
+    }
+    scheduleFlush(delayMs) {
+        const config = this.config;
+        if (config === null) {
+            return;
+        }
+        if (this.flushTimer !== null) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flush();
+        }, delayMs ?? config.flushInterval);
+    }
+    clearFlushTimer() {
+        if (this.flushTimer !== null) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+    flushViaBeacon() {
+        const config = this.config;
+        const navigatorSource = getNavigatorSource();
+        if (config === null || this.bufferedEvents.length === 0 || navigatorSource === null) {
+            return;
+        }
+        const pendingEvents = [...this.bufferedEvents];
+        const body = buildBrowserTransportRequestBody(config.endpoint, pendingEvents);
+        const flushViaKeepalive = () => {
+            if (config.fetchImpl === null) {
+                void this.flush();
+                return;
+            }
+            void config
+                .fetchImpl(config.endpoint, {
+                method: "POST",
+                headers: this.getTransportHeaders(config),
+                body,
+                keepalive: true
+            })
+                .then(() => {
+                if (this.bufferedEvents === pendingEvents || this.sameLeadingEvents(pendingEvents)) {
+                    this.bufferedEvents.splice(0, pendingEvents.length);
+                }
+                this.nextRetryAt = null;
+                this.clearFlushTimer();
+            })
+                .catch(() => {
+                return;
+            });
+        };
+        if (typeof navigatorSource.sendBeacon !== "function") {
+            flushViaKeepalive();
+            return;
+        }
+        const beaconBody = typeof Blob === "function"
+            ? new Blob([body], { type: "application/json" })
+            : body;
+        const accepted = navigatorSource.sendBeacon(config.endpoint, beaconBody);
+        if (accepted) {
+            this.bufferedEvents = [];
+            this.nextRetryAt = null;
+            this.clearFlushTimer();
+            return;
+        }
+        flushViaKeepalive();
+    }
+    sameLeadingEvents(events) {
+        if (this.bufferedEvents.length < events.length) {
+            return false;
+        }
+        return events.every((event, index) => this.bufferedEvents[index]?.event_id === event.event_id);
+    }
+    shouldCaptureNonExceptionEvent() {
+        const config = this.config;
+        if (config === null) {
+            return false;
+        }
+        return this.sessionSampledIn && this.sessionEventCount < config.maxEventsPerSession;
+    }
+    shouldCaptureBreadcrumb() {
+        return this.shouldCaptureNonExceptionEvent();
+    }
+    getProjectTokenFields(config) {
+        if (config.projectToken === null) {
+            return {};
+        }
+        return {
+            project_token: config.projectToken
+        };
+    }
+    getTransportHeaders(config) {
+        if (config.projectToken === null) {
+            return {
+                "content-type": "application/json"
+            };
+        }
+        return {
+            "content-type": "application/json",
+            authorization: `Bearer ${config.projectToken}`
+        };
+    }
+    createSdkEventEnvelope(config, input) {
+        const event = createEventEnvelope(input);
+        this.removeEmptyProjectToken(event, config);
+        return event;
+    }
+    removeEmptyProjectToken(event, config) {
+        if (config.projectToken !== null) {
+            return;
+        }
+        delete event["project_token"];
+    }
+    enqueueSuppressionAggregates() {
+        const config = this.config;
+        if (config === null) {
+            return;
+        }
+        for (const aggregate of this.suppressionTracker.drainAggregates(Date.now())) {
+            this.enqueueInternalEvent(this.createSdkEventEnvelope(config, {
+                schema_version: SDK_SCHEMA_VERSION,
+                event_type: "error_suppressed",
+                ...this.getProjectTokenFields(config),
+                sdk_name: SDK_NAME,
+                sdk_version: SDK_VERSION,
+                service: {
+                    name: config.service,
+                    runtime: "browser",
+                    framework: null,
+                    environment: config.environment
+                },
+                occurred_at: aggregate.lastSeen,
+                payload: {
+                    fingerprint: aggregate.fingerprint,
+                    suppressed_count: aggregate.suppressedCount,
+                    window_seconds: aggregate.windowSeconds,
+                    first_seen: aggregate.firstSeen,
+                    last_seen: aggregate.lastSeen
+                }
+            }), false);
+        }
+    }
+    shouldCaptureNetworkRequest(url, statusCode, durationMs) {
+        const config = this.config;
+        if (config === null) {
+            return false;
+        }
+        const filter = config.networkFilter;
+        if (filter.urlPatterns.length > 0 && !filter.urlPatterns.some((pattern) => matchesBrowserPattern(url, pattern))) {
+            return false;
+        }
+        if (filter.urlDenyPatterns.some((pattern) => matchesBrowserPattern(url, pattern))) {
+            return false;
+        }
+        if (filter.minResponseTime !== null && durationMs < filter.minResponseTime) {
+            return false;
+        }
+        return matchesStatusCodeFilter(statusCode, filter.statusCodes);
+    }
+    pruneExpiredRemoteProbeDirectives(nowMs) {
+        const directives = this.remoteProbeState.directives.filter((directive) => Date.parse(directive.expiresAt) > nowMs);
+        if (this.activeTriggerDirective !== null && Date.parse(this.activeTriggerDirective.expiresAt) <= nowMs) {
+            this.activeTriggerDirective = null;
+        }
+        if (directives.length === this.remoteProbeState.directives.length) {
+            return;
+        }
+        this.remoteProbeState = {
+            ...this.remoteProbeState,
+            directives
+        };
+    }
+    async refreshRemoteProbeConfig() {
+        const config = this.config;
+        if (config === null || config.fetchImpl === null || config.transportMode !== "direct" || config.projectToken === null) {
+            return;
+        }
+        try {
+            const response = await config.fetchImpl(deriveSdkConfigEndpoint(config.endpoint), {
+                method: "GET",
+                headers: {
+                    authorization: `Bearer ${config.projectToken}`
+                }
+            });
+            if (response.status === 304 || typeof response.json !== "function") {
+                return;
+            }
+            const payload = await response.json();
+            const parsed = parseRemoteProbeConfigPayload(payload, Date.now());
+            if (parsed !== null) {
+                this.remoteProbeState = parsed;
+                this.pruneExpiredRemoteProbeDirectives(Date.now());
+                await this.activatePendingTriggerTokenIfPossible();
+            }
+        }
+        catch {
+            return;
+        }
+    }
+    updateRemoteProbeStateFromIngestionResponse(payload) {
+        const directives = parseIngestionProbeDirectives(payload, Date.now());
+        if (directives === null) {
+            this.pruneExpiredRemoteProbeDirectives(Date.now());
+            return;
+        }
+        this.remoteProbeState = {
+            ...this.remoteProbeState,
+            directives
+        };
+        this.pruneExpiredRemoteProbeDirectives(Date.now());
+    }
+    consumeTriggerTokenFromLocation() {
+        const locationSource = getLocationSource();
+        const historySource = getHistorySource();
+        const search = typeof locationSource?.search === "string" ? locationSource.search : "";
+        if (search.length === 0) {
+            return null;
+        }
+        const params = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
+        const token = params.get("_debug_probe");
+        if (token === null || token.length === 0) {
+            return null;
+        }
+        params.delete("_debug_probe");
+        const cleanedPath = `${locationSource?.pathname ?? ""}${params.toString().length > 0 ? `?${params.toString()}` : ""}`;
+        historySource?.replaceState({}, "", cleanedPath);
+        return token;
+    }
+    async activatePendingTriggerTokenIfPossible() {
+        if (this.pendingTriggerToken === null) {
+            return;
+        }
+        const directive = await validateBrowserTriggerToken({
+            token: this.pendingTriggerToken,
+            triggerTokenKey: this.remoteProbeState.triggerTokenKey,
+            nowMs: Date.now()
+        });
+        this.pendingTriggerToken = null;
+        this.activeTriggerDirective = directive;
+    }
+    normalizeProbeInput(data) {
+        if (data === null || typeof data !== "object" || Array.isArray(data)) {
+            return { value: data };
+        }
+        return data;
+    }
+    getMatchingRemoteProbeDirectives(label, nowMs) {
+        const config = this.config;
+        if (config === null ||
+            this.remoteProbeState.probesEnabled !== true ||
+            this.remoteProbeState.remoteProbesEnabled !== true) {
+            return [];
+        }
+        this.pruneExpiredRemoteProbeDirectives(nowMs);
+        const activeDirectives = this.activeTriggerDirective === null
+            ? this.remoteProbeState.directives
+            : [...this.remoteProbeState.directives, this.activeTriggerDirective];
+        return activeDirectives.filter((directive) => {
+            if (directive.service !== "*" && directive.service !== config.service) {
+                return false;
+            }
+            if (directive.environment !== "*" && directive.environment !== config.environment) {
+                return false;
+            }
+            return this.matchesProbeLabelPattern(directive.labelPattern, label);
+        });
+    }
+    matchesProbeLabelPattern(pattern, label) {
+        if (pattern === "*") {
+            return true;
+        }
+        if (pattern.endsWith(".*")) {
+            const prefix = pattern.slice(0, -2);
+            return label === prefix || label.startsWith(`${prefix}.`);
+        }
+        return pattern === label;
+    }
+}
+export function createDebugBundleBrowserSdk() {
+    return new BrowserSdk();
+}
+//# sourceMappingURL=index.js.map