@scalebun/react-native 1.10.5 → 1.10.6

package/dist/scalebun.full.js

@@ -605,7 +605,7 @@ var SDK_VERSION;
 var init_version = __esm({
   "lib/module/core/constants/version.js"() {
     "use strict";
-    SDK_VERSION = "1.10.5";
+    SDK_VERSION = "1.10.6";
   }
 });
 
@@ -647,6 +647,15 @@ function staticDeviceContext() {
   if (c.Model) out.device_model = String(c.Model);
   if (c.Manufacturer) out.manufacturer = String(c.Manufacturer);
   else if (c.Brand) out.manufacturer = String(c.Brand);
+  else if (out.platform_os === "ios") out.manufacturer = "Apple";
+  return out;
+}
+function nativeDeviceContext(info) {
+  const out = {};
+  if (!info) return out;
+  if (info.osVersion) out.os_version = info.osVersion;
+  if (info.deviceModel) out.device_model = info.deviceModel;
+  if (info.manufacturer) out.manufacturer = info.manufacturer;
   return out;
 }
 function mergeDeviceContext(configured, detected = staticDeviceContext()) {
@@ -11232,6 +11241,27 @@ var init_EventTracker = __esm({
         }
         this.persistQueue();
       }
+      /**
+       * Fold in device facts that were not knowable at init.
+       *
+       * `Platform.constants` answers Android synchronously, so its model and manufacturer ride the
+       * very first event. iOS exposes neither there — only the native bridge knows, and the bridge is
+       * async and may not be installed at all. Without this the iOS half of every install reported no
+       * model whatsoever.
+       *
+       * `buildEnvelope` reads `cfg.context` per event, so applying it here reaches every event from
+       * the next one onward. Detected keys WIN over whatever the integrator configured, for the same
+       * reason `mergeDeviceContext` inverts the usual precedence: a measurement must not be
+       * overridable by a guess. Empty patches are ignored so a bridge that answered with nothing
+       * cannot blank a value the static path already found.
+       */
+      applyDetectedContext(patch) {
+        if (!patch || Object.keys(patch).length === 0) return;
+        this.cfg.context = {
+          ...this.cfg.context ?? {},
+          ...patch
+        };
+      }
       // ─── internals ─────────────────────────────────────────────────────────────
       buildEnvelope(eventName, properties) {
         const ctx = this.cfg.context ?? {};
@@ -17408,6 +17438,7 @@ var SDKBootstrapper = class {
 
 // lib/module/public/ScaleBunFacade.js
 init_EventTracker();
+init_bridgeAdapter();
 init_automaticEvents();
 
 // lib/module/analytics/eventLane.js
@@ -19925,6 +19956,8 @@ var ScaleBunFacade = class {
          * the whole time. The SDK knows the device; the integrator is guessing at it.
          * Everything outside the detected keys is still theirs.
          */
+        // Everything Platform.constants knows. On iOS that is neither the model nor the
+        // manufacturer, so the bridge completes it below once it answers.
         context: mergeDeviceContext(rawConfig?.context),
         // Use the same foreground id as replay/journey capture. The
         // callback is resolved per event because the session subsystem
@@ -19938,6 +19971,7 @@ var ScaleBunFacade = class {
       });
       this._eventTracker.start();
       __DEV__ && logger.info("[ScaleBun] Envelope event tracking started \u2192 /v1/batch.");
+      this._applyNativeDeviceContext(this._eventTracker);
       this._captureInstallReferrer(this._eventTracker);
       const tracker = this._eventTracker;
       this._configManager = new ConfigManager({
@@ -19956,6 +19990,25 @@ var ScaleBunFacade = class {
       logger.warn("[ScaleBun] Failed to start envelope event tracking:", err?.message);
     }
   }
+  /**
+   * Fold the native bridge's device facts into the analytics context once it answers.
+   *
+   * Detected values never overwrite a populated one with an empty one — `nativeDeviceContext`
+   * drops absent keys and `applyDetectedContext` ignores an empty patch — so a bridge that
+   * cannot answer leaves whatever `Platform.constants` already found.
+   */
+  _applyNativeDeviceContext(tracker) {
+    Promise.resolve().then(() => bridgeAdapter.getDeviceInfo()).then((info) => {
+      if (!info) return;
+      tracker.applyDetectedContext(nativeDeviceContext({
+        osVersion: info.osVersion,
+        deviceModel: info.deviceModel
+        // iOS ships no manufacturer over the bridge; it is a constant there and the
+        // static path already set it. Android's arrives via Platform.constants.
+      }));
+    }).catch(() => {
+    });
+  }
   /**
    * Android-only: read the Play Install Referrer once per install and route it into
    * attribution. `scalebun_click_id` → the deterministic click path; the full

package/dist/scalebun.slim.js

@@ -600,7 +600,7 @@ var SDK_VERSION;
 var init_version = __esm({
   "lib/module/core/constants/version.js"() {
     "use strict";
-    SDK_VERSION = "1.10.5";
+    SDK_VERSION = "1.10.6";
   }
 });
 
@@ -642,6 +642,15 @@ function staticDeviceContext() {
   if (c.Model) out.device_model = String(c.Model);
   if (c.Manufacturer) out.manufacturer = String(c.Manufacturer);
   else if (c.Brand) out.manufacturer = String(c.Brand);
+  else if (out.platform_os === "ios") out.manufacturer = "Apple";
+  return out;
+}
+function nativeDeviceContext(info) {
+  const out = {};
+  if (!info) return out;
+  if (info.osVersion) out.os_version = info.osVersion;
+  if (info.deviceModel) out.device_model = info.deviceModel;
+  if (info.manufacturer) out.manufacturer = info.manufacturer;
   return out;
 }
 function mergeDeviceContext(configured, detected = staticDeviceContext()) {
@@ -6528,6 +6537,27 @@ var init_EventTracker = __esm({
         }
         this.persistQueue();
       }
+      /**
+       * Fold in device facts that were not knowable at init.
+       *
+       * `Platform.constants` answers Android synchronously, so its model and manufacturer ride the
+       * very first event. iOS exposes neither there — only the native bridge knows, and the bridge is
+       * async and may not be installed at all. Without this the iOS half of every install reported no
+       * model whatsoever.
+       *
+       * `buildEnvelope` reads `cfg.context` per event, so applying it here reaches every event from
+       * the next one onward. Detected keys WIN over whatever the integrator configured, for the same
+       * reason `mergeDeviceContext` inverts the usual precedence: a measurement must not be
+       * overridable by a guess. Empty patches are ignored so a bridge that answered with nothing
+       * cannot blank a value the static path already found.
+       */
+      applyDetectedContext(patch) {
+        if (!patch || Object.keys(patch).length === 0) return;
+        this.cfg.context = {
+          ...this.cfg.context ?? {},
+          ...patch
+        };
+      }
       // ─── internals ─────────────────────────────────────────────────────────────
       buildEnvelope(eventName, properties) {
         const ctx = this.cfg.context ?? {};
@@ -14198,6 +14228,7 @@ var SDKBootstrapper = class {
 
 // lib/module/public/ScaleBunFacade.js
 init_EventTracker();
+init_bridgeAdapter();
 init_automaticEvents();
 
 // lib/module/analytics/eventLane.js
@@ -16714,6 +16745,8 @@ var ScaleBunFacade = class {
          * the whole time. The SDK knows the device; the integrator is guessing at it.
          * Everything outside the detected keys is still theirs.
          */
+        // Everything Platform.constants knows. On iOS that is neither the model nor the
+        // manufacturer, so the bridge completes it below once it answers.
         context: mergeDeviceContext(rawConfig?.context),
         // Use the same foreground id as replay/journey capture. The
         // callback is resolved per event because the session subsystem
@@ -16727,6 +16760,7 @@ var ScaleBunFacade = class {
       });
       this._eventTracker.start();
       __DEV__ && logger.info("[ScaleBun] Envelope event tracking started \u2192 /v1/batch.");
+      this._applyNativeDeviceContext(this._eventTracker);
       this._captureInstallReferrer(this._eventTracker);
       const tracker = this._eventTracker;
       this._configManager = new ConfigManager({
@@ -16745,6 +16779,25 @@ var ScaleBunFacade = class {
       logger.warn("[ScaleBun] Failed to start envelope event tracking:", err?.message);
     }
   }
+  /**
+   * Fold the native bridge's device facts into the analytics context once it answers.
+   *
+   * Detected values never overwrite a populated one with an empty one — `nativeDeviceContext`
+   * drops absent keys and `applyDetectedContext` ignores an empty patch — so a bridge that
+   * cannot answer leaves whatever `Platform.constants` already found.
+   */
+  _applyNativeDeviceContext(tracker) {
+    Promise.resolve().then(() => bridgeAdapter.getDeviceInfo()).then((info) => {
+      if (!info) return;
+      tracker.applyDetectedContext(nativeDeviceContext({
+        osVersion: info.osVersion,
+        deviceModel: info.deviceModel
+        // iOS ships no manufacturer over the bridge; it is a constant there and the
+        // static path already set it. Android's arrives via Platform.constants.
+      }));
+    }).catch(() => {
+    });
+  }
   /**
    * Android-only: read the Play Install Referrer once per install and route it into
    * attribution. `scalebun_click_id` → the deterministic click path; the full

package/ios/Core/DeviceIdentity.swift

@@ -0,0 +1,50 @@
+import Foundation
+
+/**
+ * The ONE place that answers "which iPhone is this?".
+ *
+ * iOS ships no API for the name a person would recognise. `UIDevice.current.model` returns the
+ * FAMILY — the literal string "iPhone" or "iPad" — which is identical on an iPhone 6 and an
+ * iPhone 17 Pro, so a dashboard grouping by it sees one bucket holding every iOS device ever.
+ * `ReplaySdk.getDeviceInfo` sent exactly that, which is why the replay lane could never tell two
+ * iPhones apart.
+ *
+ * The hardware identifier from `uname()` — "iPhone16,2" — is the only thing the OS will tell us,
+ * and it is unique per model. It is not the marketing name and this module does not pretend
+ * otherwise: turning "iPhone16,2" into "iPhone 15 Pro Max" needs a lookup table, and that table
+ * belongs on the server, where a device released after this binary shipped can be named without
+ * waiting for every app to adopt a new SDK and ship to the App Store.
+ *
+ * `ScaleBunProfilerModule` already had this function privately; both lanes now share it so they
+ * cannot drift into reporting two different models for one device.
+ */
+@objc(ScaleBunDeviceIdentity)
+public final class ScaleBunDeviceIdentity: NSObject {
+
+    /**
+     * The hardware identifier, e.g. "iPhone16,2" / "iPad14,3".
+     *
+     * On the simulator `uname` reports the HOST architecture ("x86_64", "arm64"), so the
+     * simulator's own hint is preferred when present — otherwise every developer's simulator
+     * session lands in the dashboard as a device model named after a CPU.
+     */
+    @objc public static func modelIdentifier() -> String {
+        if let simulator = ProcessInfo.processInfo
+            .environment["SIMULATOR_MODEL_IDENTIFIER"], !simulator.isEmpty {
+            return simulator
+        }
+        var systemInfo = utsname()
+        uname(&systemInfo)
+        let identifier = withUnsafePointer(to: &systemInfo.machine) {
+            $0.withMemoryRebound(to: CChar.self, capacity: 1) {
+                String(validatingUTF8: $0) ?? ""
+            }
+        }
+        // Empty rather than "Unknown": an absent measurement must not arrive looking like a value.
+        return identifier
+    }
+
+    // No manufacturer constant here on purpose. iOS's manufacturer is answerable without the
+    // bridge — the platform being iOS entails it — so staticDeviceContext() sets it on the FIRST
+    // event rather than waiting for a native round-trip that may never come back.
+}

package/ios/Profiler/ScaleBunProfilerModule.swift

@@ -392,15 +392,9 @@ class ScaleBunProfilerModule: RCTEventEmitter {
         sendEvent(withName: "ScaleBunProfiler_Capabilities", body: buildCapabilities())
     }
 
+    /** Shared with the replay lane so the two cannot report different models for one device. */
     private func deviceModel() -> String {
-        var systemInfo = utsname()
-        uname(&systemInfo)
-        let modelCode = withUnsafePointer(to: &systemInfo.machine) {
-            $0.withMemoryRebound(to: CChar.self, capacity: 1) {
-                String(validatingUTF8: $0) ?? "Unknown"
-            }
-        }
-        return modelCode
+        return ScaleBunDeviceIdentity.modelIdentifier()
     }
 
     private func isDebugBuild() -> Bool {

package/ios/ReplaySdk.swift

@@ -572,7 +572,9 @@ class ReplaySdk: RCTEventEmitter {
         resolve([
             "platform": "ios",
             "osVersion": device.systemVersion,
-            "deviceModel": device.model,
+            // NOT device.model — that is the family ("iPhone"), identical on every iPhone ever
+            // made. ScaleBunDeviceIdentity reports the hardware identifier, which is unique per model.
+            "deviceModel": ScaleBunDeviceIdentity.modelIdentifier(),
             "screenWidth": Int(screen.bounds.width * screen.scale),
             "screenHeight": Int(screen.bounds.height * screen.scale),
             "pixelDensity": screen.scale,

package/lib/commonjs/analytics/EventTracker.js

@@ -341,6 +341,28 @@ class EventTracker {
     this.persistQueue();
   }
 
+  /**
+   * Fold in device facts that were not knowable at init.
+   *
+   * `Platform.constants` answers Android synchronously, so its model and manufacturer ride the
+   * very first event. iOS exposes neither there — only the native bridge knows, and the bridge is
+   * async and may not be installed at all. Without this the iOS half of every install reported no
+   * model whatsoever.
+   *
+   * `buildEnvelope` reads `cfg.context` per event, so applying it here reaches every event from
+   * the next one onward. Detected keys WIN over whatever the integrator configured, for the same
+   * reason `mergeDeviceContext` inverts the usual precedence: a measurement must not be
+   * overridable by a guess. Empty patches are ignored so a bridge that answered with nothing
+   * cannot blank a value the static path already found.
+   */
+  applyDetectedContext(patch) {
+    if (!patch || Object.keys(patch).length === 0) return;
+    this.cfg.context = {
+      ...(this.cfg.context ?? {}),
+      ...patch
+    };
+  }
+
   // ─── internals ─────────────────────────────────────────────────────────────
 
   buildEnvelope(eventName, properties) {

package/lib/commonjs/core/constants/version.js

@@ -9,5 +9,5 @@ exports.SDK_VERSION = void 0;
  * can attribute telemetry to the SDK build that produced it.
  * Keep in sync with package.json "version".
  */
-const SDK_VERSION = exports.SDK_VERSION = '1.10.5';
+const SDK_VERSION = exports.SDK_VERSION = '1.10.6';
 //# sourceMappingURL=version.js.map

package/lib/commonjs/core/context/device.js

@@ -104,6 +104,10 @@ function staticDeviceContext() {
   if (osVersion) out.os_version = String(osVersion);
   if (c.Model) out.device_model = String(c.Model);
   if (c.Manufacturer) out.manufacturer = String(c.Manufacturer);else if (c.Brand) out.manufacturer = String(c.Brand);
+  // iOS exposes no manufacturer because it does not need to: every device running iOS is Apple's.
+  // A tautology, not a guess — and it means the field is populated on event #1 rather than waiting
+  // for a bridge that may never answer.
+  else if (out.platform_os === 'ios') out.manufacturer = 'Apple';
   return out;
 }
 
@@ -113,6 +117,7 @@ function nativeDeviceContext(info) {
   if (!info) return out;
   if (info.osVersion) out.os_version = info.osVersion;
   if (info.deviceModel) out.device_model = info.deviceModel;
+  if (info.manufacturer) out.manufacturer = info.manufacturer;
   return out;
 }
 

package/lib/commonjs/public/ScaleBunFacade.js

@@ -20,6 +20,7 @@ var _debug = require("../debug");
 var _api = require("../features/replay/public/api");
 var _SDKBootstrapper = require("../bootstrap/SDKBootstrapper");
 var _EventTracker = require("../analytics/EventTracker");
+var _bridgeAdapter = require("../features/replay/bridge/adapters/bridgeAdapter");
 var _automaticEvents = require("../analytics/automaticEvents");
 var _eventLane = require("../analytics/eventLane");
 var _ConfigManager = require("../config/ConfigManager");
@@ -313,6 +314,8 @@ class ScaleBunFacade {
          * the whole time. The SDK knows the device; the integrator is guessing at it.
          * Everything outside the detected keys is still theirs.
          */
+        // Everything Platform.constants knows. On iOS that is neither the model nor the
+        // manufacturer, so the bridge completes it below once it answers.
         context: (0, _device.mergeDeviceContext)(rawConfig?.context),
         // Use the same foreground id as replay/journey capture. The
         // callback is resolved per event because the session subsystem
@@ -327,6 +330,19 @@ class ScaleBunFacade {
       this._eventTracker.start();
       __DEV__ && _internalLogger.logger.info('[ScaleBun] Envelope event tracking started → /v1/batch.');
 
+      // Complete the device context from the native bridge.
+      //
+      // `Platform.constants` answers Android synchronously — model and manufacturer ride the
+      // first event. It answers NEITHER on iOS, so without this every iOS installation
+      // reported no device model at all: `nativeDeviceContext` existed for exactly this and
+      // had no caller, and the bridge's own answer was `UIDevice.current.model` — the string
+      // "iPhone", identical on every iPhone ever made.
+      //
+      // Fire-and-forget on purpose. The bridge is async and absent entirely on Expo Go or an
+      // older native binary; waiting on it would delay the first event, and failing on it
+      // would take analytics down over a nice-to-have field.
+      this._applyNativeDeviceContext(this._eventTracker);
+
       // Android: capture the Play Install Referrer once per install → feeds the
       // deterministic click_id path + a one-off install_referrer event (UTM/gclid).
       // Fire-and-forget; no-op off Android.
@@ -351,6 +367,24 @@ class ScaleBunFacade {
     }
   }
 
+  /**
+   * Fold the native bridge's device facts into the analytics context once it answers.
+   *
+   * Detected values never overwrite a populated one with an empty one — `nativeDeviceContext`
+   * drops absent keys and `applyDetectedContext` ignores an empty patch — so a bridge that
+   * cannot answer leaves whatever `Platform.constants` already found.
+   */
+  _applyNativeDeviceContext(tracker) {
+    Promise.resolve().then(() => _bridgeAdapter.bridgeAdapter.getDeviceInfo()).then(info => {
+      if (!info) return;
+      tracker.applyDetectedContext((0, _device.nativeDeviceContext)({
+        osVersion: info.osVersion,
+        deviceModel: info.deviceModel
+        // iOS ships no manufacturer over the bridge; it is a constant there and the
+        // static path already set it. Android's arrives via Platform.constants.
+      }));
+    }).catch(() => {/* bridge unavailable — the static context stands */});
+  }
   /**
    * Android-only: read the Play Install Referrer once per install and route it into
    * attribution. `scalebun_click_id` → the deterministic click path; the full

package/lib/module/analytics/EventTracker.js

@@ -336,6 +336,28 @@ export class EventTracker {
     this.persistQueue();
   }
 
+  /**
+   * Fold in device facts that were not knowable at init.
+   *
+   * `Platform.constants` answers Android synchronously, so its model and manufacturer ride the
+   * very first event. iOS exposes neither there — only the native bridge knows, and the bridge is
+   * async and may not be installed at all. Without this the iOS half of every install reported no
+   * model whatsoever.
+   *
+   * `buildEnvelope` reads `cfg.context` per event, so applying it here reaches every event from
+   * the next one onward. Detected keys WIN over whatever the integrator configured, for the same
+   * reason `mergeDeviceContext` inverts the usual precedence: a measurement must not be
+   * overridable by a guess. Empty patches are ignored so a bridge that answered with nothing
+   * cannot blank a value the static path already found.
+   */
+  applyDetectedContext(patch) {
+    if (!patch || Object.keys(patch).length === 0) return;
+    this.cfg.context = {
+      ...(this.cfg.context ?? {}),
+      ...patch
+    };
+  }
+
   // ─── internals ─────────────────────────────────────────────────────────────
 
   buildEnvelope(eventName, properties) {

package/lib/module/core/constants/version.js

@@ -3,5 +3,5 @@
  * can attribute telemetry to the SDK build that produced it.
  * Keep in sync with package.json "version".
  */
-export const SDK_VERSION = '1.10.5';
+export const SDK_VERSION = '1.10.6';
 //# sourceMappingURL=version.js.map

package/lib/module/core/context/device.js

@@ -92,6 +92,10 @@ export function staticDeviceContext() {
   if (osVersion) out.os_version = String(osVersion);
   if (c.Model) out.device_model = String(c.Model);
   if (c.Manufacturer) out.manufacturer = String(c.Manufacturer);else if (c.Brand) out.manufacturer = String(c.Brand);
+  // iOS exposes no manufacturer because it does not need to: every device running iOS is Apple's.
+  // A tautology, not a guess — and it means the field is populated on event #1 rather than waiting
+  // for a bridge that may never answer.
+  else if (out.platform_os === 'ios') out.manufacturer = 'Apple';
   return out;
 }
 
@@ -101,6 +105,7 @@ export function nativeDeviceContext(info) {
   if (!info) return out;
   if (info.osVersion) out.os_version = info.osVersion;
   if (info.deviceModel) out.device_model = info.deviceModel;
+  if (info.manufacturer) out.manufacturer = info.manufacturer;
   return out;
 }
 

package/lib/module/public/ScaleBunFacade.js

@@ -18,13 +18,14 @@ import { BugReportFeature } from '../features/bugreport/BugReportFeature';
 import { PersistentQueue } from '../pipeline/queue/persistentQueue';
 import { MemoryBackend, createStorageBackend } from '../storage/StorageBackend';
 import { getDeviceId } from '../core/id/deviceId';
-import { mergeDeviceContext, resolveEventPlatform } from '../core/context/device';
+import { mergeDeviceContext, nativeDeviceContext, resolveEventPlatform } from '../core/context/device';
 import { coreContainer } from '../core/di/container';
 import { flushQueue } from '../pipeline/queue/flushQueue';
 import { enableDebug as _enableDebug, disableDebug as _disableDebug, isDebugEnabled, addBreadcrumb as _addBreadcrumb, ping as _ping, _getStream, _setFlushFn, getPerformanceFeature as _getPerformanceFeature, requestExport as _requestExport, buildDebugConfigFromInitConfig, applyFeatureGatesToDebugConfig, sendDebugMetric } from '../debug';
 import { ReplaySdk } from '../features/replay/public/api';
 import { SDKBootstrapper } from '../bootstrap/SDKBootstrapper';
 import { EventTracker } from '../analytics/EventTracker';
+import { bridgeAdapter } from '../features/replay/bridge/adapters/bridgeAdapter';
 import { emitAutomaticEvent } from '../analytics/automaticEvents';
 import { resolveEventLane, isUploadedSessionEvent } from '../analytics/eventLane';
 import { ConfigManager } from '../config/ConfigManager';
@@ -307,6 +308,8 @@ class ScaleBunFacade {
          * the whole time. The SDK knows the device; the integrator is guessing at it.
          * Everything outside the detected keys is still theirs.
          */
+        // Everything Platform.constants knows. On iOS that is neither the model nor the
+        // manufacturer, so the bridge completes it below once it answers.
         context: mergeDeviceContext(rawConfig?.context),
         // Use the same foreground id as replay/journey capture. The
         // callback is resolved per event because the session subsystem
@@ -321,6 +324,19 @@ class ScaleBunFacade {
       this._eventTracker.start();
       __DEV__ && logger.info('[ScaleBun] Envelope event tracking started → /v1/batch.');
 
+      // Complete the device context from the native bridge.
+      //
+      // `Platform.constants` answers Android synchronously — model and manufacturer ride the
+      // first event. It answers NEITHER on iOS, so without this every iOS installation
+      // reported no device model at all: `nativeDeviceContext` existed for exactly this and
+      // had no caller, and the bridge's own answer was `UIDevice.current.model` — the string
+      // "iPhone", identical on every iPhone ever made.
+      //
+      // Fire-and-forget on purpose. The bridge is async and absent entirely on Expo Go or an
+      // older native binary; waiting on it would delay the first event, and failing on it
+      // would take analytics down over a nice-to-have field.
+      this._applyNativeDeviceContext(this._eventTracker);
+
       // Android: capture the Play Install Referrer once per install → feeds the
       // deterministic click_id path + a one-off install_referrer event (UTM/gclid).
       // Fire-and-forget; no-op off Android.
@@ -345,6 +361,24 @@ class ScaleBunFacade {
     }
   }
 
+  /**
+   * Fold the native bridge's device facts into the analytics context once it answers.
+   *
+   * Detected values never overwrite a populated one with an empty one — `nativeDeviceContext`
+   * drops absent keys and `applyDetectedContext` ignores an empty patch — so a bridge that
+   * cannot answer leaves whatever `Platform.constants` already found.
+   */
+  _applyNativeDeviceContext(tracker) {
+    Promise.resolve().then(() => bridgeAdapter.getDeviceInfo()).then(info => {
+      if (!info) return;
+      tracker.applyDetectedContext(nativeDeviceContext({
+        osVersion: info.osVersion,
+        deviceModel: info.deviceModel
+        // iOS ships no manufacturer over the bridge; it is a constant there and the
+        // static path already set it. Android's arrives via Platform.constants.
+      }));
+    }).catch(() => {/* bridge unavailable — the static context stands */});
+  }
   /**
    * Android-only: read the Play Install Referrer once per install and route it into
    * attribution. `scalebun_click_id` → the deterministic click path; the full

package/lib/typescript/analytics/EventTracker.d.ts

@@ -134,6 +134,21 @@ export declare class EventTracker {
     }): void;
     flush(): Promise<void>;
     stop(): void;
+    /**
+     * Fold in device facts that were not knowable at init.
+     *
+     * `Platform.constants` answers Android synchronously, so its model and manufacturer ride the
+     * very first event. iOS exposes neither there — only the native bridge knows, and the bridge is
+     * async and may not be installed at all. Without this the iOS half of every install reported no
+     * model whatsoever.
+     *
+     * `buildEnvelope` reads `cfg.context` per event, so applying it here reaches every event from
+     * the next one onward. Detected keys WIN over whatever the integrator configured, for the same
+     * reason `mergeDeviceContext` inverts the usual precedence: a measurement must not be
+     * overridable by a guess. Empty patches are ignored so a bridge that answered with nothing
+     * cannot blank a value the static path already found.
+     */
+    applyDetectedContext(patch: Record<string, string>): void;
     private buildEnvelope;
     private enqueue;
     private scheduleFlush;

package/lib/typescript/core/constants/version.d.ts

@@ -3,5 +3,5 @@
  * can attribute telemetry to the SDK build that produced it.
  * Keep in sync with package.json "version".
  */
-export declare const SDK_VERSION = "1.10.5";
+export declare const SDK_VERSION = "1.10.6";
 //# sourceMappingURL=version.d.ts.map

package/lib/typescript/core/context/device.d.ts

@@ -34,6 +34,7 @@ export declare function nativeDeviceContext(info: {
     platform?: string;
     osVersion?: string;
     deviceModel?: string;
+    manufacturer?: string;
 } | null): Record<string, string>;
 /**
  * Merge the integrator's context with what we detected — DETECTED WINS on the keys above.

package/lib/typescript/public/ScaleBunFacade.d.ts

@@ -80,6 +80,14 @@ declare class ScaleBunFacade {
     private _autoEnableDebug;
     /** Boot the Phase 1 envelope tracking lane if an appId is configured. */
     private _maybeStartEventTracker;
+    /**
+     * Fold the native bridge's device facts into the analytics context once it answers.
+     *
+     * Detected values never overwrite a populated one with an empty one — `nativeDeviceContext`
+     * drops absent keys and `applyDetectedContext` ignores an empty patch — so a bridge that
+     * cannot answer leaves whatever `Platform.constants` already found.
+     */
+    private _applyNativeDeviceContext;
     /**
      * Android-only: read the Play Install Referrer once per install and route it into
      * attribution. `scalebun_click_id` → the deterministic click path; the full

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scalebun/react-native",
-  "version": "1.10.5",
+  "version": "1.10.6",
   "description": "React Native SDK for ScaleBun",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/analytics/EventTracker.ts

@@ -387,6 +387,25 @@ export class EventTracker {
         this.persistQueue();
     }
 
+    /**
+     * Fold in device facts that were not knowable at init.
+     *
+     * `Platform.constants` answers Android synchronously, so its model and manufacturer ride the
+     * very first event. iOS exposes neither there — only the native bridge knows, and the bridge is
+     * async and may not be installed at all. Without this the iOS half of every install reported no
+     * model whatsoever.
+     *
+     * `buildEnvelope` reads `cfg.context` per event, so applying it here reaches every event from
+     * the next one onward. Detected keys WIN over whatever the integrator configured, for the same
+     * reason `mergeDeviceContext` inverts the usual precedence: a measurement must not be
+     * overridable by a guess. Empty patches are ignored so a bridge that answered with nothing
+     * cannot blank a value the static path already found.
+     */
+    applyDetectedContext(patch: Record<string, string>): void {
+        if (!patch || Object.keys(patch).length === 0) return;
+        this.cfg.context = { ...(this.cfg.context ?? {}), ...patch };
+    }
+
     // ─── internals ─────────────────────────────────────────────────────────────
 
     private buildEnvelope(eventName: string, properties?: Record<string, any>): Envelope {

package/src/core/constants/version.ts

@@ -3,4 +3,4 @@
  * can attribute telemetry to the SDK build that produced it.
  * Keep in sync with package.json "version".
  */
-export const SDK_VERSION = '1.10.5';
+export const SDK_VERSION = '1.10.6';

package/src/core/context/device.ts

@@ -114,6 +114,10 @@ export function staticDeviceContext(): Record<string, string> {
     if (c.Model) out.device_model = String(c.Model);
     if (c.Manufacturer) out.manufacturer = String(c.Manufacturer);
     else if (c.Brand) out.manufacturer = String(c.Brand);
+    // iOS exposes no manufacturer because it does not need to: every device running iOS is Apple's.
+    // A tautology, not a guess — and it means the field is populated on event #1 rather than waiting
+    // for a bridge that may never answer.
+    else if (out.platform_os === 'ios') out.manufacturer = 'Apple';
     return out;
 }
 
@@ -122,11 +126,13 @@ export function nativeDeviceContext(info: {
     platform?: string;
     osVersion?: string;
     deviceModel?: string;
+    manufacturer?: string;
 } | null): Record<string, string> {
     const out: Record<string, string> = {};
     if (!info) return out;
     if (info.osVersion) out.os_version = info.osVersion;
     if (info.deviceModel) out.device_model = info.deviceModel;
+    if (info.manufacturer) out.manufacturer = info.manufacturer;
     return out;
 }
 

package/src/public/ScaleBunFacade.ts

@@ -20,7 +20,7 @@ import { PersistentQueue } from '../pipeline/queue/persistentQueue';
 import { MemoryBackend, createStorageBackend } from '../storage/StorageBackend';
 import { HttpClient } from '../transport/http/httpClient';
 import { getDeviceId } from '../core/id/deviceId';
-import { mergeDeviceContext, resolveEventPlatform } from '../core/context/device';
+import { mergeDeviceContext, nativeDeviceContext, resolveEventPlatform } from '../core/context/device';
 import { coreContainer } from '../core/di/container';
 import { flushQueue } from '../pipeline/queue/flushQueue';
 import {
@@ -48,6 +48,7 @@ import type {
 } from '../features/replay/public/types';
 import { SDKBootstrapper } from '../bootstrap/SDKBootstrapper';
 import { EventTracker } from '../analytics/EventTracker';
+import { bridgeAdapter } from '../features/replay/bridge/adapters/bridgeAdapter';
 import {
     emitAutomaticEvent,
     type AutomaticEventName,
@@ -368,6 +369,8 @@ class ScaleBunFacade {
                  * the whole time. The SDK knows the device; the integrator is guessing at it.
                  * Everything outside the detected keys is still theirs.
                  */
+                // Everything Platform.constants knows. On iOS that is neither the model nor the
+                // manufacturer, so the bridge completes it below once it answers.
                 context: mergeDeviceContext(rawConfig?.context),
                 // Use the same foreground id as replay/journey capture. The
                 // callback is resolved per event because the session subsystem
@@ -384,6 +387,19 @@ class ScaleBunFacade {
             this._eventTracker.start();
             __DEV__ && logger.info('[ScaleBun] Envelope event tracking started → /v1/batch.');
 
+            // Complete the device context from the native bridge.
+            //
+            // `Platform.constants` answers Android synchronously — model and manufacturer ride the
+            // first event. It answers NEITHER on iOS, so without this every iOS installation
+            // reported no device model at all: `nativeDeviceContext` existed for exactly this and
+            // had no caller, and the bridge's own answer was `UIDevice.current.model` — the string
+            // "iPhone", identical on every iPhone ever made.
+            //
+            // Fire-and-forget on purpose. The bridge is async and absent entirely on Expo Go or an
+            // older native binary; waiting on it would delay the first event, and failing on it
+            // would take analytics down over a nice-to-have field.
+            this._applyNativeDeviceContext(this._eventTracker);
+
             // Android: capture the Play Install Referrer once per install → feeds the
             // deterministic click_id path + a one-off install_referrer event (UTM/gclid).
             // Fire-and-forget; no-op off Android.
@@ -405,6 +421,30 @@ class ScaleBunFacade {
         }
     }
 
+
+    /**
+     * Fold the native bridge's device facts into the analytics context once it answers.
+     *
+     * Detected values never overwrite a populated one with an empty one — `nativeDeviceContext`
+     * drops absent keys and `applyDetectedContext` ignores an empty patch — so a bridge that
+     * cannot answer leaves whatever `Platform.constants` already found.
+     */
+    private _applyNativeDeviceContext(tracker: EventTracker): void {
+        Promise.resolve()
+            .then(() => bridgeAdapter.getDeviceInfo())
+            .then(info => {
+                if (!info) return;
+                tracker.applyDetectedContext(
+                    nativeDeviceContext({
+                        osVersion: info.osVersion,
+                        deviceModel: info.deviceModel,
+                        // iOS ships no manufacturer over the bridge; it is a constant there and the
+                        // static path already set it. Android's arrives via Platform.constants.
+                    }),
+                );
+            })
+            .catch(() => { /* bridge unavailable — the static context stands */ });
+    }
     /**
      * Android-only: read the Play Install Referrer once per install and route it into
      * attribution. `scalebun_click_id` → the deterministic click path; the full