@sailfish-ai/recorder 1.10.2 → 1.10.4

package/dist/recording.js

@@ -1,13 +1,11 @@
-import { record } from "@sailfish-rrweb/rrweb-record-only";
-import { getRecordConsolePlugin, } from "@sailfish-rrweb/rrweb-plugin-console-record";
 // import { NetworkRecordOptions } from "@sailfish-rrweb/rrweb-plugin-network-record";
 import { EventType } from "@sailfish-rrweb/types";
 import { Complete, DomContentEventId, DomContentSource, Loading, } from "./constants";
-// Fiber tracking for source → DOM correlation
-import { installFiberHook, processExistingTree } from "./fiberHook";
 import { getCallerLocation, getCallerLocationFromTrace, } from "./sourceLocation";
 import suppressConsoleLogsDuringCall from "./suppressConsoleLogsDuringCall";
 import { initializeWebSocket, sendEvent } from "./websocket";
+// Module-level reference to rrweb record, populated after dynamic import
+let _record = null;
 const MASK_CLASS = "sailfishSanitize";
 const ZENDESK_ELEMENT_ID = "zendesk_chat";
 const ZENDESK_PROVIDER = "Zendesk";
@@ -140,7 +138,8 @@ export function initializeDomContentEvents(sessionId) {
         });
     });
 }
-export function initializeConsolePlugin(consoleRecordSettings, sessionId) {
+export async function initializeConsolePlugin(consoleRecordSettings, sessionId) {
+    const { getRecordConsolePlugin } = await import("@sailfish-rrweb/rrweb-plugin-console-record");
     const { name, observer } = getRecordConsolePlugin(consoleRecordSettings);
     observer((payload) => {
         const anyPayload = payload;
@@ -249,21 +248,6 @@ export async function initializeRecording(captureSettings, // TODO - Sibyl post-
 backendApi, apiKey, sessionId, envValue) {
     const webSocket = initializeWebSocket(backendApi, apiKey, sessionId, envValue);
     try {
-        // Initialize fiber tracking for source → DOM correlation
-        // This captures React component names via _debugOwner chain and adds data-sf-* attributes
-        // IMPORTANT: Must process existing tree BEFORE rrweb starts, so full snapshot includes attributes
-        if (captureSettings.enableFiberTracking !== false) {
-            try {
-                installFiberHook();
-                // Process any components that already rendered before hook was installed
-                // This must happen synchronously BEFORE record() to ensure attributes are in the snapshot
-                processExistingTree();
-                console.log("[Sailfish] React Fiber tracking enabled");
-            }
-            catch (fiberError) {
-                console.warn("[Sailfish] Failed to enable Fiber tracking:", fiberError);
-            }
-        }
         // Create throttled emit wrapper (only for text edit events)
         const throttledEmit = createThrottledEmit(captureSettings.textEditThrottleEnabled);
         const emitWithContext = (event) => {
@@ -271,15 +255,40 @@ backendApi, apiKey, sessionId, envValue) {
             event.sessionId = sessionId;
             throttledEmit.emit(event);
         };
-        record({
-            emit(event) {
-                emitWithContext(event);
-            },
-            maskInputOptions: { text: true },
-            maskInputFn,
-            maskTextClass: MASK_CLASS,
-            ...captureSettings,
-        });
+        // Defer heavy synchronous work (Fiber hook install, DOM tree walk, rrweb full snapshot)
+        // via requestIdleCallback so the main thread can finish loading first.
+        const startHeavyWork = async () => {
+            // Initialize fiber tracking for source → DOM correlation
+            if (captureSettings.enableFiberTracking !== false) {
+                try {
+                    const { installFiberHook, processExistingTree } = await import("./fiberHook");
+                    installFiberHook();
+                    processExistingTree();
+                    console.log("[Sailfish] React Fiber tracking enabled");
+                }
+                catch (fiberError) {
+                    console.warn("[Sailfish] Failed to enable Fiber tracking:", fiberError);
+                }
+            }
+            const { record } = await import("@sailfish-rrweb/rrweb-record-only");
+            _record = record;
+            record({
+                emit(event) {
+                    emitWithContext(event);
+                },
+                maskInputOptions: { text: true },
+                maskInputFn,
+                maskTextClass: MASK_CLASS,
+                ...captureSettings,
+            });
+        };
+        if (typeof requestIdleCallback === "function") {
+            requestIdleCallback(startHeavyWork, { timeout: 2000 });
+        }
+        else {
+            // Fallback for browsers without requestIdleCallback (Safari < 16.4)
+            setTimeout(startHeavyWork, 0);
+        }
         // Flush buffered text edits before page unload
         window.addEventListener('beforeunload', () => {
             throttledEmit.flush();
@@ -302,21 +311,21 @@ backendApi, apiKey, sessionId, envValue) {
                 ]);
             });
             const handleWidgetOpen = () => {
-                record.addSailfishEvent(EventType.SailfishCustom, {
+                _record?.addSailfishEvent(EventType.SailfishCustom, {
                     action: "customer support chat opened",
                     element_id: ZENDESK_ELEMENT_ID,
                     provider: ZENDESK_PROVIDER,
                 });
             };
             const handleWidgetClose = () => {
-                record.addSailfishEvent(EventType.SailfishCustom, {
+                _record?.addSailfishEvent(EventType.SailfishCustom, {
                     action: "customer support chat closed",
                     element_id: ZENDESK_ELEMENT_ID,
                     provider: ZENDESK_PROVIDER,
                 });
             };
             const handleUnreadMessages = (count) => {
-                record.addSailfishEvent(EventType.SailfishCustom, {
+                _record?.addSailfishEvent(EventType.SailfishCustom, {
                     action: "zendesk unreadmessages",
                     element_id: ZENDESK_ELEMENT_ID,
                     provider: ZENDESK_PROVIDER,

package/dist/session.js

@@ -40,10 +40,16 @@ export function getOrSetSessionId() {
     }
     return sessionId;
 }
-// Set up beforeunload listener to mark page refresh
-if (HAS_WINDOW) {
-    window.addEventListener("beforeunload", () => {
-        // Prepend our flag to preserve customer's window.name
-        window.name = REFRESH_FLAG + window.name;
-    });
+// Deferred: call ensureSessionListeners() from startRecording() to avoid module-level side effects
+let _sessionListenersInstalled = false;
+export function ensureSessionListeners() {
+    if (_sessionListenersInstalled)
+        return;
+    _sessionListenersInstalled = true;
+    if (HAS_WINDOW) {
+        window.addEventListener("beforeunload", () => {
+            // Prepend our flag to preserve customer's window.name
+            window.name = REFRESH_FLAG + window.name;
+        });
+    }
 }

package/dist/types/inAppReportIssueModal/integrations.d.ts

@@ -3,8 +3,16 @@ import { IssueReportState } from "./types";
 export declare function getIntegrationData(): EngineeringTicketIntegration | null;
 export declare function hasValidIntegration(): boolean;
 export declare function fetchIntegrationData(apiKey: string, backendApi: string): Promise<void>;
+/**
+ * Re-fetch integration data in the background. Returns the fresh data
+ * and updates the module-level cache. Callers can compare with previous
+ * data to decide whether to refresh the UI.
+ */
+export declare function refreshIntegrationData(apiKey: string, backendApi: string): Promise<EngineeringTicketIntegration | null>;
 export declare function populateSelectOptions(selectElement: HTMLSelectElement, options: any[], defaultValue?: string): void;
 export declare function populatePriorityOptions(selectElement: HTMLSelectElement, provider: string, defaultPriority?: number): void;
+export declare function populateSprintOptions(selectElement: HTMLSelectElement, sprints: any[], currentValue?: string): void;
+export declare function getSprintFieldId(): string;
 export declare function updateIssueTypeOptions(selectElement: HTMLSelectElement, projectId: string): void;
 export declare function getFieldsForProject(projectId: string, issueTypeId?: string): any[];
 export declare function getUsers(): any[];

package/dist/types/inAppReportIssueModal/types.d.ts

@@ -11,6 +11,7 @@ export interface IssueReportState {
     engTicketProject: string;
     engTicketPriority: number;
     engTicketLabels: string[];
+    engTicketSprint: string;
     engTicketIssueType: string;
     engTicketCustomFields: Record<string, any>;
 }
@@ -28,13 +29,11 @@ export declare const STORAGE_KEYS: {
 };
 export declare const DEFAULT_SHORTCUTS: ShortcutsConfig;
 export declare const ReportIssueContext: {
-    shortcuts: {
-        openReportIssue?: ShortcutConfig;
-        openStartNowMode?: ShortcutConfig;
-    };
+    shortcuts: ShortcutsConfig;
     resolveSessionId: (() => string) | null;
     apiKey: string | null;
     backendApi: string | null;
     triageBaseUrl: string;
     deactivateIsolation: () => void;
+    integrationData: any;
 };

package/dist/types/index.d.ts

@@ -1,11 +1,11 @@
-import { LogRecordOptions } from "@sailfish-rrweb/rrweb-plugin-console-record";
-import { ShortcutsConfig } from "./inAppReportIssueModal";
+import type { LogRecordOptions } from "@sailfish-rrweb/rrweb-plugin-console-record";
+import type { ShortcutsConfig } from "./inAppReportIssueModal";
 import { CaptureSettings } from "./types";
 export declare const STORAGE_VERSION = 1;
 export declare const DEFAULT_CAPTURE_SETTINGS: CaptureSettings;
 export declare const DEFAULT_CONSOLE_RECORDING_SETTINGS: LogRecordOptions;
 export declare function matchUrlWithWildcard(input: unknown, patterns: string[]): boolean;
-export declare function startRecording({ apiKey, backendApi, domainsToPropagateHeaderTo, domainsToNotPropagateHeaderTo, serviceVersion, serviceIdentifier, gitSha, serviceAdditionalMetadata, enableIpTracking, }: {
+export declare function startRecording({ apiKey, backendApi, domainsToPropagateHeaderTo, domainsToNotPropagateHeaderTo, serviceVersion, serviceIdentifier, gitSha, serviceAdditionalMetadata, enableIpTracking, captureStreamingResponseBody, captureResponseBodyMaxMb, captureStreamPrefixKb, captureStreamTimeoutMs, }: {
     apiKey: string;
     backendApi?: string;
     domainsToPropagateHeaderTo?: string[];
@@ -15,6 +15,10 @@ export declare function startRecording({ apiKey, backendApi, domainsToPropagateH
     gitSha?: string;
     serviceAdditionalMetadata?: Record<string, any>;
     enableIpTracking?: boolean;
+    captureStreamingResponseBody?: boolean;
+    captureResponseBodyMaxMb?: number;
+    captureStreamPrefixKb?: number;
+    captureStreamTimeoutMs?: number;
 }): Promise<void>;
 export declare const initRecorder: (options: {
     apiKey: string;
@@ -29,6 +33,10 @@ export declare const initRecorder: (options: {
     customBaseUrl?: string;
     enableFiberTracking?: boolean;
     enableIpTracking?: boolean;
+    captureStreamingResponseBody?: boolean;
+    captureResponseBodyMaxMb?: number;
+    captureStreamPrefixKb?: number;
+    captureStreamTimeoutMs?: number;
 }) => Promise<void>;
 export * from "./graphql";
 export { openReportIssueModal } from "./inAppReportIssueModal";

package/dist/types/recording.d.ts

@@ -1,4 +1,4 @@
-import { LogRecordOptions } from "@sailfish-rrweb/rrweb-plugin-console-record";
+import type { LogRecordOptions } from "@sailfish-rrweb/rrweb-plugin-console-record";
 import ReconnectingWebSocket from "reconnecting-websocket";
 export declare const getUrlAndStoredUuids: () => {
     page_visit_uuid: string;
@@ -8,6 +8,6 @@ export declare const getUrlAndStoredUuids: () => {
     tabVisibilityState: string;
 };
 export declare function initializeDomContentEvents(sessionId: string): void;
-export declare function initializeConsolePlugin(consoleRecordSettings: LogRecordOptions, sessionId: string): void;
+export declare function initializeConsolePlugin(consoleRecordSettings: LogRecordOptions, sessionId: string): Promise<void>;
 export declare function initializeRecording(captureSettings: any, // TODO - Sibyl post-launch - replace type
 backendApi: string, apiKey: string, sessionId: string, envValue?: string): Promise<ReconnectingWebSocket>;

package/dist/types/session.d.ts

@@ -1 +1,2 @@
 export declare function getOrSetSessionId(): string;
+export declare function ensureSessionListeners(): void;

package/dist/types/websocket.d.ts

@@ -4,6 +4,7 @@ import ReconnectingWebSocket from "reconnecting-websocket";
  * This disables tracking and clears localStorage if backend says tracking is not active
  */
 export declare function clearStaleFuncSpanState(): void;
+export declare function restoreFuncSpanState(): void;
 export declare function flushBufferedEvents(): Promise<void>;
 export declare function sendEvent(event: any): void;
 export declare function initializeWebSocket(backendApi: string, apiKey: string, sessionId: string, envValue?: string): ReconnectingWebSocket;

package/dist/websocket.js

@@ -106,16 +106,19 @@ export function clearStaleFuncSpanState() {
         console.log("[Sailfish] Cleared stale function span tracking state (backend validation failed)");
     }
 }
-// Load persisted global state immediately on module initialization
-// This ensures headers are added from the very first HTTP request, even before WebSocket connects
-(() => {
+// Deferred: call restoreFuncSpanState() from startRecording() to avoid module-level side effects
+let _funcSpanStateRestored = false;
+export function restoreFuncSpanState() {
+    if (_funcSpanStateRestored)
+        return;
+    _funcSpanStateRestored = true;
     const persistedState = loadGlobalFuncSpanState();
     if (persistedState && persistedState.enabled) {
         funcSpanTrackingEnabled = true;
         funcSpanExpirationTime = persistedState.expirationTimestampMs;
         isLocalTrackingMode = false;
         if (DEBUG) {
-            console.log(`[Sailfish] Module init: Restored global function span tracking from localStorage:`, {
+            console.log(`[Sailfish] Restored global function span tracking from localStorage:`, {
                 enabled: true,
                 expirationTime: funcSpanExpirationTime,
             });
@@ -129,24 +132,22 @@ export function clearStaleFuncSpanState() {
                 funcSpanExpirationTime = null;
                 clearGlobalFuncSpanState();
                 if (DEBUG) {
-                    console.log("[Sailfish] Module init: Persisted tracking already expired, cleared state");
+                    console.log("[Sailfish] Persisted tracking already expired, cleared state");
                 }
             }
             else {
-                // State is still valid, keep it temporarily until WebSocket provides the true state
                 if (DEBUG) {
-                    console.log("[Sailfish] Module init: Function span tracking is active and valid (temporary until WebSocket confirms)");
+                    console.log("[Sailfish] Function span tracking is active and valid (temporary until WebSocket confirms)");
                 }
             }
         }
         else {
-            // No expiration time - keep enabled temporarily until WebSocket provides the true state
             if (DEBUG) {
-                console.log("[Sailfish] Module init: Function span tracking is active (no expiration, temporary until WebSocket confirms)");
+                console.log("[Sailfish] Function span tracking is active (no expiration, temporary until WebSocket confirms)");
             }
         }
     }
-})();
+}
 function isWebSocketOpen(ws) {
     return ws?.readyState === WebSocket.OPEN;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailfish-ai/recorder",
-  "version": "1.10.2",
+  "version": "1.10.4",
   "publishPublicly": true,
   "type": "module",
   "main": "dist/recorder.cjs",