@dashx/react-native 1.4.1 → 1.5.0

package/.claude/settings.local.json

@@ -1,31 +1,7 @@
 {
   "permissions": {
     "allow": [
-      "Bash(xcodebuild -scheme DashX -destination 'generic/platform=iOS')",
-      "Bash(grep -v \"^$\")",
-      "Bash(find /Users/gulshan/Work/dashx-demo-ios -name *.entitlements)",
-      "Bash(wc -l /Users/gulshan/Work/dashx-ios/Sources/DashX/*.swift)",
-      "Bash(swift build:*)",
-      "Bash(xcodebuild -scheme DashX -destination 'generic/platform=iOS' build)",
-      "Bash(./gradlew :dashx:compileDebugKotlin)",
-      "Bash(./gradlew :dashx:compileDebugKotlin --info)",
-      "Bash(gh pr:*)",
-      "WebFetch(domain:github.com)",
-      "WebFetch(domain:patch-diff.githubusercontent.com)",
-      "WebFetch(domain:raw.githubusercontent.com)",
-      "Bash(ls -la /Users/gulshan/Work/dashx-react-native/ios/DashXRCTAppDelegate*)",
-      "Bash(npx jest *)",
-      "Bash(ls *)",
-      "Bash(grep *)",
-      "Read(//private/tmp/**)",
-      "Bash(javap -p com/dashx/android/DashX.class)",
-      "Bash(javap -p 'com/dashx/android/DashX$Companion.class')",
-      "Bash(jar xf *)",
-      "Bash(javap 'com/dashx/android/DashX$Companion.class')",
-      "Bash(javap 'com/dashx/android/data/Asset.class')",
-      "Bash(javap 'com/dashx/android/data/AssetData.class')",
-      "Read(//Users/gulshan/Work/dashx-ios/**)",
-      "WebSearch"
+      "Bash(git fetch *)"
     ]
   }
 }

package/.claude/worktrees/autocapture-conventions-review-78f665/.gitattributes

@@ -0,0 +1 @@
+*.pbxproj -text

package/.claude/worktrees/autocapture-conventions-review-78f665/.github/workflows/ci.yml

@@ -0,0 +1,67 @@
+name: CI
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main, develop]
+
+jobs:
+  lint-and-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          cache: yarn
+
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile
+
+      - name: Lint
+        run: yarn lint
+
+      - name: Test
+        run: yarn test
+
+  # Android JVM unit tests for the bridge (see android/src/test). Runs
+  # standalone via the minimal `android/settings.gradle` + buildscript block
+  # added for this purpose — no consumer app checkout required. Scoped to
+  # PRs against `develop` and pushes to `main` per the team's release
+  # workflow (feature branches → develop, develop → main on release).
+  android-test:
+    runs-on: ubuntu-latest
+    if: >-
+      (github.event_name == 'push' && github.ref == 'refs/heads/main') ||
+      (github.event_name == 'pull_request' && github.base_ref == 'develop')
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - name: Cache Gradle
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('android/build.gradle', 'android/gradle/wrapper/gradle-wrapper.properties') }}
+          restore-keys: ${{ runner.os }}-gradle-
+
+      - name: Run Android unit tests
+        working-directory: android
+        run: ./gradlew :testDebugUnitTest --no-daemon
+
+      - name: Upload test report on failure
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: android-test-report
+          path: android/build/reports/tests/testDebugUnitTest

package/.claude/worktrees/autocapture-conventions-review-78f665/.gitignore

@@ -0,0 +1,49 @@
+
+# OSX
+#
+.DS_Store
+
+# node.js
+#
+node_modules/
+npm-debug.log
+yarn-error.log
+
+# Xcode
+#
+build/
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+xcuserdata
+*.xccheckout
+*.moved-aside
+DerivedData
+*.hmap
+*.ipa
+*.xcuserstate
+project.xcworkspace
+
+# Android/IntelliJ
+#
+build/
+.idea
+.gradle
+# Kotlin 2.x incremental-compile cache (errors/, sessions/). Per-dev,
+# regenerated on every compile.
+.kotlin/
+local.properties
+*.iml
+
+# BUCK
+buck-out/
+\.buckd/
+*.keystore
+
+# Cursor
+.cursor

package/.claude/worktrees/autocapture-conventions-review-78f665/.nvmrc

@@ -0,0 +1 @@
+v24

package/.claude/worktrees/autocapture-conventions-review-78f665/CHANGELOG.md

@@ -0,0 +1,144 @@
+# Changelog
+
+All notable changes to `@dashx/react-native` are documented in this file. Format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), versions follow [SemVer](https://semver.org/).
+
+## [1.5.0] — 2026-10-28
+
+### Required upgrade steps
+
+1. **Bump the dashx-ios pod tag to 1.6.1 in your `ios/Podfile`**. `pod install` refuses the upgrade otherwise, because the podspec floor is now `>= 1.6.1`:
+
+   ```ruby
+   pod 'DashX/SDK', :git => 'https://github.com/dashxhq/dashx-ios.git', :tag => '1.6.1'
+   ```
+
+### Breaking
+
+- **Automatic events are renamed by the native SDKs**, now dashx-ios 1.6.1 and dashx-android 1.5.0. Screen views are `$screen` with the screen name in `$screen_name` (was `Screen Viewed` with `name`), `dx_deep_link_opened` is `Deep Link Opened` and `dx_notification_navigated` is `Push Notification Tapped`, with their data unchanged. Reports, flows or filters on the old names or the `name` key need updating. Lifecycle event names and keys are unchanged.
+
+### Added
+
+- **`DashX.enableLifecycleTracking()` on Android.** Previously iOS only (a no-op on Android). It now registers the dashx-android activity lifecycle callbacks with the application context. Call it after `configure`. With dashx-android 1.5.0 these are app-level: one launch event per cold start, `Application Opened` with `from_background` on return and `Application Backgrounded` on leaving, not one per Activity change.
+- **`DashX.trackNavigation(navigationRef)`** for React Navigation. Sends a screen view for the current route once the `NavigationContainer` is ready, then one per change of the focused route's name, and returns a function that stops tracking. Screen views go through `DashX.screen`, which the native SDKs record as `$screen` with the route name in `$screen_name`. Route params are not sent. Works with any React Navigation version through its container ref, without a dependency on `@react-navigation/*`. Prefer it over native screen tracking: React Native screens are routes, not native view controllers or activities.
+
+## [1.4.1] — 2026-05-06
+
+### Required upgrade steps
+
+1. **Bump the dashx-ios pod tag to 1.5.1 in your `ios/Podfile`** — `pod install` will refuse the upgrade otherwise (the podspec floor is now `>= 1.5.1`):
+
+   ```ruby
+   pod 'DashX/SDK', :git => 'https://github.com/dashxhq/dashx-ios.git', :tag => '1.5.1'
+   ```
+
+   The floor is required because earlier dashx-ios versions either fall back to silent-push on the backend (pre-1.3.0, throttled by iOS) or omit `.timeSensitive` from the authorization request (pre-1.5.1, causing `interruption-level: time-sensitive` payloads to silently downgrade and stay filterable by Focus / Reduce Interruptions / Scheduled Summary on iOS 18 / 26).
+
+2. **Wire `fallbackToSettings: true` somewhere in your permission UI** to recover existing iOS users — fresh installs are auto-fixed by the upgrade, but users who already granted notification permission under the old SDK keep an `.authorized` state without the time-sensitive entitlement, and Apple's `requestAuthorization` is a one-shot grant that can't be silently upgraded. They have to flip the **Time Sensitive Notifications** toggle in iOS Settings themselves.
+
+   ```js
+   // From a "Notifications acting up?" affordance, or as a one-time
+   // post-upgrade prompt:
+   await DashX.requestNotificationPermission({ fallbackToSettings: true });
+   ```
+
+   When the user is already determined (granted or denied on iOS / permanently denied on Android), this opens the system notification settings page instead of firing a futile `requestAuthorization`. Without this step, your existing iOS users will keep experiencing the original "intermittent / second attempt works" symptom even after upgrading to 1.4.1.
+
+### Migration
+
+- **Consumers who subclass `DashXReactNativeModuleImpl`** and override `requestNotificationPermission(promise:)` need to update the override signature to `requestNotificationPermission(fallbackToSettings: Boolean, promise: Promise)`. Otherwise Kotlin's override resolution silently drops to the impl's version and your custom logic stops running. Same applies to anyone subclassing the new-arch / old-arch `DashXReactNativeModule` wrappers. Most consumers don't subclass these — flagged here for the few that do.
+
+### Added
+
+- **`DashX.requestNotificationPermission({ fallbackToSettings })`.** Optional flag, default `false`. When `true`, the SDK detects platform-specific dead-ends and opens the system notification-settings page instead of firing a futile prompt:
+  - **iOS** — already granted or denied (iOS no-ops `requestAuthorization` in that state).
+  - **Android** — `POST_NOTIFICATIONS` permanently denied (Android 13+, two-strikes rule). `requestPermissions()` auto-resolves DENIED without UI in that state.
+
+  Existing call sites (`DashX.requestNotificationPermission()` with no arguments) compile and behave unchanged.
+
+### Fixed
+
+- **Foreground push duplicate-display race in `DashXNotificationHandler.handleRemoteNotification`.** Now short-circuits when the payload already carries `aps.alert`, letting iOS render the notification natively via NSE / `willPresent` instead of racing a duplicate `UNUserNotificationCenter.add(...)` against it. Without the short-circuit the local re-add could clobber the NSE-attached image or briefly flicker on screen.
+- **Suspension race in the image-attached reconstruction path.** The `fetchCompletionHandler` now fires only after the async image download and the local `add()` both complete, with a 25-second budget under iOS's background-push limit. Previously the handler fired immediately while the download was still in flight, letting iOS suspend the process before the notification actually displayed.
+
+## [1.4.0] — 2026-04-27
+
+### Changed
+
+- **`DashX.unsubscribe()` now returns `Promise<{ success: boolean }>`** (was `void`). Matches `@dashx/browser`'s shape exactly — apps using a Metro `.web.ts` resolver can now share a single typed callsite across web and native.
+
+  **Migration**
+
+  Most existing call sites continue to work unchanged:
+
+  ```ts
+  DashX.unsubscribe()                          // ✓ fire-and-forget still works
+  await DashX.unsubscribe()                    // ✓ still works (return value just unused)
+  const { success } = await DashX.unsubscribe()  // new capability
+  ```
+
+  Two situations to watch for after upgrading:
+
+  - **Unhandled-rejection warnings.** Previously the native module surfaced errors only in its own logs; the JS API was silent. Now JS-side promise rejections fire on SDK-state problems (Firebase Messaging dependency missing, `configure()` not yet called) and transport failures (Firebase `deleteToken` failure, GraphQL / network errors). If you never caught errors before because there was nothing to catch, a fire-and-forget `DashX.unsubscribe()` may now surface "Possible Unhandled Promise Rejection" warnings in your console. Wrap with `.catch(...)` or `try / await` if those warnings are noisy.
+  - **TypeScript `: void` annotations.** `const x: void = DashX.unsubscribe()` no longer compiles. Vanishingly rare in practice but worth a grep.
+
+  **What the resolved value means**
+
+  - **`success: true`** — backend found and unsubscribed a matching contact.
+  - **`success: false`** — non-error outcome meaning "no matching contact found"; typically the anonymous UID rotated since subscribe, the FCM token is stale, the contact is already unsubscribed, or `unsubscribe()` was called on a device that never subscribed in this session. The device ends up unsubscribed in either case; the boolean is useful for diagnostics and analytics.
+  - **Promise rejection** — distinct from `success: false` so callers can branch on SDK-misuse vs legitimate no-match.
+
+- **Native pin bumps to pick up the underlying schema change:**
+  - `android/build.gradle` → `com.dashx:dashx-android` `1.2.7` → `1.2.8`. The bridge now passes `onSuccess` / `onError(DashXError)` callbacks to the native `DashX.unsubscribe(...)` and resolves/rejects the JS promise accordingly.
+  - iOS pod consumers should bump `pod 'DashX/SDK'` to `:tag => '1.5.0'` in their Podfile. The bridge now calls `DashX.unsubscribe { result in ... }` and resolves/rejects the JS promise from the `Result<Bool, Error>` completion.
+
+## [1.3.2] — 2026-04-22
+
+### Added
+- **`DashX.onPushNotificationReceived(callback)`** — new name for registering a foreground push listener. Same signature, same subscription shape; matches the `@dashx/browser` API so cross-platform apps using a Metro `.web.ts` wrapper can share the callsite.
+
+### Deprecated
+- **`DashX.onMessageReceived(callback)`** is now a deprecated alias of `onPushNotificationReceived` and logs a one-time `console.warn` on first call. The name leaked up from Android's Firebase `FirebaseMessagingService.onMessageReceived` override and was ambiguous in the DashX domain ("message" overloaded with `trackMessage` and in-app notifications). Scheduled for removal in the next major version.
+
+## [1.3.1] — 2026-04-21
+
+### Added
+- **`DashX.onNotificationClicked` now fires on Android.** Previously only wired on iOS — the Android bridge didn't register a `DashXNotificationListener` with the SDK, so JS listeners never received tap events. The bridge now registers a listener in `DashXReactNativeModuleImpl.initialize()` and emits a `notificationClicked` event matching the iOS shape: `{ notification, action, actionIdentifier }`. `actionIdentifier` is the tapped button's identifier (body tap → empty string, matching iOS's always-a-string contract).
+- Android JVM unit tests for the kotlinx-serialization conversion helpers (`Utils.kt`) — 16 tests covering all primitive types, nested objects/arrays, null handling, round-trips, and regression cases for the two pre-migration crash paths. Runs as a dedicated `android-test` CI job on PRs to `develop` and pushes to `main`.
+
+### Changed
+- **Android JSON handling consolidated on kotlinx-serialization.** Removed the Gson dependency and the `org.json`-shaped helpers (`MapUtil.java`, `ArrayUtil.java`), rewrote `Utils.kt` to use kotlinx `JsonObject` / `JsonArray` end-to-end. Matches how dashx-android itself serializes (its Apollo scalar mapping is `kotlinx.serialization.json.JsonObject`), eliminates the string round-trips the previous cross-library code was doing, and removes a class of bugs where three JSON libraries coexisted. Internal helper signatures changed (`convertMapToJson` now returns `JsonObject?`, `convertJsonToMap` now takes `JsonObject?`); consumer JS API is unchanged.
+- `android/build.gradle` dep on `com.dashx:dashx-android` bumped `1.2.6` → `1.2.7` to receive the new 3-arg `onNotificationClicked(payload, action, actionIdentifier)` listener overload.
+
+### Fixed
+- `uploadAsset` / `fetchAsset` on Android previously failed to compile against `@dashx/react-native` due to a type mismatch in the TurboModule-migration callsite (`org.json.JSONObject` passed to a Gson `JsonObject`-typed helper, introduced in 1.2.0's TurboModule PR and never caught because no Android consumer had built the bridge since). Fixed by the Gson → kotlinx migration described above.
+
+## [1.3.0] — 2026-04-20
+
+### Breaking
+- **`DashX` pod → `DashX/SDK`.** The podspec now depends on the `DashX/SDK` subspec of [dashx-ios 1.4.0+](https://github.com/dashxhq/dashx-ios) with no version constraint. Consumers must update their Podfile:
+  ```ruby
+  # before
+  pod 'DashX', :git => 'https://github.com/dashxhq/dashx-ios.git', :tag => '1.1.9'
+
+  # after
+  pod 'DashX/SDK', :git => 'https://github.com/dashxhq/dashx-ios.git', :tag => '1.4.0'
+  ```
+- **`FirebaseMessaging` is now a hard dependency.** Previously the bridge guarded Firebase usage with `#if canImport(FirebaseMessaging)`, but `canImport` doesn't see consumer-Podfile pods at this pod's compile time, so the guard silently elided every FCM code path — push registration stopped working on fresh installs. Consumers must enable modular headers in their Podfile:
+  ```ruby
+  use_modular_headers!
+  # or, per-pod:
+  pod 'FirebaseMessaging', :modular_headers => true
+  ```
+
+### Added
+- `DashX.onNotificationClicked(callback)` — fires when the user taps a DashX notification or one of its action buttons. Callback receives `{ notification, action, actionIdentifier }` where `action` is a resolved `NavigationAction` (`deepLink` / `screen` / `richLanding` / `clickAction`) or `null`.
+- `DashXNotificationResponseResult.navigationAction` — new Swift-only field on the helper result type returned by `DashXNotificationHandler.handleNotificationResponse(_:)`.
+- `NotificationClickedEvent` exported from `index.d.ts`.
+
+### Fixed
+- **iOS dev builds silently failing to receive pushes.** `Messaging.messaging().setAPNSToken(_, type: .unknown)` sometimes mis-tagged the APNs environment on dev-signed binaries, producing an FCM token whose pushes 410'd at Apple. The bridge now forces `.sandbox` in `DEBUG` configurations and `.prod` otherwise.
+- **`DashX.setIdentity(uid, token)` now passes `null` / `""` / `undefined` through to the native SDK unchanged** (apart from normalizing `undefined → null`, since the RN bridge can't carry `undefined`). Previously the JS wrapper threw on `null` / `""` / `undefined` for `uid`, contradicting the nullable signatures on iOS (`NSString?`) and Android (`String?`). TypeScript signature updated: `setIdentity(uid: string | null, token?: string | null): void`.
+
+## [1.2.0] — 2026-04-16
+
+Previous release — see git log.

package/.claude/worktrees/autocapture-conventions-review-78f665/CONTRIBUTING.md

@@ -0,0 +1,190 @@
+# Contributing to @dashx/react-native
+
+## Prerequisites
+
+- Node.js >= 16
+- Yarn
+- Xcode (for iOS)
+- Android Studio with JDK 17 (for Android)
+- CocoaPods (`gem install cocoapods`)
+
+## Getting Started
+
+1. Clone the repository:
+
+```sh
+git clone https://github.com/dashxhq/dashx-react-native.git
+cd dashx-react-native
+```
+
+2. Install dependencies:
+
+```sh
+yarn install
+```
+
+3. Run tests:
+
+```sh
+yarn test
+```
+
+4. Run lint:
+
+```sh
+yarn lint
+```
+
+## Building the SDK Locally
+
+### Android
+
+The Android bridge lives in `android/` and is a Gradle library module that is built as part of a React Native app — it cannot be built standalone because it depends on the React Native Gradle plugin and Android SDK provided by the host app.
+
+To build and test locally, use a React Native demo app (e.g. `dashx-demo-react-native`):
+
+1. In the demo app's `package.json`, point to your local SDK checkout:
+
+```json
+"dependencies": {
+  "@dashx/react-native": "file:../dashx-react-native"
+}
+```
+
+2. Install and build:
+
+```sh
+cd dashx-demo-react-native
+yarn install
+cd android
+./gradlew assembleDebug
+```
+
+3. **To test with a local `dashx-android` SDK build**, publish it to local Maven and add `mavenLocal()` to the demo app's `android/build.gradle` repositories:
+
+```sh
+# In dashx-android:
+./gradlew publishToMavenLocal
+
+# In dashx-react-native/android/build.gradle, add:
+repositories {
+    mavenLocal()
+    // ...
+}
+```
+
+### iOS
+
+The iOS bridge lives in `ios/` and is distributed as a CocoaPod (`DashXReactNative.podspec`). Like Android, it is built as part of a React Native app's Xcode workspace.
+
+To build and test locally, use a React Native demo app (e.g. `dashx-demo-react-native`):
+
+1. In the demo app's `package.json`, point to your local SDK checkout:
+
+```json
+"dependencies": {
+  "@dashx/react-native": "file:../dashx-react-native"
+}
+```
+
+2. Install dependencies and pods:
+
+```sh
+cd dashx-demo-react-native
+yarn install
+cd ios
+pod install
+```
+
+3. Build from Xcode by opening the `.xcworkspace`, or from the command line:
+
+```sh
+xcodebuild -workspace ios/DashXDemoReactNative.xcworkspace \
+  -scheme DashXDemoReactNative \
+  -destination 'generic/platform=iOS Simulator' \
+  build
+```
+
+4. **To test with a local `dashx-ios` SDK build**, add a path override in the demo app's `Podfile`:
+
+```ruby
+pod 'DashX', :path => '../../dashx-ios'
+```
+
+Then re-run `pod install`.
+
+## Project Structure
+
+```
+dashx-react-native/
+  index.js              # JS bridge — public API surface
+  index.d.ts            # TypeScript type definitions
+  android/
+    src/main/java/com/dashx/rn/sdk/
+      DashXReactNativeModule.kt   # Android native module
+      DashXReactNativePackage.kt  # Package registration
+      DashXReactNativeFirebaseMessagingService.kt  # FCM service
+      util/                       # Bridge conversion utilities
+    build.gradle                  # Android build config
+  ios/
+    DashXReactNative.swift        # iOS native module — SOURCE OF TRUTH for bridge methods
+    DashXReactNative.mm           # Obj-C++ bridge exports — AUTO-GENERATED, see below
+    DashXEventEmitter.swift       # Event emitter for push notifications
+    DashXRCTAppDelegate.swift     # AppDelegate with Firebase/push handling
+  scripts/
+    generate-bridge-shim.js       # Regenerates DashXReactNative.mm from the Swift @objc decls
+  DashXReactNative.podspec        # CocoaPods spec
+  __tests__/                      # Jest tests
+```
+
+## iOS bridge: editing methods
+
+`ios/DashXReactNative.mm` is **auto-generated** from `ios/DashXReactNative.swift`.
+Don't hand-edit it — your changes will be overwritten on the next regen, and CI
+will fail anyway because the committed `.mm` won't match what the script
+produces.
+
+Workflow when adding or changing a bridged method:
+
+1. Edit `ios/DashXReactNative.swift`. Each bridged method needs an `@objc`
+   decoration. Multi-arg methods use the explicit form
+   `@objc(methodName:label1:label2:)`; zero-arg methods use bare `@objc`.
+2. Run the regen:
+   ```sh
+   yarn sync-bridge-shim
+   ```
+3. Commit both the Swift change AND the regenerated `ios/DashXReactNative.mm`
+   in the same PR.
+
+CI verification: `yarn lint` chains `yarn check-bridge-shim`, which re-runs
+the generator and fails on a non-empty `git diff` against the committed
+`.mm`. So a forgotten `sync-bridge-shim` step is caught at PR time, not in
+production.
+
+Why the `.mm` exists at all: React Native's iOS bridge requires every Swift
+method to be declared in BOTH the Swift `@objc` form (for runtime dispatch)
+AND in `RCT_EXTERN_METHOD(...)` form in an Obj-C++ shim (for old-arch
+consumers' bridge module registration + new-arch compile-time selector
+verification). The script makes the Swift declarations the single source of
+truth and emits the matching shim mechanically.
+
+If the script ever fails with `unknown Swift parameter type "..."`, add a
+mapping for that type in `scripts/generate-bridge-shim.js`'s
+`SWIFT_TO_OBJC` table (one line, then re-run).
+
+## Running Tests
+
+```sh
+yarn test
+```
+
+Tests mock the React Native native modules and verify the JS bridge layer: input validation, native method delegation, promise handling, and event listener registration.
+
+## Publishing
+
+Use `yarn publish` to bump the version and release to npm:
+
+```sh
+yarn publish
+git push origin main
+```

package/.claude/worktrees/autocapture-conventions-review-78f665/DashXReactNative.podspec

@@ -0,0 +1,38 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "DashXReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "13.0" }
+  s.source       = { :git => "https://github.com/dashxhq/dashx-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.requires_arc = true
+
+  # React Native >= 0.71 provides install_modules_dependencies.
+  # Since our minimum supported RN version is 0.74, we can call it directly.
+  install_modules_dependencies(s)
+
+  # DashX iOS SDK — consumers must provide the source in their Podfile:
+  #   pod 'DashX/SDK', :git => 'https://github.com/dashxhq/dashx-ios.git', :tag => '1.6.1'
+  # For local development:
+  #   pod 'DashX', :path => '../dashx-ios'
+  #
+  # Floor of 1.6.1, the first release whose automatic event names match
+  # dashx-android 1.5.0 ($screen, Deep Link Opened, Push Notification Tapped).
+  s.dependency "DashX/SDK", ">= 1.6.1"
+
+  # Hard dependency so that `canImport(FirebaseMessaging)`
+  # evaluates at this pod's compile time, where consumer-Podfile pods aren't
+  # visible — so an "optional" guard silently elides every Firebase code path.
+  # Consumers should set `use_modular_headers!` (or `:modular_headers => true`
+  # on FirebaseMessaging) in their Podfile so this Swift import resolves.
+  s.dependency "FirebaseMessaging"
+end

package/.claude/worktrees/autocapture-conventions-review-78f665/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 DashX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/.claude/worktrees/autocapture-conventions-review-78f665/README.md

@@ -0,0 +1,97 @@
+<p align="center">
+    <br />
+    <a href="https://dashx.com"><img src="https://raw.githubusercontent.com/dashxhq/brand-book/master/assets/logo-black-text-color-icon@2x.png" alt="DashX" height="40" /></a>
+    <br />
+    <br />
+    <strong>Your All-in-One Product Stack</strong>
+</p>
+
+<div align="center">
+  <h4>
+    <a href="https://dashx.com">Website</a>
+    <span> | </span>
+    <a href="https://docs.dashx.com">Documentation</a>
+  </h4>
+</div>
+
+<br />
+
+# @dashx/react-native
+
+[![npm version](https://img.shields.io/npm/v/@dashx/react-native.svg)](https://www.npmjs.com/package/@dashx/react-native)
+[![license](https://img.shields.io/npm/l/@dashx/react-native.svg)](https://github.com/dashxhq/dashx-react-native/blob/main/LICENSE)
+[![platforms](https://img.shields.io/badge/platforms-Android%20%7C%20iOS-brightgreen.svg)](#install)
+
+_DashX SDK for React Native_
+
+## Install
+
+Requires **React Native 0.74+**, **iOS 13.0+**, **Android SDK 26+**, and **Node.js 16+**.
+
+Supports both the **Old Architecture** (bridge) and **New Architecture** (TurboModule) from a single install.
+
+> **Note:** This SDK uses native modules and is **not compatible with Expo Go**. Use a [development build](https://docs.expo.dev/develop/development-builds/introduction/) if you are using Expo.
+
+```sh
+npm install @dashx/react-native
+```
+
+or
+
+```sh
+yarn add @dashx/react-native
+```
+
+## Documentation
+
+For detailed documentation, visit [React Native SDK documentation](https://docs.dashx.com/sdks/client-side/react-native-sdk).
+
+## Automatic events
+
+### App lifecycle
+
+On iOS and Android, call `enableLifecycleTracking()` after `configure` to send these events:
+
+- `Application Installed` and `Application Updated` on the first launch of a new install or build
+- `Application Opened` on launch and when returning to the foreground (`from_background`)
+- `Application Backgrounded` when the app leaves the foreground (`session_length`, in seconds)
+- `Application Crashed` on an uncaught native exception (iOS only)
+
+```js
+DashX.configure({ publicKey: 'YOUR_PUBLIC_KEY' });
+DashX.enableLifecycleTracking();
+```
+
+### Screen views with React Navigation
+
+React Native screens are routes rather than native screens, so track them from the navigation container. `trackNavigation` sends `DashX.screen(route.name)`, recorded as `$screen` with the route name in `$screen_name`, for the first route and then whenever the focused route's name changes. Route params are not sent. Call it from `onReady` so the first screen is captured; it returns a function that stops tracking.
+
+```jsx
+import { NavigationContainer, useNavigationContainerRef } from '@react-navigation/native';
+import DashX from '@dashx/react-native';
+
+export default function App() {
+  const navigationRef = useNavigationContainerRef();
+
+  return (
+    <NavigationContainer
+      ref={navigationRef}
+      onReady={() => DashX.trackNavigation(navigationRef)}
+    >
+      {/* ... */}
+    </NavigationContainer>
+  );
+}
+```
+
+## Deep linking and push navigation
+
+See the [Deep Linking & Push Navigation](https://docs.dashx.com/apps/messaging/deep-linking) guide for setup instructions, payload fields, and code examples.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and workflow.
+
+## License
+
+MIT