sitepong 0.2.3 → 0.2.4

package/ios/ScreenRecorder/H264Encoder.swift

@@ -0,0 +1,229 @@
+import VideoToolbox
+import CoreMedia
+
+class H264Encoder {
+  private var session: VTCompressionSession?
+  private let bitrate: Int
+  private let bufferDurationMs: Int
+  private var width: Int32 = 0
+  private var height: Int32 = 0
+  private var sessionCreated = false
+
+  /// Rolling buffer of encoded NAL units with timestamps
+  private var nalBuffer: [(data: Data, isKeyframe: Bool, timestamp: CFTimeInterval)] = []
+  private let bufferLock = NSLock()
+
+  init(bitrate: Int, bufferDurationMs: Int) {
+    self.bitrate = bitrate
+    self.bufferDurationMs = bufferDurationMs
+  }
+
+  func start() {
+    // Session is created lazily on first frame (we need dimensions)
+  }
+
+  func stop() {
+    guard let session = session else { return }
+    VTCompressionSessionCompleteFrames(session, untilPresentationTimeStamp: .invalid)
+    VTCompressionSessionInvalidate(session)
+    self.session = nil
+    self.sessionCreated = false
+
+    bufferLock.lock()
+    nalBuffer.removeAll()
+    bufferLock.unlock()
+  }
+
+  func encode(pixelBuffer: CVPixelBuffer, timestamp: CMTime) {
+    let w = Int32(CVPixelBufferGetWidth(pixelBuffer))
+    let h = Int32(CVPixelBufferGetHeight(pixelBuffer))
+
+    // Create or recreate session if dimensions changed
+    if !sessionCreated || w != width || h != height {
+      createSession(width: w, height: h)
+    }
+
+    guard let session = session else { return }
+
+    var flags = VTEncodeInfoFlags()
+    VTCompressionSessionEncodeFrame(
+      session,
+      imageBuffer: pixelBuffer,
+      presentationTimeStamp: timestamp,
+      duration: .invalid,
+      frameProperties: nil,
+      sourceFrameRefcon: nil,
+      infoFlagsOut: &flags
+    )
+
+    // Trim the rolling buffer
+    trimBuffer()
+  }
+
+  func flushPendingFrames() {
+    guard let session = session else { return }
+    VTCompressionSessionCompleteFrames(session, untilPresentationTimeStamp: .invalid)
+  }
+
+  /// Get all buffered NAL data for upload, then clear the buffer.
+  func drainBuffer() -> Data {
+    bufferLock.lock()
+    defer { bufferLock.unlock() }
+
+    var combined = Data()
+    for entry in nalBuffer {
+      combined.append(entry.data)
+    }
+    nalBuffer.removeAll()
+    return combined
+  }
+
+  private func createSession(width: Int32, height: Int32) {
+    if let existing = session {
+      VTCompressionSessionInvalidate(existing)
+    }
+
+    self.width = width
+    self.height = height
+
+    let status = VTCompressionSessionCreate(
+      allocator: kCFAllocatorDefault,
+      width: width,
+      height: height,
+      codecType: kCMVideoCodecType_H264,
+      encoderSpecification: nil,
+      imageBufferAttributes: nil,
+      compressedDataAllocator: nil,
+      outputCallback: encoderCallback,
+      refcon: Unmanaged.passUnretained(self).toOpaque(),
+      compressionSessionOut: &session
+    )
+
+    guard status == noErr, let session = session else {
+      print("[SitePong ScreenRecorder] Failed to create VTCompressionSession: \(status)")
+      return
+    }
+
+    // Configure encoder
+    VTSessionSetProperty(session, key: kVTCompressionPropertyKey_ProfileLevel, value: kVTProfileLevel_H264_Baseline_AutoLevel)
+    VTSessionSetProperty(session, key: kVTCompressionPropertyKey_AverageBitRate, value: NSNumber(value: bitrate))
+    VTSessionSetProperty(session, key: kVTCompressionPropertyKey_RealTime, value: kCFBooleanTrue)
+    VTSessionSetProperty(session, key: kVTCompressionPropertyKey_AllowFrameReordering, value: kCFBooleanFalse)
+    // Keyframe every 5 seconds
+    VTSessionSetProperty(session, key: kVTCompressionPropertyKey_MaxKeyFrameInterval, value: NSNumber(value: 15))
+    VTSessionSetProperty(session, key: kVTCompressionPropertyKey_MaxKeyFrameIntervalDuration, value: NSNumber(value: 5.0))
+
+    VTCompressionSessionPrepareToEncodeFrames(session)
+    sessionCreated = true
+  }
+
+  private func trimBuffer() {
+    bufferLock.lock()
+    defer { bufferLock.unlock() }
+
+    let cutoff = CACurrentMediaTime() - Double(bufferDurationMs) / 1000.0
+    // Remove entries older than cutoff, but keep at least the most recent keyframe
+    var lastKeyframeIndex: Int? = nil
+    for (i, entry) in nalBuffer.enumerated() {
+      if entry.isKeyframe {
+        lastKeyframeIndex = i
+      }
+    }
+
+    var trimTo = 0
+    for (i, entry) in nalBuffer.enumerated() {
+      if entry.timestamp >= cutoff {
+        trimTo = i
+        break
+      }
+      trimTo = i + 1
+    }
+
+    // Don't trim past the last keyframe before cutoff
+    if let lki = lastKeyframeIndex, trimTo > lki {
+      trimTo = lki
+    }
+
+    if trimTo > 0 {
+      nalBuffer.removeFirst(trimTo)
+    }
+  }
+
+  func handleEncodedFrame(status: OSStatus, sampleBuffer: CMSampleBuffer?) {
+    guard status == noErr, let sampleBuffer = sampleBuffer else { return }
+
+    // Check if keyframe
+    let attachments = CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, createIfNecessary: false)
+    var isKeyframe = false
+    if let attachments = attachments, CFArrayGetCount(attachments) > 0 {
+      let dict = unsafeBitCast(CFArrayGetValueAtIndex(attachments, 0), to: CFDictionary.self)
+      let key = kCMSampleAttachmentKey_NotSync
+      isKeyframe = !CFDictionaryContainsKey(dict, Unmanaged.passUnretained(key).toOpaque())
+    }
+
+    var data = Data()
+
+    // For keyframes, prepend SPS/PPS parameter sets
+    if isKeyframe {
+      if let formatDesc = CMSampleBufferGetFormatDescription(sampleBuffer) {
+        // SPS
+        var spsSize: Int = 0
+        var spsCount: Int = 0
+        var spsPointer: UnsafePointer<UInt8>?
+        if CMVideoFormatDescriptionGetH264ParameterSetAtIndex(formatDesc, parameterSetIndex: 0, parameterSetPointerOut: &spsPointer, parameterSetSizeOut: &spsSize, parameterSetCountOut: &spsCount, nalUnitHeaderLengthOut: nil) == noErr,
+           let sps = spsPointer {
+          // Annex-B start code
+          data.append(contentsOf: [0x00, 0x00, 0x00, 0x01])
+          data.append(sps, count: spsSize)
+        }
+        // PPS
+        var ppsSize: Int = 0
+        var ppsPointer: UnsafePointer<UInt8>?
+        if CMVideoFormatDescriptionGetH264ParameterSetAtIndex(formatDesc, parameterSetIndex: 1, parameterSetPointerOut: &ppsPointer, parameterSetSizeOut: &ppsSize, parameterSetCountOut: nil, nalUnitHeaderLengthOut: nil) == noErr,
+           let pps = ppsPointer {
+          data.append(contentsOf: [0x00, 0x00, 0x00, 0x01])
+          data.append(pps, count: ppsSize)
+        }
+      }
+    }
+
+    // Extract NAL units from sample buffer
+    guard let dataBuffer = CMSampleBufferGetDataBuffer(sampleBuffer) else { return }
+    var totalLength: Int = 0
+    var bufferPointer: UnsafeMutablePointer<Int8>?
+    CMBlockBufferGetDataPointer(dataBuffer, atOffset: 0, lengthAtOffsetOut: nil, totalLengthOut: &totalLength, dataPointerOut: &bufferPointer)
+
+    guard let pointer = bufferPointer else { return }
+
+    var offset = 0
+    while offset < totalLength - 4 {
+      var nalUnitLength: UInt32 = 0
+      memcpy(&nalUnitLength, pointer.advanced(by: offset), 4)
+      nalUnitLength = nalUnitLength.bigEndian
+      offset += 4
+
+      // Annex-B start code
+      data.append(contentsOf: [0x00, 0x00, 0x00, 0x01])
+      data.append(Data(bytes: pointer.advanced(by: offset), count: Int(nalUnitLength)))
+      offset += Int(nalUnitLength)
+    }
+
+    // Add to rolling buffer (trimmed by time in encode())
+    bufferLock.lock()
+    nalBuffer.append((data: data, isKeyframe: isKeyframe, timestamp: CACurrentMediaTime()))
+    bufferLock.unlock()
+  }
+}
+
+// C callback for VTCompressionSession
+private func encoderCallback(
+  outputCallbackRefCon: UnsafeMutableRawPointer?,
+  sourceFrameRefCon: UnsafeMutableRawPointer?,
+  status: OSStatus,
+  infoFlags: VTEncodeInfoFlags,
+  sampleBuffer: CMSampleBuffer?
+) {
+  guard let refCon = outputCallbackRefCon else { return }
+  let encoder = Unmanaged<H264Encoder>.fromOpaque(refCon).takeUnretainedValue()
+  encoder.handleEncodedFrame(status: status, sampleBuffer: sampleBuffer)
+}

package/ios/ScreenRecorder/ScreenCapture.swift

@@ -0,0 +1,149 @@
+import UIKit
+import CoreVideo
+import CoreMedia
+
+class ScreenCapture {
+  private let fps: Int
+  private let sensitiveViewManager: SensitiveViewManager
+  private let onFrame: (CVPixelBuffer, CMTime) -> Void
+  private var timer: Timer?
+  private var frameCount: Int = 0
+  private var startTime: CFTimeInterval = 0
+
+  init(fps: Int, sensitiveViewManager: SensitiveViewManager, onFrame: @escaping (CVPixelBuffer, CMTime) -> Void) {
+    self.fps = max(1, min(fps, 10))
+    self.sensitiveViewManager = sensitiveViewManager
+    self.onFrame = onFrame
+  }
+
+  func start() {
+    guard timer == nil else { return }
+
+    startTime = CACurrentMediaTime()
+    frameCount = 0
+
+    let interval = 1.0 / Double(fps)
+    let t = Timer(timeInterval: interval, repeats: true) { [weak self] _ in
+      self?.tick()
+    }
+    RunLoop.main.add(t, forMode: .common)
+    timer = t
+
+    // Capture the first frame on main thread
+    if Thread.isMainThread {
+      tick()
+    } else {
+      DispatchQueue.main.async { [weak self] in
+        self?.tick()
+      }
+    }
+  }
+
+  func stop() {
+    timer?.invalidate()
+    timer = nil
+  }
+
+  private func tick() {
+    guard let window = Self.keyWindow else { return }
+
+    let elapsed = CACurrentMediaTime() - startTime
+    let timestamp = CMTimeMakeWithSeconds(elapsed, preferredTimescale: 600)
+
+    // Capture at half resolution to reduce size
+    let scale: CGFloat = 0.5
+    let scaledSize = CGSize(
+      width: window.bounds.width * scale,
+      height: window.bounds.height * scale
+    )
+    let renderer = UIGraphicsImageRenderer(size: scaledSize)
+    let image = renderer.image { ctx in
+      ctx.cgContext.scaleBy(x: scale, y: scale)
+      window.drawHierarchy(in: window.bounds, afterScreenUpdates: false)
+    }
+
+    // Get sensitive view rects in window coordinates
+    let sensitiveRects = sensitiveViewManager.getSensitiveRects(in: window)
+
+    // Draw black rectangles over sensitive areas directly on the image
+    let maskedImage: UIImage
+    if sensitiveRects.isEmpty {
+      maskedImage = image
+    } else {
+      let maskRenderer = UIGraphicsImageRenderer(size: scaledSize)
+      maskedImage = maskRenderer.image { ctx in
+        // Draw the original screenshot
+        image.draw(at: .zero)
+        // Draw black rectangles over sensitive areas (scaled to half resolution)
+        ctx.cgContext.setFillColor(UIColor.black.cgColor)
+        for rect in sensitiveRects {
+          let scaledRect = CGRect(
+            x: rect.origin.x * scale,
+            y: rect.origin.y * scale,
+            width: rect.size.width * scale,
+            height: rect.size.height * scale
+          )
+          ctx.cgContext.fill(scaledRect)
+        }
+      }
+    }
+
+    // Convert UIImage to CVPixelBuffer
+    guard let pixelBuffer = Self.pixelBuffer(from: maskedImage) else { return }
+
+    onFrame(pixelBuffer, timestamp)
+    frameCount += 1
+  }
+
+  private static var keyWindow: UIWindow? {
+    if #available(iOS 15.0, *) {
+      return UIApplication.shared.connectedScenes
+        .compactMap { $0 as? UIWindowScene }
+        .flatMap { $0.windows }
+        .first { $0.isKeyWindow }
+    } else {
+      return UIApplication.shared.windows.first { $0.isKeyWindow }
+    }
+  }
+
+  static func pixelBuffer(from image: UIImage) -> CVPixelBuffer? {
+    guard let cgImage = image.cgImage else { return nil }
+
+    let width = cgImage.width
+    let height = cgImage.height
+
+    let attrs: [String: Any] = [
+      kCVPixelBufferCGImageCompatibilityKey as String: true,
+      kCVPixelBufferCGBitmapContextCompatibilityKey as String: true,
+      kCVPixelBufferIOSurfacePropertiesKey as String: [:],
+    ]
+
+    var pixelBuffer: CVPixelBuffer?
+    let status = CVPixelBufferCreate(
+      kCFAllocatorDefault,
+      width, height,
+      kCVPixelFormatType_32BGRA,
+      attrs as CFDictionary,
+      &pixelBuffer
+    )
+
+    guard status == kCVReturnSuccess, let buffer = pixelBuffer else { return nil }
+
+    CVPixelBufferLockBaseAddress(buffer, [])
+    defer { CVPixelBufferUnlockBaseAddress(buffer, []) }
+
+    guard let context = CGContext(
+      data: CVPixelBufferGetBaseAddress(buffer),
+      width: width,
+      height: height,
+      bitsPerComponent: 8,
+      bytesPerRow: CVPixelBufferGetBytesPerRow(buffer),
+      space: CGColorSpaceCreateDeviceRGB(),
+      bitmapInfo: CGImageAlphaInfo.premultipliedFirst.rawValue | CGBitmapInfo.byteOrder32Little.rawValue
+    ) else { return nil }
+
+    context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
+
+    return buffer
+  }
+}

package/ios/ScreenRecorder/ScreenRecorderModule.swift

@@ -0,0 +1,179 @@
+import ExpoModulesCore
+// The single shared capture engine (spec §3/§4) is compiled into this same
+// `Sitepong` pod (ios/WatchtowerCore/*.swift), so it is reachable in-module —
+// no `import WatchtowerCore` and no separate pod. This module reimplements no
+// capture/screenshot/hash/redact/upload logic; it only forwards to the engine.
+
+public class SitePongScreenRecorderModule: Module {
+  private var screenCapture: ScreenCapture?
+  private var encoder: H264Encoder?
+  private var uploader: ChunkUploader?
+  private var sensitiveViewManager = SensitiveViewManager()
+  private var recording = false
+
+  public func definition() -> ModuleDefinition {
+    Name("SitePongScreenRecorder")
+
+    Function("isRecording") { () -> Bool in
+      return self.recording
+    }
+
+    AsyncFunction("startRecording") { (options: [String: Any], promise: Promise) in
+      guard !self.recording else {
+        promise.resolve(nil)
+        return
+      }
+
+      let apiKey = options["apiKey"] as? String ?? ""
+      let endpoint = options["endpoint"] as? String ?? "https://ingest.sitepong.com"
+      let sessionId = options["sessionId"] as? String ?? ""
+      let fps = options["fps"] as? Int ?? 1
+      let quality = options["quality"] as? String ?? "standard"
+      let bufferDuration = options["bufferDuration"] as? Int ?? 60_000
+
+      let bitrate = self.bitrateForQuality(quality)
+
+      self.uploader = ChunkUploader(
+        endpoint: endpoint,
+        apiKey: apiKey,
+        sessionId: sessionId
+      )
+
+      self.encoder = H264Encoder(
+        bitrate: bitrate,
+        bufferDurationMs: bufferDuration
+      )
+
+      self.screenCapture = ScreenCapture(
+        fps: fps,
+        sensitiveViewManager: self.sensitiveViewManager,
+        onFrame: { [weak self] pixelBuffer, timestamp in
+          self?.encoder?.encode(pixelBuffer: pixelBuffer, timestamp: timestamp)
+        }
+      )
+
+      self.encoder?.start()
+      self.screenCapture?.start()
+      self.recording = true
+      promise.resolve(nil)
+    }
+
+    AsyncFunction("stopRecording") { (promise: Promise) in
+      self.stopInternal()
+      promise.resolve(nil)
+    }
+
+    AsyncFunction("flushBuffer") { (promise: Promise) in
+      guard self.recording else {
+        promise.resolve(nil)
+        return
+      }
+      // Flush pending frames from encoder to its rolling buffer
+      self.encoder?.flushPendingFrames()
+      // Drain the encoder's time-trimmed rolling buffer
+      let data = self.encoder?.drainBuffer() ?? Data()
+      let uploader = self.uploader
+      DispatchQueue.global(qos: .utility).async {
+        let semaphore = DispatchSemaphore(value: 0)
+        Task {
+          do {
+            try await uploader?.uploadData(data)
+          } catch {
+            print("[SitePong ScreenRecorder] Flush error: \(error)")
+          }
+          semaphore.signal()
+        }
+        semaphore.wait()
+        DispatchQueue.main.async {
+          promise.resolve(nil)
+        }
+      }
+    }
+
+    Function("addSensitiveView") { (viewTag: Int) in
+      self.sensitiveViewManager.addView(tag: viewTag)
+      // Also mark the underlying UIView so WatchtowerCore's redaction (§5/§4.3)
+      // sees it — same UIView, no new capture code. Marking happens on main.
+      DispatchQueue.main.async {
+        if let view = self.findUIView(tag: viewTag) {
+          view.watchtowerSensitive = true
+        }
+      }
+    }
+
+    Function("removeSensitiveView") { (viewTag: Int) in
+      self.sensitiveViewManager.removeView(tag: viewTag)
+      DispatchQueue.main.async {
+        if let view = self.findUIView(tag: viewTag) {
+          view.watchtowerSensitive = false
+        }
+      }
+    }
+
+    // MARK: - Watchtower thin bridge (spec §4.1)
+    // Each function ONLY forwards to the shared WatchtowerCore engine (§3).
+    // No tap capture, screenshot, hashing, redaction, or upload logic here.
+
+    Function("watchtowerStart") { (config: [String: Any]) in
+      let apiKey = config["apiKey"] as? String ?? ""
+      let projectId = config["projectId"] as? String ?? ""
+      let endpointStr = config["endpoint"] as? String ?? ""
+      let sampleRate = config["sampleRate"] as? Double ?? 0.1
+      // RN host stamps platform "react-native-ios" (§1.1/§4.4).
+      let platform = config["platform"] as? String ?? "react-native-ios"
+      guard let endpoint = URL(string: endpointStr) else { return }
+      Watchtower.start(apiKey: apiKey, projectId: projectId,
+                       endpoint: endpoint, sampleRate: sampleRate,
+                       platform: platform)
+    }
+
+    Function("watchtowerStop") {
+      Watchtower.stop()
+    }
+
+    Function("watchtowerSetScreen") { (name: String) in
+      Watchtower.setScreen(name)
+    }
+
+    Function("watchtowerCaptureScreenshot") {
+      Watchtower.captureScreenshot()
+    }
+
+    Function("watchtowerSetUser") { (distinctId: String?) in
+      Watchtower.setUser(distinctId)
+    }
+
+    Function("watchtowerGetSessionId") { () -> String? in
+      return Watchtower.sessionId
+    }
+  }
+
+  /// Find a UIView by React tag across all key windows (mirrors
+  /// SensitiveViewManager's lookup but at the window level for redaction).
+  private func findUIView(tag: Int) -> UIView? {
+    for scene in UIApplication.shared.connectedScenes {
+      guard let windowScene = scene as? UIWindowScene else { continue }
+      for window in windowScene.windows {
+        if let v = window.viewWithTag(tag), v !== window { return v }
+      }
+    }
+    return nil
+  }
+
+  private func stopInternal() {
+    self.screenCapture?.stop()
+    self.encoder?.stop()
+    self.screenCapture = nil
+    self.encoder = nil
+    self.uploader = nil
+    self.recording = false
+  }
+
+  private func bitrateForQuality(_ quality: String) -> Int {
+    switch quality {
+    case "low": return 50_000
+    case "high": return 300_000
+    default: return 150_000 // standard
+    }
+  }
+}

package/ios/ScreenRecorder/SensitiveViewManager.swift

@@ -0,0 +1,63 @@
+import UIKit
+
+class SensitiveViewManager {
+  private var sensitiveViewTags: Set<Int> = []
+  private let lock = NSLock()
+
+  func addView(tag: Int) {
+    lock.lock()
+    sensitiveViewTags.insert(tag)
+    lock.unlock()
+  }
+
+  func removeView(tag: Int) {
+    lock.lock()
+    sensitiveViewTags.remove(tag)
+    lock.unlock()
+  }
+
+  /// Return the window-coordinate rects of all registered sensitive views.
+  /// Used by ScreenCapture to draw black rectangles over these areas.
+  func getSensitiveRects(in window: UIWindow) -> [CGRect] {
+    lock.lock()
+    let tags = sensitiveViewTags
+    lock.unlock()
+
+    var rects: [CGRect] = []
+
+    for tag in tags {
+      guard let sensitiveView = findView(tag: tag, in: window) else {
+        continue
+      }
+
+      let frame = sensitiveView.convert(sensitiveView.bounds, to: window)
+      guard !frame.isEmpty, frame.width > 0, frame.height > 0 else { continue }
+
+      rects.append(frame)
+    }
+
+    return rects
+  }
+
+  /// Find a UIView by its tag by walking the entire hierarchy.
+  private func findView(tag: Int, in window: UIWindow) -> UIView? {
+    // UIKit's built-in viewWithTag (works in Fabric since UIView.tag is set)
+    if let view = window.viewWithTag(tag), view !== window {
+      return view
+    }
+    // Full recursive walk as fallback
+    return findViewRecursively(in: window, tag: tag)
+  }
+
+  private func findViewRecursively(in view: UIView, tag: Int) -> UIView? {
+    for subview in view.subviews {
+      if subview.tag == tag {
+        return subview
+      }
+      if let found = findViewRecursively(in: subview, tag: tag) {
+        return found
+      }
+    }
+    return nil
+  }
+}

package/ios/Sitepong.podspec

@@ -0,0 +1,57 @@
+require 'json'
+
+# This podspec lives in ios/ (where Expo autolinking discovers module podspecs),
+# so package.json is one level up.
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+# ─────────────────────────────────────────────────────────────────────────────
+# ONE pod for the entire SitePong SDK.
+#
+# Every native capability customers used to install as a separate npm package —
+# screen recording, the Watchtower tap-capture engine, the persistent device id,
+# and Live Activities — now compiles into this single `Sitepong` pod. Apps
+# install ONE package (`sitepong`); Expo autolinking finds this podspec and links
+# all of it. Nothing is linked via a Podfile patch anymore: the Watchtower engine
+# (ios/WatchtowerCore/*.swift) is part of this same Swift module, so the bridge
+# reaches it directly without `import WatchtowerCore` or a `:path` pod.
+#
+# The Live Activity Widget Extension (ios/LiveActivity/widget/**) is the only
+# native code NOT in this pod — a WidgetKit extension is a separate app target,
+# injected opt-in by app.plugin.js when `liveActivities` is enabled.
+# ─────────────────────────────────────────────────────────────────────────────
+Pod::Spec.new do |s|
+  s.name           = 'Sitepong'
+  s.version        = package['version']
+  s.summary        = package['description'] || 'Official SitePong SDK'
+  s.description    = package['description'] || 'Official SitePong SDK'
+  s.license        = package['license'] || 'MIT'
+  s.author         = 'SitePong'
+  s.homepage       = 'https://sitepong.com'
+  # 15.1 is the highest floor across the merged modules (screen recorder /
+  # live activity). ActivityKit / WidgetKit symbols are gated at runtime with
+  # @available(iOS 16.2, *), so a 15.1 deployment target is safe.
+  s.platforms      = { :ios => '15.1' }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/programmrz/sitepong.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # UIKit/CoreImage/Foundation — Watchtower engine. VideoToolbox/CoreMedia/
+  # CoreVideo — the H.264 screen recorder. SwiftUI — engine + widget modifiers.
+  s.frameworks       = 'UIKit', 'CoreImage', 'Foundation',
+                       'VideoToolbox', 'CoreMedia', 'CoreVideo', 'SwiftUI'
+  # ActivityKit / WidgetKit are iOS 16.2+; weak-link so a 15.1 app still loads.
+  s.weak_frameworks  = 'ActivityKit', 'WidgetKit'
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  # Paths are relative to this podspec (ios/). Everything under ios/ EXCEPT the
+  # Live Activity widget extension, which is a separate WidgetKit app-extension
+  # target added by the config plugin.
+  s.source_files  = '**/*.{h,m,mm,swift}'
+  s.exclude_files = 'LiveActivity/widget/**/*'
+end