@scalebun-release/react-native 2.5.0

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

@@ -0,0 +1,110 @@
+/**
+ * ScaleBun Debug — WebSocket Client Transport
+ *
+ * Connects the SDK to the Desktop app over LAN WebSocket.
+ * Features:
+ *   - Auto-reconnect with exponential backoff
+ *   - Message buffering when disconnected
+ *   - Heartbeat ping/pong for connection health
+ *   - Server ACK confirmation after handshake
+ *   - No-throw safety on all public methods
+ */
+import { type DebugMessage, type CommandMessage } from './protocol';
+export interface DebugTransportConfig {
+    host: string;
+    port: number;
+    /** Max messages to buffer when disconnected. Default: 500 */
+    maxBufferSize?: number;
+    /** Max reconnect attempts before giving up. Default: 20 */
+    maxReconnectAttempts?: number;
+    /** Base reconnect delay in ms. Default: 250 */
+    reconnectBaseMs?: number;
+    /** Max reconnect delay in ms. Default: 5000 */
+    reconnectMaxMs?: number;
+    appName?: string;
+    appVersion?: string;
+    bundleId?: string;
+    platform?: 'ios' | 'android' | 'web';
+    osVersion?: string;
+    deviceModel?: string;
+    deviceName?: string;
+    buildType?: 'debug' | 'release';
+    capabilities?: string[];
+    /**
+     * Shared secret for desktop authentication.
+     * If provided (non-null), included in the HelloMessage payload.
+     * The desktop will validate this against its configured secret.
+     * Default: null (not sent — backward compatible with old desktops).
+     */
+    secret?: string | null;
+}
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'closed';
+export type CommandHandler = (cmd: CommandMessage) => void;
+export type StateChangeHandler = (state: ConnectionState) => void;
+export declare class DebugTransport {
+    private ws;
+    private config;
+    private state;
+    private buffer;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private heartbeatIntervalMs;
+    private commandHandlers;
+    private stateHandlers;
+    private sequence;
+    private _deviceId;
+    private _sessionId;
+    private _closed;
+    private _handshakeAcked;
+    /** Cumulative count of messages dropped due to buffer overflow */
+    private _droppedMessages;
+    constructor(config: DebugTransportConfig);
+    /** Set device/session identity (called before connect) */
+    setIdentity(deviceId: string, sessionId: string): void;
+    /** Connect to the desktop app */
+    connect(): void;
+    /**
+     * Send a debug message. Buffers if not connected. Never throws.
+     *
+     * MESSAGE ORDERING POLICY (v1 — best-effort):
+     * Within a single WebSocket connection TCP guarantees in-order delivery,
+     * so messages sent here arrive at the desktop in the same order they are
+     * passed to send(). Across a reconnect, buffered messages are flushed FIFO
+     * via _flushBuffer(), preserving their relative send order. However, any
+     * messages that were already delivered before the disconnect and any that
+     * are delivered after the flush may interleave with in-flight state in the
+     * desktop store. No sequence number is stamped on application messages, and
+     * the desktop performs no gap-detection or reordering. This is intentional
+     * for v1: the overhead of a per-device reorder buffer is not justified until
+     * a concrete UI correctness issue is observed. Revisit if needed.
+     */
+    send(msg: DebugMessage): void;
+    /** Register a handler for incoming commands from desktop */
+    onCommand(handler: CommandHandler): () => void;
+    /** Register a state change listener */
+    onStateChange(handler: StateChangeHandler): () => void;
+    /** Get current connection state */
+    getState(): ConnectionState;
+    /** Get next sequence number */
+    nextSequence(): number;
+    /** Get device ID */
+    get deviceId(): string;
+    /** Get session ID */
+    get sessionId(): string;
+    /** Get cumulative count of messages dropped due to buffer overflow */
+    get droppedMessages(): number;
+    /** Disconnect and stop reconnecting */
+    disconnect(): void;
+    private _doConnect;
+    private _sendHandshake;
+    private _handleAck;
+    private _startHeartbeat;
+    private _stopHeartbeat;
+    private _flushBuffer;
+    private _handleMessage;
+    private _scheduleReconnect;
+    private _clearReconnect;
+    private _setState;
+}
+//# sourceMappingURL=transport.d.ts.map

package/lib/typescript/features/bugreport/BugReportFeature.d.ts

@@ -0,0 +1,59 @@
+import type { EngageAttachmentDraft } from '../engage/engageTypes';
+/** Why a submit did not produce a report id. Mirrors the web SDK's discriminated failure union. */
+export type BugFailure = 'init' | 'consent' | 'send' | 'empty';
+/** Resolves to the report id, or to `{ e }` naming WHICH branch failed. */
+export type BugSubmitResult = string | {
+    e: BugFailure;
+};
+export interface BugReportInput {
+    /** The issue text. Required — a report with no description is not a report. */
+    message: string;
+    title?: string;
+    /**
+     * Reporter's email. Optional on purpose: the session usually already resolves to an end user, so
+     * the form should PREFILL this rather than demand it from someone who just shook their phone in
+     * frustration. `BugReport.reporterEmail` is nullable server-side.
+     */
+    email?: string;
+    /**
+     * An approved voice note, produced by `features/engage/captureVoiceAttachment`.
+     *
+     * That module returns a transcript as a PREFILL and only marks `transcriptApproved` once the user
+     * has explicitly accepted the wording. This feature must never submit an unapproved draft — a
+     * machine transcription of someone's voice, sent without them confirming it, is a different
+     * product decision than the one that pipeline was built for.
+     */
+    voice?: EngageAttachmentDraft;
+}
+type SubmitFn = (input: BugReportInput) => Promise<BugSubmitResult>;
+export declare class BugReportFeature {
+    readonly name = "bugReport";
+    private active;
+    private submitFn;
+    /** Raises the 'report' capture signal so replay flushes its buffer into the current session. */
+    private signalFn;
+    get isActive(): boolean;
+    setup(hooks?: {
+        signal?: () => void;
+    }): void;
+    /**
+     * Flush replay into the session so the report has its visual context.
+     *
+     * Fail-soft: replay may be disabled, paused, or unsupported on this build. A report without a
+     * replay anchor is still a useful report, so this must never block a submit.
+     */
+    signalReport(): void;
+    /** Wired by the facade after init — the full submit path (transport + session + context). */
+    setSubmit(fn: SubmitFn): void;
+    /**
+     * Submit a report.
+     *
+     * Returns rather than throws, always. This is called from a UI the host app renders, often from a
+     * user gesture; an exception escaping into a React Native render tree is a redbox for the
+     * customer's user, over a bug report they were trying to send us.
+     */
+    submit(input: BugReportInput): Promise<BugSubmitResult>;
+    teardown(): void;
+}
+export {};
+//# sourceMappingURL=BugReportFeature.d.ts.map

package/lib/typescript/features/bugreport/buildPayload.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Builds the body for POST /ingestion/sessions/:sessionId/bug-reports.
+ *
+ * Kept as a PURE function with no transport, no bridge and no clock of its own, because the wire
+ * shape is a cross-repo contract and the only way to keep it honest is to be able to assert it
+ * directly. Every bound below is copied from the server DTO
+ * (wzb-dashboard-backend/src/features/bug-reports/dto/submit-bug-report.dto.ts) rather than guessed:
+ *
+ *   clientReportId?   string            idempotency key -> BugReport.clientReportId (@unique)
+ *   title?            string   <= 300
+ *   message           string   <= 20000  -> BugReport.description  (REQUIRED)
+ *   email?            string   <= 320
+ *   url?              string   <= 2000
+ *   console?          unknown[]          recent breadcrumbs
+ *   screenshotKey?    string   <= 512, [A-Za-z0-9._/-] and no ".."
+ *   timestamp?        number             2000-01-01 .. 2100-01-01 in epoch MILLIS
+ *   replaySeq?        int      0 .. 2147483647
+ *   replaySegmentId?  string   <= 256
+ *
+ * Truncating here rather than letting the server 400 is deliberate: a 20,001-character description
+ * is a real report from a real annoyed user, and losing it to a validation error helps nobody. The
+ * ceiling is theirs, so we respect it at the edge. Nothing is silently REWRITTEN — only cut, and
+ * only at bounds the server would otherwise reject outright.
+ */
+/** Mirrors SubmitBugReportDto. Optional keys are omitted entirely rather than sent as undefined. */
+export interface BugReportPayload {
+    clientReportId?: string;
+    title?: string;
+    message: string;
+    email?: string;
+    url?: string;
+    console?: unknown[];
+    screenshotKey?: string;
+    timestamp?: number;
+    replaySeq?: number;
+    replaySegmentId?: string;
+}
+export interface ReplayCoord {
+    seq?: number | null;
+    segmentId?: string | null;
+}
+export declare function buildBugReportPayload(input: {
+    message: string;
+    title?: string;
+    email?: string;
+    clientReportId?: string;
+}, breadcrumbs?: readonly unknown[], ctx?: {
+    replayCoord?: ReplayCoord | null;
+    timestamp?: number;
+}): BugReportPayload;
+//# sourceMappingURL=buildPayload.d.ts.map

package/lib/typescript/features/bugreport/index.d.ts

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

package/lib/typescript/features/crash/CrashFeature.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ScaleBun SDK — Crash Feature
+ *
+ * Installs the JS global error handler (ErrorUtils) and routes every uncaught
+ * exception through the central CrashReporter, which fans it out to all sinks
+ * (desktop event stream + SaaS backend errors endpoint).
+ *
+ * SOLID: Single Responsibility — only owns the JS crash-handler lifecycle.
+ * Delivery concerns live in CrashReporter / its sinks.
+ */
+import type { IFeature, FeatureContext } from '../../core/contracts/IFeature';
+export declare class CrashFeature implements IFeature {
+    readonly name = "crash";
+    private active;
+    private flushFn;
+    constructor(flushFn: () => Promise<void>);
+    initialize(_context: FeatureContext): void;
+    teardown(): void;
+    get isActive(): boolean;
+}
+//# sourceMappingURL=CrashFeature.d.ts.map

package/lib/typescript/features/crash/CrashReporter.d.ts

@@ -0,0 +1,107 @@
+/**
+ * ScaleBun SDK — Crash Reporter
+ *
+ * Single, central entry point for ALL crash/error reports regardless of origin
+ * (JS uncaught, handled via captureError, or native drained on next launch).
+ *
+ * SOLID:
+ *  - Single Responsibility: normalize a crash report and fan it out to sinks.
+ *  - Open/Closed: add new delivery targets by registering a CrashSink — no
+ *    caller or existing-sink changes required.
+ *  - Liskov/Interface Segregation: every sink implements the same minimal
+ *    `CrashSink` contract (one method).
+ *  - Dependency Inversion: callers depend on the CrashReporter abstraction,
+ *    not on the desktop/backend transports directly.
+ */
+/** Where the crash originated. */
+export type CrashSource = 'js' | 'handled' | 'native' | 'manual';
+/** Normalized, transport-agnostic crash report. */
+export interface CrashReport {
+    /** Human-readable error message. */
+    message: string;
+    /** Stack trace (JS string or joined native frames). */
+    stack?: string;
+    /** Coarse classification persisted on the backend: crash | handled | native. */
+    type: string;
+    /** True for process-terminating crashes. */
+    isFatal: boolean;
+    /** Origin of the report — used by sinks for tagging, never for routing. */
+    source: CrashSource;
+    /** Active screen at crash time, when known. */
+    screenName?: string;
+    /** ios | android, when known. */
+    platform?: string;
+    /** ISO timestamp; sinks default to now when omitted. */
+    timestamp?: string;
+    /** Free-form extra context (thread name, signal, cause, ...). */
+    metadata?: Record<string, unknown>;
+    /**
+     * The session this crash BELONGS to, when that is not the current one.
+     *
+     * Set only by a recovered native crash: it happened in a process that is already gone, so the
+     * session it belongs to is not the session running now. Without it the report is routed through
+     * whichever SessionManager exists at drain time and lands on the NEW session — marking a healthy
+     * session crashed and the crashed one clean.
+     *
+     * Absent means "the current session", which is correct for every live report.
+     */
+    sessionId?: string;
+    /**
+     * Stable id for a recovered native crash — the idempotency key.
+     *
+     * Generated ONCE when the crash was first written to disk, never per attempt, so any number of
+     * retries collapse to one backend record. An id minted at upload time would defeat dedupe
+     * entirely and turn every retry into a fresh duplicate crash.
+     */
+    crashId?: string;
+}
+/**
+ * A delivery target for crash reports. Implementations MUST be no-throw:
+ * a failing sink must never break crash delivery to the other sinks.
+ */
+export interface CrashSink {
+    readonly name: string;
+    deliver(report: CrashReport): void;
+}
+/**
+ * Fans a normalized crash report out to every registered sink.
+ * Sink failures are isolated (noThrow) so one bad target cannot starve others.
+ */
+export declare class CrashReporter {
+    private readonly sinks;
+    /** Register a delivery target. Returns an unsubscribe fn. */
+    registerSink(sink: CrashSink): () => void;
+    /**
+     * Deliver a crash report to all sinks. No-throw.
+     *
+     * Scrubbed ONCE, here, before any sink sees it — so no intake and no sink can carry a token or
+     * a phone number off the device (see scrubCrash.ts). If scrubbing itself fails, the report is
+     * reduced to what cannot leak rather than sent raw.
+     */
+    report(report: CrashReport): void;
+}
+/**
+ * Desktop / analytics sink — emits a `$crash` event through the SDK event
+ * pipeline (debug stream + legacy events). Decoupled from the facade via an
+ * injected track function (Dependency Inversion).
+ */
+export declare class DesktopEventSink implements CrashSink {
+    private readonly trackFn;
+    readonly name = "desktop";
+    constructor(trackFn: (name: string, payload?: Record<string, unknown>) => void);
+    deliver(report: CrashReport): void;
+}
+/**
+ * SaaS backend sink — routes the report to the dedicated ingestion errors
+ * endpoint (the data the dashboard Crashes view reads). No-op when no
+ * clientKey-backed session is active.
+ */
+export declare class BackendErrorsSink implements CrashSink {
+    readonly name = "backend";
+    deliver(report: CrashReport): void;
+}
+/** Returns the shared reporter, lazily creating it on first use. */
+export declare function getCrashReporter(): CrashReporter;
+/** Reset (tests / SDK re-init). */
+export declare function resetCrashReporter(): void;
+//# sourceMappingURL=CrashReporter.d.ts.map

package/lib/typescript/features/crash/NativeCrashFeature.d.ts

@@ -0,0 +1,17 @@
+import type { IFeature, FeatureContext } from '../../core/contracts/IFeature';
+/**
+ * Installs native crash handlers (Android UncaughtExceptionHandler,
+ * iOS NSSetUncaughtExceptionHandler + signal handlers) and drains any
+ * crash record left from the previous process run.
+ *
+ * Runs alongside CrashFeature (which covers JS exceptions via ErrorUtils).
+ * Does not replace or modify the JS handler.
+ */
+export declare class NativeCrashFeature implements IFeature {
+    readonly name = "crash.native";
+    private active;
+    initialize(_context: FeatureContext): void;
+    teardown(): void;
+    get isActive(): boolean;
+}
+//# sourceMappingURL=NativeCrashFeature.d.ts.map

package/lib/typescript/features/crash/capture.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Manual error/message capture — the `Sentry.captureException` equivalent.
+ *
+ * D3: these used to write envelopes into `memoryQueue`, a queue whose only
+ * drain (`Dispatcher.flush`) was registered in the DI container and never
+ * resolved by anything — every capture was accumulated and discarded. They
+ * were also never exported, so the two entry points were reachable by nobody
+ * and delivered to nowhere.
+ *
+ * Now they ride the SAME pipeline as automatic crash capture (CrashReporter →
+ * BackendErrorsSink → `/ingestion/sessions/:id/errors`) — the one path in this
+ * SDK that is proven to land rows.
+ */
+export declare function captureException(error: Error, extra?: {
+    screenName?: string;
+    metadata?: Record<string, unknown>;
+}): void;
+export declare function captureMessage(message: string, extra?: {
+    screenName?: string;
+    metadata?: Record<string, unknown>;
+}): void;
+//# sourceMappingURL=capture.d.ts.map

package/lib/typescript/features/crash/globalHandler.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Install the JS global (uncaught) error handler via React Native's `ErrorUtils`.
+ *
+ * `ErrorUtils` is accessed through `globalThis` rather than imported because:
+ *  - it is a runtime global; importing it from 'react-native' conflicts with the
+ *    ambient global value under `isolatedModules`, and
+ *  - on the New Architecture / bridgeless runtime it may be installed lazily, so
+ *    we feature-detect before use. (Calling it unguarded threw
+ *    "Cannot read property 'getGlobalHandler' of undefined" on New Arch.)
+ *
+ * No-op (logs once) when `ErrorUtils` is unavailable.
+ */
+export declare function installGlobalHandler(onCrash: (error: Error, isFatal: boolean) => void): void;
+//# sourceMappingURL=globalHandler.d.ts.map

package/lib/typescript/features/crash/index.d.ts

@@ -0,0 +1,2 @@
+export declare function installCrashReporting(onCrash: (error: Error, isFatal: boolean) => void): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/features/crash/nativeCrashBridge.d.ts

@@ -0,0 +1,43 @@
+/** The session a crash happening right now belongs to, or null before any session opened. */
+export declare function getNativeActiveSession(): string | null;
+export declare function setNativeActiveSession(sessionId: string): Promise<void>;
+export declare function installNativeCrashHandler(): Promise<void>;
+/**
+ * Drain the crash records left from previous process runs.
+ * Returns true if at least one pending crash was found.
+ *
+ * Stops early the first time delivery fails: if the network is down for one crash it is down for the
+ * next, and every extra attempt is a request that cannot succeed made during app startup.
+ */
+export declare function drainNativeCrash(): Promise<boolean>;
+/**
+ * DEV/TEST ONLY — ask the native module to crash the process right now, so the
+ * native handler captures it and the next launch drains it to the backend.
+ * No-op when the native module or `crashNow` is unavailable.
+ */
+export declare function triggerNativeCrash(): Promise<void>;
+/**
+ * Persist a FATAL JS crash to disk BEFORE the process dies.
+ *
+ * A fatal JS error tears the process down almost immediately. The normal error
+ * path queues the crash and POSTs it asynchronously, which loses the race: the
+ * process is gone before the request finishes, and nothing is on disk to retry.
+ * This is why a JS crash could vanish while a native one always survived.
+ *
+ * The fix is the native module's SYNCHRONOUS persistJsCrash: it writes the
+ * record to the same store native crashes use and returns before this function
+ * returns — so by the time the JS handler unwinds, the crash is durable. The
+ * existing drain path then delivers it on the next launch, at least once,
+ * deduped on crashId.
+ *
+ * Synchronous and no-throw by construction: this runs inside the global error
+ * handler, where an exception would replace one crash with another.
+ */
+export declare function persistFatalJsCrash(input: {
+    message: string;
+    stack?: string;
+    screenName?: string;
+    platform?: string;
+    sessionId?: string;
+}): boolean;
+//# sourceMappingURL=nativeCrashBridge.d.ts.map

package/lib/typescript/features/crash/rejectionHandler.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Capture UNHANDLED PROMISE REJECTIONS.
+ *
+ * THE GAP THIS CLOSES
+ * `ErrorUtils.setGlobalHandler` (see ./globalHandler) catches uncaught *throws* and nothing else. A
+ * rejected promise with no `.catch()` does not pass through it — React Native routes those to its own
+ * rejection tracker, which prints a LogBox warning in development and does nothing whatsoever in
+ * production. So `await doThing()` with no catch was reported by the WEB SDK (which listens for
+ * `unhandledrejection`) and silently lost on mobile. Same product, same mistake in the host's code,
+ * one platform reporting it — the cross-SDK asymmetry CLAUDE.md §2 exists to catch.
+ *
+ * WHY `require`, GUARDED, AND NOT AN IMPORT
+ * `promise/setimmediate/rejection-tracking` is React Native's own tracker: it arrives with
+ * react-native in any real app, and adding it to this package's dependencies would put a third-party
+ * runtime dep into the SDK for something the platform already ships. It is therefore resolved at
+ * runtime and treated as optional — the same shape as `globalHandler`'s `ErrorUtils` feature-detect,
+ * for the same reason. When it cannot be resolved this logs once and no-ops; nothing throws.
+ *
+ * ⚠️ `enable()` REPLACES the current handlers — it does not chain, and the module exposes no way to
+ * read the previous ones. Calling it therefore takes over from React Native's own dev-mode warning,
+ * so this re-emits that warning itself under `__DEV__`. Without it, installing the SDK would make
+ * unhandled rejections *quieter* in development than they were before, which is a poor trade for
+ * catching them in production.
+ */
+/** The slice of `promise/setimmediate/rejection-tracking` this uses. */
+export interface RejectionTracker {
+    enable(options: {
+        allRejections: boolean;
+        onUnhandled: (id: number, error: unknown) => void;
+        onHandled: (id: number) => void;
+    }): void;
+}
+/**
+ * Pick the tracker that owns the Promise the app actually uses.
+ *
+ * HERMES FIRST. On Hermes (every RN app since 0.70 by default) `global.Promise` is Hermes' own
+ * built-in, and React Native's polyfillPromise keeps it. The npm `promise` library's tracker only
+ * sees promises created by THAT library's constructor — none, on Hermes — so hooking it caught
+ * nothing: every `await` with no catch in a Hermes app went unreported, in debug and release alike.
+ * Hermes ships its own tracker with the same option shape; RN enables it only under __DEV__ (for
+ * LogBox), so in a release build it is ours to enable.
+ *
+ * The npm tracker remains the fallback for JSC, where the polyfill IS that library.
+ *
+ * Exported for tests; `env` stands in for the global object and `load` for require.
+ */
+export declare function resolveRejectionTracker(env?: {
+    HermesInternal?: any;
+}, load?: (id: string) => unknown): RejectionTracker | null;
+/** Exported for tests. Type, status, message and key NAMES only — never a value. */
+export declare function describeRejection(value: unknown): string;
+/**
+ * Install the unhandled-rejection handler.
+ *
+ * @returns true when the tracker was available and handlers were installed.
+ */
+export declare function installRejectionHandler(onRejection: (error: Error) => void, deps?: {
+    resolveTracker?: () => RejectionTracker | null;
+    isDev?: boolean;
+}): boolean;
+/** Test seam — number of reported-and-not-yet-handled rejections. */
+export declare function __pendingRejectionCount(): number;
+/** Test seam — clear state between cases. */
+export declare function __resetRejectionsForTests(): void;
+//# sourceMappingURL=rejectionHandler.d.ts.map

package/lib/typescript/features/crash/scrubCrash.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Remove credentials and personal data from a crash report BEFORE it leaves the reporter.
+ *
+ * WHY. Nothing on the crash path redacted anything: message, stack and metadata went to every sink
+ * byte for byte, and the backend stored them as sent. Error text in a real app carries exactly what
+ * must never be stored — an axios failure's message and config (Authorization: Bearer …), a URL with
+ * `?token=` in it, a validation error quoting the phone number the user typed, an OTP. SB-POL-001
+ * says credential fields are never captured; for crashes that was not true.
+ *
+ * WHERE. Once, in CrashReporter.report(), so every intake (global handler, promise rejections, the
+ * error boundary, captureError, recovered native crashes) is covered and no sink can receive the raw
+ * report. persistFatalJsCrash scrubs too, because it writes to disk before the reporter runs.
+ * The backend scrubs again on ingest — SDKs already in the field send raw text.
+ *
+ * WHAT IS KEPT. Stack frames stay readable (`at fn (file.js:12:34)`, `0 LeGarage 0x1…`): grouping
+ * and symbolication depend on them, so the stack gets only the patterns that cannot collide with a
+ * frame. Replacements are fixed labels, so two crashes that differ only by a phone number still
+ * read — and fingerprint — the same.
+ *
+ * Zero dependencies (SDK core rule). Input is capped BEFORE any regex runs, so a hostile or
+ * enormous message costs a bounded amount of work.
+ */
+/** A message or any free text: every rule. */
+export declare function scrubText(value: unknown, max?: number): string;
+/** A stack: only the rules that cannot damage a frame. */
+export declare function scrubStack(value: unknown): string | undefined;
+/** Metadata: secret keys dropped, strings scrubbed, bounded depth / keys / size. */
+export declare function scrubMetadata(meta: unknown): Record<string, unknown> | undefined;
+/** The fields of a crash report that can carry user data, scrubbed. Everything else untouched. */
+export declare function scrubCrashFields<T extends {
+    message: string;
+    stack?: string;
+    metadata?: Record<string, unknown>;
+}>(report: T): T;
+//# sourceMappingURL=scrubCrash.d.ts.map

package/lib/typescript/features/engage/EngageAnchor.d.ts

@@ -0,0 +1,36 @@
+import { type ReactElement, type ReactNode, type RefCallback } from 'react';
+import { type ViewProps } from 'react-native';
+export interface EngageAnchorRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface EngageAnchorHandle {
+    measureInWindow: (callback: (x: number, y: number, width: number, height: number) => void) => void;
+}
+export interface EngageAnchorRegistry {
+    register: (anchorKey: string, node: EngageAnchorHandle) => () => void;
+    measure: (anchorKey: string, callback: (rect: EngageAnchorRect | null) => void) => boolean;
+    subscribe: (anchorKey: string, listener: () => void) => () => void;
+    notify: (anchorKey: string) => void;
+}
+/** Internal registry factory exported for zero-native test coverage. */
+export declare function createEngageAnchorRegistry(): EngageAnchorRegistry;
+/** Scoped automatically by EngagePromptProvider; exported for direct EngageInAppView hosts. */
+export declare function EngageAnchorProvider({ children }: {
+    children: ReactNode;
+}): ReactElement;
+export declare function useEngageAnchorRegistry(): EngageAnchorRegistry;
+/**
+ * Layout-safe anchor API. Attach the returned ref directly to a native-backed control:
+ * `const anchor = useScaleBunAnchor('home.transfer'); <Pressable ref={anchor} />`.
+ */
+export declare function useScaleBunAnchor(anchorKey: string): RefCallback<EngageAnchorHandle>;
+export interface ScaleBunAnchorProps extends ViewProps {
+    anchorKey: string;
+    children?: ReactNode;
+}
+/** Wrapper alternative for hosts that cannot attach a callback ref to the target itself. */
+export declare function ScaleBunAnchor({ anchorKey, children, onLayout, ...props }: ScaleBunAnchorProps): ReactElement;
+//# sourceMappingURL=EngageAnchor.d.ts.map

package/lib/typescript/features/engage/EngageArchetypeRenderers.d.ts

@@ -0,0 +1,66 @@
+/**
+ * ScaleBun SDK — Archetype-specific in-app renderers
+ *
+ * These renderers own mechanic content only. Presentation (modal, sheet, banner,
+ * fullscreen, anchored, or inline) stays in EngageInAppView so one mechanic can
+ * be mounted correctly in every container.
+ *
+ * Implemented archetypes (matching dashboard variant keys):
+ *   spin_wheel          → animated spinning prize wheel
+ *   countdown_offer     → live flip-style countdown clock
+ *   scratch_card        → tap-to-reveal scratch surface
+ *   slot_reward         → three-reel slot machine
+ *   poll_card           → single-choice option list
+ *   nps_prompt          → 0–10 NPS number row
+ *   emoji_reaction_bar  → emoji row picker
+ *   rating_request      → 1–5 star tap rating
+ *   streak_reward       → day-streak dot strip
+ *   checklist_progress  → tick-off checklist
+ *   coupon_wallet       → large coupon reveal chip
+ */
+import React from "react";
+import type { InAppBranchProps } from "./EngageInAppView";
+export declare function resolveWheelDiameter(availableWidth: number): number;
+export type WheelSegment = {
+    id: string;
+    label: string;
+    fullLabel: string;
+    color: string;
+    sourceIndex: number;
+};
+type WheelOutcome = {
+    index: number;
+    label: string;
+    resolved: boolean;
+};
+export declare function prepareWheelSegments(value: unknown, source?: Record<string, unknown>): WheelSegment[];
+export declare function resolveWheelOutcome(segments: readonly WheelSegment[], source: Record<string, unknown>): WheelOutcome;
+export declare function SpinWheelInApp(props: InAppBranchProps): React.ReactElement;
+export declare function resolveCountdownDeadline(expiryValue: string, now?: number): number;
+export declare function CountdownInApp(props: InAppBranchProps): React.ReactElement;
+export declare function CarouselDeckInApp(props: InAppBranchProps): React.ReactElement;
+export declare function ScratchCardInApp(props: InAppBranchProps): React.ReactElement;
+export declare function SlotRewardInApp(props: InAppBranchProps): React.ReactElement;
+export declare function PollCardInApp(props: InAppBranchProps): React.ReactElement;
+export declare function NpsPromptInApp(props: InAppBranchProps): React.ReactElement;
+export declare function EmojiReactionBarInApp(props: InAppBranchProps): React.ReactElement;
+export declare function StarRatingInApp(props: InAppBranchProps): React.ReactElement;
+export declare function StreakRewardInApp(props: InAppBranchProps): React.ReactElement;
+export declare function ChecklistProgressInApp(props: InAppBranchProps): React.ReactElement;
+export declare function CouponWalletInApp(props: InAppBranchProps): React.ReactElement;
+export declare function QrNfcInApp(props: InAppBranchProps): React.ReactElement;
+export declare function VideoCommerceInApp(props: InAppBranchProps): React.ReactElement;
+export declare function CelebrationInApp(props: InAppBranchProps): React.ReactElement;
+/** One question-family entry point; payload shape selects the smallest native control. */
+export declare function QuestionFlowInApp(props: InAppBranchProps): React.ReactElement;
+/** Progress-family entry point shared by streak and task-list payloads. */
+export declare function ChecklistProgressFamilyInApp(props: InAppBranchProps): React.ReactElement;
+export type ArchetypeRenderer = (props: InAppBranchProps) => React.ReactElement;
+export type ArchetypeContentFamily = "spinWheel" | "scratchReveal" | "slotReward" | "carouselDeck" | "countdown" | "questionFlow" | "checklistProgress" | "qrNfc" | "videoCommerce" | "celebration";
+/** Canonical mechanic families. Null means the container should render the payload. */
+export declare const ARCHETYPE_CONTENT_RENDERERS: Readonly<Record<ArchetypeContentFamily, ArchetypeRenderer | null>>;
+/** Resolve a canonical family key without silently inventing missing mechanics. */
+export declare function resolveArchetypeContent(archetype?: string | null): ArchetypeRenderer | null;
+export declare const ARCHETYPE_RENDERERS: Record<string, ArchetypeRenderer>;
+export {};
+//# sourceMappingURL=EngageArchetypeRenderers.d.ts.map