@v-tilt/browser 1.1.5 → 1.2.0

package/dist/types.d.ts

@@ -12,6 +12,13 @@ export interface VTiltConfig {
     api_host?: string;
     /** UI host for dashboard links */
     ui_host?: string | null;
+    /**
+     * Host for loading extension scripts (recorder.js, etc.)
+     * Defaults to unpkg CDN: https://unpkg.com/@v-tilt/browser@{version}/dist
+     * Can also use jsdelivr: https://cdn.jsdelivr.net/npm/@v-tilt/browser@{version}/dist
+     * Or self-hosted: https://your-domain.com/static
+     */
+    script_host?: string;
     /** Proxy domain for tracking requests */
     proxy?: string;
     /** Full proxy URL for tracking requests */
@@ -64,6 +71,10 @@ export interface VTiltConfig {
     respect_dnt?: boolean;
     /** Opt users out by default */
     opt_out_capturing_by_default?: boolean;
+    /** Session recording configuration */
+    session_recording?: SessionRecordingOptions;
+    /** Disable session recording (convenience flag) */
+    disable_session_recording?: boolean;
     /** Global attributes added to all events */
     globalAttributes?: Record<string, string>;
     /** Bootstrap data for initialization */
@@ -176,14 +187,83 @@ export interface RequestOptions {
     timeout?: number;
     retry?: boolean;
 }
+/** Mask options for input elements in session recording */
+export interface SessionRecordingMaskInputOptions {
+    color?: boolean;
+    date?: boolean;
+    "datetime-local"?: boolean;
+    email?: boolean;
+    month?: boolean;
+    number?: boolean;
+    range?: boolean;
+    search?: boolean;
+    tel?: boolean;
+    text?: boolean;
+    time?: boolean;
+    url?: boolean;
+    week?: boolean;
+    textarea?: boolean;
+    select?: boolean;
+    password?: boolean;
+}
+/** Session recording configuration */
+export interface SessionRecordingOptions {
+    /** Enable session recording */
+    enabled?: boolean;
+    /** Sample rate (0-1, where 1 = 100%) */
+    sampleRate?: number;
+    /** Minimum session duration in ms before sending */
+    minimumDurationMs?: number;
+    /** Session idle threshold in ms (default: 5 minutes) */
+    sessionIdleThresholdMs?: number;
+    /** Full snapshot interval in ms (default: 5 minutes) */
+    fullSnapshotIntervalMs?: number;
+    /** Enable console log capture */
+    captureConsole?: boolean;
+    /** Enable network request capture */
+    captureNetwork?: boolean;
+    /** Canvas recording settings */
+    captureCanvas?: {
+        recordCanvas?: boolean;
+        canvasFps?: number;
+        canvasQuality?: number;
+    };
+    /** Block class for elements to hide (default: 'vt-no-capture') */
+    blockClass?: string;
+    /** Block selector for elements to hide */
+    blockSelector?: string;
+    /** Ignore class for input masking (default: 'vt-ignore-input') */
+    ignoreClass?: string;
+    /** Mask text class (default: 'vt-mask') */
+    maskTextClass?: string;
+    /** Mask text selector */
+    maskTextSelector?: string;
+    /** Mask all inputs (default: true) */
+    maskAllInputs?: boolean;
+    /** Mask input options */
+    maskInputOptions?: SessionRecordingMaskInputOptions;
+    /** Masking configuration */
+    masking?: {
+        maskAllInputs?: boolean;
+        maskTextSelector?: string;
+        blockSelector?: string;
+    };
+    /** Record headers in network requests */
+    recordHeaders?: boolean;
+    /** Record body in network requests */
+    recordBody?: boolean;
+    /** Compress events before sending (default: true) */
+    compressEvents?: boolean;
+    /** Internal: Mutation throttler refill rate */
+    __mutationThrottlerRefillRate?: number;
+    /** Internal: Mutation throttler bucket size */
+    __mutationThrottlerBucketSize?: number;
+}
 export interface RemoteConfig {
     /** Default to identified_only mode */
     defaultIdentifiedOnly?: boolean;
     /** Feature flags */
     featureFlags?: FeatureFlagsConfig;
     /** Session recording config */
-    sessionRecording?: {
-        enabled?: boolean;
-        sampleRate?: number;
-    };
+    sessionRecording?: SessionRecordingOptions;
 }

package/dist/utils/globals.d.ts

@@ -1,6 +1,48 @@
 declare const win: (Window & typeof globalThis) | undefined;
+/**
+ * Extension kinds that can be lazy loaded
+ */
+export type VTiltExtensionKind = "recorder" | "web-vitals";
+/**
+ * Interface for lazy-loaded session recording (set by recorder.ts)
+ * Matches LazyLoadedSessionRecordingInterface in session-recording-wrapper.ts
+ */
+export interface LazyLoadedSessionRecordingInterface {
+    start: (startReason?: string) => void;
+    stop: () => void;
+    sessionId: string;
+    status: string;
+    isStarted: boolean;
+    onRemoteConfig?: (response: any) => void;
+    log: (message: string, level: "log" | "warn" | "error") => void;
+    updateConfig: (config: any) => void;
+}
+/**
+ * VTilt Extensions interface for dynamically loaded modules
+ * This is the contract between lazily loaded extensions and the SDK
+ */
+export interface VTiltExtensions {
+    /** Load an external dependency script */
+    loadExternalDependency?: (instance: any, // VTilt instance - using any to avoid circular imports
+    kind: VTiltExtensionKind, callback: (error?: string | Event, event?: Event) => void) => void;
+    /** rrweb record function (set by recorder.ts) */
+    rrweb?: {
+        record: any;
+        version?: string;
+    };
+    /** rrweb plugins (set by recorder.ts) */
+    rrwebPlugins?: {
+        getRecordConsolePlugin?: () => any;
+        getRecordNetworkPlugin?: (options: any) => any;
+    };
+    /** Factory to create LazyLoadedSessionRecording (set by recorder.ts) */
+    initSessionRecording?: (instance: any, config?: any) => LazyLoadedSessionRecordingInterface;
+}
 export type AssignableWindow = Window & typeof globalThis & {
+    /** Main VTilt instance */
     vt: any;
+    /** VTilt Extensions for dynamically loaded modules */
+    __VTiltExtensions__?: VTiltExtensions;
 };
 export declare const ArrayProto: any[];
 export declare const nativeForEach: (callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void;

package/dist/vtilt.d.ts

@@ -1,7 +1,9 @@
 import { VTiltConfig, EventPayload } from "./types";
 import { HistoryAutocapture } from "./extensions/history-autocapture";
+import { SessionRecordingWrapper } from "./extensions/replay";
 import { type QueuedRequest } from "./request-queue";
 export declare class VTilt {
+    readonly version = "1.1.5";
     private configManager;
     private sessionManager;
     private userManager;
@@ -10,6 +12,7 @@ export declare class VTilt {
     private retryQueue;
     private rateLimiter;
     historyAutocapture?: HistoryAutocapture;
+    sessionRecording?: SessionRecordingWrapper;
     __loaded: boolean;
     private _initial_pageview_captured;
     private _visibility_state_listener;
@@ -236,10 +239,43 @@ export declare class VTilt {
      * Get current session ID
      */
     getSessionId(): string | null;
+    /**
+     * Get current distinct ID
+     */
+    getDistinctId(): string;
+    /**
+     * Get anonymous ID
+     */
+    getAnonymousId(): string;
     /**
      * Update configuration
      */
     updateConfig(config: Partial<VTiltConfig>): void;
+    /**
+     * Initialize session recording
+     */
+    private _initSessionRecording;
+    /**
+     * Build session recording config from VTiltConfig
+     */
+    private _buildSessionRecordingConfig;
+    /**
+     * Start session recording
+     * Call this to manually start recording if it wasn't enabled initially
+     */
+    startSessionRecording(): void;
+    /**
+     * Stop session recording
+     */
+    stopSessionRecording(): void;
+    /**
+     * Check if session recording is active
+     */
+    isSessionRecordingActive(): boolean;
+    /**
+     * Get session recording ID
+     */
+    getSessionRecordingId(): string | null;
     /**
      * _execute_array() deals with processing any vTilt function
      * calls that were called before the vTilt library was loaded

package/lib/config.js

@@ -25,6 +25,8 @@ class ConfigManager {
             script.getAttribute("data-api-host") ||
                 script.getAttribute("data-host") ||
                 initialConfig.api_host;
+        config.script_host =
+            script.getAttribute("data-script-host") || initialConfig.script_host;
         config.proxy = script.getAttribute("data-proxy") || initialConfig.proxy;
         config.proxyUrl =
             script.getAttribute("data-proxy-url") || initialConfig.proxyUrl;

package/lib/entrypoints/array.d.ts

@@ -1 +1,2 @@
+import "./external-scripts-loader";
 import "./array.no-external";

package/lib/entrypoints/array.js

@@ -1,3 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+require("./external-scripts-loader");
 require("./array.no-external");

package/lib/entrypoints/external-scripts-loader.d.ts

@@ -0,0 +1,24 @@
+/**
+ * External Scripts Loader
+ *
+ * Dynamically loads external scripts (like rrweb) from CDN.
+ * Based on PostHog's implementation.
+ */
+import type { VTilt } from "../vtilt";
+import { VTiltExtensionKind } from "../utils/globals";
+/**
+ * Load a script dynamically
+ */
+declare const loadScript: (vtilt: VTilt, url: string, callback: (error?: string | Event, event?: Event) => void) => void;
+/**
+ * Get the URL for an extension script
+ *
+ * Priority:
+ * 1. script_host config (if set) - loads from {script_host}/dist/{kind}.js
+ * 2. Default to unpkg CDN for npm package
+ *
+ * Note: script_host should be the base URL (e.g., "https://cdn.example.com")
+ * The /dist/ path is automatically appended to match the npm package structure
+ */
+declare const getExtensionUrl: (vtilt: VTilt, kind: VTiltExtensionKind) => string;
+export { loadScript, getExtensionUrl };

package/lib/entrypoints/external-scripts-loader.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * External Scripts Loader
+ *
+ * Dynamically loads external scripts (like rrweb) from CDN.
+ * Based on PostHog's implementation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExtensionUrl = exports.loadScript = void 0;
+const globals_1 = require("../utils/globals");
+const LOGGER_PREFIX = "[ExternalScriptsLoader]";
+/**
+ * Load a script dynamically
+ */
+const loadScript = (vtilt, url, callback) => {
+    const config = vtilt.getConfig();
+    // Check if external script loading is disabled
+    if (config.disable_external_dependency_loading) {
+        console.warn(`${LOGGER_PREFIX} ${url} was requested but loading of external scripts is disabled.`);
+        return callback("Loading of external scripts is disabled");
+    }
+    // Check if script is already loaded
+    const existingScripts = globals_1.document === null || globals_1.document === void 0 ? void 0 : globals_1.document.querySelectorAll("script");
+    if (existingScripts) {
+        for (let i = 0; i < existingScripts.length; i++) {
+            if (existingScripts[i].src === url) {
+                const alreadyExistingScriptTag = existingScripts[i];
+                if (alreadyExistingScriptTag.__vtilt_loading_callback_fired) {
+                    // Script already exists and fired its load event
+                    return callback();
+                }
+                // Script exists but hasn't loaded yet - attach callback
+                alreadyExistingScriptTag.addEventListener("load", (event) => {
+                    alreadyExistingScriptTag.__vtilt_loading_callback_fired = true;
+                    callback(undefined, event);
+                });
+                alreadyExistingScriptTag.onerror = (error) => callback(error);
+                return;
+            }
+        }
+    }
+    const addScript = () => {
+        var _a;
+        if (!globals_1.document) {
+            return callback("document not found");
+        }
+        const scriptTag = globals_1.document.createElement("script");
+        scriptTag.type = "text/javascript";
+        scriptTag.crossOrigin = "anonymous";
+        scriptTag.src = url;
+        scriptTag.onload = (event) => {
+            scriptTag.__vtilt_loading_callback_fired = true;
+            callback(undefined, event);
+        };
+        scriptTag.onerror = (error) => callback(error);
+        const scripts = globals_1.document.querySelectorAll("body > script");
+        if (scripts.length > 0) {
+            (_a = scripts[0].parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(scriptTag, scripts[0]);
+        }
+        else {
+            globals_1.document.body.appendChild(scriptTag);
+        }
+    };
+    if (globals_1.document === null || globals_1.document === void 0 ? void 0 : globals_1.document.body) {
+        addScript();
+    }
+    else {
+        globals_1.document === null || globals_1.document === void 0 ? void 0 : globals_1.document.addEventListener("DOMContentLoaded", addScript);
+    }
+};
+exports.loadScript = loadScript;
+/**
+ * SDK version - used for loading correct script version from CDN
+ */
+const SDK_VERSION = "1.1.5";
+/**
+ * Get the URL for an extension script
+ *
+ * Priority:
+ * 1. script_host config (if set) - loads from {script_host}/dist/{kind}.js
+ * 2. Default to unpkg CDN for npm package
+ *
+ * Note: script_host should be the base URL (e.g., "https://cdn.example.com")
+ * The /dist/ path is automatically appended to match the npm package structure
+ */
+const getExtensionUrl = (vtilt, kind) => {
+    const config = vtilt.getConfig();
+    // Use script_host if configured (matches snippet behavior: script_host+"/dist/array.js")
+    if (config.script_host) {
+        const cleanHost = config.script_host.replace(/\/+$/gm, "");
+        return `${cleanHost}/dist/${kind}.js`;
+    }
+    // Default: load from unpkg (npm CDN)
+    // This serves the file directly from the published @v-tilt/browser package
+    return `https://unpkg.com/@v-tilt/browser@${SDK_VERSION}/dist/${kind}.js`;
+};
+exports.getExtensionUrl = getExtensionUrl;
+// Initialize extensions object
+globals_1.assignableWindow.__VTiltExtensions__ =
+    globals_1.assignableWindow.__VTiltExtensions__ || {};
+/**
+ * Load an external dependency
+ */
+globals_1.assignableWindow.__VTiltExtensions__.loadExternalDependency = (vtilt, kind, callback) => {
+    const url = getExtensionUrl(vtilt, kind);
+    loadScript(vtilt, url, callback);
+};

package/lib/entrypoints/module.es.d.ts

@@ -1,3 +1,4 @@
+import "./external-scripts-loader";
 import vt from "./module.no-external.es";
 export * from "./module.no-external.es";
 export default vt;

package/lib/entrypoints/module.es.js

@@ -17,6 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+require("./external-scripts-loader");
 const module_no_external_es_1 = __importDefault(require("./module.no-external.es"));
 __exportStar(require("./module.no-external.es"), exports);
 exports.default = module_no_external_es_1.default;

package/lib/entrypoints/recorder.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Recorder Entrypoint
+ *
+ * This file is built as a separate bundle (recorder.js) that can be
+ * lazy-loaded when session recording is enabled.
+ *
+ * It exports:
+ * - rrweb.record: The rrweb record function
+ * - rrwebPlugins: Plugins for console recording
+ * - initSessionRecording: Factory function to create LazyLoadedSessionRecording
+ */
+import { record as rrwebRecord } from "@rrweb/record";
+import { LazyLoadedSessionRecordingInterface } from "../utils/globals";
+import type { SessionRecordingConfig } from "../extensions/replay/types";
+import type { VTilt } from "../vtilt";
+/**
+ * Factory function to create a LazyLoadedSessionRecording instance
+ *
+ * Called by SessionRecordingWrapper after the recorder script is loaded
+ */
+declare function initSessionRecording(instance: VTilt, config?: SessionRecordingConfig): LazyLoadedSessionRecordingInterface;
+export { initSessionRecording };
+export default rrwebRecord;

package/lib/entrypoints/recorder.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Recorder Entrypoint
+ *
+ * This file is built as a separate bundle (recorder.js) that can be
+ * lazy-loaded when session recording is enabled.
+ *
+ * It exports:
+ * - rrweb.record: The rrweb record function
+ * - rrwebPlugins: Plugins for console recording
+ * - initSessionRecording: Factory function to create LazyLoadedSessionRecording
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSessionRecording = initSessionRecording;
+const record_1 = require("@rrweb/record");
+const rrweb_plugin_console_record_1 = require("@rrweb/rrweb-plugin-console-record");
+const globals_1 = require("../utils/globals");
+const session_recording_1 = require("../extensions/replay/session-recording");
+// Initialize extensions object
+globals_1.assignableWindow.__VTiltExtensions__ =
+    globals_1.assignableWindow.__VTiltExtensions__ || {};
+// Register rrweb record function
+globals_1.assignableWindow.__VTiltExtensions__.rrweb = {
+    record: record_1.record,
+    version: "v2",
+};
+// Register rrweb plugins
+globals_1.assignableWindow.__VTiltExtensions__.rrwebPlugins = {
+    getRecordConsolePlugin: rrweb_plugin_console_record_1.getRecordConsolePlugin,
+};
+/**
+ * Factory function to create a LazyLoadedSessionRecording instance
+ *
+ * Called by SessionRecordingWrapper after the recorder script is loaded
+ */
+function initSessionRecording(instance, config) {
+    return new session_recording_1.LazyLoadedSessionRecording(instance, config);
+}
+// Register the factory function
+globals_1.assignableWindow.__VTiltExtensions__.initSessionRecording =
+    initSessionRecording;
+exports.default = record_1.record;

package/lib/extensions/replay/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Session Recording Extension
+ *
+ * Exports for rrweb session recording functionality.
+ *
+ * Architecture:
+ * - SessionRecordingWrapper: Lightweight wrapper in main bundle, handles lazy loading
+ * - LazyLoadedSessionRecording: Actual recording logic, loaded on demand via recorder.js
+ */
+export { SessionRecordingWrapper, LAZY_LOADING, type SessionRecordingStatus, type LazyLoadedSessionRecordingInterface, } from "./session-recording-wrapper";
+export { LazyLoadedSessionRecording } from "./session-recording";
+export type { SessionRecordingConfig, SessionStartReason, RecordOptions, RRWebRecord, SnapshotBuffer, CanvasRecordingConfig, NetworkPayloadCaptureConfig, MaskingConfig, TriggerType, } from "./types";
+export { compressEvent, estimateSize, truncateLargeConsoleLogs, splitBuffer, isSessionIdleEvent, isRecordingPausedEvent, isInteractiveEvent, RECORDING_MAX_EVENT_SIZE, RECORDING_BUFFER_TIMEOUT, RECORDING_IDLE_THRESHOLD_MS, } from "./session-recording-utils";

package/lib/extensions/replay/index.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Session Recording Extension
+ *
+ * Exports for rrweb session recording functionality.
+ *
+ * Architecture:
+ * - SessionRecordingWrapper: Lightweight wrapper in main bundle, handles lazy loading
+ * - LazyLoadedSessionRecording: Actual recording logic, loaded on demand via recorder.js
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECORDING_IDLE_THRESHOLD_MS = exports.RECORDING_BUFFER_TIMEOUT = exports.RECORDING_MAX_EVENT_SIZE = exports.isInteractiveEvent = exports.isRecordingPausedEvent = exports.isSessionIdleEvent = exports.splitBuffer = exports.truncateLargeConsoleLogs = exports.estimateSize = exports.compressEvent = exports.LazyLoadedSessionRecording = exports.LAZY_LOADING = exports.SessionRecordingWrapper = void 0;
+// Main export - the wrapper that lives in the main bundle
+var session_recording_wrapper_1 = require("./session-recording-wrapper");
+Object.defineProperty(exports, "SessionRecordingWrapper", { enumerable: true, get: function () { return session_recording_wrapper_1.SessionRecordingWrapper; } });
+Object.defineProperty(exports, "LAZY_LOADING", { enumerable: true, get: function () { return session_recording_wrapper_1.LAZY_LOADING; } });
+// Lazy-loaded implementation (only used in recorder.js bundle)
+var session_recording_1 = require("./session-recording");
+Object.defineProperty(exports, "LazyLoadedSessionRecording", { enumerable: true, get: function () { return session_recording_1.LazyLoadedSessionRecording; } });
+// Utilities
+var session_recording_utils_1 = require("./session-recording-utils");
+Object.defineProperty(exports, "compressEvent", { enumerable: true, get: function () { return session_recording_utils_1.compressEvent; } });
+Object.defineProperty(exports, "estimateSize", { enumerable: true, get: function () { return session_recording_utils_1.estimateSize; } });
+Object.defineProperty(exports, "truncateLargeConsoleLogs", { enumerable: true, get: function () { return session_recording_utils_1.truncateLargeConsoleLogs; } });
+Object.defineProperty(exports, "splitBuffer", { enumerable: true, get: function () { return session_recording_utils_1.splitBuffer; } });
+Object.defineProperty(exports, "isSessionIdleEvent", { enumerable: true, get: function () { return session_recording_utils_1.isSessionIdleEvent; } });
+Object.defineProperty(exports, "isRecordingPausedEvent", { enumerable: true, get: function () { return session_recording_utils_1.isRecordingPausedEvent; } });
+Object.defineProperty(exports, "isInteractiveEvent", { enumerable: true, get: function () { return session_recording_utils_1.isInteractiveEvent; } });
+Object.defineProperty(exports, "RECORDING_MAX_EVENT_SIZE", { enumerable: true, get: function () { return session_recording_utils_1.RECORDING_MAX_EVENT_SIZE; } });
+Object.defineProperty(exports, "RECORDING_BUFFER_TIMEOUT", { enumerable: true, get: function () { return session_recording_utils_1.RECORDING_BUFFER_TIMEOUT; } });
+Object.defineProperty(exports, "RECORDING_IDLE_THRESHOLD_MS", { enumerable: true, get: function () { return session_recording_utils_1.RECORDING_IDLE_THRESHOLD_MS; } });

package/lib/extensions/replay/session-recording-utils.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Session Recording Utilities
+ *
+ * Utility functions for session recording.
+ * Based on PostHog's sessionrecording-utils.ts
+ */
+import { EventType, IncrementalSource, eventWithTime } from "@rrweb/types";
+import type { SnapshotBuffer } from "./types";
+export declare const INCREMENTAL_SNAPSHOT_EVENT_TYPE = 3;
+export declare const ONE_KB = 1024;
+export declare const ONE_MB: number;
+export declare const SEVEN_MB: number;
+export declare const PARTIAL_COMPRESSION_THRESHOLD = 1024;
+export declare const RECORDING_MAX_EVENT_SIZE: number;
+export declare const RECORDING_BUFFER_TIMEOUT = 2000;
+export declare const RECORDING_IDLE_THRESHOLD_MS: number;
+/** Active interaction sources */
+export declare const ACTIVE_SOURCES: IncrementalSource[];
+/**
+ * Gzip compress data to a base64 string
+ */
+export declare function gzipToString(data: unknown): string;
+/**
+ * Estimate the size of an object in bytes
+ */
+export declare function estimateSize(obj: unknown): number;
+export interface CompressedFullSnapshotEvent {
+    type: typeof EventType.FullSnapshot;
+    data: string;
+}
+export interface CompressedIncrementalSnapshotEvent {
+    type: typeof EventType.IncrementalSnapshot;
+    data: {
+        source: IncrementalSource;
+        texts: string;
+        attributes: string;
+        removes: string;
+        adds: string;
+    };
+}
+export interface CompressedIncrementalStyleSnapshotEvent {
+    type: typeof EventType.IncrementalSnapshot;
+    data: {
+        source: typeof IncrementalSource.StyleSheetRule;
+        id?: number;
+        styleId?: number;
+        replace?: string;
+        replaceSync?: string;
+        adds?: string;
+        removes?: string;
+    };
+}
+export type CompressedEvent = CompressedFullSnapshotEvent | CompressedIncrementalSnapshotEvent | CompressedIncrementalStyleSnapshotEvent;
+export type CompressedEventWithTime = CompressedEvent & {
+    timestamp: number;
+    delay?: number;
+    cv: "2024-10";
+};
+/**
+ * Compress an rrweb event for transmission
+ * Only compresses full snapshots and mutation events above threshold
+ */
+export declare function compressEvent(event: eventWithTime): eventWithTime | CompressedEventWithTime;
+/**
+ * Truncate large console log payloads to prevent excessive data
+ */
+export declare function truncateLargeConsoleLogs(event: eventWithTime): eventWithTime;
+/**
+ * Split a large buffer into smaller chunks for transmission
+ */
+export declare function splitBuffer(buffer: SnapshotBuffer, sizeLimit?: number): SnapshotBuffer[];
+/**
+ * Check if an event is a session idle custom event
+ */
+export declare function isSessionIdleEvent(event: eventWithTime): event is eventWithTime & {
+    data: {
+        tag: string;
+        payload: unknown;
+    };
+};
+/**
+ * Check if an event is a recording paused custom event
+ */
+export declare function isRecordingPausedEvent(event: eventWithTime): boolean;
+/**
+ * Check if an event represents user interaction
+ */
+export declare function isInteractiveEvent(event: eventWithTime): boolean;
+/**
+ * Clamp a value to a range with logging
+ */
+export declare function clampToRange(value: number, min: number, max: number, label: string, defaultValue: number): number;