serve-sim 0.1.49-beta.141.1 → 0.1.49

package/README.md

@@ -148,6 +148,10 @@ Options:
                       Cap the H.264 stream bitrate (default scales with
                       screen size, 6-30 Mbps). Also read from
                       SERVE_SIM_MAX_BITRATE
+      --device-set <path>
+                      Use this CoreSimulator device set instead of Xcode's
+                      default (simctl --set). Applies to subcommands too.
+                      Also read from SERVE_SIM_DEVICE_SET
       --list [device] List running streams
       --kill [device] Kill running stream(s)
 
@@ -175,6 +179,7 @@ serve-sim --panes devices,tools --fit  # start with selected panes open and fit
 serve-sim --theme dark                 # start the simulator in Dark Mode
 serve-sim --allow-exec                 # enable `serve-sim exec` and .ipa drag-to-install
 serve-sim --max-bitrate 8              # cap H.264 at 8 Mbps (slow links / shared hosts)
+serve-sim --device-set ~/pool <udid>   # a simulator of another device set
 
 # Type text into the focused field
 serve-sim type "Hello, world!"
@@ -218,6 +223,10 @@ The host shell — `POST /exec`, `{command}` frames on the `/exec-ws` control ch
 
 `--detach` and `--no-preview` reuse a running server only when it was started with the same `--auth-token` (or with none on both sides) and the same `--allow-exec` setting (on or off on both sides); otherwise they exit with an error — stop the old server with `serve-sim -k <udid>` first.
 
+### Device sets (`--device-set`)
+
+Tools that keep simulators in a CoreSimulator device set of their own (device pools, CI runners) put them where `simctl list` and Simulator.app never look. `--device-set <path>` (or `SERVE_SIM_DEVICE_SET`, an existing directory) points serve-sim at that set: every `simctl` call gets `--set <path>`, each preview records its set in its state file so previews in different sets never take each other's simulators for shut down, the native capture, input and accessibility bridges look the device up in that set, and per-simulator data (permissions) is read from it. Simulator.app is not opened for such a set, since it only shows Xcode's default one. The flag applies to subcommands such as `serve-sim camera` too (each `camera` subcommand refuses a simulator the set does not list), and a command finds only previews of its own set, whether or not it names a simulator; `-l` and `-k` without a device still list and stop previews in every set. The toolbar's library shell commands (`homeButtonCommand`, the screenshot button) still name no device set; the preview page uses host actions instead.
+
 ### Camera
 
 `serve-sim camera <bundle-id>` replaces the simulator's camera feed for a single app. A small host-side helper writes BGRA frames into a POSIX shared-memory region; an injected dylib (`DYLD_INSERT_LIBRARIES`) swizzles AVFoundation inside the simulator process so the app reads from that region instead of the simulator's stub camera.
@@ -230,6 +239,8 @@ Sources:
 - **file** — image (PNG/JPEG/HEIC/…) or video (mp4/mov/m4v/webm/…). The CLI sniffs the kind from the extension and falls back to magic bytes for files without an extension.
 - **webcam** — live `AVCaptureDevice` (built-in, Continuity, external).
 
+Movies an app records from the injected camera (`AVCaptureMovieFileOutput`, as in expo-camera's `recordAsync` and VisionCamera) are video-only: they have no audio track, even with `recordAsync({ mute: false })`.
+
 ### Screen recording
 
 The record button in the preview toolbar and `serve-sim record` both drive a native recorder in the server: it encodes the simulator framebuffer directly (full native resolution, constant frame rate, hardware H.264/HEVC), independent of the stream codec the viewer uses. Stopping streams the finished MP4 to the client that stopped it (a browser download, or the `-o` file) and deletes the server's temp copy. One recording runs per device; any client may stop it, and a `serve-sim record` whose recording is stopped elsewhere exits with an error instead of saving.

package/Sources/SimCameraInjector/SimCamFakes.m

@@ -141,6 +141,7 @@ void SimCamLogSwallowedRuntimeError(NSString *via, id object, NSDictionary *user
 }
 - (BOOL)isHighestPhotoQualitySupported { return YES; }
 - (BOOL)isVideoBinned { return NO; }
+- (BOOL)isVideoHDRSupported { return NO; }
 - (BOOL)isVideoStabilizationModeSupported:(AVCaptureVideoStabilizationMode)m { return NO; }
 - (CGFloat)videoMaxZoomFactor { return 16.0; }
 - (CGFloat)videoZoomFactorUpscaleThreshold { return 1.0; }
@@ -199,9 +200,20 @@ static char kFakePositionKey;
 - (BOOL)isSuspended { return NO; }
 - (BOOL)lockForConfiguration:(NSError **)e { return YES; }
 - (void)unlockForConfiguration { }
+// AVFoundation's setters validate against private format state the fakes
+// lack and throw, so configuration a library applies (VisionCamera 5 sets
+// format, frame rate and color space on every session) is accepted and
+// dropped: the injected frames have one size and rate.
 - (AVCaptureDeviceFormat *)activeFormat { return SimCamSharedFakeFormat(); }
+- (void)setActiveFormat:(AVCaptureDeviceFormat *)f { (void)f; }
 - (CMTime)activeVideoMinFrameDuration { return CMTimeMake(1, 30); }
+- (void)setActiveVideoMinFrameDuration:(CMTime)d { (void)d; }
 - (CMTime)activeVideoMaxFrameDuration { return CMTimeMake(1, 30); }
+- (void)setActiveVideoMaxFrameDuration:(CMTime)d { (void)d; }
+- (AVCaptureColorSpace)activeColorSpace { return AVCaptureColorSpace_sRGB; }
+- (void)setActiveColorSpace:(AVCaptureColorSpace)c { (void)c; }
+- (AVCaptureDeviceFormat *)activeDepthDataFormat { return nil; }
+- (void)setActiveDepthDataFormat:(AVCaptureDeviceFormat *)f { (void)f; }
 - (CGFloat)videoZoomFactor { return 1.0; }
 - (void)setVideoZoomFactor:(CGFloat)v { (void)v; }
 - (void)rampToVideoZoomFactor:(CGFloat)f withRate:(float)r { (void)f; (void)r; }

package/Sources/SimCameraInjector/SimCamMovieOutput.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+
+void SimCamInstallMovieOutputSwizzles(void);
+
+// End the output's fake recording, if it has one. AVFoundation's error when
+// the session's media sources or destinations change
+// (AVErrorSessionConfigurationChanged, in Apple's documentation: "Recording
+// stopped because the configuration of media sources and destinations
+// changed") is for the output leaving its fake session: removed, or the
+// session's last fake camera removed, after which stopRecording no longer
+// reaches the fake. A session stopped or let go mid-recording has no error
+// code of its own (AVErrorSessionNotRunning is for a recording that cannot
+// start), so its recordings end as a stop.
+void SimCamFakeMovieOutputLeftSession(AVCaptureOutput *output);
+void SimCamFakeMovieOutputSessionStopped(AVCaptureOutput *output);

package/Sources/SimCameraInjector/SimCamMovieOutput.m

@@ -0,0 +1,211 @@
+#import "SimCamMovieOutput.h"
+#import "SimCamFakes.h"
+#import "SimCamFrameSource.h"
+#import "SimCamMovieRecorder.h"
+#import "SimCamSwizzles.h"
+
+#import <AVFoundation/AVFoundation.h>
+#import <objc/runtime.h>
+
+// What a movie output on a fake session records with in place of its own
+// recorder, which has no media there.
+@interface SimCamFakeMovieOutput : NSObject
+@property (atomic, copy) NSDictionary<NSString *, id> *videoSettings;
+@property (atomic, strong) SimCamMovieRecorder *recorder;
+@end
+@implementation SimCamFakeMovieOutput
+@end
+
+static char kSimCamFakeMovieOutputKey;
+
+// nil for an output AVFoundation records itself.
+static SimCamFakeMovieOutput *SimCamFakeMovieOutputFor(AVCaptureMovieFileOutput *output) {
+    if (!SimCamOutputAttachedToFakeSession(output)) return nil;
+    SimCamFakeMovieOutput *fake = objc_getAssociatedObject(output, &kSimCamFakeMovieOutputKey);
+    if (fake) return fake;
+    @synchronized (output) {
+        fake = objc_getAssociatedObject(output, &kSimCamFakeMovieOutputKey);
+        if (!fake) {
+            fake = [SimCamFakeMovieOutput new];
+            fake.videoSettings = @{ AVVideoCodecKey: AVVideoCodecTypeH264 };
+            objc_setAssociatedObject(output, &kSimCamFakeMovieOutputKey, fake, OBJC_ASSOCIATION_RETAIN);
+        }
+        return fake;
+    }
+}
+
+// The fake that answers the output's recording getters: the output's own
+// while it is on a fake session, and after it leaves, the one holding its
+// last fake recording, because a removed output's recording finishes, and
+// its delegate reads these getters, after the removal. No input reaches a
+// native session in this process, so the output never records natively and
+// that recording answers for good, as it does while the output is attached.
+static SimCamFakeMovieOutput *SimCamFakeRecordingFor(AVCaptureMovieFileOutput *output) {
+    SimCamFakeMovieOutput *fake = SimCamFakeMovieOutputFor(output);
+    if (fake) return fake;
+    fake = objc_getAssociatedObject(output, &kSimCamFakeMovieOutputKey);
+    return fake.recorder ? fake : nil;
+}
+
+void SimCamFakeMovieOutputLeftSession(AVCaptureOutput *output) {
+    SimCamFakeMovieOutput *fake = objc_getAssociatedObject(output, &kSimCamFakeMovieOutputKey);
+    // The file is finished and plays, as AVFoundation's is.
+    [fake.recorder stopWithError:[NSError errorWithDomain:AVFoundationErrorDomain
+                                                     code:AVErrorSessionConfigurationChanged
+                                                 userInfo:@{ AVErrorRecordingSuccessfullyFinishedKey: @YES }]];
+}
+void SimCamFakeMovieOutputSessionStopped(AVCaptureOutput *output) {
+    SimCamFakeMovieOutput *fake = objc_getAssociatedObject(output, &kSimCamFakeMovieOutputKey);
+    [fake.recorder stop];
+}
+
+// AVFoundation answers these from the native connection graph, which a
+// session with a fake camera never builds, and throws for a connection it
+// does not own ("Invalid connection passed"). The recording methods are
+// swizzled on AVCaptureMovieFileOutput, which overrides some of them, so
+// AVCaptureFileOutput and its other subclasses are untouched.
+@interface AVCaptureMovieFileOutput (SimCam)
+@end
+@implementation AVCaptureMovieFileOutput (SimCam)
+- (NSArray<AVVideoCodecType> *)simcam_availableVideoCodecTypes {
+    SimCamFakeMovieOutput *fake = SimCamFakeMovieOutputFor(self);
+    if (!fake) return [self simcam_availableVideoCodecTypes];
+    return @[ AVVideoCodecTypeH264, AVVideoCodecTypeHEVC ];
+}
+- (NSArray<NSString *> *)simcam_supportedOutputSettingsKeysForConnection:(AVCaptureConnection *)connection {
+    SimCamFakeMovieOutput *fake = SimCamFakeMovieOutputFor(self);
+    if (!fake) return [self simcam_supportedOutputSettingsKeysForConnection:connection];
+    return @[ AVVideoCodecKey, AVVideoCompressionPropertiesKey ];
+}
+- (NSDictionary<NSString *, id> *)simcam_outputSettingsForConnection:(AVCaptureConnection *)connection {
+    SimCamFakeMovieOutput *fake = SimCamFakeMovieOutputFor(self);
+    if (!fake) return [self simcam_outputSettingsForConnection:connection];
+    if (![SimCamConnectionsForOutput(self) containsObject:connection]) {
+        [NSException raise:NSInvalidArgumentException
+                    format:@"*** -[AVCaptureMovieFileOutput outputSettingsForConnection:] Invalid connection passed"];
+    }
+    return SimCamConnectionCarries(connection, AVMediaTypeVideo) ? fake.videoSettings : @{};
+}
+- (void)simcam_setOutputSettings:(NSDictionary<NSString *, id> *)settings
+                   forConnection:(AVCaptureConnection *)connection {
+    SimCamFakeMovieOutput *fake = SimCamFakeMovieOutputFor(self);
+    if (!fake) {
+        [self simcam_setOutputSettings:settings forConnection:connection];
+        return;
+    }
+    // AVFoundation ignores settings for another output's connection, and the
+    // fake movie has no audio track, so only the output's own video
+    // connection sets them.
+    if (![SimCamConnectionsForOutput(self) containsObject:connection]) return;
+    if (!SimCamConnectionCarries(connection, AVMediaTypeVideo)) return;
+    fake.videoSettings = settings ?: @{ AVVideoCodecKey: AVVideoCodecTypeH264 };
+}
+- (void)simcam_startRecordingToOutputFileURL:(NSURL *)url
+                           recordingDelegate:(id<AVCaptureFileOutputRecordingDelegate>)delegate {
+    SimCamFakeMovieOutput *fake = SimCamFakeMovieOutputFor(self);
+    if (!fake) {
+        [self simcam_startRecordingToOutputFileURL:url recordingDelegate:delegate];
+        return;
+    }
+    // AVFoundation closes the file in progress before it opens the next.
+    [fake.recorder stop];
+    SimCamMovieRecorder *recorder = [[SimCamMovieRecorder alloc]
+        initWithOutput:self
+                   URL:url
+              delegate:delegate
+           connections:SimCamConnectionsForOutput(self)
+         videoSettings:fake.videoSettings
+           maxDuration:self.maxRecordedDuration
+           maxFileSize:self.maxRecordedFileSize];
+    fake.recorder = recorder;
+    // AVErrorSessionNotRunning, in Apple's documentation: "The recording
+    // couldn't start because the session isn't running."
+    if (!SimCamFakeSessionForOutput(self).isRunning) {
+        [recorder stopWithError:[NSError errorWithDomain:AVFoundationErrorDomain
+                                                    code:AVErrorSessionNotRunning
+                                                userInfo:nil]];
+        return;
+    }
+    SimCamMarkCameraInUse();
+    [[SimCamRegistry shared] startPumpingIfNeeded];
+    [recorder start];
+}
+- (void)simcam_stopRecording {
+    SimCamFakeMovieOutput *fake = SimCamFakeMovieOutputFor(self);
+    if (!fake) {
+        [self simcam_stopRecording];
+        return;
+    }
+    [fake.recorder stop];
+}
+- (void)simcam_pauseRecording {
+    SimCamFakeMovieOutput *fake = SimCamFakeMovieOutputFor(self);
+    if (!fake) {
+        [self simcam_pauseRecording];
+        return;
+    }
+    [fake.recorder pause];
+}
+- (void)simcam_resumeRecording {
+    SimCamFakeMovieOutput *fake = SimCamFakeMovieOutputFor(self);
+    if (!fake) {
+        [self simcam_resumeRecording];
+        return;
+    }
+    [fake.recorder resume];
+}
+- (BOOL)simcam_isRecording {
+    SimCamFakeMovieOutput *fake = SimCamFakeRecordingFor(self);
+    if (!fake) return [self simcam_isRecording];
+    return fake.recorder.isRecording;
+}
+- (BOOL)simcam_isRecordingPaused {
+    SimCamFakeMovieOutput *fake = SimCamFakeRecordingFor(self);
+    if (!fake) return [self simcam_isRecordingPaused];
+    return fake.recorder.isPaused;
+}
+- (NSURL *)simcam_outputFileURL {
+    SimCamFakeMovieOutput *fake = SimCamFakeRecordingFor(self);
+    if (!fake) return [self simcam_outputFileURL];
+    return fake.recorder.isRecording ? fake.recorder.URL : nil;
+}
+- (CMTime)simcam_recordedDuration {
+    SimCamFakeMovieOutput *fake = SimCamFakeRecordingFor(self);
+    if (!fake) return [self simcam_recordedDuration];
+    return fake.recorder ? fake.recorder.recordedDuration : kCMTimeZero;
+}
+- (int64_t)simcam_recordedFileSize {
+    SimCamFakeMovieOutput *fake = SimCamFakeRecordingFor(self);
+    if (!fake) return [self simcam_recordedFileSize];
+    return fake.recorder.recordedFileSize;
+}
+@end
+
+void SimCamInstallMovieOutputSwizzles(void) {
+    Class movieOut = [AVCaptureMovieFileOutput class];
+    SwizzleInstanceMethod(movieOut,
+        @selector(availableVideoCodecTypes),
+        @selector(simcam_availableVideoCodecTypes));
+    SwizzleInstanceMethod(movieOut,
+        @selector(supportedOutputSettingsKeysForConnection:),
+        @selector(simcam_supportedOutputSettingsKeysForConnection:));
+    SwizzleInstanceMethod(movieOut,
+        @selector(outputSettingsForConnection:),
+        @selector(simcam_outputSettingsForConnection:));
+    SwizzleInstanceMethod(movieOut,
+        @selector(setOutputSettings:forConnection:),
+        @selector(simcam_setOutputSettings:forConnection:));
+    SwizzleInstanceMethod(movieOut,
+        @selector(startRecordingToOutputFileURL:recordingDelegate:),
+        @selector(simcam_startRecordingToOutputFileURL:recordingDelegate:));
+    SwizzleInstanceMethod(movieOut, @selector(stopRecording), @selector(simcam_stopRecording));
+    SwizzleInstanceMethod(movieOut, @selector(isRecording), @selector(simcam_isRecording));
+    SwizzleInstanceMethod(movieOut, @selector(outputFileURL), @selector(simcam_outputFileURL));
+    SwizzleInstanceMethod(movieOut, @selector(recordedDuration), @selector(simcam_recordedDuration));
+    SwizzleInstanceMethod(movieOut, @selector(recordedFileSize), @selector(simcam_recordedFileSize));
+    if (@available(iOS 18.0, *)) {
+        SwizzleInstanceMethod(movieOut, @selector(pauseRecording), @selector(simcam_pauseRecording));
+        SwizzleInstanceMethod(movieOut, @selector(resumeRecording), @selector(simcam_resumeRecording));
+        SwizzleInstanceMethod(movieOut, @selector(isRecordingPaused), @selector(simcam_isRecordingPaused));
+    }
+}

package/Sources/SimCameraInjector/SimCamMovieRecorder.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#import <AVFoundation/AVFoundation.h>
+
+// One AVCaptureMovieFileOutput recording from the injected frames. A session
+// with a fake camera never runs natively, so the movie output's own recorder
+// has no media; this writes the current frame at the frame rate to the URL
+// with AVAssetWriter and calls the recording delegate as AVFoundation does.
+@interface SimCamMovieRecorder : NSObject
+- (instancetype)initWithOutput:(AVCaptureFileOutput *)output
+                           URL:(NSURL *)url
+                      delegate:(id<AVCaptureFileOutputRecordingDelegate>)delegate
+                   connections:(NSArray<AVCaptureConnection *> *)connections
+                 videoSettings:(NSDictionary<NSString *, id> *)videoSettings
+                   maxDuration:(CMTime)maxDuration
+                   maxFileSize:(int64_t)maxFileSize;
+- (void)start;
+- (void)stop;
+// Ends the recording as `stop` does, with `error` for the delegate once the
+// file is finished. Before `start`, the recording fails with `error` and
+// writes nothing.
+- (void)stopWithError:(NSError *)error;
+- (void)pause;
+- (void)resume;
+@property (nonatomic, readonly) NSURL *URL;
+@property (nonatomic, readonly, getter=isRecording) BOOL recording;
+@property (nonatomic, readonly, getter=isPaused) BOOL paused;
+@property (nonatomic, readonly) CMTime recordedDuration;
+@property (nonatomic, readonly) int64_t recordedFileSize;
+@end

package/Sources/SimCameraInjector/SimCamMovieRecorder.m

@@ -0,0 +1,270 @@
+#import "SimCamMovieRecorder.h"
+#import "SimCamFrameSource.h"
+#import "SimCamLog.h"
+
+#import <QuartzCore/QuartzCore.h>
+#import <objc/message.h>
+#include <stdatomic.h>
+
+static const int32_t kSimCamMovieFrameRate = 30;
+static const int32_t kSimCamMovieTimescale = 600;
+
+// AVFoundation reports a failed recording with
+// AVErrorRecordingSuccessfullyFinishedKey set to NO, which apps read to tell
+// a usable file from a broken one.
+static NSError *SimCamRecordingFailure(NSError *cause) {
+    NSMutableDictionary *userInfo = [cause.userInfo mutableCopy] ?: [NSMutableDictionary new];
+    userInfo[AVErrorRecordingSuccessfullyFinishedKey] = @NO;
+    return [NSError errorWithDomain:cause.domain ?: AVFoundationErrorDomain
+                               code:cause ? cause.code : AVErrorUnknown
+                           userInfo:userInfo];
+}
+
+// A limit that ends the recording leaves a finished file that plays, which
+// AVFoundation reports with AVErrorRecordingSuccessfullyFinishedKey set to YES.
+static NSError *SimCamRecordingLimitReached(AVError code) {
+    return [NSError errorWithDomain:AVFoundationErrorDomain
+                               code:code
+                           userInfo:@{ AVErrorRecordingSuccessfullyFinishedKey: @YES }];
+}
+
+@implementation SimCamMovieRecorder {
+    // Held until the delegate hears the recording finished, as AVFoundation
+    // always tells it, even when the app lets the output go first.
+    AVCaptureFileOutput *_output;
+    id<AVCaptureFileOutputRecordingDelegate> _delegate;
+    NSArray<AVCaptureConnection *> *_connections;
+    NSDictionary<NSString *, id> *_videoSettings;
+    CMTime _maxDuration;
+    // Bytes; 0 is no limit.
+    int64_t _maxFileSize;
+    dispatch_queue_t _queue;
+    dispatch_source_t _timer;
+    AVAssetWriter *_writer;
+    AVAssetWriterInput *_input;
+    AVAssetWriterInputPixelBufferAdaptor *_adaptor;
+    CFTimeInterval _startedAt;
+    CFTimeInterval _pausedAt;
+    CFTimeInterval _pausedSeconds;
+    CMTime _lastFrameTime;
+    BOOL _finishing;
+    // Read from any thread through the public getters.
+    _Atomic(BOOL) _recording;
+    _Atomic(BOOL) _paused;
+    _Atomic(int64_t) _recordedValue;
+}
+
+- (instancetype)initWithOutput:(AVCaptureFileOutput *)output
+                           URL:(NSURL *)url
+                      delegate:(id<AVCaptureFileOutputRecordingDelegate>)delegate
+                   connections:(NSArray<AVCaptureConnection *> *)connections
+                 videoSettings:(NSDictionary<NSString *, id> *)videoSettings
+                   maxDuration:(CMTime)maxDuration
+                   maxFileSize:(int64_t)maxFileSize {
+    if ((self = [super init])) {
+        _output = output;
+        _URL = url;
+        _delegate = delegate;
+        _connections = [connections copy] ?: @[];
+        _videoSettings = [videoSettings copy] ?: @{};
+        _maxDuration = maxDuration;
+        _maxFileSize = maxFileSize;
+        _queue = dispatch_queue_create("dev.servesim.simcam.movie", DISPATCH_QUEUE_SERIAL);
+        _lastFrameTime = kCMTimeInvalid;
+    }
+    return self;
+}
+
+- (BOOL)isRecording { return _recording; }
+- (BOOL)isPaused { return _paused; }
+- (CMTime)recordedDuration { return CMTimeMake(_recordedValue, kSimCamMovieTimescale); }
+- (int64_t)recordedFileSize {
+    NSDictionary *attributes = [[NSFileManager defaultManager]
+        attributesOfItemAtPath:_URL.path error:nil];
+    return (int64_t)attributes.fileSize;
+}
+
+- (void)start {
+    _recording = YES;
+    dispatch_async(_queue, ^{
+        NSError *error = nil;
+        if (![self openWriter:&error]) {
+            [self finishWithError:SimCamRecordingFailure(error) endingAt:kCMTimeInvalid];
+            return;
+        }
+        self->_startedAt = CACurrentMediaTime();
+        [self appendFrameAt:kCMTimeZero];
+        simcam_log(@"movie recording started → %@", self->_URL.lastPathComponent);
+        [self callDelegate:@selector(captureOutput:didStartRecordingToOutputFileAtURL:fromConnections:)];
+        self->_timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, self->_queue);
+        uint64_t intervalNs = NSEC_PER_SEC / kSimCamMovieFrameRate;
+        dispatch_source_set_timer(self->_timer,
+            dispatch_time(DISPATCH_TIME_NOW, (int64_t)intervalNs), intervalNs, intervalNs / 10);
+        __weak SimCamMovieRecorder *weakSelf = self;
+        dispatch_source_set_event_handler(self->_timer, ^{ [weakSelf tick]; });
+        dispatch_resume(self->_timer);
+    });
+}
+
+- (void)stop {
+    [self stopWithError:nil];
+}
+
+- (void)stopWithError:(NSError *)error {
+    dispatch_async(_queue, ^{ [self finishWithError:error endingAt:kCMTimeInvalid]; });
+}
+
+- (void)pause {
+    dispatch_async(_queue, ^{
+        if (self->_paused || self->_finishing) return;
+        self->_pausedAt = CACurrentMediaTime();
+        self->_paused = YES;
+        [self callDelegate:@selector(captureOutput:didPauseRecordingToOutputFileAtURL:fromConnections:)];
+    });
+}
+
+- (void)resume {
+    dispatch_async(_queue, ^{
+        if (!self->_paused || self->_finishing) return;
+        self->_pausedSeconds += CACurrentMediaTime() - self->_pausedAt;
+        self->_paused = NO;
+        [self callDelegate:@selector(captureOutput:didResumeRecordingToOutputFileAtURL:fromConnections:)];
+    });
+}
+
+#pragma mark - Queue-confined
+
+- (BOOL)openWriter:(NSError **)error {
+    CVPixelBufferRef frame = [[SimCamRegistry shared] currentPixelBuffer];
+    size_t width = frame ? CVPixelBufferGetWidth(frame) : 1280;
+    size_t height = frame ? CVPixelBufferGetHeight(frame) : 720;
+    if (frame) CVPixelBufferRelease(frame);
+
+    if ([[NSFileManager defaultManager] fileExistsAtPath:_URL.path]) {
+        if (error) *error = [NSError errorWithDomain:AVFoundationErrorDomain
+                                                code:AVErrorFileAlreadyExists
+                                            userInfo:@{
+                                                NSURLErrorKey: _URL,
+                                                NSLocalizedDescriptionKey: @"A file already exists at the recording URL",
+                                            }];
+        return NO;
+    }
+    // AVCaptureMovieFileOutput writes a QuickTime movie whatever the file's
+    // extension says, so the fake does too.
+    _writer = [AVAssetWriter assetWriterWithURL:_URL fileType:AVFileTypeQuickTimeMovie error:error];
+    if (!_writer) return NO;
+
+    NSMutableDictionary *settings = [NSMutableDictionary dictionaryWithDictionary:@{
+        AVVideoCodecKey: _videoSettings[AVVideoCodecKey] ?: AVVideoCodecTypeH264,
+        AVVideoWidthKey: @(width),
+        AVVideoHeightKey: @(height),
+    }];
+    if (_videoSettings[AVVideoCompressionPropertiesKey]) {
+        settings[AVVideoCompressionPropertiesKey] = _videoSettings[AVVideoCompressionPropertiesKey];
+    }
+    _input = [AVAssetWriterInput assetWriterInputWithMediaType:AVMediaTypeVideo outputSettings:settings];
+    _input.expectsMediaDataInRealTime = YES;
+    _adaptor = [AVAssetWriterInputPixelBufferAdaptor
+        assetWriterInputPixelBufferAdaptorWithAssetWriterInput:_input
+                                   sourcePixelBufferAttributes:nil];
+    if (![_writer canAddInput:_input]) {
+        if (error) *error = [NSError errorWithDomain:AVFoundationErrorDomain
+                                                code:AVErrorUnknown
+                                            userInfo:@{ NSLocalizedDescriptionKey: @"serve-sim could not add a video track" }];
+        return NO;
+    }
+    [_writer addInput:_input];
+    if (![_writer startWriting]) {
+        if (error) *error = _writer.error;
+        return NO;
+    }
+    [_writer startSessionAtSourceTime:kCMTimeZero];
+    return YES;
+}
+
+- (void)tick {
+    if (_finishing) return;
+    if (_writer.status == AVAssetWriterStatusFailed) {
+        [self finishWithError:SimCamRecordingFailure(_writer.error) endingAt:kCMTimeInvalid];
+        return;
+    }
+    // Checked while paused too, in case the writer flushes what it had
+    // buffered then. The writer flushes in chunks and adds the movie header
+    // as it finishes, so the finished file runs past the limit by what it
+    // had buffered.
+    if (_maxFileSize > 0 && self.recordedFileSize >= _maxFileSize) {
+        [self finishWithError:SimCamRecordingLimitReached(AVErrorMaximumFileSizeReached) endingAt:kCMTimeInvalid];
+        return;
+    }
+    if (_paused) return;
+    CFTimeInterval elapsed = CACurrentMediaTime() - _startedAt - _pausedSeconds;
+    CMTime now = CMTimeMakeWithSeconds(elapsed, kSimCamMovieTimescale);
+    if (CMTIME_IS_VALID(_maxDuration) && CMTimeCompare(now, _maxDuration) >= 0) {
+        [self finishWithError:SimCamRecordingLimitReached(AVErrorMaximumDurationReached) endingAt:_maxDuration];
+        return;
+    }
+    [self appendFrameAt:now];
+}
+
+- (void)appendFrameAt:(CMTime)time {
+    if (CMTIME_IS_VALID(_lastFrameTime) && CMTimeCompare(time, _lastFrameTime) <= 0) return;
+    if (!_input.isReadyForMoreMediaData) return;
+    CVPixelBufferRef frame = [[SimCamRegistry shared] currentPixelBuffer];
+    if (!frame) return;
+    if ([_adaptor appendPixelBuffer:frame withPresentationTime:time]) {
+        _lastFrameTime = time;
+        _recordedValue = CMTimeConvertScale(time, kSimCamMovieTimescale, kCMTimeRoundingMethod_Default).value;
+    }
+    CVPixelBufferRelease(frame);
+}
+
+// `end` is where the movie stops; invalid means one frame past the last.
+- (void)finishWithError:(NSError *)error endingAt:(CMTime)end {
+    if (_finishing) return;
+    _finishing = YES;
+    if (_timer) {
+        dispatch_source_cancel(_timer);
+        _timer = nil;
+    }
+    void (^deliver)(NSError *) = ^(NSError *result) {
+        self->_recording = NO;
+        self->_paused = NO;
+        simcam_log(@"movie recording finished → %@ (%.2f s, error=%@)",
+            self->_URL.lastPathComponent, CMTimeGetSeconds(self.recordedDuration),
+            result.localizedDescription ?: @"none");
+        AVCaptureFileOutput *output = self->_output;
+        [self->_delegate captureOutput:output
+           didFinishRecordingToOutputFileAtURL:self->_URL
+                               fromConnections:self->_connections
+                                         error:result];
+        self->_delegate = nil;
+        self->_output = nil;
+    };
+    if (_writer.status != AVAssetWriterStatusWriting) {
+        deliver(SimCamRecordingFailure(error ?: _writer.error));
+        return;
+    }
+    [_input markAsFinished];
+    if (!CMTIME_IS_VALID(end) && CMTIME_IS_VALID(_lastFrameTime)) {
+        end = CMTimeAdd(_lastFrameTime, CMTimeMake(1, kSimCamMovieFrameRate));
+    }
+    if (CMTIME_IS_VALID(end)) {
+        [_writer endSessionAtSourceTime:end];
+        _recordedValue = CMTimeConvertScale(end, kSimCamMovieTimescale, kCMTimeRoundingMethod_Default).value;
+    }
+    [_writer finishWritingWithCompletionHandler:^{
+        dispatch_async(self->_queue, ^{
+            BOOL completed = self->_writer.status == AVAssetWriterStatusCompleted;
+            deliver(completed ? error : SimCamRecordingFailure(self->_writer.error));
+        });
+    }];
+}
+
+- (void)callDelegate:(SEL)selector {
+    if (![_delegate respondsToSelector:selector]) return;
+    AVCaptureFileOutput *output = _output;
+    ((void (*)(id, SEL, AVCaptureFileOutput *, NSURL *, NSArray *))objc_msgSend)(
+        _delegate, selector, output, _URL, _connections);
+}
+
+@end

package/Sources/SimCameraInjector/SimCamSwizzles.h

@@ -1,3 +1,14 @@
 #pragma once
 
+#import <AVFoundation/AVFoundation.h>
+
 void SimCamInstallSwizzles(void);
+
+// Shared with the other swizzle files.
+BOOL SimCamOutputAttachedToFakeSession(AVCaptureOutput *output);
+AVCaptureSession *SimCamFakeSessionForOutput(AVCaptureOutput *output);
+NSArray<AVCaptureConnection *> *SimCamConnectionsForOutput(AVCaptureOutput *output);
+BOOL SimCamConnectionCarries(AVCaptureConnection *connection, AVMediaType mediaType);
+// Hidden from the dylib's exports, as the one helper without the SimCam
+// prefix.
+__attribute__((visibility("hidden"))) BOOL SwizzleInstanceMethod(Class cls, SEL orig, SEL swiz);