@appium/coresim 1.7.0 → 1.9.0

package/src/coresim.mm

@@ -31,6 +31,8 @@
 #include "native/objc_runtime.h"
 #include "native/sim_device.h"
 #include "native/sim_device_set.h"
+#include "native/sim_jpeg_stream.h"
+#include "native/sim_orientation.h"
 #include "native/sim_pasteboard.h"
 #include "native/sim_process.h"
 #include "native/sim_screenshot.h"
@@ -99,7 +101,7 @@ NSError* MakeDescriptorError(NSString* which, int savedErrno) {
 }
 
 NSError* MakeSpawnPathError(NSString* message) {
-  return [NSError errorWithDomain:@"com.appium.coresim.spawn" code:1 userInfo:@{NSLocalizedDescriptionKey : message}];
+  return [NSError errorWithDomain:@"io.appium.coresim.spawn" code:1 userInfo:@{NSLocalizedDescriptionKey : message}];
 }
 
 // Standard bin dirs to search, in order, when `path` is a bare command name (no `/`) — mirrors
@@ -258,9 +260,11 @@ struct AddonInstanceData {
   Napi::FunctionReference avStreamConstructor;
   Napi::FunctionReference avRecordingConstructor;
   Napi::FunctionReference privateRecordingConstructor;
+  Napi::FunctionReference jpegStreamConstructor;
   ActiveSessionRegistry<coresim::VideoStreamSession> activeVideoStreams;
   ActiveSessionRegistry<coresim::AVStreamSession> activeAVStreams;
   ActiveSessionRegistry<coresim::AVRecordingSession> activeAVRecordings;
+  ActiveSessionRegistry<coresim::JpegStreamSession> activeJpegStreams;
 };
 
 }  // namespace
@@ -326,6 +330,58 @@ Napi::Object NativeVideoStream::NewInstance(Napi::Env env, std::shared_ptr<cores
       env, boxed, [](Napi::Env /*env*/, std::shared_ptr<coresim::VideoStreamSession>* data) { delete data; })});
 }
 
+// Wraps a live coresim::JpegStreamSession — same shape as NativeVideoStream minus
+// `requestKeyFrame()` (meaningless here: every JPEG frame is already independently decodable, see
+// sim_jpeg_stream.h). Frames/errors are delivered live via the callbacks passed directly to
+// startJpegStream, not through this object — it only exposes `stop()`.
+class NativeJpegStream : public Napi::ObjectWrap<NativeJpegStream> {
+ public:
+  static void Init(Napi::Env env);
+  static Napi::Object NewInstance(Napi::Env env, std::shared_ptr<coresim::JpegStreamSession> session);
+  explicit NativeJpegStream(const Napi::CallbackInfo& info);
+
+ private:
+  std::shared_ptr<coresim::JpegStreamSession> session_;
+
+  Napi::Value Stop(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    auto session = session_;
+    return RunAsyncVoid(env, [session]() { session->Stop(); });
+  }
+
+  // See NativeVideoStream::Finalize for why this hands off to a background queue.
+  void Finalize(Napi::Env env) override {
+    auto session = std::move(session_);
+    if (session) {
+      env.GetInstanceData<AddonInstanceData>()->activeJpegStreams.Deregister(session);
+      dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        session->Stop();
+      });
+    }
+  }
+};
+
+NativeJpegStream::NativeJpegStream(const Napi::CallbackInfo& info) : Napi::ObjectWrap<NativeJpegStream>(info) {
+  auto* boxed = info[0].As<Napi::External<std::shared_ptr<coresim::JpegStreamSession>>>().Data();
+  session_ = *boxed;
+  info.Env().GetInstanceData<AddonInstanceData>()->activeJpegStreams.Register(session_);
+}
+
+void NativeJpegStream::Init(Napi::Env env) {
+  Napi::Function ctor = DefineClass(env, "NativeJpegStream",
+                                    {
+                                        InstanceMethod<&NativeJpegStream::Stop>("stop"),
+                                    });
+  env.GetInstanceData<AddonInstanceData>()->jpegStreamConstructor = Napi::Persistent(ctor);
+}
+
+Napi::Object NativeJpegStream::NewInstance(Napi::Env env, std::shared_ptr<coresim::JpegStreamSession> session) {
+  auto* boxed = new std::shared_ptr<coresim::JpegStreamSession>(std::move(session));
+  Napi::Function ctor = env.GetInstanceData<AddonInstanceData>()->jpegStreamConstructor.Value();
+  return ctor.New({Napi::External<std::shared_ptr<coresim::JpegStreamSession>>::New(
+      env, boxed, [](Napi::Env /*env*/, std::shared_ptr<coresim::JpegStreamSession>* data) { delete data; })});
+}
+
 // Wraps a live coresim::AVStreamSession — the combined-AV counterpart to NativeVideoStream above,
 // same shape (only `stop()`/`requestKeyFrame()`; access units/errors are delivered live via the
 // callbacks passed directly to startAVStream).
@@ -473,7 +529,7 @@ class NativePrivateRecordingHandle : public Napi::ObjectWrap<NativePrivateRecord
     id device = device_;
     return RunAsyncVoid(env, [device]() {
       dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-      dispatch_queue_t queue = dispatch_queue_create("com.appium.coresim.stopRecordVideo", DISPATCH_QUEUE_SERIAL);
+      dispatch_queue_t queue = dispatch_queue_create("io.appium.coresim.stopRecordVideo", DISPATCH_QUEUE_SERIAL);
       __block NSError* capturedError = nil;
       NSError* resolveError = nil;
       BOOL ok = coresim::StopVideoRecording(
@@ -573,7 +629,7 @@ class NativeDevice : public Napi::ObjectWrap<NativeDevice> {
     NSDictionary* options = OptionsArg(info, 0);
     return RunAsyncVoid(env, [device, options]() {
       dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-      dispatch_queue_t queue = dispatch_queue_create("com.appium.coresim.boot", DISPATCH_QUEUE_SERIAL);
+      dispatch_queue_t queue = dispatch_queue_create("io.appium.coresim.boot", DISPATCH_QUEUE_SERIAL);
       __block NSError* capturedError = nil;
       BootAsync(device, options, queue, ^(NSError* error) {
         capturedError = error;
@@ -743,6 +799,15 @@ class NativeDevice : public Napi::ObjectWrap<NativeDevice> {
     });
   }
 
+  Napi::Value SetOrientation(const Napi::CallbackInfo& info) {
+    id device = device_;
+    int32_t orientation = info[0].As<Napi::Number>().Int32Value();
+    return RunAsyncVoid(info.Env(), [device, orientation]() {
+      NSError* error = nil;
+      ThrowIfFailed(coresim::SetDeviceOrientation(device, orientation, &error), error);
+    });
+  }
+
   Napi::Value SendPushNotification(const Napi::CallbackInfo& info) {
     id device = device_;
     NSString* bundleId = @(info[0].As<Napi::String>().Utf8Value().c_str());
@@ -1043,13 +1108,30 @@ class NativeDevice : public Napi::ObjectWrap<NativeDevice> {
         [](Napi::Env env, NSArray* result) -> Napi::Value { return NSObjectToJsValue(env, result); });
   }
 
+  Napi::Value GetOrientation(const Napi::CallbackInfo& info) {
+    id device = device_;
+    return RunAsync<int32_t>(
+        info.Env(),
+        [device]() -> int32_t {
+          dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+          __block int32_t result = 1;
+          coresim::ReadGuestOrientation(device, ^(int32_t orientation) {
+            result = orientation;
+            dispatch_semaphore_signal(sema);
+          });
+          dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
+          return result;
+        },
+        [](Napi::Env env, int32_t result) -> Napi::Value { return Napi::Number::New(env, result); });
+  }
+
   // Shared by StartVideoRecording (audio path)/StartVideoStream — `argIndex` is where the options
   // object (if any) sits in `info`.
   static coresim::VideoEncoderOptions ParseVideoEncoderOptions(const Napi::CallbackInfo& info, size_t argIndex) {
     NSString* displayId = nil;
     coresim::VideoStreamCodec codec = coresim::VideoStreamCodec::kH264;
-    double fps = 15.0;
-    int bitrate = 2000000;
+    double fps = 60.0;
+    int bitrate = 4000000;
     if (info.Length() > argIndex && info[argIndex].IsObject()) {
       Napi::Object options = info[argIndex].As<Napi::Object>();
       if (options.Has("displayId") && options.Get("displayId").IsString()) {
@@ -1069,6 +1151,37 @@ class NativeDevice : public Napi::ObjectWrap<NativeDevice> {
     return coresim::VideoEncoderOptions{codec, displayId, fps, bitrate};
   }
 
+  // `quality`/`displayId`/`fps` are this addon's own options, not a CoreSimulator options
+  // dictionary — the TS layer (commands/jpeg-stream.ts) already constrains them, so anything else
+  // (including absent) is just defaulted here rather than validated again (mirrors Screenshot's
+  // identical comment above).
+  static coresim::JpegStreamOptions ParseJpegStreamOptions(const Napi::CallbackInfo& info, size_t argIndex) {
+    NSString* displayId = nil;
+    double fps = 60.0;
+    // Defaults to 80, not ImageIO's own (near-lossless, much larger) default — see
+    // JpegStreamOptions's own comment (sim_jpeg_stream.h) for why.
+    NSNumber* jpegQualityPercent = @80;
+    double scale = 1.0;
+    if (info.Length() > argIndex && info[argIndex].IsObject()) {
+      Napi::Object options = info[argIndex].As<Napi::Object>();
+      if (options.Has("displayId") && options.Get("displayId").IsString()) {
+        displayId = @(options.Get("displayId").As<Napi::String>().Utf8Value().c_str());
+      }
+      if (options.Has("fps") && options.Get("fps").IsNumber()) {
+        fps = options.Get("fps").As<Napi::Number>().DoubleValue();
+      }
+      if (options.Has("quality") && options.Get("quality").IsNumber()) {
+        jpegQualityPercent = @(options.Get("quality").As<Napi::Number>().DoubleValue());
+      }
+      // JS-facing `scale` is a 1-100 percent (commands/jpeg-stream.ts already validates the
+      // range), converted here to the 0.0-1.0 fraction JpegStreamSession actually applies.
+      if (options.Has("scale") && options.Get("scale").IsNumber()) {
+        scale = options.Get("scale").As<Napi::Number>().DoubleValue() / 100.0;
+      }
+    }
+    return coresim::JpegStreamOptions{displayId, fps, jpegQualityPercent, scale};
+  }
+
   static bool OptionsWantAudio(const Napi::CallbackInfo& info, size_t argIndex) {
     return info.Length() > argIndex && info[argIndex].IsObject() && info[argIndex].As<Napi::Object>().Has("audio") &&
            info[argIndex].As<Napi::Object>().Get("audio").IsBoolean() &&
@@ -1132,7 +1245,7 @@ class NativeDevice : public Napi::ObjectWrap<NativeDevice> {
         env,
         [device, displayId, mask, assetWriterOutputSettings, outputFile]() -> id {
           dispatch_semaphore_t sema = dispatch_semaphore_create(0);
-          dispatch_queue_t queue = dispatch_queue_create("com.appium.coresim.recordVideo", DISPATCH_QUEUE_SERIAL);
+          dispatch_queue_t queue = dispatch_queue_create("io.appium.coresim.recordVideo", DISPATCH_QUEUE_SERIAL);
           __block NSError* capturedError = nil;
           NSError* resolveError = nil;
           BOOL ok = coresim::StartVideoRecording(
@@ -1380,6 +1493,81 @@ class NativeDevice : public Napi::ObjectWrap<NativeDevice> {
         });
   }
 
+  // Real-time JPEG frame stream via ImageIO (see sim_jpeg_stream.mm) — a client-side MJPEG stream
+  // is just this frame sequence multipart-boundary-framed over HTTP, which coresim itself has no
+  // opinion about. Same TSFN/registry/teardown shape as StartVideoStream's audio-less branch,
+  // minus keyframes/resync (every JPEG frame is independently decodable).
+  Napi::Value StartJpegStream(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    id device = device_;
+    coresim::JpegStreamOptions options = ParseJpegStreamOptions(info, 0);
+    Napi::Function onFrame = info[1].As<Napi::Function>();
+    Napi::Function onError = info[2].As<Napi::Function>();
+
+    // See StartVideoStream's identical comment on accessUnitTsfn — bounded so a slow-draining
+    // consumer throttles the encoder via BlockingCall instead of letting queued frames grow
+    // unbounded.
+    static constexpr size_t kFrameQueueSize = 60;
+    Napi::ThreadSafeFunction frameTsfn =
+        Napi::ThreadSafeFunction::New(env, onFrame, "coresim jpeg stream frame", kFrameQueueSize, 1);
+    Napi::ThreadSafeFunction errorTsfn = Napi::ThreadSafeFunction::New(env, onError, "coresim jpeg stream error", 0, 1);
+    auto tsfnGuard = std::make_shared<TsfnReleaseGuard>();
+
+    return RunAsync<std::shared_ptr<coresim::JpegStreamSession>>(
+        env,
+        [device, options, frameTsfn, errorTsfn, tsfnGuard]() mutable -> std::shared_ptr<coresim::JpegStreamSession> {
+          auto session = std::make_shared<coresim::JpegStreamSession>(
+              device, options,
+              [frameTsfn](coresim::JpegFrame frame) mutable {
+                frameTsfn.BlockingCall([frame = std::move(frame)](Napi::Env env, Napi::Function jsCallback) mutable {
+                  // See StartVideoStream's identical comment on why this is wrapped in try/catch.
+                  try {
+                    Napi::Object obj = Napi::Object::New(env);
+                    obj.Set("data", Napi::Buffer<uint8_t>::Copy(env, frame.data.data(), frame.data.size()));
+                    obj.Set("sequence", Napi::Number::New(env, static_cast<double>(frame.sequence)));
+                    obj.Set("timestampMicros", Napi::Number::New(env, static_cast<double>(frame.timestampMicros)));
+                    jsCallback.Call({obj});
+                  } catch (...) {
+                  }
+                });
+              },
+              [errorTsfn](NSError* error) mutable {
+                NSErrorException exception(error);
+                errorTsfn.BlockingCall([exception](Napi::Env env, Napi::Function jsCallback) {
+                  try {
+                    jsCallback.Call({NSErrorExceptionToJsError(env, exception).Value()});
+                  } catch (...) {
+                  }
+                });
+              },
+              [frameTsfn, errorTsfn, tsfnGuard]() mutable {
+                ReleaseTsfnOnce(tsfnGuard, [&]() mutable {
+                  frameTsfn.Release();
+                  errorTsfn.Release();
+                });
+              },
+              [frameTsfn, errorTsfn, tsfnGuard]() mutable {
+                ReleaseTsfnOnce(tsfnGuard, [&]() mutable {
+                  frameTsfn.Abort();
+                  errorTsfn.Abort();
+                });
+              });
+          try {
+            session->Start();
+          } catch (...) {
+            ReleaseTsfnOnce(tsfnGuard, [&]() mutable {
+              frameTsfn.Release();
+              errorTsfn.Release();
+            });
+            throw;
+          }
+          return session;
+        },
+        [](Napi::Env env, std::shared_ptr<coresim::JpegStreamSession> session) -> Napi::Value {
+          return NativeJpegStream::NewInstance(env, session);
+        });
+  }
+
   // Option dictionary keys for `spawnWithPath:options:...` aren't part of the ObjC runtime
   // metadata this addon resolves selectors from (they're string literals inside CoreSimulator's
   // own implementation) — confirmed by resolving each `SimDeviceSpawnKey*` symbol at runtime via
@@ -1541,6 +1729,7 @@ void NativeDevice::Init(Napi::Env env) {
                       InstanceMethod<&NativeDevice::OpenUrl>("openUrl"),
                       InstanceMethod<&NativeDevice::SetLocation>("setLocation"),
                       InstanceMethod<&NativeDevice::ClearLocation>("clearLocation"),
+                      InstanceMethod<&NativeDevice::SetOrientation>("setOrientation"),
                       InstanceMethod<&NativeDevice::SendPushNotification>("sendPushNotification"),
                       InstanceMethod<&NativeDevice::AddCertificate>("addCertificate"),
                       InstanceMethod<&NativeDevice::ResetKeychain>("resetKeychain"),
@@ -1565,8 +1754,10 @@ void NativeDevice::Init(Napi::Env env) {
                       InstanceMethod<&NativeDevice::GetWebInspectorSocket>("getWebInspectorSocket"),
                       InstanceMethod<&NativeDevice::Screenshot>("screenshot"),
                       InstanceMethod<&NativeDevice::GetDisplays>("getDisplays"),
+                      InstanceMethod<&NativeDevice::GetOrientation>("getOrientation"),
                       InstanceMethod<&NativeDevice::StartVideoRecording>("startVideoRecording"),
                       InstanceMethod<&NativeDevice::StartVideoStream>("startVideoStream"),
+                      InstanceMethod<&NativeDevice::StartJpegStream>("startJpegStream"),
                       InstanceMethod<&NativeDevice::Spawn>("spawn"),
                   });
   env.GetInstanceData<AddonInstanceData>()->deviceConstructor = Napi::Persistent(ctor);
@@ -1818,6 +2009,7 @@ void CleanupActiveSessions(AddonInstanceData* instanceData) {
   };
   instanceData->activeVideoStreams.StopAll(stopStream);
   instanceData->activeAVStreams.StopAll(stopStream);
+  instanceData->activeJpegStreams.StopAll(stopStream);
   instanceData->activeAVRecordings.StopAll([](auto& session) {
     dispatch_semaphore_t sema = dispatch_semaphore_create(0);
     session->Stop([sema](NSError*) { dispatch_semaphore_signal(sema); });
@@ -1850,6 +2042,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   NativeAVStream::Init(env);
   NativeAVRecording::Init(env);
   NativePrivateRecordingHandle::Init(env);
+  NativeJpegStream::Init(env);
   exports.Set("sharedServiceContext", Napi::Function::New(env, SharedServiceContextBinding));
   exports.Set("frameworkVersion", Napi::Function::New(env, FrameworkVersionBinding));
   exports.Set("flushActiveSessions", Napi::Function::New(env, FlushActiveSessionsBinding));

package/src/index.ts

@@ -2,14 +2,18 @@ export {NativeSimError, NativeSimUnavailableError, NativeSimDispatchError, Nativ
 export {NativeSimctl} from './native-simctl.js';
 export {SpawnedProcess} from './commands/spawn.js';
 export {VideoStream} from './commands/video-stream.js';
+export {JpegStream} from './commands/jpeg-stream.js';
 export type {AppContainerType} from './commands/app.js';
 export type {BiometricName} from './commands/biometric.js';
 export {
+  DeviceOrientation,
   SimBootStatus,
   SimDeviceState,
   type ApnsAlert,
   type ApnsPayload,
   type ApnsSound,
+  type JpegFrame,
+  type JpegStreamOptions,
   type PushNotificationPayload,
   type ScreenshotOptions,
   type SimBootInfo,

package/src/native/audio_encoder.mm

@@ -12,7 +12,7 @@ namespace coresim {
 
 namespace {
 
-NSString* const kAudioEncoderErrorDomain = @"com.appium.coresim.AudioEncoder";
+NSString* const kAudioEncoderErrorDomain = @"io.appium.coresim.AudioEncoder";
 
 NSError* MakeError(NSInteger code, NSString* message) {
   return [NSError errorWithDomain:kAudioEncoderErrorDomain code:code userInfo:@{NSLocalizedDescriptionKey : message}];

package/src/native/av_recording.h

@@ -46,7 +46,7 @@ class AVRecordingSession {
 
  private:
   class Impl;
-  std::unique_ptr<Impl> impl_;
+  std::shared_ptr<Impl> impl_;
 };
 
 }  // namespace coresim

package/src/native/av_recording.mm

@@ -13,7 +13,7 @@ namespace coresim {
 
 namespace {
 
-NSString* const kAVRecordingErrorDomain = @"com.appium.coresim.AVRecording";
+NSString* const kAVRecordingErrorDomain = @"io.appium.coresim.AVRecording";
 
 NSError* MakeError(NSInteger code, NSString* message) {
   return [NSError errorWithDomain:kAVRecordingErrorDomain code:code userInfo:@{NSLocalizedDescriptionKey : message}];
@@ -23,14 +23,17 @@ constexpr size_t kMaxPendingAudioSamples = 500;  // a few seconds of AAC packets
 
 }  // namespace
 
-class AVRecordingSession::Impl {
+class AVRecordingSession::Impl : public std::enable_shared_from_this<Impl> {
  public:
   Impl(id device, NSString* udid, VideoEncoderOptions videoOptions, NSString* outputFile, bool captureAudio)
       : device_(device),
         udid_(udid),
         videoOptions_(videoOptions),
         outputFile_(outputFile),
-        captureAudio_(captureAudio) {}
+        captureAudio_(captureAudio) {
+    // Forced on regardless of what the caller passed — see VideoEncoderOptions::fixedFrameSize.
+    videoOptions_.fixedFrameSize = true;
+  }
 
   ~Impl() { TearDownIfNeeded(); }
 
@@ -49,18 +52,31 @@ class AVRecordingSession::Impl {
       throw NSErrorException(writerError ?: MakeError(1, @"Failed to create an AVAssetWriter"));
     }
 
+    // A weak_ptr (not `this`, and not a strong shared_ptr) captured by every callback handed to a
+    // collaborator below: `this` would dangle if a callback fires mid-teardown (see Fail()'s own
+    // comment), but a strong self-capture stored in a member `this` itself owns (videoEncoder_,
+    // audioTap_) would leak instead, keeping this Impl alive forever via a reference cycle. Locking
+    // it at call time gets safety without either problem.
+    std::weak_ptr<Impl> weakSelf = weak_from_this();
     try {
       if (captureAudio_) {
         audioTap_ = std::make_unique<AudioTapSession>(
-            udid_, [this](const AudioBufferList* data, const AudioTimeStamp* time) { HandleAudioPCM(data, time); },
-            [this](NSError* error) {
+            udid_,
+            [weakSelf](const AudioBufferList* data, const AudioTimeStamp* time) {
+              if (auto self = weakSelf.lock()) {
+                self->HandleAudioPCM(data, time);
+              }
+            },
+            [weakSelf](NSError* error) {
               // A failed process-list refresh (kAudioTapNonFatalProcessListRefreshErrorCode) isn't
               // fatal — the tap keeps running. Everything else is.
               if ([error.domain isEqualToString:kAudioTapErrorDomain] &&
                   error.code == kAudioTapNonFatalProcessListRefreshErrorCode) {
                 return;
               }
-              Fail(error, /*fromVideo=*/false);
+              if (auto self = weakSelf.lock()) {
+                self->Fail(error, /*fromVideo=*/false);
+              }
             },
             [] {});
         audioTap_->Start();
@@ -68,7 +84,12 @@ class AVRecordingSession::Impl {
         // Start() can invoke HandleAudioPCM before returning, so audioEncoder_ is written under
         // mutex_ (same lock HandleAudioPCM reads it under) to avoid a torn/racy pointer read.
         auto encoder = std::make_unique<AudioEncoder>(
-            audioTap_->Format(), [this](CMSampleBufferRef sampleBuffer) { HandleAudioSample(sampleBuffer); },
+            audioTap_->Format(),
+            [weakSelf](CMSampleBufferRef sampleBuffer) {
+              if (auto self = weakSelf.lock()) {
+                self->HandleAudioSample(sampleBuffer);
+              }
+            },
             &clockOrigin_);
         {
           std::lock_guard<std::mutex> lock(mutex_);
@@ -83,9 +104,19 @@ class AVRecordingSession::Impl {
         [writer_ addInput:audioInput_];
       }
 
-      videoEncoder_ = std::make_unique<VideoFrameEncoder>(
-          device_, videoOptions_, [this](CMSampleBufferRef sampleBuffer) { HandleVideoSample(sampleBuffer); },
-          [this](NSError* error) { Fail(error, /*fromVideo=*/true); }, [] {}, &clockOrigin_);
+      videoEncoder_ = std::make_shared<VideoFrameEncoder>(
+          device_, videoOptions_,
+          [weakSelf](CMSampleBufferRef sampleBuffer) {
+            if (auto self = weakSelf.lock()) {
+              self->HandleVideoSample(sampleBuffer);
+            }
+          },
+          [weakSelf](NSError* error) {
+            if (auto self = weakSelf.lock()) {
+              self->Fail(error, /*fromVideo=*/true);
+            }
+          },
+          [] {}, &clockOrigin_);
       videoEncoder_->Start();
     } catch (...) {
       TearDownIfNeeded();
@@ -185,7 +216,7 @@ class AVRecordingSession::Impl {
           [writer_ startSessionAtSourceTime:CMSampleBufferGetPresentationTimeStamp(sampleBuffer)];
           writerStarted_ = true;
           justStarted = true;
-          AppendVideoLocked(sampleBuffer);
+          writingError = AppendVideoLocked(sampleBuffer);
           for (CMSampleBufferRef pending : pendingAudio_) {
             AppendAudioLocked(pending);
             CFRelease(pending);
@@ -195,7 +226,7 @@ class AVRecordingSession::Impl {
           writingError = writer_.error ?: MakeError(3, @"AVAssetWriter startWriting failed");
         }
       } else {
-        AppendVideoLocked(sampleBuffer);
+        writingError = AppendVideoLocked(sampleBuffer);
       }
     }
     if (writingError != nil) {
@@ -245,11 +276,16 @@ class AVRecordingSession::Impl {
     }
   }
 
-  // Caller holds mutex_.
-  void AppendVideoLocked(CMSampleBufferRef sampleBuffer) {
-    if (videoInput_.isReadyForMoreMediaData) {
-      [videoInput_ appendSampleBuffer:sampleBuffer];
+  // Caller holds mutex_. Returns a descriptive error if the append failed (e.g. a mid-recording
+  // rotation resizes the encoder but a track's dimensions are fixed for the writer's life), nil otherwise.
+  NSError* AppendVideoLocked(CMSampleBufferRef sampleBuffer) {
+    if (!videoInput_.isReadyForMoreMediaData) {
+      return nil;  // transient backpressure, not a failure
+    }
+    if ([videoInput_ appendSampleBuffer:sampleBuffer]) {
+      return nil;
     }
+    return writer_.error ?: MakeError(4, @"Failed to append a video sample to the recording");
   }
 
   // Caller holds mutex_.
@@ -314,19 +350,23 @@ class AVRecordingSession::Impl {
     return pending;
   }
 
-  // Called from either encoder's onError, or from HandleVideoSample on a writer-level failure —
-  // not holding mutex_ (could deadlock against that same encoder's own queue). Stops only the
-  // OTHER (still-running) encoder — the one whose callback we're inside is already tearing itself
-  // down on its own error path, and calling its own blocking Stop() here would deadlock.
+  // Called from either encoder's onError, or from HandleVideoSample on a writer-level append
+  // failure — not holding mutex_ (could deadlock against that encoder's own queue).
+  //
+  // fromVideo=true also needs videoEncoder_ itself stopped: a writer append failure leaves
+  // VideoToolbox otherwise healthy and encoding forever. But videoEncoder_->Stop() dispatch_syncs
+  // onto its own queue, and HandleVideoSample (VideoToolbox's own output callback) isn't
+  // guaranteed to be off that queue — so it's dispatched async instead, via a shared_ptr `encoder`
+  // copy that can outlive this Impl. Stop() can still flush a pending frame into onSample_/onError_
+  // synchronously; those hold only a weak_ptr (see Start()), but `self` below keeps it resolvable
+  // for the duration of this block. onEnd_ waits until that's done, not fired eagerly here.
   void Fail(NSError* error, bool fromVideo) {
     if (fromVideo) {
       if (audioTap_) {
         audioTap_->Stop();
       }
-    } else {
-      if (videoEncoder_) {
-        videoEncoder_->Stop();
-      }
+    } else if (videoEncoder_) {
+      videoEncoder_->Stop();
     }
     std::vector<std::function<void(NSError*)>> pending;
     {
@@ -338,7 +378,16 @@ class AVRecordingSession::Impl {
         callback(error);
       }
     }
-    FireEndOnce();
+    if (fromVideo && videoEncoder_) {
+      std::shared_ptr<VideoFrameEncoder> encoder = videoEncoder_;
+      std::shared_ptr<Impl> self = shared_from_this();
+      dispatch_async(dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0), ^{
+        encoder->Stop();
+        self->FireEndOnce();
+      });
+    } else {
+      FireEndOnce();
+    }
   }
 
   // The single point where a real (first-ever) Stop() attempt's outcome becomes known — records
@@ -389,7 +438,7 @@ class AVRecordingSession::Impl {
   std::function<void()> onEnd_;
 
   double clockOrigin_ = 0;
-  std::unique_ptr<VideoFrameEncoder> videoEncoder_;
+  std::shared_ptr<VideoFrameEncoder> videoEncoder_;
   std::unique_ptr<AudioTapSession> audioTap_;
   std::unique_ptr<AudioEncoder> audioEncoder_;
 
@@ -410,7 +459,7 @@ class AVRecordingSession::Impl {
 
 AVRecordingSession::AVRecordingSession(id device, NSString* udid, VideoEncoderOptions videoOptions,
                                        NSString* outputFile, bool captureAudio)
-    : impl_(std::make_unique<Impl>(device, udid, videoOptions, outputFile, captureAudio)) {}
+    : impl_(std::make_shared<Impl>(device, udid, videoOptions, outputFile, captureAudio)) {}
 
 AVRecordingSession::~AVRecordingSession() = default;
 

package/src/native/sim_audio_tap.mm

@@ -11,7 +11,7 @@
 
 namespace coresim {
 
-NSString* const kAudioTapErrorDomain = @"com.appium.coresim.AudioTap";
+NSString* const kAudioTapErrorDomain = @"io.appium.coresim.AudioTap";
 
 namespace {
 
@@ -66,7 +66,7 @@ class AudioTapSession::Impl {
   Impl(NSString* udid, std::function<void(const AudioBufferList*, const AudioTimeStamp*)> onBuffer,
        std::function<void(NSError*)> onError, std::function<void()> onEnd)
       : udid_(udid), onBuffer_(std::move(onBuffer)), onError_(std::move(onError)), onEnd_(std::move(onEnd)) {
-    queue_ = dispatch_queue_create("com.appium.coresim.audioTap", DISPATCH_QUEUE_SERIAL);
+    queue_ = dispatch_queue_create("io.appium.coresim.audioTap", DISPATCH_QUEUE_SERIAL);
   }
 
   ~Impl() { Stop(); }
@@ -154,7 +154,7 @@ class AudioTapSession::Impl {
     NSDictionary* aggregateDescription = @{
       @(kAudioAggregateDeviceNameKey) : [NSString stringWithFormat:@"coresim-audio-%@", udid_],
       @(kAudioAggregateDeviceUIDKey) :
-          [NSString stringWithFormat:@"com.appium.coresim.audio.%@.%@", udid_, uuid.UUIDString],
+          [NSString stringWithFormat:@"io.appium.coresim.audio.%@.%@", udid_, uuid.UUIDString],
       @(kAudioAggregateDeviceIsPrivateKey) : @YES,
       @(kAudioAggregateDeviceTapAutoStartKey) : @NO,
       @(kAudioAggregateDeviceTapListKey) : @[ @{

package/src/native/sim_device.h

@@ -2,6 +2,8 @@
 
 #import <Foundation/Foundation.h>
 
+#include <cstdint>
+
 namespace coresim {
 
 // -[SimDevice UDID] / -[SimDevice name] / -[SimDevice state] / -[SimDevice deviceType] /
@@ -19,6 +21,11 @@ id DeviceRuntime(id device);
 // privacy-permission access (see tcc_privacy.h).
 NSString* DeviceDataPath(id device);
 
+// -[SimDevice lastBootedAt] -> the current boot session's start time (nil if never booted). Used to
+// tell a guest preference file that predates this boot from one already rewritten this boot (see
+// sim_orientation.mm).
+NSDate* DeviceLastBootedAt(id device);
+
 // -[SimDevice bootWithOptions:error:]
 BOOL Boot(id device, NSDictionary* options, NSError** error);
 
@@ -64,6 +71,10 @@ NSString* Getenv(id device, NSString* name, NSError** error);
 // the same way Apple's own Simulator.app does.
 unsigned int LookupMachPort(id device, NSString* serviceName, NSError** error);
 
+// Rotates the device via a raw GSEvent mach message to SpringBoard's "PurpleWorkspacePort" (see
+// CLAUDE.md). `orientation`: 1=portrait, 2=portraitUpsideDown, 3=landscapeRight, 4=landscapeLeft.
+BOOL SetDeviceOrientation(id device, int32_t orientation, NSError** error);
+
 // -[SimDevice installApplication:withOptions:error:]
 BOOL InstallApp(id device, NSURL* appURL, NSDictionary* options, NSError** error);