ScreenCapture + CMSampleBuffer logic issue

i'm trying to work on a simple screen recording app on macOS that always records the last 'x' seconds of your screen and saves it whenever you want, as a way to get comfortable with swift programming and apple APIs.

i was able to get it running for the past '30 seconds' and record and store it. however i realised that there was a core issue with my solution: i was defining the SCStreamConfiguration.queueDepth = 900 (to account for 30fps for 30 seconds) which goes completely against apple's instructions: https://developer.apple.com/documentation/screencapturekit/scstreamconfiguration/queuedepth?language=objc

now when i changed queueDepth back to 8, i am only able to record 8 frames and it saves only those first 8 frames. i am unsure what the flow of the apis should be while dealing with screenCaptureKit.

for context, here's my recording manager code that handles this logic (queueDepth = 900)

import Foundation
import ScreenCaptureKit
import AVFoundation

class RecordingManager: NSObject, ObservableObject, SCStreamDelegate {
    static let shared = RecordingManager()
    
    @Published var isRecording = false
    private var isStreamActive = false // Custom state flag
    
    private var stream: SCStream?
    private var streamOutputQueue = DispatchQueue(label: "com.clipback.StreamOutput", qos: .userInteractive)
    private var screenStreamOutput: ScreenStreamOutput? // Strong reference to output
    private var lastDisplayID: CGDirectDisplayID?
    private let displayCheckQueue = DispatchQueue(label: "com.clipback.DisplayCheck", qos: .background)
    
    // In-memory rolling buffer for last 30 seconds
    private var rollingFrameBuffer: [(CMSampleBuffer, CMTime)] = []
    private let rollingFrameBufferQueue = DispatchQueue(label: "com.clipback.RollingBuffer", qos: .userInteractive)
    private let rollingBufferDuration: TimeInterval = 30.0 // seconds
    
    // Track frame statistics
    private var frameCount: Int = 0
    private var lastReportTime: Date = Date()
    
    // Monitor for display availability
    private var displayCheckTimer: Timer?
    private var isWaitingForDisplay = false

    func startRecording() {
        print("[DEBUG] startRecording called.")
        guard !isRecording && !isWaitingForDisplay else {
            print("[DEBUG] Already recording or waiting, ignoring startRecording call")
            return
        }
        isWaitingForDisplay = true
        isStreamActive = true // Set active state
        checkForDisplay()
    }
    
    private func setupAndStartRecording(for display: SCDisplay, excluding appToExclude: SCRunningApplication?) {
        print("[DEBUG] setupAndStartRecording called for display: \(display.displayID)")
        let excludedApps = [appToExclude].compactMap { $0 }
        let filter = SCContentFilter(display: display, excludingApplications: excludedApps, exceptingWindows: [])
        let config = SCStreamConfiguration()
        config.width = display.width
        config.height = display.height
        config.minimumFrameInterval = CMTime(value: 1, timescale: 30) // 30 FPS
        config.queueDepth = 900
        config.showsCursor = true
        print("[DEBUG] SCStreamConfiguration created: width=\(config.width), height=\(config.height), FPS=\(config.minimumFrameInterval.timescale)")
        stream = SCStream(filter: filter, configuration: config, delegate: self)
        print("[DEBUG] SCStream initialized.")
        self.screenStreamOutput = ScreenStreamOutput { [weak self] sampleBuffer, outputType in
            guard let self = self else { return }
            guard outputType == .screen else { return }
            guard sampleBuffer.isValid else { return }
            guard let attachments = CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, createIfNecessary: false) as? [[SCStreamFrameInfo: Any]],
                  let statusRawValue = attachments.first?[.status] as? Int,
                  let status = SCFrameStatus(rawValue: statusRawValue),
                  status == .complete else {
                return
            }
            self.trackFrameRate()
            self.handleFrame(sampleBuffer)
        }
        do {
            try stream?.addStreamOutput(screenStreamOutput!, type: .screen, sampleHandlerQueue: streamOutputQueue)
            stream?.startCapture { [weak self] error in
                print("[DEBUG] SCStream.startCapture completion handler.")
                guard error == nil else {
                    print("[DEBUG] Failed to start capture: \(error!.localizedDescription)")
                    self?.handleStreamError(error!)
                    return
                }
                DispatchQueue.main.async {
                    self?.isRecording = true
                    self?.isStreamActive = true // Update state on successful start
                    print("[DEBUG] Recording started. isRecording = true.")
                }
            }
        } catch {
            print("[DEBUG] Error adding stream output: \(error.localizedDescription)")
            handleStreamError(error)
        }
    }

    private func handleFrame(_ sampleBuffer: CMSampleBuffer) {
        rollingFrameBufferQueue.async { [weak self] in
            guard let self = self else { return }
            let pts = CMSampleBufferGetPresentationTimeStamp(sampleBuffer)
            var retainedBuffer: CMSampleBuffer?
            CMSampleBufferCreateCopy(allocator: kCFAllocatorDefault, sampleBuffer: sampleBuffer, sampleBufferOut: &retainedBuffer)
            guard let buffer = retainedBuffer else {
                print("[DEBUG] Failed to copy sample buffer")
                return
            }
            self.rollingFrameBuffer.append((buffer, pts))
            if let lastPTS = self.rollingFrameBuffer.last?.1 {
                while let firstPTS = self.rollingFrameBuffer.first?.1,
                      CMTimeGetSeconds(CMTimeSubtract(lastPTS, firstPTS)) > self.rollingBufferDuration {
                    self.rollingFrameBuffer.removeFirst()
                }
            }
        }
    }
    
    func stream(_ stream: SCStream, didStopWithError error: Error) {
        print("[DEBUG] Stream stopped with error: \(error.localizedDescription)")
        displayCheckQueue.async { [weak self] in // Move to displayCheckQueue for synchronization
            self?.handleStreamError(error)
        }
    }
    
    

what could be the reason for this and what would be the possible fix logically? i dont understand why it's dependant on queueDepth, and if it is, how can I empty and append new recorded frames to it so that it continues working? any help or resource is greatly appreciated!