@repliqo/sdk-react-native 0.1.0

package/dist/core/client.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppAnalytics = void 0;
+const react_native_1 = require("react-native");
+const capture_1 = require("../snapshot/capture");
+const config_1 = require("./config");
+const logger_1 = require("./logger");
+const api_client_1 = require("../transport/api.client");
+const batch_queue_1 = require("../transport/batch-queue");
+const error_tracker_1 = require("../trackers/error.tracker");
+// Native multi-window capture is used automatically via captureScreenshot()
+// when the ScreenCaptureModule is linked. No permission or service needed.
+class AppAnalytics {
+    constructor(config) {
+        this.snapshotCapture = null;
+        this.errorTracker = null;
+        this.sessionId = null;
+        this.currentScreen = null;
+        this.currentScreenEnteredAt = null;
+        this.appStateSubscription = null;
+        this.config = (0, config_1.resolveConfig)(config);
+        this.logger = new logger_1.Logger(this.config.debug);
+        this.apiClient = new api_client_1.ApiClient(this.config.baseUrl, this.config.apiKey, this.logger);
+        this.eventQueue = new batch_queue_1.BatchQueue(this.config.batchSize, this.config.flushInterval, async (events) => {
+            if (!this.sessionId) {
+                this.logger.warn('Cannot flush events: no active session');
+                throw new Error('No active session');
+            }
+            await this.apiClient.sendEventsBatch(this.sessionId, events);
+        });
+        this.screenVisitQueue = new batch_queue_1.BatchQueue(this.config.batchSize, this.config.flushInterval, async (visits) => {
+            await this.apiClient.sendScreenVisitsBatch(visits);
+        });
+        // Snapshots are heavier (~15-30 KB JPEG each) so they use a smaller
+        // batch size, shorter flush interval, and a tighter memory cap than
+        // the event queue. All configurable via SDKConfig.
+        this.snapshotQueue = new batch_queue_1.BatchQueue(this.config.snapshotBatchSize, this.config.snapshotFlushInterval, async (snapshots) => {
+            await this.apiClient.sendSnapshotsBatch(snapshots);
+        }, this.config.snapshotMaxBufferSize);
+        this.eventQueue.startAutoFlush();
+        this.screenVisitQueue.startAutoFlush();
+        this.snapshotQueue.startAutoFlush();
+        if (this.config.enableSnapshots) {
+            this.snapshotCapture = new capture_1.SnapshotCapture({
+                captureInterval: this.config.snapshotInterval,
+                maxSnapshotsPerSession: this.config.maxSnapshotsPerSession,
+            }, (snapshot) => {
+                this.snapshotQueue.add(snapshot);
+            }, undefined, // default captureScreenshot provider
+            (...args) => this.logger.log(...args), (...args) => this.logger.warn(...args));
+        }
+        if (this.config.enableCrashTracking) {
+            this.errorTracker = new error_tracker_1.ErrorTracker((crash) => {
+                // Crash reports are sent immediately (fire-and-forget), not batched
+                this.apiClient.sendCrashReport(crash).catch(() => { });
+            });
+            this.errorTracker.start();
+        }
+        this.setupAppStateListener();
+        this.logger.log('SDK initialized with config:', {
+            baseUrl: this.config.baseUrl,
+            appId: this.config.appId,
+            batchSize: this.config.batchSize,
+            flushInterval: this.config.flushInterval,
+            enableSnapshots: this.config.enableSnapshots,
+            snapshotInterval: this.config.snapshotInterval,
+            enableCrashTracking: this.config.enableCrashTracking,
+        });
+    }
+    static init(config) {
+        if (AppAnalytics.instance) {
+            AppAnalytics.instance.logger.warn('AppAnalytics already initialized. Returning existing instance.');
+            return AppAnalytics.instance;
+        }
+        AppAnalytics.instance = new AppAnalytics(config);
+        return AppAnalytics.instance;
+    }
+    static getInstance() {
+        if (!AppAnalytics.instance) {
+            throw new Error('AppAnalytics not initialized. Call AppAnalytics.init(config) first.');
+        }
+        return AppAnalytics.instance;
+    }
+    static destroy() {
+        if (AppAnalytics.instance) {
+            const instance = AppAnalytics.instance;
+            instance.logger.log('Destroying AppAnalytics instance');
+            if (instance.errorTracker) {
+                instance.errorTracker.stop();
+                instance.errorTracker = null;
+            }
+            if (instance.snapshotCapture) {
+                instance.snapshotCapture.stop();
+                instance.snapshotCapture = null;
+            }
+            instance.eventQueue.stopAutoFlush();
+            instance.screenVisitQueue.stopAutoFlush();
+            instance.snapshotQueue.stopAutoFlush();
+            if (instance.appStateSubscription) {
+                instance.appStateSubscription.remove();
+                instance.appStateSubscription = null;
+            }
+            // Attempt a final flush (fire-and-forget)
+            instance.flush().catch(() => { });
+            AppAnalytics.instance = null;
+        }
+    }
+    async startSession(deviceId, deviceInfo) {
+        try {
+            const response = await this.apiClient.startSession(deviceId, deviceInfo);
+            this.sessionId = response.id;
+            this.logger.log('Session started with ID:', this.sessionId);
+            this.errorTracker?.setSessionId(this.sessionId);
+            if (this.snapshotCapture) {
+                this.snapshotCapture.setSessionId(this.sessionId);
+                this.snapshotCapture.reset();
+                // Native capture (MediaProjection) is NOT started automatically.
+                // It requires a system dialog that is confusing if shown on every
+                // launch. The host app can call enableNativeCapture() explicitly
+                // when the user opts in. Until then, view-shot is used.
+                this.startSnapshotCapture();
+            }
+            return this.sessionId;
+        }
+        catch (error) {
+            this.logger.error('Failed to start session:', error);
+            throw error;
+        }
+    }
+    async endSession() {
+        if (!this.sessionId) {
+            this.logger.warn('No active session to end');
+            return;
+        }
+        // Stop snapshot capture
+        this.stopSnapshotCapture();
+        // Flush any pending screen exit
+        if (this.currentScreen && this.currentScreenEnteredAt) {
+            this.onScreenExit(this.currentScreen);
+        }
+        // Flush remaining data
+        await this.flush();
+        try {
+            await this.apiClient.endSession(this.sessionId);
+            this.logger.log('Session ended:', this.sessionId);
+        }
+        catch (error) {
+            this.logger.error('Failed to end session:', error);
+        }
+        this.sessionId = null;
+        this.currentScreen = null;
+        this.currentScreenEnteredAt = null;
+        this.errorTracker?.setSessionId(null);
+        if (this.snapshotCapture) {
+            this.snapshotCapture.setSessionId(null);
+        }
+    }
+    trackTouch(x, y, screenName, extra) {
+        if (!this.sessionId) {
+            this.logger.warn('Cannot track touch: no active session');
+            return;
+        }
+        if (!this.config.enableTouchTracking) {
+            return;
+        }
+        const event = {
+            type: 'touch',
+            screenName: screenName || this.currentScreen || undefined,
+            data: { x, y, ...extra },
+            timestamp: new Date().toISOString(),
+        };
+        this.eventQueue.add(event);
+        this.logger.log('Touch tracked:', event);
+    }
+    trackNavigation(fromScreen, toScreen) {
+        if (!this.sessionId) {
+            this.logger.warn('Cannot track navigation: no active session');
+            return;
+        }
+        if (!this.config.enableNavigationTracking) {
+            return;
+        }
+        const event = {
+            type: 'navigation',
+            screenName: toScreen,
+            data: { fromScreen, toScreen },
+            timestamp: new Date().toISOString(),
+        };
+        this.eventQueue.add(event);
+        this.logger.log('Navigation tracked:', fromScreen, '->', toScreen);
+    }
+    trackCustomEvent(eventName, data) {
+        if (!this.sessionId) {
+            this.logger.warn('Cannot track custom event: no active session');
+            return;
+        }
+        const event = {
+            type: 'custom',
+            screenName: this.currentScreen || undefined,
+            data: { eventName, ...data },
+            timestamp: new Date().toISOString(),
+        };
+        this.eventQueue.add(event);
+        this.logger.log('Custom event tracked:', eventName);
+    }
+    reportError(error, metadata) {
+        if (!this.errorTracker) {
+            this.logger.warn('Cannot report error: crash tracking is not enabled');
+            return;
+        }
+        this.errorTracker.reportError(error, metadata);
+    }
+    onScreenEnter(screenName) {
+        this.currentScreen = screenName;
+        this.currentScreenEnteredAt = new Date().toISOString();
+        this.errorTracker?.setCurrentScreen(screenName);
+        this.snapshotCapture?.setCurrentScreen(screenName);
+        this.logger.log('Screen entered:', screenName);
+    }
+    onScreenExit(screenName) {
+        if (this.sessionId &&
+            this.currentScreen === screenName &&
+            this.currentScreenEnteredAt) {
+            const enteredAt = this.currentScreenEnteredAt;
+            const exitedAt = new Date().toISOString();
+            const duration = new Date(exitedAt).getTime() - new Date(enteredAt).getTime();
+            const visit = {
+                sessionId: this.sessionId,
+                screenName,
+                enteredAt,
+                exitedAt,
+                duration,
+            };
+            this.screenVisitQueue.add(visit);
+            this.logger.log('Screen exited:', screenName, 'duration:', duration);
+        }
+        if (this.currentScreen === screenName) {
+            this.currentScreen = null;
+            this.currentScreenEnteredAt = null;
+            this.errorTracker?.setCurrentScreen(null);
+        }
+    }
+    async flush() {
+        this.logger.log('Flushing queues...');
+        await Promise.all([
+            this.eventQueue.flush(),
+            this.screenVisitQueue.flush(),
+            this.snapshotQueue.flush(),
+        ]);
+        this.logger.log('Flush complete');
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getCurrentScreen() {
+        return this.currentScreen;
+    }
+    /**
+     * Force an immediate screenshot capture, outside the periodic schedule.
+     * Useful for capturing specific moments (e.g. right after a critical
+     * user action). Respects the in-flight lock and session cap.
+     */
+    async captureSnapshot(screenName) {
+        if (!this.sessionId || !this.snapshotCapture) {
+            return;
+        }
+        if (screenName) {
+            this.snapshotCapture.setCurrentScreen(screenName);
+        }
+        await this.snapshotCapture.captureNow();
+    }
+    startSnapshotCapture() {
+        if (this.snapshotCapture) {
+            this.snapshotCapture.start();
+            this.logger.log('Snapshot capture started');
+        }
+    }
+    stopSnapshotCapture() {
+        if (this.snapshotCapture) {
+            this.snapshotCapture.stop();
+            this.logger.log('Snapshot capture stopped');
+        }
+    }
+    isInitialized() {
+        return true;
+    }
+    setupAppStateListener() {
+        let wasInBackground = false;
+        this.appStateSubscription = react_native_1.AppState.addEventListener('change', (nextAppState) => {
+            if (nextAppState === 'background' || nextAppState === 'inactive') {
+                this.logger.log('App going to background, pausing snapshots + flushing');
+                this.stopSnapshotCapture();
+                wasInBackground = true;
+                this.flush().catch((error) => {
+                    this.logger.error('Error flushing on app state change:', error);
+                });
+            }
+            else if (nextAppState === 'active' && wasInBackground) {
+                wasInBackground = false;
+                this.logger.log('App returned to foreground, resuming snapshots');
+                if (this.snapshotCapture && this.sessionId) {
+                    this.startSnapshotCapture();
+                }
+            }
+        });
+    }
+}
+exports.AppAnalytics = AppAnalytics;
+AppAnalytics.instance = null;

package/dist/core/config.d.ts

@@ -0,0 +1,4 @@
+import { SDKConfig } from '../types/events';
+export declare const DEFAULT_CONFIG: Required<Omit<SDKConfig, 'apiKey' | 'appId' | 'baseUrl'>>;
+export type ResolvedConfig = SDKConfig & typeof DEFAULT_CONFIG;
+export declare function resolveConfig(config: SDKConfig): ResolvedConfig;

package/dist/core/config.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.resolveConfig = resolveConfig;
+exports.DEFAULT_CONFIG = {
+    batchSize: 20,
+    flushInterval: 30000,
+    enableTouchTracking: true,
+    enableNavigationTracking: true,
+    enableSnapshots: true,
+    // 0.5 fps. JPEG screenshots at 390px/40% quality are ~15-30 KB each,
+    // so 2 s gives a good quality/bandwidth tradeoff for MVP session replay.
+    snapshotInterval: 2000,
+    // Cap sessions at ~30 minutes of continuous capture (900 frames).
+    maxSnapshotsPerSession: 900,
+    // Smaller batches than events - JPEGs are heavier.
+    snapshotBatchSize: 8,
+    snapshotFlushInterval: 15000,
+    // ~32 * 30KB ≈ 1 MB cap on in-memory buffer if the backend is down.
+    snapshotMaxBufferSize: 32,
+    enableCrashTracking: true,
+    debug: false,
+};
+function resolveConfig(config) {
+    return { ...exports.DEFAULT_CONFIG, ...config };
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,8 @@
+export declare class Logger {
+    private debugEnabled;
+    private prefix;
+    constructor(debugEnabled: boolean, prefix?: string);
+    log(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}

package/dist/core/logger.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+    constructor(debugEnabled, prefix = '[Repliqo]') {
+        this.debugEnabled = debugEnabled;
+        this.prefix = prefix;
+    }
+    log(...args) {
+        if (this.debugEnabled) {
+            console.log(this.prefix, ...args);
+        }
+    }
+    warn(...args) {
+        if (this.debugEnabled) {
+            console.warn(this.prefix, ...args);
+        }
+    }
+    error(...args) {
+        if (this.debugEnabled) {
+            console.error(this.prefix, ...args);
+        }
+    }
+}
+exports.Logger = Logger;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { AppAnalytics } from './core/client';
+export { TouchTracker } from './trackers/touch.tracker';
+export { useNavigationTracker, trackScreenChange, } from './trackers/navigation.tracker';
+export { trackScreenEnter, trackScreenExit, } from './trackers/screen.tracker';
+export { ErrorTracker } from './trackers/error.tracker';
+export { SnapshotCapture } from './snapshot/capture';
+export { captureScreenshot } from './snapshot/captureScreenshot';
+export { isNativeScreenCaptureAvailable, captureNativeFrame, } from './snapshot/NativeScreenCapture';
+export type { EventType, AnalyticsEvent, TouchEventData, NavigationEventData, ScreenVisit, DeviceInfo, SDKConfig, } from './types/events';
+export type { ScreenshotData, SnapshotPayload, } from './types/snapshot';
+export type { CrashReport } from './types/crash';
+export type { SnapshotCaptureConfig } from './snapshot/capture';
+export type { ScreenshotResult } from './snapshot/captureScreenshot';
+export { DEFAULT_CONFIG } from './core/config';
+export type { ResolvedConfig } from './core/config';

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = exports.captureNativeFrame = exports.isNativeScreenCaptureAvailable = exports.captureScreenshot = exports.SnapshotCapture = exports.ErrorTracker = exports.trackScreenExit = exports.trackScreenEnter = exports.trackScreenChange = exports.useNavigationTracker = exports.TouchTracker = exports.AppAnalytics = void 0;
+// Main class
+var client_1 = require("./core/client");
+Object.defineProperty(exports, "AppAnalytics", { enumerable: true, get: function () { return client_1.AppAnalytics; } });
+// Trackers
+var touch_tracker_1 = require("./trackers/touch.tracker");
+Object.defineProperty(exports, "TouchTracker", { enumerable: true, get: function () { return touch_tracker_1.TouchTracker; } });
+var navigation_tracker_1 = require("./trackers/navigation.tracker");
+Object.defineProperty(exports, "useNavigationTracker", { enumerable: true, get: function () { return navigation_tracker_1.useNavigationTracker; } });
+Object.defineProperty(exports, "trackScreenChange", { enumerable: true, get: function () { return navigation_tracker_1.trackScreenChange; } });
+var screen_tracker_1 = require("./trackers/screen.tracker");
+Object.defineProperty(exports, "trackScreenEnter", { enumerable: true, get: function () { return screen_tracker_1.trackScreenEnter; } });
+Object.defineProperty(exports, "trackScreenExit", { enumerable: true, get: function () { return screen_tracker_1.trackScreenExit; } });
+var error_tracker_1 = require("./trackers/error.tracker");
+Object.defineProperty(exports, "ErrorTracker", { enumerable: true, get: function () { return error_tracker_1.ErrorTracker; } });
+// Snapshot
+var capture_1 = require("./snapshot/capture");
+Object.defineProperty(exports, "SnapshotCapture", { enumerable: true, get: function () { return capture_1.SnapshotCapture; } });
+var captureScreenshot_1 = require("./snapshot/captureScreenshot");
+Object.defineProperty(exports, "captureScreenshot", { enumerable: true, get: function () { return captureScreenshot_1.captureScreenshot; } });
+var NativeScreenCapture_1 = require("./snapshot/NativeScreenCapture");
+Object.defineProperty(exports, "isNativeScreenCaptureAvailable", { enumerable: true, get: function () { return NativeScreenCapture_1.isNativeScreenCaptureAvailable; } });
+Object.defineProperty(exports, "captureNativeFrame", { enumerable: true, get: function () { return NativeScreenCapture_1.captureNativeFrame; } });
+// Config
+var config_1 = require("./core/config");
+Object.defineProperty(exports, "DEFAULT_CONFIG", { enumerable: true, get: function () { return config_1.DEFAULT_CONFIG; } });

package/dist/snapshot/NativeScreenCapture.d.ts

@@ -0,0 +1,17 @@
+export interface NativeFrameResult {
+    image: string;
+    width: number;
+    height: number;
+    format: 'jpeg';
+}
+/** Whether the native multi-window capture module is available. */
+export declare function isNativeScreenCaptureAvailable(): boolean;
+/**
+ * Capture a single frame using native multi-window capture.
+ * Captures ALL visible windows: main view + modals + alerts + dialogs.
+ *
+ * No permissions required. No dialog. No foreground service.
+ *
+ * @returns NativeFrameResult or null if capture failed / not available
+ */
+export declare function captureNativeFrame(): Promise<NativeFrameResult | null>;

package/dist/snapshot/NativeScreenCapture.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNativeScreenCaptureAvailable = isNativeScreenCaptureAvailable;
+exports.captureNativeFrame = captureNativeFrame;
+const react_native_1 = require("react-native");
+const NativeModule = react_native_1.Platform.OS === 'android'
+    ? react_native_1.NativeModules.ScreenCaptureModule ?? null
+    : null;
+/** Whether the native multi-window capture module is available. */
+function isNativeScreenCaptureAvailable() {
+    return NativeModule !== null;
+}
+/**
+ * Capture a single frame using native multi-window capture.
+ * Captures ALL visible windows: main view + modals + alerts + dialogs.
+ *
+ * No permissions required. No dialog. No foreground service.
+ *
+ * @returns NativeFrameResult or null if capture failed / not available
+ */
+async function captureNativeFrame() {
+    if (!NativeModule)
+        return null;
+    try {
+        const result = await NativeModule.captureFrame();
+        if (!result || !result.image)
+            return null;
+        return {
+            image: result.image,
+            width: result.width,
+            height: result.height,
+            format: 'jpeg',
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/snapshot/capture.d.ts

@@ -0,0 +1,36 @@
+import { SnapshotPayload, ScreenshotData } from '../types/snapshot';
+export interface SnapshotCaptureConfig {
+    captureInterval: number;
+    maxSnapshotsPerSession: number;
+}
+export type ScreenshotProvider = () => Promise<ScreenshotData | null>;
+type LogFn = (...args: any[]) => void;
+/**
+ * Captures JPEG screenshots of the RN view hierarchy at a fixed interval
+ * and forwards them to the host (usually the snapshot BatchQueue).
+ */
+export declare class SnapshotCapture {
+    private timeoutId;
+    private sequence;
+    private config;
+    private onSnapshot;
+    private sessionId;
+    private currentScreen;
+    private capturing;
+    private running;
+    private provider;
+    private log;
+    private warn;
+    constructor(config: SnapshotCaptureConfig, onSnapshot: (snapshot: SnapshotPayload) => void, provider?: ScreenshotProvider, log?: LogFn, warn?: LogFn);
+    start(): void;
+    stop(): void;
+    captureNow(): Promise<void>;
+    private scheduleNext;
+    private tick;
+    reset(): void;
+    setSessionId(sessionId: string | null): void;
+    setCurrentScreen(screenName: string): void;
+    getSequence(): number;
+    isRunning(): boolean;
+}
+export {};

package/dist/snapshot/capture.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotCapture = void 0;
+const captureScreenshot_1 = require("./captureScreenshot");
+/**
+ * Captures JPEG screenshots of the RN view hierarchy at a fixed interval
+ * and forwards them to the host (usually the snapshot BatchQueue).
+ */
+class SnapshotCapture {
+    constructor(config, onSnapshot, provider = captureScreenshot_1.captureScreenshot, log = () => { }, warn = () => { }) {
+        this.timeoutId = null;
+        this.sequence = 0;
+        this.sessionId = null;
+        this.currentScreen = 'unknown';
+        this.capturing = false;
+        this.running = false;
+        this.config = config;
+        this.onSnapshot = onSnapshot;
+        this.provider = provider;
+        this.log = log;
+        this.warn = warn;
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.log('Snapshot capture started (interval:', this.config.captureInterval, 'ms)');
+        this.scheduleNext();
+    }
+    stop() {
+        this.running = false;
+        if (this.timeoutId !== null) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+        this.log('Snapshot capture stopped');
+    }
+    async captureNow() {
+        await this.tick();
+    }
+    scheduleNext() {
+        if (!this.running)
+            return;
+        this.timeoutId = setTimeout(() => {
+            Promise.resolve(this.tick()).finally(() => {
+                if (this.running) {
+                    this.scheduleNext();
+                }
+            });
+        }, this.config.captureInterval);
+    }
+    async tick() {
+        if (!this.sessionId)
+            return;
+        if (this.capturing)
+            return;
+        if (this.sequence >= this.config.maxSnapshotsPerSession) {
+            this.log('Max snapshots reached:', this.sequence);
+            this.stop();
+            return;
+        }
+        this.capturing = true;
+        let screenshot = null;
+        try {
+            screenshot = await this.provider();
+        }
+        catch (err) {
+            this.warn('Snapshot capture failed:', err);
+            screenshot = null;
+        }
+        finally {
+            this.capturing = false;
+        }
+        if (!screenshot) {
+            this.warn('Snapshot returned null (provider unavailable or failed)');
+            return;
+        }
+        // Strip `source` field before sending — the backend DTO only
+        // accepts { image, width, height, format } and rejects unknown props.
+        const { image, width, height, format } = screenshot;
+        const payload = {
+            sessionId: this.sessionId,
+            screenName: this.currentScreen,
+            timestamp: new Date().toISOString(),
+            sequence: this.sequence,
+            isDiff: false,
+            data: { image, width, height, format },
+        };
+        this.sequence++;
+        this.log('Snapshot captured: seq=', this.sequence - 1, 'screen=', this.currentScreen, 'size=', Math.round(screenshot.image.length / 1024), 'KB');
+        this.onSnapshot(payload);
+    }
+    reset() {
+        this.sequence = 0;
+    }
+    setSessionId(sessionId) {
+        this.sessionId = sessionId;
+    }
+    setCurrentScreen(screenName) {
+        this.currentScreen = screenName;
+    }
+    getSequence() {
+        return this.sequence;
+    }
+    isRunning() {
+        return this.running;
+    }
+}
+exports.SnapshotCapture = SnapshotCapture;

package/dist/snapshot/captureScreenshot.d.ts

@@ -0,0 +1,26 @@
+export type CaptureSource = 'native' | 'viewshot';
+export interface ScreenshotResult {
+    image: string;
+    width: number;
+    height: number;
+    format: 'jpeg';
+    /** Which capture method produced this frame. */
+    source: CaptureSource;
+}
+/**
+ * Capture a JPEG screenshot using the best available method:
+ *
+ *  1. Native multi-window capture (Android) — uses View.draw() on all
+ *     app windows via WindowManagerGlobal reflection. Captures modals,
+ *     alerts, dialogs, overlays. No permissions needed.
+ *  2. react-native-view-shot fallback — captures the main RN view only
+ *     (no modals or native dialogs)
+ *  3. null — if both are unavailable
+ *
+ * Never throws. Returns null on any failure.
+ */
+export declare function captureScreenshot(): Promise<ScreenshotResult | null>;
+/**
+ * Test-only: reset cached view-shot resolution.
+ */
+export declare function __resetCaptureRefForTests(): void;