@sailfish-ai/recorder 1.12.6 → 1.12.8

package/dist/hoverDetection.js

@@ -0,0 +1,371 @@
+// Hover action detection (DIAGPLAT-1790) — v2.
+//
+// rrweb has no native hover/mouseover interaction, so the recorder detects it
+// itself. v2 design:
+//   • Detect dwell over an element with hover-like affordance (tooltip, menu/
+//     popover trigger, cursor:pointer, or a matching `:hover` CSS rule).
+//   • At the dwell mark, RE-CHECK `el.matches(":hover")` — only then is it a
+//     real, intentional hover (kills the entered-then-left race).
+//   • Emit ONCE at hover-END, carrying `duration_ms` (real dwell time).
+//   • Suppress at the source: if the hover ended because the user CLICKED the
+//     element, don't emit (a hover→click is just a click). Because this is
+//     decided locally and in order, it needs no backend/Kafka-batch dedup.
+//   • Volume guard before anything is emitted: per-element cooldown +
+//     token-bucket rate limit + hard session cap — so a pathological page can
+//     never flood the WebSocket/Kafka/Postgres.
+//
+// SSR-safe: every entry point guards against a missing window/document.
+import { EventType } from "@sailfish-rrweb/types";
+// ARIA roles that imply hover-revealed UI (menus, popovers, tooltips).
+const MENU_ROLES = new Set(["menu", "menuitem", "menubar", "tooltip"]);
+// Memoized "base" selectors (rightmost compound, `:hover` stripped) from every
+// readable stylesheet. Recomputed only when the stylesheet count changes.
+let cachedSheetCount = -1;
+let hoverBaseSelectors = [];
+// From a single comma-separated selector that contains `:hover`, push the
+// "base" selector of the element that is actually HOVERED. The `:hover` may
+// qualify any compound in the chain, not the rightmost one: in
+// `.menu:hover .item` the user hovers `.menu` (and `.item` is merely revealed),
+// so the affordance element is `.menu`, NOT `.item`. We therefore split the
+// selector into its compounds (by combinator) and, for each compound that
+// carries `:hover`, strip the `:hover` (and any pseudo-element) to recover the
+// structural selector to match against.
+function collectHoverBases(selectorText, out) {
+    for (const part of selectorText.split(",")) {
+        if (part.indexOf(":hover") === -1)
+            continue;
+        // Split into compounds on combinators (descendant / > / + / ~).
+        for (const compound of part.split(/\s*[>+~]\s*|\s+/)) {
+            if (compound.indexOf(":hover") === -1)
+                continue;
+            const base = compound
+                .replace(/:hover\b/g, "")
+                // pseudo-elements (::before/::after) el.matches() can't evaluate —
+                // drop them so e.g. `.tip:hover::after` still resolves to `.tip`.
+                .replace(/::[a-zA-Z-]+/g, "")
+                .trim();
+            if (base)
+                out.push(base);
+        }
+    }
+}
+// Walk a rule list, descending into grouping rules (@media / @supports /
+// @layer / @container) and CSS-nested rules — a `:hover` rule nested inside
+// `@media (hover: hover) { … }` (the modern best-practice pattern) would
+// otherwise be invisible, so strict affordance would miss it entirely.
+function collectFromRules(rules, out, depth) {
+    if (depth > 10)
+        return; // pathological nesting guard
+    for (let j = 0; j < rules.length; j++) {
+        const rule = rules[j];
+        const selectorText = rule.selectorText;
+        if (selectorText && selectorText.indexOf(":hover") !== -1) {
+            collectHoverBases(selectorText, out);
+        }
+        // CSSGroupingRule (and CSS-nested CSSStyleRule) expose `.cssRules`.
+        let nested = null;
+        try {
+            nested = rule.cssRules ?? null;
+        }
+        catch {
+            nested = null; // inaccessible
+        }
+        if (nested && nested.length)
+            collectFromRules(nested, out, depth + 1);
+    }
+}
+function getHoverBaseSelectors() {
+    const sheets = document.styleSheets;
+    if (sheets.length === cachedSheetCount)
+        return hoverBaseSelectors;
+    cachedSheetCount = sheets.length;
+    const selectors = [];
+    for (let i = 0; i < sheets.length; i++) {
+        let rules = null;
+        try {
+            rules = sheets[i].cssRules;
+        }
+        catch {
+            continue; // cross-origin / inaccessible stylesheet
+        }
+        if (!rules)
+            continue;
+        collectFromRules(rules, selectors, 0);
+    }
+    hoverBaseSelectors = selectors;
+    return selectors;
+}
+function matchesHoverRule(el) {
+    const selectors = getHoverBaseSelectors();
+    for (let i = 0; i < selectors.length; i++) {
+        try {
+            if (el.matches(selectors[i]))
+                return true;
+        }
+        catch {
+            // .matches() rejects malformed/unsupported selectors — ignore them.
+        }
+    }
+    return false;
+}
+/**
+ * True when `el` itself exposes hover-like behavior. Cheapest checks first.
+ * In `strict` mode bare `cursor:pointer` does NOT qualify — only a genuine
+ * hover effect (tooltip, menu/popover, or a matching `:hover` CSS rule).
+ */
+function hasHoverAffordance(el, strict) {
+    // Hover-revealed UI (tooltip / menu / popover) — real hover behavior even
+    // when implemented in JS rather than a `:hover` rule.
+    if (el.hasAttribute("title") ||
+        el.hasAttribute("data-tooltip") ||
+        el.hasAttribute("aria-describedby")) {
+        return true;
+    }
+    const role = el.getAttribute("role");
+    if (el.hasAttribute("aria-haspopup") || (role && MENU_ROLES.has(role))) {
+        return true;
+    }
+    // A genuine CSS hover effect targets this element — the gold standard.
+    if (matchesHoverRule(el))
+        return true;
+    // cursor:pointer is broad (most clickable elements set it, with no actual
+    // hover effect) — only counts in non-strict mode.
+    if (!strict) {
+        try {
+            if (typeof window.getComputedStyle === "function") {
+                if (window.getComputedStyle(el).cursor === "pointer")
+                    return true;
+            }
+        }
+        catch {
+            // getComputedStyle can throw on detached nodes — ignore.
+        }
+    }
+    return false;
+}
+/** Walk up from `start` to the nearest element with hover affordance. */
+function resolveHoverAffordance(start, maxDepth, strict) {
+    let el = start;
+    let depth = 0;
+    while (el && depth <= maxDepth) {
+        if (hasHoverAffordance(el, strict))
+            return el;
+        el = el.parentElement;
+        depth++;
+    }
+    return null;
+}
+/**
+ * Confirm the cursor is actually still over `el` at emit time. `:hover` matches
+ * an element when the pointer is over it OR a descendant — exactly what we want
+ * (we track the affordance ancestor). If the environment can't evaluate `:hover`
+ * (older jsdom, etc.), don't drop the hover — we only got here via a real
+ * pointerover + dwell with no intervening pointerout.
+ */
+function stillHovering(el) {
+    try {
+        return el.matches(":hover");
+    }
+    catch {
+        return true;
+    }
+}
+/** Simple token bucket: `capacity` burst, refills `refillPerSec` tokens/sec. */
+class TokenBucket {
+    capacity;
+    refillPerSec;
+    tokens;
+    last;
+    constructor(capacity, refillPerSec, now) {
+        this.capacity = capacity;
+        this.refillPerSec = refillPerSec;
+        this.tokens = capacity;
+        this.last = now;
+    }
+    tryConsume(now) {
+        this.tokens = Math.min(this.capacity, this.tokens + ((now - this.last) / 1000) * this.refillPerSec);
+        this.last = now;
+        if (this.tokens < 1)
+            return false;
+        this.tokens -= 1;
+        return true;
+    }
+}
+const COOLDOWN_LRU_CAP = 500;
+// Single detector per document. If the recorder re-initializes (reconnect, SPA
+// re-init, bfcache pageshow re-arm), a second install would otherwise STACK a
+// second set of capture-phase listeners on top of the first — double-emitting
+// every hover and leaking the originals. Tear down the previous install first.
+let activeTeardown = null;
+/**
+ * Install document-level hover detection. Returns a teardown function. No-op
+ * (returns a no-op teardown) outside the browser. Idempotent: a second call
+ * tears down the previous install before arming a new one.
+ */
+export function installHoverDetection(record, options) {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+        return () => { };
+    }
+    // Reclaim any detector from a prior install before arming a new one.
+    if (activeTeardown) {
+        activeTeardown();
+        activeTeardown = null;
+    }
+    const dwellMs = Math.max(0, options.dwellMs);
+    const cooldownMs = Math.max(0, options.cooldownMs ?? 3000);
+    const maxPerSession = options.maxPerSession ?? 300;
+    const maxPerSecond = options.maxPerSecond ?? 1;
+    const maxDwellMs = options.maxDwellMs ?? 60_000;
+    const maxDepth = options.maxAncestorDepth ?? 5;
+    const strict = options.strictAffordance ?? true;
+    // Date.now() (ms) is plenty for dwell timing and is advanced by fake timers
+    // in tests; performance.now() isn't reliably faked.
+    const now = () => Date.now();
+    // ── volume guard state ──────────────────────────────────────────────────
+    const lastEmitById = new Map();
+    let sessionHoverCount = 0;
+    const bucket = new TokenBucket(Math.max(10, maxPerSecond), maxPerSecond, now());
+    const passesVolumeGate = (id, t) => {
+        if (sessionHoverCount >= maxPerSession)
+            return false;
+        const last = lastEmitById.get(id);
+        if (last !== undefined && t - last < cooldownMs)
+            return false;
+        if (!bucket.tryConsume(t))
+            return false;
+        // record + LRU-cap the cooldown map
+        lastEmitById.delete(id);
+        lastEmitById.set(id, t);
+        if (lastEmitById.size > COOLDOWN_LRU_CAP) {
+            const oldest = lastEmitById.keys().next().value;
+            if (oldest !== undefined)
+                lastEmitById.delete(oldest);
+        }
+        sessionHoverCount += 1;
+        return true;
+    };
+    // ── per-hover tracking state ────────────────────────────────────────────
+    let trackedEl = null;
+    let enterTime = 0;
+    let dwellReached = false;
+    let dwellTimer = null;
+    let capTimer = null;
+    const clearTimers = () => {
+        if (dwellTimer !== null) {
+            clearTimeout(dwellTimer);
+            dwellTimer = null;
+        }
+        if (capTimer !== null) {
+            clearTimeout(capTimer);
+            capTimer = null;
+        }
+    };
+    const reset = () => {
+        clearTimers();
+        trackedEl = null;
+        dwellReached = false;
+    };
+    const emit = (el, startedAt, endedAt) => {
+        const id = record.mirror?.getId?.(el) ?? -1;
+        if (!id || id <= 0)
+            return; // not in the rrweb mirror → backend can't resolve it
+        if (!passesVolumeGate(id, endedAt))
+            return;
+        record.addSailfishEvent?.(EventType.SailfishCustom, {
+            action: "hover",
+            element_id: id,
+            started_at: Math.round(startedAt),
+            ended_at: Math.round(endedAt),
+            // Clamp ≥ 0: Date.now() isn't monotonic, so a clock step could otherwise
+            // produce a negative span.
+            duration_ms: Math.max(0, Math.round(endedAt - startedAt)),
+        });
+    };
+    // End the current hover. `emitted-by` semantics: emit only for genuine ends
+    // (leave / switch / cap / flush) once dwell was reached. A click END
+    // suppresses (hover→click is just a click); a raced-out dwell never set
+    // dwellReached so it can't emit.
+    const endHover = (cause) => {
+        const el = trackedEl;
+        const reached = dwellReached;
+        const started = enterTime;
+        reset();
+        if (el && reached && cause !== "click") {
+            emit(el, started, now());
+        }
+    };
+    const startHover = (el) => {
+        reset();
+        trackedEl = el;
+        enterTime = now();
+        dwellReached = false;
+        dwellTimer = setTimeout(() => {
+            dwellTimer = null;
+            if (trackedEl && stillHovering(trackedEl)) {
+                dwellReached = true;
+                // Arm the hard cap so an indefinitely-parked cursor still emits once.
+                capTimer = setTimeout(() => {
+                    capTimer = null;
+                    endHover("cap");
+                }, Math.max(0, maxDwellMs - dwellMs));
+            }
+            else {
+                reset(); // entered then left before the dwell — no hover
+            }
+        }, dwellMs);
+    };
+    const onPointerOver = (event) => {
+        const target = event.target;
+        if (!(target instanceof Element))
+            return;
+        const affordanceEl = resolveHoverAffordance(target, maxDepth, strict);
+        if (!affordanceEl) {
+            if (trackedEl && !trackedEl.contains(target))
+                endHover("leave");
+            return;
+        }
+        if (affordanceEl === trackedEl)
+            return; // already tracking it
+        if (trackedEl)
+            endHover("switch"); // moved A→B: A's hover ends (may emit)
+        startHover(affordanceEl);
+    };
+    const onPointerOut = (event) => {
+        const related = event.relatedTarget;
+        if (trackedEl &&
+            (!(related instanceof Node) || !trackedEl.contains(related))) {
+            endHover("leave");
+        }
+    };
+    const onPointerDown = (event) => {
+        const target = event.target;
+        if (trackedEl &&
+            target instanceof Node &&
+            (trackedEl === target || trackedEl.contains(target))) {
+            endHover("click"); // suppress — this hover became a click
+        }
+    };
+    const onVisibility = () => {
+        if (document.visibilityState === "hidden")
+            endHover("flush");
+    };
+    const capture = { capture: true, passive: true };
+    document.addEventListener("pointerover", onPointerOver, capture);
+    document.addEventListener("pointerout", onPointerOut, capture);
+    document.addEventListener("pointerdown", onPointerDown, capture);
+    document.addEventListener("visibilitychange", onVisibility, true);
+    window.addEventListener("pagehide", onVisibility, true);
+    const teardown = () => {
+        endHover("flush");
+        reset();
+        document.removeEventListener("pointerover", onPointerOver, { capture: true });
+        document.removeEventListener("pointerout", onPointerOut, { capture: true });
+        document.removeEventListener("pointerdown", onPointerDown, { capture: true });
+        document.removeEventListener("visibilitychange", onVisibility, true);
+        window.removeEventListener("pagehide", onVisibility, true);
+        if (activeTeardown === teardown)
+            activeTeardown = null;
+    };
+    activeTeardown = teardown;
+    return teardown;
+}

package/dist/hoverDetection.test.js

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { installHoverDetection } from "./hoverDetection";
+// EventType.SailfishCustom === 25 (must match the backend's SailfishCustomEvent).
+const SAILFISH_CUSTOM = 25;
+function makeRecord(id = 42) {
+    return {
+        addSailfishEvent: vi.fn(),
+        mirror: { getId: vi.fn((_node) => id) },
+    };
+}
+// Affordance via the `title` attribute (cheapest path, no CSS needed in jsdom).
+// We stub matches() so the `:hover` recheck is deterministic regardless of how
+// jsdom handles the dynamic `:hover` pseudo-class.
+function makeHoverable(hovering = true) {
+    const el = document.createElement("button");
+    el.setAttribute("title", "Help");
+    vi.spyOn(el, "matches").mockReturnValue(hovering);
+    document.body.appendChild(el);
+    return el;
+}
+const over = (el) => el.dispatchEvent(new Event("pointerover", { bubbles: true }));
+const out = (el) => el.dispatchEvent(new Event("pointerout", { bubbles: true })); // null relatedTarget => "left"
+const down = (el) => el.dispatchEvent(new Event("pointerdown", { bubbles: true }));
+describe("installHoverDetection (v2)", () => {
+    let teardown = () => { };
+    beforeEach(() => {
+        vi.useFakeTimers();
+        document.body.innerHTML = "";
+    });
+    afterEach(() => {
+        teardown();
+        teardown = () => { };
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+    });
+    it("emits once at hover-END with a duration, only after the dwell", () => {
+        const el = makeHoverable(true);
+        const record = makeRecord();
+        teardown = installHoverDetection(record, { dwellMs: 500 });
+        over(el);
+        vi.advanceTimersByTime(500); // dwell reached, but no end yet
+        expect(record.addSailfishEvent).not.toHaveBeenCalled();
+        vi.advanceTimersByTime(300); // dwell another 300ms
+        out(el); // hover ends -> emit
+        expect(record.addSailfishEvent).toHaveBeenCalledTimes(1);
+        const [type, payload] = record.addSailfishEvent.mock.calls[0];
+        expect(type).toBe(SAILFISH_CUSTOM);
+        expect(payload.action).toBe("hover");
+        expect(payload.element_id).toBe(42);
+        expect(payload.duration_ms).toBeGreaterThanOrEqual(800);
+        // start + end are explicit epoch-ms; end − start === duration.
+        expect(typeof payload.started_at).toBe("number");
+        expect(typeof payload.ended_at).toBe("number");
+        expect(payload.ended_at - payload.started_at).toBe(payload.duration_ms);
+    });
+    it("does NOT emit if the cursor is no longer hovering at the dwell mark", () => {
+        const el = makeHoverable(false); // matches(":hover") === false at recheck
+        const record = makeRecord();
+        teardown = installHoverDetection(record, { dwellMs: 500 });
+        over(el);
+        vi.advanceTimersByTime(500);
+        out(el);
+        expect(record.addSailfishEvent).not.toHaveBeenCalled();
+    });
+    it("suppresses the hover when it ends in a click on the same element", () => {
+        const el = makeHoverable(true);
+        const record = makeRecord();
+        teardown = installHoverDetection(record, { dwellMs: 500 });
+        over(el);
+        vi.advanceTimersByTime(500); // dwell reached
+        down(el); // click -> suppress
+        out(el);
+        expect(record.addSailfishEvent).not.toHaveBeenCalled();
+    });
+    it("strict mode (default) ignores cursor:pointer-only elements", () => {
+        const div = document.createElement("div"); // no tooltip / menu / :hover rule
+        document.body.appendChild(div);
+        vi.spyOn(window, "getComputedStyle").mockReturnValue({
+            cursor: "pointer",
+        });
+        const record = makeRecord();
+        teardown = installHoverDetection(record, { dwellMs: 100 }); // strict default
+        over(div);
+        vi.advanceTimersByTime(200);
+        out(div);
+        expect(record.addSailfishEvent).not.toHaveBeenCalled();
+    });
+    it("non-strict mode accepts cursor:pointer as affordance", () => {
+        const div = document.createElement("div");
+        vi.spyOn(div, "matches").mockReturnValue(true); // :hover recheck passes
+        document.body.appendChild(div);
+        vi.spyOn(window, "getComputedStyle").mockReturnValue({
+            cursor: "pointer",
+        });
+        const record = makeRecord();
+        teardown = installHoverDetection(record, {
+            dwellMs: 100,
+            strictAffordance: false,
+        });
+        over(div);
+        vi.advanceTimersByTime(100);
+        out(div);
+        expect(record.addSailfishEvent).toHaveBeenCalledTimes(1);
+    });
+    it("does not emit for elements without hover affordance", () => {
+        const div = document.createElement("div");
+        document.body.appendChild(div);
+        const record = makeRecord();
+        teardown = installHoverDetection(record, { dwellMs: 500 });
+        over(div);
+        vi.advanceTimersByTime(1000);
+        out(div);
+        expect(record.addSailfishEvent).not.toHaveBeenCalled();
+    });
+    it("dedups repeated hovers on the same element within the cooldown", () => {
+        const el = makeHoverable(true);
+        const record = makeRecord();
+        teardown = installHoverDetection(record, {
+            dwellMs: 100,
+            cooldownMs: 3000,
+        });
+        // First hover cycle -> emits.
+        over(el);
+        vi.advanceTimersByTime(100);
+        out(el);
+        // Second hover cycle on the same element, well within cooldown -> suppressed.
+        over(el);
+        vi.advanceTimersByTime(100);
+        out(el);
+        expect(record.addSailfishEvent).toHaveBeenCalledTimes(1);
+    });
+    it("enforces the per-session cap", () => {
+        const record = makeRecord();
+        teardown = installHoverDetection(record, {
+            dwellMs: 100,
+            cooldownMs: 0,
+            maxPerSession: 1,
+            maxPerSecond: 1000,
+        });
+        const a = makeHoverable(true);
+        const b = makeHoverable(true);
+        record.mirror.getId.mockImplementation((n) => (n === a ? 1 : 2));
+        over(a);
+        vi.advanceTimersByTime(100);
+        out(a); // emits (1/1)
+        over(b);
+        vi.advanceTimersByTime(100);
+        out(b); // capped
+        expect(record.addSailfishEvent).toHaveBeenCalledTimes(1);
+    });
+    it("emits on the hard dwell cap when the cursor is parked indefinitely", () => {
+        const el = makeHoverable(true);
+        const record = makeRecord();
+        teardown = installHoverDetection(record, {
+            dwellMs: 500,
+            maxDwellMs: 5000,
+        });
+        over(el);
+        vi.advanceTimersByTime(5000); // never leaves; cap fires
+        expect(record.addSailfishEvent).toHaveBeenCalledTimes(1);
+        expect(record.addSailfishEvent.mock.calls[0][1].duration_ms).toBeGreaterThanOrEqual(5000);
+    });
+    it("skips emission when the element is not in the rrweb mirror", () => {
+        const el = makeHoverable(true);
+        const record = makeRecord(-1); // getId returns -1 (unmapped)
+        teardown = installHoverDetection(record, { dwellMs: 100 });
+        over(el);
+        vi.advanceTimersByTime(100);
+        out(el);
+        expect(record.addSailfishEvent).not.toHaveBeenCalled();
+    });
+    it("is idempotent: re-installing tears down the prior detector (no double-emit)", () => {
+        const el = makeHoverable(true);
+        // First install, then a second install on the SAME document (simulates a
+        // recorder re-init). The second must reclaim the first's listeners so a
+        // single hover fires exactly once, not once per stacked detector.
+        const record1 = makeRecord();
+        installHoverDetection(record1, { dwellMs: 100 });
+        const record2 = makeRecord();
+        teardown = installHoverDetection(record2, { dwellMs: 100 });
+        over(el);
+        vi.advanceTimersByTime(100);
+        out(el);
+        expect(record1.addSailfishEvent).not.toHaveBeenCalled(); // old detector gone
+        expect(record2.addSailfishEvent).toHaveBeenCalledTimes(1); // only the new one
+    });
+});

package/dist/inAppReportIssueModal/index.js

@@ -1291,6 +1291,13 @@ function bindListeners() {
                 // skipped. The title is already validated above; priority always has
                 // a default selection. (Done before closeModal so the inputs still
                 // exist to probe.)
+                //
+                // IMPORTANT: only validate these when an eng ticket is actually being
+                // created. The eng-ticket fields stay in the DOM (hidden via
+                // display:none) when "Create an Eng Ticket" is unchecked, so without
+                // this gate a connected integration's required fields (e.g. Jira's
+                // "Reporter") get flagged on an issue-only submit even though they are
+                // not visible and not used downstream.
                 const isFieldEmpty = (v) => {
                     if (v === undefined || v === null)
                         return true;
@@ -1300,7 +1307,9 @@ function bindListeners() {
                         return v.length === 0;
                     return false;
                 };
-                const requiredFields = (getFieldsForProject(engTicketProject, engTicketIssueType) || []).filter((f) => f && f.required);
+                const requiredFields = currentState.createEngTicket
+                    ? (getFieldsForProject(engTicketProject, engTicketIssueType) || []).filter((f) => f && f.required)
+                    : [];
                 const missingRequired = [];
                 for (const f of requiredFields) {
                     const fid = f.fieldId || f.key;

package/dist/index.js

@@ -84,6 +84,14 @@ export const DEFAULT_CAPTURE_SETTINGS = {
     blockSelector: "",
     unmaskSelector: "",
     maskInputOptions: { password: true },
+    // Hover action (DIAGPLAT-1790): on by default; dwell ≈ when a tooltip/label
+    // would appear. All tunable per-account via the captureSettings API payload.
+    recordHover: true,
+    hoverDwellMs: 500,
+    hoverStrictAffordance: true,
+    hoverCooldownMs: 3000,
+    hoverMaxPerSession: 300,
+    hoverMaxPerSecond: 1,
 };
 export const DEFAULT_CONSOLE_RECORDING_SETTINGS = {
     level: ["info", "log", "warn", "error"],

package/dist/recorder.cjs

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const e = require("./chunks/index-BIj4l3CV.js");
+const e = require("./chunks/index-CPZwt1ko.js");
 require("./chunks/patch2d-9voowhJ_.js"), exports.DEFAULT_CAPTURE_SETTINGS = e.DEFAULT_CAPTURE_SETTINGS, exports.DEFAULT_CONSOLE_RECORDING_SETTINGS = e.DEFAULT_CONSOLE_RECORDING_SETTINGS, exports.STORAGE_VERSION = e.STORAGE_VERSION, exports.addOrUpdateMetadata = e.addOrUpdateMetadata, exports.buildBatches = e.buildBatches, exports.clearStaleFuncSpanState = e.clearStaleFuncSpanState, exports.createSkipHeadersPropagationChecker = e.createSkipHeadersPropagationChecker, exports.createTriageAndIssueFromRecorder = e.createTriageAndIssueFromRecorder, exports.createTriageFromRecorder = e.createTriageFromRecorder, exports.disableFunctionSpanTracking = e.disableFunctionSpanTracking, exports.enableFunctionSpanTracking = e.enableFunctionSpanTracking, exports.ensureHrefCache = e.ensureHrefCache, exports.eventSize = e.eventSize, exports.fetchAndSendIp = e.fetchAndSendIp, exports.fetchCaptureSettings = e.fetchCaptureSettings, exports.fetchEngineeringTicketPlatformIntegrations = e.fetchEngineeringTicketPlatformIntegrations, exports.fetchFunctionSpanTrackingEnabled = e.fetchFunctionSpanTrackingEnabled, exports.flushBufferedEvents = e.flushBufferedEvents, exports.getBinaryDropCount = e.getBinaryDropCount, exports.getBufferedAmount = e.getBufferedAmount, exports.getCachedHref = e.getCachedHref, exports.getCachedHrefNoQuery = e.getCachedHrefNoQuery, exports.getFuncSpanHeader = e.getFuncSpanHeader, exports.getIdentifiedUser = e.getIdentifiedUser, exports.getOrSetSessionId = e.getOrSetSessionId, exports.getUrlAndStoredUuids = e.getUrlAndStoredUuids, exports.identify = e.identify, exports.initRecorder = e.initRecorder, exports.initializeConsolePlugin = e.initializeConsolePlugin, exports.initializeDomContentEvents = e.initializeDomContentEvents, exports.initializeFunctionSpanTrackingFromApi = e.initializeFunctionSpanTrackingFromApi, exports.initializePerformancePlugin = e.initializePerformancePlugin, exports.initializeRecording = e.initializeRecording, exports.initializeWebSocket = e.initializeWebSocket, exports.invalidateUrlCache = e.invalidateUrlCache, exports.isFunctionSpanTrackingEnabled = e.isFunctionSpanTrackingEnabled, exports.isTransportSaturated = e.isTransportSaturated, exports.maskCanvasDraws = e.maskCanvasDraws, exports.maskInputFn = e.maskInputFn, exports.matchUrlWithWildcard = e.matchUrlWithWildcard, Object.defineProperty(exports, "nowTimestamp", { enumerable: true, get: () => e.nowTimestamp }), exports.onNavigationChange = e.onNavigationChange, exports.openReportIssueModal = e.openReportIssueModal, exports.registerChart = e.registerChart, exports.registerFabricCanvas = e.registerFabricCanvas, exports.registerKonvaStage = e.registerKonvaStage, exports.registerPixiApp = e.registerPixiApp, exports.registerThreeScene = e.registerThreeScene, exports.requestTimeSync = e.requestTimeSync, exports.restoreFuncSpanState = e.restoreFuncSpanState, exports.sendDomainsToNotPropagateHeaderTo = e.sendDomainsToNotPropagateHeaderTo, exports.sendEvent = e.sendEvent, exports.sendGraphQLRequest = e.sendGraphQLRequest, exports.sendMessage = e.sendMessage, exports.startRecording = e.startRecording, exports.startRecordingSession = e.startRecordingSession, exports.toAbsoluteUrl = e.toAbsoluteUrl, exports.trackingEvent = e.trackingEvent, exports.withAppUrlMetadata = e.withAppUrlMetadata, exports.wsSendBinary = e.wsSendBinary;

package/dist/recorder.js

@@ -1,4 +1,4 @@
-import { D, a, S, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s, t, v, w, x, z, A, B, C, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8 } from "./chunks/index-DIYomvdD.js";
+import { D, a, S, b, c, d, e, f, g, h, j, k, l, m, n, o, p, q, r, s, t, v, w, x, z, A, B, C, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, T, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8 } from "./chunks/index-BUAmLDnY.js";
 import "./chunks/patch2d-PQxcaE6r.js";
 export {
   D as DEFAULT_CAPTURE_SETTINGS,