@shortkitsdk/react-native 0.2.14 → 0.2.15

package/android/src/main/java/com/shortkit/reactnative/ShortKitBridge.kt

@@ -28,6 +28,7 @@ import com.shortkit.sdk.config.FeedSource
 import com.shortkit.sdk.config.ScrollAxis
 import com.shortkit.sdk.config.SurveyOverlayMode
 import com.shortkit.sdk.config.VideoCarouselOverlayMode
+import com.shortkit.sdk.feed.ShortKitRefreshState
 import com.shortkit.sdk.config.VideoOverlayMode
 import com.shortkit.sdk.feed.FeedPreload
 import com.shortkit.sdk.feed.ShortKitFeedFragment
@@ -162,6 +163,8 @@ class ShortKitBridge(
                 val scrollAxisStr = obj.optString("scrollAxis", "vertical")
                 val scrollAxis = if (scrollAxisStr == "horizontal") ScrollAxis.Horizontal else ScrollAxis.Vertical
 
+                val pullToRefreshEnabled = obj.optBoolean("pullToRefreshEnabled", true)
+
                 FeedConfig(
                     feedHeight = feedHeight,
                     videoOverlay = videoOverlay,
@@ -174,6 +177,7 @@ class ShortKitBridge(
                     feedSource = feedSource,
                     filter = filter,
                     scrollAxis = scrollAxis,
+                    pullToRefreshEnabled = pullToRefreshEnabled,
                 )
             } catch (e: Exception) {
                 android.util.Log.e("SK:Bridge", "parseFeedConfig: EXCEPTION parsing config, returning default. json=${json.take(300)}", e)
@@ -488,6 +492,7 @@ class ShortKitBridge(
     private val feedRegistry = mutableMapOf<String, WeakReference<ShortKitFeedFragment>>()
     private val pendingOps = mutableMapOf<String, MutableList<(ShortKitFeedFragment) -> Unit>>()
     private val pendingOpsLock = Any()
+    private var lastProgressEmitTime = 0L
 
     /** Expose the underlying SDK for the Fabric feed view manager. */
     val sdk: ShortKit? get() = shortKit
@@ -528,8 +533,35 @@ class ShortKitBridge(
                 emitEventOnMain("onContentTapped", params)
             }
 
-            override fun onRefreshRequested() {
-                emitEventOnMain("onRefreshRequested", Arguments.createMap())
+            override fun onRefreshStateChanged(state: ShortKitRefreshState) {
+                // Throttle pulling events to max 1 per 16ms to avoid bridge saturation
+                if (state is ShortKitRefreshState.Pulling) {
+                    val now = android.os.SystemClock.uptimeMillis()
+                    if (now - lastProgressEmitTime < 16L) return
+                    lastProgressEmitTime = now
+                }
+
+                val params = Arguments.createMap().apply {
+                    when (state) {
+                        is ShortKitRefreshState.Idle -> {
+                            putString("status", "idle")
+                            putDouble("progress", 0.0)
+                        }
+                        is ShortKitRefreshState.Pulling -> {
+                            putString("status", "pulling")
+                            putDouble("progress", state.progress.toDouble())
+                        }
+                        is ShortKitRefreshState.Triggered -> {
+                            putString("status", "triggered")
+                            putDouble("progress", 0.0)
+                        }
+                        is ShortKitRefreshState.Refreshing -> {
+                            putString("status", "refreshing")
+                            putDouble("progress", 0.0)
+                        }
+                    }
+                }
+                emitEventOnMain("onRefreshStateChanged", params)
             }
 
             override fun onFeedContentFetched(items: List<ContentItem>) {

package/android/src/main/java/com/shortkit/reactnative/ShortKitModule.kt

@@ -207,11 +207,11 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
     @ReactMethod
     override fun preloadFeed(configJSON: String, itemsJSON: String?, promise: Promise) {
         val b = bridge
-        if (b == null) {
-            promise.resolve("")
-            return
+        if (b != null) {
+            b.preloadFeed(configJSON, itemsJSON) { result -> promise.resolve(result) }
+        } else {
+            bufferOp { bridge?.preloadFeed(configJSON, itemsJSON) { result -> promise.resolve(result) } }
         }
-        b.preloadFeed(configJSON, itemsJSON) { result -> promise.resolve(result) }
     }
 
     // -----------------------------------------------------------------
@@ -261,7 +261,7 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
                 "onSurveyResponse" -> emitOnSurveyResponse(params)
                 "onContentTapped" -> emitOnContentTapped(params)
                 "onDismiss" -> emitOnDismiss(params)
-                "onRefreshRequested" -> emitOnRefreshRequested(params)
+                "onRefreshStateChanged" -> emitOnRefreshStateChanged(params)
                 "onDidFetchContentItems" -> emitOnDidFetchContentItems(params)
                 "onFeedReady" -> emitOnFeedReady(params)
                 "onOverlayActiveChanged" -> emitOnOverlayActiveChanged(params)

package/ios/ReactCarouselOverlayHost.swift

@@ -37,6 +37,9 @@ import ShortKitSDK
     private var isActive = false
     private var activeImageIndex = 0
 
+    /// Serial queue for JPEG encoding + temp file writes (off main thread).
+    private static let imageWriteQueue = DispatchQueue(label: "com.shortkit.carousel-image-write", qos: .userInitiated)
+
     /// Unique identifier for this overlay instance, used for event routing.
     let surfaceId = UUID().uuidString
 
@@ -63,15 +66,28 @@ import ShortKitSDK
         activeImageIndex = 0
         createSurfaceIfNeeded()
 
-        // Replace remote URLs with local file URLs for any natively-cached images.
+        // Replace remote URLs with local file URLs for any natively-cached images
+        // that already have a temp file on disk (fast path: FileManager.fileExists).
+        // If the native cache has the image but no temp file exists yet, use the
+        // remote URL immediately and schedule a background write so the file://
+        // URL is available on the next configure() for this image.
         var modifiedItem = item
         if let cachedImage {
             var localImages: [CarouselImage] = []
             for image in item.images {
-                if let uiImage = cachedImage(image.url),
-                   let localURL = writeTempImage(uiImage, for: image.url) {
-                    localImages.append(CarouselImage(url: localURL, alt: image.alt))
+                let tempURL = Self.tempFileURL(for: image.url)
+                if FileManager.default.fileExists(atPath: tempURL.path) {
+                    // Fast path: temp file already written — use file:// URL
+                    localImages.append(CarouselImage(url: tempURL.absoluteString, alt: image.alt))
+                } else if let uiImage = cachedImage(image.url) {
+                    // Native cache hit but no temp file yet — use remote URL now,
+                    // write temp file in background for next time.
+                    localImages.append(image)
+                    Self.imageWriteQueue.async {
+                        Self.writeTempImage(uiImage, to: tempURL)
+                    }
                 } else {
+                    // Not cached — use remote URL
                     localImages.append(image)
                 }
             }
@@ -124,23 +140,19 @@ import ShortKitSDK
         ])
     }
 
-    /// Write a UIImage to the temp directory, returning a file:// URL string.
-    private func writeTempImage(_ image: UIImage, for remoteURL: String) -> String? {
+    /// Deterministic temp file URL for a given remote image URL.
+    private static func tempFileURL(for remoteURL: String) -> URL {
         let hash = remoteURL.hash
         let fileName = "sk-carousel-\(abs(hash)).jpg"
-        let fileURL = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent(fileName)
-
-        if FileManager.default.fileExists(atPath: fileURL.path) {
-            return fileURL.absoluteString
-        }
+        return URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent(fileName)
+    }
 
-        guard let data = image.jpegData(compressionQuality: 0.9) else { return nil }
-        do {
-            try data.write(to: fileURL, options: .atomic)
-            return fileURL.absoluteString
-        } catch {
-            return nil
-        }
+    /// JPEG-encode a UIImage and write to the given file URL.
+    /// Safe to call from any queue — no UIKit main-thread requirements.
+    private static func writeTempImage(_ image: UIImage, to fileURL: URL) {
+        guard !FileManager.default.fileExists(atPath: fileURL.path),
+              let data = image.jpegData(compressionQuality: 0.9) else { return }
+        try? data.write(to: fileURL, options: .atomic)
     }
 
     public func resetState() {

package/ios/ReactOverlayHost.swift

@@ -46,7 +46,9 @@ import ShortKitSDK
     private var cachedPlaybackRate: Double = 1.0
     private var cachedCaptionsEnabled: Bool = false
     private var cachedActiveCue: [String: Any]? = nil
-    private var cachedFeedScrollPhase: String? = nil
+    private var cachedActiveCueJson: String? = nil      // pre-serialized for bridge
+    private var cachedFeedScrollPhase: String? = nil     // already a JSON string
+    private var isDragging: Bool = false                  // true while scroll phase is .dragging
 
     // Time coalescing
     private var cachedTime: (current: Double, duration: Double, buffered: Double) = (0, 0, 0)
@@ -137,7 +139,9 @@ import ShortKitSDK
         cachedTime = (0, 0, 0)
         cachedPlayerState = "idle"
         cachedActiveCue = nil
+        cachedActiveCueJson = nil
         cachedFeedScrollPhase = nil
+        isDragging = false
 
         createSurfaceIfNeeded()
 
@@ -165,30 +169,21 @@ import ShortKitSDK
         }
     }
 
-    /// Emit all cached state as individual events. Called from activatePlayback()
-    /// (deferred) and can be called whenever we need to synchronize JS state.
+    /// Emit all cached state as a single batched event. Called from
+    /// activatePlayback() (deferred) and on drag→settled transitions.
+    /// Uses pre-serialized JSON strings to avoid JSONSerialization on the
+    /// main thread during the swipe-settle critical path.
     private func emitFullState() {
-        var body: [String: Any] = [
+        bridge?.emit("onOverlayFullState", body: [
             "surfaceId": surfaceId,
             "isActive": true,
             "playerState": cachedPlayerState,
             "isMuted": cachedIsMuted,
             "playbackRate": cachedPlaybackRate,
             "captionsEnabled": cachedCaptionsEnabled,
-        ]
-        if let cue = cachedActiveCue,
-           let cueData = try? JSONSerialization.data(withJSONObject: cue),
-           let cueJson = String(data: cueData, encoding: .utf8) {
-            body["activeCue"] = cueJson
-        } else {
-            body["activeCue"] = NSNull()
-        }
-        if let scrollPhase = cachedFeedScrollPhase {
-            body["feedScrollPhase"] = scrollPhase
-        } else {
-            body["feedScrollPhase"] = NSNull()
-        }
-        bridge?.emit("onOverlayFullState", body: body)
+            "activeCue": cachedActiveCueJson ?? NSNull(),
+            "feedScrollPhase": cachedFeedScrollPhase ?? NSNull(),
+        ])
     }
 
     // MARK: - Surface Creation
@@ -255,17 +250,21 @@ import ShortKitSDK
     // MARK: - Player Subscriptions
 
     private func subscribeToPlayer(_ player: ShortKitPlayer) {
+        // Player state, muted, playbackRate, captionsEnabled, and activeCue
+        // are suppressed during .dragging to avoid unnecessary bridge traffic
+        // for an overlay that is scrolling off screen. emitFullState() re-syncs
+        // all cached values when the scroll settles (or on cancelled swipe).
+
         player.playerState
             .receive(on: DispatchQueue.main)
             .sink { [weak self] state in
                 guard let self else { return }
                 self.cachedPlayerState = Self.playerStateString(state)
-                if self.isActive {
-                    self.bridge?.emit("onOverlayPlayerStateChanged", body: [
-                        "surfaceId": self.surfaceId,
-                        "playerState": self.cachedPlayerState
-                    ])
-                }
+                guard self.isActive, !self.isDragging else { return }
+                self.bridge?.emit("onOverlayPlayerStateChanged", body: [
+                    "surfaceId": self.surfaceId,
+                    "playerState": self.cachedPlayerState
+                ])
             }
             .store(in: &cancellables)
 
@@ -274,12 +273,11 @@ import ShortKitSDK
             .sink { [weak self] muted in
                 guard let self else { return }
                 self.cachedIsMuted = muted
-                if self.isActive {
-                    self.bridge?.emit("onOverlayMutedChanged", body: [
-                        "surfaceId": self.surfaceId,
-                        "isMuted": self.cachedIsMuted
-                    ])
-                }
+                guard self.isActive, !self.isDragging else { return }
+                self.bridge?.emit("onOverlayMutedChanged", body: [
+                    "surfaceId": self.surfaceId,
+                    "isMuted": self.cachedIsMuted
+                ])
             }
             .store(in: &cancellables)
 
@@ -288,12 +286,11 @@ import ShortKitSDK
             .sink { [weak self] rate in
                 guard let self else { return }
                 self.cachedPlaybackRate = Double(rate)
-                if self.isActive {
-                    self.bridge?.emit("onOverlayPlaybackRateChanged", body: [
-                        "surfaceId": self.surfaceId,
-                        "playbackRate": self.cachedPlaybackRate
-                    ])
-                }
+                guard self.isActive, !self.isDragging else { return }
+                self.bridge?.emit("onOverlayPlaybackRateChanged", body: [
+                    "surfaceId": self.surfaceId,
+                    "playbackRate": self.cachedPlaybackRate
+                ])
             }
             .store(in: &cancellables)
 
@@ -302,12 +299,11 @@ import ShortKitSDK
             .sink { [weak self] enabled in
                 guard let self else { return }
                 self.cachedCaptionsEnabled = enabled
-                if self.isActive {
-                    self.bridge?.emit("onOverlayCaptionsEnabledChanged", body: [
-                        "surfaceId": self.surfaceId,
-                        "captionsEnabled": self.cachedCaptionsEnabled
-                    ])
-                }
+                guard self.isActive, !self.isDragging else { return }
+                self.bridge?.emit("onOverlayCaptionsEnabledChanged", body: [
+                    "surfaceId": self.surfaceId,
+                    "captionsEnabled": self.cachedCaptionsEnabled
+                ])
             }
             .store(in: &cancellables)
 
@@ -315,30 +311,26 @@ import ShortKitSDK
             .receive(on: DispatchQueue.main)
             .sink { [weak self] cue in
                 guard let self else { return }
+                // Pre-serialize once; reused by emitFullState() and individual emission.
                 if let cue {
                     self.cachedActiveCue = [
                         "text": cue.text,
                         "startTime": cue.startTime,
                         "endTime": cue.endTime,
                     ]
-                } else {
-                    self.cachedActiveCue = nil
-                }
-                if self.isActive {
-                    if let cached = self.cachedActiveCue,
-                       let data = try? JSONSerialization.data(withJSONObject: cached),
+                    if let data = try? JSONSerialization.data(withJSONObject: self.cachedActiveCue!),
                        let json = String(data: data, encoding: .utf8) {
-                        self.bridge?.emit("onOverlayActiveCueChanged", body: [
-                            "surfaceId": self.surfaceId,
-                            "activeCue": json
-                        ])
-                    } else {
-                        self.bridge?.emit("onOverlayActiveCueChanged", body: [
-                            "surfaceId": self.surfaceId,
-                            "activeCue": NSNull()
-                        ])
+                        self.cachedActiveCueJson = json
                     }
+                } else {
+                    self.cachedActiveCue = nil
+                    self.cachedActiveCueJson = nil
                 }
+                guard self.isActive, !self.isDragging else { return }
+                self.bridge?.emit("onOverlayActiveCueChanged", body: [
+                    "surfaceId": self.surfaceId,
+                    "activeCue": self.cachedActiveCueJson ?? NSNull()
+                ])
             }
             .store(in: &cancellables)
 
@@ -346,18 +338,26 @@ import ShortKitSDK
             .receive(on: DispatchQueue.main)
             .sink { [weak self] phase in
                 guard let self else { return }
+                // Pre-serialize once; reused by emitFullState() and individual emission.
                 switch phase {
                 case .dragging(let from):
-                    let dict: [String: Any] = ["phase": "dragging", "fromId": from]
-                    if let data = try? JSONSerialization.data(withJSONObject: dict),
+                    self.isDragging = true
+                    if let data = try? JSONSerialization.data(withJSONObject: ["phase": "dragging", "fromId": from]),
                        let json = String(data: data, encoding: .utf8) {
                         self.cachedFeedScrollPhase = json
                     }
                 case .settled:
-                    let dict: [String: Any] = ["phase": "settled"]
-                    if let data = try? JSONSerialization.data(withJSONObject: dict),
-                       let json = String(data: data, encoding: .utf8) {
-                        self.cachedFeedScrollPhase = json
+                    let wasDragging = self.isDragging
+                    self.isDragging = false
+                    self.cachedFeedScrollPhase = "{\"phase\":\"settled\"}"
+
+                    // Re-sync all state that was suppressed during the drag.
+                    // Handles both normal swipes (new item's activatePlayback
+                    // will also fire) and cancelled swipes (same item, no
+                    // activatePlayback — this is the only re-sync path).
+                    if wasDragging, self.isActive {
+                        self.emitFullState()
+                        return  // fullState includes feedScrollPhase
                     }
                 }
                 if self.isActive {
@@ -372,7 +372,7 @@ import ShortKitSDK
         player.time
             .receive(on: DispatchQueue.main)
             .sink { [weak self] time in
-                guard let self, self.isActive else { return }
+                guard let self, self.isActive, !self.isDragging else { return }
                 self.cachedTime = (time.current, time.duration, time.buffered)
                 self.timeDirty = true
             }
@@ -424,9 +424,7 @@ import ShortKitSDK
         props["playbackRate"] = cachedPlaybackRate
         props["captionsEnabled"] = cachedCaptionsEnabled
 
-        if let cue = cachedActiveCue,
-           let cueData = try? JSONSerialization.data(withJSONObject: cue),
-           let cueJson = String(data: cueData, encoding: .utf8) {
+        if let cueJson = cachedActiveCueJson {
             props["activeCue"] = cueJson
         }
 

package/ios/ShortKitBridge.swift

@@ -17,6 +17,15 @@ import ShortKitSDK
     private var shortKit: ShortKit?
     private var cancellables = Set<AnyCancellable>()
     private weak var delegate: ShortKitBridgeDelegateProtocol?
+    private var lastProgressEmitTime: CFTimeInterval = 0
+
+    // Time update coalescing (250ms, matching overlay timer interval)
+    private var cachedTime: (current: Double, duration: Double, buffered: Double) = (0, 0, 0)
+    private var timeCoalesceTimer: Timer?
+    private var timeDirty = false
+
+    // Scroll phase coalescing — only emit .dragging on first touch
+    private var lastEmittedScrollPhase: String = "settled"
 
     /// Surface presenter for creating RCTFabricSurface instances in overlay hosts.
     /// Set from ShortKitModule.mm via setSurfacePresenter: (called by RCTInstance).
@@ -116,12 +125,15 @@ import ShortKitSDK
         }
 
         subscribeToPublishers(sdk.player)
+        startTimeCoalescing()
         sdk.delegate = self
     }
 
     // MARK: - Teardown
 
     @objc public func teardown() {
+        timeCoalesceTimer?.invalidate()
+        timeCoalesceTimer = nil
         cancellables.removeAll()
         preloadHandles.removeAll()
         feedRegistry.removeAll()
@@ -376,24 +388,27 @@ import ShortKitSDK
             }
             .store(in: &cancellables)
 
-        // Current item
+        // Current item — deferred to next run-loop tick so emission doesn't
+        // contend with Core Animation's commit phase during swipe settle.
         player.currentItem
             .receive(on: DispatchQueue.main)
             .sink { [weak self] item in
                 guard let item else { return }
-                self?.emit("onCurrentItemChanged", body: Self.contentItemDict(item))
+                let body = Self.contentItemDict(item)
+                DispatchQueue.main.async {
+                    self?.emit("onCurrentItemChanged", body: body)
+                }
             }
             .store(in: &cancellables)
 
-        // Time updates
+        // Time updates — coalesced at 250ms (4 events/sec) to avoid flooding
+        // the JS bridge. Matches the overlay timer interval in ReactOverlayHost.
         player.time
             .receive(on: DispatchQueue.main)
             .sink { [weak self] time in
-                self?.emit("onTimeUpdate", body: [
-                    "current": time.current,
-                    "duration": time.duration,
-                    "buffered": time.buffered
-                ])
+                guard let self else { return }
+                self.cachedTime = (time.current, time.duration, time.buffered)
+                self.timeDirty = true
             }
             .store(in: &cancellables)
 
@@ -458,7 +473,8 @@ import ShortKitSDK
             }
             .store(in: &cancellables)
 
-        // Feed transition
+        // Feed transition — deferred to next run-loop tick so emission doesn't
+        // contend with Core Animation's commit phase during swipe settle.
         player.feedTransition
             .receive(on: DispatchQueue.main)
             .sink { [weak self] event in
@@ -473,24 +489,35 @@ import ShortKitSDK
                 if let to = event.to {
                     body["toItem"] = self.serializeContentItemToJSON(to)
                 }
-                self.emit("onFeedTransition", body: body)
+                DispatchQueue.main.async { [weak self] in
+                    self?.emit("onFeedTransition", body: body)
+                }
             }
             .store(in: &cancellables)
 
-        // Feed scroll phase
+        // Feed scroll phase — coalesced: only emit .dragging on first touch
+        // (transition from settled), drop intermediate .dragging events. Always
+        // emit .settled. Deferred to next run-loop tick to avoid contending with
+        // Core Animation's commit phase.
         player.feedScrollPhase
             .receive(on: DispatchQueue.main)
             .sink { [weak self] phase in
+                guard let self else { return }
                 switch phase {
                 case .dragging(let fromId):
-                    self?.emit("onFeedScrollPhase", body: [
-                        "phase": "dragging",
-                        "fromId": fromId
-                    ])
+                    // Only emit on transition from settled → dragging
+                    guard self.lastEmittedScrollPhase != "dragging" else { return }
+                    self.lastEmittedScrollPhase = "dragging"
+                    let body: [String: Any] = ["phase": "dragging", "fromId": fromId]
+                    DispatchQueue.main.async { [weak self] in
+                        self?.emit("onFeedScrollPhase", body: body)
+                    }
                 case .settled:
-                    self?.emit("onFeedScrollPhase", body: [
-                        "phase": "settled"
-                    ])
+                    self.lastEmittedScrollPhase = "settled"
+                    let body: [String: Any] = ["phase": "settled"]
+                    DispatchQueue.main.async { [weak self] in
+                        self?.emit("onFeedScrollPhase", body: body)
+                    }
                 }
             }
             .store(in: &cancellables)
@@ -536,6 +563,21 @@ import ShortKitSDK
         }
     }
 
+    // MARK: - Time Coalescing
+
+    private func startTimeCoalescing() {
+        timeCoalesceTimer?.invalidate()
+        timeCoalesceTimer = Timer.scheduledTimer(withTimeInterval: 0.25, repeats: true) { [weak self] _ in
+            guard let self, self.timeDirty else { return }
+            self.timeDirty = false
+            self.emit("onTimeUpdate", body: [
+                "current": self.cachedTime.current,
+                "duration": self.cachedTime.duration,
+                "buffered": self.cachedTime.buffered
+            ])
+        }
+    }
+
     // MARK: - Content Item Serialization
 
     /// Serialize a ContentItem to a JSON string for bridge transport.
@@ -658,6 +700,8 @@ import ShortKitSDK
         let scrollAxisStr = obj["scrollAxis"] as? String ?? "vertical"
         let scrollAxis: ScrollAxis = scrollAxisStr == "horizontal" ? .horizontal : .vertical
 
+        let pullToRefreshEnabled = obj["pullToRefreshEnabled"] as? Bool ?? true
+
         return FeedConfig(
             feedHeight: feedHeight,
             scrollAxis: scrollAxis,
@@ -669,6 +713,7 @@ import ShortKitSDK
             muteOnStart: muteOnStart,
             autoplay: autoplay,
             feedSource: feedSource,
+            pullToRefreshEnabled: pullToRefreshEnabled,
             filter: filter
         )
     }
@@ -870,8 +915,23 @@ extension ShortKitBridge: ShortKitDelegate {
         ])
     }
 
-    public func shortKitDidRequestRefresh(_ shortKit: ShortKit) {
-        emitOnMain("onRefreshRequested", body: [:])
+    public func shortKit(_ shortKit: ShortKit, didChangeRefreshState state: ShortKitRefreshState) {
+        let body: [String: Any]
+        switch state {
+        case .idle:
+            body = ["status": "idle", "progress": 0.0]
+        case .pulling(let progress):
+            // Throttle pulling events to max 1 per 16ms to avoid bridge saturation
+            let now = CACurrentMediaTime()
+            guard now - lastProgressEmitTime >= 0.016 else { return }
+            lastProgressEmitTime = now
+            body = ["status": "pulling", "progress": progress]
+        case .triggered:
+            body = ["status": "triggered", "progress": 0.0]
+        case .refreshing:
+            body = ["status": "refreshing", "progress": 0.0]
+        }
+        emitOnMain("onRefreshStateChanged", body: body)
     }
 
     public func shortKit(_ shortKit: ShortKit, didFetchContentItems items: [ContentItem]) {

package/ios/ShortKitModule.mm

@@ -72,7 +72,7 @@ RCT_EXPORT_MODULE(ShortKitModule)
     @"onContentTapped",
     @"onDismiss",
     @"onFeedReady",
-    @"onRefreshRequested",
+    @"onRefreshStateChanged",
     @"onDidFetchContentItems",
     @"onOverlayActiveChanged",
     @"onOverlayPlayerStateChanged",
@@ -264,9 +264,18 @@ RCT_EXPORT_METHOD(preloadFeed:(NSString *)configJSON
                   itemsJSON:(NSString *)itemsJSON
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
-  [_shortKitBridge preloadFeed:configJSON itemsJSON:itemsJSON completion:^(NSString *uuid) {
-    resolve(uuid);
-  }];
+  if (_shortKitBridge) {
+    [_shortKitBridge preloadFeed:configJSON itemsJSON:itemsJSON completion:^(NSString *uuid) {
+      resolve(uuid);
+    }];
+  } else {
+    if (!_pendingBridgeOps) _pendingBridgeOps = [NSMutableArray new];
+    [_pendingBridgeOps addObject:^{
+      [self->_shortKitBridge preloadFeed:configJSON itemsJSON:itemsJSON completion:^(NSString *uuid) {
+        resolve(uuid);
+      }];
+    }];
+  }
 }
 
 // MARK: - Storyboard / Seek Thumbnails

package/ios/ShortKitSDK.xcframework/Info.plist

@@ -22,12 +22,13 @@
 			<key>BinaryPath</key>
 			<string>ShortKitSDK.framework/ShortKitSDK</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64-simulator</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>ShortKitSDK.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>

package/ios/ShortKitSDK.xcframework/ios-arm64/ShortKitSDK.framework/Headers/ShortKitSDK-Swift.h

@@ -360,6 +360,7 @@ SWIFT_CLASS("_TtC11ShortKitSDK26ShortKitFeedViewController")
 - (void)scrollViewWillBeginDragging:(UIScrollView * _Nonnull)scrollView;
 - (void)scrollViewDidEndDecelerating:(UIScrollView * _Nonnull)scrollView;
 - (void)scrollViewDidEndDragging:(UIScrollView * _Nonnull)scrollView willDecelerate:(BOOL)decelerate;
+- (void)scrollViewDidScrollToTop:(UIScrollView * _Nonnull)scrollView;
 - (void)scrollViewDidScroll:(UIScrollView * _Nonnull)scrollView;
 @end
 

package/ios/ShortKitSDK.xcframework/ios-arm64/ShortKitSDK.framework/Info.plist

@@ -11,6 +11,10 @@
     <key>CFBundlePackageType</key>
     <string>FMWK</string>
     <key>CFBundleVersion</key>
-    <string>1</string>
+    <string>0.2.15</string>
+    <key>CFBundleShortVersionString</key>
+    <string>0.2.15</string>
+    <key>MinimumOSVersion</key>
+    <string>16.0</string>
 </dict>
 </plist>