@scalebun-release/react-native 2.5.0

package/lib/module/push/native/nativeNotifications.js

@@ -0,0 +1,155 @@
+/**
+ * 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.
+ */
+
+import { NativeModules, NativeEventEmitter } from 'react-native';
+import { logger } from '../../core/logger/internalLogger';
+const NOTIFICATION_OPENED_EVENT = 'ScaleBunEngageNotificationOpened';
+const FOREGROUND_NOTIFICATION_EVENT = 'ScaleBunEngageForegroundNotification';
+
+/** iOS native notification body ({ title, body, data }) — mirrors the Android shape. */
+
+function getModule() {
+  return NativeModules?.ScaleBunEngage ?? null;
+}
+
+/** True when the native notification surface is present (Android with ScaleBunEngage). */
+export function hasNativeNotificationSupport() {
+  const mod = getModule();
+  return !!(mod?.ensureNotificationChannel && mod?.showForegroundNotification);
+}
+
+/** Create the notification channel natively (API 26+). No-op when unavailable. */
+export async function ensureNativeChannel(config) {
+  try {
+    const mod = getModule();
+    if (!mod?.ensureNotificationChannel) return false;
+    return await mod.ensureNotificationChannel(config.channelId, config.channelName ?? 'Notifications', config.importance ?? 4,
+    // IMPORTANCE_HIGH
+    config.description ?? null);
+  } catch (err) {
+    __DEV__ && logger.debug(`[Push.native] ensureChannel failed (fail-soft): ${err?.message}`);
+    return false;
+  }
+}
+
+/** Display a notification natively (foreground display path). No-op when unavailable. */
+export async function showNativeNotification(input) {
+  try {
+    const mod = getModule();
+    if (!mod?.showForegroundNotification) return false;
+    return await mod.showForegroundNotification({
+      title: input.title,
+      body: input.body,
+      channelId: input.channelId,
+      data: input.data ?? {},
+      ...(input.notificationId != null ? {
+        notificationId: input.notificationId
+      } : {})
+    });
+  } catch (err) {
+    __DEV__ && logger.debug(`[Push.native] showNotification failed (fail-soft): ${err?.message}`);
+    return false;
+  }
+}
+
+/**
+ * Subscribe to native notification-open events (warm/foreground taps). Returns an
+ * unsubscribe function, or a no-op when the native module is absent.
+ */
+export function subscribeNativeNotificationOpened(onOpened) {
+  try {
+    const nativeModule = NativeModules?.ScaleBunEngage;
+    if (!nativeModule) return () => {};
+    const emitter = new NativeEventEmitter(nativeModule);
+    const sub = emitter.addListener(NOTIFICATION_OPENED_EVENT, payload => onOpened(payload?.data ?? {}));
+    return () => sub.remove();
+  } catch (err) {
+    __DEV__ && logger.debug(`[Push.native] opened subscription failed (fail-soft): ${err?.message}`);
+    return () => {};
+  }
+}
+
+/**
+ * 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 async function consumeInitialNativeNotification() {
+  try {
+    const mod = getModule();
+    if (!mod?.consumeInitialNotification) return null;
+    const payload = await mod.consumeInitialNotification();
+    if (!payload) return null;
+    return payload.data ?? {};
+  } catch (err) {
+    __DEV__ && logger.debug(`[Push.native] consumeInitial failed (fail-soft): ${err?.message}`);
+    return null;
+  }
+}
+
+/**
+ * iOS: request notification authorization natively. Returns the normalized status
+ * ('granted' | 'provisional' | 'denied') or null when unavailable (fail-soft).
+ */
+export async function requestNativePushPermission() {
+  try {
+    const mod = getModule();
+    if (!mod?.requestPushPermission) return null;
+    return await mod.requestPushPermission();
+  } catch (err) {
+    __DEV__ && logger.debug(`[Push.native] requestPushPermission failed (fail-soft): ${err?.message}`);
+    return 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 function subscribeNativeForegroundNotification(onForeground) {
+  try {
+    const nativeModule = NativeModules?.ScaleBunEngage;
+    if (!nativeModule) return () => {};
+    const emitter = new NativeEventEmitter(nativeModule);
+    const sub = emitter.addListener(FOREGROUND_NOTIFICATION_EVENT, payload => onForeground(payload ?? {
+      data: {}
+    }));
+    return () => sub.remove();
+  } catch (err) {
+    __DEV__ && logger.debug(`[Push.native] foreground subscription failed (fail-soft): ${err?.message}`);
+    return () => {};
+  }
+}
+
+/**
+ * Read (once) the cold-start opened notification as a full normalized note
+ * ({ title, body, data }) — iOS path. Returns null when none/unavailable.
+ */
+export async function consumeInitialNativeNotificationFull() {
+  try {
+    const mod = getModule();
+    if (!mod?.consumeInitialNotification) return null;
+    const payload = await mod.consumeInitialNotification();
+    if (!payload) return null;
+    return {
+      title: 'title' in payload ? payload.title : undefined,
+      body: 'body' in payload ? payload.body : undefined,
+      data: payload.data ?? {}
+    };
+  } catch (err) {
+    __DEV__ && logger.debug(`[Push.native] consumeInitialFull failed (fail-soft): ${err?.message}`);
+    return null;
+  }
+}
+//# sourceMappingURL=nativeNotifications.js.map

package/lib/module/push/types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.js.map

package/lib/module/specs/NativeReplaySdk.js

@@ -0,0 +1,24 @@
+import { TurboModuleRegistry } 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 default TurboModuleRegistry.get('ReplaySdk');
+//# sourceMappingURL=NativeReplaySdk.js.map

package/lib/module/specs/NativeScaleBunCrash.js

@@ -0,0 +1,26 @@
+import { TurboModuleRegistry } 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.
+ */
+
+/**
+ * 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`.
+ */
+export default TurboModuleRegistry.get('ScaleBunCrash');
+//# sourceMappingURL=NativeScaleBunCrash.js.map

package/lib/module/specs/NativeScaleBunInstallReferrer.js

@@ -0,0 +1,20 @@
+import { TurboModuleRegistry } 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 default TurboModuleRegistry.get('ScaleBunInstallReferrer');
+//# sourceMappingURL=NativeScaleBunInstallReferrer.js.map

package/lib/module/specs/NativeScaleBunOta.js

@@ -0,0 +1,28 @@
+import { TurboModuleRegistry } 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
+ */
+
+/**
+ * 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`.
+ */
+export default TurboModuleRegistry.get('ScaleBunOta');
+//# sourceMappingURL=NativeScaleBunOta.js.map

package/lib/module/specs/NativeScaleBunPerformance.js

@@ -0,0 +1,21 @@
+import { TurboModuleRegistry } 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 default TurboModuleRegistry.get('ScaleBunPerformance');
+//# sourceMappingURL=NativeScaleBunPerformance.js.map

package/lib/module/specs/NativeScaleBunProfiler.js

@@ -0,0 +1,22 @@
+import { TurboModuleRegistry } 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 default TurboModuleRegistry.get('ScaleBunProfiler');
+//# sourceMappingURL=NativeScaleBunProfiler.js.map

package/lib/module/specs/NativeScaleBunStorage.js

@@ -0,0 +1,36 @@
+import { TurboModuleRegistry } from 'react-native';
+
+/**
+ * React Native Codegen spec for the first-party durable key-value store
+ * (`ScaleBunStorage`).
+ *
+ * This is the SDK's OWN persistence backend — it requires NO third-party storage
+ * library. App developers install nothing: the native module ships inside
+ * `@scalebun/react-native` and persists data to an app-private file
+ * (Android `filesDir/scalebun_kv.json`, iOS Application Support).
+ *
+ * DESIGN — synchronous mirror + async write-through:
+ *   The JS `StorageBackend` contract is synchronous (it is read at module-load
+ *   time, e.g. the device id). RN has no synchronous durable storage in core, so
+ *   this module exposes ONE synchronous method, `getAllSync()`, used exactly
+ *   once during `createStorageBackend()` to hydrate an in-memory mirror. All
+ *   subsequent reads hit that mirror synchronously; writes are mirrored in
+ *   memory and flushed to disk asynchronously through `setItems`/`removeItems`.
+ *   Disk writes are coalesced + atomic (temp-file + rename) on the native side.
+ *
+ * Codegen note: `getAllSync` returns `string` (a JSON object of all key→value
+ * pairs) and is therefore generated as a SYNCHRONOUS JSI method on the New
+ * Architecture; on the Old Architecture it is a blocking synchronous bridge
+ * method. The write methods return `Promise<void>` so they never block the JS
+ * thread.
+ */
+
+/**
+ * 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 the storage layer falls back to an
+ * in-memory backend with a single honest warning. On the Old Architecture the
+ * registry transparently bridges to the legacy `NativeModules.ScaleBunStorage`.
+ */
+export default TurboModuleRegistry.get('ScaleBunStorage');
+//# sourceMappingURL=NativeScaleBunStorage.js.map

package/lib/module/storage/StorageBackend.js

@@ -0,0 +1,231 @@
+/**
+ * ScaleBun SDK — Storage Backend Abstraction
+ *
+ * Pluggable, synchronous key-value storage interface used by the PersistentQueue,
+ * the Engage throttle/test-seen stores, the event tracker identifiers, and the
+ * device id. It is the SDK's single storage seam — no feature talks to a storage
+ * implementation directly.
+ *
+ * DEFAULT BACKEND — first-party, zero third-party dependency:
+ * The default React Native backend (`NativeKVBackend`) is backed by the SDK's
+ * OWN native module (`ScaleBunStorage`), which persists to an app-private file
+ * (Android `filesDir/scalebun_kv.json`, iOS Application Support). App developers
+ * install NOTHING — the native module ships inside `@scalebun/react-native`.
+ *
+ * Because this interface is synchronous (it is read at module-load time) but
+ * native file IO is asynchronous, `NativeKVBackend` keeps a synchronous in-memory
+ * mirror that is hydrated ONCE from the native store via the synchronous
+ * `getAllSync()` method, then kept in sync with the disk through asynchronous,
+ * coalesced write-through (`setItems` / `removeItems`).
+ *
+ * FALLBACK:
+ * If the native module is unavailable (e.g. the app has not rebuilt native code,
+ * web/SSR, or a unit-test environment), the factory falls back to `MemoryBackend`
+ * and logs exactly ONE honest warning per app launch. Data will not survive a
+ * restart in that mode — but the SDK keeps functioning.
+ */
+
+import { logger } from '../core/logger/internalLogger';
+import ScaleBunStorage from '../specs/NativeScaleBunStorage';
+
+// ─── Interface ──────────────────────────────────────────────────────────────
+
+/**
+ * Minimal synchronous key-value storage interface for the persistent queue and
+ * the SDK's small identifiers/state.
+ *
+ * All operations are synchronous. The default native backend satisfies this with
+ * an in-memory mirror over an app-private file (hydrated once at init, written
+ * back asynchronously). Implementations must never throw.
+ */
+
+// ─── MemoryBackend ──────────────────────────────────────────────────────────
+
+/**
+ * In-memory storage backend. Data does NOT survive app restarts.
+ *
+ * Used for:
+ * - Unit tests (no native deps)
+ * - Emergency fallback when the native durable store is unavailable
+ * - Environments where persistence is explicitly disabled
+ */
+export class MemoryBackend {
+  data = new Map();
+  get(key) {
+    return this.data.get(key);
+  }
+  set(key, value) {
+    this.data.set(key, value);
+  }
+  delete(key) {
+    this.data.delete(key);
+  }
+  getAllKeys() {
+    return Array.from(this.data.keys());
+  }
+}
+
+// ─── NativeKVBackend ────────────────────────────────────────────────────────
+
+/**
+ * Minimal shape of the native `ScaleBunStorage` module this backend depends on.
+ * Declared structurally (not imported as the codegen `Spec`) so tests can inject
+ * a plain fake and so the backend never hard-depends on the generated type.
+ */
+
+/**
+ * Durable, first-party storage backed by the SDK's own `ScaleBunStorage` native
+ * module. Data survives app restarts, crashes, and force-kills (modulo the small
+ * window of the most-recent un-flushed write — see below).
+ *
+ * Strategy:
+ *   - On construction, `getAllSync()` loads the entire persisted namespace into a
+ *     synchronous in-memory `Map` (the mirror).
+ *   - Reads (`get` / `getAllKeys`) serve the mirror synchronously.
+ *   - Writes (`set` / `delete`) update the mirror immediately, then enqueue a
+ *     pending change that is flushed to the native store on a microtask. Pending
+ *     sets/deletes for the same key are coalesced; ordering is preserved per key.
+ *
+ * Durability window: a write is in the mirror immediately but reaches disk on the
+ * next flush. A process kill in that sub-millisecond window can lose the most
+ * recent write(s). This matches any async-persistence store and is the price of
+ * not blocking the JS thread on every event. Everything already on disk is safe
+ * and atomically written by the native side.
+ */
+export class NativeKVBackend {
+  /** Keys whose latest value still needs to be pushed to the native store. */
+  pendingSets = new Map();
+  /** Keys whose deletion still needs to be pushed to the native store. */
+  pendingDeletes = new Set();
+  flushScheduled = false;
+  constructor(native) {
+    this.native = native;
+    this.mirror = this._hydrate();
+  }
+
+  /** Load the full persisted namespace synchronously into the mirror. */
+  _hydrate() {
+    const map = new Map();
+    try {
+      const raw = this.native.getAllSync();
+      if (raw) {
+        const obj = JSON.parse(raw);
+        for (const k of Object.keys(obj)) {
+          const v = obj[k];
+          if (typeof v === 'string') map.set(k, v);
+        }
+      }
+    } catch (e) {
+      // A corrupt/unreadable store must not break init — start empty and
+      // let the native side overwrite with the next atomic flush.
+      logger.warn('[StorageBackend] Native store hydrate failed; starting empty this run:', e?.message);
+    }
+    return map;
+  }
+  get(key) {
+    return this.mirror.get(key);
+  }
+  set(key, value) {
+    this.mirror.set(key, value);
+    this.pendingSets.set(key, value);
+    this.pendingDeletes.delete(key);
+    this._scheduleFlush();
+  }
+  delete(key) {
+    this.mirror.delete(key);
+    this.pendingDeletes.add(key);
+    this.pendingSets.delete(key);
+    this._scheduleFlush();
+  }
+  getAllKeys() {
+    return Array.from(this.mirror.keys());
+  }
+
+  /** Coalesce pending writes and flush them to the native store on a microtask. */
+  _scheduleFlush() {
+    if (this.flushScheduled) return;
+    this.flushScheduled = true;
+    // Microtask: batch every synchronous set/delete in the current tick into a
+    // single native round-trip, so a popBatch() of 50 entries is one flush.
+    Promise.resolve().then(() => this._flush());
+  }
+  _flush() {
+    this.flushScheduled = false;
+    try {
+      if (this.pendingSets.size > 0) {
+        const obj = {};
+        for (const [k, v] of this.pendingSets) obj[k] = v;
+        this.pendingSets.clear();
+        void Promise.resolve(this.native.setItems(JSON.stringify(obj)))?.catch?.(() => {});
+      }
+      if (this.pendingDeletes.size > 0) {
+        const keys = Array.from(this.pendingDeletes);
+        this.pendingDeletes.clear();
+        void Promise.resolve(this.native.removeItems(JSON.stringify(keys)))?.catch?.(() => {});
+      }
+    } catch {
+      // Native write-through failure is non-fatal; the mirror remains correct
+      // for this session and the next flush retries newer writes.
+    }
+  }
+}
+
+// ─── Factory ────────────────────────────────────────────────────────────────
+
+/**
+ * Resolve the SDK's native KV module, or null if it isn't present in this
+ * runtime (web/SSR, Jest, or an app that hasn't rebuilt native after upgrading).
+ */
+function getNativeModule() {
+  const mod = ScaleBunStorage;
+  if (mod && typeof mod.getAllSync === 'function') return mod;
+  return null;
+}
+
+/**
+ * Shared singleton — `createStorageBackend()` must return the SAME instance to
+ * every caller so the in-memory mirror, the pending-write queue, and the
+ * one-time fallback warning are not duplicated across features.
+ */
+let sharedBackend = null;
+
+/**
+ * Create (once) and return the shared storage backend for the current
+ * environment.
+ *
+ * Selection order:
+ *   1. `NativeKVBackend` over the first-party `ScaleBunStorage` native module
+ *      (durable, app-private file — the default for React Native).
+ *   2. `MemoryBackend` (emergency fallback — no persistence), with exactly ONE
+ *      honest warning per launch. The warning never mentions any third-party
+ *      library.
+ *
+ * Idempotent: subsequent calls return the cached instance.
+ */
+export function createStorageBackend() {
+  if (sharedBackend) return sharedBackend;
+  const native = getNativeModule();
+  if (native) {
+    try {
+      sharedBackend = new NativeKVBackend(native);
+      __DEV__ && logger.debug('[StorageBackend] Using native durable backend (ScaleBunStorage)');
+      return sharedBackend;
+    } catch (e) {
+      logger.warn('[StorageBackend] Native durable store failed to initialize; ' + 'using in-memory storage for this launch — events may not survive an app restart:', e?.message);
+      sharedBackend = new MemoryBackend();
+      return sharedBackend;
+    }
+  }
+  logger.warn('[StorageBackend] Native durable store unavailable; using in-memory storage ' + 'for this launch — events may not survive an app restart. ' + 'Rebuild the app with the ScaleBun native module to enable disk persistence.');
+  sharedBackend = new MemoryBackend();
+  return sharedBackend;
+}
+
+/**
+ * TEST-ONLY: reset the shared backend singleton so each test can exercise the
+ * factory's selection logic from a clean slate.
+ */
+export function __resetStorageBackendForTests() {
+  sharedBackend = null;
+}
+//# sourceMappingURL=StorageBackend.js.map

package/lib/module/storage/db/sqlite.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=sqlite.js.map

package/lib/module/storage/files/fileStore.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=fileStore.js.map

package/lib/module/transport/auth/sdkSession.js

@@ -0,0 +1,21 @@
+export class SdkSessionManager {
+  setSession(token, expiresIn) {
+    this.token = token;
+    this.expiresAt = Date.now() + expiresIn * 1000;
+  }
+  getToken() {
+    if (this.token && this.expiresAt && Date.now() < this.expiresAt) {
+      return this.token;
+    }
+    return undefined;
+  }
+  isExpired() {
+    return !this.getToken();
+  }
+  clear() {
+    this.token = undefined;
+    this.expiresAt = undefined;
+  }
+}
+export const sdkSession = new SdkSessionManager();
+//# sourceMappingURL=sdkSession.js.map

package/lib/module/transport/backoff/exponentialJitter.js

@@ -0,0 +1,10 @@
+/**
+ * Exponential backoff with jitter.
+ */
+export function getDelayWithJitter(attempt, base = 1000) {
+  const cap = 30000;
+  const delay = Math.min(cap, base * Math.pow(2, attempt));
+  const jitter = delay * 0.2 * Math.random();
+  return delay + jitter;
+}
+//# sourceMappingURL=exponentialJitter.js.map

package/lib/module/transport/http/endpoints.js

@@ -0,0 +1,40 @@
+export const ENDPOINTS = {
+  // Legacy replay endpoints (backward compat)
+  SESSIONS: '/sdk/sessions',
+  EVENTS: '/sdk/events',
+  // SaaS ingestion endpoints
+  INGESTION_START: '/ingestion/sessions',
+  INGESTION_IDENTIFY: id => `/ingestion/sessions/${id}/identify`,
+  INGESTION_FRAMES: id => `/ingestion/sessions/${id}/frames`,
+  INGESTION_FRAMES_PRESIGN: id => `/ingestion/sessions/${id}/frames/presign`,
+  INGESTION_EVENTS: id => `/ingestion/sessions/${id}/events`,
+  INGESTION_NETWORK: id => `/ingestion/sessions/${id}/network`,
+  INGESTION_LOGS: id => `/ingestion/sessions/${id}/logs`,
+  INGESTION_ERRORS: id => `/ingestion/sessions/${id}/errors`,
+  INGESTION_PERFORMANCE: id => `/ingestion/sessions/${id}/performance`,
+  INGESTION_FINALIZE: id => `/ingestion/sessions/${id}/finalize`,
+  INGESTION_RATING: id => `/ingestion/sessions/${id}/rating`,
+  INGESTION_RATING_STANDALONE: '/ingestion/ratings',
+  // Rating-funnel event lane (ratings-rebuild CONTRACT §1.2). Batch POST of the
+  // 5 closed funnel events; deduped server-side on client eventId (D8).
+  INGESTION_RATING_EVENTS: '/ingestion/rating-events',
+  // Engage surface (CONTRACT.md §1.3 / §3) — config serve + upload lanes.
+  // Config is a function so app/user context can be passed as query params for
+  // server-side targeting/throttle evaluation; uploads are plain POST constants.
+  ENGAGE_CONFIG: query => `/sdk/engage/config${query ? `?${query}` : ''}`,
+  // GET (D3 serve lane)
+  COACH_CONFIG: preview => `/sdk/coach/config${preview ? `?preview=${encodeURIComponent(preview)}` : ''}`,
+  ENGAGE_RESPONSES: '/sdk/engage/responses',
+  // POST (campaign responses)
+  ENGAGE_EVENTS: '/sdk/engage/events',
+  // POST (in-app impression/click/dismiss)
+  ENGAGE_SURVEY_IMPRESSIONS: '/sdk/engage/surveys/impressions',
+  // POST (shown/started funnel beacons)
+  ENGAGE_DEVICE_TOKEN: '/sdk/engage/device-token',
+  // POST (push-token registration)
+  ENGAGE_ATTACHMENTS_PRESIGN: '/sdk/engage/attachments/presign',
+  // POST (screenshot/voice presign)
+  // OTA (Over-the-Air Updates) — check endpoint for bundle availability.
+  OTA_CHECK: '/sdk/ota/check' // POST (Sprint 1: returns { action: 'NONE' })
+};
+//# sourceMappingURL=endpoints.js.map