@scalebun-release/react-native 2.5.0

package/lib/typescript/features/session/sessionTypes.d.ts

@@ -0,0 +1,362 @@
+import type { PlatformOS } from '../../core/context/device';
+import type { FrameScrollEntry } from './frameScrollState';
+/**
+ * ScaleBun SDK — Unified Session Domain Model
+ *
+ * Single source of truth for event types, frame types, session lifecycle,
+ * transport contracts, sync contracts, capture configuration, and artifact indexing.
+ *
+ * Architecture rules:
+ * - imageRef in ReplayFrame is an artifact reference (ID/path), NOT base64.
+ *   Base64 is transport-layer detail only.
+ * - SyncDecisionEngine in the SDK owns sync policy; native only gathers metadata.
+ * - Frame capture is native-only (PixelCopy on Android, UIWindow on iOS).
+ *   No JS screenshot fallback for session replay.
+ * - Frame retention prefers crash-adjacent/error-context frames over generic old frames.
+ */
+export type SessionStatus = 'active' | 'ended' | 'timeout';
+export interface SessionMetadata {
+    appName?: string;
+    appVersion?: string;
+    bundleId?: string;
+    platform?: PlatformOS;
+    osVersion?: string;
+    deviceModel?: string;
+    deviceName?: string;
+    screenWidth?: number;
+    screenHeight?: number;
+    buildType?: 'debug' | 'release';
+}
+export interface Session {
+    sessionId: string;
+    deviceId: string;
+    startedAt: number;
+    endedAt?: number;
+    status: SessionStatus;
+    metadata: SessionMetadata;
+    transportState: TransportState;
+    syncState: SyncState;
+    artifactIndex: SessionArtifactIndex;
+}
+export type JourneyEventType = 'SESSION_STARTED' | 'SESSION_ENDED' | 'APP_FOREGROUND' | 'APP_BACKGROUND' | 'SCREEN_VIEW'
+/** Leaving a screen, carrying the MEASURED dwell time — see SessionManager.onScreenChange. */
+ | 'SCREEN_EXIT' | 'USER_ACTION' | 'NETWORK_REQUEST_STARTED' | 'NETWORK_REQUEST_COMPLETED' | 'NETWORK_REQUEST_FAILED' | 'LOG_EMITTED' | 'ERROR_CAPTURED' | 'CRASH_CAPTURED' | 'REPLAY_FRAME_CAPTURED' | 'LOADING_STARTED' | 'LOADING_COMPLETED';
+export type JourneyEventSeverity = 'info' | 'warning' | 'error' | 'fatal';
+export type JourneyEventSource = 'sdk' | 'native' | 'user' | 'system';
+export interface JourneyEvent {
+    eventId: string;
+    sessionId: string;
+    /** If this event belongs to a recorded journey */
+    journeyId?: string;
+    ts: number;
+    type: JourneyEventType;
+    /** Subtype for further classification (e.g. 'TAP', 'SWIPE', 'console.error') */
+    subtype?: string;
+    severity?: JourneyEventSeverity;
+    /** Screen name at time of event */
+    screen?: string;
+    /**
+     * frameId of the screenshot that was ON SCREEN when this event happened.
+     *
+     * The picture the user was looking at, not the one that follows. Mobile has no DOM to
+     * reconstruct, so a captured frame is the only record of what a screen looked like at a
+     * moment — which makes this the join key between a tap and the state it was made in.
+     *
+     * Set only when a keyframe from the SAME screen was captured recently enough to still be
+     * showing (see SessionManager.currentFrameForEvent). Absent means "not captured", which is a
+     * DIFFERENT answer from "nothing was open" and must never be folded into it:
+     *   · the analytics lane never has one — it runs only when no recording is active, so no
+     *     screenshots exist at all
+     *   · a tap right after navigation has none — the capture is debounced and evicted on
+     *     screen change
+     */
+    frameId?: string;
+    payload?: Record<string, unknown>;
+    /** Links related events (e.g. network request start → complete) */
+    correlationId?: string;
+    /** Distributed trace ID */
+    traceId?: string;
+    source?: JourneyEventSource;
+}
+/**
+ * imageRef is an ARTIFACT REFERENCE (opaque ID/path), not raw base64.
+ * Base64 content is a transport/storage detail resolved separately.
+ * This keeps the domain model transport-agnostic.
+ */
+export interface ReplayFrame {
+    frameId: string;
+    sessionId: string;
+    ts: number;
+    /** Monotonic per-session sequence (P2-0). Assigned in JS, starts at 1, +1 per emitted frame. */
+    sequenceNumber: number;
+    /** Keyframe (full image) or delta (changed regions vs baseFrameId). P2-5. */
+    frameType: 'keyframe' | 'delta';
+    /** frameId of the keyframe a delta is encoded against; undefined for keyframes. P2-5. */
+    baseFrameId?: string;
+    /** Artifact reference — resolved to actual data by transport/storage layer */
+    imageRef: string;
+    width: number;
+    height: number;
+    /** Encoded image byte size (real value from native), 0 if unknown. */
+    byteSize?: number;
+    /** Image encoding from native ('avif' | 'webp' | 'jpeg' | 'png'). P2-2 fallback chain. */
+    format?: string;
+    quality: ReplayQuality;
+    captureReason: CaptureReason;
+    /** Native-only capture — JS never captures frames */
+    sourcePlatform: PlatformOS;
+    redactionState?: 'none' | 'text-masked' | 'full';
+    /** Screen name at capture time — for frame-to-screen correlation */
+    screen?: string;
+    /**
+     * Visible scroll containers read natively at the moment of capture, largest first, at most 4
+     * (Android capture-view px, iOS points). Undefined = not measured; [] = none on screen.
+     * See frameScrollState.ts.
+     */
+    scrollState?: FrameScrollEntry[];
+    /** Interaction point metadata — populated when captureReason is 'interaction' */
+    interactionPoint?: {
+        /** Tap/gesture X coordinate in device pixels */
+        x: number;
+        /** Tap/gesture Y coordinate in device pixels */
+        y: number;
+        /** Normalized X (0 to 1) for safe heatmap overlay across different viewport sizes */
+        normalizedX?: number;
+        /** Normalized Y (0 to 1) for safe heatmap overlay across different viewport sizes */
+        normalizedY?: number;
+        /** Device screen width at capture time */
+        screenWidth: number;
+        /** Device screen height at capture time */
+        screenHeight: number;
+        /** Actual viewport width at capture time, equivalent to screenWidth in most cases */
+        viewportWidth?: number;
+        /** Actual viewport height at capture time, equivalent to screenHeight in most cases */
+        viewportHeight?: number;
+        /** Gesture type: tap, long_press, swipe, scroll */
+        gestureType: string;
+        /** For swipes/scrolls: End X coordinate */
+        endX?: number;
+        /** For swipes/scrolls: End Y coordinate */
+        endY?: number;
+        /** For swipes/scrolls: Normalized End X */
+        normalizedEndX?: number;
+        /** For swipes/scrolls: Normalized End Y */
+        normalizedEndY?: number;
+        /** Duration of gesture if tracked */
+        durationMs?: number;
+        /** Gesture direction: up, down, left, right */
+        direction?: string;
+    };
+}
+export type CaptureReason = 'navigation' | 'interaction' | 'frequency' | 'manual' | 'error-context' | 'scroll' | 'screen_loaded';
+export interface CrashAnchor {
+    crashEventId: string;
+    /** Event IDs within ±N of the crash */
+    nearbyEventIds: string[];
+    /** Frame IDs within ±N of the crash */
+    nearbyFrameIds: string[];
+    timestamp: number;
+}
+export interface SessionArtifactIndex {
+    /** Frame IDs in chronological order */
+    frameRefs: string[];
+    /** Event IDs in chronological order */
+    eventRefs: string[];
+    /** Event IDs where type is NETWORK_REQUEST_* */
+    networkRefs: string[];
+    /** Event IDs where type is LOG_EMITTED */
+    logRefs: string[];
+    /** Crash/error anchors with nearby context */
+    crashAnchors: CrashAnchor[];
+    /** Future: artifact upload references for remote dashboard */
+    uploadRefs?: string[];
+}
+/** When to capture frames */
+export type CaptureMode = 'navigation' | 'interactions' | 'frequency';
+/** Frame quality presets — maps to native JPEG compression */
+export type ReplayQuality = 'high' | 'normal' | 'low' | 'grayscale';
+/** Quality preset → concrete capture parameters (used by native engines) */
+export declare const QUALITY_PRESETS: Record<ReplayQuality, {
+    maxWidth: number;
+    jpegQuality: number;
+}>;
+export interface PrivacyPolicy {
+    redactTextInputs: boolean;
+    redactImages: boolean;
+    /** TestIDs to completely exclude from capture */
+    blockTestIds: string[];
+    /** Screen names to exclude from replay capture */
+    captureExclusions: string[];
+}
+export interface SessionReplayConfig {
+    captureMode: CaptureMode;
+    quality: ReplayQuality;
+    /** Used with 'frequency' mode. Minimum 500ms. */
+    intervalMs: number;
+    includeNetworkLogs: boolean;
+    includeSdkLogs: boolean;
+    includeUserSteps: boolean;
+    /** Max frames before dropping old (prefers keeping crash-adjacent) */
+    maxFrames: number;
+    /** Max events before dropping old (prefers keeping crash-adjacent) */
+    maxEventCount: number;
+    /** Auto-end session after this duration */
+    maxDurationMs: number;
+    privacyPolicy: PrivacyPolicy;
+    /** P2-1: suppress visually-unchanged consecutive frames. Default true. */
+    changeDetection?: boolean;
+    /** P2-1: 0 = exact-hash match; >0 = perceptual distance threshold (native). Default 0. */
+    changeSensitivity?: number;
+    /** P2-1 heartbeat: force a keyframe even if unchanged after this many ms, so static
+     *  periods still have a frame AND deltas always have a fresh base. Default 5000. */
+    maxKeyframeIntervalMs?: number;
+    /** P2-2: native encode preference order; first that succeeds on-device wins. */
+    frameFormatPreference?: Array<'avif' | 'webp' | 'jpeg'>;
+    /** P2-2: lossy encoder quality 0..100. Default 55. */
+    frameQuality?: number;
+    /** P2-5: emit deltas between keyframes. Default false (keyframe-only when off). */
+    deltaEncoding?: boolean;
+    /** P2-5: force a keyframe every N frames so a dropped base strands < N-1 deltas. Default 10. */
+    deltaKeyframeInterval?: number;
+    /** `interactions` mode: sample the screen briefly after each semantic frame, uploading only
+     *  samples whose pixels changed, so motion between taps is not lost. Needs changeDetection.
+     *  See ACTIVITY_SAMPLE_INTERVAL_MS in ReplayCaptureManager. Default true. */
+    activitySampling?: boolean;
+}
+export declare const DEFAULT_SESSION_REPLAY_CONFIG: SessionReplayConfig;
+export type TransportState = 'local' | 'pending-sync' | 'syncing' | 'synced' | 'failed';
+/**
+ * SessionTransport abstraction.
+ * DesktopSessionTransport implements this now.
+ * RemoteDashboardSessionTransport will implement this later.
+ * Core session logic never knows transport details.
+ */
+export interface SessionTransport {
+    sendSessionStart(session: Session): void;
+    sendSessionEnd(session: Session): void;
+    sendEvent(event: JourneyEvent): void;
+    /**
+     * Send a replay frame. The transport is responsible for resolving
+     * imageRef → actual content (base64, URL, etc.) at the transport boundary.
+     * @param frame - frame metadata (imageRef is artifact reference)
+     * @param imageData - raw image data (base64) for transport serialization
+     */
+    sendFrame(frame: ReplayFrame, imageData: string): void;
+}
+export type SyncState = 'eligible' | 'ineligible' | 'pending-evaluation' | 'opted-out';
+/**
+ * Metadata gathered by NATIVE layer, passed to SDK for sync decision.
+ * Native only gathers; SDK's SyncDecisionEngine owns the eligibility policy.
+ */
+export interface NativeSyncMetadata {
+    deviceModel: string;
+    osVersion: string;
+    batteryLevel?: number;
+    batteryCharging?: boolean;
+    networkType?: 'wifi' | 'cellular' | 'ethernet' | 'none' | 'unknown';
+    isMeteredNetwork?: boolean;
+    availableMemoryMb?: number;
+    thermalState?: 'nominal' | 'fair' | 'serious' | 'critical';
+}
+/**
+ * Candidate presented to SyncDecisionEngine for eligibility evaluation.
+ */
+export interface SyncCandidate {
+    sessionId: string;
+    metadata: SessionMetadata;
+    nativeMetadata?: NativeSyncMetadata;
+    eventCount: number;
+    frameCount: number;
+    durationMs: number;
+    hasCrash: boolean;
+    hasError: boolean;
+}
+export interface SyncDecision {
+    shouldSync: boolean;
+    reason: string;
+    priority: 'high' | 'normal' | 'low';
+}
+/**
+ * Callback type for custom sync eligibility evaluation.
+ * The SDK provides a default implementation; host apps can override.
+ */
+export type SyncDecisionCallback = (candidate: SyncCandidate) => SyncDecision;
+/**
+ * Result returned by native capture engine.
+ * base64 is transient — used at the transport boundary, NOT stored in domain as imageRef.
+ */
+export interface NativeFrameResult {
+    base64: string;
+    width: number;
+    height: number;
+    /** Byte size of the compressed image */
+    byteSize: number;
+    /** Platform that performed the capture */
+    platform: PlatformOS;
+    /** Actual on-device encoding after the AVIF->WebP->JPEG fallback (P2-2). */
+    format?: string;
+    /** Optional native frame hash for change detection (P2-1). JS falls back to hashing base64. */
+    frameHash?: string;
+    /** Sanitized visible scroll containers at capture time; undefined = not measured. */
+    scrollState?: FrameScrollEntry[];
+}
+/**
+ * Native device/session metadata result.
+ */
+export interface NativeDeviceMetadata {
+    deviceModel: string;
+    osVersion: string;
+    screenWidth: number;
+    screenHeight: number;
+    platform: 'android' | 'ios';
+    appName?: string;
+    appVersion?: string;
+    bundleId?: string;
+    buildType?: 'debug' | 'release';
+}
+/**
+ * Priority levels for frame retention when buffer is full.
+ * Higher priority frames are kept longer.
+ *
+ * CRASH_ADJACENT and ERROR_CONTEXT frames are NEVER dropped before
+ * generic NAVIGATION/INTERACTION/FREQUENCY frames.
+ */
+export declare enum FrameRetentionPriority {
+    /** Lowest: regular periodic captures */
+    FREQUENCY = 0,
+    /** Low: regular navigation frames */
+    NAVIGATION = 1,
+    /** Medium: interaction-triggered frames */
+    INTERACTION = 2,
+    /** Medium-high: manually triggered captures */
+    MANUAL = 3,
+    /** High: captured in response to an error event */
+    ERROR_CONTEXT = 4,
+    /** Highest: adjacent to a crash event — never drop before others */
+    CRASH_ADJACENT = 5
+}
+/** Map CaptureReason → retention priority */
+export declare function getFrameRetentionPriority(reason: CaptureReason): FrameRetentionPriority;
+export declare const SESSION_EVENTS: {
+    readonly SESSION_START: "session:start";
+    readonly SESSION_END: "session:end";
+    readonly EVENT: "session:event";
+    readonly FRAME: "session:frame";
+};
+/**
+ * Priority levels for event retention when buffer is full.
+ * Crash/error events are NEVER dropped before generic events.
+ */
+export declare enum EventRetentionPriority {
+    LOG = 0,
+    NETWORK = 1,
+    LIFECYCLE = 2,
+    SCREEN_VIEW = 3,
+    USER_ACTION = 4,
+    ERROR = 5,
+    CRASH = 6
+}
+/** Map JourneyEventType → retention priority */
+export declare function getEventRetentionPriority(type: JourneyEventType): EventRetentionPriority;
+export type { Session as ContractSession, SessionMetadata as ContractSessionMetadata, SessionStatus as ContractSessionStatus, JourneyEvent as ContractJourneyEvent, JourneyEventType as ContractJourneyEventType, ReplayFrame as ContractReplayFrame, CaptureReason as ContractCaptureReason, SessionReplayConfig as ContractSessionReplayConfig, SessionTransport as ContractSessionTransport, SyncCandidate as ContractSyncCandidate, SyncDecision as ContractSyncDecision, NativeFrameResult as ContractNativeFrameResult, NativeDeviceMetadata as ContractNativeDeviceMetadata, } from '../../vendor/sdk-contracts';
+//# sourceMappingURL=sessionTypes.d.ts.map

package/lib/typescript/features/session/viewportPlausibility.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Is the viewport the platform just reported actually believable?
+ *
+ * WHY THIS EXISTS
+ * ───────────────
+ * The native layer reports the content view's size and the SDK trusts it unconditionally: in
+ * `SessionManager._normalizeInteractionPayload`, a payload tagged `confidence: 'high'` short-circuits
+ * every other source and is cached as the normalization base for the rest of the session. One device
+ * in production reports a size that cannot be true, and nothing noticed.
+ *
+ * Measured on production 2026-09-20, across 56 device models:
+ *
+ *   device                    viewportWidth(px)   windowWidth(dp)   implied density
+ *   OPPO CPH2821                      720               360.0             2.000  ok
+ *   Xiaomi 23129RAA4G                1080               392.7             2.750  ok
+ *   samsung SM-M526BR                1080               411.4             2.625  ok
+ *   HUAWEI INE-LX1                   1080               360.0             3.000  ok
+ *   HONOR DNY-NX9                    1264               361.1             3.500  ok
+ *   every iPhone                  390..440          390..440             1.000  ok  (pt space)
+ *   OnePlus OnePlus8Pro               288               434.7             0.663  IMPLAUSIBLE
+ *
+ * 55 of 56 pass, one fails, and the failure is the device whose replays render as an impossibly
+ * tall, narrow phone. Its `windowWidth` of 434.7dp is *correct* for a 1440px screen (1440/434.7 =
+ * 3.3125) — it is `viewportWidth` that is wrong, by a factor of five.
+ *
+ * WHY THIS TEST AND NOT A DEVICE LIST
+ * ───────────────────────────────────
+ * The SDK already sends two INDEPENDENTLY SOURCED measurements of the same screen: the native
+ * content view (physical px on Android, points on iOS) and the JS layout width from
+ * `Dimensions.get('window')` (density-independent). Converted into a common unit they must agree.
+ * That is a self-consistency check, so it holds on hardware nobody here has ever seen — which is the
+ * whole point. A model allowlist would have to be updated for the next OnePlus, and would not exist
+ * until after that device had already shipped bad data for a week.
+ *
+ * WHY NOT ASPECT RATIO, the obvious alternative: it does not separate. The OnePlus sits at 0.643 and
+ * a legitimate Android emulator in the same fleet sits at 0.629. Aspect is kept below only as a
+ * SECONDARY guard against a corrupted height, never as the primary signal.
+ *
+ * Pure and dependency-free on purpose: the backend holds a byte-identical copy so ingest can reach
+ * the same verdict as capture, and `geometry:parity` asserts the two have not drifted.
+ */
+export interface ViewportSample {
+    /** Native content view width — physical px on Android, points on iOS. */
+    viewportWidth?: number | null;
+    viewportHeight?: number | null;
+    /** JS layout width from `Dimensions.get('window')`, in density-independent units. */
+    windowWidth?: number | null;
+    /** Which unit `viewportWidth` is in; the SDK tags every payload with it. */
+    coordinateSpace?: string | null;
+    /** `PixelRatio.get()` when the caller knows it. Absent → the looser range test is used. */
+    density?: number | null;
+}
+export type ViewportVerdict = 'ok' | 'implausible' | 'unverified';
+export interface ViewportCheck {
+    verdict: ViewportVerdict;
+    /** viewportWidth / windowWidth — what the device implies its density is. Null when uncheckable. */
+    impliedDensity: number | null;
+    /** What it should have been: `PixelRatio.get()`, or 1 in point-space. Null when unknown. */
+    expectedDensity: number | null;
+    /** Short machine-readable cause, for logs and for the ingest flag. Null when ok. */
+    reason: string | null;
+}
+/**
+ * Judge a reported viewport.
+ *
+ * `unverified` is a THIRD state on purpose and never collapses into `ok`. A payload from an older
+ * SDK build carries no `windowWidth`, so the invariant cannot be evaluated at all — recording that
+ * as "checked and fine" would be the same defect as rendering a missing measurement as zero. The
+ * caller decides what to do with an unverifiable sample; it must not be told a lie about it.
+ */
+export declare function checkViewport(sample: ViewportSample): ViewportCheck;
+//# sourceMappingURL=viewportPlausibility.d.ts.map

package/lib/typescript/features/skan/skanBridge.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Wraps the ScaleBunSkan native module (iOS only — SKAdNetwork is an Apple framework).
+ * Bridges JS conversion-value updates to StoreKit's
+ * `SKAdNetwork.updatePostbackConversionValue(_:coarseValue:lockWindow:)`.
+ *
+ * Every call is a no-op when the native module is unavailable (Android, Expo Go,
+ * JS-only environments, or iOS < 11.3), mirroring nativeCrashBridge — the SDK never
+ * throws from a missing SKAN module.
+ */
+export type SkanCoarseValue = 'low' | 'medium' | 'high';
+/** True when the native SKAN module is present (iOS dev/prod build). */
+export declare function isSkanAvailable(): boolean;
+/**
+ * Update the SKAdNetwork fine conversion value (0–63), optionally with a SKAN 4.0
+ * coarse value and a window-lock. Resolves to true if the native call was made.
+ */
+export declare function updateSkanConversionValue(value: number, coarseValue?: SkanCoarseValue, lockWindow?: boolean): Promise<boolean>;
+//# sourceMappingURL=skanBridge.d.ts.map

package/lib/typescript/features/skan/skanConversionManager.d.ts

@@ -0,0 +1,69 @@
+import { StorageBackend } from '../../storage/StorageBackend';
+import { type SkanCoarseValue } from './skanBridge';
+/**
+ * Auto-applies SKAdNetwork conversion values from the server-side CV schema.
+ *
+ * The dashboard defines a schema — a list of rules mapping a funnel event name to a
+ * fine conversion value (0–63), optional SKAN 4.0 coarse value, an optional revenue
+ * gate, and an optional window-lock. The SDK fetches that schema once on init and,
+ * as events fire, applies the HIGHEST matching rule via StoreKit — so the app
+ * developer never computes conversion values by hand.
+ *
+ * Design guarantees:
+ *  - iOS only. Every method is a no-op on Android / Expo Go / JS-only (mirrors skanBridge).
+ *  - Monotonic. Apple requires an increasing fine value within a measurement window,
+ *    so a rule is applied only when its value exceeds the last applied value.
+ *  - Locked-window aware. Once a rule with `lockWindow` fires, no further updates.
+ *  - Durable. The applied value + lock survive relaunch (SKAN spans days), persisted
+ *    via the SDK's own StorageBackend.
+ *  - No-throw. Never crashes the host app; failures are logged at debug level.
+ */
+export interface SkanCvRule {
+    /** Fine conversion value 0–63. */
+    value: number;
+    /** SKAN 4.0 coarse bucket. */
+    coarse?: SkanCoarseValue;
+    /** Funnel event name this rule matches (e.g. 'first_open' | 'signup' | 'purchase'). */
+    event: string;
+    /** Optional revenue gate — rule only matches when event revenue ≥ this. */
+    minRevenue?: number;
+    /** Lock the measurement window after applying this rule. */
+    lockWindow?: boolean;
+}
+export interface SkanConversionManagerOptions {
+    apiBaseUrl: string;
+    clientKey: string;
+    storage?: Pick<StorageBackend, 'get' | 'set'>;
+    isAvailable?: () => boolean;
+    applyConversionValue?: (value: number, coarse?: SkanCoarseValue, lockWindow?: boolean) => Promise<boolean>;
+    fetchImpl?: typeof fetch;
+}
+export declare class SkanConversionManager {
+    private readonly apiBaseUrl;
+    private readonly clientKey;
+    private readonly storage;
+    private readonly available;
+    private readonly applyCv;
+    private readonly fetchImpl;
+    private schema;
+    private enabled;
+    private currentValue;
+    private locked;
+    constructor(opts: SkanConversionManagerOptions);
+    /** Restore persisted CV state + last-known schema (survives relaunch). */
+    private hydrate;
+    /**
+     * Fetch the active CV schema for this app (client-key auth). No-op on non-iOS.
+     * Safe to call fire-and-forget; failures leave any cached schema in place.
+     */
+    refreshSchema(): Promise<void>;
+    /**
+     * Feed a tracked event. Applies the highest matching rule if it raises the fine
+     * value and the window isn't locked. `revenue` gates rules with `minRevenue`.
+     */
+    onEvent(eventName: string, revenue?: number): void;
+    /** Highest-value rule matching the event name and revenue gate, or null. */
+    private pickRule;
+    private persist;
+}
+//# sourceMappingURL=skanConversionManager.d.ts.map

package/lib/typescript/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * ScaleBun SDK — Public Entry Point
+ *
+ * This is the ONLY file consumers should import from.
+ * All exports here constitute the official public API surface.
+ *
+ * Internal modules (replay, debug protocol, transport, etc.)
+ * are NOT exported — they are implementation details.
+ *
+ * @packageDocumentation
+ */
+export { default } from './public/ScaleBunFacade';
+export { ScaleBunProvider } from './public/ScaleBunProvider';
+/**
+ * Render-error boundary. Named and shaped to match `@scalebun/web-react`'s export so the same code
+ * works on both platforms — see the note in ScaleBunErrorBoundary.tsx for why a host boundary
+ * without this silently swallowed every React render error.
+ */
+export { ScaleBunErrorBoundary, type ScaleBunErrorBoundaryProps } from './public/ScaleBunErrorBoundary';
+export { ScaleBunDebugRoot, ScaleBunScreen, useScaleBunScreen } from './features/journey/ScaleBunDebugRoot';
+export { ScaleBunScrollView } from './features/journey/ScaleBunScrollView';
+export { ScaleBunFlatList } from './features/journey/ScaleBunFlatList';
+export { ScaleBunSectionList } from './features/journey/ScaleBunSectionList';
+/** Opt-in impression tracking — the mobile counterpart to web's `[data-scalebun-track-impression]`. */
+export { ScaleBunImpression } from './features/journey/ScaleBunImpression';
+export type { ScaleBunImpressionProps } from './features/journey/ScaleBunImpression';
+export { EngagePromptProvider, useEngagePrompt, } from './features/engage/EngagePromptProvider';
+export { EngageAnchorProvider, ScaleBunAnchor, useScaleBunAnchor, } from './features/engage/EngageAnchor';
+export { captureException, captureMessage } from './features/crash/capture';
+export type { RevenueInput, RevenueType, NormalizedRevenue } from './analytics/revenue';
+export type { SubscriptionInput, SubscriptionPlan, SubscriptionStatus } from './analytics/subscription';
+export type { EventTrackerStats } from './analytics/EventTracker';
+export { otaOrchestrator, OtaOrchestrator } from './features/ota/OtaOrchestrator';
+export type { SyncResult, BootGuardConfig } from './features/ota/OtaOrchestrator';
+export { useOtaUpdate } from './features/ota/useOtaUpdate';
+export type { UseOtaUpdateOptions, UseOtaUpdateReturn } from './features/ota/useOtaUpdate';
+export type { OtaCheckResponse, OtaBundlePayload } from './features/ota/OtaTypes';
+export { otaEventEmitter } from './features/ota/OtaEventEmitter';
+export type { OtaEvent, OtaEventType, OtaEventListener } from './features/ota/OtaEventEmitter';
+export { ScaleBunInlineSlot } from './features/engage/EngageInlinePlacement';
+export { EngagePromptView, PROMPT_RENDERERS, resolvePromptRenderer, } from './features/engage/EngagePromptView';
+export { EngageInAppView, INAPP_RENDERERS, resolveInAppRenderer, resolveInAppLayout, } from './features/engage/EngageInAppView';
+export { EngageThrottleStore, isCampaignEligible, isInAppEligible, selectCampaignToRender, selectInAppToRender, selectInAppVariant, } from './features/engage/engageThrottle';
+export { _getTransport as getDebugTransport, getPerformanceFeature, getProfilerFeature } from './debug/bootstrap';
+export type { ScaleBunInitConfig, ScaleBunUser, ScaleBunFeatures } from './public/types';
+export type { ScaleBunProviderProps } from './public/ScaleBunProvider';
+export type { SimplifiedInitConfig, DebugConnectionConfig, PrivacyConfig, BrandingConfig, ExportPresetName, SimplifiedExportOptions, ExportResult, } from './public/types';
+export type { DebugConfig } from './debug/bootstrap';
+export type { EngageConfigResponse, CoachConfigResponse, CoachTourConfig, CoachTourStep, EngageConfigContext, EngageCampaignConfig, EngageCampaignType, InAppMessageConfig, InAppRenderSpec, InAppRenderAssets, InAppRenderExt, InAppMediaSize, InAppOutcomeIcon, InAppOutcomeActionType, InAppOutcomeAction, InAppOutcomeConfig, InAppCta, InAppCoachmarkStep, InAppCoachmarkPlacement, InAppExperiment, InAppVariantId, InAppGameVariantKey, InAppGameAction, InAppGameRequest, InAppGameOutcome, InAppGameResult, InAppGameRequestHandler, QuestionSpec, Targeting, Throttle, EngageResponseInput, EngageEventInput, DeviceTokenInput, SurveyAnswer, } from './features/engage/engageTypes';
+export type { EngagePromptProviderProps, EngagePromptController, EngageRendererFacade, EngageRatingRouting, ShowEngagePromptOptions, ShowInAppMessageOptions, InAppDeepLinkHandler, } from './features/engage/EngagePromptProvider';
+export type { EngageAnchorHandle, EngageAnchorRect, ScaleBunAnchorProps, } from './features/engage/EngageAnchor';
+export type { ScaleBunInlineSlotProps } from './features/engage/EngageInlinePlacement';
+export type { EngagePromptResult, PromptRenderer, PromptBranchProps, RatingPromptConfig, RatingRoute, } from './features/engage/EngagePromptView';
+export type { EngageInAppViewProps, InAppRenderer, InAppBranchProps, InAppMechanicInteraction, InAppLayout, } from './features/engage/EngageInAppView';
+export type { CampaignThrottleState } from './features/engage/engageThrottle';
+export type { PushNotification, EnablePushOptions, EnablePushResult, NotificationPermissionStatus, AndroidChannelConfig, AdapterId, } from './push/types';
+export { createTypedTracker, defineTrackingPlan } from './public/typedTracker';
+export type { TypedTracker, TypedTrackerPlan, TrackedEventMap, TrackedEventSpec, PlanPropType, PropsFor, TrackTarget, } from './public/typedTracker';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/integrations/fetch/fetchInterceptor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ScaleBun SDK — Fetch Interceptor
+ *
+ * Monkey-patches the global `fetch` to capture network events.
+ *
+ * When `captureNetworkBodies` is enabled:
+ *   - Request headers are extracted from `init.headers`.
+ *   - Response headers are extracted from `response.headers`.
+ *   - Request body is extracted synchronously from `init.body`
+ *     (strings and URLSearchParams only; FormData / streams get a placeholder).
+ *   - Response body is read via `response.clone().text()` and truncated
+ *     to `networkBodyMaxBytes`. Binary content-types are skipped.
+ *   - All headers and bodies pass through `redactNetworkEvent` when
+ *     `redactNetwork` is true.
+ *
+ * ⚠️  PRIVACY: Body capture is opt-in via `captureNetworkBodies: true`.
+ * The integrator is responsible for compliance with applicable privacy
+ * regulations (GDPR, CCPA, etc.) and their own privacy policy.
+ *
+ * Scope: JS-host (fetch) only.
+ * Native-layer capture (OkHttp / URLSession) is a separate future task.
+ */
+export interface FetchInterceptorOptions {
+    /** Capture request/response headers and bodies. Default: false */
+    captureNetworkBodies?: boolean;
+    /** Max bytes to capture per body before truncating. Default: 65536 */
+    networkBodyMaxBytes?: number;
+    /** Apply redaction pipeline to captured headers/bodies. Default: true (fail closed) */
+    redactNetwork?: boolean;
+    /**
+     * Lifecycle ping for consumers that need to know a request is IN FLIGHT, not just what it
+     * turned out to be. `onEvent` fires once, on completion; this fires twice, around the call.
+     *
+     * `end` is raised in a `finally`, so a rejected fetch closes its own start. Pairing it with
+     * the success path alone would leak one in-flight request per network failure — permanently,
+     * since nothing ever decrements it afterwards.
+     */
+    onRequestPhase?: (phase: 'start' | 'end', url: string) => void;
+}
+export declare function installFetchInterceptor(onEvent: (data: any) => void, options?: FetchInterceptorOptions): void;
+//# sourceMappingURL=fetchInterceptor.d.ts.map

package/lib/typescript/integrations/navigation/screenTracker.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=screenTracker.d.ts.map