@scalebun-release/react-native 2.5.0

package/lib/typescript/features/replay/public/api.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Session Replay SDK — Public API Facade
+ *
+ * This is the main entry point for SDK consumers.
+ * All methods are no-throw — errors are logged and silently handled.
+ *
+ * Usage (standalone):
+ *   import { ReplaySdk } from '@scalebun/replay-sdk';
+ *   ReplaySdk.init({ apiKey: '...', endpoint: '...' });
+ *
+ * Usage (via scalebun-sdk):
+ *   // Called internally by bootstrap.ts:
+ *   ReplaySdk.init(config, { debugTransport: transport });
+ */
+import type { ReplayConfig, ReplayUser, ReplayBreadcrumb, ReplayPrivacyOptions, ReplayLinkResult, ReplaySyncCallback } from './types';
+import { CapturingMode, ScreenshotQuality } from './enums';
+import type { ReplayTransport } from '../transport/ReplayTransport';
+import type { DebugTransportLike } from '../transport/DesktopReplayTransport';
+export interface ReplaySdkInitOptions {
+    /** External debug transport from scalebun-sdk for desktop streaming */
+    debugTransport?: DebugTransportLike;
+}
+export declare const ReplaySdk: {
+    /**
+     * Initialize the Session Replay SDK.
+     *
+     * Must be called before any other SDK method.
+     * Safe to call multiple times — re-initializes with new config.
+     *
+     * @param partialConfig - SDK configuration (merged with defaults)
+     * @param opts - Optional init options (e.g. external debugTransport)
+     */
+    init(partialConfig: Partial<ReplayConfig>, opts?: ReplaySdkInitOptions): Promise<void>;
+    /** @internal Get the active transport (for integration with SessionManager) */
+    _getTransport(): ReplayTransport | null;
+    /** Start a new replay session */
+    start(): Promise<void>;
+    /** Stop the current replay session and finalize */
+    stop(): Promise<void>;
+    /** Pause the current session (e.g. when app backgrounds) */
+    pause(): Promise<void>;
+    /** Resume a paused session */
+    resume(): Promise<void>;
+    /** Manually trigger a frame capture */
+    captureManualFrame(): Promise<void>;
+    /** Enable or disable the SDK at runtime */
+    setEnabled(enabled: boolean): Promise<void>;
+    /** Change the capture mode at runtime */
+    setCapturingMode(mode: CapturingMode): Promise<void>;
+    /** Change screenshot quality at runtime */
+    setScreenshotQuality(quality: ScreenshotQuality): Promise<void>;
+    /** Change capture interval (frequency mode) */
+    setScreenshotCaptureInterval(intervalMs: number): Promise<void>;
+    /** Enable/disable user step tracking */
+    setUserStepsEnabled(enabled: boolean): Promise<void>;
+    /** Enable/disable network log capture */
+    setNetworkLogsEnabled(enabled: boolean): void;
+    /** Enable/disable SDK log capture */
+    setSdkLogsEnabled(enabled: boolean): void;
+    /** Set the current screen name for replay context */
+    setCurrentScreen(screenName: string): Promise<void>;
+    /** Set user identity for the current session */
+    setUser(user: ReplayUser): Promise<void>;
+    /** Clear user identity */
+    clearUser(): Promise<void>;
+    /** Update privacy options at runtime */
+    setPrivacyOptions(options: Partial<ReplayPrivacyOptions>): Promise<void>;
+    /** Add a custom breadcrumb to the session timeline */
+    addBreadcrumb(breadcrumb: ReplayBreadcrumb): Promise<void>;
+    /** Set a callback invoked before each upload batch. Return false to cancel. */
+    setSyncCallback(callback: ReplaySyncCallback | null): void;
+    /** Force-flush pending data for upload */
+    flush(): Promise<void>;
+    /** Get a link to the current session replay (if available) */
+    getSessionReplayLink(): Promise<ReplayLinkResult | null>;
+    /** Get whether the SDK is currently recording */
+    readonly isRecording: boolean;
+    /** Get the current session ID */
+    readonly sessionId: string | null;
+    /** Destroy the SDK and release all resources */
+    destroy(): Promise<void>;
+};
+//# sourceMappingURL=api.d.ts.map

package/lib/typescript/features/replay/public/enums.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Session Replay SDK — Public Enums
+ *
+ * All user-facing enumerations for the replay SDK.
+ * These are the canonical values used across JS, Android, and iOS.
+ */
+/** How frames are captured */
+export declare enum CapturingMode {
+    /** Capture only on screen/route navigation changes */
+    Navigation = "navigation",
+    /** Capture on navigation + user interactions (tap, scroll, input) with throttling */
+    Interactions = "interactions",
+    /** Capture at a fixed time interval + on navigation changes */
+    Frequency = "frequency"
+}
+/** Screenshot compression quality */
+export declare enum ScreenshotQuality {
+    High = "high",
+    Normal = "normal",
+    Low = "low",
+    Grayscale = "grayscale"
+}
+/** Session lifecycle state */
+export declare enum SessionState {
+    Idle = "idle",
+    Recording = "recording",
+    Paused = "paused",
+    Finalizing = "finalizing",
+    Uploading = "uploading",
+    Completed = "completed",
+    Failed = "failed"
+}
+/** Timeline event categories */
+export declare enum TimelineEventType {
+    SessionStart = "session_start",
+    SessionEnd = "session_end",
+    ScreenViewed = "screen_viewed",
+    UserTap = "user_tap",
+    UserLongPress = "user_long_press",
+    UserScroll = "user_scroll",
+    UserSwipe = "user_swipe",
+    TextInputChange = "text_input_change",
+    KeyboardShown = "keyboard_shown",
+    KeyboardHidden = "keyboard_hidden",
+    AppForeground = "app_foreground",
+    AppBackground = "app_background",
+    ConsoleLog = "console_log",
+    NetworkRequest = "network_request",
+    CustomBreadcrumb = "custom_breadcrumb",
+    ErrorCaptured = "error_captured",
+    CrashCaptured = "crash_captured",
+    ManualCapture = "manual_capture",
+    FrameCaptured = "frame_captured"
+}
+/** Interaction tracking granularity */
+export declare enum InteractionType {
+    Tap = "tap",
+    LongPress = "long_press",
+    Scroll = "scroll",
+    Swipe = "swipe",
+    TextInput = "text_input",
+    Custom = "custom"
+}
+/** Frame capture trigger source */
+export declare enum CaptureTrigger {
+    Navigation = "navigation",
+    Interaction = "interaction",
+    Timer = "timer",
+    Manual = "manual",
+    Lifecycle = "lifecycle",
+    Error = "error"
+}
+//# sourceMappingURL=enums.d.ts.map

package/lib/typescript/features/replay/public/types.d.ts

@@ -0,0 +1,249 @@
+/**
+ * Session Replay SDK — Public Types
+ *
+ * All user-facing TypeScript types and interfaces.
+ */
+import type { CapturingMode, ScreenshotQuality, SessionState, TimelineEventType, CaptureTrigger } from './enums';
+export interface ReplayConfig {
+    /** Enable/disable the SDK. Default: true */
+    enabled: boolean;
+    /** API key for authentication with the upload endpoint */
+    apiKey: string;
+    /** Base URL for session upload endpoint */
+    endpoint: string;
+    /** Capture mode. Default: 'interactions' */
+    captureMode: CapturingMode;
+    /** Screenshot quality. Default: 'normal' */
+    screenshotQuality: ScreenshotQuality;
+    /** Capture interval in ms (only used in 'frequency' mode). Default: 1500 */
+    screenshotCaptureIntervalMs: number;
+    /** Track user interactions (taps, scrolls, inputs). Default: true */
+    userStepsEnabled: boolean;
+    /** Capture network request breadcrumbs. Default: true */
+    networkLogsEnabled: boolean;
+    /** Capture SDK/console logs. Default: true */
+    sdkLogsEnabled: boolean;
+    /** Auto-start recording on SDK init. Default: true */
+    autoStart: boolean;
+    /** Privacy configuration */
+    privacy: ReplayPrivacyOptions;
+    /** Maximum session duration in ms. Default: 300000 (5 min) */
+    maxSessionDurationMs: number;
+    /** Maximum frames per session. Default: 500 */
+    maxFramesPerSession: number;
+    /** Maximum local storage size in bytes. Default: 100MB */
+    maxStorageSizeBytes: number;
+    /** Maximum events per session. Default: 5000 */
+    maxEventsPerSession: number;
+    /** Upload batch size (number of frames per batch). Default: 10 */
+    uploadBatchSize: number;
+    /** Retry attempts for failed uploads. Default: 3 */
+    maxRetryAttempts: number;
+    /** Enable verbose internal logging. Default: false */
+    verboseLogging: boolean;
+    /** Send replay data to backend API. Default: false (desktop streaming only) */
+    sendToBackend: boolean;
+    /** Force backend upload even in dev/emulator mode. Default: false */
+    forceBackendInDev: boolean;
+}
+export interface ReplayPrivacyOptions {
+    /** Mask all text input fields in screenshots. Default: true */
+    maskTextInputs: boolean;
+    /** Mask all images in screenshots. Default: false */
+    maskImages: boolean;
+    /** Screen names where capture is completely disabled */
+    ignoredScreens: string[];
+    /** View/element identifiers to mask (testID, accessibilityLabel, nativeID) */
+    maskedElementIds: string[];
+    /** Completely disable screenshot capture (events-only mode). Default: false */
+    disableScreenshots: boolean;
+    /** Custom privacy predicate — return true to mask a given element ID */
+    customMaskPredicate?: (elementId: string) => boolean;
+}
+export interface ReplayUser {
+    /** Unique user identifier */
+    id: string;
+    /** Display name */
+    name?: string;
+    /** Email address */
+    email?: string;
+    /** Arbitrary key-value metadata */
+    attributes?: Record<string, string | number | boolean>;
+}
+export interface ReplayBreadcrumb {
+    /** Breadcrumb category (e.g. 'navigation', 'user', 'network', 'custom') */
+    category: string;
+    /** Human-readable message */
+    message: string;
+    /** Severity level */
+    level: 'debug' | 'info' | 'warning' | 'error' | 'fatal';
+    /** Breadcrumb timestamp (auto-filled if omitted) */
+    timestamp?: number;
+    /** Additional metadata */
+    data?: Record<string, unknown>;
+}
+export interface ReplayFrameMetadata {
+    /** Unique frame identifier */
+    frameId: string;
+    /** Session this frame belongs to */
+    sessionId: string;
+    /** Capture timestamp (epoch ms) */
+    timestamp: number;
+    /** Sequence number within the session */
+    sequenceNumber: number;
+    /** Current screen name at time of capture */
+    screenName: string;
+    /** What triggered this frame capture */
+    trigger: CaptureTrigger;
+    /** Image format */
+    format: 'jpeg' | 'webp' | 'png';
+    /** Compressed image size in bytes */
+    sizeBytes: number;
+    /** Frame width in pixels */
+    width: number;
+    /** Frame height in pixels */
+    height: number;
+    /** Quality setting used */
+    quality: ScreenshotQuality;
+    /** Whether privacy masking was applied */
+    masked: boolean;
+}
+export interface ReplayTimelineEvent {
+    /** Unique event identifier */
+    eventId: string;
+    /** Session this event belongs to */
+    sessionId: string;
+    /** Event type */
+    type: TimelineEventType;
+    /** Event timestamp (epoch ms) */
+    timestamp: number;
+    /** Current screen name */
+    screenName: string;
+    /** Human-readable label */
+    label: string;
+    /** Optional associated frame ID */
+    frameId?: string;
+    /** Event-specific payload */
+    data?: Record<string, unknown>;
+}
+export interface ReplaySessionInfo {
+    /** Unique session identifier */
+    sessionId: string;
+    /** Session state */
+    state: SessionState;
+    /** Start timestamp */
+    startedAt: number;
+    /** End timestamp (null if active) */
+    endedAt: number | null;
+    /** Duration in ms */
+    durationMs: number;
+    /** Number of captured frames */
+    frameCount: number;
+    /** Number of timeline events */
+    eventCount: number;
+    /** Current screen name */
+    currentScreen: string;
+    /** Capture mode in use */
+    captureMode: CapturingMode;
+    /** Device metadata */
+    device: ReplayDeviceInfo;
+    /** User identity (if set) */
+    user: ReplayUser | null;
+}
+export interface ReplayDeviceInfo {
+    platform: 'android' | 'ios';
+    osVersion: string;
+    deviceModel: string;
+    screenWidth: number;
+    screenHeight: number;
+    pixelDensity: number;
+    appName: string;
+    appVersion: string;
+    bundleId: string;
+    locale: string;
+}
+export interface ReplaySyncContext {
+    /** Session being uploaded */
+    sessionId: string;
+    /** Total frames in this batch */
+    frameCount: number;
+    /** Total events in this batch */
+    eventCount: number;
+    /** Total payload size in bytes */
+    totalSizeBytes: number;
+    /** Session duration in ms */
+    durationMs: number;
+    /** Device info */
+    device: ReplayDeviceInfo;
+    /** User info (if set) */
+    user: ReplayUser | null;
+}
+/** Return false from sync callback to cancel the upload */
+export type ReplaySyncCallback = (context: ReplaySyncContext) => boolean | Promise<boolean>;
+export interface ReplayLinkResult {
+    /** Direct URL to view this session replay */
+    url: string;
+    /** Session ID */
+    sessionId: string;
+    /** Whether the session has been uploaded */
+    uploaded: boolean;
+}
+export interface NetworkRequestSummary {
+    /** HTTP method */
+    method: string;
+    /** Request URL (may be truncated) */
+    url: string;
+    /** HTTP status code (0 if failed) */
+    statusCode: number;
+    /** Duration in ms */
+    durationMs: number;
+    /** Request body size in bytes */
+    requestSizeBytes: number;
+    /** Response body size in bytes */
+    responseSizeBytes: number;
+    /** Whether the request errored */
+    error: boolean;
+    /** Error message if failed */
+    errorMessage?: string;
+    /** Request start timestamp */
+    startTimestamp: number;
+    /** Request headers (captured if captureNetworkBodies is true) */
+    requestHeaders?: Record<string, string>;
+    /** Response headers (captured if captureNetworkBodies is true) */
+    responseHeaders?: Record<string, string>;
+    /** Request body (captured if captureNetworkBodies is true) */
+    requestBody?: unknown;
+    /** Response body (captured if captureNetworkBodies is true) */
+    responseBody?: unknown;
+}
+export interface SessionManifest {
+    /** Schema version for forward compatibility */
+    schemaVersion: number;
+    /** Session metadata */
+    session: ReplaySessionInfo;
+    /** Total number of frame batches */
+    totalBatches: number;
+    /** Whether this manifest is the final one */
+    finalized: boolean;
+}
+export interface FrameBatchPayload {
+    sessionId: string;
+    batchIndex: number;
+    frames: ReplayFrameMetadata[];
+    /** Base64-encoded frame images, keyed by frameId */
+    images: Record<string, string>;
+}
+export interface EventBatchPayload {
+    sessionId: string;
+    batchIndex: number;
+    events: ReplayTimelineEvent[];
+}
+export interface FinalizationPayload {
+    sessionId: string;
+    endedAt: number;
+    durationMs: number;
+    totalFrames: number;
+    totalEvents: number;
+    finalState: SessionState;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/features/replay/replay/breadcrumbs/breadcrumbCollector.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Session Replay SDK — Breadcrumb Collector
+ *
+ * Collects and buffers breadcrumbs from various sources
+ * (user, network, console, custom) and forwards them to native.
+ */
+import type { ReplayBreadcrumb, NetworkRequestSummary } from '../../public/types';
+declare class BreadcrumbCollector {
+    private readonly _queue;
+    private _enabled;
+    setEnabled(enabled: boolean): void;
+    /** Add a custom breadcrumb */
+    addBreadcrumb(breadcrumb: ReplayBreadcrumb): Promise<void>;
+    /** Add a network request breadcrumb */
+    addNetworkBreadcrumb(request: NetworkRequestSummary): Promise<void>;
+    /** Add a console log breadcrumb */
+    addConsoleBreadcrumb(level: string, message: string, args?: unknown[]): Promise<void>;
+    /** Get all collected breadcrumbs */
+    getAll(): readonly ReplayBreadcrumb[];
+    /** Clear all breadcrumbs */
+    clear(): void;
+    get count(): number;
+}
+export declare const breadcrumbCollector: BreadcrumbCollector;
+export {};
+//# sourceMappingURL=breadcrumbCollector.d.ts.map

package/lib/typescript/features/replay/replay/frames/frameModels.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Session Replay SDK — Frame Models
+ *
+ * Internal frame representation and helpers.
+ */
+import type { ReplayFrameMetadata } from '../../public/types';
+import type { CaptureTrigger, ScreenshotQuality } from '../../public/enums';
+/** Create a new frame metadata entry */
+export declare function createFrameMetadata(params: {
+    sessionId: string;
+    sequenceNumber: number;
+    screenName: string;
+    trigger: CaptureTrigger;
+    format: 'jpeg' | 'webp' | 'png';
+    sizeBytes: number;
+    width: number;
+    height: number;
+    quality: ScreenshotQuality;
+    masked: boolean;
+}): ReplayFrameMetadata;
+/** Estimate decoded frame size in memory (for backpressure) */
+export declare function estimateFrameMemoryBytes(width: number, height: number): number;
+//# sourceMappingURL=frameModels.d.ts.map

package/lib/typescript/features/replay/replay/session/sessionOrchestrator.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Session Replay SDK — Session Orchestrator
+ *
+ * JS-side session lifecycle coordination.
+ * Manages state transitions, connects integrations to native module,
+ * and handles session timers/limits.
+ *
+ * This is the main coordinator — it does NOT own capture logic
+ * (that's native). It manages JS-side state, event subscriptions,
+ * and integration wiring.
+ */
+import type { ReplayConfig, ReplayUser, ReplaySyncCallback } from '../../public/types';
+import { SessionState, CapturingMode } from '../../public/enums';
+declare class SessionOrchestrator {
+    private _config;
+    private _state;
+    private _sessionId;
+    private _user;
+    private _syncCallback;
+    private _currentScreen;
+    private _durationTimer;
+    private _frequencyTimer;
+    private _appStateSubscription;
+    private _initialized;
+    private _startedAt;
+    initialize(config: ReplayConfig): Promise<boolean>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    captureManualFrame(): Promise<void>;
+    setCurrentScreen(screenName: string): Promise<void>;
+    setUser(user: ReplayUser): Promise<void>;
+    clearUser(): Promise<void>;
+    setSyncCallback(callback: ReplaySyncCallback | null): void;
+    setEnabled(enabled: boolean): Promise<void>;
+    setCapturingMode(mode: CapturingMode): Promise<void>;
+    private _startDurationTimer;
+    private _startFrequencyTimerIfNeeded;
+    private _stopTimers;
+    private _stopFrequencyTimer;
+    private _onAppStateChange;
+    private _setupNativeEventListeners;
+    get state(): SessionState;
+    get sessionId(): string | null;
+    get currentScreen(): string;
+    get isRecording(): boolean;
+    destroy(): Promise<void>;
+}
+/** Singleton orchestrator */
+export declare const sessionOrchestrator: SessionOrchestrator;
+export {};
+//# sourceMappingURL=sessionOrchestrator.d.ts.map

package/lib/typescript/features/replay/replay/timeline/timelineModels.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Session Replay SDK — Timeline Models
+ *
+ * Internal timeline event representation and factory.
+ */
+import type { ReplayTimelineEvent } from '../../public/types';
+import { TimelineEventType } from '../../public/enums';
+/** Create a timeline event */
+export declare function createTimelineEvent(params: {
+    sessionId: string;
+    type: TimelineEventType;
+    screenName: string;
+    label: string;
+    frameId?: string;
+    data?: Record<string, unknown>;
+}): ReplayTimelineEvent;
+/** Create a screen viewed event */
+export declare function screenViewedEvent(sessionId: string, screenName: string): ReplayTimelineEvent;
+/** Create a user interaction event */
+export declare function interactionEvent(sessionId: string, screenName: string, interactionType: string, target?: string): ReplayTimelineEvent;
+/** Create a network request event */
+export declare function networkEvent(sessionId: string, screenName: string, method: string, url: string, statusCode: number, durationMs: number): ReplayTimelineEvent;
+/** Create a breadcrumb event */
+export declare function breadcrumbEvent(sessionId: string, screenName: string, category: string, message: string, data?: Record<string, unknown>): ReplayTimelineEvent;
+/** Create an error event */
+export declare function errorEvent(sessionId: string, screenName: string, errorMessage: string, fatal?: boolean): ReplayTimelineEvent;
+/** Create an app lifecycle event */
+export declare function lifecycleEvent(sessionId: string, screenName: string, foreground: boolean): ReplayTimelineEvent;
+//# sourceMappingURL=timelineModels.d.ts.map

package/lib/typescript/features/replay/transport/BackendReplayTransport.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Session Replay SDK — Backend Replay Transport
+ *
+ * Uploads replay data to a backend API via HTTP.
+ * Uses batching for frames/events and retry with exponential backoff.
+ *
+ * Design:
+ * - sendSessionStart → POST /v1/replay/sessions
+ * - sendFrame → buffered, flushed in batches to POST /v1/replay/sessions/:id/frames
+ * - sendEvent → buffered, flushed in batches to POST /v1/replay/sessions/:id/events
+ * - sendSessionEnd → flushes pending + POST /v1/replay/sessions/:id/finalize
+ *
+ * Never throws — all errors are caught and logged.
+ */
+import type { ReplayTransport, ReplaySessionStartPayload, ReplaySessionEndPayload, ReplayFramePayload, ReplayEventPayload } from './ReplayTransport';
+export interface BackendTransportConfig {
+    endpoint: string;
+    apiKey: string;
+    /** Number of frames to batch before uploading. Default: 5 */
+    batchSize?: number;
+    /** Auto-flush interval in ms. Default: 3000 */
+    flushIntervalMs?: number;
+    /** Request timeout in ms. Default: 30000 */
+    timeoutMs?: number;
+}
+export declare class BackendReplayTransport implements ReplayTransport {
+    private _config;
+    private _pendingFrames;
+    private _pendingEvents;
+    private _flushTimer;
+    private _currentSessionId;
+    private _destroyed;
+    constructor(config: BackendTransportConfig);
+    sendSessionStart(payload: ReplaySessionStartPayload): void;
+    sendFrame(frame: ReplayFramePayload, imageData: string): void;
+    sendEvent(event: ReplayEventPayload): void;
+    sendSessionEnd(payload: ReplaySessionEndPayload): void;
+    destroy(): void;
+    private _flushFrames;
+    private _flushEvents;
+    private _startFlushTimer;
+    private _stopFlushTimer;
+    private _post;
+}
+//# sourceMappingURL=BackendReplayTransport.d.ts.map

package/lib/typescript/features/replay/transport/CompositeReplayTransport.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Session Replay SDK — Composite Replay Transport
+ *
+ * Fans out replay data to 1+ child transports (e.g. desktop + backend).
+ * Each child transport handles its own errors independently.
+ * A failure in one transport never blocks another.
+ *
+ * Never throws — all errors are caught and logged.
+ */
+import type { ReplayTransport, ReplaySessionStartPayload, ReplaySessionEndPayload, ReplayFramePayload, ReplayEventPayload } from './ReplayTransport';
+export declare class CompositeReplayTransport implements ReplayTransport {
+    private _transports;
+    constructor(transports: ReplayTransport[]);
+    sendSessionStart(payload: ReplaySessionStartPayload): void;
+    sendFrame(frame: ReplayFramePayload, imageData: string): void;
+    sendEvent(event: ReplayEventPayload): void;
+    sendSessionEnd(payload: ReplaySessionEndPayload): void;
+    destroy(): void;
+    /** Number of active child transports */
+    get transportCount(): number;
+}
+//# sourceMappingURL=CompositeReplayTransport.d.ts.map

package/lib/typescript/features/replay/transport/DesktopReplayTransport.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Session Replay SDK — Desktop Replay Transport
+ *
+ * Streams replay data to the ScaleBun desktop tool via DebugTransport (WebSocket).
+ * This is the bridge between replay-sdk and scalebun-sdk's debug transport layer.
+ *
+ * The DebugTransport reference is injected from scalebun-sdk at init time.
+ * This transport serializes replay payloads into the debug protocol format
+ * (category: 'session', name: 'session:*').
+ *
+ * Never throws — all errors are caught and logged.
+ */
+import type { ReplayTransport, ReplaySessionStartPayload, ReplaySessionEndPayload, ReplayFramePayload, ReplayEventPayload } from './ReplayTransport';
+/**
+ * Minimal interface for scalebun-sdk's DebugTransport.
+ * We only depend on the shape, not the actual class, to avoid circular deps.
+ */
+export interface DebugTransportLike {
+    send(msg: unknown): void;
+    getState(): string;
+    readonly deviceId: string;
+    readonly sessionId: string;
+    nextSequence(): number;
+}
+export declare class DesktopReplayTransport implements ReplayTransport {
+    private _transport;
+    constructor(transport: DebugTransportLike);
+    sendSessionStart(payload: ReplaySessionStartPayload): void;
+    sendFrame(frame: ReplayFramePayload, imageData: string): void;
+    sendEvent(event: ReplayEventPayload): void;
+    sendSessionEnd(payload: ReplaySessionEndPayload): void;
+    destroy(): void;
+    private _send;
+}
+//# sourceMappingURL=DesktopReplayTransport.d.ts.map