@stream-io/video-react-native-sdk 1.36.2 → 1.37.1-beta.0

package/ios/StreamVideoReactNative.m

@@ -4,7 +4,6 @@
 #import <React/RCTUIManagerUtils.h>
 #import <UIKit/UIKit.h>
 #import <CallKit/CallKit.h>
-#import <PushKit/PushKit.h>
 #import "StreamVideoReactNative.h"
 #import "WebRTCModule.h"
 #import "WebRTCModuleOptions.h"
@@ -21,12 +20,17 @@
 #import <stream_react_native_webrtc/stream_react_native_webrtc-Swift.h>
 #endif
 
+// Import Swift-generated header for TracksRecorderManager and friends.
+#if __has_include("stream_video_react_native-Swift.h")
+#import "stream_video_react_native-Swift.h"
+#elif __has_include(<stream_video_react_native/stream_video_react_native-Swift.h>)
+#import <stream_video_react_native/stream_video_react_native-Swift.h>
+#endif
+
 // Do not change these consts, it is what is used react-native-webrtc
 NSNotificationName const kBroadcastStartedNotification = @"iOS_BroadcastStarted";
 NSNotificationName const kBroadcastStoppedNotification = @"iOS_BroadcastStopped";
 
-static NSString *const DEFAULT_DISPLAY_NAME = @"Unknown Caller";
-
 static dispatch_queue_t _dictionaryQueue = nil;
 
 void broadcastNotificationCallback(CFNotificationCenterRef center,
@@ -49,9 +53,6 @@ void broadcastNotificationCallback(CFNotificationCenterRef center,
     AVAudioPlayer *_busyTonePlayer; // Instance variable
 }
 
-// necessary for addUIBlock usage https://github.com/facebook/react-native/issues/50800#issuecomment-2823327307
-@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
-
 RCT_EXPORT_MODULE();
 
 +(BOOL)requiresMainQueueSetup {
@@ -72,77 +73,6 @@ RCT_EXPORT_MODULE();
     });
 }
 
-+(BOOL)canRegisterCall {
-    Class callingxClass = NSClassFromString(@"Callingx");
-    if (!callingxClass) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][canRegisterCall] Callingx not available");
-        #endif
-        return YES;
-    }
-
-    SEL selector = @selector(canRegisterCall);
-    if (![callingxClass respondsToSelector:selector]) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][canRegisterCall] Callingx does not respond to canRegisterCall selector");
-        #endif
-        return YES;
-    }
-
-    NSMethodSignature *signature = [callingxClass methodSignatureForSelector:selector];
-    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
-    [invocation setTarget:callingxClass];
-    [invocation setSelector:selector];
-    [invocation invoke];
-
-    BOOL canRegister = NO;
-    [invocation getReturnValue:&canRegister];
-
-    #if DEBUG
-    NSLog(@"[StreamVideoReactNative][canRegisterCall] canRegisterCall = %@", canRegister ? @"YES" : @"NO");
-    #endif
-
-    return canRegister;
-}
-
-+(BOOL)shouldSkipIncomingPushInForeground {
-    Class callingxClass = NSClassFromString(@"Callingx");
-    if (!callingxClass) {
-        return NO;
-    }
-
-    SEL selector = @selector(shouldSkipIncomingPushInForeground);
-    if (![callingxClass respondsToSelector:selector]) {
-        return NO;
-    }
-
-    NSMethodSignature *signature = [callingxClass methodSignatureForSelector:selector];
-    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
-    [invocation setTarget:callingxClass];
-    [invocation setSelector:selector];
-    [invocation invoke];
-
-    BOOL shouldSkip = NO;
-    [invocation getReturnValue:&shouldSkip];
-    return shouldSkip;
-}
-
-+(BOOL)isAppInForeground {
-    // applicationState must be read on the main thread (PushKit delivers on
-    // main, so the common path skips dispatch). Treat Inactive as foreground:
-    // covers brief transitions and system overlays.
-    __block UIApplicationState state = UIApplicationStateActive;
-    void (^readState)(void) = ^{
-        state = [UIApplication sharedApplication].applicationState;
-    };
-    if ([NSThread isMainThread]) {
-        readState();
-    } else {
-        dispatch_sync(dispatch_get_main_queue(), readState);
-    }
-    return state != UIApplicationStateBackground;
-}
-
 +(void)voipRegistration {
     Class voipManagerClass = NSClassFromString(@"Callingx.VoipNotificationsManager");
     if (!voipManagerClass) {
@@ -168,223 +98,6 @@ RCT_EXPORT_MODULE();
     [voipManagerClass voipRegistration];
 }
 
-+(void)didUpdatePushCredentials:(PKPushCredentials *)credentials forType:(NSString *)type {
-    Class voipManagerClass = NSClassFromString(@"Callingx.VoipNotificationsManager");
-    if (!voipManagerClass) {
-        // Fallback: Try the unmangled name (might work depending on Swift version)
-        voipManagerClass = NSClassFromString(@"VoipNotificationsManager");
-    }
-    
-    if (!voipManagerClass) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didUpdatePushCredentials] VoipNotificationsManager not available");
-        #endif
-        return;
-    }
-    
-    SEL selector = @selector(didUpdatePushCredentials:forType:);
-    if (![voipManagerClass respondsToSelector:selector]) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didUpdatePushCredentials] VoipNotificationsManager does not respond to didUpdatePushCredentials:forType:");
-        #endif
-        return;
-    }
-    
-    [voipManagerClass didUpdatePushCredentials:credentials forType:type];
-}
-
-+(void)didReceiveIncomingPush:(PKPushPayload *)payload forType:(NSString *)type completionHandler: (void (^_Nullable)(void)) completion {
-    NSDictionary *streamPayload = payload.dictionaryPayload[@"stream"];
-    if (!streamPayload) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPush] Stream payload not found");
-        #endif
-        if (completion) {
-            completion();
-        }
-        return;
-    }
-
-    NSString *callCid = streamPayload[@"call_cid"];
-    if (!callCid) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPush] Missing required field: call_cid");
-        #endif
-        if (completion) {
-            completion();
-        }
-        return;
-    }
-
-    if (![StreamVideoReactNative canRegisterCall]) {
-        if (completion) {
-            completion();
-        }
-        return;
-    }
-
-    [StreamVideoReactNative reportNewIncomingCall:streamPayload forType:type completionHandler:completion];
-    [StreamVideoReactNative didReceiveIncomingPushWithPayload:payload forType:type];
-}
-
-+(void)didReceiveIncomingVoIPPush:(PKPushPayload *)payload
-                         metadata:(id _Nullable)metadata
-                completionHandler:(void (^_Nullable)(void))completion {
-    NSDictionary *streamPayload = payload.dictionaryPayload[@"stream"];
-    if (!streamPayload) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingVoIPPush] Stream payload not found");
-        #endif
-        if (completion) {
-            completion();
-        }
-        return;
-    }
-
-    NSString *callCid = streamPayload[@"call_cid"];
-    if (!callCid) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingVoIPPush] Missing required field: call_cid");
-        #endif
-        if (completion) {
-            completion();
-        }
-        return;
-    }
-
-    NSString *type = @"PKPushTypeVoIP";
-    BOOL mustReport = readMustReportFromMetadata(metadata);
-
-    // Both skip paths require mustReport == NO; skipping while YES risks
-    // PushKit terminating the app.
-    if (!mustReport && ![StreamVideoReactNative canRegisterCall]) {
-        // Busy reject: drop without forwarding to JS.
-        if (completion) {
-            completion();
-        }
-        return;
-    }
-
-    if (!mustReport &&
-        [StreamVideoReactNative shouldSkipIncomingPushInForeground] &&
-        [StreamVideoReactNative isAppInForeground]) {
-        // Foreground skip: hide CallKit, let JS render the ringing UI.
-        [StreamVideoReactNative didReceiveIncomingPushWithPayload:payload forType:type];
-        if (completion) {
-            completion();
-        }
-        return;
-    }
-
-    [StreamVideoReactNative reportNewIncomingCall:streamPayload forType:type completionHandler:completion];
-    [StreamVideoReactNative didReceiveIncomingPushWithPayload:payload forType:type];
-}
-
-// Reads `PKVoIPPushMetadata.mustReport` via runtime dispatch. Fail-safe:
-// returns YES on any uncertainty (nil, missing property, wrong return type)
-// so unknown metadata never causes CallKit to be skipped.
-static BOOL readMustReportFromMetadata(id _Nullable metadata) {
-    SEL selector = @selector(mustReport);
-    if (!metadata || ![metadata respondsToSelector:selector]) {
-        return YES;
-    }
-    NSMethodSignature *signature = [metadata methodSignatureForSelector:selector];
-    if (!signature || signature.methodReturnLength != sizeof(BOOL)) {
-        return YES;
-    }
-    // BOOL encodes as "c" (legacy ABIs) or "B" (modern). Reject anything else
-    // so getReturnValue: never reads garbage from an object-returning selector.
-    const char *returnType = signature.methodReturnType;
-    if (!returnType ||
-        (strcmp(returnType, @encode(BOOL)) != 0 &&
-         strcmp(returnType, @encode(bool)) != 0)) {
-        return YES;
-    }
-
-    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
-    [invocation setTarget:metadata];
-    [invocation setSelector:selector];
-    [invocation invoke];
-
-    BOOL mustReport = NO;
-    [invocation getReturnValue:&mustReport];
-    return mustReport;
-}
-
-+(void)reportNewIncomingCall:(NSDictionary *)streamPayload forType:(NSString *)type completionHandler: (void (^_Nullable)(void)) completion {
-    Class callingxClass = NSClassFromString(@"Callingx");
-    if (!callingxClass) {
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPush] Callingx not available");
-        return;
-    }
-    
-    SEL selector = @selector(reportNewIncomingCall:handle:handleType:hasVideo:localizedCallerName:supportsHolding:supportsDTMF:supportsGrouping:supportsUngrouping:payload:withCompletionHandler:);
-    if (![callingxClass respondsToSelector:selector]) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPush] Callingx does not respond to selector");
-        #endif
-        return;
-    }
-    
-    NSString *callCid = streamPayload[@"call_cid"];
-    NSString *callDisplayName = streamPayload[@"call_display_name"];
-    NSString *createdByDisplayName = streamPayload[@"created_by_display_name"];
-    NSString *createdCallerName = callDisplayName.length > 0 ? callDisplayName : createdByDisplayName;
-    NSString *localizedCallerName = createdCallerName.length > 0 ? createdCallerName : DEFAULT_DISPLAY_NAME;
-    NSString *createdById = streamPayload[@"created_by_id"];
-    NSString *handle = createdById.length > 0 ? createdById : localizedCallerName;
-    NSString *videoIncluded = streamPayload[@"video"];
-    BOOL hasVideo = [videoIncluded isEqualToString:@"false"] ? NO : YES;
-    NSString *handleType = @"generic";
-    BOOL supportsHolding = NO;
-    BOOL supportsDTMF = NO;
-    BOOL supportsGrouping = NO;
-    BOOL supportsUngrouping = NO;
-    void (^completionHandler)(void) = completion;
-
-    NSMethodSignature *signature = [callingxClass methodSignatureForSelector:selector];
-    NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
-    [invocation setTarget:callingxClass];
-    [invocation setSelector:selector];
-    [invocation setArgument:&callCid atIndex:2];
-    [invocation setArgument:&handle atIndex:3];
-    [invocation setArgument:&handleType atIndex:4];
-    [invocation setArgument:&hasVideo atIndex:5];
-    [invocation setArgument:&localizedCallerName atIndex:6];
-    [invocation setArgument:&supportsHolding atIndex:7];
-    [invocation setArgument:&supportsDTMF atIndex:8];
-    [invocation setArgument:&supportsGrouping atIndex:9];
-    [invocation setArgument:&supportsUngrouping atIndex:10];
-    [invocation setArgument:&streamPayload atIndex:11];
-    [invocation setArgument:&completionHandler atIndex:12];
-    [invocation invoke];
-}
-
-+(void)didReceiveIncomingPushWithPayload:(PKPushPayload *)payload forType:(NSString *)type {
-    Class voipManagerClass = NSClassFromString(@"Callingx.VoipNotificationsManager");
-    if (!voipManagerClass) {
-        // Fallback: Try the unmangled name (might work depending on Swift version)
-        voipManagerClass = NSClassFromString(@"VoipNotificationsManager");
-    }
-    
-    if (!voipManagerClass) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPushWithPayload] VoipNotificationsManager not available");
-        #endif
-        return;
-    }
-    
-    SEL selector = @selector(didReceiveIncomingPushWithPayload:forType:);
-    if (![voipManagerClass respondsToSelector:selector]) {
-        #if DEBUG
-        NSLog(@"[StreamVideoReactNative][didReceiveIncomingPushWithPayload] VoipNotificationsManager does not respond to didReceiveIncomingPushWithPayload:forType:");
-        #endif
-        return;
-    }
-    
-    [voipManagerClass didReceiveIncomingPushWithPayload:payload forType:type];
-}
-
 -(instancetype)init {
     if ((self = [super init])) {
         _notificationCenter = CFNotificationCenterGetDarwinNotifyCenter();
@@ -924,7 +637,7 @@ RCT_EXPORT_METHOD(stopInAppScreenCapture:(RCTPromiseResolveBlock)resolve
 RCT_EXPORT_METHOD(startScreenShareAudioMixing:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 {
-    WebRTCModule *webrtcModule = [self.bridge moduleForClass:[WebRTCModule class]];
+    WebRTCModule *webrtcModule = [self.moduleRegistry moduleForName:"WebRTCModule"];
     WebRTCModuleOptions *options = [WebRTCModuleOptions sharedInstance];
 
     ScreenShareAudioMixer *mixer = webrtcModule.audioDeviceModule.screenShareAudioMixer;
@@ -955,7 +668,7 @@ RCT_EXPORT_METHOD(startScreenShareAudioMixing:(RCTPromiseResolveBlock)resolve
 RCT_EXPORT_METHOD(stopScreenShareAudioMixing:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject)
 {
-    WebRTCModule *webrtcModule = [self.bridge moduleForClass:[WebRTCModule class]];
+    WebRTCModule *webrtcModule = [self.moduleRegistry moduleForName:"WebRTCModule"];
     WebRTCModuleOptions *options = [WebRTCModuleOptions sharedInstance];
 
     // Stop feeding audio to the mixer
@@ -979,4 +692,78 @@ RCT_EXPORT_METHOD(stopScreenShareAudioMixing:(RCTPromiseResolveBlock)resolve
     resolve(nil);
 }
 
+#pragma mark - Track Recording
+
+RCT_EXPORT_METHOD(startTrackRecording:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    WebRTCModule *webrtcModule = [self.bridge moduleForClass:[WebRTCModule class]];
+    if (!webrtcModule) {
+        reject(@"recording_error", @"WebRTCModule not available", nil);
+        return;
+    }
+
+    NSString *videoTrackId = options[@"videoTrackId"];
+    if (![videoTrackId isKindOfClass:[NSString class]]) videoTrackId = nil;
+
+    NSNumber *maxDuration = options[@"maxDurationMs"];
+    NSInteger maxDurationMs = ([maxDuration isKindOfClass:[NSNumber class]])
+        ? [maxDuration integerValue] : 5000;
+
+    NSNumber *targetW = options[@"targetWidth"];
+    NSInteger targetWidth = ([targetW isKindOfClass:[NSNumber class]])
+        ? [targetW integerValue] : 0;
+
+    NSNumber *targetH = options[@"targetHeight"];
+    NSInteger targetHeight = ([targetH isKindOfClass:[NSNumber class]])
+        ? [targetH integerValue] : 0;
+
+    [[TracksRecorderManager shared]
+        startRecordingWithVideoTrackId:videoTrackId
+                         maxDurationMs:maxDurationMs
+                           targetWidth:targetWidth
+                          targetHeight:targetHeight
+                          webRTCModule:webrtcModule
+                            completion:^(NSURL * _Nullable fileURL, NSError * _Nullable err) {
+        if (err) {
+            reject(@"recording_error", err.localizedDescription, err);
+        } else {
+            resolve(fileURL ? fileURL.absoluteString : [NSNull null]);
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(stopTrackRecording:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [[TracksRecorderManager shared] stopRecordingWithCompletion:^{
+        resolve(nil);
+    }];
+}
+
+RCT_EXPORT_METHOD(clearStreamRecordings:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [[TracksRecorderManager shared] clearRecordingsDirectoryWithCompletion:^(NSError * _Nullable err) {
+        if (err) {
+            reject(@"clear_error", err.localizedDescription, err);
+        } else {
+            resolve(nil);
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(getStreamRecordings:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    NSArray<NSURL *> *urls = [[TracksRecorderManager shared] listRecordings];
+    NSMutableArray<NSString *> *result = [NSMutableArray arrayWithCapacity:urls.count];
+    for (NSURL *url in urls) {
+        NSString *abs = url.absoluteString;
+        if (abs) [result addObject:abs];
+    }
+    resolve(result);
+}
+
 @end

package/ios/TracksRecorder/AudioPipeline.swift

@@ -0,0 +1,270 @@
+//
+// Copyright © 2026 Stream.io Inc. All rights reserved.
+//
+
+import AVFoundation
+import CoreMedia
+import Foundation
+import WebRTC
+
+/// Audio pipeline owned by `TracksRecorderManager`. Encapsulates the AAC audio path:
+///  - the `RecorderAudioRenderTap` installed on
+///    `RTCDefaultAudioProcessingModule.renderPreProcessingDelegate`
+///    (post-mix decoded audio, no per-track lookup required),
+///  - the in-place speaker mute (`muteOriginal: true` on the tap; the tap
+///    zero-fills the buffer after copying for recording),
+///  - the AAC `AVAssetWriterInput` (writer-driven encode via
+///    `outputSettings`),
+///  - per-recording counters / PTS range surfaced via `logSummary` at stop.
+///
+/// All state mutation runs on the host's serial queue. The tap's
+/// callback runs on a WebRTC audio thread and re-dispatches onto
+/// `host.queue` after copying the PCM buffer.
+internal final class AudioPipeline {
+
+    private static let aacBitRate: NSNumber = NSNumber(value: 64_000)
+
+    private weak var host: PipelineHost?
+
+    private let apm: RTCDefaultAudioProcessingModule
+
+    private var renderTap: RecorderAudioRenderTap?
+    private var audioInput: AVAssetWriterInput?
+    private var inputAdded = false
+
+    // Diagnostic counters + PTS range, surfaced via [logSummary] at stop.
+    private var buffersReceived = 0
+    private var samplesAppended = 0
+    private var buffersDropped = 0
+    private var firstSamplePtsUs: Int64 = -1
+    private var lastSamplePtsUs: Int64 = -1
+
+    // MARK: - Init
+
+    init(host: PipelineHost, apm: RTCDefaultAudioProcessingModule) {
+        self.host = host
+        self.apm = apm
+    }
+
+    // MARK: - Public API
+
+    /// Install the render-tap as the APM's `renderPreProcessingDelegate`.
+    /// The tap copies PCM into a new buffer for recording AND zero-fills the
+    /// original (post-mix decoded audio) so the speaker plays silence —
+    /// this gives "audio in the file, silence at the speaker" without
+    /// disrupting the recording. The standard `track.setVolume(0)` /
+    /// `track.isEnabled = false` mutes apply *before* this tap and would
+    /// silence the recording too.
+    func start() {
+        let tap = RecorderAudioRenderTap(muteOriginal: true) { [weak self] pcmBuffer in
+            self?.handleAudioBuffer(pcmBuffer: pcmBuffer)
+        }
+        renderTap = tap
+        apm.renderPreProcessingDelegate = tap
+    }
+
+    /// On-queue. Clear the render-tap delegate slot — only if it still
+    /// points to this pipeline's tap. If another consumer has rotated in,
+    /// leave theirs alone.
+    func detachSink() {
+        if let tap = renderTap, apm.renderPreProcessingDelegate === tap {
+            apm.renderPreProcessingDelegate = nil
+        }
+        renderTap = nil
+    }
+
+    /// On-queue. Marks the asset-writer input as finished so the writer can
+    /// finalise.
+    func markInputAsFinished() {
+        audioInput?.markAsFinished()
+    }
+
+    func logSummary() {
+        let tapCalls = renderTap?.callCount ?? -1
+        let durationMs: Int64
+        if firstSamplePtsUs >= 0 && lastSamplePtsUs >= firstSamplePtsUs {
+            durationMs = (lastSamplePtsUs - firstSamplePtsUs) / 1000
+        } else {
+            durationMs = -1
+        }
+        NSLog(
+            "[TracksRecorder.Audio] summary received=%d appended=%d dropped=%d tapCalls=%d firstPtsUs=%lld lastPtsUs=%lld durationMs=%lld",
+            buffersReceived,
+            samplesAppended,
+            buffersDropped,
+            tapCalls,
+            firstSamplePtsUs,
+            lastSamplePtsUs,
+            durationMs
+        )
+    }
+
+    // MARK: - Tap → queue bridge
+
+    private func handleAudioBuffer(pcmBuffer: AVAudioPCMBuffer) {
+        // Unlike `VideoPipeline`'s `CVPixelBuffer` closure capture, an
+        // ARC-retained `AVAudioPCMBuffer` does *not* extend the lifetime
+        // of the underlying PCM samples — those live in WebRTC's
+        // render-buffer pool and are reused the moment this callback
+        // returns. A deep copy before the queue hop is mandatory.
+        guard let copy = AudioPipeline.deepCopyPCMBuffer(pcmBuffer) else { return }
+        guard let host = host else { return }
+
+        // `DispatchTime.now().uptimeNanoseconds` is the monotonic clock
+        // that matches `RTCVideoFrame.timeStampNs` on iOS — both reduce
+        // to `mach_absolute_time()` converted to nanoseconds, so the
+        // shared time origin works coherently across both pipelines.
+        let captureTimeNs = DispatchTime.now().uptimeNanoseconds
+        host.queue.async { [weak self] in
+            self?.handleAudioBufferOnQueue(pcmBuffer: copy, captureTimeNs: captureTimeNs)
+        }
+    }
+
+    private func handleAudioBufferOnQueue(pcmBuffer: AVAudioPCMBuffer, captureTimeNs: UInt64) {
+        guard let host = host, host.isRecording, let writer = host.assetWriter else { return }
+
+        // Lazy-create the writer's audio input on the first buffer. The
+        // input's settings depend on the runtime PCM format reported by
+        // WebRTC.
+        if audioInput == nil {
+            configureAudioInput(format: pcmBuffer.format, writer: writer)
+        }
+
+        let pts = presentationTime(host: host, timestampNs: captureTimeNs)
+
+        guard writer.status == .writing,
+              let audioInput = audioInput,
+              audioInput.isReadyForMoreMediaData else {
+            buffersDropped += 1
+            return
+        }
+
+        guard let sampleBuffer = AudioPipeline.makeSampleBuffer(from: pcmBuffer, pts: pts) else {
+            buffersDropped += 1
+            return
+        }
+
+        if audioInput.append(sampleBuffer) {
+            buffersReceived += 1
+            samplesAppended += 1
+            let ptsUs = Int64(CMTimeGetSeconds(pts) * 1_000_000)
+            if firstSamplePtsUs < 0 || ptsUs < firstSamplePtsUs {
+                firstSamplePtsUs = ptsUs
+            }
+            if ptsUs > lastSamplePtsUs {
+                lastSamplePtsUs = ptsUs
+            }
+        } else {
+            buffersDropped += 1
+        }
+    }
+
+    // MARK: - Asset writer input setup
+
+    private func configureAudioInput(format: AVAudioFormat, writer: AVAssetWriter) {
+        let settings: [String: Any] = [
+            AVFormatIDKey: NSNumber(value: kAudioFormatMPEG4AAC),
+            AVSampleRateKey: NSNumber(value: format.sampleRate),
+            AVNumberOfChannelsKey: NSNumber(value: format.channelCount),
+            AVEncoderBitRateKey: AudioPipeline.aacBitRate,
+        ]
+        let input = AVAssetWriterInput(mediaType: .audio, outputSettings: settings)
+        input.expectsMediaDataInRealTime = true
+
+        guard writer.canAdd(input) else {
+            NSLog("[TracksRecorder.Audio] writer cannot add audio input")
+            host?.onFatalError(makeRecorderError("audio_input_add_failed", code: 4))
+            return
+        }
+         
+        writer.add(input)
+        audioInput = input
+        inputAdded = true
+        host?.onTrackAdded()
+    }
+
+    // MARK: - PCM → CMSampleBuffer helper
+
+    /// Converts an `AVAudioPCMBuffer` into a `CMSampleBuffer` suitable for
+    /// `AVAssetWriterInput.append`. Returns `nil` if any Core Media call
+    /// fails; the caller treats that as a dropped buffer.
+    private static func makeSampleBuffer(
+        from pcmBuffer: AVAudioPCMBuffer,
+        pts: CMTime
+    ) -> CMSampleBuffer? {
+        var formatDescription: CMAudioFormatDescription?
+        let createDescStatus = CMAudioFormatDescriptionCreate(
+            allocator: kCFAllocatorDefault,
+            asbd: pcmBuffer.format.streamDescription,
+            layoutSize: 0,
+            layout: nil,
+            magicCookieSize: 0,
+            magicCookie: nil,
+            extensions: nil,
+            formatDescriptionOut: &formatDescription
+        )
+        guard createDescStatus == noErr, let formatDesc = formatDescription else { return nil }
+
+        var sampleBuffer: CMSampleBuffer?
+        var timing = CMSampleTimingInfo(
+            duration: CMTime(value: 1, timescale: Int32(pcmBuffer.format.sampleRate)),
+            presentationTimeStamp: pts,
+            decodeTimeStamp: .invalid
+        )
+        let createStatus = CMSampleBufferCreate(
+            allocator: kCFAllocatorDefault,
+            dataBuffer: nil,
+            dataReady: false,
+            makeDataReadyCallback: nil,
+            refcon: nil,
+            formatDescription: formatDesc,
+            sampleCount: CMItemCount(pcmBuffer.frameLength),
+            sampleTimingEntryCount: 1,
+            sampleTimingArray: &timing,
+            sampleSizeEntryCount: 0,
+            sampleSizeArray: nil,
+            sampleBufferOut: &sampleBuffer
+        )
+        guard createStatus == noErr, let sb = sampleBuffer else { return nil }
+
+        let setStatus = CMSampleBufferSetDataBufferFromAudioBufferList(
+            sb,
+            blockBufferAllocator: kCFAllocatorDefault,
+            blockBufferMemoryAllocator: kCFAllocatorDefault,
+            flags: 0,
+            bufferList: pcmBuffer.audioBufferList
+        )
+        guard setStatus == noErr else { return nil }
+        return sb
+    }
+
+    /// Returns a deep copy of the supplied `AVAudioPCMBuffer`. WebRTC owns
+    /// the source buffer's backing memory only for the duration of the
+    /// render-tap callback; ARC retains the wrapper across the queue hop
+    /// but not the underlying PCM samples. Copying here lets the recorder
+    /// queue read the data later without racing WebRTC's render-buffer
+    /// reuse.
+    private static func deepCopyPCMBuffer(_ source: AVAudioPCMBuffer) -> AVAudioPCMBuffer? {
+        guard let copy = AVAudioPCMBuffer(
+            pcmFormat: source.format,
+            frameCapacity: source.frameCapacity
+        ) else { return nil }
+        copy.frameLength = source.frameLength
+        let frameLength = Int(source.frameLength)
+        let channelCount = Int(source.format.channelCount)
+        if let src = source.int16ChannelData, let dst = copy.int16ChannelData {
+            for ch in 0..<channelCount {
+                memcpy(dst[ch], src[ch], frameLength * MemoryLayout<Int16>.size)
+            }
+        } else if let src = source.floatChannelData, let dst = copy.floatChannelData {
+            for ch in 0..<channelCount {
+                memcpy(dst[ch], src[ch], frameLength * MemoryLayout<Float>.size)
+            }
+        } else if let src = source.int32ChannelData, let dst = copy.int32ChannelData {
+            for ch in 0..<channelCount {
+                memcpy(dst[ch], src[ch], frameLength * MemoryLayout<Int32>.size)
+            }
+        }
+        return copy
+    }
+}