node-mac-recorder 2.24.9 → 2.24.11

package/src/ios_device_recorder.mm

@@ -8,10 +8,13 @@
 extern "C" bool startCameraRecording(NSString *outputPath, NSString *deviceId, NSError **error);
 extern "C" bool waitForCameraRecordingStart(double timeoutSeconds);
 extern "C" bool stopCameraRecording(void);
+extern "C" bool stopIOSDeviceRecording(void);
 extern "C" bool isCameraRecording(void);
 extern "C" bool startStandaloneAudioRecording(NSString *outputPath, NSString *preferredDeviceId, NSError **error);
 extern "C" bool stopStandaloneAudioRecording(void);
 extern "C" bool isStandaloneAudioRecording(void);
+extern "C" bool pauseIOSDeviceRecording(void);
+extern "C" bool resumeIOSDeviceRecording(void);
 
 @interface MRIOSDeviceRecorder : NSObject <AVCaptureFileOutputRecordingDelegate>
 @property(nonatomic, strong) AVCaptureSession *session;
@@ -21,6 +24,8 @@ extern "C" bool isStandaloneAudioRecording(void);
 @property(atomic) BOOL recording;
 @property(atomic) BOOL startCompleted;
 @property(atomic) BOOL finishCompleted;
+@property(atomic) BOOL startRequested;
+@property(atomic) BOOL stopRequested;
 @property(atomic, strong) NSError *finishError;
 @property(nonatomic) BOOL captureCamera;
 @property(nonatomic) BOOL captureMicrophone;
@@ -37,7 +42,7 @@ extern "C" bool isStandaloneAudioRecording(void);
     self.recording = YES;
     self.startCompleted = YES;
     self.primaryStartedAt = [NSDate date];
-    MRSyncMarkPrimaryStarted(CMClockGetTime(CMClockGetHostTimeClock()));
+    if (!self.stopRequested) MRSyncMarkPrimaryStarted(CMClockGetTime(CMClockGetHostTimeClock()));
     MRLog(@"📱 iPhone capture started: %@", fileURL.path);
 }
 
@@ -192,8 +197,8 @@ extern "C" bool startIOSDeviceRecording(NSString *outputPath,
                                          NSString *audioOutputPath,
                                          NSString *audioDeviceId,
                                          NSError **errorOut) {
-    @autoreleasepool {
-        if (g_iosRecorder && (g_iosRecorder.recording || g_iosRecorder.startCompleted)) {
+    @try {
+        if (g_iosRecorder) {
             if (errorOut) {
                 *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
                                                 code:1
@@ -253,12 +258,14 @@ extern "C" bool startIOSDeviceRecording(NSString *outputPath,
         recorder.audioOutputPath = audioOutputPath;
         recorder.primaryStartedAt = nil;
 
+        g_iosRecorder = recorder;
         [recorder.session beginConfiguration];
         if ([recorder.session canSetSessionPreset:AVCaptureSessionPresetHigh]) {
             recorder.session.sessionPreset = AVCaptureSessionPresetHigh;
         }
         if (![recorder.session canAddInput:input]) {
             [recorder.session commitConfiguration];
+            stopIOSDeviceRecording();
             if (errorOut) {
                 *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
                                                 code:3
@@ -269,6 +276,7 @@ extern "C" bool startIOSDeviceRecording(NSString *outputPath,
         [recorder.session addInput:input];
         if (![recorder.session canAddOutput:recorder.movieOutput]) {
             [recorder.session commitConfiguration];
+            stopIOSDeviceRecording();
             if (errorOut) {
                 *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
                                                 code:4
@@ -297,7 +305,7 @@ extern "C" bool startIOSDeviceRecording(NSString *outputPath,
                 !startCameraRecording(cameraOutputPath, cameraDeviceId, &cameraError)) {
                 MRSyncConfigurePrimaryStart(NO);
                 MRSyncConfigure(NO);
-                g_iosRecorder = nil;
+                stopIOSDeviceRecording();
                 if (errorOut) {
                     *errorOut = cameraError ?: [NSError errorWithDomain:@"MacRecorderIOS"
                                                                     code:7
@@ -314,7 +322,7 @@ extern "C" bool startIOSDeviceRecording(NSString *outputPath,
                 if (isCameraRecording()) stopCameraRecording();
                 MRSyncConfigurePrimaryStart(NO);
                 MRSyncConfigure(NO);
-                g_iosRecorder = nil;
+                stopIOSDeviceRecording();
                 if (errorOut) {
                     *errorOut = audioError ?: [NSError errorWithDomain:@"MacRecorderIOS"
                                                                   code:8
@@ -335,23 +343,24 @@ extern "C" bool startIOSDeviceRecording(NSString *outputPath,
                                                 code:5
                                             userInfo:@{NSLocalizedDescriptionKey: @"The iPhone capture session did not start"}];
             }
-            g_iosRecorder = nil;
+            stopIOSDeviceRecording();
             return false;
         }
 
+        recorder.startRequested = YES;
         [recorder.movieOutput startRecordingToOutputFileURL:[NSURL fileURLWithPath:outputPath]
                                           recordingDelegate:recorder];
         bool started = MRWaitForFlag(^bool{
-            return recorder.startCompleted;
+            return recorder.startCompleted || recorder.finishCompleted;
         }, 10.0);
-        if (!started) {
+        if (!started || !recorder.startCompleted || recorder.finishCompleted) {
             if (recorder.movieOutput.isRecording) [recorder.movieOutput stopRecording];
             [recorder.session stopRunning];
             if (isCameraRecording()) stopCameraRecording();
             if (isStandaloneAudioRecording()) stopStandaloneAudioRecording();
             MRSyncConfigurePrimaryStart(NO);
             MRSyncConfigure(NO);
-            g_iosRecorder = nil;
+            stopIOSDeviceRecording();
             if (errorOut) {
                 *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
                                                 code:6
@@ -368,7 +377,7 @@ extern "C" bool startIOSDeviceRecording(NSString *outputPath,
             if (isStandaloneAudioRecording()) stopStandaloneAudioRecording();
             MRSyncConfigurePrimaryStart(NO);
             MRSyncConfigure(NO);
-            g_iosRecorder = nil;
+            stopIOSDeviceRecording();
             if (errorOut) {
                 *errorOut = [NSError errorWithDomain:@"MacRecorderIOS"
                                                 code:9
@@ -377,33 +386,52 @@ extern "C" bool startIOSDeviceRecording(NSString *outputPath,
             return false;
         }
         return true;
+    } @catch (NSException *exception) {
+        // NSError must live in the caller's autorelease pool. The previous
+        // inner pool returned a dangling NSError on device/startup failures.
+        if (g_iosRecorder && !g_iosRecorder.startCompleted && !g_iosRecorder.movieOutput.isRecording) {
+            g_iosRecorder.startRequested = NO;
+        }
+        @try { [g_iosRecorder.session commitConfiguration]; } @catch (NSException *ignored) {}
+        stopIOSDeviceRecording();
+        if (errorOut) *errorOut = [NSError errorWithDomain:@"MacRecorderIOS" code:10
+            userInfo:@{NSLocalizedDescriptionKey: exception.reason ?: @"iPhone capture startup failed"}];
+        return false;
     }
 }
 
 extern "C" bool stopIOSDeviceRecording(void) {
     @autoreleasepool {
+      @try {
         MRIOSDeviceRecorder *recorder = g_iosRecorder;
         if (!recorder) return true;
 
+        recorder.stopRequested = YES;
         if (recorder.primaryStartedAt) {
-            NSTimeInterval duration = MAX(0.0, -[recorder.primaryStartedAt timeIntervalSinceNow]);
+            NSTimeInterval duration = MAX(0.0,
+                -[recorder.primaryStartedAt timeIntervalSinceNow] - MRSyncGetPausedDurationSeconds());
             MRSyncSetStopLimitSeconds(duration);
         }
 
         BOOL cameraStopped = YES;
         BOOL microphoneStopped = YES;
-        if (recorder.captureCamera && isCameraRecording()) {
+        if (recorder.captureCamera) {
             cameraStopped = stopCameraRecording();
         }
-        if (recorder.captureMicrophone && isStandaloneAudioRecording()) {
+        if (recorder.captureMicrophone) {
             microphoneStopped = stopStandaloneAudioRecording();
         }
 
         if (recorder.movieOutput.isRecording) {
             [recorder.movieOutput stopRecording];
-            MRWaitForFlag(^bool{
-                return recorder.finishCompleted;
-            }, 20.0);
+        }
+        // isRecording becomes false BEFORE the delegate finishes its file.
+        // Keep ownership until that callback, including after USB removal.
+        if (recorder.startRequested && !recorder.finishCompleted) {
+            if (!MRWaitForFlag(^bool{ return recorder.finishCompleted; }, 20.0)) {
+                NSLog(@"[Recorder] iPhone is still finalizing; retaining the session");
+                return false;
+            }
         }
         if (recorder.session.isRunning) [recorder.session stopRunning];
 
@@ -425,19 +453,68 @@ extern "C" bool stopIOSDeviceRecording(void) {
         // auxiliary source failed to finalize. The JS layer validates each
         // returned path independently before packaging it.
         return finished && fileExists;
+      } @catch (NSException *exception) {
+        NSLog(@"[Recorder] iPhone stop failed safely: %@", exception.reason);
+        return false;
+      }
     }
 }
 
+extern "C" bool isIOSDeviceRecordingPending(void) {
+    return g_iosRecorder != nil;
+}
+
+extern "C" bool isIOSDeviceRecordingStopping(void) {
+    return g_iosRecorder && g_iosRecorder.stopRequested;
+}
+
 extern "C" bool isIOSDeviceRecording(void) {
     return g_iosRecorder && (g_iosRecorder.recording || g_iosRecorder.movieOutput.isRecording);
 }
 
+extern "C" bool pauseIOSDeviceRecording(void) {
+    @autoreleasepool {
+        MRIOSDeviceRecorder *recorder = g_iosRecorder;
+        if (!recorder || !recorder.movieOutput.isRecording) return false;
+        if (recorder.movieOutput.isRecordingPaused) return true;
+        @try {
+            [recorder.movieOutput pauseRecording];
+            MRSyncPause();
+            return true;
+        } @catch (NSException *exception) {
+            MRLog(@"❌ iPhone pause failed: %@", exception.reason);
+            return false;
+        }
+    }
+}
+
+extern "C" bool resumeIOSDeviceRecording(void) {
+    @autoreleasepool {
+        MRIOSDeviceRecorder *recorder = g_iosRecorder;
+        if (!recorder || !recorder.movieOutput.isRecording) return false;
+        if (!recorder.movieOutput.isRecordingPaused) {
+            MRSyncResume();
+            return true;
+        }
+        @try {
+            [recorder.movieOutput resumeRecording];
+            MRSyncResume();
+            return true;
+        } @catch (NSException *exception) {
+            MRLog(@"❌ iPhone resume failed: %@", exception.reason);
+            return false;
+        }
+    }
+}
+
 extern "C" NSString *currentIOSDeviceRecordingPath(void) {
     return g_iosRecorder.outputPath;
 }
 
 Napi::Value GetIOSCaptureDevices(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
+    @autoreleasepool {
+      @try {
     NSArray<NSDictionary *> *devices = listIOSCaptureDevices();
     Napi::Array result = Napi::Array::New(env, devices.count);
     for (NSUInteger index = 0; index < devices.count; index++) {
@@ -456,10 +533,18 @@ Napi::Value GetIOSCaptureDevices(const Napi::CallbackInfo& info) {
         result.Set(index, item);
     }
     return result;
+      } @catch (NSException *exception) {
+        Napi::Error::New(env, exception.reason.UTF8String ?: "iPhone capture failed").ThrowAsJavaScriptException();
+        return env.Null();
+      }
+    }
+
 }
 
 Napi::Value StartIOSDeviceRecording(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
+    @autoreleasepool {
+      @try {
     if (info.Length() < 1 || !info[0].IsString()) {
         Napi::TypeError::New(env, "Output path is required").ThrowAsJavaScriptException();
         return env.Null();
@@ -505,21 +590,35 @@ Napi::Value StartIOSDeviceRecording(const Napi::CallbackInfo& info) {
                                            audioDeviceId,
                                            &error);
     if (!success && error) {
-        // startIOSDeviceRecording owns an inner autorelease pool. Do not bridge
-        // the NSError past that pool into V8; the JS wrapper turns false into a
-        // stable user-facing error and avoids a dangling Objective-C object.
-        MRLog(@"❌ iPhone capture could not start");
+        Napi::Error::New(env, error.localizedDescription.UTF8String ?: "iPhone capture could not start").ThrowAsJavaScriptException();
+        return env.Null();
     }
     return Napi::Boolean::New(env, success);
+      } @catch (NSException *exception) {
+        Napi::Error::New(env, exception.reason.UTF8String ?: "iPhone capture failed").ThrowAsJavaScriptException();
+        return env.Null();
+      }
+    }
+
 }
 
 Napi::Value StopIOSDeviceRecording(const Napi::CallbackInfo& info) {
     return Napi::Boolean::New(info.Env(), stopIOSDeviceRecording());
 }
 
+Napi::Value PauseIOSDeviceRecording(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), pauseIOSDeviceRecording());
+}
+
+Napi::Value ResumeIOSDeviceRecording(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), resumeIOSDeviceRecording());
+}
+
 Napi::Value GetIOSDeviceRecordingStatus(const Napi::CallbackInfo& info) {
     Napi::Object status = Napi::Object::New(info.Env());
     status.Set("isRecording", Napi::Boolean::New(info.Env(), isIOSDeviceRecording()));
+    status.Set("isPaused", Napi::Boolean::New(info.Env(),
+        g_iosRecorder && g_iosRecorder.movieOutput.isRecordingPaused));
     NSString *path = currentIOSDeviceRecordingPath();
     if (path.length > 0) status.Set("outputPath", Napi::String::New(info.Env(), [path UTF8String]));
     return status;
@@ -529,6 +628,8 @@ Napi::Object InitIOSDeviceRecorder(Napi::Env env, Napi::Object exports) {
     exports.Set("getIOSCaptureDevices", Napi::Function::New(env, GetIOSCaptureDevices));
     exports.Set("startIOSDeviceRecording", Napi::Function::New(env, StartIOSDeviceRecording));
     exports.Set("stopIOSDeviceRecording", Napi::Function::New(env, StopIOSDeviceRecording));
+    exports.Set("pauseIOSDeviceRecording", Napi::Function::New(env, PauseIOSDeviceRecording));
+    exports.Set("resumeIOSDeviceRecording", Napi::Function::New(env, ResumeIOSDeviceRecording));
     exports.Set("getIOSDeviceRecordingStatus", Napi::Function::New(env, GetIOSDeviceRecordingStatus));
     return exports;
 }

package/src/keyboard_tracker.mm

@@ -11,6 +11,7 @@
 #import <CoreGraphics/CoreGraphics.h>
 #import <Carbon/Carbon.h>
 #import "logging.h"
+#import "sync_timeline.h"
 
 // ---- Global durum (tek aktif oturum) --------------------------------------
 static CFMachPortRef g_kbEventTap = NULL;
@@ -110,6 +111,10 @@ static CGEventRef KeyboardEventCallback(CGEventTapProxy proxy,
         return event;
     }
 
+    if (MRSyncIsPaused()) {
+        return event;
+    }
+
     @autoreleasepool {
         CGEventFlags flags = CGEventGetFlags(event);
         BOOL hasCommand = (flags & kCGEventFlagMaskCommand) != 0;
@@ -146,7 +151,9 @@ static CGEventRef KeyboardEventCallback(CGEventTapProxy proxy,
         }
 
         double unixMs = NowUnixMs();
-        double relMs = g_kbStartUnixMs > 0 ? (unixMs - g_kbStartUnixMs) : 0.0;
+        double relMs = g_kbStartUnixMs > 0
+            ? (unixMs - g_kbStartUnixMs - (MRSyncGetPausedDurationSeconds() * 1000.0))
+            : 0.0;
         if (relMs < 0) relMs = 0;
 
         NSString *json = [NSString stringWithFormat:

package/src/mac_recorder.mm

@@ -25,12 +25,19 @@ extern "C" {
                                    NSString* qualityPreset);
     bool stopAVFoundationRecording();
     bool isAVFoundationRecording();
+    bool hasAVFoundationRecordingResources();
+    bool isAVFoundationRecordingStopping();
     NSString* getAVFoundationAudioPath();
 
     NSArray<NSDictionary *> *listCameraDevices();
     bool startCameraRecording(NSString *outputPath, NSString *deviceId, NSError **error);
     bool stopCameraRecording();
     bool isCameraRecording();
+    bool isCameraRecordingStopping();
+    bool hasCameraRecordingResources();
+    bool isIOSDeviceRecording();
+    bool isIOSDeviceRecordingPending();
+    bool isIOSDeviceRecordingStopping();
     NSString *currentCameraRecordingPath();
     bool waitForCameraRecordingStart(double timeoutSeconds);
     double currentCameraRecordingStartTime(void);
@@ -85,7 +92,8 @@ static double MRComputeElapsedRecordingSeconds(void) {
     if (!g_hasRecordingStartTime) {
         return -1.0;
     }
-    CFTimeInterval elapsed = CFAbsoluteTimeGetCurrent() - g_recordingStartTime;
+    CFTimeInterval elapsed = CFAbsoluteTimeGetCurrent() - g_recordingStartTime
+        - MRSyncGetPausedDurationSeconds();
     if (elapsed <= 0.0) {
         return -1.0;
     }
@@ -218,11 +226,11 @@ void cleanupRecording() {
     }
     
     // AVFoundation cleanup (supports both Node.js and Electron)
-    if (isAVFoundationRecording()) {
+    if (hasAVFoundationRecordingResources()) {
         stopAVFoundationRecording();
     }
 
-    if (isCameraRecording()) {
+    if (hasCameraRecordingResources()) {
         stopCameraRecording();
     }
     if (isStandaloneAudioRecording()) {
@@ -240,11 +248,20 @@ void cleanupRecording() {
 Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
-    if (info.Length() < 1) {
+    if (info.Length() < 1 || !info[0].IsString()) {
         Napi::TypeError::New(env, "Output path required").ThrowAsJavaScriptException();
         return env.Null();
     }
     
+    // Do not tear down an active/pending capture from another invocation.
+    if (isCameraRecordingStopping() || isIOSDeviceRecordingPending() || isAVFoundationRecording() || isAVFoundationRecordingStopping()) {
+        return Napi::Boolean::New(env, false);
+    }
+    if (@available(macOS 12.3, *)) {
+        if ([ScreenCaptureKitRecorder isRecording] || [ScreenCaptureKitRecorder isScheduling] ||
+            [ScreenCaptureKitRecorder isCleaningUp]) return Napi::Boolean::New(env, false);
+    }
+
     // IMPORTANT: Clean up any stale recording state before starting
     // This fixes the issue where macOS 14/13 users get "recording already in progress"
     MRLog(@"🧹 Cleaning up any previous recording state...");
@@ -863,11 +880,12 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
 
     // Try ScreenCaptureKit first
     if (@available(macOS 12.3, *)) {
-        if ([ScreenCaptureKitRecorder isRecording]) {
+        if ([ScreenCaptureKitRecorder isRecording] || [ScreenCaptureKitRecorder isScheduling] ||
+            [ScreenCaptureKitRecorder isCleaningUp]) {
             MRLog(@"🛑 Stopping ScreenCaptureKit recording");
 
             // CRITICAL FIX: Stop camera and audio FIRST (they are synchronous)
-            if (isCameraRecording()) {
+            if (hasCameraRecordingResources()) {
                 MRLog(@"🛑 Stopping camera recording...");
                 bool cameraStopped = stopCameraRecording();
                 if (cameraStopped) {
@@ -878,7 +896,7 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
             }
 
             // Stop standalone microphone if it was used (macOS 13/14)
-            if (g_usingStandaloneAudio && isStandaloneAudioRecording()) {
+            if (g_usingStandaloneAudio) {
                 MRLog(@"🛑 Stopping standalone microphone recording...");
                 bool micStopped = stopStandaloneAudioRecording();
                 if (micStopped) {
@@ -894,8 +912,8 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
             // It will set g_isRecording = NO in its completion handler
             [ScreenCaptureKitRecorder stopRecording];
 
-            // DO NOT set g_isRecording here - let ScreenCaptureKit completion handler do it
-            // Otherwise we have a race condition where JS thinks recording stopped but it's still running
+            // Native lifecycle status separately reports asynchronous cleanup.
+            g_isRecording = false;
             g_usingStandaloneAudio = false;
             return Napi::Boolean::New(env, true);
         }
@@ -907,11 +925,11 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     extern NSString* getAVFoundationAudioPath();
     
     @try {
-        if (isAVFoundationRecording()) {
+        if (hasAVFoundationRecordingResources()) {
             MRLog(@"🛑 Stopping AVFoundation recording");
 
-            BOOL cameraWasRecording = isCameraRecording();
-            BOOL audioWasRecording = g_usingStandaloneAudio && isStandaloneAudioRecording();
+            BOOL cameraWasRecording = hasCameraRecordingResources();
+            BOOL audioWasRecording = g_usingStandaloneAudio;
             __block BOOL cameraStopResult = YES;
             __block BOOL audioStopResult = YES;
 
@@ -983,14 +1001,43 @@ Napi::Value StopRecording(const Napi::CallbackInfo& info) {
     }
     
     MRLog(@"⚠️ No active recording found to stop");
-    if (isCameraRecording()) {
+    if (hasCameraRecordingResources()) {
         stopCameraRecording();
     }
+    stopStandaloneAudioRecording();
+    g_usingStandaloneAudio = false;
     g_isRecording = false;
     MRSyncSetStopLimitSeconds(-1.0);
     return Napi::Boolean::New(env, true);
 }
 
+Napi::Value PauseRecording(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    bool recording = g_isRecording || hasAVFoundationRecordingResources();
+    if (@available(macOS 12.3, *)) {
+        recording = recording || [ScreenCaptureKitRecorder isRecording];
+    }
+    if (!recording) {
+        Napi::Error::New(env, "No active recording to pause").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    MRSyncPause();
+    return Napi::Boolean::New(env, true);
+}
+
+Napi::Value ResumeRecording(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (!MRSyncIsPaused()) {
+        return Napi::Boolean::New(env, true);
+    }
+    MRSyncResume();
+    return Napi::Boolean::New(env, true);
+}
+
+Napi::Value GetRecordingPauseStatus(const Napi::CallbackInfo& info) {
+    return Napi::Boolean::New(info.Env(), MRSyncIsPaused());
+}
+
 
 
 // NAPI Function: Get Windows List
@@ -1375,6 +1422,26 @@ Napi::Value PrewarmScreenCapture(const Napi::CallbackInfo& info) {
     return Napi::Boolean::New(env, false);
 }
 
+// Actual native state, independent of the legacy first-ten-frames/UI flag.
+Napi::Value GetRecordingLifecycleStatus(const Napi::CallbackInfo& info) {
+    bool recording = hasAVFoundationRecordingResources() || isIOSDeviceRecordingPending();
+    bool starting = false;
+    bool stopping = isCameraRecordingStopping() || isIOSDeviceRecordingStopping() || isAVFoundationRecordingStopping();
+    if (@available(macOS 12.3, *)) {
+        recording = recording || [ScreenCaptureKitRecorder isRecording];
+        starting = [ScreenCaptureKitRecorder isScheduling];
+        stopping = stopping || [ScreenCaptureKitRecorder isCleaningUp];
+    }
+    Napi::Object result = Napi::Object::New(info.Env());
+    result.Set("isRecording", recording);
+    result.Set("isStarting", starting);
+    result.Set("isStopping", stopping);
+    result.Set("isPaused", MRSyncIsPaused());
+    result.Set("pausedDuration", MRSyncGetPausedDurationSeconds());
+    result.Set("hasAuxiliaryRecording", hasCameraRecordingResources() || isStandaloneAudioRecording());
+    return result;
+}
+
 Napi::Value GetRecordingStatus(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
 
@@ -1755,8 +1822,12 @@ Napi::Value CheckPermissions(const Napi::CallbackInfo& info) {
 
 // Initialize NAPI Module
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    exports.Set("getRecordingLifecycleStatus", Napi::Function::New(env, GetRecordingLifecycleStatus));
     exports.Set(Napi::String::New(env, "startRecording"), Napi::Function::New(env, StartRecording));
     exports.Set(Napi::String::New(env, "stopRecording"), Napi::Function::New(env, StopRecording));
+    exports.Set(Napi::String::New(env, "pauseRecording"), Napi::Function::New(env, PauseRecording));
+    exports.Set(Napi::String::New(env, "resumeRecording"), Napi::Function::New(env, ResumeRecording));
+    exports.Set(Napi::String::New(env, "getRecordingPauseStatus"), Napi::Function::New(env, GetRecordingPauseStatus));
 
     exports.Set(Napi::String::New(env, "getAudioDevices"), Napi::Function::New(env, GetAudioDevices));
     exports.Set(Napi::String::New(env, "getCameraDevices"), Napi::Function::New(env, GetCameraDevices));

package/src/recording_writer_safety.h

@@ -0,0 +1,66 @@
+#pragma once
+#import <AVFoundation/AVFoundation.h>
+
+// Call only after detaching and draining sample callbacks. A writer which has
+// not received its first frame cannot be marked/finished: AVFoundation raises
+// NSInternalInconsistencyException, which a JavaScript catch cannot intercept.
+static BOOL MRFinishAssetWriterSafely(AVAssetWriter *writer,
+                                    NSTimeInterval timeoutSeconds,
+                                    double stopLimitSeconds = -1.0) {
+    if (!writer) return YES;
+    dispatch_semaphore_t finished = nil;
+    @try {
+        AVAssetWriterStatus status = writer.status;
+        if (status == AVAssetWriterStatusCompleted) return YES;
+        if (status == AVAssetWriterStatusUnknown) {
+            [writer cancelWriting];
+            return NO;
+        }
+        if (status != AVAssetWriterStatusWriting) return NO;
+        if (stopLimitSeconds > 0 && isfinite(stopLimitSeconds)) {
+            [writer endSessionAtSourceTime:CMTimeMakeWithSeconds(stopLimitSeconds, 600)];
+        }
+        // Respect each recorder's bounded wait. A global 60-second floor blocks
+        // the native stop path synchronously and makes the app appear frozen.
+        // Timing out is safe because the writer is deliberately not cancelled.
+        NSTimeInterval waitSeconds =
+            isfinite(timeoutSeconds) && timeoutSeconds > 0 ? timeoutSeconds : 5.0;
+        finished = dispatch_semaphore_create(0);
+        // finishWriting marks all inputs as finished. The completion captures
+        // only its semaphore, never mutable globals from a subsequent session.
+        [writer finishWritingWithCompletionHandler:^{ dispatch_semaphore_signal(finished); }];
+        long timedOut = dispatch_semaphore_wait(finished,
+            dispatch_time(DISPATCH_TIME_NOW, (int64_t)(waitSeconds * NSEC_PER_SEC)));
+        if (timedOut) {
+            // NEVER cancel here. cancelWriting deletes the output file, so a
+            // finalization that is merely slow would destroy the user's
+            // recording — the editor then opens with no video. Waiting stops,
+            // the writer keeps finalizing in the background and still produces
+            // the file; only the "completed" confirmation is lost.
+            NSLog(@"[Recorder] Writer still finalizing after %.3fs; leaving it to finish", waitSeconds);
+            return NO;
+        }
+        return writer.status == AVAssetWriterStatusCompleted;
+    } @catch (NSException *exception) {
+        NSLog(@"[Recorder] Writer finalization failed safely: %@", exception.reason);
+        @try {
+            if (writer.status == AVAssetWriterStatusUnknown) {
+                // No first frame arrived, so there is no output file to lose.
+                [writer cancelWriting];
+            } else if (writer.status == AVAssetWriterStatusWriting) {
+                // Frames were written: cancelling would delete them. Trigger
+                // finalization best effort instead and do not wait on it.
+                [writer finishWritingWithCompletionHandler:^{}];
+            }
+        } @catch (NSException *cancelError) {
+            NSLog(@"[Recorder] Writer cancellation failed: %@", cancelError.reason);
+        }
+        return NO;
+    } @finally {
+#if !__has_feature(objc_arc)
+        // The copied completion block owns a separate reference, including
+        // when it runs after a timeout. Balance this call's create reference.
+        if (finished) dispatch_release(finished);
+#endif
+    }
+}

package/src/screen_capture_kit.h

@@ -13,9 +13,9 @@ API_AVAILABLE(macos(12.3))
 + (void)prewarmShareableContent;
 
 // MULTI-SESSION API: New session-based recording
-+ (NSString *)startRecordingWithConfiguration:(NSDictionary *)config
++ (BOOL)startRecordingWithConfiguration:(NSDictionary *)config
                                      delegate:(id)delegate
-                                        error:(NSError **)error;  // Returns sessionId
+                                        error:(NSError **)error;
 + (BOOL)stopRecording:(NSString *)sessionId;  // Stop specific session
 + (BOOL)isRecording:(NSString *)sessionId;    // Check specific session
 + (BOOL)isFullyInitialized:(NSString *)sessionId;  // Check if session's first frames received
@@ -26,6 +26,8 @@ API_AVAILABLE(macos(12.3))
 // LEGACY API: For backward compatibility (uses implicit default session)
 + (void)stopRecording;  // Stops all sessions
 + (BOOL)isRecording;    // Returns YES if ANY session is recording
++ (BOOL)isScheduling;
++ (BOOL)isCleaningUp;
 + (BOOL)isFullyInitialized;  // Check if default session initialized
 + (NSTimeInterval)getVideoStartTimestamp;  // Get default session timestamp