@scalebun-release/react-native 2.5.0

package/lib/typescript/features/replay/bridge/nativeModule.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Session Replay SDK — Native Module Bridge
+ *
+ * Typed interface for the native module (Android/iOS).
+ * Every method here has a corresponding implementation in:
+ *   - Android: ReplaySdkModule.kt
+ *   - iOS: ReplaySdk.swift
+ *
+ * All bridge methods are async (they cross the native boundary).
+ */
+/** Native frame capture result returned from platform */
+export interface NativeFrameResult {
+    base64: string;
+    width: number;
+    height: number;
+    sizeBytes: number;
+    format: string;
+    timestamp: number;
+    /** Visible scroll containers at capture time — raw native value, sanitize before use. */
+    scrollState?: unknown;
+}
+/**
+ * Metadata-only result from a native capture-to-file (durable outbox path).
+ * NO base64 — the encoded image lives in the native outbox and the bytes never
+ * cross the JS bridge. The native uploader owns its upload.
+ */
+export interface NativeOutboxFrameResult {
+    frameId: string;
+    sessionId: string;
+    localPath: string;
+    width: number;
+    height: number;
+    sizeBytes: number;
+    format: string;
+    contentType: string;
+    timestamp: number;
+    screenName: string;
+    trigger: string;
+    masked: boolean;
+    /** Cheap native content hash; lets JS change-detection run without base64. */
+    frameHash: string;
+    /** Visible scroll containers at capture time — raw native value, sanitize before use. */
+    scrollState?: unknown;
+}
+/** Stats snapshot of the native file outbox. */
+export interface NativeOutboxStats {
+    enabled: boolean;
+    uploadEnabled: boolean;
+    totalBytes: number;
+    sessionCount: number;
+}
+/** Native voice-note recording result (Slice D) */
+export interface NativeVoiceResult {
+    base64: string;
+    mime: string;
+    durationMs: number;
+    byteSize: number;
+    /** On-device STT prefill (best-effort; user edits + approves before send). */
+    transcript: string;
+    transcriptAvailable: boolean;
+}
+/** Native session info returned from platform */
+export interface NativeSessionInfo {
+    sessionId: string;
+    state: string;
+    startedAt: number;
+    endedAt: number;
+    frameCount: number;
+    eventCount: number;
+    currentScreen: string;
+}
+/** Native device info */
+export interface NativeDeviceInfo {
+    platform: string;
+    osVersion: string;
+    deviceModel: string;
+    screenWidth: number;
+    screenHeight: number;
+    pixelDensity: number;
+    appName: string;
+    appVersion: string;
+    bundleId: string;
+    locale: string;
+}
+/**
+ * Native module interface — must match Kotlin/Swift implementations exactly.
+ *
+ * Method naming convention:
+ *   - camelCase
+ *   - Returns Promise for all async operations
+ *   - Accepts serializable types only (string, number, boolean, objects, arrays)
+ */
+export interface ReplaySdkNativeModule {
+    initialize(config: Record<string, unknown>): Promise<boolean>;
+    startSession(): Promise<string>;
+    stopSession(): Promise<boolean>;
+    pauseSession(): Promise<boolean>;
+    resumeSession(): Promise<boolean>;
+    captureFrame(reason: string): Promise<NativeFrameResult | null>;
+    captureManualFrame(): Promise<NativeFrameResult | null>;
+    captureScreenshot(reason: string): Promise<NativeFrameResult | null>;
+    /**
+     * Lightweight outbox bootstrap for the SaaS path where the full native
+     * `initialize()` is never called. Constructs only the NativeOutbox + uploader.
+     * Idempotent. Resolves false when the flag is off or already initialized.
+     */
+    initOutbox(config: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Capture a screenshot straight to the native outbox; resolves metadata only.
+     * STAGES the image (no upload-marker meta) so the JS orchestrator can decide
+     * keyframe/delta + change-detection before committing or discarding.
+     */
+    captureScreenshotToFile(input: Record<string, unknown>): Promise<NativeOutboxFrameResult | null>;
+    /** Commit a staged frame (writes JS-authoritative meta → uploadable). Resolves meta path. */
+    commitOutboxFrame(meta: Record<string, unknown>): Promise<string | null>;
+    /** Discard a staged frame the JS orchestrator suppressed (no upload). */
+    discardOutboxFrame(sessionId: string, frameId: string): Promise<boolean>;
+    /** Append already-batched telemetry records to the native JSONL outbox. */
+    enqueueOutboxRecords(lane: string, sessionId: string, records: Array<Record<string, unknown>>): Promise<boolean>;
+    /** Close open segments and trigger a native upload drain. */
+    flushNativeOutbox(): Promise<boolean>;
+    /** Re-run startup recovery (requeue interrupted uploads, sweep orphans). */
+    recoverNativeOutbox(): Promise<boolean>;
+    /** Snapshot of outbox size/usage. */
+    getOutboxStats(): Promise<NativeOutboxStats | null>;
+    /**
+     * Per-feature quota (shared contract v1). `blocked: true` parks the lane in the native uploader
+     * (no drain, no retry) and DELETES everything stored for it across all sessions, resolving the
+     * number of files removed; `blocked: false` un-parks it. Lanes: 'frames' | 'events' | 'network'.
+     * Optional: absent on binaries built before quota enforcement — the JS gates still hold there.
+     */
+    setOutboxLaneQuota?(lane: string, blocked: boolean): Promise<number>;
+    startVoiceRecording(): Promise<void>;
+    stopVoiceRecording(): Promise<NativeVoiceResult | null>;
+    cancelVoiceRecording(): Promise<void>;
+    setEnabled(enabled: boolean): Promise<void>;
+    setCapturingMode(mode: string): Promise<void>;
+    setScreenshotQuality(quality: string): Promise<void>;
+    setScreenshotCaptureInterval(intervalMs: number): Promise<void>;
+    setUserStepsEnabled(enabled: boolean): Promise<void>;
+    setNetworkLogsEnabled(enabled: boolean): Promise<void>;
+    setSdkLogsEnabled(enabled: boolean): Promise<void>;
+    setPrivacyOptions(options: Record<string, unknown>): Promise<void>;
+    maskElement(elementId: string): Promise<void>;
+    unmaskElement(elementId: string): Promise<void>;
+    setUser(user: Record<string, unknown>): Promise<void>;
+    clearUser(): Promise<void>;
+    addBreadcrumb(breadcrumb: Record<string, unknown>): Promise<void>;
+    addNetworkBreadcrumb(request: Record<string, unknown>): Promise<void>;
+    setCurrentScreen(screenName: string): Promise<void>;
+    reportInteraction(interaction: Record<string, unknown>): Promise<void>;
+    getSessionInfo(): Promise<NativeSessionInfo | null>;
+    getDeviceInfo(): Promise<NativeDeviceInfo>;
+    getSessionReplayLink(): Promise<{
+        url: string;
+        sessionId: string;
+        uploaded: boolean;
+    } | null>;
+    flushUpload(): Promise<boolean>;
+    cancelUpload(): Promise<void>;
+    destroy(): Promise<void>;
+}
+export declare function getReplaySdkNative(): ReplaySdkNativeModule | null;
+/** Check if native module is available without throwing */
+export declare function isNativeModuleAvailable(): boolean;
+//# sourceMappingURL=nativeModule.d.ts.map

package/lib/typescript/features/replay/bridge/nativeQuota.d.ts

@@ -0,0 +1,26 @@
+import { type QuotaFeature } from '../../../config/quotaState';
+export declare const QUOTA_NATIVE_LANES: ReadonlyArray<readonly [QuotaFeature, string]>;
+/** Push every mapped lane's current state to native. Best-effort, never throws. */
+export declare function syncNativeQuotaLanes(): void;
+/**
+ * Who drops a session the native uploader saw refused (402 quota_exceeded feature:"sessions").
+ * Set by the BackendSessionAdapter; returns an unregister that only clears its own handler.
+ */
+export declare function setNativeSessionRefusedHandler(fn: (sessionId: string) => void): () => void;
+/**
+ * Wire native ↔ quota once per process: the lane-state mirror on EVERY quotaState sync, and the
+ * listener for 402s / partial grants the native uploader received. Called before native
+ * initOutbox / initialize — whichever path builds an uploader — so neither depends on the JS
+ * adapter's own outbox flags.
+ */
+export declare function subscribeNativeQuotaEvents(): void;
+/** Exported for tests: what the listener does with one native notification. */
+export declare function handleNativeQuotaEvent(e: {
+    status?: number;
+    body?: unknown;
+    retryAfterMs?: number;
+    sessionId?: string;
+}): void;
+/** TEST-ONLY */
+export declare function __resetNativeQuotaForTests(): void;
+//# sourceMappingURL=nativeQuota.d.ts.map

package/lib/typescript/features/replay/core/clock/clock.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Session Replay SDK — Clock
+ *
+ * Monotonic-safe timestamp utilities.
+ * Uses Date.now() as the primary source but provides
+ * relative delta helpers for duration calculation.
+ */
+/** Current epoch timestamp in milliseconds */
+export declare function now(): number;
+export declare function markSessionStart(): void;
+/** Get ms elapsed since session start. Returns 0 if session not started. */
+export declare function sessionElapsed(): number;
+export declare function resetClock(): void;
+/** Format ms duration to human-readable string */
+export declare function formatDuration(ms: number): string;
+//# sourceMappingURL=clock.d.ts.map

package/lib/typescript/features/replay/core/config/defaults.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Session Replay SDK — Default Configuration
+ */
+import { ScreenshotQuality } from '../../public/enums';
+import type { ReplayConfig } from '../../public/types';
+export declare const DEFAULT_CONFIG: ReplayConfig;
+/** Quality presets: maxWidth in px, JPEG/WebP quality 0-100 */
+export declare const QUALITY_PRESETS: Record<ScreenshotQuality, {
+    maxWidth: number;
+    jpegQuality: number;
+    format: 'webp' | 'jpeg';
+}>;
+/** Interaction capture debounce thresholds in ms */
+export declare const INTERACTION_DEBOUNCE: Record<string, number>;
+/** Session limits */
+export declare const SESSION_LIMITS: {
+    readonly MIN_INTERVAL_MS: 200;
+    readonly MAX_INTERVAL_MS: 30000;
+    readonly MIN_SESSION_DURATION_MS: 5000;
+    readonly MAX_SESSION_DURATION_MS: 1800000;
+    readonly MIN_FRAMES: 10;
+    readonly MAX_FRAMES: 2000;
+    readonly MIN_EVENTS: 100;
+    readonly MAX_EVENTS: 50000;
+    readonly MAX_BREADCRUMB_MESSAGE_LENGTH: 1024;
+    readonly MAX_BREADCRUMB_DATA_SIZE: 4096;
+};
+//# sourceMappingURL=defaults.d.ts.map

package/lib/typescript/features/replay/core/config/validator.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Session Replay SDK — Config Validator
+ *
+ * Validates and merges user config with defaults.
+ * Returns a fully populated, safe config object.
+ */
+import type { ReplayConfig } from '../../public/types';
+export interface ValidationResult {
+    config: ReplayConfig;
+    warnings: string[];
+}
+export declare function validateConfig(partial: Partial<ReplayConfig>): ValidationResult;
+//# sourceMappingURL=validator.d.ts.map

package/lib/typescript/features/replay/core/env/environmentDetector.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Session Replay SDK — Environment Detector
+ *
+ * Detects whether the app is running in a development or emulator environment.
+ * Used to auto-skip backend upload in dev mode unless explicitly forced.
+ */
+/**
+ * Check if the app is running in dev/emulator mode.
+ * Uses React Native's __DEV__ global flag.
+ *
+ * @returns true if running in development mode
+ */
+export declare function isDevOrEmulator(): boolean;
+//# sourceMappingURL=environmentDetector.d.ts.map

package/lib/typescript/features/replay/core/errors/safeCall.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Session Replay SDK — Safe Call Wrappers
+ *
+ * No-throw boundaries for all public API methods and native bridge calls.
+ */
+/** Execute a synchronous function, catching and logging any errors */
+export declare function safeCall<T>(label: string, fn: () => T, fallback: T): T;
+/** Execute an async function, catching and logging any errors */
+export declare function safeCallAsync<T>(label: string, fn: () => Promise<T>, fallback: T): Promise<T>;
+/** Fire-and-forget async call — never throws, never awaited by caller */
+export declare function fireAndForget(label: string, fn: () => Promise<void>): void;
+//# sourceMappingURL=safeCall.d.ts.map

package/lib/typescript/features/replay/core/ids/sessionId.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Session Replay SDK — Session ID Generator
+ *
+ * Generates unique session and event identifiers.
+ * Uses timestamp + random suffix for uniqueness without external deps.
+ */
+/** Generate a unique session ID: "rs-{timestamp}-{random}" */
+export declare function generateSessionId(): string;
+/** Generate a unique event ID: "re-{timestamp}-{random}" */
+export declare function generateEventId(): string;
+/** Generate a unique frame ID: "rf-{timestamp}-{random}" */
+export declare function generateFrameId(): string;
+/** Generate a unique batch ID: "rb-{timestamp}-{random}" */
+export declare function generateBatchId(): string;
+//# sourceMappingURL=sessionId.d.ts.map

package/lib/typescript/features/replay/core/logger/logger.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Session Replay SDK — Internal Logger
+ *
+ * Leveled logger with optional verbose mode.
+ * All SDK internal logging goes through this.
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export declare function setVerbose(enabled: boolean): void;
+export declare const logger: {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/lib/typescript/features/replay/core/privacy/privacyTypes.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Session Replay SDK — Privacy Types (Core)
+ *
+ * Internal privacy processing types used by native and JS layers.
+ */
+import type { ReplayPrivacyOptions } from '../../public/types';
+/** Privacy configuration resolved for a specific screen */
+export interface ResolvedPrivacy {
+    /** Should capture be skipped entirely for this screen? */
+    skipCapture: boolean;
+    /** Should text inputs be masked? */
+    maskTextInputs: boolean;
+    /** Should images be masked? */
+    maskImages: boolean;
+    /** Element IDs to mask */
+    maskedElementIds: Set<string>;
+    /** Custom mask predicate */
+    customPredicate: ((elementId: string) => boolean) | null;
+}
+/** Resolve privacy options for a specific screen name */
+export declare function resolvePrivacy(options: ReplayPrivacyOptions, screenName: string): ResolvedPrivacy;
+/** Check if a specific element should be masked */
+export declare function shouldMaskElement(privacy: ResolvedPrivacy, elementId: string): boolean;
+//# sourceMappingURL=privacyTypes.d.ts.map

package/lib/typescript/features/replay/core/queue/boundedQueue.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Session Replay SDK — Bounded Queue
+ *
+ * Thread-safe bounded queue with backpressure.
+ * Used for frame capture requests, event buffering, and upload batching.
+ */
+export declare class BoundedQueue<T> {
+    private readonly _items;
+    private readonly _maxSize;
+    private _dropped;
+    constructor(maxSize: number);
+    /** Enqueue an item. Returns false if item was dropped due to capacity. */
+    enqueue(item: T): boolean;
+    /** Dequeue the oldest item. Returns undefined if empty. */
+    dequeue(): T | undefined;
+    /** Dequeue up to `count` items at once */
+    dequeueBatch(count: number): T[];
+    /** Peek at the oldest item without removing */
+    peek(): T | undefined;
+    get size(): number;
+    get capacity(): number;
+    get droppedCount(): number;
+    get isEmpty(): boolean;
+    get isFull(): boolean;
+    clear(): void;
+    /** Get all items as a snapshot (does not remove) */
+    snapshot(): readonly T[];
+}
+//# sourceMappingURL=boundedQueue.d.ts.map

package/lib/typescript/features/replay/integrations/alert/alertInstrumentation.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Session Replay SDK — Native Alert Instrumentation
+ *
+ * Why this exists
+ * ---------------
+ * React Native `Alert.alert` / `Alert.prompt` render a NATIVE dialog:
+ *   - iOS   → a `UIAlertController` in a separate `.alert`-level `UIWindow`.
+ *   - Android → an `AlertDialog` in its own dialog `Window`.
+ *
+ * Neither surface is part of the React view tree, so:
+ *   1. The JS touch responder in `ReplayRoot`/`ScaleBunDebugRoot` never sees the
+ *      OK/Cancel taps (the responder only covers the app's React root view).
+ *   2. The native touch trackers attach to the app/activity window, not the
+ *      alert/dialog window, so they miss those taps too.
+ *
+ * The frame-level visibility of the alert is solved natively (Android already
+ * composites extra windows; iOS now composites all windows in
+ * ScreenshotCaptureManager). This module solves the INTERACTION + LIFECYCLE
+ * half in one cross-platform place by wrapping the `Alert` API:
+ *   - records `alert_shown` when an alert is presented,
+ *   - records `alert_action` (with the pressed button label) at press time,
+ *   - records `alert_dismissed` after the dialog closes,
+ *   - triggers frames so the timeline shows the screen with the alert visible
+ *     and the screen right after it is dismissed.
+ *
+ * Everything routes through the unified `SessionManager` (the same pipeline all
+ * other gestures use). `SessionManager.onUserAction` / `captureManualFrame`
+ * already no-op when recording is OFF, so this is inert outside an active
+ * session. Install is reversible and idempotent.
+ *
+ * OS limitation (documented): exact touch COORDINATES inside the native dialog
+ * are not available to JS or to the app-window touch tracker. We record the
+ * semantic button identity (text + style) instead, which is more accurate for
+ * the timeline than a guessed coordinate would be. Alerts presented purely from
+ * native code (not via RN `Alert`) are out of scope.
+ */
+export interface AlertInstrumentationOptions {
+    /** Emit verbose `[AlertCapture]` debug logs. Default: false. */
+    debug?: boolean;
+}
+/**
+ * Patch `Alert.alert` / `Alert.prompt`. Idempotent and reversible.
+ */
+export declare function installAlertInstrumentation(opts?: AlertInstrumentationOptions): void;
+/** Restore the original `Alert` API. Safe to call when not installed. */
+export declare function uninstallAlertInstrumentation(): void;
+export declare function isAlertInstrumentationInstalled(): boolean;
+//# sourceMappingURL=alertInstrumentation.d.ts.map

package/lib/typescript/features/replay/integrations/logs/consoleIntegration.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Session Replay SDK — Console Log Integration
+ *
+ * Patches console.log/warn/error to capture log breadcrumbs.
+ * Can be enabled/disabled at runtime.
+ */
+/**
+ * Install console interceptors.
+ * Safe to call multiple times — only installs once.
+ */
+export declare function installConsoleIntegration(): void;
+/**
+ * Remove console interceptors and restore originals.
+ */
+export declare function uninstallConsoleIntegration(): void;
+/** Enable/disable console breadcrumb capture at runtime */
+export declare function setConsoleEnabled(enabled: boolean): void;
+//# sourceMappingURL=consoleIntegration.d.ts.map

package/lib/typescript/features/replay/integrations/network/networkAdapter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Session Replay SDK — Network Adapter
+ *
+ * Provides network breadcrumb integration via adapter pattern.
+ * Does NOT monkey-patch XMLHttpRequest or fetch.
+ * Instead, provides a report function that users or other interceptors can call.
+ *
+ * Usage:
+ *   import { reportNetworkRequest } from '@scalebun/replay-sdk';
+ *
+ *   // After your network request completes:
+ *   reportNetworkRequest({
+ *       method: 'GET',
+ *       url: 'https://api.example.com/data',
+ *       statusCode: 200,
+ *       durationMs: 150,
+ *       requestSizeBytes: 0,
+ *       responseSizeBytes: 1024,
+ *       error: false,
+ *       startTimestamp: Date.now() - 150,
+ *   });
+ */
+import type { NetworkRequestSummary } from '../../public/types';
+/**
+ * Report a completed network request as a replay breadcrumb.
+ * Safe to call from anywhere — no-throw.
+ */
+export declare function reportNetworkRequest(request: NetworkRequestSummary): void;
+/** Enable/disable network breadcrumb collection */
+export declare function setNetworkEnabled(enabled: boolean): void;
+//# sourceMappingURL=networkAdapter.d.ts.map

package/lib/typescript/features/replay/integrations/react-navigation/navigationIntegration.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Session Replay SDK — React Navigation Integration
+ *
+ * Listens to React Navigation route changes and reports them
+ * as screen views to the native replay module.
+ *
+ * Usage:
+ *   import { useReplayNavigation } from '@scalebun/replay-sdk';
+ *   const navigationRef = useNavigationContainerRef();
+ *   useReplayNavigation(navigationRef);
+ */
+/**
+ * React hook to integrate React Navigation with Session Replay.
+ *
+ * Automatically tracks screen changes and triggers frame captures.
+ *
+ * @param navigationRef - The navigation container ref from React Navigation
+ */
+export declare function useReplayNavigation(navigationRef: any): void;
+/**
+ * Manual screen tracking for apps not using React Navigation.
+ * Call this whenever the user navigates to a new screen.
+ */
+export declare function trackScreen(screenName: string): void;
+//# sourceMappingURL=navigationIntegration.d.ts.map

package/lib/typescript/features/replay/integrations/touch/ReplayRoot.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Session Replay SDK — ReplayRoot Component
+ *
+ * Root wrapper component for touch/interaction tracking.
+ * Wrap your app root with this to enable automatic interaction detection.
+ *
+ * Usage:
+ *   import { ReplayRoot } from '@scalebun/replay-sdk';
+ *
+ *   function App() {
+ *     return (
+ *       <ReplayRoot>
+ *         <NavigationContainer>...</NavigationContainer>
+ *       </ReplayRoot>
+ *     );
+ *   }
+ */
+import React, { type ReactNode } from 'react';
+interface ReplayRootProps {
+    children: ReactNode;
+    /** Disable interaction tracking. Default: false */
+    disableInteractionTracking?: boolean;
+}
+export declare function ReplayRoot({ children, disableInteractionTracking }: ReplayRootProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=ReplayRoot.d.ts.map

package/lib/typescript/features/replay/pipeline/batching/batchManager.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Session Replay SDK — Batch Manager
+ *
+ * Accumulates frames and events, then creates upload batches
+ * when batch size is reached or flush is triggered.
+ */
+import type { ReplayFrameMetadata, ReplayTimelineEvent } from '../../public/types';
+export interface PendingBatch {
+    batchId: string;
+    sessionId: string;
+    batchIndex: number;
+    frames: ReplayFrameMetadata[];
+    events: ReplayTimelineEvent[];
+    images: Record<string, string>;
+    createdAt: number;
+    sizeBytes: number;
+}
+declare class BatchManager {
+    private _batchSize;
+    private _batchIndex;
+    private _sessionId;
+    private readonly _pendingFrames;
+    private readonly _pendingEvents;
+    private readonly _pendingImages;
+    private readonly _readyBatches;
+    configure(batchSize: number): void;
+    setSessionId(sessionId: string): void;
+    /** Add a frame to the pending batch */
+    addFrame(frame: ReplayFrameMetadata, base64Image: string): void;
+    /** Add an event to the pending batch */
+    addEvent(event: ReplayTimelineEvent): void;
+    /** Force-flush all pending items into a batch */
+    flush(): PendingBatch | null;
+    /** Dequeue the next ready batch for upload */
+    dequeueReadyBatch(): PendingBatch | undefined;
+    /** Check if there are ready batches */
+    get hasReadyBatches(): boolean;
+    get pendingFrameCount(): number;
+    get readyBatchCount(): number;
+    /** Reset all state */
+    reset(): void;
+    private _createBatch;
+    private _estimateSize;
+}
+export declare const batchManager: BatchManager;
+export {};
+//# sourceMappingURL=batchManager.d.ts.map

package/lib/typescript/features/replay/pipeline/envelope/envelopeBuilder.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Session Replay SDK — Envelope Builder
+ *
+ * Constructs upload payload envelopes for session manifest,
+ * frame batches, event batches, and finalization payloads.
+ */
+import type { SessionManifest, FrameBatchPayload, EventBatchPayload, FinalizationPayload, ReplaySessionInfo, ReplayFrameMetadata, ReplayTimelineEvent } from '../../public/types';
+export declare function buildSessionManifest(session: ReplaySessionInfo, totalBatches: number, finalized: boolean): SessionManifest;
+export declare function buildFrameBatch(sessionId: string, batchIndex: number, frames: ReplayFrameMetadata[], images: Record<string, string>): FrameBatchPayload;
+export declare function buildEventBatch(sessionId: string, batchIndex: number, events: ReplayTimelineEvent[]): EventBatchPayload;
+export declare function buildFinalization(sessionId: string, endedAt: number, durationMs: number, totalFrames: number, totalEvents: number): FinalizationPayload;
+//# sourceMappingURL=envelopeBuilder.d.ts.map

package/lib/typescript/features/replay/pipeline/retry/retryPolicy.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Session Replay SDK — Retry Policy
+ *
+ * Exponential backoff retry for upload failures.
+ */
+export interface RetryConfig {
+    maxAttempts: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    backoffMultiplier: number;
+}
+export declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+/** Calculate delay for a given attempt number (exponential backoff with jitter) */
+export declare function calculateDelay(attempt: number, config?: RetryConfig): number;
+/** Execute an async function with retry policy */
+export declare function withRetry<T>(label: string, fn: (attempt: number) => Promise<T>, shouldRetry: (error: any, attempt: number) => boolean, config?: RetryConfig): Promise<T>;
+//# sourceMappingURL=retryPolicy.d.ts.map

package/lib/typescript/features/replay/pipeline/transport/transportTypes.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Session Replay SDK — Transport Types
+ *
+ * Transport layer interfaces for session upload.
+ */
+export interface TransportConfig {
+    endpoint: string;
+    apiKey: string;
+    timeoutMs: number;
+    maxRetries: number;
+}
+export interface TransportResult {
+    success: boolean;
+    statusCode: number;
+    retryable: boolean;
+    error?: string;
+}
+export interface TransportPayload {
+    path: string;
+    method: 'POST' | 'PUT' | 'PATCH';
+    headers: Record<string, string>;
+    body: string;
+}
+/**
+ * Transport interface — implemented by native or JS-side HTTP clients.
+ * The native implementation is preferred for background upload support.
+ */
+export interface ReplayTransportInterface {
+    send(payload: TransportPayload): Promise<TransportResult>;
+    cancel(): void;
+}
+/** Default JS-side transport using fetch */
+export declare class FetchTransport implements ReplayTransportInterface {
+    private readonly _config;
+    private _abortController;
+    constructor(config: TransportConfig);
+    send(payload: TransportPayload): Promise<TransportResult>;
+    cancel(): void;
+}
+//# sourceMappingURL=transportTypes.d.ts.map