@sansavision/apphelm-react-native-replay 0.0.0-stage → 0.8.0

package/ApphelmReactNativeReplay.podspec

@@ -0,0 +1,20 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ApphelmReactNativeReplay"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://apphelm.dev"
+  s.license      = { :type => "Proprietary", :file => "LICENSE" }
+  s.authors      = "SansaVision"
+  s.platforms    = { :ios => "13.4" }
+  s.source       = { :git => "https://github.com/Sansa-Organisation/apphelm.git", :tag => "v#{s.version}" }
+  s.source_files = "ios/**/*.{h,m,mm}"
+  s.requires_arc = true
+  s.frameworks   = "UIKit"
+  s.pod_target_xcconfig = { "CLANG_CXX_LANGUAGE_STANDARD" => "c++20" }
+
+  s.dependency "React-Core"
+end

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.8.0 (prepared 7 Nov 2026, not published)
+
+- First version (for SDK 0.8.0): the native half of `@sansavision/apphelm/react-native-replay`. An
+  Android module and an iOS module that describe the app's native views (the AppHelm Kotlin and
+  Swift SDKs' wireframe rules, with React Native's text views recognised) and note taps, for the
+  JavaScript recorder. Secure text fields are never read. `replayCapture` is null when the module
+  is not linked; `ApphelmReplayMask` and `ApphelmReplayNoCapture` mark views. Checked with
+  `checks/run-checks.sh` (javac and clang against stubs, the Android view walk on Robolectric, the
+  iOS view walk in the iOS simulator); not yet built in a React Native app or run on a device.

package/LICENSE

@@ -0,0 +1,3 @@
+Copyright 2026 SansaVision. All rights reserved.
+
+This package may be used only under an active Apphelm service agreement. Redistribution, sublicensing, and reverse engineering are prohibited except where applicable law does not permit those restrictions.

package/README.md

@@ -1,3 +1,55 @@
-# Temporary Holding Version
+# @sansavision/apphelm-react-native-replay
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The native half of AppHelm's React Native session replay. It walks the native views your app shows (React Native renders real `UIView`s and Android `View`s) and describes them to `@sansavision/apphelm/react-native-replay`, which turns them into wireframes, masks them, samples them and uploads them. The rest of the AppHelm React Native SDK has no native code: install this package only if you want replays.
+
+```sh
+npm install @sansavision/apphelm @sansavision/apphelm-react-native-replay
+cd ios && pod install
+```
+
+React Native's autolinking picks the module up (Android: `ApphelmReplayPackage`; iOS: the `ApphelmReactNativeReplay` pod). Rebuild the app afterwards: a JavaScript reload is not enough.
+
+```ts
+import { createReactNativeSdk } from "@sansavision/apphelm/react-native";
+import { mobileReplay } from "@sansavision/apphelm/react-native-replay";
+import { replayCapture } from "@sansavision/apphelm-react-native-replay";
+
+const apphelm = createReactNativeSdk({
+  apiKey, workspaceId, productId, storage: AsyncStorage, appState: AppState,
+  // Replay uploads with the product's project key and an origin it allows, like the browser SDK.
+  surveyKey: "ahl_pub_…", surveyOrigin: "https://app.example.com",
+  replay: mobileReplay({ capture: replayCapture, sessionSampleRate: 0.1, onErrorSampleRate: 1 }),
+});
+
+// Once the person agreed to session replay (your consent prompt; AppHelm does not ask):
+apphelm.setReplayConsent(true);
+```
+
+Call `apphelm.screen(name)` (or `navigationTracker()`) as you would anyway: a replay names its screens from it, and sign-in, sign-up, checkout, payment, billing and admin screens are never recorded.
+
+## What it records
+
+- A **wireframe** of the screen each time it changes, checked once a second: each view's box, background colour, border, corner radius, and its text (masked as below). Images are empty boxes; nothing is ever captured as pixels.
+- **Taps**: where, and when. Nothing else about touches.
+- Screen names, and when the app goes to the background and comes back.
+
+## Masking
+
+- `<TextInput secureTextEntry>` (iOS `secureTextEntry` or a password `textContentType`; Android a password input type or a `password` autofill hint) is **never read** by the native module: it is sent as a flag and drawn as `********`.
+- Every other text input shows asterisks (`maskAllTextInputs`, default `true`).
+- Labels and button titles are shown unless `maskAllText: true`. This follows the AppHelm Swift and Kotlin SDKs; Sentry's `mobileReplayIntegration` masks all text by default.
+- `<ApphelmReplayMask>` (or `testID` containing `apphelm-mask`) masks the text inside it; `<ApphelmReplayNoCapture>` (or `testID` containing `apphelm-no-capture`) draws its area as an empty box and reads nothing inside it. Both are `View`s with `collapsable={false}` and set `testID`.
+- React Native's text views are recognised as text: `ReactTextView` (a `TextView`) and, through its `getText()`, a text view that is not a `TextView` (React Native 0.80's `PreparedLayoutTextView`) on Android; `RCTParagraphComponentView` (new architecture, its `attributedText`) and `RCTTextView` (old architecture, its accessibility label) on iOS.
+
+## Sampling and replay on error
+
+`sessionSampleRate` (default 1) is the share of recordings kept whole. With `onErrorSampleRate` above 0, a recording that wasn't picked is kept in memory only (the last 30 seconds, at most about 2 MB) and uploaded when an exception is captured and kept: after `sampleRate`, `ignoreErrors` and the other filters, and after `beforeSend`, which sees the event before it carries `replay_session_id`. Messages never upload a buffer. Error events carry the replay's id as `replay_session_id`. An uncaught fatal error keeps the replay in `storage` until it is sent, on the next launch if need be (not if consent was withdrawn meanwhile).
+
+## Limits
+
+- **Not yet run in a React Native app, or on a device, by AppHelm.** What was checked (`checks/run-checks.sh`): the Java module compiles with `javac -Werror -Xlint:all` against `android.jar` and stubs of React Native's classes, and its view walk and tap callback ran on Robolectric's Android 15 against plain Android views (EditText, TextView, Button, Switch, ImageView, a view shaped like `PreparedLayoutTextView`); the iOS module type-checks with `clang++ -Werror` against stubs of React Native's headers, and its view walk ran on real UIKit in the iOS 26.5 simulator against UIKit views and classes named like React Native's text views. The tap hook on iOS (`sendEvent:`), the bridge calls, autolinking and React Native's own view classes were not exercised.
+- One window: the key window on iOS, the current Activity's window on Android. React Native's `<Modal>` is a separate window (a Dialog) on Android, so it isn't recorded there.
+- Backgrounds React Native draws with its own drawables (`CSSBackgroundDrawable` and similar) are read through their `getColor()` or `getBackgroundColor()` where they have one; gradients, shadows and images are not drawn.
+- Expo Go has no custom native modules: use a development build. `replayCapture` is `null` when the module isn't linked; `mobileReplay` then records nothing.
+
+Requires React Native 0.71 or later.

package/android/build.gradle

@@ -0,0 +1,30 @@
+// The Android half of @sansavision/apphelm-react-native-replay, built by the app's Gradle
+// through React Native's autolinking. It needs nothing beyond React Native and the Android SDK.
+apply plugin: "com.android.library"
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+  namespace "dev.apphelm.reactnative.replay"
+  compileSdkVersion safeExtGet("compileSdkVersion", 35)
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 35)
+  }
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  // Resolved by the React Native Gradle plugin to the app's react-android.
+  implementation "com.facebook.react:react-native:+"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/dev/apphelm/reactnative/replay/ApphelmReplayModule.java

@@ -0,0 +1,150 @@
+package dev.apphelm.reactnative.replay;
+
+import android.app.Activity;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+import android.view.Window;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import java.lang.ref.WeakReference;
+
+/**
+ * The Android half of AppHelm's React Native session replay: describes the resumed Activity's
+ * views (what React Native rendered: ReactTextView, ReactEditText, ReactImageView…) for the
+ * JavaScript recorder in @sansavision/apphelm/react-native-replay, and notes taps. The view walk is
+ * the AppHelm Kotlin SDK's (ReplayViewCapture.kt): a wireframe, never pixels, and the text of a
+ * password field is never read. Nothing runs before JavaScript calls {@code start} (after the
+ * developer declared replay consent); every failure resolves to false or null.
+ */
+public class ApphelmReplayModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "ApphelmReplay";
+
+  private final Handler main = new Handler(Looper.getMainLooper());
+  private final ReplayViewDescriber describer = new ReplayViewDescriber();
+  private final ReplayTaps taps = new ReplayTaps();
+  /** Touched on the main thread only. */
+  private boolean started = false;
+  private WeakReference<Window> tapWindow = new WeakReference<>(null);
+  private String lastTree = null;
+
+  public ApphelmReplayModule(ReactApplicationContext context) {
+    super(context);
+  }
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod
+  public void start(final Promise promise) {
+    main.post(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          started = true;
+          lastTree = null;
+          Activity activity = getReactApplicationContext().getCurrentActivity();
+          if (activity != null) attachTaps(activity.getWindow());
+          promise.resolve(true);
+        } catch (Throwable error) {
+          promise.resolve(false);
+        }
+      }
+    });
+  }
+
+  @ReactMethod
+  public void stop(final Promise promise) {
+    main.post(new Runnable() {
+      @Override
+      public void run() {
+        stopOnMain();
+        promise.resolve(null);
+      }
+    });
+  }
+
+  /**
+   * The screen now, as JSON: {@code {"w":…,"h":…,"root":{…}|null,"taps":[[x,y,ms],…]}} in dp. With
+   * {@code force} false, root is null when the views describe the same as last time.
+   */
+  @ReactMethod
+  public void snapshot(final boolean force, final Promise promise) {
+    main.post(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          promise.resolve(snapshotOnMain(force));
+        } catch (Throwable error) {
+          promise.resolve(null);
+        }
+      }
+    });
+  }
+
+  private String snapshotOnMain(boolean force) {
+    if (!started) return null;
+    Activity activity = getReactApplicationContext().getCurrentActivity();
+    Window window = activity == null ? null : activity.getWindow();
+    if (window == null) return null;
+    attachTaps(window);
+    View decor = window.getDecorView();
+    float density = decor.getResources().getDisplayMetrics().density;
+    if (!(density > 0)) density = 1f;
+    String tree = describer.describe(decor, density);
+    boolean changed = force || tree == null || !tree.equals(lastTree);
+    lastTree = tree;
+    StringBuilder out = new StringBuilder(tree == null ? 64 : tree.length() + 96);
+    out.append("{\"w\":").append(ReplayViewDescriber.number(decor.getWidth() / density))
+        .append(",\"h\":").append(ReplayViewDescriber.number(decor.getHeight() / density))
+        .append(",\"root\":").append(changed && tree != null ? tree : "null")
+        .append(",\"taps\":");
+    taps.drain(out);
+    return out.append('}').toString();
+  }
+
+  /** Wraps the window's callback to note taps; a window wrapped by someone after us is left as it is. */
+  private void attachTaps(Window window) {
+    if (window == null || tapWindow.get() == window) return;
+    detachTaps();
+    Window.Callback original = window.getCallback();
+    if (original == null) return;
+    if (!(original instanceof ReplayTaps.TapCallback)) window.setCallback(new ReplayTaps.TapCallback(original, window, taps));
+    tapWindow = new WeakReference<>(window);
+  }
+
+  private void detachTaps() {
+    Window window = tapWindow.get();
+    tapWindow = new WeakReference<>(null);
+    if (window == null) return;
+    Window.Callback current = window.getCallback();
+    if (current instanceof ReplayTaps.TapCallback) window.setCallback(((ReplayTaps.TapCallback) current).original);
+  }
+
+  private void stopOnMain() {
+    started = false;
+    lastTree = null;
+    try {
+      detachTaps();
+    } catch (Throwable ignored) {
+      // Best effort.
+    }
+    taps.clear();
+  }
+
+  /** The window callback must not outlive the React instance (a reload, the app closing). */
+  @Override
+  public void invalidate() {
+    main.post(new Runnable() {
+      @Override
+      public void run() {
+        stopOnMain();
+      }
+    });
+    super.invalidate();
+  }
+}

package/android/src/main/java/dev/apphelm/reactnative/replay/ApphelmReplayPackage.java

@@ -0,0 +1,21 @@
+package dev.apphelm.reactnative.replay;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.Collections;
+import java.util.List;
+
+/** Registered by React Native's autolinking. */
+public class ApphelmReplayPackage implements ReactPackage {
+  @Override
+  public List<NativeModule> createNativeModules(ReactApplicationContext context) {
+    return Collections.<NativeModule>singletonList(new ApphelmReplayModule(context));
+  }
+
+  @Override
+  public List<ViewManager> createViewManagers(ReactApplicationContext context) {
+    return Collections.emptyList();
+  }
+}

package/android/src/main/java/dev/apphelm/reactnative/replay/ReplayTaps.java

@@ -0,0 +1,116 @@
+package dev.apphelm.reactnative.replay;
+
+import android.os.SystemClock;
+import android.view.ActionMode;
+import android.view.KeyEvent;
+import android.view.KeyboardShortcutGroup;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.SearchEvent;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.accessibility.AccessibilityEvent;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Taps (a press released within 16 dp of where it began, in under 600 ms), noted from a wrapped
+ * Window.Callback as the AppHelm Kotlin SDK's TapCallback does, and handed to JavaScript with
+ * each snapshot. Only the position and the time are kept.
+ */
+final class ReplayTaps {
+  private static final int MAX_TAPS = 50;
+  private final List<double[]> taps = new ArrayList<>();
+
+  synchronized void add(double x, double y, double at) {
+    if (taps.size() >= MAX_TAPS) taps.remove(0);
+    taps.add(new double[] {x, y, at});
+  }
+
+  synchronized void clear() {
+    taps.clear();
+  }
+
+  /** Appends the taps as a JSON array and forgets them. */
+  synchronized void drain(StringBuilder out) {
+    out.append('[');
+    for (int index = 0; index < taps.size(); index += 1) {
+      double[] tap = taps.get(index);
+      if (index > 0) out.append(',');
+      out.append('[').append(ReplayViewDescriber.number(tap[0])).append(',').append(ReplayViewDescriber.number(tap[1])).append(',').append((long) tap[2]).append(']');
+    }
+    out.append(']');
+    taps.clear();
+  }
+
+  /** Passes every window callback through and notes taps. */
+  static final class TapCallback implements Window.Callback {
+    final Window.Callback original;
+    private final Window window;
+    private final ReplayTaps taps;
+    private float downX;
+    private float downY;
+    private long downAt;
+
+    TapCallback(Window.Callback original, Window window, ReplayTaps taps) {
+      this.original = original;
+      this.window = window;
+      this.taps = taps;
+    }
+
+    @Override
+    public boolean dispatchTouchEvent(MotionEvent event) {
+      try {
+        if (event != null) note(event);
+      } catch (Throwable ignored) {
+        // Replay never breaks a touch.
+      }
+      return original.dispatchTouchEvent(event);
+    }
+
+    private void note(MotionEvent event) {
+      int action = event.getActionMasked();
+      if (action == MotionEvent.ACTION_DOWN) {
+        downX = event.getX();
+        downY = event.getY();
+        downAt = event.getEventTime();
+      } else if (action == MotionEvent.ACTION_UP) {
+        float density = window.getDecorView().getResources().getDisplayMetrics().density;
+        if (!(density > 0)) density = 1f;
+        float slop = 16 * density;
+        if (event.getEventTime() - downAt < 600 && Math.abs(event.getX() - downX) < slop && Math.abs(event.getY() - downY) < slop) {
+          // Event times are uptime; JavaScript wants wall-clock milliseconds.
+          double at = System.currentTimeMillis() - (SystemClock.uptimeMillis() - event.getEventTime());
+          taps.add(event.getX() / density, event.getY() / density, at);
+        }
+      }
+    }
+
+    @Override public boolean dispatchKeyEvent(KeyEvent event) { return original.dispatchKeyEvent(event); }
+    @Override public boolean dispatchKeyShortcutEvent(KeyEvent event) { return original.dispatchKeyShortcutEvent(event); }
+    @Override public boolean dispatchTrackballEvent(MotionEvent event) { return original.dispatchTrackballEvent(event); }
+    @Override public boolean dispatchGenericMotionEvent(MotionEvent event) { return original.dispatchGenericMotionEvent(event); }
+    @Override public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) { return original.dispatchPopulateAccessibilityEvent(event); }
+    @Override public View onCreatePanelView(int featureId) { return original.onCreatePanelView(featureId); }
+    @Override public boolean onCreatePanelMenu(int featureId, Menu menu) { return original.onCreatePanelMenu(featureId, menu); }
+    @Override public boolean onPreparePanel(int featureId, View view, Menu menu) { return original.onPreparePanel(featureId, view, menu); }
+    @Override public boolean onMenuOpened(int featureId, Menu menu) { return original.onMenuOpened(featureId, menu); }
+    @Override public boolean onMenuItemSelected(int featureId, MenuItem item) { return original.onMenuItemSelected(featureId, item); }
+    @Override public void onWindowAttributesChanged(WindowManager.LayoutParams attrs) { original.onWindowAttributesChanged(attrs); }
+    @Override public void onContentChanged() { original.onContentChanged(); }
+    @Override public void onWindowFocusChanged(boolean hasFocus) { original.onWindowFocusChanged(hasFocus); }
+    @Override public void onAttachedToWindow() { original.onAttachedToWindow(); }
+    @Override public void onDetachedFromWindow() { original.onDetachedFromWindow(); }
+    @Override public void onPanelClosed(int featureId, Menu menu) { original.onPanelClosed(featureId, menu); }
+    @Override public boolean onSearchRequested() { return original.onSearchRequested(); }
+    @Override public boolean onSearchRequested(SearchEvent searchEvent) { return original.onSearchRequested(searchEvent); }
+    @Override public ActionMode onWindowStartingActionMode(ActionMode.Callback callback) { return original.onWindowStartingActionMode(callback); }
+    @Override public ActionMode onWindowStartingActionMode(ActionMode.Callback callback, int type) { return original.onWindowStartingActionMode(callback, type); }
+    @Override public void onActionModeStarted(ActionMode mode) { original.onActionModeStarted(mode); }
+    @Override public void onActionModeFinished(ActionMode mode) { original.onActionModeFinished(mode); }
+    @Override public void onProvideKeyboardShortcuts(List<KeyboardShortcutGroup> data, Menu menu, int deviceId) { original.onProvideKeyboardShortcuts(data, menu, deviceId); }
+    @Override public void onPointerCaptureChanged(boolean hasCapture) { original.onPointerCaptureChanged(hasCapture); }
+  }
+}

package/android/src/main/java/dev/apphelm/reactnative/replay/ReplayViewDescriber.java

@@ -0,0 +1,309 @@
+package dev.apphelm.reactnative.replay;
+
+import android.graphics.Color;
+import android.graphics.drawable.ColorDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.GradientDrawable;
+import android.os.Build;
+import android.text.InputType;
+import android.text.method.PasswordTransformationMethod;
+import android.view.View;
+import android.view.ViewGroup;
+import android.webkit.WebView;
+import android.widget.Button;
+import android.widget.CompoundButton;
+import android.widget.EditText;
+import android.widget.ImageView;
+import android.widget.TextView;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/**
+ * Describes a view tree as the JSON tree @sansavision/apphelm/react-native-replay builds its
+ * wireframe from (NativeViewNode: short keys, dp). The rules are the AppHelm Kotlin SDK's
+ * ReplayViewCapture.describe: EditText is an input (a password one is secure and its text is never
+ * read), CompoundButton a toggle, Button a button, TextView text, ImageView an image, WebView a web
+ * view; a field, button, toggle or image is a leaf. React Native's own views are subclasses of
+ * these (ReactEditText, ReactTextView, ReactSwitch, ReactImageView), so they are recognised as
+ * they are; a React Native text view that is not a TextView (PreparedLayoutTextView) is read
+ * through its getText(). Hidden views are left out; the walk stops at 3,000 views.
+ * Main thread only.
+ */
+final class ReplayViewDescriber {
+  static final int MAX_NODES = 3_000;
+  static final int MAX_TEXT = 500;
+  private static final int MAX_DEPTH = 200;
+
+  private final WeakHashMap<View, Integer> ids = new WeakHashMap<>();
+  private int nextId = 0;
+  private int count = 0;
+  private final int[] location = new int[2];
+  /** getText() of view classes that are not TextViews, and colour getters of drawable classes; null when a class has none. */
+  private final Map<Class<?>, Method> textGetters = new HashMap<>();
+  private final Map<Class<?>, Method> colourGetters = new HashMap<>();
+  private final Map<Class<?>, Method> innerDrawables = new HashMap<>();
+
+  /** The tree from {@code root}, or null when the root itself is hidden. */
+  String describe(View root, float density) {
+    count = 0;
+    StringBuilder out = new StringBuilder(16 * 1024);
+    return describe(root, density, out, 0) ? out.toString() : null;
+  }
+
+  private int idOf(View view) {
+    Integer id = ids.get(view);
+    if (id == null) {
+      id = ++nextId;
+      ids.put(view, id);
+    }
+    return id;
+  }
+
+  /** Appends the view's node; false (nothing appended) when it is hidden or the budget is spent. */
+  private boolean describe(View view, float density, StringBuilder out, int depth) {
+    if (count >= MAX_NODES || depth > MAX_DEPTH) return false;
+    if (view.getVisibility() != View.VISIBLE) return false;
+    float alpha = view.getAlpha();
+    if (alpha <= 0.01f) return false;
+    count += 1;
+    view.getLocationInWindow(location);
+    String kind = "view";
+    CharSequence text = null;
+    Integer foreground = null;
+    float fontSize = 0;
+    boolean secure = false;
+    Boolean on = null;
+    if (view instanceof EditText) {
+      EditText field = (EditText) view;
+      kind = "input";
+      secure = isPasswordInput(field.getInputType(), field.getTransformationMethod() instanceof PasswordTransformationMethod) || hasPasswordHint(field);
+      // A password field's text is never read.
+      if (!secure) text = field.getText();
+    } else if (view instanceof CompoundButton) {
+      kind = "toggle";
+      on = ((CompoundButton) view).isChecked();
+      text = ((CompoundButton) view).getText();
+    } else if (view instanceof Button) {
+      kind = "button";
+      text = ((Button) view).getText();
+    } else if (view instanceof TextView) {
+      kind = "text";
+      text = ((TextView) view).getText();
+    } else if (view instanceof ImageView) {
+      kind = "image";
+    } else if (view instanceof WebView) {
+      kind = "web";
+    } else {
+      Method getter = textGetter(view.getClass());
+      if (getter != null) {
+        try {
+          Object value = getter.invoke(view);
+          if (value instanceof CharSequence) {
+            kind = "text";
+            text = (CharSequence) value;
+          }
+        } catch (Throwable ignored) {
+          // Not text after all.
+        }
+      }
+    }
+    if (view instanceof TextView) {
+      TextView label = (TextView) view;
+      foreground = label.getCurrentTextColor();
+      fontSize = label.getTextSize() / density;
+    }
+    String background = null;
+    float corner = 0;
+    Drawable drawable = view.getBackground();
+    if (drawable instanceof ColorDrawable) {
+      background = hex(((ColorDrawable) drawable).getColor());
+    } else if (drawable instanceof GradientDrawable) {
+      GradientDrawable gradient = (GradientDrawable) drawable;
+      if (gradient.getColor() != null) background = hex(gradient.getColor().getDefaultColor());
+      corner = gradient.getCornerRadius() / density;
+    } else if (drawable != null) {
+      background = reflectedColour(drawable, 0);
+    }
+    boolean noCapture = marked(view, "ph-no-capture", "apphelm-no-capture");
+    boolean mask = marked(view, "ph-mask", "apphelm-mask");
+
+    out.append("{\"i\":").append(idOf(view))
+        .append(",\"k\":\"").append(kind).append('"')
+        .append(",\"x\":").append(number(location[0] / density))
+        .append(",\"y\":").append(number(location[1] / density))
+        .append(",\"w\":").append(number(view.getWidth() / density))
+        .append(",\"h\":").append(number(view.getHeight() / density));
+    if (alpha < 0.999f) out.append(",\"a\":").append(number(alpha));
+    if (background != null) out.append(",\"bg\":\"").append(background).append('"');
+    if (foreground != null) {
+      String colour = hex(foreground);
+      if (colour != null) out.append(",\"fg\":\"").append(colour).append('"');
+    }
+    if (corner >= 1) out.append(",\"r\":").append(number(corner));
+    if (fontSize > 0) out.append(",\"fs\":").append(number(fontSize));
+    if (secure) out.append(",\"s\":1");
+    if (on != null) out.append(",\"on\":").append(on ? "true" : "false");
+    if (noCapture) {
+      // Left out: an empty box, nothing inside read.
+      out.append(",\"nc\":1}");
+      return true;
+    }
+    if (mask) out.append(",\"m\":1");
+    if (text != null && text.length() > 0) {
+      out.append(",\"t\":");
+      string(out, text.length() > MAX_TEXT ? text.subSequence(0, MAX_TEXT) : text);
+    }
+    if (view instanceof ViewGroup && kind.equals("view")) {
+      ViewGroup group = (ViewGroup) view;
+      int start = out.length();
+      out.append(",\"c\":[");
+      int mark = out.length();
+      for (int index = 0; index < group.getChildCount(); index += 1) {
+        View child = group.getChildAt(index);
+        if (child == null) continue;
+        int before = out.length();
+        if (before > mark) out.append(',');
+        if (!describe(child, density, out, depth + 1)) out.setLength(before);
+      }
+      if (out.length() == mark) out.setLength(start);
+      else out.append(']');
+    }
+    out.append('}');
+    return true;
+  }
+
+  /** True for any password input type or a password transformation (the Kotlin SDK's isPasswordInput). */
+  static boolean isPasswordInput(int inputType, boolean transformed) {
+    int variation = inputType & (InputType.TYPE_MASK_CLASS | InputType.TYPE_MASK_VARIATION);
+    return transformed
+        || variation == (InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD)
+        || variation == (InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_WEB_PASSWORD)
+        || variation == (InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD)
+        || variation == (InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_VARIATION_PASSWORD);
+  }
+
+  /** React Native's autoComplete="password" / "new-password" (autofill hints, Android 8+). */
+  private static boolean hasPasswordHint(View view) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false;
+    String[] hints = view.getAutofillHints();
+    if (hints == null) return false;
+    for (String hint : hints) if (hint != null && hint.toLowerCase(Locale.ROOT).contains("password")) return true;
+    return false;
+  }
+
+  /** A marker in the view's tag (React Native's testID) or its content description (accessibilityLabel). */
+  private static boolean marked(View view, String first, String second) {
+    Object tag = view.getTag();
+    if (tag instanceof String && (((String) tag).contains(first) || ((String) tag).contains(second))) return true;
+    CharSequence description = view.getContentDescription();
+    if (description == null) return false;
+    String value = description.toString();
+    return value.contains(first) || value.contains(second);
+  }
+
+  /** A public no-argument getText() on a view class named like a text view, cached per class. */
+  private Method textGetter(Class<?> type) {
+    if (textGetters.containsKey(type)) return textGetters.get(type);
+    Method found = null;
+    String name = type.getSimpleName();
+    // Never a field (or a wrapper of one): only a view that draws text, such as PreparedLayoutTextView.
+    if (name.contains("Text") && !name.contains("Input") && !name.contains("Edit") && !name.contains("Field") && !name.contains("Password") && !name.contains("Secure")) {
+      try {
+        Method method = type.getMethod("getText");
+        if (CharSequence.class.isAssignableFrom(method.getReturnType())) found = method;
+      } catch (Throwable ignored) {
+        // No text.
+      }
+    }
+    textGetters.put(type, found);
+    return found;
+  }
+
+  /**
+   * The colour of a drawable AppHelm doesn't know (React Native's CSSBackgroundDrawable,
+   * ReactViewBackgroundDrawable, or the BackgroundDrawable inside a CompositeBackgroundDrawable):
+   * its int getColor() or getBackgroundColor(), one drawable deep.
+   */
+  private String reflectedColour(Drawable drawable, int depth) {
+    Class<?> type = drawable.getClass();
+    Method getter;
+    if (colourGetters.containsKey(type)) getter = colourGetters.get(type);
+    else {
+      getter = intGetter(type, "getColor");
+      if (getter == null) getter = intGetter(type, "getBackgroundColor");
+      colourGetters.put(type, getter);
+    }
+    try {
+      if (getter != null) return hex((Integer) getter.invoke(drawable));
+    } catch (Throwable ignored) {
+      // No colour.
+    }
+    if (depth > 0) return null;
+    Method inner;
+    if (innerDrawables.containsKey(type)) inner = innerDrawables.get(type);
+    else {
+      inner = null;
+      try {
+        Method method = type.getMethod("getBackground");
+        if (Drawable.class.isAssignableFrom(method.getReturnType())) inner = method;
+      } catch (Throwable ignored) {
+        // None.
+      }
+      innerDrawables.put(type, inner);
+    }
+    try {
+      Object value = inner == null ? null : inner.invoke(drawable);
+      if (value instanceof Drawable && value != drawable) {
+        Drawable nested = (Drawable) value;
+        if (nested instanceof ColorDrawable) return hex(((ColorDrawable) nested).getColor());
+        return reflectedColour(nested, depth + 1);
+      }
+    } catch (Throwable ignored) {
+      // No colour.
+    }
+    return null;
+  }
+
+  private static Method intGetter(Class<?> type, String name) {
+    try {
+      Method method = type.getMethod(name);
+      return method.getReturnType() == int.class ? method : null;
+    } catch (Throwable ignored) {
+      return null;
+    }
+  }
+
+  static String hex(int color) {
+    if (Color.alpha(color) < 3) return null;
+    return String.format(Locale.ROOT, "#%06x", color & 0xFFFFFF);
+  }
+
+  /** A dp value with at most two decimals. */
+  static String number(double value) {
+    if (Double.isNaN(value) || Double.isInfinite(value)) return "0";
+    long rounded = Math.round(value * 100);
+    if (rounded % 100 == 0) return Long.toString(rounded / 100);
+    return Double.toString(rounded / 100.0);
+  }
+
+  static void string(StringBuilder out, CharSequence value) {
+    out.append('"');
+    for (int index = 0; index < value.length(); index += 1) {
+      char c = value.charAt(index);
+      switch (c) {
+        case '"': out.append("\\\""); break;
+        case '\\': out.append("\\\\"); break;
+        case '\n': out.append("\\n"); break;
+        case '\r': out.append("\\r"); break;
+        case '\t': out.append("\\t"); break;
+        default:
+          if (c < 0x20 || c == 0x2028 || c == 0x2029) out.append(String.format(Locale.ROOT, "\\u%04x", (int) c));
+          else out.append(c);
+      }
+    }
+    out.append('"');
+  }
+}

package/index.d.ts

@@ -0,0 +1,18 @@
+import type { ReactElement } from "react";
+import type { ViewProps } from "react-native";
+
+/** The native view capture, for `mobileReplay({ capture })`; null when the native module isn't linked. */
+export declare const replayCapture: {
+  /** React Native's `Platform.OS`. */
+  platform: string;
+  /** Start noting taps; false when the module can't. */
+  start(): Promise<boolean>;
+  stop(): Promise<void>;
+  /** The screen as JSON (`NativeSnapshot`), or null. */
+  snapshot(force: boolean): Promise<string | null>;
+} | null;
+
+/** A View whose text, and its children's, is masked in session replay. It sets `testID` to `apphelm-mask`. */
+export declare function ApphelmReplayMask(props: ViewProps): ReactElement;
+/** A View left out of session replay (an empty box). It sets `testID` to `apphelm-no-capture`. */
+export declare function ApphelmReplayNoCapture(props: ViewProps): ReactElement;

package/index.js

@@ -0,0 +1,26 @@
+// The native module (android/ and ios/) as the `capture` that @sansavision/apphelm/react-native-replay's
+// `mobileReplay` takes. When the module isn't linked (Expo Go, a build made before installing this
+// package) it is null and nothing is recorded. No call rejects.
+import { createElement } from "react";
+import { NativeModules, Platform, View } from "react-native";
+
+const native = NativeModules.ApphelmReplay;
+
+export const replayCapture = native && typeof native.start === "function" && typeof native.stop === "function" && typeof native.snapshot === "function"
+  ? {
+      platform: Platform.OS,
+      start: () => native.start().then((started) => started === true, () => false),
+      stop: () => native.stop().then(() => undefined, () => undefined),
+      snapshot: (force) => native.snapshot(force === true).then((json) => (typeof json === "string" && json.length > 0 ? json : null), () => null),
+    }
+  : null;
+
+/** A View whose text, and its children's, is masked in session replay (asterisks). */
+export function ApphelmReplayMask(props) {
+  return createElement(View, { ...props, testID: "apphelm-mask", collapsable: false });
+}
+
+/** A View left out of session replay: drawn as an empty box, nothing inside it read. */
+export function ApphelmReplayNoCapture(props) {
+  return createElement(View, { ...props, testID: "apphelm-no-capture", collapsable: false });
+}

package/ios/ApphelmReplay.mm

@@ -0,0 +1,335 @@
+// The iOS half of @sansavision/apphelm-react-native-replay: describes the key window's views (what
+// React Native rendered: RCTParagraphComponentView / RCTTextView, RCTUITextField, RCTImageView…)
+// for the JavaScript recorder in @sansavision/apphelm/react-native-replay, and notes taps. The view
+// walk is the AppHelm Swift SDK's (ReplayUIKit.swift): a wireframe, never pixels, and the text of a
+// secure field is never read. Taps come from UIApplication's sendEvent:, as sentry-cocoa's replay
+// notes touches, not from a gesture recognizer that could hold back React Native's touch handler.
+// Nothing runs before JavaScript calls `start` (after the developer declared replay consent). No
+// call ever rejects.
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTInvalidating.h>
+#import <objc/runtime.h>
+
+namespace {
+const NSUInteger kMaxNodes = 3000;
+const NSUInteger kMaxText = 500;
+const NSUInteger kMaxDepth = 200;
+const NSUInteger kMaxTaps = 50;
+
+// Touched on the main thread only: sendEvent: and the module's methods (methodQueue) run there.
+bool tapsEnabled = false;
+NSMutableArray<NSArray<NSNumber *> *> *pendingTaps = nil;
+NSMapTable<UITouch *, NSValue *> *touchStarts = nil;
+IMP originalSendEvent = NULL;
+char replayIdKey;
+NSInteger nextReplayId = 0;
+
+void noteEvent(UIEvent *event)
+{
+  if (!tapsEnabled || event.type != UIEventTypeTouches) return;
+  for (UITouch *touch in event.allTouches) {
+    UIWindow *window = touch.window;
+    if (!window) continue;
+    CGPoint point = [touch locationInView:window];
+    if (touch.phase == UITouchPhaseBegan) {
+      // The start point and time, packed as a rect: origin = point, size.width = timestamp.
+      [touchStarts setObject:[NSValue valueWithCGRect:CGRectMake(point.x, point.y, touch.timestamp, 0)] forKey:touch];
+    } else if (touch.phase == UITouchPhaseEnded) {
+      NSValue *start = [touchStarts objectForKey:touch];
+      [touchStarts removeObjectForKey:touch];
+      if (!start) continue;
+      CGRect began = start.CGRectValue;
+      if (touch.timestamp - began.size.width < 0.6 && fabs(point.x - began.origin.x) < 16 && fabs(point.y - began.origin.y) < 16) {
+        if (pendingTaps.count >= kMaxTaps) [pendingTaps removeObjectAtIndex:0];
+        double at = [[NSDate date] timeIntervalSince1970] * 1000.0;
+        [pendingTaps addObject:@[ @(round(point.x * 100) / 100), @(round(point.y * 100) / 100), @((long long)at) ]];
+      }
+    } else if (touch.phase == UITouchPhaseCancelled) {
+      [touchStarts removeObjectForKey:touch];
+    }
+  }
+}
+
+void apphelmSendEvent(id application, SEL selector, UIEvent *event)
+{
+  @try {
+    noteEvent(event);
+  } @catch (__unused NSException *exception) {
+    // Replay never breaks a touch.
+  }
+  ((void (*)(id, SEL, UIEvent *))originalSendEvent)(application, selector, event);
+}
+
+void installTapHook()
+{
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    pendingTaps = [NSMutableArray array];
+    touchStarts = [NSMapTable weakToStrongObjectsMapTable];
+    Method method = class_getInstanceMethod([UIApplication class], @selector(sendEvent:));
+    if (method) originalSendEvent = method_setImplementation(method, (IMP)apphelmSendEvent);
+  });
+}
+
+NSString *hexColour(UIColor *color)
+{
+  if (!color) return nil;
+  CGFloat red = 0, green = 0, blue = 0, alpha = 0;
+  if (![color getRed:&red green:&green blue:&blue alpha:&alpha] || alpha <= 0.01) return nil;
+  auto byte = [](CGFloat value) { return (int)lround(MIN(1.0, MAX(0.0, value)) * 255.0); };
+  return [NSString stringWithFormat:@"#%02x%02x%02x", byte(red), byte(green), byte(blue)];
+}
+
+NSNumber *points(CGFloat value)
+{
+  if (isnan(value) || isinf(value)) return @0;
+  return @(round(value * 100) / 100);
+}
+
+NSInteger idOf(UIView *view)
+{
+  NSNumber *stored = objc_getAssociatedObject(view, &replayIdKey);
+  if (stored) return stored.integerValue;
+  nextReplayId += 1;
+  objc_setAssociatedObject(view, &replayIdKey, @(nextReplayId), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+  return nextReplayId;
+}
+
+bool isKind(UIView *view, NSString *className)
+{
+  Class type = NSClassFromString(className);
+  return type && [view isKindOfClass:type];
+}
+
+bool marked(UIView *view, NSString *first, NSString *second)
+{
+  // React Native's testID is the accessibilityIdentifier.
+  NSString *identifier = view.accessibilityIdentifier;
+  return identifier && ([identifier containsString:first] || [identifier containsString:second]);
+}
+
+void putText(NSMutableDictionary *node, NSString *text)
+{
+  if (text.length == 0) return;
+  node[@"t"] = text.length > kMaxText ? [text substringToIndex:kMaxText] : text;
+}
+
+/** React Native's text views (RCTParagraphComponentView on the new architecture, RCTTextView on the old) draw an attributed string, not a UILabel. */
+void describeReactText(UIView *view, NSMutableDictionary *node)
+{
+  node[@"k"] = @"text";
+  NSAttributedString *attributed = nil;
+  if ([view respondsToSelector:@selector(attributedText)]) {
+    id value = [view valueForKey:@"attributedText"];
+    if ([value isKindOfClass:[NSAttributedString class]]) attributed = value;
+  }
+  if (attributed.length > 0) {
+    putText(node, attributed.string);
+    UIFont *font = [attributed attribute:NSFontAttributeName atIndex:0 effectiveRange:NULL];
+    UIColor *color = [attributed attribute:NSForegroundColorAttributeName atIndex:0 effectiveRange:NULL];
+    if ([font isKindOfClass:[UIFont class]]) node[@"fs"] = points(font.pointSize);
+    if ([color isKindOfClass:[UIColor class]]) {
+      NSString *hex = hexColour(color);
+      if (hex) node[@"fg"] = hex;
+    }
+  } else {
+    // RCTTextView's accessibilityLabel is its text when the app set none.
+    putText(node, view.accessibilityLabel);
+  }
+}
+
+class Describer {
+ public:
+  explicit Describer(UIWindow *window) : window_(window) {}
+
+  NSMutableDictionary *describe(UIView *view, NSUInteger depth)
+  {
+    if (count_ >= kMaxNodes || depth > kMaxDepth || view.isHidden || view.alpha <= 0.01) return nil;
+    count_ += 1;
+    CGRect frame = [view convertRect:view.bounds toView:window_];
+    NSMutableDictionary *node = [NSMutableDictionary dictionaryWithCapacity:12];
+    node[@"i"] = @(idOf(view));
+    node[@"x"] = points(frame.origin.x);
+    node[@"y"] = points(frame.origin.y);
+    node[@"w"] = points(frame.size.width);
+    node[@"h"] = points(frame.size.height);
+    if (view.alpha < 0.999) node[@"a"] = points(view.alpha);
+    NSString *background = hexColour(view.backgroundColor);
+    if (!background && view.layer.backgroundColor) background = hexColour([UIColor colorWithCGColor:view.layer.backgroundColor]);
+    if (background) node[@"bg"] = background;
+    if (view.layer.borderWidth > 0 && view.layer.borderColor) {
+      NSString *border = hexColour([UIColor colorWithCGColor:view.layer.borderColor]);
+      if (border) {
+        node[@"bc"] = border;
+        node[@"bw"] = points(view.layer.borderWidth);
+      }
+    }
+    if (view.layer.cornerRadius >= 1) node[@"r"] = points(view.layer.cornerRadius);
+    NSString *kind = @"view";
+    if ([view isKindOfClass:[UITextField class]]) {
+      UITextField *field = (UITextField *)view;
+      kind = @"input";
+      bool secure = field.isSecureTextEntry || [field.textContentType isEqualToString:UITextContentTypePassword] || [field.textContentType isEqualToString:UITextContentTypeNewPassword];
+      // A secure field's text is never read.
+      if (secure) node[@"s"] = @1;
+      else putText(node, field.text);
+      NSString *colour = hexColour(field.textColor);
+      if (colour) node[@"fg"] = colour;
+      if (field.font) node[@"fs"] = points(field.font.pointSize);
+    } else if ([view isKindOfClass:[UITextView class]]) {
+      UITextView *text = (UITextView *)view;
+      kind = text.isEditable ? @"input" : @"text";
+      bool secure = text.isSecureTextEntry || [text.textContentType isEqualToString:UITextContentTypePassword] || [text.textContentType isEqualToString:UITextContentTypeNewPassword];
+      if (secure) {
+        kind = @"input";
+        node[@"s"] = @1;
+      } else putText(node, text.text);
+      NSString *colour = hexColour(text.textColor);
+      if (colour) node[@"fg"] = colour;
+      if (text.font) node[@"fs"] = points(text.font.pointSize);
+    } else if ([view isKindOfClass:[UILabel class]]) {
+      UILabel *label = (UILabel *)view;
+      kind = @"text";
+      putText(node, label.text);
+      NSString *colour = hexColour(label.textColor);
+      if (colour) node[@"fg"] = colour;
+      node[@"fs"] = points(label.font.pointSize);
+    } else if ([view isKindOfClass:[UIButton class]]) {
+      UIButton *button = (UIButton *)view;
+      kind = @"button";
+      putText(node, [button titleForState:UIControlStateNormal] ?: button.titleLabel.text);
+      NSString *colour = hexColour([button titleColorForState:UIControlStateNormal]);
+      if (colour) node[@"fg"] = colour;
+      if (button.titleLabel.font) node[@"fs"] = points(button.titleLabel.font.pointSize);
+    } else if ([view isKindOfClass:[UISwitch class]]) {
+      UISwitch *toggle = (UISwitch *)view;
+      kind = @"toggle";
+      node[@"on"] = @(toggle.isOn);
+      NSString *colour = hexColour(toggle.isOn ? (toggle.onTintColor ?: [UIColor systemGreenColor]) : toggle.backgroundColor);
+      if (colour) node[@"bg"] = colour;
+    } else if ([view isKindOfClass:[UIImageView class]] || isKind(view, @"RCTImageView") || isKind(view, @"RCTImageComponentView")) {
+      kind = @"image";
+    } else if (isKind(view, @"RCTParagraphComponentView") || isKind(view, @"RCTTextView")) {
+      describeReactText(view, node);
+      kind = node[@"k"];
+    } else if ([NSStringFromClass([view class]) containsString:@"WKWebView"]) {
+      // WebKit is not linked for this check; the class name is enough.
+      kind = @"web";
+    }
+    node[@"k"] = kind;
+    if (marked(view, @"ph-no-capture", @"apphelm-no-capture")) {
+      // Left out: an empty box, nothing inside read.
+      [node removeObjectForKey:@"t"];
+      node[@"nc"] = @1;
+      return node;
+    }
+    if (marked(view, @"ph-mask", @"apphelm-mask")) node[@"m"] = @1;
+    if ([kind isEqualToString:@"view"] || [kind isEqualToString:@"text"]) {
+      NSMutableArray *children = [NSMutableArray array];
+      for (UIView *child in view.subviews) {
+        NSMutableDictionary *described = describe(child, depth + 1);
+        if (described) [children addObject:described];
+      }
+      if (children.count > 0) node[@"c"] = children;
+    }
+    return node;
+  }
+
+ private:
+  UIWindow *window_;
+  NSUInteger count_ = 0;
+};
+
+UIWindow *keyWindow()
+{
+  UIApplication *application = [UIApplication sharedApplication];
+  for (UIScene *scene in application.connectedScenes) {
+    if (![scene isKindOfClass:[UIWindowScene class]]) continue;
+    for (UIWindow *window in ((UIWindowScene *)scene).windows) {
+      if (window.isKeyWindow) return window;
+    }
+  }
+  return nil;
+}
+} // namespace
+
+@interface ApphelmReplay : NSObject <RCTBridgeModule, RCTInvalidating>
+@end
+
+@implementation ApphelmReplay {
+  NSString *_lastTree;
+}
+
+RCT_EXPORT_MODULE(ApphelmReplay)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+// UIKit is main-thread only: every method runs there.
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+RCT_EXPORT_METHOD(start : (RCTPromiseResolveBlock)resolve reject : (__unused RCTPromiseRejectBlock)reject)
+{
+  installTapHook();
+  tapsEnabled = originalSendEvent != NULL;
+  [pendingTaps removeAllObjects];
+  _lastTree = nil;
+  resolve(@YES);
+}
+
+RCT_EXPORT_METHOD(stop : (RCTPromiseResolveBlock)resolve reject : (__unused RCTPromiseRejectBlock)reject)
+{
+  tapsEnabled = false;
+  [pendingTaps removeAllObjects];
+  [touchStarts removeAllObjects];
+  _lastTree = nil;
+  resolve([NSNull null]);
+}
+
+/// The screen now, as JSON: {"w":…,"h":…,"root":{…}|null,"taps":[[x,y,ms],…]} in points. With
+/// `force` NO, root is null when the views describe the same as last time.
+RCT_EXPORT_METHOD(snapshot : (BOOL)force resolve : (RCTPromiseResolveBlock)resolve reject : (__unused RCTPromiseRejectBlock)reject)
+{
+  @try {
+    UIWindow *window = keyWindow();
+    if (!window) {
+      resolve([NSNull null]);
+      return;
+    }
+    Describer describer(window);
+    NSMutableDictionary *root = describer.describe(window, 0);
+    NSString *tree = nil;
+    if (root) {
+      NSData *data = [NSJSONSerialization dataWithJSONObject:root options:0 error:nil];
+      if (data) tree = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+    }
+    BOOL changed = force || !tree || ![tree isEqualToString:_lastTree];
+    _lastTree = tree;
+    NSData *tapData = [NSJSONSerialization dataWithJSONObject:(pendingTaps ?: @[]) options:0 error:nil];
+    NSString *taps = tapData ? [[NSString alloc] initWithData:tapData encoding:NSUTF8StringEncoding] : @"[]";
+    [pendingTaps removeAllObjects];
+    NSString *out = [NSString stringWithFormat:@"{\"w\":%@,\"h\":%@,\"root\":%@,\"taps\":%@}", points(window.bounds.size.width), points(window.bounds.size.height), changed && tree ? tree : @"null", taps];
+    resolve(out);
+  } @catch (__unused NSException *exception) {
+    resolve([NSNull null]);
+  }
+}
+
+- (void)invalidate
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+    tapsEnabled = false;
+    [pendingTaps removeAllObjects];
+    [touchStarts removeAllObjects];
+  });
+}
+
+@end

package/package.json

@@ -1,6 +1,16 @@
 {
   "name": "@sansavision/apphelm-react-native-replay",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.8.0",
+  "description": "The native half of AppHelm's React Native session replay: describes the app's native views (Android and iOS) as wireframes for @sansavision/apphelm/react-native-replay. Never pixels; secure text is never read.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": { "types": "./index.d.ts", "import": "./index.js" }
+  },
+  "files": ["index.js", "index.d.ts", "ApphelmReactNativeReplay.podspec", "ios/ApphelmReplay.mm", "android/build.gradle", "android/src/main", "README.md", "CHANGELOG.md", "LICENSE"],
+  "peerDependencies": { "react": ">=18", "react-native": ">=0.71" },
+  "peerDependenciesMeta": { "react": { "optional": true }, "react-native": { "optional": true } },
+  "publishConfig": { "access": "public", "provenance": false }
+}