@scalebun-release/react-native 2.5.0

package/lib/typescript/core/logger/internalLogger.d.ts

@@ -0,0 +1,24 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4
+}
+/** Public, string-based log level used in SDK init config. */
+export type LogLevelName = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+declare class InternalLogger {
+    private level;
+    setLevel(level: LogLevel): void;
+    /** Set level from the public string name used in config (e.g. 'warn'). */
+    setLevelByName(name: LogLevelName): void;
+    /** Current numeric level — exposed for callers that branch on dev verbosity. */
+    getLevel(): LogLevel;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+}
+export declare const logger: InternalLogger;
+export {};
+//# sourceMappingURL=internalLogger.d.ts.map

package/lib/typescript/core/logger/levels.d.ts

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

package/lib/typescript/crypto/hmacSha256.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pure-JS HMAC-SHA256 (Phase 5.4) — no native module, so it runs identically on the
+ * Old and New RN architectures and in Node. Output matches Node's
+ * `crypto.createHmac('sha256', key).update(msg).digest('hex')` (asserted in tests).
+ *
+ * Used to sign the /batch envelope so the backend can tamper-detect the payload.
+ */
+/** HMAC-SHA256(key, message) → lowercase hex. */
+export declare function hmacSha256Hex(key: string, message: string): string;
+//# sourceMappingURL=hmacSha256.d.ts.map

package/lib/typescript/debug/bootstrap.d.ts

@@ -0,0 +1,148 @@
+/**
+ * ScaleBun Debug — Bootstrap (Orchestrator)
+ *
+ * Entry point for enabling the debug subsystem.
+ * Delegates to focused modules for each responsibility:
+ *   - hostResolver   → debug host address resolution
+ *   - replayWiring   → ReplaySdk init + native capture
+ *   - sessionWiring  → SessionManager creation
+ *   - perfWiring     → PerformanceFeature + ProfilerFeature
+ *   - screenTracking → auto screen detection + cross-cutting state
+ *   - exportBridge   → SDK→Desktop export protocol
+ *
+ * This file retained: DebugConfig type, singleton state variables,
+ * enableDebug/disableDebug orchestration, and getter functions.
+ */
+import { DebugTransport } from './transport';
+import { DebugEventStream } from './stream';
+import { CommandRegistry } from './commands';
+import { PerformanceFeature } from '../features/performance/PerformanceFeature';
+import { ProfilerFeature } from '../features/profiler/ProfilerFeature';
+import type { JourneyConfig } from '../features/journey/journeyTypes';
+import type { SessionReplayConfig } from '../features/session/sessionTypes';
+import { AutoScreenDetector } from '../features/navigation/AutoScreenDetector';
+import type { SimplifiedExportOptions, ExportResult, ExportPresetName } from '../public/types';
+import type { ReplayConfig } from '../features/replay/public/types';
+import type { SessionManager as SessionManagerType } from '../features/session/SessionManager';
+export interface DebugConfig {
+    host?: string;
+    port?: number;
+    appName?: string;
+    bundleId?: string;
+    captureConsole?: boolean;
+    captureSDKLogs?: boolean;
+    redactNetwork?: boolean;
+    enablePerf?: boolean;
+    stallThresholdMs?: number;
+    journey?: JourneyConfig;
+    session?: Partial<SessionReplayConfig>;
+    replay?: Partial<ReplayConfig>;
+    /**
+     * Shared secret for desktop authentication.
+     * If provided, included in the HelloMessage handshake.
+     * Must match the secret configured in the Desktop app.
+     * Default: null (not sent).
+     */
+    secret?: string | null;
+    /** @internal */
+    _sessionDisabled?: boolean;
+    /** @internal */
+    _performanceDisabled?: boolean;
+    enableProfiler?: boolean;
+    /**
+     * Permit the debug channel in a RELEASE build. Default false, and you
+     * almost certainly want it that way.
+     *
+     * The transport is an unencrypted `ws://` socket that carries captured
+     * console output, network traffic and the shared `secret` itself in
+     * cleartext, readable by anyone on the same Wi-Fi. That is an acceptable
+     * trade for a developer on their own machine and not acceptable in an app
+     * on a user's phone.
+     *
+     * Until now the only thing standing between those two cases was that the
+     * desktop tooling is excluded from bundles by default — a BUILD-time
+     * opt-out, not a release check. Anyone who set `devTools: true` to debug
+     * locally and shipped without reverting it published an app that opens
+     * that socket in production. This flag makes that a deliberate act rather
+     * than an oversight.
+     */
+    allowInRelease?: boolean;
+}
+/**
+ * Enable the debug subsystem. Connects to the desktop app over WebSocket
+ * and starts streaming SDK events.
+ *
+ * Safe to call multiple times — will no-op if already enabled (idempotent).
+ */
+export declare function enableDebug(config: DebugConfig): void;
+/**
+ * Disable the debug subsystem and clean up all resources.
+ */
+export declare function disableDebug(): void;
+export declare function isDebugEnabled(): boolean;
+export declare function addBreadcrumb(message: string, data?: Record<string, unknown>): void;
+export declare function ping(): void;
+/** @internal */
+export declare function _getStream(): DebugEventStream | null;
+/** @internal */
+export declare function _getCommands(): CommandRegistry | null;
+/** @internal */
+export declare function _setFlushFn(fn: () => Promise<void>): void;
+/** @internal */
+export declare function _getReplaySdk(): {
+    init(partialConfig: Partial<ReplayConfig>, opts?: import("../features/replay/public/api").ReplaySdkInitOptions): Promise<void>;
+    _getTransport(): import("../features/replay/transport/ReplayTransport").ReplayTransport | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    captureManualFrame(): Promise<void>;
+    setEnabled(enabled: boolean): Promise<void>;
+    setCapturingMode(mode: import("../features/replay/public/enums").CapturingMode): Promise<void>;
+    setScreenshotQuality(quality: import("../features/replay/public/enums").ScreenshotQuality): Promise<void>;
+    setScreenshotCaptureInterval(intervalMs: number): Promise<void>;
+    setUserStepsEnabled(enabled: boolean): Promise<void>;
+    setNetworkLogsEnabled(enabled: boolean): void;
+    setSdkLogsEnabled(enabled: boolean): void;
+    setCurrentScreen(screenName: string): Promise<void>;
+    setUser(user: import("../features/replay/public/types").ReplayUser): Promise<void>;
+    clearUser(): Promise<void>;
+    setPrivacyOptions(options: Partial<import("../features/replay/public/types").ReplayPrivacyOptions>): Promise<void>;
+    addBreadcrumb(breadcrumb: import("../features/replay/public/types").ReplayBreadcrumb): Promise<void>;
+    setSyncCallback(callback: import("../features/replay/public/types").ReplaySyncCallback | null): void;
+    flush(): Promise<void>;
+    getSessionReplayLink(): Promise<import("../features/replay/public/types").ReplayLinkResult | null>;
+    readonly isRecording: boolean;
+    readonly sessionId: string | null;
+    destroy(): Promise<void>;
+};
+/** @internal */
+export declare function _isReplaySdkInitialized(): boolean;
+/** @internal */
+export declare function _getTransport(): DebugTransport | null;
+/** @internal */
+export declare function _getJourneyConfig(): Required<JourneyConfig>;
+/** @internal */
+export declare function _isJourneyEnabled(): boolean;
+/** @internal */
+export declare function _setDebugReady(ready: boolean): void;
+/** @internal */
+/** @internal */
+export declare function _getSessionManager(): SessionManagerType | null;
+/** @internal */
+export declare function _getAutoScreenDetector(): AutoScreenDetector | null;
+export declare function getPerformanceFeature(): PerformanceFeature | null;
+export declare function getProfilerFeature(): ProfilerFeature | null;
+export { setTrackedScreen, getTrackedScreen } from './screenTracking';
+/** @internal — Emit a journey-category event to desktop */
+export declare function _emitJourneyEvent(name: string, data: Record<string, unknown>): void;
+/**
+ * Request an export from the desktop application.
+ */
+export declare function requestExport(presetOrOptions?: ExportPresetName | SimplifiedExportOptions): Promise<ExportResult>;
+/**
+ * Handle export result from desktop (called by CommandRegistry).
+ * @internal
+ */
+export declare function _handleExportResult(args: Record<string, unknown>): void;
+//# sourceMappingURL=bootstrap.d.ts.map

package/lib/typescript/debug/commands.d.ts

@@ -0,0 +1,77 @@
+/**
+ * ScaleBun Debug — Command Registry & Handlers
+ *
+ * Handles commands sent from the Desktop app to the SDK.
+ * Each command has a name and a handler function.
+ * Built-in commands: ping, setLogLevel, clearQueue, triggerFlush, addBreadcrumb, snapshot
+ * Journey commands: journeyRecordToggle, journeyCaptureStep, journeySave, journeyRun, journeyStopRun
+ */
+import { type CommandMessage } from './protocol';
+import type { DebugTransport } from './transport';
+import type { DebugEventStream } from './stream';
+type CommandHandlerFn = (args: Record<string, unknown> | undefined) => Promise<{
+    success: boolean;
+    data?: Record<string, unknown>;
+    error?: string;
+}>;
+interface IJourneyManager {
+    readonly isRecording: boolean;
+    startRecording(): void;
+    stopRecording(): void;
+    captureStep(gestureMode: string, label?: string, note?: string): Promise<{
+        success: boolean;
+        data?: Record<string, unknown>;
+        error?: string;
+    }>;
+    saveJourney(name: string, journeyId?: string): Promise<{
+        success: boolean;
+        data?: Record<string, unknown>;
+        error?: string;
+    }>;
+    runJourney(journeyData: any, options?: any): Promise<void>;
+    stopRun(): void;
+}
+interface ISessionManager {
+    readonly isActive: boolean;
+    readonly currentSessionId: string | null;
+    startSession(metadata?: Record<string, unknown>): void;
+    endSession(reason?: 'ended' | 'timeout'): void;
+    emitEvent(type: string, opts?: Record<string, unknown>): void;
+    captureManualFrame?(): Promise<any>;
+}
+export declare class CommandRegistry {
+    private handlers;
+    private transport;
+    private stream;
+    private flushFn;
+    private journeyManager;
+    private sessionManager;
+    private _journeyEnabled;
+    private _debugReady;
+    constructor(transport: DebugTransport);
+    /** Set the event stream reference (for breadcrumb command) */
+    setStream(stream: DebugEventStream): void;
+    /** Set the flush function reference */
+    setFlushFn(fn: () => Promise<void>): void;
+    /** Set the session manager reference */
+    setSessionManager(manager: ISessionManager): void;
+    /** Set the journey manager reference */
+    setJourneyManager(manager: IJourneyManager): void;
+    /** Set journey enabled flag */
+    setJourneyEnabled(enabled: boolean): void;
+    /** Set debug ready flag */
+    setDebugReady(ready: boolean): void;
+    /** Register a custom command handler */
+    register(name: string, handler: CommandHandlerFn): void;
+    /** Handle an incoming command from desktop. Never throws. */
+    handleCommand(cmd: CommandMessage): Promise<void>;
+    private _registerBuiltins;
+    /**
+     * Send a captured screenshot via transport as a session:frame event.
+     * Uses explicit 'perf-capture' source tag to distinguish from replay frames.
+     */
+    private _sendPerfScreenshot;
+    private _sendResult;
+}
+export {};
+//# sourceMappingURL=commands.d.ts.map

package/lib/typescript/debug/configBuilder.d.ts

@@ -0,0 +1,13 @@
+import type { DebugConnectionConfig, ScaleBunFeatures } from '../public/types';
+import type { DebugConfig } from './bootstrap';
+/**
+ * Converts DebugConnectionConfig (public init API) to DebugConfig (internal debug API).
+ * Returns null if the config should not trigger a debug connection.
+ */
+export declare function buildDebugConfigFromInitConfig(debugConfig: DebugConnectionConfig): DebugConfig | null;
+/**
+ * Applies feature flag opt-outs to a DebugConfig, producing a gated copy.
+ * Called before enableDebug() to ensure feature flags are respected.
+ */
+export declare function applyFeatureGatesToDebugConfig(config: DebugConfig, features: ScaleBunFeatures): DebugConfig;
+//# sourceMappingURL=configBuilder.d.ts.map

package/lib/typescript/debug/exportBridge.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ScaleBun Debug — Export Bridge
+ *
+ * SDK→Desktop export request with typed protocol, correlation IDs,
+ * timeout handling, and pending-request deduplication.
+ */
+import type { DebugTransport } from './transport';
+import type { SimplifiedExportOptions, ExportResult, ExportPresetName } from '../public/types';
+/**
+ * Request an export from the desktop application.
+ *
+ * Protocol:
+ *   1. SDK sends event { category: 'export', name: 'export:request', data: { requestId, preset?, options? } }
+ *   2. Desktop receives event, runs export pipeline, sends back command { name: 'exportReportResult', args: { requestId, success, filePath?, error?, cancelled? } }
+ *   3. SDK resolves/rejects the Promise based on the command result
+ */
+export declare function requestExport(transport: DebugTransport | null, enabled: boolean, presetOrOptions?: ExportPresetName | SimplifiedExportOptions): Promise<ExportResult>;
+/**
+ * Handle export result from desktop (called by CommandRegistry).
+ * @internal
+ */
+export declare function handleExportResult(args: Record<string, unknown>): void;
+/**
+ * Reject all pending exports and clear state.
+ */
+export declare function teardownExports(): void;
+//# sourceMappingURL=exportBridge.d.ts.map

package/lib/typescript/debug/hostResolver.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ScaleBun Debug — Host Resolver
+ *
+ * Resolves the debug host address for WebSocket connection.
+ * Android emulator uses 10.0.2.2 to reach host machine's loopback.
+ * iOS simulator / physical devices / web use localhost.
+ */
+/**
+ * Resolve the debug host address.
+ * If explicit host is provided, uses that directly.
+ * Otherwise auto-resolves based on platform.
+ */
+export declare function resolveDebugHost(explicit?: string): string;
+//# sourceMappingURL=hostResolver.d.ts.map

package/lib/typescript/debug/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * ScaleBun Debug — Public API
+ *
+ * Re-exports the public-facing debug API.
+ * Internal modules should import from specific files directly.
+ */
+export { enableDebug, disableDebug, isDebugEnabled, addBreadcrumb, ping, _getStream, _setFlushFn, _getCommands, _getReplaySdk, _isReplaySdkInitialized, _getTransport, _getJourneyConfig, _isJourneyEnabled, _setDebugReady, _getSessionManager, getPerformanceFeature, _getAutoScreenDetector, requestExport, _handleExportResult } from './bootstrap';
+export type { DebugConfig } from './bootstrap';
+export { buildDebugConfigFromInitConfig, applyFeatureGatesToDebugConfig } from './configBuilder';
+export { sendDebugMetric } from './metrics';
+export type { DebugMessage, EventMessage, MetricMessage, CommandMessage, CommandResultMessage, HelloMessage, ErrorMessage, EventCategory, LogLevel as DebugLogLevel, CommandName, } from './protocol';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/debug/metrics.d.ts

@@ -0,0 +1,2 @@
+export declare function sendDebugMetric(name: string, value: number, unit?: string, tags?: Record<string, string>): void;
+//# sourceMappingURL=metrics.d.ts.map

package/lib/typescript/debug/perf.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ScaleBun Debug — Performance Monitoring
+ *
+ * Captures JS event-loop stalls and frame drop signals.
+ * Uses setInterval drift detection to measure event-loop blocking.
+ *
+ * Approach:
+ *   1. Run a 16ms interval timer (one frame budget at 60fps)
+ *   2. Measure actual elapsed time vs expected
+ *   3. If drift > threshold, report a "stall" event
+ *   4. Periodically send aggregate metrics to desktop
+ */
+import { type DebugTransport } from './transport';
+export interface PerfConfig {
+    /** Stall detection threshold in ms. Default: 32 (two frames) */
+    stallThresholdMs?: number;
+    /** How often to report aggregate metrics in ms. Default: 5000 */
+    reportIntervalMs?: number;
+    /** Enable stall detection. Default: true */
+    enableStallDetection?: boolean;
+}
+export declare class PerfMonitor {
+    private transport;
+    private config;
+    private stallTimer;
+    private reportTimer;
+    private lastTick;
+    private stalls;
+    private stallCount;
+    private maxStallMs;
+    private totalStallMs;
+    private running;
+    constructor(transport: DebugTransport, config?: PerfConfig);
+    /** Start monitoring */
+    start(): void;
+    /** Stop monitoring and clean up */
+    stop(): void;
+    private _startStallDetection;
+    private _startReportInterval;
+    private _reportAggregateMetrics;
+    private _sendMetric;
+}
+//# sourceMappingURL=perf.d.ts.map

package/lib/typescript/debug/perfWiring.d.ts

@@ -0,0 +1,33 @@
+/**
+ * ScaleBun Debug — Performance & Profiler Wiring
+ *
+ * Initializes PerformanceFeature and ProfilerFeature for debug mode.
+ * Falls back to legacy PerfMonitor if PerformanceFeature fails.
+ */
+import { PerformanceFeature } from '../features/performance/PerformanceFeature';
+import { ProfilerFeature } from '../features/profiler/ProfilerFeature';
+import { PerfMonitor } from './perf';
+import type { DebugTransport } from './transport';
+import type { DebugEventStream } from './stream';
+export interface PerfWiringResult {
+    performanceFeature: PerformanceFeature | null;
+    profilerFeature: ProfilerFeature | null;
+    perfMonitor: PerfMonitor | null;
+}
+/**
+ * Initialize PerformanceFeature with debug transport.
+ * Falls back to legacy PerfMonitor if PerformanceFeature fails.
+ */
+export declare function initPerformance(transport: DebugTransport, stream: DebugEventStream | null, config: {
+    performanceDisabled?: boolean;
+    enablePerf?: boolean;
+    stallThresholdMs?: number;
+}): {
+    performanceFeature: PerformanceFeature | null;
+    perfMonitor: PerfMonitor | null;
+};
+/**
+ * Initialize ProfilerFeature for debug mode.
+ */
+export declare function initProfiler(transport: DebugTransport, enableProfiler?: boolean): ProfilerFeature | null;
+//# sourceMappingURL=perfWiring.d.ts.map

package/lib/typescript/debug/protocol.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ScaleBun Debug Protocol — re-export shim
+ *
+ * All schemas and types now live in the canonical package:
+ *   @scalebun/protocol
+ *
+ * This file is a thin re-export so that every import path inside the SDK
+ * (e.g. `import { ... } from './protocol'`) continues to resolve without
+ * any changes to callers.
+ *
+ * Do NOT add new schema logic here. Edit @scalebun/protocol/src/index.ts.
+ */
+export { PROTOCOL_VERSION, DEFAULT_HEARTBEAT_INTERVAL_MS, HelloMessageSchema, EventCategorySchema, LogLevelSchema, EventMessageSchema, MetricMessageSchema, CommandNameSchema, CommandMessageSchema, CommandResultMessageSchema, ErrorMessageSchema, PingMessageSchema, PongMessageSchema, AckMessageSchema, DebugMessageSchema, parseDebugMessage, parseAnyMessage, serializeMessage, deserializeMessage, } from '../vendor/protocol';
+export type { HelloMessage, EventMessage, MetricMessage, CommandMessage, CommandResultMessage, ErrorMessage, PingMessage, PongMessage, AckMessage, DebugMessage, AnyScaleBunMessage, EventCategory, LogLevel, CommandName, ParseResult, DeviceInfo, DeviceStatus, } from '../vendor/protocol';
+//# sourceMappingURL=protocol.d.ts.map

package/lib/typescript/debug/redaction.d.ts

@@ -0,0 +1,69 @@
+/**
+ * ScaleBun Debug — Security Redaction & PII Detection
+ *
+ * Ensures sensitive data is never sent over the debug transport.
+ * All functions return new objects (never mutate originals).
+ * All functions are no-throw safe.
+ */
+/**
+ * Redact sensitive HTTP headers. Returns a new object with redacted values.
+ * Original headers object is not mutated.
+ */
+export declare function redactHeaders(headers: Record<string, string> | undefined): Record<string, string>;
+/**
+ * Deep-redact sensitive keys in a body object. Returns a new object.
+ * Handles nested objects and arrays. Never throws.
+ *
+ * SB-02: string bodies (what JSON.stringify produces — i.e. essentially every
+ * React Native network body) are no longer passed through untouched. If a string
+ * parses as JSON it is deep-redacted and re-serialized; otherwise structured
+ * secrets in the string are scrubbed. This closes the "6 of 9 seeded secrets
+ * survived" leak while leaving non-sensitive metadata intact.
+ */
+export declare function redactBody(body: unknown, maxDepth?: number): unknown;
+export interface PIIWarning {
+    type: string;
+    match: string;
+    /** Where in the data the PII was found */
+    location: string;
+}
+/**
+ * Scan a string for PII patterns. Returns a bounded list of warnings.
+ * Never throws.
+ */
+export declare function scanForPII(text: string, location?: string): PIIWarning[];
+/**
+ * Scan an object deeply for PII. Returns a bounded list of warnings.
+ * Never throws.
+ */
+export declare function scanObjectForPII(obj: unknown, basePath?: string, maxDepth?: number): PIIWarning[];
+/**
+ * Redact query parameters that may contain tokens/secrets.
+ * Never throws.
+ */
+export declare function redactUrl(url: string): string;
+export interface RedactedNetworkEvent {
+    url: string;
+    method: string;
+    status: number;
+    duration: number;
+    requestHeaders: Record<string, string>;
+    responseHeaders: Record<string, string>;
+    requestBody: unknown;
+    responseBody: unknown;
+    piiWarnings: PIIWarning[];
+}
+/**
+ * Apply full redaction pipeline to a network event.
+ */
+export declare function redactNetworkEvent(event: {
+    url?: string;
+    method?: string;
+    status?: number;
+    duration?: number;
+    requestHeaders?: Record<string, string>;
+    responseHeaders?: Record<string, string>;
+    requestBody?: unknown;
+    responseBody?: unknown;
+}): RedactedNetworkEvent;
+//# sourceMappingURL=redaction.d.ts.map

package/lib/typescript/debug/replayWiring.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ScaleBun Debug — Replay Wiring
+ *
+ * Handles ReplaySdk initialization with desktop transport,
+ * and deferred native capture wiring into SessionManager.
+ */
+import { ReplaySdk } from '../features/replay/public/api';
+import type { ReplayConfig } from '../features/replay/public/types';
+import type { DebugTransport } from './transport';
+import type { SessionManager as SessionManagerType } from '../features/session/SessionManager';
+/**
+ * Initialize ReplaySdk with desktop transport for dual-mode streaming.
+ * Non-fatal — logs warning on failure.
+ */
+export declare function initReplaySdk(replayConfig: Partial<ReplayConfig> | undefined, transport: DebugTransport): void;
+/**
+ * Wire native screenshot bridge into SessionManager.
+ * Uses deferred init with idempotent guard, retry, and no duplicate binding.
+ */
+export declare function wireNativeCaptureDeferred(getSessionManager: () => SessionManagerType | null): void;
+export declare function isReplaySdkInitialized(): boolean;
+export declare function getReplaySdk(): typeof ReplaySdk;
+export declare function teardownReplay(): void;
+export declare function resetReplayState(): void;
+//# sourceMappingURL=replayWiring.d.ts.map

package/lib/typescript/debug/screenTracking.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ScaleBun Debug — Screen Tracking
+ *
+ * Module-level screen state tracking and auto screen detection wiring.
+ * Feeds screen changes to SessionManager, PerformanceFeature, ProfilerFeature.
+ */
+import { AutoScreenDetector } from '../features/navigation/AutoScreenDetector';
+/** Update the tracked screen — called by navigation detectors */
+export declare function setTrackedScreen(screen: string | null): void;
+/** Get the current tracked screen — used by event stream enrichment */
+export declare function getTrackedScreen(): string | null;
+/**
+ * Start auto screen detection and wire callbacks to all subsystems.
+ */
+export declare function startAutoScreenDetection(): AutoScreenDetector | null;
+//# sourceMappingURL=screenTracking.d.ts.map

package/lib/typescript/debug/sessionWiring.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ScaleBun Debug — Session Wiring
+ *
+ * Creates and wires the unified SessionManager for debug sessions.
+ * Handles native capture factory creation via NativeModules.
+ */
+import type { SessionReplayConfig } from '../features/session/sessionTypes';
+import type { SessionManager as SessionManagerType } from '../features/session/SessionManager';
+import type { DebugTransport } from './transport';
+import type { CommandRegistry } from './commands';
+/**
+ * Create and wire the SessionManager for debug mode.
+ * Returns the created SessionManager instance, or null on failure.
+ */
+export declare function createSessionManager(transport: DebugTransport, commands: CommandRegistry, sessionConfig?: Partial<SessionReplayConfig>, sessionDisabled?: boolean): SessionManagerType | null;
+//# sourceMappingURL=sessionWiring.d.ts.map

package/lib/typescript/debug/stream.d.ts

@@ -0,0 +1,77 @@
+/**
+ * ScaleBun Debug — Event Stream Tap
+ *
+ * Subscribes to SDK internal events and streams them to the debug transport.
+ * Taps into:
+ *   - PersistentQueue (mirrors pipeline envelopes)
+ *   - InternalLogger (SDK log messages)
+ *   - Console (console.log/warn/error)
+ *
+ * All hooks are non-invasive and no-throw safe.
+ */
+import { type DebugTransport } from './transport';
+import { type LogLevel } from './protocol';
+import { type Envelope } from '../pipeline/envelope/envelope';
+interface StreamConfig {
+    /** Whether to capture console.log/warn/error. Default: true */
+    captureConsole?: boolean;
+    /** Whether to capture SDK internal logs. Default: true */
+    captureSDKLogs?: boolean;
+    /** Whether to redact network events. Default: true */
+    redactNetwork?: boolean;
+}
+export declare class DebugEventStream {
+    private transport;
+    private config;
+    private originalConsole;
+    private consoleInstalled;
+    private teardownFns;
+    /** Provider for current screen name — injected at setup from screen tracker */
+    private screenProvider;
+    /**
+     * Provider for the RECORDING session ID (`ses-xxx`).
+     * Injected from bootstrap via setRecordingSessionProvider() after the
+     * SessionManager is created. Returns null when no recording is active.
+     *
+     * This is the single read point for `recordingSessionId` across all event
+     * construction paths in this file — do NOT read it anywhere else.
+     */
+    private recordingSessionProvider;
+    constructor(transport: DebugTransport, config?: StreamConfig);
+    /** Set the screen provider for network/event enrichment */
+    setScreenProvider(provider: () => string | null): void;
+    /**
+     * Set the recording session ID provider.
+     * Must be called after SessionManager is created in bootstrap.
+     * The provider reads SessionManager.recordingSessionId — the single
+     * source of truth for whether a recording is active.
+     */
+    setRecordingSessionProvider(provider: () => string | null): void;
+    /** Install all stream taps */
+    install(): void;
+    /** Send an envelope from the SDK pipeline to the debug stream */
+    tapEnvelope(envelope: Envelope): void;
+    /** Send a log event directly (for SDK internal logger integration) */
+    tapLog(level: LogLevel, message: string, args?: unknown[]): void;
+    /** Send a custom breadcrumb event */
+    tapBreadcrumb(message: string, data?: Record<string, unknown>): void;
+    /** Uninstall all taps and restore original behavior */
+    teardown(): void;
+    private _installConsoleTap;
+    private _installNetworkTap;
+    private _sendNetworkEvent;
+    private _restoreConsole;
+    private _mapEnvelopeCategory;
+    private _inferLogLevel;
+    private _inferTags;
+    private _generateId;
+    /**
+     * Read the current recording session ID from the injected provider.
+     * Returns null when: no provider set, or no recording active.
+     * This is the ONLY place in this file that reads recordingSessionId.
+     */
+    private _getRecordingSessionId;
+    private _safeSerialize;
+}
+export {};
+//# sourceMappingURL=stream.d.ts.map