@obsrviq/react-native 0.3.1 → 0.3.2

package/README.md

@@ -1,8 +1,8 @@
 # @obsrviq/react-native
 
-Mobile session replay + analytics capture for **React Native (iOS + Android)**, feeding the same Lumera backend as the web tracker. Engineered around one non-negotiable: **zero added latency on the device.**
+Mobile session replay + analytics capture for **React Native (iOS + Android)**, feeding the same Obsrviq backend as the web tracker. Engineered around one non-negotiable: **zero added latency on the device.**
 
-> **Status: in development.** The pure-JS layer (public API, session/identity, network/error/console capture, transport) is implemented. The native screenshot-capture TurboModule (iOS Swift / Android Kotlin), the backend frame-storage path, and the mobile player renderer are in progress — see [Roadmap](#roadmap).
+> **Status: shipped.** The full pipeline is live — the pure-JS layer (public API, session/identity, network/error/console capture, transport), the native screenshot-capture TurboModule (iOS Swift / Android Kotlin), native touch capture, the backend frame-storage path, and the mobile player renderer (screenshot timeline + touch ripples + network waterfall). Native code is compiled inside the consuming app's iOS/Android build — see [Building](#building-native).
 
 ---
 
@@ -59,29 +59,55 @@ Requires React Native ≥ 0.76 (New Architecture). Works under the old architect
 ## Quickstart
 
 ```ts
-import { LumeraReplay } from '@obsrviq/react-native';
+import { ObsrviqReplay } from '@obsrviq/react-native';
 
-LumeraReplay.init({
+ObsrviqReplay.init({
   siteKey: 'pk_live_…',
-  // privacy-by-default: all text + images masked. Opt out per-view with <LumeraMask unmask>.
+  // privacy-by-default: all text + images masked. Opt out per-view with <ObsrviqMask unmask>.
 });
 
 // later — identical API to the web SDK:
-LumeraReplay.identify('user_123', { plan: 'pro' });
-LumeraReplay.track('checkout_started', { cart: 3 });
-LumeraReplay.conversion('purchase', { value: 49.0 });
-LumeraReplay.tag('vip', 'beta');
+ObsrviqReplay.identify('user_123', { plan: 'pro' });
+ObsrviqReplay.track('checkout_started', { cart: 3 });
+ObsrviqReplay.conversion('purchase', { value: 49.0 });
+ObsrviqReplay.tag('vip', 'beta');
 ```
 
+> **Naming:** the SDK is `ObsrviqReplay` / `ObsrviqConfig` / `<ObsrviqMask>`. The old
+> `LumeraReplay` / `LumeraConfig` / `<LumeraMask>` names are still exported as **deprecated
+> aliases**, so pre-rebrand integrations keep working unchanged.
+
 ## API
 
-Mirrors `@obsrviq/tracker` 1:1 — `init`, `identify`, `setMetadata`, `track`, `conversion`, `tag`, `startTask`/`endTask`, `setConsent`, `reset`, `stop`, `flush`, `getDiagnostics`, `sessionId`. See [`src/config.ts`](src/config.ts) for the full config.
+Mirrors `@obsrviq/tracker` 1:1 — `init`, `identify`, `setMetadata`, `track`, `conversion`, `tag`, `startTask`/`endTask`, `setConsent`, `reset`, `stop`, `flush`, `getDiagnostics`, `sessionId`. `screen(name)` records a route view (the mobile analog of a web pageview — call it from your navigation listener).
+
+## Config
+
+Passed to `init({ siteKey, … })`. See [`src/config.ts`](src/config.ts) for the authoritative list.
+
+| Option | Default | What it does |
+|---|---|---|
+| `siteKey` | — | **Required.** Your ingest key (`pk_…`). |
+| `enableReplay` | `true` | Record the screen (native screenshot stream). |
+| `fps` | `1` | Capture cadence cap, frames/sec (change-driven underneath). |
+| `jpegQuality` | `0.4` | JPEG quality 0..1 on the encode path. |
+| `maxCaptureDim` | `1200` | Cap the longer edge of each frame (px) — the storage/bandwidth lever. `0` = full native res. |
+| `maskAllText` | `true` | Mask all text before any pixel is persisted. |
+| `maskAllImages` | `true` | Mask all images/media. |
+| `captureTouches` | `true` | Capture taps + swipes as a touch overlay (native, non-blocking gesture observer — never interferes with the app's own gestures). |
+| `captureNetworkBodies` | `false` | Capture request + response bodies (masked, size-capped at 8KB). Off by default — bodies can hold PII. |
+| `redactHeaders` | `['authorization','cookie','set-cookie']` | Header allowlist redaction for captured network events. |
+| `captureConsole` | `true` | Mirror `console.*` into the session. |
+| `sampleRate` | `1` | Fraction of sessions recorded (0..1). |
+| `continueSession` | `false` | Resume the same session across foreground/background within the window. |
+| `requireConsent` | `false` | Gate all recording until `setConsent(true)`. |
 
 ## Privacy / masking
 
 - **Default:** all text and images are masked before any pixel is persisted (masking runs on the capture thread, pre-encode).
-- **Per-view control:** `<LumeraMask>` / `<LumeraMask unmask>` wrappers (call `setViewMasked(reactTag, …)` natively). *(component pending — task #95/#96)*
-- Network header redaction (`authorization`/`cookie`/`set-cookie` by default), bodies off by default.
+- **Per-view control:** `<ObsrviqMask>` / `<ObsrviqMask unmask>` wrappers (call `setViewMasked(reactTag, …)` natively).
+- Network: header allowlist redaction (`authorization`/`cookie`/`set-cookie` by default). Request/response **bodies are off by default** — opt in with `captureNetworkBodies: true` (bodies are size-capped at 8KB and can hold personal data, so enable deliberately).
+- Touch capture records only coordinates + phase (start/move/end) — never the content under the finger.
 
 ## Data flow
 
@@ -91,18 +117,21 @@ Two independent uploaders, one session:
 |---|---|---|---|---|
 | Structured (network/error/console/custom) | JS | `POST /v1/batch` | `network`/`error`/`console`/`custom` | Postgres `events` |
 | Screenshot frames | **Native** | `POST /v1/batch` | `screen` | blob + `mobile_frames` index |
+| Touch (taps/swipes) | **Native** | `POST /v1/batch` | `touch` | Postgres `events` (synced to the timeline by `t`) |
 
-Both share `siteKey` + `sessionId`. No `seq` collision: structured events never write replay chunks; `screen` frames get their own frame index. The ingest endpoint already accepts new event types (permissive validation), so **no ingest change is needed** — only a worker routing rule for `type:'screen'`.
+All three share `siteKey` + `sessionId`. No `seq` collision: structured events never write replay chunks; `screen` frames get their own frame index; `touch` events are small and land in the `events` table. The worker routes `screen` to the blob store + `mobile_frames`, keeps everything else (including `touch`) in `events`. The player overlays `touch` events as ripples and renders `network` events as a per-request waterfall with an expandable headers/body inspector.
 
 ## Roadmap
 
 - [x] JS core — public API, session/identity, network/error/console capture, transport (`src/`)
-- [x] Wire format — `MobileScreenEvent` (`type:'screen'`) + `MobileTouchEvent` in `@obsrviq/types`
-- [ ] Native iOS capture (Swift TurboModule) — `ios/` *(task #95)*
-- [ ] Native Android capture (Kotlin TurboModule) — `android/` *(task #96)*
-- [ ] Backend — route `type:'screen'` to blob + `mobile_frames`, migration *(task #97)*
-- [ ] Player — mobile screenshot renderer + device-based routing *(task #98)*
+- [x] Wire format — `MobileScreenEvent` (`type:'screen'`) + `MobileTouchEvent` (`type:'touch'`) in `@obsrviq/types`
+- [x] Native iOS capture (Swift TurboModule) — screenshots + touch observer — `ios/`
+- [x] Native Android capture (Kotlin TurboModule) — screenshots + touch observer — `android/`
+- [x] Backend — route `type:'screen'` to blob + `mobile_frames`, `touch` to `events` (migration 017)
+- [x] Player — mobile screenshot renderer + device-based routing + touch ripples + network waterfall/inspector
+- [x] `<ObsrviqMask>` / `<ObsrviqMask unmask>` per-view privacy component (iOS + Android)
+- [x] Network request/response **body** capture (opt-in, `captureNetworkBodies`)
 
 ## Building (native)
 
-Native code can't be compiled in the SDK repo — build it inside a real RN app and test on devices (jank only shows on hardware, especially low-end). Codegen runs automatically during the app's iOS/Android build from [`src/spec/NativeLumeraReplay.ts`](src/spec/NativeLumeraReplay.ts).
+Native code can't be compiled in the SDK repo — build it inside a real RN app and test on devices (jank only shows on hardware, especially low-end). Codegen runs automatically during the app's iOS/Android build from [`src/spec/NativeObsrviqReplay.ts`](src/spec/NativeObsrviqReplay.ts).

package/android/build.gradle

@@ -8,7 +8,7 @@ apply plugin: "org.jetbrains.kotlin.android"   // REQUIRED: sources are Kotlin
 apply plugin: "com.facebook.react"   // enables New-Arch codegen for the TurboModule
 
 android {
-  namespace "app.lumera.replay"
+  namespace "app.obsrviq.replay"
   compileSdkVersion safeExtGet("compileSdkVersion", 35)
 
   defaultConfig {

package/android/src/main/java/app/obsrviq/replay/ObsrviqMaskViewManager.kt

@@ -0,0 +1,42 @@
+package app.obsrviq.replay
+
+import android.view.View
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+
+/**
+ * Backs the optional `<ObsrviqMask>` JS component. It is a plain pass-through container
+ * (children render normally); its sole job is to tell the capture engine "redact my
+ * subtree". On attach it registers its own View.id in [ObsrviqReplayModule.maskedTags];
+ * on detach it removes it. This is the geometry [ObsrviqReplayModule.collectMaskRects]
+ * walks: an explicitly-masked container yields one redaction block over the whole subtree.
+ *
+ * Kept deliberately minimal — no custom props, no shadow node. JS can also drive masking
+ * imperatively via `NativeObsrviqReplay.setViewMasked(reactTag, masked)` without this view.
+ */
+@ReactModule(name = ObsrviqMaskViewManager.REACT_CLASS)
+class ObsrviqMaskViewManager : SimpleViewManager<View>() {
+
+  override fun getName() = REACT_CLASS
+
+  override fun createViewInstance(reactContext: ThemedReactContext): View =
+    object : View(reactContext) {
+      override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        ObsrviqReplayModule.maskTag(id)
+      }
+
+      override fun onDetachedFromWindow() {
+        ObsrviqReplayModule.unmaskTag(id)
+        super.onDetachedFromWindow()
+      }
+    }
+
+  companion object {
+    // Must match the JS requireNativeComponent name + the iOS RCT_EXPORT_MODULE name.
+    // (Was "LumeraMask" on Android while iOS/JS used "LumeraMaskView" — a name mismatch
+    // that silently disabled the mask component on Android. Unified to "ObsrviqMaskView".)
+    const val REACT_CLASS = "ObsrviqMaskView"
+  }
+}

package/android/src/main/java/app/{lumera/replay/LumeraReplayModule.kt → obsrviq/replay/ObsrviqReplayModule.kt}

@@ -1,4 +1,4 @@
-package app.lumera.replay
+package app.obsrviq.replay
 
 import android.graphics.Bitmap
 import android.graphics.Canvas
@@ -30,7 +30,7 @@ import java.util.UUID
 import java.util.concurrent.atomic.AtomicBoolean
 
 /**
- * Lumera native screenshot-replay capture engine (Android).
+ * Obsrviq native screenshot-replay capture engine (Android).
  *
  * THREADING CONTRACT:
  *   • UI thread → only schedules a PixelCopy (which is async) + a cheap mask-rect walk.
@@ -41,14 +41,14 @@ import java.util.concurrent.atomic.AtomicBoolean
  * which misses hardware-accelerated content. One reused RGB_565 bitmap. No pixels
  * cross the RN bridge: this engine uploads frames itself to `${endpoint}/v1/batch`.
  *
- * NOTE: extends the codegen'd `NativeLumeraReplaySpec` (New Arch). The
- * `LumeraReplayPackage` registers it as the TurboModule named "LumeraReplay".
+ * NOTE: extends the codegen'd `NativeObsrviqReplaySpec` (New Arch). The
+ * `ObsrviqReplayPackage` registers it as the TurboModule named "ObsrviqReplay".
  */
-class LumeraReplayModule(private val reactCtx: ReactApplicationContext) :
-  NativeLumeraReplaySpec(reactCtx) {
+class ObsrviqReplayModule(private val reactCtx: ReactApplicationContext) :
+  NativeObsrviqReplaySpec(reactCtx) {
 
   // Dedicated background thread for ALL post-capture work (PixelCopy callback + encode + upload).
-  private val bgThread = HandlerThread("lumera-replay").apply { start() }
+  private val bgThread = HandlerThread("obsrviq-replay").apply { start() }
   private val bg = Handler(bgThread.looper)
 
   private var opts: ReadableStartOptions? = null
@@ -81,7 +81,7 @@ class LumeraReplayModule(private val reactCtx: ReactApplicationContext) :
   private var framesDropped = 0
   private var bytesSent = 0L
 
-  override fun getName() = "LumeraReplay"
+  override fun getName() = "ObsrviqReplay"
 
   // MARK: - Lifecycle
 
@@ -323,7 +323,7 @@ class LumeraReplayModule(private val reactCtx: ReactApplicationContext) :
    * Walk the decorView on the UI thread → redaction rects (in captured-pixel space) for
    * masked nodes: TextView/EditText when [ReadableStartOptions.maskAllText], ImageView when
    * [ReadableStartOptions.maskAllImages]. A view whose id (RN reactTag) is in [maskedTags]
-   * — set via `setViewMasked(tag, true)` or `<LumeraMask>` — is force-masked along with its
+   * — set via `setViewMasked(tag, true)` or `<ObsrviqMask>` — is force-masked along with its
    * whole subtree (one block), regardless of mask-all. Rect = getLocationInWindow + width/height.
    *
    * Honoring per-view UN-masking under mask-all (force-unmask) would need a second, explicit
@@ -397,7 +397,7 @@ class LumeraReplayModule(private val reactCtx: ReactApplicationContext) :
 
   /**
    * Assemble ONE `IngestBatch` from buffered `screen` events and POST it to
-   * `${endpoint}/v1/batch` (HttpURLConnection on `bg`, x-lumera-key header, plain JSON).
+   * `${endpoint}/v1/batch` (HttpURLConnection on `bg`, x-obsrviq-key header, plain JSON).
    * On HTTP 2xx: bump counters + ++seq. On failure: re-queue (prepend so order holds).
    */
   private fun flush() {
@@ -462,7 +462,7 @@ class LumeraReplayModule(private val reactCtx: ReactApplicationContext) :
         // octet-stream, NOT application/json — the ingest reads the raw body buffer and
         // sniffs gzip itself; application/json hits Fastify's JSON parser → 400 empty_body.
         setRequestProperty("content-type", "application/octet-stream")
-        setRequestProperty("x-lumera-key", o.siteKey)
+        setRequestProperty("x-obsrviq-key", o.siteKey)
         setFixedLengthStreamingMode(payload.size)
       }
       conn.outputStream.use { os: OutputStream -> os.write(payload) }
@@ -517,8 +517,8 @@ class LumeraReplayModule(private val reactCtx: ReactApplicationContext) :
   companion object {
     /**
      * Process-wide set of explicitly-masked View ids (RN reactTags). Shared so both the
-     * TurboModule (`setViewMasked`) and the `<LumeraMask>` view manager
-     * ([LumeraMaskViewManager]) feed the same registry the capture walk reads. A
+     * TurboModule (`setViewMasked`) and the `<ObsrviqMask>` view manager
+     * ([ObsrviqMaskViewManager]) feed the same registry the capture walk reads. A
      * ConcurrentHashMap-backed set: written from the UI thread, read on `bg`.
      */
     private val maskedTags: MutableSet<Int> =

package/android/src/main/java/app/{lumera/replay/LumeraReplayPackage.kt → obsrviq/replay/ObsrviqReplayPackage.kt}

@@ -1,4 +1,4 @@
-package app.lumera.replay
+package app.obsrviq.replay
 
 import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
@@ -8,30 +8,30 @@ import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
 
 /**
- * TurboModule package for the Lumera native capture engine.
+ * TurboModule package for the Obsrviq native capture engine.
  *
  * Registered by the host app (autolinking via react-native.config.js, or manually in
  * MainApplication's `getPackages()`). Exposes the New-Architecture TurboModule named
- * "LumeraReplay" plus the optional <LumeraMask> view manager.
+ * "ObsrviqReplay" plus the optional <ObsrviqMask> view manager.
  *
  * Uses [BaseReactPackage] (RN 0.76+) — `getModule(name, ctx)` is resolved lazily by the
  * TurboModule infrastructure, and [getReactModuleInfoProvider] marks the module
  * `isTurboModule = true` so it is loaded over JSI (never the legacy bridge).
  */
-class LumeraReplayPackage : BaseReactPackage() {
+class ObsrviqReplayPackage : BaseReactPackage() {
 
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
     when (name) {
-      LumeraReplayModuleName -> LumeraReplayModule(reactContext)
+      ObsrviqReplayModuleName -> ObsrviqReplayModule(reactContext)
       else -> null
     }
 
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
     ReactModuleInfoProvider {
       mapOf(
-        LumeraReplayModuleName to ReactModuleInfo(
-          /* name = */ LumeraReplayModuleName,
-          /* className = */ LumeraReplayModule::class.java.name,
+        ObsrviqReplayModuleName to ReactModuleInfo(
+          /* name = */ ObsrviqReplayModuleName,
+          /* className = */ ObsrviqReplayModule::class.java.name,
           /* canOverrideExistingModule = */ false,
           /* needsEagerInit = */ false,
           /* isCxxModule = */ false,
@@ -40,11 +40,11 @@ class LumeraReplayPackage : BaseReactPackage() {
       )
     }
 
-  // View managers are not TurboModules; supply the optional <LumeraMask> manager directly.
+  // View managers are not TurboModules; supply the optional <ObsrviqMask> manager directly.
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
-    listOf(LumeraMaskViewManager())
+    listOf(ObsrviqMaskViewManager())
 
   private companion object {
-    const val LumeraReplayModuleName = "LumeraReplay"
+    const val ObsrviqReplayModuleName = "ObsrviqReplay"
   }
 }

package/ios/{LumeraMaskView.h → ObsrviqMaskView.h}

@@ -3,7 +3,7 @@
 NS_ASSUME_NONNULL_BEGIN
 
 /**
- * Backing native view for the <LumeraMask> RN component. It is a plain pass-through
+ * Backing native view for the <ObsrviqMask> RN component. It is a plain pass-through
  * container (children render normally); its only job is to register/unregister its RN
  * `reactTag` with the capture engine so the region it occupies is masked (or, with
  * `masked={false}`, explicitly UN-masked — overriding the global maskAll* defaults).
@@ -11,7 +11,7 @@ NS_ASSUME_NONNULL_BEGIN
  * The mask itself is composited natively off the UI thread during capture — this view
  * adds no per-frame cost and never rasterizes anything.
  */
-@interface LumeraMaskView : UIView
+@interface ObsrviqMaskView : UIView
 /** YES → mask this subtree; NO → force-unmask it. Default YES. */
 @property (nonatomic, assign) BOOL masked;
 @end

package/ios/{LumeraMaskView.m → ObsrviqMaskView.m}

@@ -1,22 +1,22 @@
-#import "LumeraMaskView.h"
+#import "ObsrviqMaskView.h"
 #import <React/RCTComponent.h>
 
-// The capture engine's @objc surface (see LumeraReplay.swift). Mirrors the umbrella-
-// header resolution in LumeraReplayModule.mm; we only need `shared` + setViewMasked here.
-#if __has_include(<lumera_react_native/lumera_react_native-Swift.h>)
-#import <lumera_react_native/lumera_react_native-Swift.h>
-#elif __has_include("lumera_react_native-Swift.h")
-#import "lumera_react_native-Swift.h"
-#elif __has_include("LumeraReactNative-Swift.h")
-#import "LumeraReactNative-Swift.h"
+// The capture engine's @objc surface (see ObsrviqReplay.swift). Mirrors the umbrella-
+// header resolution in ObsrviqReplayModule.mm; we only need `shared` + setViewMasked here.
+#if __has_include(<obsrviq_react_native/obsrviq_react_native-Swift.h>)
+#import <obsrviq_react_native/obsrviq_react_native-Swift.h>
+#elif __has_include("obsrviq_react_native-Swift.h")
+#import "obsrviq_react_native-Swift.h"
+#elif __has_include("ObsrviqReactNative-Swift.h")
+#import "ObsrviqReactNative-Swift.h"
 #else
-@interface LumeraReplay : NSObject
-@property (class, nonatomic, readonly, strong) LumeraReplay *shared;
+@interface ObsrviqReplay : NSObject
+@property (class, nonatomic, readonly, strong) ObsrviqReplay *shared;
 - (void)setViewMasked:(NSNumber *)reactTag masked:(NSNumber *)masked;
 @end
 #endif
 
-@implementation LumeraMaskView
+@implementation ObsrviqMaskView
 
 - (instancetype)init
 {
@@ -63,7 +63,7 @@
   // registering → honor the `masked` prop (YES = mask, NO = force-unmask).
   // !registering (leaving the tree) → clear the entry by unmasking.
   BOOL value = registering ? self.masked : NO;
-  [LumeraReplay.shared setViewMasked:tag masked:@(value)];
+  [ObsrviqReplay.shared setViewMasked:tag masked:@(value)];
 }
 
 - (void)dealloc
@@ -72,7 +72,7 @@
   // without a willMoveToSuperview:nil (shouldn't happen, but tags must not leak).
   NSNumber *tag = self.reactTag;
   if (tag != nil) {
-    [LumeraReplay.shared setViewMasked:tag masked:@(NO)];
+    [ObsrviqReplay.shared setViewMasked:tag masked:@(NO)];
   }
 }
 

package/ios/{LumeraMaskViewManager.m → ObsrviqMaskViewManager.m}

@@ -1,21 +1,21 @@
 #import <React/RCTViewManager.h>
-#import "LumeraMaskView.h"
+#import "ObsrviqMaskView.h"
 
 /**
- * View manager for the <LumeraMask> RN component (registered as native component
- * "LumeraMaskView"). It exposes a single `masked` prop and returns a LumeraMaskView,
+ * View manager for the <ObsrviqMask> RN component (registered as native component
+ * "ObsrviqMaskView"). It exposes a single `masked` prop and returns a ObsrviqMaskView,
  * which (un)registers its reactTag with the capture engine on mount/unmount.
  *
  * The package's codegenConfig is `type: "modules"` (TurboModule only — no Fabric
  * component spec), so this legacy RCTViewManager is the right minimal surface: RN's
  * view interop layer bridges it under both the old and new architectures.
  */
-@interface LumeraMaskViewManager : RCTViewManager
+@interface ObsrviqMaskViewManager : RCTViewManager
 @end
 
-@implementation LumeraMaskViewManager
+@implementation ObsrviqMaskViewManager
 
-RCT_EXPORT_MODULE(LumeraMaskView)
+RCT_EXPORT_MODULE(ObsrviqMaskView)
 
 RCT_EXPORT_VIEW_PROPERTY(masked, BOOL)
 
@@ -23,7 +23,7 @@ RCT_EXPORT_VIEW_PROPERTY(masked, BOOL)
 
 - (UIView *)view
 {
-  return [LumeraMaskView new];
+  return [ObsrviqMaskView new];
 }
 
 @end

package/ios/{LumeraReplay.swift → ObsrviqReplay.swift}

@@ -3,7 +3,7 @@ import UIKit
 import UIKit.UIGestureRecognizerSubclass   // touchesBegan/Moved/Ended overrides
 
 /**
- * Lumera native screenshot-replay capture engine (iOS).
+ * Obsrviq native screenshot-replay capture engine (iOS).
  *
  * THREADING CONTRACT (the whole point):
  *   • UI thread  → TWO things only: the `view.drawHierarchy(in:afterScreenUpdates:false)`
@@ -17,11 +17,11 @@ import UIKit.UIGestureRecognizerSubclass   // touchesBegan/Moved/Ended overrides
  * (independent of the JS structured-event stream's seq; the worker keys frames by
  * event id, not seq, so the two streams never collide).
  *
- * Reached from the ObjC++ TurboModule bridge (LumeraReplayModule.mm) via the `@objc`
+ * Reached from the ObjC++ TurboModule bridge (ObsrviqReplayModule.mm) via the `@objc`
  * wrappers at the bottom of this file.
  */
-@objc(LumeraReplay)
-final class LumeraReplay: NSObject {
+@objc(ObsrviqReplay)
+final class ObsrviqReplay: NSObject {
 
   struct Options {
     var endpoint: String
@@ -39,10 +39,10 @@ final class LumeraReplay: NSObject {
 
   /// One process-wide instance — the bridge forwards every call here so the JS
   /// surface (start/stop/configure/mask/diagnostics) talks to a single engine.
-  @objc static let shared = LumeraReplay()
+  @objc static let shared = ObsrviqReplay()
 
   // Serial background queue: ALL post-capture work (mask/encode/JSON/upload) lands here.
-  private let work = DispatchQueue(label: "app.lumera.replay.work", qos: .utility)
+  private let work = DispatchQueue(label: "app.obsrviq.replay.work", qos: .utility)
   // URLSession on the background queue — uploads never touch the JS bridge or main thread.
   private let session: URLSession = {
     let cfg = URLSessionConfiguration.default
@@ -102,7 +102,7 @@ final class LumeraReplay: NSObject {
       // Passive touch observer: a non-consuming gesture recognizer on the key window
       // records taps + swipes without interfering with the app's own gestures.
       if opts.captureTouches, self.touchRecognizer == nil, let window = self.keyWindow() {
-        let r = LumeraTouchRecognizer(target: self, action: #selector(self.touchNoop))
+        let r = ObsrviqTouchRecognizer(target: self, action: #selector(self.touchNoop))
         r.sink = self
         window.addGestureRecognizer(r)
         self.touchRecognizer = r
@@ -485,7 +485,7 @@ final class LumeraReplay: NSObject {
 
     var req = URLRequest(url: url)
     req.httpMethod = "POST"
-    req.setValue(opts.siteKey, forHTTPHeaderField: "x-lumera-key")
+    req.setValue(opts.siteKey, forHTTPHeaderField: "x-obsrviq-key")
     // octet-stream, NOT application/json — the ingest reads the raw body buffer and
     // sniffs gzip itself; application/json hits Fastify's JSON parser → 400 empty_body.
     req.setValue("application/octet-stream", forHTTPHeaderField: "content-type")
@@ -615,7 +615,7 @@ final class LumeraReplay: NSObject {
   /// RFC 4122 v4 UUID for frame ids (the worker keys frame blobs by this — must be unique).
   private static func uuidv4() -> String { UUID().uuidString.lowercased() }
 
-  // MARK: - @objc bridge surface (called from LumeraReplayModule.mm)
+  // MARK: - @objc bridge surface (called from ObsrviqReplayModule.mm)
   //
   // The ObjC++ TurboModule passes NSDictionary option maps straight through; these
   // wrappers unbox them into the Swift `Options` struct and forward to the real methods.
@@ -671,8 +671,8 @@ final class LumeraReplay: NSObject {
 /// A passive (non-consuming) touch observer added to the key window. Records taps +
 /// swipe samples and forwards them to the engine without interfering with the app's
 /// own gesture handling (cancelsTouchesInView = false; it never claims a gesture).
-final class LumeraTouchRecognizer: UIGestureRecognizer {
-  weak var sink: LumeraReplay?
+final class ObsrviqTouchRecognizer: UIGestureRecognizer {
+  weak var sink: ObsrviqReplay?
 
   override init(target: Any?, action: Selector?) {
     super.init(target: target, action: action)

package/ios/ObsrviqReplayModule.h

@@ -0,0 +1,20 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * The native screenshot-capture TurboModule, exposed to JS as "ObsrviqReplay".
+ *
+ * This thin ObjC++ shell exists only to satisfy React Native's codegen'd New-Arch
+ * protocol (NativeObsrviqReplaySpec, generated from src/spec/NativeObsrviqReplay.ts via
+ * the `ObsrviqReplaySpec` codegen target) and to forward each call to the shared Swift
+ * engine `ObsrviqReplay`, which owns the entire capture → mask → encode → upload loop.
+ *
+ * No capture logic lives here. The implementation (.mm) conforms to the generated
+ * <NativeObsrviqReplaySpec> protocol and implements `getTurboModule:` for the New Arch.
+ */
+@interface ObsrviqReplayModule : NSObject <RCTBridgeModule>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/{LumeraReplayModule.mm → ObsrviqReplayModule.mm}

@@ -1,23 +1,23 @@
-#import "LumeraReplayModule.h"
+#import "ObsrviqReplayModule.h"
 
-// The Swift engine (LumeraReplay, @objc-exposed) is surfaced to ObjC++ through the
+// The Swift engine (ObsrviqReplay, @objc-exposed) is surfaced to ObjC++ through the
 // pod's auto-generated Swift umbrella header. CocoaPods names it
-// "<module_name>-Swift.h"; for this pod (`lumera-react-native`) Clang sanitizes that
-// to `lumera_react_native-Swift.h`. We tolerate either spelling so the bridge builds
+// "<module_name>-Swift.h"; for this pod (`obsrviq-react-native`) Clang sanitizes that
+// to `obsrviq_react_native-Swift.h`. We tolerate either spelling so the bridge builds
 // whether the host app links us as a pod (umbrella under the pod name) or compiles the
 // sources into the app target (umbrella under the app's product module name).
-#if __has_include(<lumera_react_native/lumera_react_native-Swift.h>)
-#import <lumera_react_native/lumera_react_native-Swift.h>
-#elif __has_include("lumera_react_native-Swift.h")
-#import "lumera_react_native-Swift.h"
-#elif __has_include("LumeraReactNative-Swift.h")
-#import "LumeraReactNative-Swift.h"
+#if __has_include(<obsrviq_react_native/obsrviq_react_native-Swift.h>)
+#import <obsrviq_react_native/obsrviq_react_native-Swift.h>
+#elif __has_include("obsrviq_react_native-Swift.h")
+#import "obsrviq_react_native-Swift.h"
+#elif __has_include("ObsrviqReactNative-Swift.h")
+#import "ObsrviqReactNative-Swift.h"
 #else
 // Fallback: forward-declare the @objc surface we call so the bridge still compiles if
 // the umbrella header name differs in a given app. The linker resolves it from the
 // Swift object at link time.
-@interface LumeraReplay : NSObject
-@property (class, nonatomic, readonly, strong) LumeraReplay *shared;
+@interface ObsrviqReplay : NSObject
+@property (class, nonatomic, readonly, strong) ObsrviqReplay *shared;
 - (void)startWithOptions:(NSDictionary *)options;
 - (void)stopObjc;
 - (void)configureWithOptions:(NSDictionary *)options;
@@ -26,19 +26,19 @@
 @end
 #endif
 
-// The codegen'd New-Arch spec header (target name `LumeraReplaySpec`, from
+// The codegen'd New-Arch spec header (target name `ObsrviqReplaySpec`, from
 // package.json → codegenConfig.name). Present only when codegen has run (i.e. inside a
 // real app build with the New Architecture). Guarded so this file also compiles on the
 // old architecture, where the RCT_EXPORT_METHOD declarations below carry the module.
 #ifdef RCT_NEW_ARCH_ENABLED
-#import <LumeraReplaySpec/LumeraReplaySpec.h>
+#import <ObsrviqReplaySpec/ObsrviqReplaySpec.h>
 #endif
 
-@implementation LumeraReplayModule
+@implementation ObsrviqReplayModule
 
-// Registers this as the TurboModule/NativeModule named "LumeraReplay" — the exact name
-// TurboModuleRegistry.getEnforcing<Spec>('LumeraReplay') resolves on the JS side.
-RCT_EXPORT_MODULE(LumeraReplay)
+// Registers this as the TurboModule/NativeModule named "ObsrviqReplay" — the exact name
+// TurboModuleRegistry.getEnforcing<Spec>('ObsrviqReplay') resolves on the JS side.
+RCT_EXPORT_MODULE(ObsrviqReplay)
 
 // All forwarding is trivial (dispatch onto the engine, which owns its own threads); no
 // reason to hop onto a method queue.
@@ -49,44 +49,44 @@ RCT_EXPORT_MODULE(LumeraReplay)
 // `start(options)` — object arg arrives as NSDictionary at the ObjC boundary.
 RCT_EXPORT_METHOD(start:(NSDictionary *)options)
 {
-  [LumeraReplay.shared startWithOptions:options];
+  [ObsrviqReplay.shared startWithOptions:options];
 }
 
 // `stop()`
 RCT_EXPORT_METHOD(stop)
 {
-  [LumeraReplay.shared stopObjc];
+  [ObsrviqReplay.shared stopObjc];
 }
 
 // `configure(options)`
 RCT_EXPORT_METHOD(configure:(NSDictionary *)options)
 {
-  [LumeraReplay.shared configureWithOptions:options];
+  [ObsrviqReplay.shared configureWithOptions:options];
 }
 
 // `setViewMasked(reactTag, masked)` — numbers cross as `double`/`BOOL` on New Arch.
 RCT_EXPORT_METHOD(setViewMasked:(double)reactTag masked:(BOOL)masked)
 {
-  [LumeraReplay.shared setViewMasked:@(reactTag) masked:@(masked)];
+  [ObsrviqReplay.shared setViewMasked:@(reactTag) masked:@(masked)];
 }
 
 // `getDiagnostics(): Promise<NativeDiagnostics>` — resolves with the counters snapshot.
 RCT_EXPORT_METHOD(getDiagnostics:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 {
-  resolve([LumeraReplay.shared getDiagnosticsObjc]);
+  resolve([ObsrviqReplay.shared getDiagnosticsObjc]);
 }
 
 #pragma mark - New Architecture (TurboModule) wiring
 
 #ifdef RCT_NEW_ARCH_ENABLED
-// Hands the runtime the C++ JSI binding generated for our spec. `NativeLumeraReplaySpecJSI`
-// is emitted by codegen from src/spec/NativeLumeraReplay.ts (spec target `LumeraReplaySpec`)
+// Hands the runtime the C++ JSI binding generated for our spec. `NativeObsrviqReplaySpecJSI`
+// is emitted by codegen from src/spec/NativeObsrviqReplay.ts (spec target `ObsrviqReplaySpec`)
 // and dispatches each JSI call to the RCT_EXPORT_METHOD implementations above.
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params
 {
-  return std::make_shared<facebook::react::NativeLumeraReplaySpecJSI>(params);
+  return std::make_shared<facebook::react::NativeObsrviqReplaySpecJSI>(params);
 }
 #endif
 

package/{lumera-react-native.podspec → obsrviq-react-native.podspec}

@@ -3,17 +3,17 @@ require "json"
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
 Pod::Spec.new do |s|
-  s.name         = "lumera-react-native"
+  s.name         = "obsrviq-react-native"
   s.version      = package["version"]
   s.summary      = package["description"]
-  s.homepage     = "https://lumera.app"
+  s.homepage     = "https://obsrviq.com"
   s.license      = "MIT"
-  s.authors      = "Lumera"
+  s.authors      = "Obsrviq"
   s.platforms    = { :ios => "13.4" }
-  s.source       = { :git => "https://github.com/TedoraTech/lumera.git", :tag => "#{s.version}" }
+  s.source       = { :git => "https://github.com/TedoraTech/obsrviq.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
-  # Pulls in React-Core, and (on New Arch) the codegen'd LumeraReplaySpec + RN-Core deps.
+  # Pulls in React-Core, and (on New Arch) the codegen'd ObsrviqReplaySpec + RN-Core deps.
   install_modules_dependencies(s)
 end

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@obsrviq/react-native",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "publishConfig": {
     "access": "public"
   },
-  "description": "Lumera mobile capture SDK for React Native — privacy-first screenshot session replay + network/error/custom-event recording, engineered for zero added latency on device.",
+  "description": "Obsrviq mobile capture SDK for React Native — privacy-first screenshot session replay + network/error/custom-event recording, engineered for zero added latency on device.",
   "main": "src/index.ts",
   "module": "src/index.ts",
   "react-native": "src/index.ts",
@@ -14,7 +14,7 @@
     "src",
     "ios",
     "android",
-    "lumera-react-native.podspec",
+    "obsrviq-react-native.podspec",
     "!**/__tests__"
   ],
   "dependencies": {
@@ -33,11 +33,11 @@
     "typescript": "^5.7.2"
   },
   "codegenConfig": {
-    "name": "LumeraReplaySpec",
+    "name": "ObsrviqReplaySpec",
     "type": "modules",
     "jsSrcsDir": "src/spec",
     "android": {
-      "javaPackageName": "app.lumera.replay"
+      "javaPackageName": "app.obsrviq.replay"
     }
   },
   "scripts": {

package/src/ObsrviqMask.tsx

@@ -0,0 +1,63 @@
+import React from 'react';
+import { Platform, View, type ViewProps, requireNativeComponent } from 'react-native';
+
+/**
+ * <ObsrviqMask> — privacy-by-region wrapper for the native screenshot replay.
+ *
+ * Wrap any subtree to control whether it is redacted in captured frames:
+ *
+ *   <ObsrviqMask>            …</ObsrviqMask>   // force-mask this subtree
+ *   <ObsrviqMask unmask>     …</ObsrviqMask>   // force-UNMASK (overrides maskAllText/Images)
+ *
+ * Under the hood the native view (un)registers its reactTag with the capture engine via
+ * `setViewMasked(reactTag, …)`. Masking is composited natively, off the UI thread, during
+ * capture — this component renders its children verbatim and adds no per-frame cost.
+ *
+ * On unsupported platforms / unlinked builds (e.g. Expo Go) it degrades to a plain <View>
+ * so layout is unaffected. (`<LumeraMask>` remains exported as a deprecated alias.)
+ */
+export interface ObsrviqMaskProps extends ViewProps {
+  /** Force-unmask this subtree (overrides the global maskAllText/maskAllImages defaults). */
+  unmask?: boolean;
+  children?: React.ReactNode;
+}
+
+interface NativeMaskProps extends ViewProps {
+  masked: boolean;
+  children?: React.ReactNode;
+}
+
+// Resolve the native component lazily + defensively. Prefer the Obsrviq-era view, fall
+// back to the legacy "LumeraMaskView" name (pre-rebrand native binaries); if neither is
+// linked the require throws and we degrade to a plain View (capture just won't mask here).
+const NativeObsrviqMask: React.ComponentType<NativeMaskProps> | null = (() => {
+  if (Platform.OS !== 'ios' && Platform.OS !== 'android') return null;
+  // Try the Obsrviq view, then legacy names: "LumeraMaskView" (iOS pre-rebrand) and
+  // "LumeraMask" (Android pre-rebrand — they disagreed before the rename).
+  for (const name of ['ObsrviqMaskView', 'LumeraMaskView', 'LumeraMask']) {
+    try {
+      return requireNativeComponent<NativeMaskProps>(name);
+    } catch {
+      /* try the next name */
+    }
+  }
+  return null;
+})();
+
+export function ObsrviqMask({ unmask, children, ...rest }: ObsrviqMaskProps): React.ReactElement {
+  if (!NativeObsrviqMask) {
+    return <View {...rest}>{children}</View>;
+  }
+  return (
+    <NativeObsrviqMask masked={!unmask} {...rest}>
+      {children}
+    </NativeObsrviqMask>
+  );
+}
+
+/** @deprecated Renamed to {@link ObsrviqMask}. Kept as an alias for the Lumera era. */
+export const LumeraMask = ObsrviqMask;
+/** @deprecated Renamed to {@link ObsrviqMaskProps}. */
+export type LumeraMaskProps = ObsrviqMaskProps;
+
+export default ObsrviqMask;

package/src/config.ts

@@ -1,11 +1,11 @@
 import type { IngestBatch } from '@obsrviq/types';
 
 /**
- * Public init config for the Lumera React Native SDK. Mirrors the web tracker's
+ * Public init config for the Obsrviq React Native SDK. Mirrors the web tracker's
  * `ObsrviqInitConfig` where it makes sense, swapping DOM-specific privacy knobs for
  * the native screenshot-replay knobs (fps / jpegQuality / maskAll*).
  */
-export interface LumeraConfig {
+export interface ObsrviqConfig {
   /** REQUIRED — your ingest key (pk_…). */
   siteKey: string;
 
@@ -66,9 +66,9 @@ export interface LumeraConfig {
 }
 
 export type ResolvedConfig = Required<
-  Omit<LumeraConfig, 'userId' | 'metadata' | 'beforeSend'>
+  Omit<ObsrviqConfig, 'userId' | 'metadata' | 'beforeSend'>
 > &
-  Pick<LumeraConfig, 'userId' | 'metadata' | 'beforeSend'>;
+  Pick<ObsrviqConfig, 'userId' | 'metadata' | 'beforeSend'>;
 
 export const DEFAULTS: Omit<ResolvedConfig, 'siteKey' | 'userId' | 'metadata' | 'beforeSend'> = {
   enableReplay: true,
@@ -89,8 +89,11 @@ export const DEFAULTS: Omit<ResolvedConfig, 'siteKey' | 'userId' | 'metadata' |
   requireConsent: false,
 };
 
-export function resolveConfig(config: LumeraConfig): ResolvedConfig {
+export function resolveConfig(config: ObsrviqConfig): ResolvedConfig {
   const clean: Record<string, unknown> = {};
   for (const [k, v] of Object.entries(config)) if (v !== undefined) clean[k] = v;
   return { ...DEFAULTS, ...(clean as Partial<ResolvedConfig>), siteKey: config.siteKey };
 }
+
+/** @deprecated Renamed to {@link ObsrviqConfig}. Kept as an alias for the Lumera era. */
+export type LumeraConfig = ObsrviqConfig;

package/src/index.ts

@@ -1,7 +1,7 @@
 import { Dimensions, Platform } from 'react-native';
 import type { IngestBatch, IngestSessionMeta, ObsrviqEvent } from '@obsrviq/types';
-import NativeLumeraReplay from './spec/NativeLumeraReplay';
-import { type LumeraConfig, type ResolvedConfig, resolveConfig } from './config';
+import NativeObsrviqReplay from './spec/NativeObsrviqReplay';
+import { type ObsrviqConfig, type ResolvedConfig, resolveConfig } from './config';
 import { Clock, uuid } from './util';
 import { clearSession, persistProgress, resolveSession, type ResolvedSession } from './session';
 import { Transport } from './transport';
@@ -19,13 +19,13 @@ export interface Diagnostics {
 }
 
 /**
- * Lumera React Native capture SDK. Mirrors the web tracker's public API 1:1, so app
+ * Obsrviq React Native capture SDK. Mirrors the web tracker's public API 1:1, so app
  * code reads the same on web and mobile. The pure-JS side here owns identity, the
  * structured-event stream (network / error / console / custom), and transport; the
  * heavy screenshot replay stream is owned end-to-end by the native TurboModule
  * (capture → mask → encode → upload), which never blocks the JS thread.
  */
-class LumeraReplayClient {
+class ObsrviqReplayClient {
   private cfg: ResolvedConfig | null = null;
   private clock: Clock | null = null;
   private transport: Transport | null = null;
@@ -47,7 +47,7 @@ class LumeraReplayClient {
 
   /** Initialize the SDK. Idempotent. Session resolution is async (AsyncStorage); any
    *  events emitted before it resolves are buffered and timestamped correctly. */
-  init(config: LumeraConfig): void {
+  init(config: ObsrviqConfig): void {
     if (this.cfg) return;
     const cfg = resolveConfig(config);
     // Sampling: decide once, up front. A sampled-out session records nothing.
@@ -121,7 +121,7 @@ class LumeraReplayClient {
     // ── Native screenshot capture (owns capture + encode + upload, off the UI/JS thread) ──
     if (cfg.enableReplay) {
       try {
-        NativeLumeraReplay.start({
+        NativeObsrviqReplay.start({
           endpoint: cfg.endpoint,
           siteKey: cfg.siteKey,
           sessionId: this._sessionId!,
@@ -237,7 +237,7 @@ class LumeraReplayClient {
     for (const u of this.uninstalls.splice(0)) u();
     if (this.cfg?.enableReplay) {
       try {
-        NativeLumeraReplay.stop();
+        NativeObsrviqReplay.stop();
       } catch {
         /* not linked */
       }
@@ -284,9 +284,15 @@ class LumeraReplayClient {
   }
 }
 
-export const LumeraReplay = new LumeraReplayClient();
-export default LumeraReplay;
-export type { LumeraConfig };
+export const ObsrviqReplay = new ObsrviqReplayClient();
+export default ObsrviqReplay;
+export type { ObsrviqConfig };
 
-// Privacy-by-region component for the native screenshot replay (<LumeraMask> / <LumeraMask unmask>).
-export { LumeraMask, type LumeraMaskProps } from './LumeraMask';
+/** @deprecated Renamed to {@link ObsrviqReplay}. Kept as an alias for the Lumera era. */
+export const LumeraReplay = ObsrviqReplay;
+/** @deprecated Renamed to {@link ObsrviqConfig}. */
+export type { ObsrviqConfig as LumeraConfig };
+
+// Privacy-by-region component for the native screenshot replay (<ObsrviqMask> / <ObsrviqMask unmask>).
+// `LumeraMask` is re-exported as a deprecated alias.
+export { ObsrviqMask, LumeraMask, type ObsrviqMaskProps, type LumeraMaskProps } from './ObsrviqMask';

package/src/session.ts

@@ -1,8 +1,17 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { uuid } from './util';
 
-const SESSION_KEY = 'lumera.session';
-const VISITOR_KEY = 'lumera.visitor';
+const SESSION_KEY = 'obsrviq.session';
+const VISITOR_KEY = 'obsrviq.visitor';
+// Pre-rebrand keys — still read so an upgrading app keeps its visitor identity + any
+// in-flight session continuation; we migrate onto the new keys on the next write.
+const LEGACY_SESSION_KEY = 'lumera.session';
+const LEGACY_VISITOR_KEY = 'lumera.visitor';
+
+/** Read the current key, falling back to the legacy Lumera key for upgrading apps. */
+async function getStored(key: string, legacyKey: string): Promise<string | null> {
+  return (await AsyncStorage.getItem(key)) ?? (await AsyncStorage.getItem(legacyKey));
+}
 
 interface StoredSession {
   id: string;
@@ -54,7 +63,7 @@ export async function resolveSession(opts: {
   const now = opts.now ?? Date.now();
 
   // ── Visitor (persistent, anonymous) ──
-  let visitor = safeParse<StoredVisitor>(await AsyncStorage.getItem(VISITOR_KEY));
+  let visitor = safeParse<StoredVisitor>(await getStored(VISITOR_KEY, LEGACY_VISITOR_KEY));
   if (!visitor) {
     visitor = { id: uuid(), firstSeenAt: now, visitCount: 0 };
   }
@@ -62,7 +71,7 @@ export async function resolveSession(opts: {
   // ── Session (optional continuation) ──
   let session: StoredSession | null = null;
   if (opts.continueSession) {
-    const prior = safeParse<StoredSession>(await AsyncStorage.getItem(SESSION_KEY));
+    const prior = safeParse<StoredSession>(await getStored(SESSION_KEY, LEGACY_SESSION_KEY));
     const fresh = prior && now - prior.lastActivity < opts.timeoutMs;
     const sameUser = !opts.userId || !prior?.userId || prior.userId === opts.userId;
     if (prior && fresh && sameUser) session = prior;
@@ -80,6 +89,8 @@ export async function resolveSession(opts: {
     [SESSION_KEY, JSON.stringify(session)],
     [VISITOR_KEY, JSON.stringify(visitor)],
   ]);
+  // Migrate off the legacy keys so they don't go stale alongside the new ones.
+  await AsyncStorage.multiRemove([LEGACY_SESSION_KEY, LEGACY_VISITOR_KEY]);
 
   return {
     id: session.id,
@@ -94,7 +105,7 @@ export async function resolveSession(opts: {
 
 /** Persist the latest seq + activity so a continued launch resumes correctly. */
 export async function persistProgress(id: string, seq: number, userId?: string): Promise<void> {
-  const prior = safeParse<StoredSession>(await AsyncStorage.getItem(SESSION_KEY));
+  const prior = safeParse<StoredSession>(await getStored(SESSION_KEY, LEGACY_SESSION_KEY));
   if (!prior || prior.id !== id) return; // a reset() already moved on — don't clobber
   await AsyncStorage.setItem(
     SESSION_KEY,
@@ -104,5 +115,5 @@ export async function persistProgress(id: string, seq: number, userId?: string):
 
 /** reset() / logout: drop the continuation record so the next session can't resume this user. */
 export async function clearSession(): Promise<void> {
-  await AsyncStorage.removeItem(SESSION_KEY);
+  await AsyncStorage.multiRemove([SESSION_KEY, LEGACY_SESSION_KEY]);
 }

package/src/spec/{NativeLumeraReplay.ts → NativeObsrviqReplay.ts}

@@ -61,10 +61,14 @@ export interface Spec extends TurboModule {
   stop(): void;
   /** Live-tune cadence/quality/masking without restarting. */
   configure(options: ConfigureOptions): void;
-  /** Explicitly mask/unmask a native view by its RN reactTag (powers <LumeraMask>). */
+  /** Explicitly mask/unmask a native view by its RN reactTag (powers <ObsrviqMask>). */
   setViewMasked(reactTag: number, masked: boolean): void;
   /** Native-side counters for diagnostics (cheap; async so it never blocks). */
   getDiagnostics(): Promise<NativeDiagnostics>;
 }
 
-export default TurboModuleRegistry.getEnforcing<Spec>('LumeraReplay');
+// Prefer the Obsrviq-era native module; fall back to the legacy "LumeraReplay" name so an
+// app still running a pre-rebrand native binary keeps working until it rebuilds. `get`
+// (not `getEnforcing`) returns null when neither is linked — callers guard with try/catch.
+export default (TurboModuleRegistry.get<Spec>('ObsrviqReplay') ??
+  TurboModuleRegistry.get<Spec>('LumeraReplay')) as Spec;

package/src/transport.ts

@@ -28,7 +28,8 @@ export class Transport {
           // `application/json` would hit Fastify's built-in JSON parser, leaving the
           // route's Buffer.isBuffer() check false → 400 "empty_body". (Matches the web tracker.)
           'content-type': 'application/octet-stream',
-          'x-lumera-key': this.siteKey,
+          // Ingest accepts x-obsrviq-key (primary) and x-lumera-key (legacy). Send the new one.
+          'x-obsrviq-key': this.siteKey,
         },
         body: JSON.stringify(batch),
       });

package/android/src/main/java/app/lumera/replay/LumeraMaskViewManager.kt

@@ -1,39 +0,0 @@
-package app.lumera.replay
-
-import android.view.View
-import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.uimanager.SimpleViewManager
-import com.facebook.react.uimanager.ThemedReactContext
-
-/**
- * Backs the optional `<LumeraMask>` JS component. It is a plain pass-through container
- * (children render normally); its sole job is to tell the capture engine "redact my
- * subtree". On attach it registers its own View.id in [LumeraReplayModule.maskedTags];
- * on detach it removes it. This is the geometry [LumeraReplayModule.collectMaskRects]
- * walks: an explicitly-masked container yields one redaction block over the whole subtree.
- *
- * Kept deliberately minimal — no custom props, no shadow node. JS can also drive masking
- * imperatively via `NativeLumeraReplay.setViewMasked(reactTag, masked)` without this view.
- */
-@ReactModule(name = LumeraMaskViewManager.REACT_CLASS)
-class LumeraMaskViewManager : SimpleViewManager<View>() {
-
-  override fun getName() = REACT_CLASS
-
-  override fun createViewInstance(reactContext: ThemedReactContext): View =
-    object : View(reactContext) {
-      override fun onAttachedToWindow() {
-        super.onAttachedToWindow()
-        LumeraReplayModule.maskTag(id)
-      }
-
-      override fun onDetachedFromWindow() {
-        LumeraReplayModule.unmaskTag(id)
-        super.onDetachedFromWindow()
-      }
-    }
-
-  companion object {
-    const val REACT_CLASS = "LumeraMask"
-  }
-}

package/ios/LumeraReplayModule.h

@@ -1,20 +0,0 @@
-#import <Foundation/Foundation.h>
-#import <React/RCTBridgeModule.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-/**
- * The native screenshot-capture TurboModule, exposed to JS as "LumeraReplay".
- *
- * This thin ObjC++ shell exists only to satisfy React Native's codegen'd New-Arch
- * protocol (NativeLumeraReplaySpec, generated from src/spec/NativeLumeraReplay.ts via
- * the `LumeraReplaySpec` codegen target) and to forward each call to the shared Swift
- * engine `LumeraReplay`, which owns the entire capture → mask → encode → upload loop.
- *
- * No capture logic lives here. The implementation (.mm) conforms to the generated
- * <NativeLumeraReplaySpec> protocol and implements `getTurboModule:` for the New Arch.
- */
-@interface LumeraReplayModule : NSObject <RCTBridgeModule>
-@end
-
-NS_ASSUME_NONNULL_END

package/src/LumeraMask.tsx

@@ -1,52 +0,0 @@
-import React from 'react';
-import { Platform, View, type ViewProps, requireNativeComponent } from 'react-native';
-
-/**
- * <LumeraMask> — privacy-by-region wrapper for the native screenshot replay.
- *
- * Wrap any subtree to control whether it is redacted in captured frames:
- *
- *   <LumeraMask>            …</LumeraMask>   // force-mask this subtree
- *   <LumeraMask unmask>     …</LumeraMask>   // force-UNMASK (overrides maskAllText/Images)
- *
- * Under the hood the native view (un)registers its reactTag with the capture engine via
- * `setViewMasked(reactTag, …)`. Masking is composited natively, off the UI thread, during
- * capture — this component renders its children verbatim and adds no per-frame cost.
- *
- * The native view exists on iOS (and Android, task #96). On unsupported platforms /
- * unlinked builds (e.g. Expo Go) it degrades to a plain <View> so layout is unaffected.
- */
-export interface LumeraMaskProps extends ViewProps {
-  /** Force-unmask this subtree (overrides the global maskAllText/maskAllImages defaults). */
-  unmask?: boolean;
-  children?: React.ReactNode;
-}
-
-interface NativeMaskProps extends ViewProps {
-  masked: boolean;
-  children?: React.ReactNode;
-}
-
-// Resolve the native component lazily + defensively: if the native module isn't linked
-// the require throws, and we fall back to a plain View (capture simply won't mask here).
-const NativeLumeraMask: React.ComponentType<NativeMaskProps> | null = (() => {
-  if (Platform.OS !== 'ios' && Platform.OS !== 'android') return null;
-  try {
-    return requireNativeComponent<NativeMaskProps>('LumeraMaskView');
-  } catch {
-    return null;
-  }
-})();
-
-export function LumeraMask({ unmask, children, ...rest }: LumeraMaskProps): React.ReactElement {
-  if (!NativeLumeraMask) {
-    return <View {...rest}>{children}</View>;
-  }
-  return (
-    <NativeLumeraMask masked={!unmask} {...rest}>
-      {children}
-    </NativeLumeraMask>
-  );
-}
-
-export default LumeraMask;