@sellwild/react-native-sdk 1.3.7 → 1.5.0

package/SellwildSDK-RN.podspec

@@ -28,6 +28,6 @@ Pod::Spec.new do |s|
   # The host app must already pull in SellwildSDK (the iOS SDK pod). We
   # depend on it explicitly so `pod install` resolves both with one
   # declaration in the host Podfile.
-  s.dependency 'SellwildSDK', '>= 1.3.5'
+  s.dependency 'SellwildSDK', '>= 1.4.0'
   s.dependency 'React-Core'
 end

package/android/build.gradle

@@ -76,7 +76,7 @@ dependencies {
     // The native SDK that owns SellwildAdView, SellwildPrebidMobile, etc.
     // Resolves to the published AAR off https://maven.sellwild.com/releases
     // for npm consumers, or to mavenLocal in the SDK monorepo dev workflow.
-    implementation "com.sellwild:sdk:1.3.5"
+    implementation "com.sellwild:sdk:1.4.1"
 }
 
 // Force kotlin-stdlib down to the bridge's declared Kotlin version. The

package/android/src/main/java/com/sellwild/rnsdk/RnGeo.kt

@@ -0,0 +1,31 @@
+package com.sellwild.rnsdk
+
+import com.facebook.react.bridge.ReadableMap
+import com.sellwild.sdk.SellwildGeo
+
+/**
+ * Marshals a bridged JS geo object (React `ReadableMap`) into the native
+ * [SellwildGeo]. Lives in the RN module (not core) because `ReadableMap` is a
+ * React type — the core SDK must not depend on React. Returns null when nothing
+ * usable is present, so callers can clear geo by passing an empty object.
+ */
+internal object RnGeo {
+    fun readableMapToGeo(map: ReadableMap?): SellwildGeo? {
+        if (map == null) return null
+        fun str(k: String) = if (map.hasKey(k) && !map.isNull(k)) map.getString(k) else null
+        fun dbl(k: String) = if (map.hasKey(k) && !map.isNull(k)) map.getDouble(k) else null
+        fun int(k: String) = if (map.hasKey(k) && !map.isNull(k)) map.getInt(k) else null
+        val geo = SellwildGeo(
+            country = str("country"),
+            state = str("state"),
+            city = str("city"),
+            zip = str("zip"),
+            metro = str("metro"),
+            lat = dbl("lat"),
+            lon = dbl("lon"),
+            type = int("type"),
+        )
+        // toOrtbGeo() returns null when every field is empty — treat that as "no geo".
+        return if (geo.toOrtbGeo() != null) geo else null
+    }
+}

package/android/src/main/java/com/sellwild/rnsdk/SellwildBannerViewManager.kt

@@ -8,6 +8,7 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.uimanager.events.RCTEventEmitter
 import com.sellwild.sdk.AdSize
+import com.sellwild.sdk.SellwildAdStack
 import com.sellwild.sdk.SellwildAdView
 import com.sellwild.sdk.SellwildConfig
 import org.json.JSONObject
@@ -52,6 +53,9 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
         var config: ReadableMap? = null,
         var size: String? = null,
         var zoneId: String? = null,
+        // Resolved ad stack ('both' | 'gamOnly' | 'prebidOnly'), computed in JS
+        // and applied as the native override.
+        var adStack: String? = null,
         // Guards against running fresh auctions on every JS re-render. We
         // only call setup() + load() once per identity tuple. Refresh of
         // the rendered ad is driven by the SDK's internal timer.
@@ -83,6 +87,14 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
                 }
                 emit(reactContext, adView, "onAdFailed", payload)
             }
+
+            override fun onAdResize(adView: SellwildAdView, width: Int, height: Int) {
+                val payload = com.facebook.react.bridge.Arguments.createMap().apply {
+                    putInt("width", width)
+                    putInt("height", height)
+                }
+                emit(reactContext, adView, "onAdResize", payload)
+            }
         }
         return view
     }
@@ -102,6 +114,11 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
         pendingFor(view).zoneId = value
     }
 
+    @ReactProp(name = "adStack")
+    fun setAdStack(view: SellwildAdView, value: String?) {
+        pendingFor(view).adStack = value
+    }
+
     override fun onAfterUpdateTransaction(view: SellwildAdView) {
         super.onAfterUpdateTransaction(view)
 
@@ -113,11 +130,14 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
         val adSize = adSizeFromLabel(sizeLabel) ?: return
 
         // Skip if the props identity hasn't changed since last apply.
-        val key = "$sizeLabel|$zoneId|${configMap.hashCode()}"
+        val key = "$sizeLabel|$zoneId|${p.adStack}|${configMap.hashCode()}"
         if (p.lastAppliedKey == key) return
         p.lastAppliedKey = key
 
         val config = configFromMap(configMap)
+        // JS resolves the stack from config and passes it as the override so
+        // RN is deterministic; native still reads the raw `remote` for the rest.
+        view.adStackOverride = p.adStack?.let { SellwildAdStack.parse(it) }
         view.setup(config, adSize, zoneId)
         view.load()
     }
@@ -136,6 +156,7 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
             .put("onAdImpression", MapBuilder.of("registrationName", "onAdImpression"))
             .put("onAdClicked", MapBuilder.of("registrationName", "onAdClicked"))
             .put("onAdFailed", MapBuilder.of("registrationName", "onAdFailed"))
+            .put("onAdResize", MapBuilder.of("registrationName", "onAdResize"))
             .build()
     }
 
@@ -174,6 +195,10 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
             val appStoreUrl = if (map.hasKey("appStoreUrl")) map.getString("appStoreUrl") else null
             val gamTag = if (map.hasKey("gamTag")) map.getString("gamTag") else null
             val debug = map.hasKey("debug") && map.getBoolean("debug")
+            val pbsDebug = map.hasKey("pbsDebug") && map.getBoolean("pbsDebug")
+            val geo = RnGeo.readableMapToGeo(
+                if (map.hasKey("geo") && !map.isNull("geo")) map.getMap("geo") else null
+            )
             val adRefreshMax = if (map.hasKey("adRefreshMax")) map.getInt("adRefreshMax") else 0
             val adRefreshMaxMobile = if (map.hasKey("adRefreshMaxMobile")) map.getInt("adRefreshMaxMobile") else 0
             val adRefreshIntervalMs = if (map.hasKey("adRefreshIntervalMs")) map.getDouble("adRefreshIntervalMs").toLong() else 30_000L
@@ -190,6 +215,8 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
                 appStoreUrl = appStoreUrl,
                 gamTag = gamTag,
                 debug = debug,
+                pbsDebug = pbsDebug,
+                geo = geo,
                 adRefreshMax = adRefreshMax,
                 adRefreshMaxMobile = adRefreshMaxMobile,
                 adRefreshIntervalMs = adRefreshIntervalMs,

package/android/src/main/java/com/sellwild/rnsdk/SellwildFeedViewManager.kt

@@ -162,6 +162,8 @@ class SellwildFeedViewManager : SimpleViewManager<SellwildFeedView>() {
             if (map.hasKey("appStoreUrl")) config = config.copy(appStoreUrl = map.getString("appStoreUrl"))
             if (map.hasKey("gamTag")) config = config.copy(gamTag = map.getString("gamTag"))
             if (map.hasKey("debug")) config = config.copy(debug = map.getBoolean("debug"))
+            if (map.hasKey("pbsDebug")) config = config.copy(pbsDebug = map.getBoolean("pbsDebug"))
+            if (map.hasKey("geo") && !map.isNull("geo")) config = config.copy(geo = RnGeo.readableMapToGeo(map.getMap("geo")))
             if (map.hasKey("adRefreshMax")) config = config.copy(adRefreshMax = map.getInt("adRefreshMax"))
             if (map.hasKey("adRefreshMaxMobile")) config = config.copy(adRefreshMaxMobile = map.getInt("adRefreshMaxMobile"))
             if (map.hasKey("adRefreshIntervalMs")) config = config.copy(adRefreshIntervalMs = map.getDouble("adRefreshIntervalMs").toLong())

package/android/src/main/java/com/sellwild/rnsdk/SellwildModule.kt

@@ -0,0 +1,67 @@
+package com.sellwild.rnsdk
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.sellwild.sdk.SellwildEid
+import com.sellwild.sdk.SellwildEidUid
+import com.sellwild.sdk.SellwildPrebidMobile
+
+/**
+ * React Native method module for the native Sellwild SDK's runtime setters.
+ *
+ * The RN ad surface is otherwise view-manager-only (config flows as a prop);
+ * this module is the one callable bridge for imperative, session-scoped calls
+ * like [setGeo]. Registered in [SellwildSdkPackage.createNativeModules]. The
+ * module name ("SellwildRNModule") matches the iOS `@objc(SellwildRNModule)` so
+ * JS resolves one `NativeModules.SellwildRNModule` on both platforms.
+ */
+class SellwildModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "SellwildRNModule"
+
+    /**
+     * JS: `SellwildRNModule.setGeo({ state: "NY", zip: "10001", ... })`.
+     * Pass an empty object to clear. Mirrors [SellwildPrebidMobile.setGeo] —
+     * updates the Prebid auction geo AND the shared SellwildGeoStore.
+     */
+    @ReactMethod
+    fun setGeo(geo: ReadableMap?) {
+        SellwildPrebidMobile.setGeo(RnGeo.readableMapToGeo(geo))
+    }
+
+    /**
+     * JS: `SellwildRNModule.setExternalUserIds([{ source, uids: [{ id, atype, ext? }] }])`.
+     * Pass `[]` to clear. Mirrors [SellwildPrebidMobile.setExternalUserIds].
+     */
+    @ReactMethod
+    fun setExternalUserIds(eids: ReadableArray?) {
+        SellwildPrebidMobile.setExternalUserIds(toEids(eids))
+    }
+
+    private fun toEids(arr: ReadableArray?): List<SellwildEid> {
+        if (arr == null) return emptyList()
+        val out = ArrayList<SellwildEid>()
+        for (i in 0 until arr.size()) {
+            val eid = arr.getMap(i) ?: continue
+            val source = if (eid.hasKey("source")) eid.getString("source") else null
+            val uidsArr = if (eid.hasKey("uids") && !eid.isNull("uids")) eid.getArray("uids") else null
+            if (source == null || uidsArr == null) continue
+            val uids = ArrayList<SellwildEidUid>()
+            for (j in 0 until uidsArr.size()) {
+                val u = uidsArr.getMap(j) ?: continue
+                val id = (if (u.hasKey("id")) u.getString("id") else null) ?: continue
+                val atype = if (u.hasKey("atype")) u.getInt("atype") else 0
+                @Suppress("UNCHECKED_CAST")
+                val ext = if (u.hasKey("ext") && !u.isNull("ext"))
+                    u.getMap("ext")?.toHashMap() as? Map<String, Any> else null
+                uids.add(SellwildEidUid(id, atype, ext))
+            }
+            out.add(SellwildEid(source, uids))
+        }
+        return out
+    }
+}

package/android/src/main/java/com/sellwild/rnsdk/SellwildSdkPackage.kt

@@ -8,7 +8,8 @@ import com.facebook.react.uimanager.ReactShadowNode
 import com.facebook.react.uimanager.ViewManager
 
 class SellwildSdkPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> = emptyList()
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(SellwildModule(reactContext))
 
     override fun createViewManagers(
         reactContext: ReactApplicationContext,

package/ios/SellwildBannerViewManager.m

@@ -14,11 +14,13 @@
 RCT_EXPORT_VIEW_PROPERTY(config, NSDictionary)
 RCT_EXPORT_VIEW_PROPERTY(size, NSString)
 RCT_EXPORT_VIEW_PROPERTY(zoneId, NSString)
+RCT_EXPORT_VIEW_PROPERTY(adStack, NSString)
 
 // Direct events emitted to JS callbacks.
 RCT_EXPORT_VIEW_PROPERTY(onAdLoaded, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onAdImpression, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onAdClicked, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onAdFailed, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onAdResize, RCTDirectEventBlock)
 
 @end

package/ios/SellwildBannerViewManager.swift

@@ -39,6 +39,9 @@ final class SellwildBannerHostView: UIView, SellwildAdViewDelegate {
     @objc var config: NSDictionary? { didSet { needsApply = true } }
     @objc var size: NSString? { didSet { needsApply = true } }
     @objc var zoneId: NSString? { didSet { needsApply = true } }
+    /// Resolved ad stack ('both' | 'gamOnly' | 'prebidOnly'), computed in JS.
+    /// Applied as the native override so RN is driven deterministically by JS.
+    @objc var adStack: NSString? { didSet { needsApply = true } }
 
     // MARK: RN events
 
@@ -46,6 +49,8 @@ final class SellwildBannerHostView: UIView, SellwildAdViewDelegate {
     @objc var onAdImpression: RCTDirectEventBlock?
     @objc var onAdClicked: RCTDirectEventBlock?
     @objc var onAdFailed: RCTDirectEventBlock?
+    /// Emitted with the rendered creative size so JS can resize the slot.
+    @objc var onAdResize: RCTDirectEventBlock?
 
     // MARK: Internals
 
@@ -79,7 +84,8 @@ final class SellwildBannerHostView: UIView, SellwildAdViewDelegate {
         // Skip if the props identity hasn't changed since last apply —
         // refresh of the rendered ad is driven by the SDK's internal
         // timer, not by JS re-renders.
-        let key = "\(sizeStr)|\(zid)|\(cfgMap.hash)"
+        let stackStr = (adStack as String?) ?? ""
+        let key = "\(sizeStr)|\(zid)|\(stackStr)|\(cfgMap.hash)"
         if lastAppliedKey == key { return }
         lastAppliedKey = key
 
@@ -90,14 +96,19 @@ final class SellwildBannerHostView: UIView, SellwildAdViewDelegate {
         adView?.removeFromSuperview()
 
         let view = SellwildAdView(config: sellwildConfig, adSize: adSize, zoneId: zid)
+        view.adStackOverride = (adStack as String?).flatMap { SellwildAdStack.parse($0) }
         view.delegate = self
         view.translatesAutoresizingMaskIntoConstraints = false
         addSubview(view)
+        // Fill the RN-sized host rather than hard-pinning to the primary size —
+        // the host's dimensions are driven by JS style, which the JS component
+        // updates from the onAdResize event so the slot tracks the actual
+        // rendered creative (multi-size fallback, video, capped native).
         NSLayoutConstraint.activate([
             view.leadingAnchor.constraint(equalTo: leadingAnchor),
             view.topAnchor.constraint(equalTo: topAnchor),
-            view.widthAnchor.constraint(equalToConstant: adSize.cgSize.width),
-            view.heightAnchor.constraint(equalToConstant: adSize.cgSize.height),
+            view.trailingAnchor.constraint(equalTo: trailingAnchor),
+            view.bottomAnchor.constraint(equalTo: bottomAnchor),
         ])
         adView = view
         view.load()
@@ -121,6 +132,10 @@ final class SellwildBannerHostView: UIView, SellwildAdViewDelegate {
         onAdFailed?(["message": error.localizedDescription])
     }
 
+    func sellwildAdView(_ adView: SellwildAdView, didRenderWithSize size: CGSize) {
+        onAdResize?(["width": size.width, "height": size.height])
+    }
+
     // MARK: Config marshalling
 
     /// Build a minimal SellwildConfig from a JS dictionary. Only the
@@ -134,8 +149,10 @@ final class SellwildBannerHostView: UIView, SellwildAdViewDelegate {
 
         if let v = map["appBundleId"] as? String { cfg.appBundleId = v }
         if let v = map["appStoreUrl"] as? String { cfg.appStoreUrl = v }
+        if let geoMap = map["geo"] as? [String: Any] { cfg.geo = SellwildGeo(bridged: geoMap) }
         if let v = map["gamTag"] as? String { cfg.gamTag = v }
         if let v = map["debug"] as? Bool { cfg.debug = v }
+        if let v = map["pbsDebug"] as? Bool { cfg.pbsDebug = v }
         if let v = map["adRefreshMax"] as? Int { cfg.adRefreshMax = v }
         if let v = map["adRefreshMaxMobile"] as? Int { cfg.adRefreshMaxMobile = v }
 

package/ios/SellwildFeedViewManager.swift

@@ -149,8 +149,10 @@ final class SellwildFeedHostView: UIView, SellwildFeedViewDelegate {
         if let v = map["slug"] as? String { cfg.slug = v }
         if let v = map["appBundleId"] as? String { cfg.appBundleId = v }
         if let v = map["appStoreUrl"] as? String { cfg.appStoreUrl = v }
+        if let geoMap = map["geo"] as? [String: Any] { cfg.geo = SellwildGeo(bridged: geoMap) }
         if let v = map["gamTag"] as? String { cfg.gamTag = v }
         if let v = map["debug"] as? Bool { cfg.debug = v }
+        if let v = map["pbsDebug"] as? Bool { cfg.pbsDebug = v }
         if let v = map["adRefreshMax"] as? Int { cfg.adRefreshMax = v }
         if let v = map["adRefreshMaxMobile"] as? Int { cfg.adRefreshMaxMobile = v }
         if let v = map["listingsUrl"] as? String { cfg.listingsUrl = v }

package/ios/SellwildRNModule.m

@@ -0,0 +1,10 @@
+#import <React/RCTBridgeModule.h>
+
+// Exposes the Swift SellwildRNModule to React Native. Method signatures must
+// match the @objc selectors in SellwildRNModule.swift.
+@interface RCT_EXTERN_MODULE(SellwildRNModule, NSObject)
+
+RCT_EXTERN_METHOD(setGeo:(NSDictionary *)geo)
+RCT_EXTERN_METHOD(setExternalUserIds:(NSArray *)eids)
+
+@end

package/ios/SellwildRNModule.swift

@@ -0,0 +1,42 @@
+import Foundation
+import SellwildSDK
+
+/// React Native method module for the native Sellwild SDK's runtime setters.
+///
+/// The RN ad surface is otherwise view-manager-only (config flows as a prop);
+/// this module is the one callable bridge for imperative, session-scoped calls
+/// like `setGeo`. Registered on iOS via `RCT_EXTERN_MODULE` (see the paired
+/// `SellwildRNModule.m`); no manual package wiring is needed.
+@objc(SellwildRNModule)
+final class SellwildRNModule: NSObject {
+
+    /// Off-main is fine — the setters just update process-wide state.
+    @objc static func requiresMainQueueSetup() -> Bool { false }
+
+    /// JS: `SellwildRNModule.setGeo({ state: "NY", zip: "10001", ... })`.
+    /// Pass an empty object to clear. Mirrors the native
+    /// `SellwildPrebidMobile.setGeo(_:)` — updates the Prebid auction geo AND the
+    /// shared `SellwildGeoStore`.
+    @objc(setGeo:)
+    func setGeo(_ geo: NSDictionary) {
+        let map = geo as? [String: Any] ?? [:]
+        SellwildPrebidMobile.setGeo(SellwildGeo(bridged: map))
+    }
+
+    /// JS: `SellwildRNModule.setExternalUserIds([{ source, uids: [{ id, atype, ext? }] }])`.
+    /// Pass `[]` to clear. Mirrors `SellwildPrebidMobile.setExternalUserIds(_:)`.
+    @objc(setExternalUserIds:)
+    func setExternalUserIds(_ eids: NSArray) {
+        let mapped: [SellwildEid] = (eids as? [[String: Any]] ?? []).compactMap { dict in
+            guard let source = dict["source"] as? String,
+                  let rawUids = dict["uids"] as? [[String: Any]] else { return nil }
+            let uids: [SellwildEidUID] = rawUids.compactMap { u in
+                guard let id = u["id"] as? String else { return nil }
+                let atype = (u["atype"] as? NSNumber)?.intValue ?? 0
+                return SellwildEidUID(id: id, atype: atype, ext: u["ext"] as? [String: Any])
+            }
+            return SellwildEid(source: source, uids: uids)
+        }
+        SellwildPrebidMobile.setExternalUserIds(mapped)
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellwild/react-native-sdk",
-  "version": "1.3.7",
+  "version": "1.5.0",
   "description": "Sellwild mobile advertising SDK for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/SellwildBanner.tsx

@@ -1,6 +1,6 @@
 import React from 'react'
 import { Platform, requireNativeComponent, UIManager, ViewStyle, View, Text, StyleSheet, NativeSyntheticEvent } from 'react-native'
-import type { SellwildConfig, AdSize } from '@sellwild/sdk-core'
+import { resolveAdStack, type SellwildConfig, type AdSize } from '@sellwild/sdk-core'
 
 // Standard IAB mobile ad sizes — used to lock the host View dimensions.
 // The actual ad size is also propagated to native as the `size` prop label.
@@ -13,6 +13,29 @@ const AD_DIMENSIONS: Record<AdSize, { width: number; height: number }> = {
   '1x1': { width: 1, height: 1 },
 }
 
+// Parse a BANNER_SIZES value — `["300x250","320x50"]` or `[[300,250],…]`,
+// possibly a JSON string — into {width,height}[]. Mirrors the native
+// SellwildAdSizes parser so the RN slot reasons about the same size set the
+// auction requests.
+function parseSizeList(raw: unknown): Array<{ width: number; height: number }> {
+  let arr: unknown = raw
+  if (typeof raw === 'string') {
+    try { arr = JSON.parse(raw) } catch { arr = [raw] }
+  }
+  if (!Array.isArray(arr)) return []
+  const out: Array<{ width: number; height: number }> = []
+  for (const e of arr) {
+    if (typeof e === 'string') {
+      const [w, h] = e.toLowerCase().split('x').map((s) => Number(s.trim()))
+      if (w > 0 && h > 0) out.push({ width: w, height: h })
+    } else if (Array.isArray(e) && e.length === 2) {
+      const w = Number(e[0]); const h = Number(e[1])
+      if (w > 0 && h > 0) out.push({ width: w, height: h })
+    }
+  }
+  return out
+}
+
 // ─── Native component bridge ─────────────────────────────────────────────────
 //
 // As of 1.3.0 the React Native banner is backed by a real native ad view —
@@ -29,11 +52,19 @@ interface NativeBannerProps {
   config: object
   size: string
   zoneId: string
+  /**
+   * Resolved ad stack ('both' | 'gamOnly' | 'prebidOnly'). Computed in JS from
+   * the config so RN is deterministic; native treats it as the highest-priority
+   * override. The raw `remote` payload still flows through `config` for
+   * everything else (bidders, GAM tag, etc.).
+   */
+  adStack: string
   style?: ViewStyle
   onAdLoaded?: (e: NativeSyntheticEvent<{}>) => void
   onAdImpression?: (e: NativeSyntheticEvent<{ zoneId: string }>) => void
   onAdClicked?: (e: NativeSyntheticEvent<{}>) => void
   onAdFailed?: (e: NativeSyntheticEvent<{ message: string }>) => void
+  onAdResize?: (e: NativeSyntheticEvent<{ width: number; height: number }>) => void
 }
 
 const NativeBanner = (() => {
@@ -69,7 +100,40 @@ export function SellwildBanner({
   onError,
 }: SellwildBannerProps) {
   const dim = AD_DIMENSIONS[size]
-  const containerStyle: ViewStyle = { width: dim.width, height: dim.height }
+
+  // The widest/tallest size the auction may return for this placement: the
+  // primary plus any BANNER_SIZES / BANNER_SIZES_BY_ZONE fallbacks. We reserve
+  // this as the slot's baseline so a wider or taller fallback creative — e.g. a
+  // 320x50 winning a 300-wide MREC request, where 320 > 300 — never clips
+  // before, or without, the onAdResize callback. This also covers the Android
+  // prebidOnly path, whose rendering BannerView doesn't surface the winning
+  // creative size (so onAdResize can't shrink it back down there).
+  const baseline = React.useMemo(() => {
+    const remote = (config.remote ?? {}) as Record<string, unknown>
+    const byZone = remote['BANNER_SIZES_BY_ZONE']
+    const zoned = byZone && typeof byZone === 'object'
+      ? (byZone as Record<string, unknown>)[String(zoneId)]
+      : undefined
+    const sizes = [dim, ...parseSizeList(zoned ?? remote['BANNER_SIZES'])]
+    return {
+      width: Math.max(...sizes.map((s) => s.width)),
+      height: Math.max(...sizes.map((s) => s.height)),
+    }
+  }, [dim, zoneId, config.remote])
+
+  // The slot starts at the reserved baseline, then tracks whatever the native
+  // side actually renders (onAdResize): a multi-size fallback creative, an
+  // outstream video, or the capped native template. Where the actual size is
+  // reported it shrinks the slot to fit; where it isn't (Android prebidOnly)
+  // the baseline reservation prevents a clip.
+  const [rendered, setRendered] = React.useState<{ width: number; height: number } | null>(null)
+  // Reset to the baseline when the placement identity changes.
+  React.useEffect(() => { setRendered(null) }, [size, zoneId])
+
+  const containerStyle: ViewStyle = {
+    width: rendered?.width ?? baseline.width,
+    height: rendered?.height ?? baseline.height,
+  }
 
   if (!NativeBanner) {
     // Native module not registered. Most common cause: iOS bridge not yet
@@ -95,8 +159,10 @@ export function SellwildBanner({
     partnerCode: config.partnerCode,
     appBundleId: config.appBundleId,
     appStoreUrl: config.appStoreUrl,
+    geo: config.geo,
     gamTag: config.gamTag,
     debug: config.debug,
+    pbsDebug: config.pbsDebug,
     adRefreshMax: config.adRefreshMax,
     adRefreshMaxMobile: config.adRefreshMaxMobile,
     adRefreshIntervalMs: config.adRefreshInterval,
@@ -110,6 +176,7 @@ export function SellwildBanner({
       config={nativeConfig}
       size={size}
       zoneId={String(zoneId)}
+      adStack={resolveAdStack(config, zoneId)}
       onAdLoaded={() => {
         // No-op event hook today; surfaced for future fill metrics.
       }}
@@ -119,6 +186,10 @@ export function SellwildBanner({
         const msg = e.nativeEvent?.message ?? 'Ad failed'
         onError?.(new Error(msg))
       }}
+      onAdResize={(e: NativeSyntheticEvent<{ width: number; height: number }>) => {
+        const { width, height } = e.nativeEvent ?? { width: 0, height: 0 }
+        if (width > 0 && height > 0) setRendered({ width, height })
+      }}
     />
   )
 }

package/src/SellwildFeed.tsx

@@ -117,8 +117,10 @@ export function SellwildFeed({
     slug: config.slug,
     appBundleId: config.appBundleId,
     appStoreUrl: config.appStoreUrl,
+    geo: config.geo,
     gamTag: config.gamTag,
     debug: config.debug,
+    pbsDebug: config.pbsDebug,
     adRefreshMax: config.adRefreshMax,
     adRefreshMaxMobile: config.adRefreshMaxMobile,
     adRefreshIntervalMs: config.adRefreshInterval,

package/src/commands.ts

@@ -0,0 +1,37 @@
+import { NativeModules } from 'react-native'
+import type { SellwildEid, SellwildGeo } from '@sellwild/sdk-core'
+
+// Imperative bridge to the native Sellwild method module. The ad surface is
+// otherwise view-manager-only (config flows as a prop on <SellwildBanner> /
+// <SellwildFeed>); this file exposes the session-scoped native setters.
+const SellwildRNModule = NativeModules.SellwildRNModule as
+  | {
+      setGeo?: (geo: Record<string, unknown>) => void
+      setExternalUserIds?: (eids: SellwildEid[]) => void
+    }
+  | undefined
+
+/**
+ * Set or update partner-supplied geo at runtime (OpenRTB `device.geo`) for
+ * native Prebid auctions, and seed the shared native geo store read by other
+ * surfaces (e.g. the listings feed). Pass `null` to clear.
+ *
+ * Prefer `config.geo` for the value known at configure time; use `setGeo` when
+ * location resolves or changes mid-session. No-op if the native module isn't
+ * linked (e.g. before autolinking, or on an unsupported platform).
+ */
+export function setGeo(geo: SellwildGeo | null): void {
+  // Native maps an empty object to "clear", so send {} for null.
+  SellwildRNModule?.setGeo?.((geo ?? {}) as Record<string, unknown>)
+}
+
+/**
+ * Set partner-supplied external/extended user IDs, emitted as OpenRTB
+ * `user.ext.eids` on every native Prebid auction. Pass `[]` to clear.
+ *
+ * Re-set on each launch (Prebid Mobile does not persist eids across restarts).
+ * No-op if the native module isn't linked.
+ */
+export function setExternalUserIds(eids: SellwildEid[]): void {
+  SellwildRNModule?.setExternalUserIds?.(eids ?? [])
+}

package/src/index.ts

@@ -13,6 +13,9 @@ export type { SellwildListingCardProps } from './SellwildListingCard'
 export { useSellwildListings } from './useSellwildListings'
 export type { UseSellwildListingsResult } from './useSellwildListings'
 
+// Imperative native setters (runtime, session-scoped).
+export { setGeo, setExternalUserIds } from './commands'
+
 // Re-export core types for convenience
 export type {
   SellwildConfig,
@@ -22,6 +25,9 @@ export type {
   SellwildPhoto,
   SellwildUser,
   PrebidServerConfig,
+  SellwildGeo,
+  SellwildEid,
+  SellwildEidUid,
   AdSize,
   AdPlacement,
   AdPlacementType,