@scalebun-release/react-native 2.5.0

package/lib/typescript/push/adapters/loadNotifee.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Isolated lazy loader for the OPTIONAL `@notifee/react-native` dep.
+ *
+ * WHY ITS OWN FILE: Metro's dependency collector emits a dependency map one
+ * entry short for a module that contains TWO OR MORE different-string inline
+ * `require()` calls, so the require indices desync and `_dependencyMap[N]` reads
+ * `undefined` ("Requiring unknown module 'undefined'"). Keeping exactly ONE
+ * inline require per module avoids the miscount. `loadMessaging` lives in its own
+ * sibling file for the same reason.
+ *
+ * The string must still be STATICALLY resolvable at bundle time; hosts that don't
+ * install it must stub it in metro.config.js. See FIX_PUSH_UNKNOWN_MODULE.md.
+ */
+export declare function loadNotifee(): any | null;
+//# sourceMappingURL=loadNotifee.d.ts.map

package/lib/typescript/push/adapters/selectAdapter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Smart adapter selection (requirements 3 & 4).
+ *
+ * Given probed capabilities, pick the safest supported compatibility path. Two
+ * real token sources exist:
+ *   1. RNFirebase JS (@react-native-firebase/messaging) — full feature set
+ *      (token + foreground/opened callbacks), but the JS layer reads native
+ *      modules in a way that needs v18+ under the New Architecture/bridgeless.
+ *   2. The ScaleBunEngage native bridge — acquires the token by reflecting into
+ *      Firebase in NATIVE code, so it works under bridgeless regardless of the
+ *      installed RNFirebase version. Token-only (no message callbacks).
+ *
+ * Auto priority: RNFirebase when usable → native bridge (rescues the cases where
+ * RNFirebase is absent/incompatible) → manual → noop (fail-clear, actionable).
+ */
+import type { AdapterSelection, EnablePushOptions, PushCapabilities } from '../types';
+/** First RNFirebase major with working New Architecture / bridgeless support. */
+export declare const MIN_BRIDGELESS_RNFIREBASE_MAJOR = 18;
+export declare function selectAdapter(caps: PushCapabilities, options?: EnablePushOptions): AdapterSelection;
+//# sourceMappingURL=selectAdapter.d.ts.map

package/lib/typescript/push/detect/capabilities.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Runtime capability detection (requirement 4).
+ *
+ * Probes the live JS runtime — RN version, New Architecture / bridgeless mode,
+ * whether @react-native-firebase/messaging is installed & at what version, and
+ * whether the ScaleBunEngage native token bridge is linked — so the selector can
+ * choose the safest supported adapter automatically.
+ *
+ * All probes are defensive: anything unknown degrades to a conservative default
+ * rather than throwing. Build-time concerns (config files on disk, manifest
+ * permissions) live in the doctor CLI, not here.
+ */
+import type { PushCapabilities } from '../types';
+export declare function detectPushCapabilities(force?: boolean): PushCapabilities;
+//# sourceMappingURL=capabilities.d.ts.map

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

@@ -0,0 +1,10 @@
+/**
+ * Push subsystem — internal barrel. Consumer-facing surface is exposed through
+ * the ScaleBun facade (ScaleBun.enablePush / ScaleBun.push.*), not this file.
+ */
+export { PushManager } from './PushManager';
+export type { PushManagerDeps, PushStatus } from './PushManager';
+export { detectPushCapabilities } from './detect/capabilities';
+export { selectAdapter, MIN_BRIDGELESS_RNFIREBASE_MAJOR } from './adapters/selectAdapter';
+export type { PushAdapter, PushNotification, PushCapabilities, PushPlatform, PushProviderId, AdapterId, AdapterSelection, NotificationPermissionStatus, AndroidChannelConfig, EnablePushOptions, EnablePushResult, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/push/native/nativeNotifications.d.ts

@@ -0,0 +1,65 @@
+/**
+ * ScaleBun SDK — Native Notification Bridge (native-first, NO Notifee)
+ *
+ * Thin wrapper over the `ScaleBunEngage` native module's notification surface
+ * (Android: `ScaleBunNotificationPresenter` via framework APIs). This is the SDK's
+ * native-first display path: channel creation, foreground display, and
+ * notification-open events are all handled by native code — Notifee is NOT
+ * required by the core.
+ *
+ * Fail-soft everywhere: every call is a no-op (or null/false) when the native
+ * module or method is unavailable (JS-only env, iOS until its native surface
+ * lands, host without push). Never throws.
+ */
+/** iOS native notification body ({ title, body, data }) — mirrors the Android shape. */
+interface NativeNotificationPayload {
+    messageId?: string;
+    title?: string;
+    body?: string;
+    data?: Record<string, string>;
+}
+/** True when the native notification surface is present (Android with ScaleBunEngage). */
+export declare function hasNativeNotificationSupport(): boolean;
+/** Create the notification channel natively (API 26+). No-op when unavailable. */
+export declare function ensureNativeChannel(config: {
+    channelId: string;
+    channelName?: string;
+    importance?: number;
+    description?: string;
+}): Promise<boolean>;
+/** Display a notification natively (foreground display path). No-op when unavailable. */
+export declare function showNativeNotification(input: {
+    title?: string;
+    body?: string;
+    channelId: string;
+    data?: Record<string, string>;
+    notificationId?: number;
+}): Promise<boolean>;
+/**
+ * Subscribe to native notification-open events (warm/foreground taps). Returns an
+ * unsubscribe function, or a no-op when the native module is absent.
+ */
+export declare function subscribeNativeNotificationOpened(onOpened: (data: Record<string, string>) => void): () => void;
+/**
+ * Read (once) the cold-start "opened from notification" payload, if the app was
+ * launched by tapping a ScaleBunB notification. Returns the data map or null.
+ */
+export declare function consumeInitialNativeNotification(): Promise<Record<string, string> | null>;
+/**
+ * iOS: request notification authorization natively. Returns the normalized status
+ * ('granted' | 'provisional' | 'denied') or null when unavailable (fail-soft).
+ */
+export declare function requestNativePushPermission(): Promise<string | null>;
+/**
+ * Subscribe to native foreground-notification events (iOS willPresent). Returns an
+ * unsubscribe function, or a no-op when the native module is absent. Payload carries
+ * the normalized { title, body, data } note.
+ */
+export declare function subscribeNativeForegroundNotification(onForeground: (note: NativeNotificationPayload) => void): () => void;
+/**
+ * Read (once) the cold-start opened notification as a full normalized note
+ * ({ title, body, data }) — iOS path. Returns null when none/unavailable.
+ */
+export declare function consumeInitialNativeNotificationFull(): Promise<NativeNotificationPayload | null>;
+export {};
+//# sourceMappingURL=nativeNotifications.d.ts.map

package/lib/typescript/push/types.d.ts

@@ -0,0 +1,143 @@
+/**
+ * ScaleBun SDK — Push subsystem shared types.
+ *
+ * These types are platform-agnostic on purpose. The same event model
+ * (PushNotification), identity contract (registerDeviceToken input on the
+ * facade), and adapter shape are intended to be mirrored by future Flutter /
+ * native SDKs so the backend token-registration and push-event contracts stay
+ * identical across platforms. Only the adapter implementation is platform code.
+ */
+export type PushPlatform = 'android' | 'ios';
+/**
+ * Backend push-provider routing key. `fcm` = Firebase Cloud Messaging token
+ * (Android, and iOS when routed through Firebase). `apns` = a raw Apple Push
+ * Notification service device token (direct APNs, iOS only). This is the source of
+ * truth the backend uses to pick the tenant's send transport for a device token.
+ */
+export type PushProviderId = 'fcm' | 'apns';
+/**
+ * Stable identifiers for the selected compatibility path. Surfaced by the
+ * doctor CLI and `ScaleBun.push.status()` so developers know which path is live.
+ *
+ * - `rnfirebase` — @react-native-firebase/messaging (full callbacks).
+ * - `native`     — the ScaleBunEngage native bridge (reflective FCM/APNs token).
+ *                  Works under bridgeless regardless of the installed RNFirebase
+ *                  JS version; token-only (no foreground/opened message stream).
+ * - `manual`     — host supplies the token.
+ * - `noop`       — fail-clear fallback.
+ */
+export type AdapterId = 'rnfirebase' | 'native' | 'manual' | 'noop';
+export type NotificationPermissionStatus = 'granted' | 'denied' | 'provisional' | 'unavailable';
+/**
+ * Normalized notification event. Every adapter maps its provider-specific
+ * payload into this shape so consumer callbacks never depend on RNFirebase (or
+ * any provider) types.
+ */
+export interface PushNotification {
+    /** Provider message id when available. */
+    messageId?: string;
+    title?: string;
+    body?: string;
+    /** Arbitrary data payload (FCM `data`, APNs custom keys). Always defined. */
+    data: Record<string, string>;
+    /** Best-effort delivery time (ms epoch) when the provider reports it. */
+    sentTime?: number;
+}
+export interface AndroidChannelConfig {
+    channelId: string;
+    channelName?: string;
+    /** Android importance 0-5; defaults to 4 (HIGH) when omitted. */
+    importance?: number;
+    description?: string;
+}
+/**
+ * Internal push provider abstraction (requirement 2).
+ *
+ * An adapter is responsible ONLY for talking to the platform: permission,
+ * channels, token lifecycle, and notification events. It does NOT talk to the
+ * ScaleBun backend — token registration/sync is owned by PushManager so the
+ * backend contract is identical for every adapter.
+ *
+ * Every method must be safe to call and must not throw; failures are reported
+ * via return values / status, never exceptions.
+ */
+export interface PushAdapter {
+    readonly id: AdapterId;
+    /** True when this adapter's underlying provider is actually usable now. */
+    isAvailable(): boolean;
+    /**
+     * Push provider the acquired token belongs to — the backend routing key.
+     * Direct APNs (raw APNs device token on iOS) → 'apns'; Firebase-routed tokens
+     * (FCM, both platforms) → 'fcm'. Platform-dependent for adapters that bridge
+     * the native OS token directly (e.g. the ScaleBunEngage native bridge yields a raw
+     * APNs token on iOS but an FCM token on Android).
+     */
+    pushProvider(): PushProviderId;
+    /** Request OS notification permission (Android 13+, iOS). */
+    requestPermission(): Promise<NotificationPermissionStatus>;
+    /** Create/ensure an Android notification channel. No-op on iOS. */
+    createAndroidChannel(channel: AndroidChannelConfig): Promise<void>;
+    /** Acquire the current push token (FCM/APNs). Null when unavailable. */
+    getToken(): Promise<string | null>;
+    /** Subscribe to token rotation. Returns an unsubscribe fn. */
+    onTokenRefresh(cb: (token: string) => void): () => void;
+    /** Subscribe to messages received while the app is foregrounded. */
+    onForegroundMessage(cb: (message: PushNotification) => void): () => void;
+    /** Subscribe to the user tapping a notification (app already running). */
+    onNotificationOpened(cb: (message: PushNotification) => void): () => void;
+    /** The notification that cold-started the app, if any. */
+    getInitialNotification(): Promise<PushNotification | null>;
+    /** Remove all listeners. Idempotent. */
+    teardown(): void;
+}
+/**
+ * Result of runtime environment probing used to pick an adapter (requirement 4).
+ */
+export interface PushCapabilities {
+    platform: PushPlatform | 'unknown';
+    /** e.g. "0.78.3"; null when unknown. */
+    rnVersion: string | null;
+    rnVersionParts: {
+        major: number;
+        minor: number;
+        patch: number;
+    } | null;
+    /** New Architecture / bridgeless runtime detected. */
+    isNewArchitecture: boolean;
+    isBridgeless: boolean;
+    /** @react-native-firebase/messaging require() succeeded. */
+    hasRNFirebaseMessaging: boolean;
+    /** Best-effort installed @react-native-firebase version, e.g. "21.6.1". */
+    rnFirebaseVersion: string | null;
+    rnFirebaseMajor: number | null;
+    /** The ScaleBunEngage native module is linked (native FCM/APNs token bridge). */
+    hasNativeEngageBridge: boolean;
+}
+/** Why a given adapter was (not) selected — actionable, surfaced to developers. */
+export interface AdapterSelection {
+    adapter: PushAdapter;
+    /** Human-readable, actionable explanation. */
+    reason: string;
+    /** True when the selected adapter can actually deliver a token. */
+    usable: boolean;
+}
+export interface EnablePushOptions {
+    /** Force a specific compatibility path; defaults to 'auto'. */
+    provider?: 'auto' | 'rnfirebase' | 'native' | 'manual';
+    /** Android channel config; a sensible default is used when omitted. */
+    android?: AndroidChannelConfig;
+    /** For provider:'manual' — a token the host app already obtained. */
+    manualToken?: string;
+    /** Skip the OS permission prompt (host app handles it). */
+    skipPermissionRequest?: boolean;
+    onForegroundNotification?: (message: PushNotification) => void;
+    onNotificationOpened?: (message: PushNotification) => void;
+}
+export interface EnablePushResult {
+    ok: boolean;
+    adapter: AdapterId;
+    reason: string;
+    permission?: NotificationPermissionStatus;
+    tokenRegistered?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/specs/NativeReplaySdk.d.ts

@@ -0,0 +1,69 @@
+import type { TurboModule } from 'react-native';
+/**
+ * React Native Codegen spec for the native session-replay module (`ReplaySdk`).
+ *
+ * Architecture-compatibility only — this does NOT change any replay business
+ * logic. It declares the New Architecture (TurboModule) method surface so the
+ * native module registers as a real TurboModule on Android; on iOS the module
+ * subclasses `RCTEventEmitter` and is served via the interop layer.
+ *
+ * Replay events (`ReplaySdk_SessionStateChanged`, `_FrameCaptured`,
+ * `_SessionLimitReached`, `_ScreenChanged`, …) are delivered via the device
+ * event emitter and consumed with `NativeEventEmitter`, independent of this
+ * spec and identical on both architectures. `addListener` / `removeListeners`
+ * satisfy `NativeEventEmitter`.
+ *
+ * Codegen has a limited type system, so config/result maps are generic
+ * `Object`. The richer types (NativeFrameResult, NativeSessionInfo, …) are kept
+ * in `bridge/nativeModule.ts`, which casts this module to that interface — so no
+ * caller loses typing.
+ */
+export interface Spec extends TurboModule {
+    initialize(config: Object): Promise<boolean>;
+    startSession(): Promise<string>;
+    stopSession(): Promise<boolean>;
+    pauseSession(): Promise<boolean>;
+    resumeSession(): Promise<boolean>;
+    captureFrame(reason: string): Promise<Object>;
+    captureManualFrame(): Promise<Object>;
+    captureScreenshot(reason: string): Promise<Object>;
+    initOutbox(config: Object): Promise<boolean>;
+    captureScreenshotToFile(input: Object): Promise<Object>;
+    commitOutboxFrame(meta: Object): Promise<string>;
+    discardOutboxFrame(sessionId: string, frameId: string): Promise<boolean>;
+    enqueueOutboxRecords(lane: string, sessionId: string, records: Object[]): Promise<boolean>;
+    flushNativeOutbox(): Promise<boolean>;
+    recoverNativeOutbox(): Promise<boolean>;
+    getOutboxStats(): Promise<Object>;
+    setOutboxLaneQuota(lane: string, blocked: boolean): Promise<number>;
+    startVoiceRecording(): Promise<void>;
+    stopVoiceRecording(): Promise<Object>;
+    cancelVoiceRecording(): Promise<void>;
+    setEnabled(enabled: boolean): Promise<void>;
+    setCapturingMode(mode: string): Promise<void>;
+    setScreenshotQuality(quality: string): Promise<void>;
+    setScreenshotCaptureInterval(intervalMs: number): Promise<void>;
+    setUserStepsEnabled(enabled: boolean): Promise<void>;
+    setNetworkLogsEnabled(enabled: boolean): Promise<void>;
+    setSdkLogsEnabled(enabled: boolean): Promise<void>;
+    setPrivacyOptions(options: Object): Promise<void>;
+    maskElement(elementId: string): Promise<void>;
+    unmaskElement(elementId: string): Promise<void>;
+    setUser(user: Object): Promise<void>;
+    clearUser(): Promise<void>;
+    addBreadcrumb(breadcrumb: Object): Promise<void>;
+    addNetworkBreadcrumb(request: Object): Promise<void>;
+    setCurrentScreen(screenName: string): Promise<void>;
+    reportInteraction(interaction: Object): Promise<void>;
+    getSessionInfo(): Promise<Object>;
+    getDeviceInfo(): Promise<Object>;
+    getSessionReplayLink(): Promise<Object>;
+    flushUpload(): Promise<boolean>;
+    cancelUpload(): Promise<void>;
+    destroy(): Promise<void>;
+    addListener(eventName: string): void;
+    removeListeners(count: number): void;
+}
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativeReplaySdk.d.ts.map

package/lib/typescript/specs/NativeScaleBunCrash.d.ts

@@ -0,0 +1,58 @@
+import type { TurboModule } from 'react-native';
+/**
+ * React Native Codegen spec for the native crash module (`ScaleBunCrash`).
+ *
+ * This declares the New Architecture (TurboModule) interface. Codegen turns it
+ * into the native `NativeScaleBunCrashSpec` base classes (Kotlin `com.scalebun.spec`
+ * / generated ObjC protocol) that the Phase 2 `newarch` wrappers implement. On
+ * Old Architecture the identical JS surface is served by the legacy
+ * NativeModule. Method names/shapes mirror the existing native module exactly:
+ * `install` / `crashNow` / `drainPendingCrash`.
+ *
+ * Type note: codegen has a limited type system, so `drainPendingCrash` is typed
+ * as a generic `Object`. At runtime it resolves either a crash record
+ * (name, exceptionType, message, threadName, timestamp, platform, stackTrace[],
+ * cause{}) or `null` when there is no pending crash — callers must null-check.
+ */
+export interface Spec extends TurboModule {
+    /** Install the native uncaught-exception / signal handler. Idempotent. */
+    install(): Promise<boolean>;
+    /** DEV/TEST only: crash the process so the next launch can drain it. */
+    crashNow(): Promise<boolean>;
+    /**
+     * Record which session is live so a crash can name it.
+     *
+     * Called once per session. Native writes it to crash-safe storage BEFORE any crash can happen —
+     * a fatal handler cannot call back into JS to ask.
+     */
+    setActiveSessionId(sessionId: string): Promise<boolean>;
+    /** Return the previous run's crash record (or null), then clear it. */
+    drainPendingCrash(): Promise<Object>;
+    /**
+     * Delete a delivered crash by its stable id.
+     *
+     * Called ONLY after the backend has accepted it. The read is non-destructive precisely so this
+     * can be the moment of deletion — a failed upload must leave the durable copy in place.
+     */
+    clearPendingCrash(crashId: string): Promise<boolean>;
+    /**
+     * Persist a FATAL JS crash to the same on-disk store native crashes use, so
+     * the next launch drains it. SYNCHRONOUS by design (returns a boolean, not a
+     * Promise): a fatal JS error tears the process down, and an async POST — or
+     * even an async native call — races that teardown and loses the crash. A
+     * blocking write completes on disk before the JS handler returns.
+     *
+     * recordJson is a JSON crash record: at least { crashId, type, message },
+     * plus stack / screenName / platform / sessionId / timestamp when known.
+     */
+    persistJsCrash(recordJson: string): boolean;
+}
+/**
+ * Resolved via `get` (not `getEnforcing`) so the SDK degrades gracefully when
+ * the native module is unavailable (web/SSR, Expo Go) — it returns `null`
+ * instead of throwing. On Old Architecture the bridge falls back to the legacy
+ * `NativeModules.ScaleBunCrash`.
+ */
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativeScaleBunCrash.d.ts.map

package/lib/typescript/specs/NativeScaleBunInstallReferrer.d.ts

@@ -0,0 +1,28 @@
+import type { TurboModule } from 'react-native';
+/**
+ * React Native Codegen spec for the Android Play Install Referrer bridge
+ * (`ScaleBunInstallReferrer`).
+ *
+ * Android-only. Wraps Google Play's Install Referrer API to read the `referrer`
+ * string the Play Store recorded at install time (e.g. `scalebun_click_id=...`,
+ * `utm_source=...`, `gclid=...`). That string ties the install to the exact click,
+ * enabling deterministic attribution — the strongest match method on Android.
+ *
+ * iOS has no equivalent (attribution there is SKAdNetwork), so there is no iOS
+ * native impl; the JS bridge is a no-op off Android.
+ *
+ * Resolved via `get` (not `getEnforcing`) so the SDK degrades gracefully when the
+ * module is unavailable (iOS, Expo Go, Jest, a not-yet-rebuilt app) → returns null.
+ */
+export interface Spec extends TurboModule {
+    /**
+     * Resolve the Play Install Referrer string. Resolves to the raw (URL-encoded)
+     * referrer — possibly `""` for an organic install with no referrer. Rejects when
+     * the Play Install Referrer service is unavailable (no Play Store, transient
+     * error), so the JS layer can retry on a later launch.
+     */
+    getInstallReferrer(): Promise<string>;
+}
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativeScaleBunInstallReferrer.d.ts.map

package/lib/typescript/specs/NativeScaleBunOta.d.ts

@@ -0,0 +1,141 @@
+import type { TurboModule } from 'react-native';
+/**
+ * React Native Codegen spec for OTA bundle management.
+ *
+ * Manages on-disk bundle slots (current/next/previous), boot-guard markers,
+ * and atomic bundle application. All heavy lifting (download, verify, apply)
+ * is driven from JS via the OtaOrchestrator; the native module owns the
+ * filesystem layout and the boot-guard marker that operates below JS.
+ *
+ * Sprint 1: scaffold with no-op methods that return safe defaults.
+ * Sprint 2-3: real implementations (Android Kotlin + iOS Swift).
+ *
+ * Slot layout (see docs/ota-native-design.md):
+ *   {appFilesDir}/scalebun_ota/current/  — active bundle
+ *   {appFilesDir}/scalebun_ota/next/     — staged downloaded bundle
+ *   {appFilesDir}/scalebun_ota/previous/ — rollback target
+ */
+export interface Spec extends TurboModule {
+    /**
+     * Returns the absolute path to the active JS bundle, or null if using the
+     * default Metro/RN bundle. Called by the native app entry point to resolve
+     * the bundle URL at launch.
+     */
+    getActiveBundle(): string | null;
+    /**
+     * JSON array (string) of the trusted key IDs embedded in the app package, e.g.
+     * `["production-2026-01"]`. Reported on OTA check-in for SDK trust coverage
+     * (CICDPAGE §12) so the dashboard can measure key-rotation adoption. This is
+     * telemetry ONLY — the server never trusts a key because a device claims it.
+     * Empty array when no keys are embedded.
+     */
+    getTrustedKeyIds(): string;
+    /** JSON array of root/jailbreak indicator strings; [] when none found. */
+    getDeviceIntegrity(): string;
+    /**
+     * Returns JSON with current slot state:
+     * { current: { bundleId, version, sha256, installedAt } | null,
+     *   next: ... | null, previous: ... | null,
+     *   bootMarkerPresent: boolean }
+     */
+    getSlotState(): string;
+    /**
+     * Write a downloaded bundle from `sourcePath` to the 'next' slot.
+     * Verifies the sha256 before finalizing. Returns success boolean.
+     */
+    stageBundle(sourcePath: string, sha256: string): Promise<boolean>;
+    /**
+     * Sprint 7 (S7-NAT-1): Apply a binary patch to the current bundle,
+     * producing a new bundle in the 'next' slot.
+     *
+     * @param patchUrl - URL to download the patch file
+     * @param patchSha256 - SHA-256 of the patch file itself
+     * @param expectedSha256 - SHA-256 of the resulting full bundle after patching
+     * @returns true if patch was applied and the result matches expectedSha256
+     *
+     * If this returns false, the caller should fall back to full-bundle download.
+     * The native implementation uses bspatch (or equivalent) to apply the diff
+     * to the current bundle, then verifies the output hash.
+     */
+    stagePatch(patchUrl: string, patchSha256: string, expectedSha256: string): Promise<boolean>;
+    /**
+     * Atomically promote 'next' -> 'current' (and current -> previous).
+     * Sets the boot-guard marker. Returns success boolean.
+     */
+    applyUpdate(): Promise<boolean>;
+    /**
+     * Mark the current bundle as healthy (clears the boot-guard marker).
+     * Called by the OtaOrchestrator after the app has run successfully for
+     * a configurable duration post-update.
+     */
+    markHealthy(): void;
+    /**
+     * Revert to 'previous' slot (boot-guard triggered rollback).
+     * Called by native code when the boot-guard marker is still present
+     * at cold start, BEFORE JS loads.
+     */
+    revertToPrevious(): Promise<boolean>;
+    /**
+     * Restart the React Native runtime so the applied bundle loads NOW.
+     *
+     * Exists because `DevSettings.reload()` is a silent no-op in RELEASE builds
+     * (verified live: "Triggering app restart…" logged, nothing happened, same
+     * process, old bundle still running). That made IMMEDIATE / ON_NEXT_RESUME /
+     * `autoRestart` / the CodePush shim's restart all fiction in production.
+     * Android: `ReactHost.reload()` (bridgeless) or
+     * `recreateReactContextInBackground()` (bridge). iOS: RCTReloadCommand.
+     */
+    restartApp(): void;
+    /**
+     * Verify a SB-OTA-RSA-SHA256-V1 release envelope in NATIVE code, with no side
+     * effects. `envelopeJson` is the JSON `{ protocol, keyId, signedPayload,
+     * signature, downloadUrl? }` from the check response. Verification uses the
+     * trusted RSA public keys EMBEDDED in the app package (never a key from JS or
+     * the server) and platform `SHA256withRSA` (present on every supported API
+     * level — no API-33 floor).
+     *
+     * Resolves a verdict JSON string: `{ ok: boolean, code?: string, message?,
+     * keyId?, releaseId?, bundleId?, releaseSequence?, artifactSha256?,
+     * artifactSize?, resultArtifactSha256?, fingerprint? }`. A failed check is
+     * `ok:false` with a stable `code`; a rejected promise is machinery failure and
+     * the caller must treat it as a failure, never as valid.
+     */
+    verifyRelease(envelopeJson: string): Promise<string>;
+    /**
+     * Native-ENFORCED install: verify the RSA signature (as `verifyRelease`), then
+     * download the artifact, enforce the SIGNED size + SHA-256, and stage it into
+     * the `next` slot — all natively. JavaScript cannot stage bytes that were not
+     * proven authentic (once trusted keys are embedded, the legacy `stageBundle`
+     * path refuses). Does not activate; call `applyUpdate` to promote per the
+     * install mode. Resolves the same verdict JSON as `verifyRelease` (`ok:true`
+     * once staged).
+     */
+    verifyAndStageRelease(envelopeJson: string): Promise<string>;
+    /**
+     * Native-ENFORCED install from a PATCH (signed releases).
+     *
+     * Verifies the envelope exactly as `verifyAndStageRelease`; takes the expected
+     * size, hash and sequence ONLY from that verified payload; reads the current
+     * bundle under the slot lock and requires it to have come through the signed
+     * path with its recorded hash intact; downloads the patch (`patchJson`:
+     * `{url,size,sha256,baseBundleId,baseSha256?}`), rebuilds with size limits,
+     * and stages only if the result matches the SIGNED size and SHA-256. The patch
+     * bytes themselves are unsigned — the signed result hash is what anchors them.
+     *
+     * Resolves the same verdict JSON as `verifyAndStageRelease`, plus
+     * `patchUsed: true` on success. Any failure resolves `ok:false`; the caller
+     * falls back to `verifyAndStageRelease`. Absent from native builds that predate
+     * it — callers feature-detect (`typeof … === 'function'`).
+     */
+    verifyAndStagePatch(envelopeJson: string, patchJson: string): Promise<string>;
+}
+/**
+ * Resolved via `get` (not `getEnforcing`) so the SDK degrades gracefully when
+ * the native module is unavailable (web/SSR, Jest, an app that hasn't rebuilt
+ * native yet) — it returns `null` and OtaOrchestrator disables itself with a
+ * single warning. On the Old Architecture the registry transparently bridges
+ * to the legacy `NativeModules.ScaleBunOta`.
+ */
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativeScaleBunOta.d.ts.map

package/lib/typescript/specs/NativeScaleBunPerformance.d.ts

@@ -0,0 +1,31 @@
+import type { TurboModule } from 'react-native';
+/**
+ * React Native Codegen spec for the native performance module (`ScaleBunPerformance`).
+ *
+ * Declares the New Architecture (TurboModule) **method** surface. The native
+ * performance events (`ScaleBunPerformance_FrameMetrics`, `ScaleBunPerformance_UiHang`)
+ * are delivered via the device event emitter and consumed with
+ * `NativeEventEmitter`, independent of the TurboModule and identical on both
+ * architectures. `addListener` / `removeListeners` satisfy `NativeEventEmitter`.
+ *
+ * Method names/shapes mirror the existing native module exactly. `getAppStartInfo`
+ * resolves a generic `Object` (or `null` when not yet available).
+ *
+ * iOS note: this module subclasses `RCTEventEmitter` and is served via the
+ * interop layer on iOS (the JS resolver falls back to `NativeModules`); only
+ * Android registers it as a pure TurboModule today.
+ */
+export interface Spec extends TurboModule {
+    initialize(): Promise<boolean>;
+    getAppStartInfo(): Promise<Object>;
+    startFrameMetrics(intervalMs: number): Promise<boolean>;
+    stopFrameMetrics(): Promise<boolean>;
+    startHangDetection(thresholdMs: number): Promise<boolean>;
+    stopHangDetection(): Promise<boolean>;
+    destroy(): Promise<boolean>;
+    addListener(eventName: string): void;
+    removeListeners(count: number): void;
+}
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativeScaleBunPerformance.d.ts.map

package/lib/typescript/specs/NativeScaleBunProfiler.d.ts

@@ -0,0 +1,38 @@
+import type { TurboModule } from 'react-native';
+/**
+ * React Native Codegen spec for the native profiler module (`ScaleBunProfiler`).
+ *
+ * Declares the New Architecture (TurboModule) **method** surface. Native
+ * profiling events (`ScaleBunProfiler_SampleBatch`, `_Incident`, `_ThreadSnapshot`,
+ * `_StateChanged`, `_Capabilities`) continue to be delivered via the device
+ * event emitter and consumed with `NativeEventEmitter` — independent of the
+ * TurboModule, and identical on both architectures. `addListener` /
+ * `removeListeners` are required by `NativeEventEmitter`.
+ *
+ * Method names/shapes mirror the existing native module exactly. Codegen has a
+ * limited type system, so config/result maps are generic `Object`.
+ *
+ * iOS note: on iOS this module subclasses `RCTEventEmitter` and is served via
+ * the interop layer (the JS bridge falls back to `NativeModules`); only Android
+ * registers it as a pure TurboModule today.
+ */
+export interface Spec extends TurboModule {
+    startProfiler(config: Object): Promise<boolean>;
+    stopProfiler(): Promise<boolean>;
+    pauseProfilerStream(): Promise<boolean>;
+    resumeProfilerStream(): Promise<boolean>;
+    captureProfilerSnapshot(): Promise<Object>;
+    setProfilerConfig(config: Object): Promise<boolean>;
+    markProfilerSpan(spanName: string, spanId: string, metadata?: Object): Promise<boolean>;
+    endProfilerSpan(spanId: string): Promise<boolean>;
+    markProfilerInteraction(interactionId: string, interactionName: string): Promise<boolean>;
+    flushProfilerExport(): Promise<Object>;
+    getProfilerCapabilities(): Promise<Object>;
+    setCurrentScreen(screenName: string): Promise<boolean>;
+    setSessionId(sessionId: string): Promise<boolean>;
+    addListener(eventName: string): void;
+    removeListeners(count: number): void;
+}
+declare const _default: Spec | null;
+export default _default;
+//# sourceMappingURL=NativeScaleBunProfiler.d.ts.map