@v-tilt/browser 1.1.5 → 1.2.0

package/lib/extensions/replay/session-recording.js

@@ -0,0 +1,700 @@
+"use strict";
+/**
+ * Lazy Loaded Session Recording
+ *
+ * The actual rrweb session recording implementation.
+ * This is loaded on demand when recording is enabled.
+ *
+ * Based on PostHog's lazy-loaded-session-recorder.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyLoadedSessionRecording = exports.SESSION_RECORDING_BATCH_KEY = void 0;
+const types_1 = require("@rrweb/types");
+const globals_1 = require("../../utils/globals");
+const utils_1 = require("../../utils");
+const session_recording_utils_1 = require("./session-recording-utils");
+const fflate_1 = require("fflate");
+// ============================================================================
+// Constants
+// ============================================================================
+const LOGGER_PREFIX = "[SessionRecording]";
+const BASE_ENDPOINT = "/api/s";
+const TWO_SECONDS = 2000;
+const ONE_MINUTE = 60 * 1000;
+const FIVE_MINUTES = 5 * ONE_MINUTE;
+const DEFAULT_CANVAS_QUALITY = 0.4;
+const DEFAULT_CANVAS_FPS = 4;
+const MAX_CANVAS_FPS = 12;
+const MAX_CANVAS_QUALITY = 1;
+exports.SESSION_RECORDING_BATCH_KEY = "recordings";
+// Retry configuration (PostHog-style exponential backoff)
+const MAX_SNAPSHOT_RETRIES = 5;
+const INITIAL_RETRY_DELAY_MS = 3000; // 3 seconds
+const MAX_RETRY_DELAY_MS = 30000; // 30 seconds
+// ============================================================================
+// Helpers
+// ============================================================================
+function getRRWebRecord() {
+    var _a, _b;
+    return (_b = (_a = globals_1.assignableWindow === null || globals_1.assignableWindow === void 0 ? void 0 : globals_1.assignableWindow.__VTiltExtensions__) === null || _a === void 0 ? void 0 : _a.rrweb) === null || _b === void 0 ? void 0 : _b.record;
+}
+function newQueuedEvent(rrwebMethod) {
+    return {
+        rrwebMethod,
+        enqueuedAt: Date.now(),
+        attempt: 1,
+    };
+}
+// ============================================================================
+// Lazy Loaded Session Recording Class
+// ============================================================================
+class LazyLoadedSessionRecording {
+    constructor(instance, config = {}) {
+        this._endpoint = BASE_ENDPOINT;
+        // Recording state
+        this._captureStarted = false;
+        this._isIdle = "unknown";
+        this._lastActivityTimestamp = Date.now();
+        // IDs
+        this._sessionId = "";
+        this._windowId = "";
+        this._queuedRRWebEvents = [];
+        // ============================================================================
+        // Event Handlers
+        // ============================================================================
+        this._onBeforeUnload = () => {
+            this._flushBuffer();
+        };
+        this._onOffline = () => {
+            this._tryAddCustomEvent("browser offline", {});
+        };
+        this._onOnline = () => {
+            this._tryAddCustomEvent("browser online", {});
+        };
+        this._onVisibilityChange = () => {
+            if (globals_1.document === null || globals_1.document === void 0 ? void 0 : globals_1.document.visibilityState) {
+                const label = "window " + globals_1.document.visibilityState;
+                this._tryAddCustomEvent(label, {});
+            }
+        };
+        this._instance = instance;
+        this._config = config;
+        this._buffer = this._clearBuffer();
+    }
+    // ============================================================================
+    // Public API (implements LazyLoadedSessionRecordingInterface)
+    // ============================================================================
+    get isStarted() {
+        return this._captureStarted;
+    }
+    /** @deprecated Use isStarted instead */
+    get started() {
+        return this._captureStarted;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    get status() {
+        if (!this._captureStarted) {
+            return "disabled";
+        }
+        if (this._isIdle === true) {
+            return "paused";
+        }
+        return "active";
+    }
+    /**
+     * Start session recording (interface method)
+     */
+    start(startReason) {
+        if (!this._isRecordingEnabled()) {
+            this.stop();
+            return;
+        }
+        this._startCapture(startReason);
+        // Add event listeners
+        if (globals_1.window) {
+            (0, utils_1.addEventListener)(globals_1.window, "beforeunload", this._onBeforeUnload);
+            (0, utils_1.addEventListener)(globals_1.window, "offline", this._onOffline);
+            (0, utils_1.addEventListener)(globals_1.window, "online", this._onOnline);
+            (0, utils_1.addEventListener)(globals_1.window, "visibilitychange", this._onVisibilityChange);
+        }
+    }
+    /**
+     * Stop session recording (interface method)
+     */
+    stop() {
+        if (this._captureStarted && this._stopRrweb) {
+            this._stopRrweb();
+            this._stopRrweb = undefined;
+            this._captureStarted = false;
+            if (globals_1.window) {
+                globals_1.window.removeEventListener("beforeunload", this._onBeforeUnload);
+                globals_1.window.removeEventListener("offline", this._onOffline);
+                globals_1.window.removeEventListener("online", this._onOnline);
+                globals_1.window.removeEventListener("visibilitychange", this._onVisibilityChange);
+            }
+            this._clearBuffer();
+            if (this._fullSnapshotTimer) {
+                clearInterval(this._fullSnapshotTimer);
+            }
+            console.info(`${LOGGER_PREFIX} stopped`);
+        }
+    }
+    /** @deprecated Use stop() instead */
+    stopRecording() {
+        this.stop();
+    }
+    /**
+     * Add a custom event to the recording
+     */
+    addCustomEvent(tag, payload) {
+        return this._tryAddCustomEvent(tag, payload);
+    }
+    /**
+     * Take a full snapshot
+     */
+    takeFullSnapshot() {
+        return this._tryTakeFullSnapshot();
+    }
+    /**
+     * Log a message to the recording
+     */
+    log(message, level = "log") {
+        this.onRRwebEmit({
+            type: 6, // Plugin event type
+            data: {
+                plugin: "rrweb/console@1",
+                payload: {
+                    level,
+                    trace: [],
+                    payload: [JSON.stringify(message)],
+                },
+            },
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this._config = { ...this._config, ...config };
+    }
+    // ============================================================================
+    // Recording Control
+    // ============================================================================
+    _isRecordingEnabled() {
+        return !!this._config.enabled && !!globals_1.window;
+    }
+    _startCapture(startReason) {
+        // Check for required features
+        if (typeof Object.assign === "undefined" ||
+            typeof Array.from === "undefined") {
+            return;
+        }
+        if (this._captureStarted) {
+            return;
+        }
+        this._captureStarted = true;
+        // Update session/window IDs
+        const sessionId = this._instance.getSessionId();
+        this._sessionId = sessionId || this._generateId();
+        this._windowId = this._generateId();
+        // Load rrweb if not already loaded
+        if (!getRRWebRecord()) {
+            this._loadRecorder(() => {
+                this._onScriptLoaded();
+            });
+        }
+        else {
+            this._onScriptLoaded();
+        }
+        console.info(`${LOGGER_PREFIX} starting`);
+        if (startReason) {
+            this._reportStarted(startReason);
+        }
+    }
+    _loadRecorder(callback) {
+        var _a;
+        // Use the external script loader to dynamically load the recorder
+        const loadExternalDependency = (_a = globals_1.assignableWindow.__VTiltExtensions__) === null || _a === void 0 ? void 0 : _a.loadExternalDependency;
+        if (!loadExternalDependency) {
+            console.error(`${LOGGER_PREFIX} loadExternalDependency not available. Make sure external-scripts-loader is initialized.`);
+            return;
+        }
+        loadExternalDependency(this._instance, "recorder", (err) => {
+            if (err) {
+                console.error(`${LOGGER_PREFIX} Could not load recorder:`, err);
+                return;
+            }
+            callback();
+        });
+    }
+    _onScriptLoaded() {
+        var _a, _b;
+        const rrwebRecord = getRRWebRecord();
+        if (!rrwebRecord) {
+            console.error(`${LOGGER_PREFIX} onScriptLoaded was called but rrwebRecord is not available`);
+            return;
+        }
+        // Build rrweb options
+        const sessionRecordingOptions = {
+            blockClass: this._config.blockClass || "vt-no-capture",
+            blockSelector: this._config.blockSelector,
+            ignoreClass: this._config.ignoreClass || "vt-ignore-input",
+            maskTextClass: this._config.maskTextClass || "vt-mask",
+            maskTextSelector: this._config.maskTextSelector,
+            maskTextFn: undefined,
+            maskAllInputs: (_a = this._config.maskAllInputs) !== null && _a !== void 0 ? _a : true,
+            maskInputOptions: { password: true, ...this._config.maskInputOptions },
+            maskInputFn: undefined,
+            slimDOMOptions: {},
+            collectFonts: false,
+            inlineStylesheet: true,
+            recordCrossOriginIframes: false,
+        };
+        // Canvas recording
+        const canvasConfig = this._getCanvasConfig();
+        if (canvasConfig.enabled) {
+            sessionRecordingOptions.recordCanvas = true;
+            sessionRecordingOptions.sampling = { canvas: canvasConfig.fps };
+            sessionRecordingOptions.dataURLOptions = {
+                type: "image/webp",
+                quality: canvasConfig.quality,
+            };
+        }
+        // Masking
+        const maskingConfig = this._getMaskingConfig();
+        if (maskingConfig) {
+            sessionRecordingOptions.maskAllInputs =
+                (_b = maskingConfig.maskAllInputs) !== null && _b !== void 0 ? _b : true;
+            sessionRecordingOptions.maskTextSelector = maskingConfig.maskTextSelector;
+            sessionRecordingOptions.blockSelector = maskingConfig.blockSelector;
+        }
+        // Gather plugins
+        const plugins = this._gatherRRWebPlugins();
+        // Start recording
+        this._stopRrweb = rrwebRecord({
+            emit: (event) => {
+                this.onRRwebEmit(event);
+            },
+            plugins,
+            ...sessionRecordingOptions,
+        });
+        // Reset activity tracking
+        this._lastActivityTimestamp = Date.now();
+        this._isIdle = typeof this._isIdle === "boolean" ? this._isIdle : "unknown";
+        // Add custom events for debugging
+        this._tryAddCustomEvent("$session_options", {
+            sessionRecordingOptions,
+            activePlugins: plugins.map((p) => p === null || p === void 0 ? void 0 : p.name),
+        });
+    }
+    _gatherRRWebPlugins() {
+        var _a, _b;
+        const plugins = [];
+        // Console recording plugin
+        if (this._config.captureConsole) {
+            try {
+                const getRecordConsolePlugin = (_b = (_a = globals_1.assignableWindow.__VTiltExtensions__) === null || _a === void 0 ? void 0 : _a.rrwebPlugins) === null || _b === void 0 ? void 0 : _b.getRecordConsolePlugin;
+                if (getRecordConsolePlugin) {
+                    plugins.push(getRecordConsolePlugin());
+                }
+            }
+            catch (e) {
+                console.warn(`${LOGGER_PREFIX} Failed to load console plugin`, e);
+            }
+        }
+        return plugins;
+    }
+    // ============================================================================
+    // Event Processing
+    // ============================================================================
+    onRRwebEmit(rawEvent) {
+        this._processQueuedEvents();
+        if (!rawEvent || typeof rawEvent !== "object") {
+            return;
+        }
+        // Handle meta events (page URL)
+        if (rawEvent.type === types_1.EventType.Meta) {
+            const metaData = rawEvent.data;
+            this._lastHref = metaData.href;
+        }
+        // Skip if recording is paused
+        if ((0, session_recording_utils_1.isRecordingPausedEvent)(rawEvent)) {
+            // Allow recording paused events through
+        }
+        else if (this._isIdle === true) {
+            return;
+        }
+        // Schedule full snapshot on full snapshot events
+        if (rawEvent.type === types_1.EventType.FullSnapshot) {
+            this._scheduleFullSnapshot();
+        }
+        // Truncate large console logs
+        const event = (0, session_recording_utils_1.truncateLargeConsoleLogs)(rawEvent);
+        // Update session/window IDs based on activity
+        this._updateWindowAndSessionIds(event);
+        // Skip idle events unless it's the idle marker
+        if (this._isIdle === true && !(0, session_recording_utils_1.isSessionIdleEvent)(event)) {
+            return;
+        }
+        // Compress event if enabled
+        const eventToSend = this._config.compressEvents !== false ? (0, session_recording_utils_1.compressEvent)(event) : event;
+        const size = (0, session_recording_utils_1.estimateSize)(eventToSend);
+        const properties = {
+            $snapshot_bytes: size,
+            $snapshot_data: eventToSend,
+            $session_id: this._sessionId,
+            $window_id: this._windowId,
+        };
+        if (this.status === "disabled") {
+            this._clearBuffer();
+            return;
+        }
+        this._captureSnapshotBuffered(properties);
+    }
+    _processQueuedEvents() {
+        if (this._queuedRRWebEvents.length === 0) {
+            return;
+        }
+        const itemsToProcess = [...this._queuedRRWebEvents];
+        this._queuedRRWebEvents = [];
+        itemsToProcess.forEach((queuedEvent) => {
+            if (Date.now() - queuedEvent.enqueuedAt <= TWO_SECONDS) {
+                this._tryRRWebMethod(queuedEvent);
+            }
+        });
+    }
+    _updateWindowAndSessionIds(event) {
+        const isUserInteraction = (0, session_recording_utils_1.isInteractiveEvent)(event);
+        // Check for idle state
+        if (!isUserInteraction && !this._isIdle) {
+            const timeSinceLastActivity = event.timestamp - this._lastActivityTimestamp;
+            const idleThreshold = this._config.sessionIdleThresholdMs || session_recording_utils_1.RECORDING_IDLE_THRESHOLD_MS;
+            if (timeSinceLastActivity > idleThreshold) {
+                this._isIdle = true;
+                // Clear full snapshot timer while idle
+                if (this._fullSnapshotTimer) {
+                    clearInterval(this._fullSnapshotTimer);
+                }
+                this._tryAddCustomEvent("sessionIdle", {
+                    eventTimestamp: event.timestamp,
+                    lastActivityTimestamp: this._lastActivityTimestamp,
+                    threshold: idleThreshold,
+                    bufferLength: this._buffer.data.length,
+                    bufferSize: this._buffer.size,
+                });
+                this._flushBuffer();
+            }
+        }
+        // Handle returning from idle
+        let returningFromIdle = false;
+        if (isUserInteraction) {
+            this._lastActivityTimestamp = event.timestamp;
+            if (this._isIdle) {
+                const idleWasUnknown = this._isIdle === "unknown";
+                this._isIdle = false;
+                if (!idleWasUnknown) {
+                    this._tryAddCustomEvent("sessionNoLongerIdle", {
+                        reason: "user activity",
+                        type: event.type,
+                    });
+                    returningFromIdle = true;
+                }
+            }
+        }
+        if (this._isIdle) {
+            return;
+        }
+        // Check for session/window ID changes
+        const newSessionId = this._instance.getSessionId();
+        if (newSessionId && newSessionId !== this._sessionId) {
+            this._sessionId = newSessionId;
+            this._windowId = this._generateId();
+            this.stop();
+            this.start("session_id_changed");
+        }
+        else if (returningFromIdle) {
+            this._scheduleFullSnapshot();
+        }
+    }
+    // ============================================================================
+    // Buffer Management
+    // ============================================================================
+    _clearBuffer() {
+        this._buffer = {
+            size: 0,
+            data: [],
+            sessionId: this._sessionId,
+            windowId: this._windowId,
+        };
+        return this._buffer;
+    }
+    _flushBuffer() {
+        if (this._flushBufferTimer) {
+            clearTimeout(this._flushBufferTimer);
+            this._flushBufferTimer = undefined;
+        }
+        if (this.status === "buffering" ||
+            this.status === "paused" ||
+            this.status === "disabled") {
+            this._flushBufferTimer = setTimeout(() => {
+                this._flushBuffer();
+            }, session_recording_utils_1.RECORDING_BUFFER_TIMEOUT);
+            return this._buffer;
+        }
+        if (this._buffer.data.length > 0) {
+            const snapshotBuffers = (0, session_recording_utils_1.splitBuffer)(this._buffer);
+            snapshotBuffers.forEach((snapshotBuffer) => {
+                this._captureSnapshot({
+                    $snapshot_bytes: snapshotBuffer.size,
+                    $snapshot_data: snapshotBuffer.data,
+                    $session_id: snapshotBuffer.sessionId,
+                    $window_id: snapshotBuffer.windowId,
+                });
+            });
+        }
+        return this._clearBuffer();
+    }
+    _captureSnapshotBuffered(properties) {
+        var _a;
+        const additionalBytes = 2 + (((_a = this._buffer) === null || _a === void 0 ? void 0 : _a.data.length) || 0);
+        const snapshotBytes = properties.$snapshot_bytes;
+        if (!this._isIdle &&
+            (this._buffer.size + snapshotBytes + additionalBytes >
+                session_recording_utils_1.RECORDING_MAX_EVENT_SIZE ||
+                this._buffer.sessionId !== this._sessionId)) {
+            this._buffer = this._flushBuffer();
+        }
+        this._buffer.size += snapshotBytes;
+        this._buffer.data.push(properties.$snapshot_data);
+        if (!this._flushBufferTimer && !this._isIdle) {
+            this._flushBufferTimer = setTimeout(() => {
+                this._flushBuffer();
+            }, session_recording_utils_1.RECORDING_BUFFER_TIMEOUT);
+        }
+    }
+    _captureSnapshot(properties) {
+        // Send directly to /s/ endpoint (dedicated session recording endpoint)
+        const config = this._instance.getConfig();
+        const apiHost = config.api_host || "";
+        const token = config.token || "";
+        if (!apiHost || !token) {
+            console.warn(`${LOGGER_PREFIX} Missing api_host or token, cannot send snapshot`);
+            return;
+        }
+        const useCompression = this._config.compressEvents !== false;
+        const url = `${apiHost.replace(/\/$/, "")}${this._endpoint}?token=${encodeURIComponent(token)}${useCompression ? "&compression=gzip-js" : ""}`;
+        // PostHog-compatible payload format
+        const payload = {
+            token,
+            distinct_id: this._instance.getDistinctId() || "",
+            $session_id: this._sessionId,
+            $window_id: this._windowId,
+            $snapshot_data: properties.$snapshot_data,
+            $snapshot_bytes: properties.$snapshot_bytes,
+            $lib: "web",
+            $lib_version: this._instance.version || "unknown",
+            timestamp: Date.now(),
+        };
+        // Send using beacon or fetch
+        this._sendSnapshot(url, payload, useCompression);
+    }
+    _sendSnapshot(url, payload, useCompression) {
+        const payloadString = JSON.stringify(payload);
+        // Check if payload contains FullSnapshot (type 2)
+        // FullSnapshots are critical and should use fetch (not sendBeacon) to ensure delivery
+        const snapshotData = payload.$snapshot_data;
+        const hasFullSnapshot = Array.isArray(snapshotData) && snapshotData.some((e) => (e === null || e === void 0 ? void 0 : e.type) === 2);
+        // sendBeacon has ~64KB limit - use fetch for larger payloads or payloads with FullSnapshot
+        const BEACON_SIZE_LIMIT = 60000; // 60KB to be safe
+        const shouldUseFetch = payloadString.length > BEACON_SIZE_LIMIT || hasFullSnapshot;
+        // Try to compress if enabled
+        if (useCompression && typeof globals_1.window !== "undefined") {
+            try {
+                const compressed = (0, fflate_1.gzipSync)((0, fflate_1.strToU8)(payloadString));
+                // Create blob from Uint8Array - cast to any to avoid TypeScript issues with ArrayBufferLike
+                const blob = new Blob([compressed], {
+                    type: "application/octet-stream",
+                });
+                // Use fetch for large payloads or those with FullSnapshot
+                if (shouldUseFetch) {
+                    this._fetchWithRetry(url, blob, "application/octet-stream");
+                    return;
+                }
+                // Try sendBeacon for smaller payloads without FullSnapshot
+                if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+                    const sent = navigator.sendBeacon(url, blob);
+                    if (sent) {
+                        return;
+                    }
+                }
+                // Fall back to fetch with retry
+                this._fetchWithRetry(url, blob, "application/octet-stream");
+                return;
+            }
+            catch (_a) {
+                // Fall through to uncompressed
+                console.warn(`${LOGGER_PREFIX} Compression failed, sending uncompressed`);
+            }
+        }
+        // Uncompressed fallback
+        const uncompressedUrl = url.replace("&compression=gzip-js", "");
+        // Use fetch for large payloads or those with FullSnapshot
+        if (shouldUseFetch) {
+            const blob = new Blob([payloadString], { type: "application/json" });
+            this._fetchWithRetry(uncompressedUrl, blob, "application/json");
+            return;
+        }
+        if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+            const blob = new Blob([payloadString], { type: "application/json" });
+            const sent = navigator.sendBeacon(uncompressedUrl, blob);
+            if (sent) {
+                return;
+            }
+        }
+        // Fall back to fetch with retry
+        const blob = new Blob([payloadString], { type: "application/json" });
+        this._fetchWithRetry(uncompressedUrl, blob, "application/json");
+    }
+    /**
+     * Fetch with exponential backoff retry (PostHog-style)
+     * Retries on network errors and 5xx server errors
+     */
+    _fetchWithRetry(url, body, contentType, attempt = 0) {
+        // keepalive has a 64KB limit - disable for larger payloads (like FullSnapshots)
+        const KEEPALIVE_THRESHOLD = 60000; // 60KB to be safe
+        const useKeepalive = body.size < KEEPALIVE_THRESHOLD;
+        fetch(url, {
+            method: "POST",
+            body,
+            headers: {
+                "Content-Type": contentType,
+            },
+            keepalive: useKeepalive,
+        })
+            .then((response) => {
+            // Success - no action needed
+            if (response.ok) {
+                return;
+            }
+            // Client error (4xx) - don't retry
+            if (response.status >= 400 && response.status < 500) {
+                console.warn(`${LOGGER_PREFIX} Snapshot rejected by server (${response.status}), not retrying`);
+                return;
+            }
+            // Server error (5xx) - retry
+            this._scheduleRetry(url, body, contentType, attempt);
+        })
+            .catch(() => {
+            // Network error - retry
+            this._scheduleRetry(url, body, contentType, attempt);
+        });
+    }
+    /**
+     * Schedule a retry with exponential backoff and jitter
+     */
+    _scheduleRetry(url, body, contentType, attempt) {
+        if (attempt >= MAX_SNAPSHOT_RETRIES) {
+            console.warn(`${LOGGER_PREFIX} Failed to send snapshot after ${MAX_SNAPSHOT_RETRIES} retries, giving up`);
+            return;
+        }
+        // Exponential backoff with jitter: 3s, 6s, 12s, 24s... capped at 30s
+        const baseDelay = INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt);
+        const cappedDelay = Math.min(baseDelay, MAX_RETRY_DELAY_MS);
+        const jitter = (Math.random() - 0.5) * cappedDelay; // +/- 50%
+        const delay = Math.ceil(cappedDelay + jitter);
+        console.warn(`${LOGGER_PREFIX} Snapshot send failed, retrying in ${Math.round(delay / 1000)}s (attempt ${attempt + 1}/${MAX_SNAPSHOT_RETRIES})`);
+        setTimeout(() => {
+            this._fetchWithRetry(url, body, contentType, attempt + 1);
+        }, delay);
+    }
+    // ============================================================================
+    // Snapshot Scheduling
+    // ============================================================================
+    _scheduleFullSnapshot() {
+        if (this._fullSnapshotTimer) {
+            clearInterval(this._fullSnapshotTimer);
+        }
+        if (this._isIdle === true) {
+            return;
+        }
+        const interval = this._config.fullSnapshotIntervalMs || FIVE_MINUTES;
+        if (!interval) {
+            return;
+        }
+        this._fullSnapshotTimer = setInterval(() => {
+            this._tryTakeFullSnapshot();
+        }, interval);
+    }
+    // ============================================================================
+    // RRWeb Method Helpers
+    // ============================================================================
+    _tryRRWebMethod(queuedEvent) {
+        try {
+            queuedEvent.rrwebMethod();
+            return true;
+        }
+        catch (e) {
+            if (this._queuedRRWebEvents.length < 10) {
+                this._queuedRRWebEvents.push({
+                    enqueuedAt: queuedEvent.enqueuedAt || Date.now(),
+                    attempt: queuedEvent.attempt + 1,
+                    rrwebMethod: queuedEvent.rrwebMethod,
+                });
+            }
+            else {
+                console.warn(`${LOGGER_PREFIX} Could not emit queued rrweb event`, e, queuedEvent);
+            }
+            return false;
+        }
+    }
+    _tryAddCustomEvent(tag, payload) {
+        return this._tryRRWebMethod(newQueuedEvent(() => getRRWebRecord().addCustomEvent(tag, payload)));
+    }
+    _tryTakeFullSnapshot() {
+        return this._tryRRWebMethod(newQueuedEvent(() => getRRWebRecord().takeFullSnapshot()));
+    }
+    // ============================================================================
+    // Configuration Helpers
+    // ============================================================================
+    _getCanvasConfig() {
+        var _a, _b, _c;
+        const captureCanvas = this._config.captureCanvas;
+        const enabled = (_a = captureCanvas === null || captureCanvas === void 0 ? void 0 : captureCanvas.recordCanvas) !== null && _a !== void 0 ? _a : false;
+        const fps = (_b = captureCanvas === null || captureCanvas === void 0 ? void 0 : captureCanvas.canvasFps) !== null && _b !== void 0 ? _b : DEFAULT_CANVAS_FPS;
+        const quality = (_c = captureCanvas === null || captureCanvas === void 0 ? void 0 : captureCanvas.canvasQuality) !== null && _c !== void 0 ? _c : DEFAULT_CANVAS_QUALITY;
+        return {
+            enabled,
+            fps: (0, session_recording_utils_1.clampToRange)(fps, 0, MAX_CANVAS_FPS, "canvas recording fps", DEFAULT_CANVAS_FPS),
+            quality: (0, session_recording_utils_1.clampToRange)(quality, 0, MAX_CANVAS_QUALITY, "canvas recording quality", DEFAULT_CANVAS_QUALITY),
+        };
+    }
+    _getMaskingConfig() {
+        var _a;
+        const masking = this._config.masking;
+        if (!masking) {
+            return undefined;
+        }
+        return {
+            maskAllInputs: (_a = masking.maskAllInputs) !== null && _a !== void 0 ? _a : true,
+            maskTextSelector: masking.maskTextSelector,
+            blockSelector: masking.blockSelector,
+        };
+    }
+    // ============================================================================
+    // Utility Methods
+    // ============================================================================
+    _generateId() {
+        return Math.random().toString(36).substring(2, 15);
+    }
+    _reportStarted(startReason, tagPayload) {
+        console.info(`${LOGGER_PREFIX} ${startReason.replace(/_/g, " ")}`, tagPayload);
+        if (startReason !== "recording_initialized" &&
+            startReason !== "session_id_changed") {
+            this._tryAddCustomEvent(startReason, tagPayload);
+        }
+    }
+}
+exports.LazyLoadedSessionRecording = LazyLoadedSessionRecording;