@shortkitsdk/react-native 0.2.28 → 0.2.29

package/ios/ReactVideoCarouselOverlayHost.swift

@@ -324,7 +324,13 @@ import ShortKitSDK
                 } else {
                     carouselItemJSON = "{}"
                 }
+                // Tag with active surface's feedId so per-<ShortKitFeed>
+                // subscribers can filter to their own feed instance — same
+                // pattern as the other per-feed events. surfaceId continues
+                // to identify the React overlay host (a separate concern).
+                let feedId = self.bridge?.activeSurfaceFeedIdPublic() ?? ""
                 self.bridge?.emit("onCarouselActiveVideoCompleted", body: [
+                    "feedId": feedId,
                     "surfaceId": self.surfaceId,
                     "contentItem": contentItemJSON,
                     "indexInCarousel": event.indexInCarousel,

package/ios/ShortKitBridge.swift

@@ -72,7 +72,6 @@ import ShortKitSDK
 
         // Wire per-feed refresh state callback (scoped by feedId)
         vc.onRefreshStateChanged = { [weak self] state in
-            NSLog("[ShortKit Bridge] onRefreshStateChangedPerFeed feedId=%@ status=%@", id, "\(state)")
             var body: [String: Any] = ["feedId": id]
             switch state {
             case .idle:
@@ -101,6 +100,34 @@ import ShortKitSDK
             ])
         }
 
+        // Wire per-feed transition event. The FVC fires this closure from
+        // handleSwipe(to:) — one per transition, bound to this feed. This
+        // replaces the global `player.feedTransition` subscription pattern
+        // (which fanned every feed's transitions out to every mounted
+        // <ShortKitFeed>, causing cross-feed state pollution). Structural
+        // fix: callback literally cannot fire on the wrong feed.
+        vc.onFeedTransition = { [weak self] event in
+            guard let self else { return }
+            var body: [String: Any] = [
+                "feedId": id,
+                "phase": Self.transitionPhaseString(event.phase),
+                "direction": Self.transitionDirectionString(event.direction)
+            ]
+            // Serialize from the underlying FeedItem (not event.from/to
+            // which are nil for non-content cells). See the docstring on
+            // `serializeFeedItemIdentityJSON` for the why — in short, this
+            // ensures carousels/ads/surveys come through with a populated
+            // `id`, so JS-side hosts can track feed position for any cell
+            // type.
+            if let fromFeedItem = event.fromFeedItem {
+                body["fromItem"] = self.serializeFeedItemIdentityJSON(fromFeedItem)
+            }
+            if let toFeedItem = event.toFeedItem {
+                body["toItem"] = self.serializeFeedItemIdentityJSON(toFeedItem)
+            }
+            self.emitOnMain("onFeedTransition", body: body)
+        }
+
         // Replay buffered operations on the next run-loop tick so the VC's
         // view hierarchy is fully set up after didMoveToWindow returns.
         if let ops = pendingOps.removeValue(forKey: id) {
@@ -122,6 +149,24 @@ import ShortKitSDK
         return feedRegistry[id]?.vc
     }
 
+    /// Look up the feedId for the currently-active surface. Used by events
+    /// that originate in shared singletons (player Combine publishers, the
+    /// `ShortKitDelegate`) and must be attributed to one feed for the JS
+    /// wrapper's feedId filter to work. Returns `""` if no active surface
+    /// or if the active surface isn't in the registry — consumers should
+    /// treat empty feedId as "unknown/global" (JS wrapper accepts it as a
+    /// fallback for forward compatibility with older native builds).
+    private func activeSurfaceFeedId() -> String {
+        return feedRegistry.first(where: { $0.value.vc?.isActiveSurface == true })?.key ?? ""
+    }
+
+    /// Internal accessor for `activeSurfaceFeedId()` so cross-file emit
+    /// sites (e.g. `ReactVideoCarouselOverlayHost`) can tag emits with
+    /// the active feed's feedId without duplicating the lookup logic.
+    internal func activeSurfaceFeedIdPublic() -> String {
+        return activeSurfaceFeedId()
+    }
+
     // MARK: - Init
 
     @objc public init(
@@ -430,29 +475,21 @@ import ShortKitSDK
         let config = Self.parseFeedConfig(configJSON)
         let preload: FeedPreload?
 
-        NSLog("[ShortKit Bridge] preloadFeed called — feedSource: %@, hasItemsJSON: %@",
-              config.feedSource == .custom ? "custom" : "algorithmic",
-              itemsJSON != nil ? "yes (\(itemsJSON!.prefix(100))...)" : "no")
-
         if config.feedSource == .custom {
             guard let json = itemsJSON, let items = Self.parseFeedInputs(json) else {
-                NSLog("[ShortKit Bridge] ❌ preloadFeed: feedSource=custom but no valid items — returning empty")
                 completion("")
                 return
             }
-            NSLog("[ShortKit Bridge] preloadFeed: creating custom preload with %d items", items.count)
             preload = shortKit?.preloadFeed(items: items)
         } else {
             preload = shortKit?.preloadFeed(filter: config.filter)
         }
 
         guard let preload else {
-            NSLog("[ShortKit Bridge] ❌ preloadFeed: shortKit?.preloadFeed returned nil")
             completion("")
             return
         }
         let uuid = UUID().uuidString
-        NSLog("[ShortKit Bridge] ✅ preloadFeed: created handle %@", uuid)
         preloadHandles[uuid] = preload
         activeFeedId = uuid
         completion(uuid)
@@ -553,38 +590,34 @@ import ShortKitSDK
             }
             .store(in: &cancellables)
 
-        // Did loop
+        // Did loop — tagged with active surface's feedId. `player.didLoop`
+        // is a singleton Combine publisher on the shared player (only one
+        // item plays at a time). The event semantically belongs to
+        // whichever feed owns the active surface; tag with that feedId so
+        // JS consumers bound to specific feeds can filter.
         player.didLoop
             .receive(on: DispatchQueue.main)
             .sink { [weak self] event in
-                self?.emit("onDidLoop", body: [
+                guard let self else { return }
+                let feedId = self.activeSurfaceFeedId()
+                self.emit("onDidLoop", body: [
+                    "feedId": feedId,
                     "contentId": event.contentId,
                     "loopCount": event.loopCount
                 ])
             }
             .store(in: &cancellables)
 
-        // 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
-                guard let self else { return }
-                var body: [String: Any] = [
-                    "phase": Self.transitionPhaseString(event.phase),
-                    "direction": Self.transitionDirectionString(event.direction)
-                ]
-                if let from = event.from {
-                    body["fromItem"] = self.serializeContentItemToJSON(from)
-                }
-                if let to = event.to {
-                    body["toItem"] = self.serializeContentItemToJSON(to)
-                }
-                DispatchQueue.main.async { [weak self] in
-                    self?.emit("onFeedTransition", body: body)
-                }
-            }
-            .store(in: &cancellables)
+        // NOTE: The global `player.feedTransition` subscription used to live
+        // here. It's been removed — feed transitions are now emitted to RN
+        // via the per-FVC `vc.onFeedTransition` closure wired in
+        // `registerFeed(id:viewController:)` above. This eliminates the
+        // cross-feed routing bug where every mounted <ShortKitFeed>
+        // consumer received every feed's transitions.
+        //
+        // `player.sendFeedTransition` is still called by FVC.handleSwipe
+        // for backward compatibility with native iOS consumers that
+        // subscribe to `ShortKit.player.feedTransition` directly.
 
         // Feed scroll phase — coalesced: only emit .dragging on first touch
         // (transition from settled), drop intermediate .dragging events. Always
@@ -613,11 +646,16 @@ import ShortKitSDK
             }
             .store(in: &cancellables)
 
-        // Format change
+        // Format change — tagged with active surface's feedId. Same
+        // reasoning as onDidLoop: fires from shared player singleton, but
+        // semantically belongs to whichever feed owns the active surface.
         player.formatChange
             .receive(on: DispatchQueue.main)
             .sink { [weak self] event in
-                self?.emit("onFormatChange", body: [
+                guard let self else { return }
+                let feedId = self.activeSurfaceFeedId()
+                self.emit("onFormatChange", body: [
+                    "feedId": feedId,
                     "contentId": event.contentId,
                     "fromBitrate": Double(event.fromBitrate),
                     "toBitrate": Double(event.toBitrate),
@@ -683,6 +721,52 @@ import ShortKitSDK
         return json
     }
 
+    /// Serialize a `FeedItem` to a ContentItem-shaped JSON string for the
+    /// `onFeedTransition` event. For `.content` cells this is the real
+    /// `ContentItem`. For every other cell kind (adSlot, imageCarousel,
+    /// survey, videoCarousel) there is no playable `ContentItem`, so we
+    /// synthesize a minimal one whose ONLY meaningful field is `id`.
+    ///
+    /// Why: JS hosts use `event.to` as an identity cursor for resume-on-
+    /// tab-return (`setFeedItems(startAt:)`). Before this synthesis, non-
+    /// content cells came through as `to=null` and the host's stored
+    /// resume id stayed pinned to the last regular video — causing the
+    /// SDK to re-seed the feed at the wrong index on tab return, which
+    /// in turn caused black carousel cells + wrong audio (see repro
+    /// analysis in debug.log, apr 2026).
+    ///
+    /// Scope: this is a bridge-only synthesis. It never flows back into
+    /// the Swift SDK (pool, cache, FeedDataSource, etc. all still see the
+    /// real `FeedItem` / `ContentItem?` and treat non-content cells
+    /// honestly). JS-side consumers should ONLY read `.id` / `.playbackId`
+    /// from `onFeedTransition` items — deeper fields are placeholders for
+    /// non-content cells.
+    ///
+    /// TODO: when we want to expose richer per-cell metadata on the JS
+    /// side, migrate to a proper FeedPosition event payload rather than
+    /// extending this synthesis. See the long-term fix plan.
+    private func serializeFeedItemIdentityJSON(_ feedItem: FeedItem) -> String {
+        if let contentItem = feedItem.contentItem {
+            return serializeContentItemToJSON(contentItem)
+        }
+        let synthetic = ContentItem(
+            id: feedItem.id,
+            playbackId: nil,
+            title: "",
+            description: nil,
+            duration: 0,
+            streamingUrl: "",
+            thumbnailUrl: "",
+            captionTracks: [],
+            customMetadata: nil,
+            author: nil,
+            articleUrl: nil,
+            commentCount: nil,
+            fallbackUrl: nil
+        )
+        return serializeContentItemToJSON(synthetic)
+    }
+
     /// Build an NSDictionary from a ContentItem with fields matching the JS spec.
     /// `captionTracks` and `customMetadata` are JSON-serialized strings.
     private static func contentItemDict(_ item: ContentItem) -> [String: Any] {
@@ -1007,7 +1091,14 @@ import ShortKitSDK
 
 extension ShortKitBridge: ShortKitDelegate {
     public func shortKit(_ shortKit: ShortKit, didTapContent contentId: String, at index: Int) {
+        // Tag with active surface's feedId. The delegate is a singleton
+        // (the bridge), so we use the activeSurface lookup to attribute
+        // this tap to the feed it originated from. Without the tag, every
+        // mounted <ShortKitFeed> consumer would fire onContentTapped on
+        // every tap — including taps in sibling feeds.
+        let feedId = activeSurfaceFeedId()
         emitOnMain("onContentTapped", body: [
+            "feedId": feedId,
             "contentId": contentId,
             "index": index
         ])
@@ -1038,10 +1129,18 @@ extension ShortKitBridge: ShortKitDelegate {
                 self.itemCache[item.id] = item
             }
         }
+        // Capture the feedId synchronously before the async Task — after
+        // the await, activeSurface may have shifted (user swiped tabs).
+        // The fetch semantically belongs to whichever feed initiated it,
+        // which at this delegate-call moment is the active surface.
+        let feedId = activeSurfaceFeedId()
         Task {
             let data = try? JSONEncoder().encode(items)
             let json = data.flatMap { String(data: $0, encoding: .utf8) } ?? "[]"
-            self.emitOnMain("onDidFetchContentItems", body: ["items": json])
+            self.emitOnMain("onDidFetchContentItems", body: [
+                "feedId": feedId,
+                "items": json
+            ])
         }
     }
 }

package/ios/ShortKitFeedView.swift

@@ -38,14 +38,19 @@ import ShortKitSDK
         didSet { /* used at embed time only */ }
     }
 
-    /// When the consumer explicitly manages this prop, it becomes the
-    /// authoritative suspension signal — overriding willMove(toWindow:).
-    private var isActiveManagedByProp = false
-
+    /// The `active` prop is authoritative: whenever the view is deciding
+    /// whether to activate/deactivate/suspend its FeedViewController, it
+    /// consults this value directly. The `didSet` only exists to react to
+    /// transitions while the VC already exists. Transitions that arrive
+    /// before the VC is created (a common Fabric ordering: props set on the
+    /// view instance before `didMoveToWindow` runs) are stored in the Bool
+    /// property by Swift automatically — `embedFeedViewControllerIfNeeded`
+    /// reads the current value and acts on it when the VC is finally set up.
     @objc public var active: Bool = true {
         didSet {
-            guard active != oldValue, let feedVC = feedViewController else { return }
-            if !active { isActiveManagedByProp = true }
+            guard active != oldValue, let feedVC = feedViewController else {
+                return
+            }
             if active {
                 feedVC.activate()
             } else {
@@ -62,9 +67,16 @@ import ShortKitSDK
 
     // MARK: - Lifecycle
 
+    public override init(frame: CGRect) {
+        super.init(frame: frame)
+    }
+
+    public required init?(coder: NSCoder) {
+        super.init(coder: coder)
+    }
+
     public override func didMoveToWindow() {
         super.didMoveToWindow()
-
         if window != nil {
             embedFeedViewControllerIfNeeded()
         }
@@ -72,8 +84,11 @@ import ShortKitSDK
 
     public override func willMove(toWindow newWindow: UIWindow?) {
         super.willMove(toWindow: newWindow)
-
-        if newWindow == nil && !isActiveManagedByProp {
+        // Suspend only if we're leaving the window AND the prop says this
+        // surface should be active. When the prop is false, the consumer has
+        // already driven the VC into deactivate via active.didSet (or will,
+        // once the VC exists), and we mustn't double-suspend.
+        if newWindow == nil && active {
             suspendFeedViewController()
         }
     }
@@ -96,18 +111,21 @@ import ShortKitSDK
 
         // Re-attach an existing suspended VC (e.g. after native stack pop)
         if let feedVC = feedViewController {
-            NSLog("[ShortKit FeedView] re-attaching suspended VC feedId=%@", feedId ?? "nil")
             parentVC.addChild(feedVC)
             feedVC.view.frame = bounds
             addSubview(feedVC.view)
             feedVC.didMove(toParent: parentVC)
-            if !isActiveManagedByProp {
+            // Authoritative: read the current active prop and act on it.
+            // If prop is false, stay deactivated — do NOT claim the pool.
+            // This is the fix for the prop-arrived-before-VC race: a prop
+            // update dropped by the didSet guard (vcExists=false) lands here
+            // and is honored.
+            if active {
                 feedVC.activate()
             }
             if let feedId = self.feedId {
                 ShortKitBridge.shared?.registerFeed(id: feedId, viewController: feedVC)
             }
-            NSLog("[ShortKit FeedView] re-attach complete — activate() called")
             return
         }
 
@@ -120,33 +138,22 @@ import ShortKitSDK
 
         // Consume preload handle if available
         if let preloadId = self.preloadId {
-            NSLog("[ShortKit FeedView] preloadId prop: %@", preloadId)
             if let preload = ShortKitBridge.shared?.consumePreload(id: preloadId) {
                 feedConfig.preload = preload
-                NSLog("[ShortKit FeedView] ✅ Preload handle consumed for feedId: %@", preloadId)
-            } else {
-                NSLog("[ShortKit FeedView] ❌ No preload handle found for feedId: %@", preloadId)
-                NSLog("[ShortKit FeedView] Available preload handles: %@", ShortKitBridge.shared?.preloadHandles.keys.joined(separator: ", ") ?? "none")
             }
         } else if let json = self.feedItemsJSON,
                   let items = ShortKitBridge.parseFeedInputs(json) {
             // feedItems prop: wrap in an immediate preload (no async prefetch
             // work — items are available synchronously at viewDidLoad).
             feedConfig.preload = FeedPreload(immediateItems: items)
-            NSLog("[ShortKit FeedView] feedItems prop: created immediate preload with %d items", items.count)
-        } else {
-            NSLog("[ShortKit FeedView] No preloadId or feedItems prop set")
         }
 
-        NSLog("[ShortKit FeedView] feedConfig.preload is %@", feedConfig.preload != nil ? "SET" : "NIL")
-        NSLog("[ShortKit FeedView] feedConfig.feedSource: %@", feedConfig.feedSource == .custom ? "custom" : "algorithmic")
-
-        NSLog("[ShortKit FeedView] Creating ShortKitFeedViewController with config.preload=%@, config.feedSource=%@",
-              feedConfig.preload != nil ? "SET" : "NIL",
-              feedConfig.feedSource == .custom ? "custom" : "algorithmic")
-
-        let feedVC = ShortKitFeedViewController(shortKit: sdk, config: feedConfig, startAtItemId: startAtItemId)
-        feedVC.setBridgeManaged()
+        let feedVC = ShortKitFeedViewController(
+            shortKit: sdk,
+            config: feedConfig,
+            startAtItemId: startAtItemId,
+            lifecycle: .manual
+        )
 
         // Seed a thumbnail from the host app's image cache so the first cell
         // renders with a visible thumbnail from frame zero. Synchronous
@@ -174,8 +181,6 @@ import ShortKitSDK
             }
         }
 
-        NSLog("[ShortKit FeedView] VC created successfully (bridge-managed)")
-
         feedVC.onDismiss = {
             ShortKitBridge.shared?.emitDismiss()
         }
@@ -192,13 +197,12 @@ import ShortKitSDK
         feedVC.didMove(toParent: parentVC)
 
         // With FVC.viewDidAppear no longer self-claiming for bridge-managed
-        // surfaces, the bridge is the sole authority on claim timing. Mirror
-        // the reattach path: explicitly activate iff the RN `active` prop
-        // is true. If the prop is false (e.g. user is on a different tab
-        // while this FVC was created to handle a delayed API response), the
-        // FVC stays idle — no claim, no pool mutation, no hijack. A later
-        // prop change to active=true triggers `feedVC.activate()` via the
-        // prop's didSet.
+        // surfaces, the bridge is the sole authority on claim timing. Read
+        // the authoritative `active` prop and act on it. If the prop is
+        // false (including the case where it was set to false before the VC
+        // existed and the didSet guard returned early), the FVC stays idle —
+        // no claim, no pool mutation, no hijack. A later prop change to
+        // active=true triggers `feedVC.activate()` via the prop's didSet.
         if active {
             feedVC.activate()
         }
@@ -209,20 +213,15 @@ import ShortKitSDK
     /// (e.g. pushing a new screen on top). The feedVC and its state are preserved
     /// so they can be re-attached when the view returns to the window.
     private func suspendFeedViewController() {
-        NSLog("[ShortKit FeedView] suspendFeedViewController ENTRY feedId=%@", feedId ?? "nil")
         if let feedId = self.feedId {
             ShortKitBridge.shared?.unregisterFeed(id: feedId)
         }
-        guard let feedVC = feedViewController else {
-            NSLog("[ShortKit FeedView] suspendFeedViewController NOOP — no feedVC")
-            return
-        }
+        guard let feedVC = feedViewController else { return }
 
         feedVC.deactivate()
         feedVC.willMove(toParent: nil)
         feedVC.view.removeFromSuperview()
         feedVC.removeFromParent()
-        NSLog("[ShortKit FeedView] suspendFeedViewController EXIT — VC retained for re-attach")
         // Keep feedViewController reference — re-attached in embedFeedViewControllerIfNeeded
     }
 

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

@@ -11,9 +11,9 @@
     <key>CFBundlePackageType</key>
     <string>FMWK</string>
     <key>CFBundleVersion</key>
-    <string>0.2.28</string>
+    <string>0.2.29</string>
     <key>CFBundleShortVersionString</key>
-    <string>0.2.28</string>
+    <string>0.2.29</string>
     <key>MinimumOSVersion</key>
     <string>16.0</string>
 </dict>