@scalebun-release/react-native 2.5.0

package/lib/typescript/features/ota/signedDownload.d.ts

@@ -0,0 +1,81 @@
+export interface StageVerdict {
+    ok?: boolean;
+    /** Stable native failure code (OtaFailureCode), e.g. DOWNLOAD_FAILED, INVALID_SIGNATURE. */
+    code?: string;
+    /** Free text from native — logged, never sent. */
+    message?: string;
+    /**
+     * WHY a download failed, from a FIXED vocabulary (native ≥ the build that added it; absent on
+     * older binaries). Never a URL, host or exception message: presigned URLs carry signatures.
+     */
+    reason?: string;
+}
+/** The only reasons that may leave the device. Anything else is dropped. */
+export declare const DOWNLOAD_REASON: RegExp;
+/** A validated download reason, or null. */
+export declare function downloadReason(v: StageVerdict): string | null;
+/** The wire errorCode for a failed verdict: `DOWNLOAD_FAILED:http_403`, or just the code. */
+export declare function verdictErrorCode(v: StageVerdict): string;
+export type RetryDecision = 'retry' | 'refresh' | 'stop';
+export declare function retryDecision(v: StageVerdict): RetryDecision;
+/** The offered bundle as far as this needs it. */
+export interface OfferedBundle {
+    id: string;
+    releaseId?: string;
+    url: string;
+}
+export interface SignedDownloadOptions {
+    attempts: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    /** Re-check before a retry once this long has passed since the offer (URL TTL is 300 s). */
+    refreshAfterMs: number;
+    /** Give up rather than start another attempt past this total. */
+    budgetMs: number;
+}
+export declare const SIGNED_DOWNLOAD_DEFAULTS: SignedDownloadOptions;
+export interface SignedDownloadDeps<B extends OfferedBundle> {
+    /** One native verify+download+stage of `bundle`. Must resolve (a throw is mapped by the caller). */
+    attempt: (bundle: B) => Promise<StageVerdict>;
+    /** Ask the server again. Resolves to the bundle it offers now, or null for none. */
+    recheck: () => Promise<B | null>;
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+    random?: () => number;
+}
+export interface SignedDownloadResult<B> {
+    verdict: StageVerdict;
+    /** The bundle actually staged or last attempted (a refresh can replace the URL). */
+    bundle: B;
+    attempts: number;
+    /** The server stopped offering this release mid-retry: not a failure, report nothing. */
+    withdrawn: boolean;
+}
+export declare function stageSignedWithRetry<B extends OfferedBundle>(deps: SignedDownloadDeps<B>, offered: B, offeredAt: number, options?: Partial<SignedDownloadOptions>): Promise<SignedDownloadResult<B>>;
+/**
+ * Does this native build have `verifyAndStagePatch`?
+ *
+ * OTA ships JS, not native: the JS in an update runs on binaries built before the method existed.
+ * On both architectures a method missing from the native build reads as `undefined`, so this is
+ * the whole guard — never call it without asking.
+ */
+export declare function signedPatchSupported(native: unknown): boolean;
+export interface PatchOffer {
+    url: string;
+    size: number;
+    sha256: string;
+    baseBundleId: string;
+    baseSha256?: string;
+}
+/**
+ * ONE attempt to stage a signed release from its patch. Never throws, never retries: any failure
+ * means "download the full bundle" (with signedDownload's retry), which is always correct — the
+ * patch only ever saves bytes. The result is a verdict like verifyAndStageRelease's, plus
+ * `patchUsed: true` when the patch was applied.
+ */
+export declare function trySignedPatch(native: {
+    verifyAndStagePatch?: (envelopeJson: string, patchJson: string) => Promise<string>;
+} | null, envelope: unknown, url: string, patch: PatchOffer): Promise<StageVerdict & {
+    patchUsed?: boolean;
+}>;
+//# sourceMappingURL=signedDownload.d.ts.map

package/lib/typescript/features/ota/useOtaUpdate.d.ts

@@ -0,0 +1,72 @@
+import { SyncResult } from './OtaOrchestrator';
+import type { OtaBundlePayload } from './OtaTypes';
+import { OtaEvent } from './OtaEventEmitter';
+export interface UseOtaUpdateOptions {
+    apiUrl: string;
+    clientKey: string;
+    appVersion: string;
+    /**
+     * Omit to use the SDK's canonical per-install id (recommended). Supplying a
+     * different id here — the old docs suggested `deviceId` — put OTA telemetry
+     * in its own identity namespace, disconnected from every other SDK lane.
+     */
+    installationId?: string;
+    /** OTA channel to pull from. Omitted means `default`. */
+    channelName?: string;
+    /** ISO 3166-1 alpha-2. The server resolves this from the edge when absent. */
+    country?: string;
+    /** Free-form device attributes evaluated by ATTRIBUTE targeting rules. */
+    attributes?: Record<string, string | number>;
+    /** CDP segment ids this installation belongs to. */
+    segmentIds?: string[];
+    /** Lifecycle stage evaluated by LIFECYCLE_STAGE targeting rules. */
+    lifecycleStage?: string;
+    autoRestart?: boolean;
+    /**
+     * When true and the server says `isMandatory`, the hook sets
+     * `mandatoryUpdatePending` to true. The app should render a
+     * blocking overlay until the update is applied + restarted.
+     */
+    mandatoryBlocksUi?: boolean;
+}
+export interface UseOtaUpdateReturn {
+    /** True while a sync operation is in progress */
+    isSyncing: boolean;
+    /** True when an update has been installed and a restart is needed */
+    isRestartRequired: boolean;
+    /** The currently active OTA bundle (after install) */
+    activeBundle: OtaBundlePayload | null;
+    /** Result of the last sync operation */
+    syncResult: SyncResult | null;
+    /** Download progress 0–100 (during active download) */
+    downloadProgress: number;
+    /** The last OTA lifecycle event received */
+    lastEvent: OtaEvent | null;
+    /** True when a mandatory update is pending and mandatoryBlocksUi is enabled */
+    mandatoryUpdatePending: boolean;
+    /** Trigger an OTA sync */
+    sync: () => Promise<SyncResult>;
+    /** Restart the app to apply the update */
+    restart: () => void;
+}
+/**
+ * React hook for OTA updates — Sprint 5 enhanced version.
+ *
+ * Provides reactive state for download progress, lifecycle events,
+ * and mandatory update blocking.
+ *
+ * ```tsx
+ * const { sync, isSyncing, downloadProgress, mandatoryUpdatePending } = useOtaUpdate({
+ *   apiUrl: 'https://api.scalebun.com/api/v1',
+ *   clientKey: 'scalebun_ck_…',
+ *   appVersion: '1.0.0',
+ *   // installationId is resolved from the SDK's own persisted install id —
+ *   // do NOT pass deviceId here (the old example did; it split OTA telemetry
+ *   // into a separate identity namespace from every other lane).
+ *   channelName: 'production',
+ *   mandatoryBlocksUi: true,
+ * });
+ * ```
+ */
+export declare function useOtaUpdate(options: UseOtaUpdateOptions): UseOtaUpdateReturn;
+//# sourceMappingURL=useOtaUpdate.d.ts.map

package/lib/typescript/features/performance/PerformanceFeature.d.ts

@@ -0,0 +1,132 @@
+/**
+ * ScaleBun SDK — Performance Feature
+ *
+ * Main orchestrator implementing IFeature.
+ * Manages the lifecycle of all performance collectors,
+ * metrics aggregation, and transport.
+ *
+ * This is the single entry point registered with the FeatureRegistry.
+ */
+import type { IFeature, FeatureContext } from '../../core/contracts/IFeature';
+import type { PerformanceConfig } from './config';
+import { type PerfTransportSink } from './transport/PerformanceTransport';
+export declare class PerformanceFeature implements IFeature {
+    readonly name = "performance";
+    private active;
+    private config;
+    private jsStallCollector;
+    private appLaunchCollector;
+    private screenLoadCollector;
+    private autoScreenLoadCollector;
+    private frameMetricsCollector;
+    private uiHangCollector;
+    private networkPerfCollector;
+    private customTraceCollector;
+    private transport;
+    private sessionId;
+    private currentScreen;
+    private deviceMeta;
+    /** Generation counter — incremented only on NEW screen navigation */
+    private _captureGen;
+    /** Timestamp of last *successful* capture send (for throttle) */
+    private _lastCaptureTs;
+    /** Map of dedupKey → timestamp of last successful delivery. Key = `screenName\x00visitId` or `screenName\x00b{1s-bucket}`. */
+    private _recentCaptures;
+    /** Active retry timer handle (cleared on navigation) */
+    private _captureTimer;
+    /** Min time between successful captures */
+    private static readonly CAPTURE_THROTTLE_MS;
+    /** Min time before re-capturing the same screen */
+    private static readonly CAPTURE_DEDUP_MS;
+    /** Max retry attempts per capture window */
+    private static readonly CAPTURE_MAX_RETRIES;
+    /** Delay schedule for each attempt (ms) — escalating to let views settle */
+    private static readonly CAPTURE_DELAYS;
+    /** Metrics captured before the backend transport was available. */
+    private _pendingBackendMetrics;
+    /** Retry timer that drains the buffer once the transport attaches. */
+    private _backendDrainTimer;
+    /** Number of drain attempts made for the current buffered batch. */
+    private _backendDrainAttempts;
+    /** Hard cap on buffered metrics — bounds memory if a transport never attaches (non-SaaS). */
+    private static readonly BACKEND_BUFFER_MAX;
+    /** Max drain retries before giving up (non-SaaS mode never attaches a transport). */
+    private static readonly BACKEND_DRAIN_MAX_ATTEMPTS;
+    /** Escalating retry delays (ms); last value repeats. Covers the startup attach race. */
+    private static readonly BACKEND_DRAIN_DELAYS;
+    constructor(config?: Partial<PerformanceConfig>);
+    initialize(context: FeatureContext): Promise<void>;
+    /** Activate native performance module once (no-throw if unavailable). */
+    private _initializeNative;
+    /**
+     * Deterministic per-session Tier-2 sampling decision.
+     * Same sessionId always yields the same result (no mid-session flip).
+     * Falls back to RNG only when no sessionId is available yet.
+     */
+    private _shouldSampleTier2;
+    /** Start ONLY the Tier-2 sampled collectors (uiHang is a Tier-1 watchdog, not started here). */
+    startSampledCollection(): void;
+    /** Start continuous collectors on-demand */
+    startContinuousCollection(): void;
+    /** Stop continuous collectors */
+    stopContinuousCollection(): void;
+    teardown(): void;
+    get isActive(): boolean;
+    /** Connect the debug transport for sending metrics to desktop */
+    setTransportSink(sink: PerfTransportSink | null): void;
+    setSessionId(sessionId: string): void;
+    setCurrentScreen(screenName: string): void;
+    private _triggerAutoCapture;
+    /**
+     * Schedules a single capture attempt within the bounded retry window.
+     * On failure, schedules the next retry up to CAPTURE_MAX_RETRIES.
+     */
+    private _scheduleCaptureAttempt;
+    private _executeAutoCapture;
+    /**
+     * Called from the app's NavigationContainer onStateChange.
+     * Routes to AutoScreenLoadCollector for automatic timing.
+     */
+    onNavigationStateChange(state: unknown): void;
+    /**
+     * Called from AutoScreenDetector's screen-change emission (navRef/heuristic).
+     * Reuses the detector's already-resolved screen name to time screen loads in
+     * SaaS — avoids attaching a second navigation listener on the app's nav ref.
+     */
+    onScreenChange(screenName: string): void;
+    markScreenLoadStart(screenName: string): void;
+    markScreenLoadEnd(screenName: string): void;
+    startTrace(name: string): string | null;
+    stopTrace(traceId: string): void;
+    addTraceSpan(traceId: string, name: string, durationMs: number, data?: Record<string, unknown>): void;
+    addTraceMeasurement(traceId: string, name: string, value: number, unit: string): void;
+    /**
+     * Send a raw performance metric through the transport.
+     * Used by demo/debug screens to inject simulated metrics
+     * through the same proven pipeline that PerfMonitor uses.
+     */
+    sendMetric(name: string, value: number, unit?: string, tags?: Record<string, string>): void;
+    /** Called by the SDK when a $network_request event occurs */
+    processNetworkEvent(data: Record<string, unknown>): void;
+    private _handleEvent;
+    /** Map a raw perf event onto the backend metric envelope. */
+    private _toBackendMetric;
+    /**
+     * Hand a metric to the backend transport, or buffer it until one attaches.
+     * Every call first drains anything buffered, so a late-arriving transport
+     * flushes the backlog in the order the metrics were produced.
+     */
+    private _forwardMetricToBackend;
+    /** Flush all buffered metrics into the transport, preserving order. */
+    private _drainPendingBackendMetrics;
+    /**
+     * Poll for the backend transport a bounded number of times so the sole
+     * early metric (app_launch) still reaches the cloud even when no later
+     * event arrives to trigger a drain. Gives up after BACKEND_DRAIN_MAX_ATTEMPTS
+     * (non-SaaS mode never attaches a transport — the desktop path already has
+     * the data), leaving the bounded buffer to be GC'd on teardown.
+     */
+    private _scheduleBackendDrain;
+    private _clearBackendDrainTimer;
+}
+//# sourceMappingURL=PerformanceFeature.d.ts.map

package/lib/typescript/features/performance/collectors/AppLaunchCollector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ScaleBun SDK — App Launch Collector
+ *
+ * Orchestrates native bridge calls to get cold/warm start timing.
+ * The actual timing is captured by native platform modules.
+ * This collector requests it and emits an AppLaunchEvent.
+ *
+ * Enhanced: adds jsReadyMs (proxy for JS runtime readiness)
+ * and phaseLabels indicating measured vs inferred per phase.
+ */
+import type { AppLaunchEvent, PerfContext } from '../models';
+import type { PerformanceConfig } from '../config';
+export type LaunchEventCallback = (event: AppLaunchEvent) => void;
+export declare class AppLaunchCollector {
+    private config;
+    private onLaunch;
+    private contextProvider;
+    private collected;
+    constructor(config: PerformanceConfig, onLaunch: LaunchEventCallback, contextProvider: () => PerfContext);
+    /**
+     * Collect app launch timing from native module.
+     * Should be called once during initialization.
+     * Safe to call multiple times (idempotent).
+     */
+    collect(): Promise<void>;
+}
+//# sourceMappingURL=AppLaunchCollector.d.ts.map

package/lib/typescript/features/performance/collectors/AutoScreenLoadCollector.d.ts

@@ -0,0 +1,70 @@
+/**
+ * ScaleBun SDK — Auto Screen Load Collector
+ *
+ * Automatically detects screen transitions and measures load times.
+ *
+ * Priority chain:
+ *   1. React Navigation state listener (default)
+ *   2. AppState fallback (background → active)
+ *   3. Disabled (config.screenLoad === false)
+ *
+ * Manual markers via ScreenLoadCollector take precedence for the same screen.
+ */
+import type { PerformanceConfig } from '../config';
+import type { ScreenLoadEvent, PerfContext } from '../models';
+export type ScreenLoadCallback = (event: ScreenLoadEvent) => void;
+export declare class AutoScreenLoadCollector {
+    private config;
+    private onScreenLoad;
+    private contextProvider;
+    private installed;
+    private currentScreen;
+    private pending;
+    private appStateSubscription;
+    private navigationDetected;
+    private fallbackTimer;
+    private manualOverrides;
+    constructor(config: PerformanceConfig, onScreenLoad: ScreenLoadCallback, contextProvider: () => PerfContext);
+    /**
+     * Install auto screen load detection.
+     * Called from PerformanceFeature.initialize().
+     */
+    install(): void;
+    /**
+     * Called when React Navigation state changes.
+     * This should be wired from the app's NavigationContainer onStateChange.
+     */
+    onNavigationStateChange(state: unknown): void;
+    /**
+     * Called when AutoScreenDetector reports a settled screen (navRef/heuristic).
+     * The detector emits a resolved screen NAME (not a navigation state), so this
+     * path skips route extraction and times the transition the same way as
+     * onNavigationStateChange. Used in SaaS to avoid a second nav listener.
+     */
+    onScreenDetected(screenName: string): void;
+    /** Start timing a screen transition and emit screen_load once it settles. */
+    private _beginTransition;
+    /**
+     * Register a manual override for a screen name.
+     * When a manual marker is active, auto-detection for that screen is skipped.
+     */
+    registerManualOverride(screenName: string): void;
+    /**
+     * Clear a manual override after manual end marker fires.
+     */
+    clearManualOverride(screenName: string): void;
+    /**
+     * Get the current detected screen name.
+     */
+    getCurrentScreen(): string;
+    stop(): void;
+    private _installAppStateFallback;
+    private _emitScreenLoad;
+    private _cancelPending;
+    /**
+     * Extract the active route name from React Navigation state.
+     * Walks the state tree to find the deepest focused route.
+     */
+    private _extractActiveRoute;
+}
+//# sourceMappingURL=AutoScreenLoadCollector.d.ts.map

package/lib/typescript/features/performance/collectors/CustomTraceCollector.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ScaleBun SDK — Custom Trace Collector
+ *
+ * Developer-defined traces and spans for measuring custom flows.
+ * Provides a start/stop API for traces with optional child spans.
+ */
+import type { CustomTraceEvent, PerfContext } from '../models';
+import type { PerformanceConfig } from '../config';
+export type CustomTraceCallback = (event: CustomTraceEvent) => void;
+export declare class CustomTraceCollector {
+    private config;
+    private onTrace;
+    private contextProvider;
+    private activeTraces;
+    constructor(config: PerformanceConfig, onTrace: CustomTraceCallback, contextProvider: () => PerfContext);
+    /**
+     * Start a named trace. Returns the trace ID for later stop/span calls.
+     */
+    startTrace(name: string): string | null;
+    /**
+     * Stop a trace and emit the completed trace event.
+     */
+    stopTrace(traceId: string): void;
+    /**
+     * Add a span to an active trace.
+     */
+    addSpan(traceId: string, spanName: string, durationMs: number, data?: Record<string, unknown>): void;
+    /**
+     * Attach a measurement to an active trace.
+     */
+    addMeasurement(traceId: string, name: string, value: number, unit: string): void;
+    /** Abandon all active traces on teardown */
+    reset(): void;
+}
+//# sourceMappingURL=CustomTraceCollector.d.ts.map

package/lib/typescript/features/performance/collectors/FrameMetricsCollector.d.ts

@@ -0,0 +1,74 @@
+/**
+ * ScaleBun SDK — Frame Metrics Collector
+ *
+ * Receives native frame metrics via bridge events and translates
+ * them into FrameMetricsEvent. The actual frame capture happens
+ * in native code (FrameMetrics API on Android, CADisplayLink on iOS).
+ *
+ * This collector:
+ * - Listens for native frame metric snapshots
+ * - Aggregates per-window frame quality
+ * - Emits FrameMetricsEvent for transport
+ */
+import type { FrameMetricsEvent, PerfContext } from '../models';
+import type { PerformanceConfig } from '../config';
+export type FrameMetricsCallback = (event: FrameMetricsEvent) => void;
+export declare class FrameMetricsCollector {
+    private config;
+    private onFrameMetrics;
+    private contextProvider;
+    private eventSubscription;
+    private running;
+    /** AppState subscription — see `_installAppStateGate`. */
+    private appStateSubscription;
+    /** True while the native sampler is actually running (i.e. armed AND foregrounded). */
+    private sampling;
+    /** Timestamp of the last emitted window — drives the healthy-window heartbeat below. */
+    private lastEmitTs;
+    /**
+     * HEALTHY windows emit at a heartbeat, not per report interval.
+     *
+     * The native sampler reports every `reportIntervalMs` (5 s), and every window became a stored
+     * row — on a session hours long that is 720 rows/hour of "still 60 fps", which is how real
+     * sessions hit the dashboard's 2,000-row display cap with nothing to say. A window that shows
+     * ANY jank (dropped/frozen frames, meaningful slow-frame count, an FPS dip) always emits; a
+     * healthy window emits only when the heartbeat has elapsed, keeping the FPS series alive for
+     * the charts at 1/12th the volume. Capture cadence is unchanged — only identical-looking
+     * healthy rows are elided, and the first window after ANY emit gap states the recovery.
+     */
+    private static readonly HEALTHY_HEARTBEAT_MS;
+    constructor(config: PerformanceConfig, onFrameMetrics: FrameMetricsCallback, contextProvider: () => PerfContext);
+    start(): void;
+    /**
+     * Pause sampling while the app is backgrounded.
+     *
+     * THE BUG THIS FIXES. `startFrameMetrics` hands off to a native loop that runs until something
+     * calls `stopFrameMetrics`. Nothing did. The collector had no AppState awareness at all — unlike
+     * `AutoScreenLoadCollector`, which has subscribed to it since it was written — so once a session
+     * was sampled in, it kept sampling for as long as the PROCESS lived, not as long as the app was
+     * being used.
+     *
+     * Measured in production: sessions with `durationMs` of 86,400,000 (exactly 24h) and 70,797,000
+     * (~19.7h) carrying 39,766 and 3,709 frame samples against 0 and 6 real gestures respectively.
+     * `frame_metrics` was 75% of ALL mobile events for this reason.
+     *
+     * The `tier2SampleRate` knob does not help here: it gates WHICH sessions collect, not how long
+     * they collect for. A sampled-in session that gets backgrounded still samples for hours, which is
+     * why lowering it would have hidden the symptom while leaving the cause.
+     *
+     * It is also a DATA-QUALITY fix, not only a volume one. Frame timings from a backgrounded app
+     * describe a screen nobody is looking at, and they were feeding the low-FPS KPI and jank
+     * detection — so the noise was not merely stored, it was being reported as UI performance.
+     *
+     * NOTE: on iOS the OS already stops delivering CADisplayLink callbacks on background, so the
+     * practical effect is largest on Android. Gating in JS keeps the two platforms behaving the same
+     * either way, rather than relying on an OS side effect that is not part of any contract.
+     */
+    private _installAppStateGate;
+    /** Idempotent — AppState can fire 'active' more than once without an intervening background. */
+    private _startNativeSampler;
+    private _stopNativeSampler;
+    stop(): void;
+    private _handleNativeFrameMetrics;
+}
+//# sourceMappingURL=FrameMetricsCollector.d.ts.map

package/lib/typescript/features/performance/collectors/JsStallCollector.d.ts

@@ -0,0 +1,45 @@
+/**
+ * ScaleBun SDK — JS Stall Collector
+ *
+ * Detects event-loop stalls using setInterval drift detection.
+ * Migrated from debug/perf.ts and enhanced with severity bucketing,
+ * bounded memory, and proper lifecycle management.
+ *
+ * Approach:
+ *   1. Run a 16ms interval timer (one frame budget at ~60fps)
+ *   2. Measure actual elapsed time vs expected
+ *   3. If drift > threshold → record a stall event
+ *   4. Accumulate aggregated summary for periodic reporting
+ */
+import type { PerformanceConfig } from '../config';
+import type { JsStallEvent, JsStallSummary, PerfContext } from '../models';
+export type StallEventCallback = (event: JsStallEvent) => void;
+export type StallSummaryCallback = (summary: JsStallSummary & {
+    timestamp: number;
+}) => void;
+export declare class JsStallCollector {
+    private config;
+    private onStall;
+    private onSummary;
+    private contextProvider;
+    private pollTimer;
+    private reportTimer;
+    private lastTick;
+    private running;
+    private stallCount;
+    private maxStallMs;
+    private totalStallMs;
+    private recentStalls;
+    /** Per-run caps on INDIVIDUAL stall events — see the emit site. Summaries are uncapped. */
+    private static readonly EMITTED_STALLS_MAX;
+    private static readonly CRITICAL_OVERFLOW_MAX;
+    private emittedStalls;
+    private emittedCriticalOverflow;
+    constructor(config: PerformanceConfig, onStall: StallEventCallback, onSummary: StallSummaryCallback, contextProvider: () => PerfContext);
+    start(): void;
+    stop(): void;
+    private _recordStall;
+    private _classifySeverity;
+    private _flushSummary;
+}
+//# sourceMappingURL=JsStallCollector.d.ts.map

package/lib/typescript/features/performance/collectors/NetworkPerfCollector.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ScaleBun SDK — Network Performance Collector
+ *
+ * Taps into existing network events (from NetworkFeature) and extracts
+ * performance-relevant signals: slow requests, failed requests, latency.
+ * Does NOT duplicate network capture — reuses the existing pipeline.
+ */
+import type { NetworkPerfEvent, PerfContext } from '../models';
+import type { PerformanceConfig } from '../config';
+export type NetworkPerfCallback = (event: NetworkPerfEvent) => void;
+export declare class NetworkPerfCollector {
+    private config;
+    private onNetworkPerf;
+    private contextProvider;
+    constructor(config: PerformanceConfig, onNetworkPerf: NetworkPerfCallback, contextProvider: () => PerfContext);
+    /**
+     * Process a network request completion event.
+     * Called by PerformanceFeature when a $network_request event arrives.
+     * Only emits a performance event for requests that are slow or failed.
+     */
+    processNetworkEvent(data: Record<string, unknown>): void;
+}
+//# sourceMappingURL=NetworkPerfCollector.d.ts.map

package/lib/typescript/features/performance/collectors/ScreenLoadCollector.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ScaleBun SDK — Screen Load Collector
+ *
+ * Tracks screen transition timing using a start/end marker pattern.
+ * Integrates with the existing ScaleBunScreen/useScaleBunScreen navigation system.
+ */
+import type { ScreenLoadEvent, PerfContext } from '../models';
+import type { PerformanceConfig } from '../config';
+export type ScreenLoadCallback = (event: ScreenLoadEvent) => void;
+export declare class ScreenLoadCollector {
+    private config;
+    private onScreenLoad;
+    private contextProvider;
+    private pending;
+    private lastScreen;
+    constructor(config: PerformanceConfig, onScreenLoad: ScreenLoadCallback, contextProvider: () => PerfContext);
+    /**
+     * Mark the start of a screen load.
+     * Called when navigation to a new screen begins.
+     */
+    markStart(screenName: string): void;
+    /**
+     * Mark the end of a screen load.
+     * Called when the screen is rendered and interactive.
+     */
+    markEnd(screenName: string): void;
+    /** Clear all pending loads (e.g., on teardown) */
+    reset(): void;
+}
+//# sourceMappingURL=ScreenLoadCollector.d.ts.map

package/lib/typescript/features/performance/collectors/UiHangCollector.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ScaleBun SDK — UI Hang Collector
+ *
+ * Receives native UI hang detection events from the platform bridge.
+ * Android uses a background watchdog thread; iOS uses a main thread ping.
+ */
+import type { UiHangEvent, PerfContext } from '../models';
+import type { PerformanceConfig } from '../config';
+export type UiHangCallback = (event: UiHangEvent) => void;
+export declare class UiHangCollector {
+    private config;
+    private onHang;
+    private contextProvider;
+    private eventSubscription;
+    private running;
+    constructor(config: PerformanceConfig, onHang: UiHangCallback, contextProvider: () => PerfContext);
+    start(): void;
+    stop(): void;
+    private _handleNativeHang;
+}
+//# sourceMappingURL=UiHangCollector.d.ts.map