@octane-xplat/camera 0.12.0 → 0.14.0

package/dist/native/session-backend.ios.js

@@ -0,0 +1,682 @@
+import { CameraCaptureError } from "./types.js";
+import { File, knownFolders, path } from "@nativescript/core";
+//#region src/session-backend.ios.ts
+var authorizationNotDetermined = 0;
+var authorizationRestricted = 1;
+var authorizationDenied = 2;
+var authorizationAuthorized = 3;
+var captureDevicePositionUnspecified = 0;
+var captureDevicePositionBack = 1;
+var captureDevicePositionFront = 2;
+var videoOrientationPortrait = 1;
+var videoOrientationPortraitUpsideDown = 2;
+var videoOrientationLandscapeRight = 3;
+var videoOrientationLandscapeLeft = 4;
+var interruptionVideoDeviceNotAvailableInBackground = 1;
+var interruptionAudioDeviceInUseByAnotherClient = 2;
+var interruptionVideoDeviceInUseByAnotherClient = 3;
+var interruptionVideoDeviceNotAvailableWithMultipleForegroundApps = 4;
+var interruptionVideoDeviceNotAvailableDueToSystemPressure = 5;
+var avErrorMaximumDurationReached = -11810;
+var mediaTypeFor = (kind) => kind === "camera" ? AVMediaTypeVideo : AVMediaTypeAudio;
+var usageKeyFor = (kind) => kind === "camera" ? "NSCameraUsageDescription" : "NSMicrophoneUsageDescription";
+var readPermission = (kind) => {
+	switch (AVCaptureDevice.authorizationStatusForMediaType(mediaTypeFor(kind))) {
+		case authorizationAuthorized: return "granted";
+		case authorizationDenied: return "denied";
+		case authorizationRestricted: return "restricted";
+		case authorizationNotDetermined: return "notDetermined";
+		default: return "unknown";
+	}
+};
+var requestAccess = (kind) => {
+	if (!NSBundle.mainBundle.objectForInfoDictionaryKey(usageKeyFor(kind))) return Promise.reject(new CameraCaptureError({
+		kind: "configurationMissing",
+		operation: "requestPermission",
+		permission: kind,
+		message: `Missing ${usageKeyFor(kind)} in the host app's Info.plist`
+	}));
+	const status = readPermission(kind);
+	if (status !== "notDetermined") return Promise.resolve(status);
+	return new Promise((resolve) => {
+		AVCaptureDevice.requestAccessForMediaTypeCompletionHandler(mediaTypeFor(kind), () => resolve(readPermission(kind)));
+	});
+};
+var facingForPosition = (position) => position === captureDevicePositionFront ? "front" : position === captureDevicePositionBack ? "back" : void 0;
+var listCameras = () => {
+	const types = [
+		AVCaptureDeviceTypeBuiltInWideAngleCamera,
+		AVCaptureDeviceTypeBuiltInUltraWideCamera,
+		AVCaptureDeviceTypeBuiltInTelephotoCamera,
+		AVCaptureDeviceTypeBuiltInDualCamera,
+		AVCaptureDeviceTypeBuiltInDualWideCamera,
+		AVCaptureDeviceTypeBuiltInTripleCamera,
+		AVCaptureDeviceTypeBuiltInTrueDepthCamera
+	].filter((entry) => typeof entry === "string");
+	const discovery = AVCaptureDeviceDiscoverySession.discoverySessionWithDeviceTypesMediaTypePosition(types, AVMediaTypeVideo, captureDevicePositionUnspecified);
+	const devices = [];
+	const found = discovery?.devices;
+	const count = found?.count ?? 0;
+	for (let index = 0; index < count; index++) devices.push(found.objectAtIndex(index));
+	if (!devices.length) {
+		const legacy = AVCaptureDevice.devicesWithMediaType(AVMediaTypeVideo);
+		for (let index = 0; index < (legacy?.count ?? 0); index++) devices.push(legacy.objectAtIndex(index));
+	}
+	return devices;
+};
+var selectDevice = (camera, devices) => {
+	if (camera && typeof camera === "object" && "deviceId" in camera) return devices.find((device) => device.uniqueID === camera.deviceId);
+	if (camera === "front" || camera === "back") {
+		const position = camera === "front" ? captureDevicePositionFront : captureDevicePositionBack;
+		return devices.find((device) => device.position === position);
+	}
+	return devices.find((device) => device.position === captureDevicePositionBack) ?? devices[0];
+};
+var orientationToRotationAngle = (orientation) => orientation === "portrait" ? 90 : orientation === "portraitUpsideDown" ? 270 : orientation === "landscapeLeft" ? 180 : orientation === "landscapeRight" ? 0 : void 0;
+var orientationToLegacyConstant = (orientation) => orientation === "portrait" ? videoOrientationPortrait : orientation === "portraitUpsideDown" ? videoOrientationPortraitUpsideDown : orientation === "landscapeLeft" ? videoOrientationLandscapeLeft : orientation === "landscapeRight" ? videoOrientationLandscapeRight : void 0;
+/** Derive the cardinal capture orientation from a video track's
+*  preferred transform; `undefined` when it cannot be told honestly. */
+var orientationFromTransform = (transform) => {
+	const { a, b, c, d } = transform;
+	if (a === 0 && b === 1 && c === -1 && d === 0) return "portrait";
+	if (a === 0 && b === -1 && c === 1 && d === 0) return "portraitUpsideDown";
+	if (a === 1 && b === 0 && c === 0 && d === 1) return "landscapeRight";
+	if (a === -1 && b === 0 && c === 0 && d === -1) return "landscapeLeft";
+	return "unspecified";
+};
+var mapInterruptionReason = (raw) => {
+	switch (raw) {
+		case interruptionVideoDeviceNotAvailableInBackground: return "background";
+		case interruptionAudioDeviceInUseByAnotherClient: return "audioInUse";
+		case interruptionVideoDeviceInUseByAnotherClient: return "cameraInUse";
+		case interruptionVideoDeviceNotAvailableWithMultipleForegroundApps: return "multitasking";
+		case interruptionVideoDeviceNotAvailableDueToSystemPressure: return "systemPressure";
+		default: return "unknown";
+	}
+};
+var recordingsDirectory = () => {
+	const directory = path.join(knownFolders.documents().path, "octane-camera");
+	if (!File.exists(directory)) NSFileManager.defaultManager.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(directory, true, null, void 0);
+	return directory;
+};
+var hasUsageDeclaration = (kind) => Boolean(NSBundle.mainBundle.objectForInfoDictionaryKey(usageKeyFor(kind)));
+var minFreeDiskBytes = 67108864;
+var freeDiskBytes = () => {
+	try {
+		const free = NSFileManager.defaultManager.attributesOfFileSystemForPathError(knownFolders.documents().path, void 0)?.objectForKey(NSFileSystemFreeSize);
+		return free ? Number(free.longLongValue ?? free.doubleValue ?? 0) : Number.MAX_SAFE_INTEGER;
+	} catch {
+		return Number.MAX_SAFE_INTEGER;
+	}
+};
+/** iOS adapter: one AVCaptureSession shared between the attached preview
+*  and a single AVCaptureMovieFileOutput capture attempt. */
+function createSessionBackend(config) {
+	let currentConfig = { ...config };
+	let session;
+	let videoInput;
+	let audioInput;
+	let movieOutput;
+	let previewLayer;
+	let previewHost;
+	let detachFrame;
+	let previewReadyFlag = false;
+	let device;
+	let observer;
+	let observers = [];
+	let captureSink;
+	let captureRequest;
+	let limitRequested = false;
+	let noDurationLimit;
+	let interrupted = false;
+	const recordingDelegate = NSObject.extend({
+		captureOutputDidStartRecordingToOutputFileAtURLFromConnections(_output, _url, _connections) {
+			onCaptureStarted();
+		},
+		captureOutputDidFinishRecordingToOutputFileAtURLFromConnectionsError(_output, url, _connections, error) {
+			onCaptureFinished(url, error);
+		}
+	}, { protocols: [AVCaptureFileOutputRecordingDelegate] }).new();
+	const emitIssue = (kind, operation, message, cause) => ({
+		kind,
+		operation,
+		message,
+		cause
+	});
+	const notify = (phase, reason) => {
+		interrupted = phase === "began";
+		observer?.interruption(phase, reason);
+		observer?.previewReady(previewReadyFlag && !interrupted);
+	};
+	const observeSession = (target) => {
+		const center = NSNotificationCenter.defaultCenter;
+		const add = (name, object, handler) => {
+			observers.push(center.addObserverForNameObjectQueueUsingBlock(name, object, NSOperationQueue.mainQueue, handler));
+		};
+		add(AVCaptureSessionWasInterruptedNotification, target, (note) => {
+			const raw = note.userInfo?.objectForKey(AVCaptureSessionInterruptionReasonKey);
+			notify("began", mapInterruptionReason(raw ? Number(raw.integerValue) : void 0));
+		});
+		add(AVCaptureSessionInterruptionEndedNotification, target, () => {
+			notify("ended");
+		});
+		add(AVCaptureSessionRuntimeErrorNotification, target, () => {
+			observer?.availability(false);
+		});
+		add(AVCaptureDeviceWasDisconnectedNotification, device, () => {
+			observer?.availability(false);
+		});
+		add(AVCaptureDeviceWasConnectedNotification, null, () => {
+			observer?.availability(true);
+		});
+		add(UIApplicationDidEnterBackgroundNotification, null, () => {
+			notify("began", "background");
+		});
+		add(UIApplicationWillEnterForegroundNotification, null, () => {
+			notify("ended", "background");
+		});
+	};
+	const clearObservers = () => {
+		const center = NSNotificationCenter.defaultCenter;
+		for (const entry of observers) center.removeObserver(entry);
+		observers = [];
+	};
+	const supportedPreset = (target, captureDevice) => target.canSetSessionPreset(AVCaptureSessionPreset1280x720) && captureDevice.supportsAVCaptureSessionPreset(AVCaptureSessionPreset1280x720);
+	/** Resolve the effective standard profile for the current camera:
+	*  720p/30 when the device supports it, otherwise the device's own
+	*  active format disclosed honestly. */
+	const standardProfile = (captureDevice) => {
+		if (captureDevice && session && supportedPreset(session, captureDevice)) return {
+			width: 1280,
+			height: 720,
+			frameRate: 30
+		};
+		const format = captureDevice?.activeFormat;
+		const dimensions = format ? CMVideoFormatDescriptionGetDimensions(format.formatDescription) : void 0;
+		const range = captureDevice?.activeVideoMinFrameDuration;
+		const frameRate = range && range.timescale > 0 && range.value > 0 ? Math.round(range.timescale / range.value) : 30;
+		return {
+			width: dimensions?.width ?? 1280,
+			height: dimensions?.height ?? 720,
+			frameRate
+		};
+	};
+	const ensureAudioInput = (target) => {
+		if (audioInput) return true;
+		const mic = AVCaptureDevice.defaultDeviceWithMediaType(AVMediaTypeAudio);
+		if (!mic) return false;
+		const input = AVCaptureDeviceInput.deviceInputWithDeviceError(mic, void 0);
+		if (!input || !target.canAddInput(input)) return false;
+		target.addInput(input);
+		audioInput = input;
+		return true;
+	};
+	const ensureSession = () => {
+		if (session) return session;
+		const target = AVCaptureSession.new();
+		target.beginConfiguration();
+		device = selectDevice(currentConfig.camera, listCameras());
+		if (!device) {
+			target.commitConfiguration();
+			throw new CameraCaptureError({
+				kind: "unavailable",
+				operation: "startPreview",
+				message: "No camera device is available"
+			});
+		}
+		if (supportedPreset(target, device)) target.sessionPreset = AVCaptureSessionPreset1280x720;
+		const input = AVCaptureDeviceInput.deviceInputWithDeviceError(device, void 0);
+		if (!input || !target.canAddInput(input)) {
+			target.commitConfiguration();
+			throw new CameraCaptureError({
+				kind: "unavailable",
+				operation: "startPreview",
+				message: "Camera input is unavailable"
+			});
+		}
+		target.addInput(input);
+		videoInput = input;
+		const output = AVCaptureMovieFileOutput.new();
+		if (target.canAddOutput(output)) {
+			target.addOutput(output);
+			movieOutput = output;
+			noDurationLimit = output.maxRecordedDuration;
+		} else {
+			target.commitConfiguration();
+			throw new CameraCaptureError({
+				kind: "unsupportedPlatform",
+				operation: "startPreview",
+				message: "Movie file output is unavailable on this device"
+			});
+		}
+		if (currentConfig.audio && readPermission("microphone") === "granted") ensureAudioInput(target);
+		target.commitConfiguration();
+		session = target;
+		observeSession(target);
+		return target;
+	};
+	const stopSessionIfIdle = () => {
+		if (!session || captureSink || previewHost) return;
+		session.stopRunning();
+		clearObservers();
+		session = void 0;
+		videoInput = void 0;
+		audioInput = void 0;
+		movieOutput = void 0;
+		previewLayer = void 0;
+		device = void 0;
+	};
+	const onCaptureStarted = () => {
+		const request = captureRequest;
+		const sink = captureSink;
+		if (!request || !sink || !device) return;
+		const profile = standardProfile(device);
+		const configuration = {
+			cameraId: device.uniqueID,
+			facing: facingForPosition(device.position),
+			audio: request.audio && audioInput !== void 0,
+			width: profile.width,
+			height: profile.height,
+			frameRate: profile.frameRate,
+			orientation: request.orientation ?? "unspecified",
+			mimeType: "video/quicktime",
+			container: "mov"
+		};
+		sink.started(configuration);
+	};
+	const onCaptureFinished = (url, error) => {
+		const request = captureRequest;
+		const sink = captureSink;
+		captureRequest = void 0;
+		captureSink = void 0;
+		if (!request || !sink) return;
+		const filePath = url?.path ? String(url.path) : "";
+		if (!(!error || error.userInfo?.objectForKey(AVErrorRecordingSuccessfullyFinishedKey)?.boolValue === true)) {
+			try {
+				if (filePath && File.exists(filePath)) NSFileManager.defaultManager.removeItemAtPathError(filePath, void 0);
+			} catch {}
+			sink.settled({
+				kind: "failed",
+				stage: "capture",
+				issue: emitIssue("captureFailed", "finalize", error?.localizedDescription ?? "Movie recording did not complete", error)
+			});
+			stopSessionIfIdle();
+			return;
+		}
+		const limitReached = limitRequested && error?.code === avErrorMaximumDurationReached;
+		try {
+			const asset = AVURLAsset.assetWithURL(url);
+			const durationSeconds = asset ? CMTimeGetSeconds(asset.duration) : 0;
+			const videoTracks = asset?.tracksWithMediaType(AVMediaTypeVideo);
+			const audioTracks = asset?.tracksWithMediaType(AVMediaTypeAudio);
+			const track = videoTracks && videoTracks.count > 0 ? videoTracks.objectAtIndex(0) : null;
+			if (!track || !(durationSeconds > 0)) {
+				try {
+					if (filePath && File.exists(filePath)) NSFileManager.defaultManager.removeItemAtPathError(filePath, void 0);
+				} catch {}
+				sink.settled({
+					kind: "failed",
+					stage: "capture",
+					issue: emitIssue("noMedia", "finalize", "The finalized movie contains no playable media")
+				});
+				stopSessionIfIdle();
+				return;
+			}
+			const naturalSize = track.naturalSize;
+			const transform = track.preferredTransform;
+			const orientation = request.orientation && request.orientation !== "unspecified" ? request.orientation : orientationFromTransform(transform);
+			const rotated = Math.abs(transform.b) === 1 && Math.abs(transform.c) === 1;
+			const width = rotated ? naturalSize.height : naturalSize.width;
+			const height = rotated ? naturalSize.width : naturalSize.height;
+			if (request.audio && !(audioTracks && audioTracks.count > 0)) {
+				try {
+					if (filePath && File.exists(filePath)) NSFileManager.defaultManager.removeItemAtPathError(filePath, void 0);
+				} catch {}
+				sink.settled({
+					kind: "failed",
+					stage: "capture",
+					issue: emitIssue("captureFailed", "finalize", "Requested audio track is missing from the finalized movie")
+				});
+				stopSessionIfIdle();
+				return;
+			}
+			sink.settled({
+				kind: "clip",
+				output: {
+					kind: "nativeFile",
+					resourceId: `file:${filePath}`,
+					fileUrl: `file://${filePath}`
+				},
+				mimeType: "video/quicktime",
+				durationMs: Math.round(durationSeconds * 1e3),
+				width,
+				height,
+				orientation,
+				hasAudio: request.audio && (audioTracks?.count ?? 0) > 0,
+				limitReached
+			});
+		} catch (cause) {
+			sink.settled({
+				kind: "failed",
+				stage: "finalization",
+				issue: emitIssue("finalizationFailed", "finalize", cause instanceof Error ? cause.message : String(cause), cause)
+			});
+		}
+		stopSessionIfIdle();
+	};
+	return {
+		platform: "ios",
+		supported: typeof AVCaptureMovieFileOutput !== "undefined",
+		checkPermission: async (kind) => {
+			if (!hasUsageDeclaration(kind)) return "unknown";
+			return readPermission(kind);
+		},
+		requestPermission: (kind) => requestAccess(kind),
+		getCapabilities: async () => {
+			const devices = listCameras();
+			const cameras = devices.map((entry) => ({
+				id: entry.uniqueID,
+				label: entry.localizedName ?? entry.uniqueID,
+				facing: facingForPosition(entry.position)
+			}));
+			const selected = device ?? selectDevice(currentConfig.camera, devices);
+			const profile = selected ? (() => {
+				const probe = AVCaptureSession.new();
+				probe.beginConfiguration();
+				const supported = supportedPreset(probe, selected);
+				probe.commitConfiguration();
+				return supported ? {
+					width: 1280,
+					height: 720,
+					frameRate: 30
+				} : standardProfile(selected);
+			})() : {
+				width: 1280,
+				height: 720,
+				frameRate: 30
+			};
+			const available = cameras.length > 0;
+			return {
+				supported: typeof AVCaptureMovieFileOutput !== "undefined" && available,
+				reason: !available ? "No camera device is available on this host" : typeof AVCaptureMovieFileOutput === "undefined" ? "Movie file output is unsupported by this runtime" : void 0,
+				available,
+				cameras,
+				profiles: [{
+					profile: "standard",
+					...profile
+				}],
+				audio: typeof AVCaptureDevice.defaultDeviceWithMediaType === "function",
+				orientations: [
+					"portrait",
+					"portraitUpsideDown",
+					"landscapeLeft",
+					"landscapeRight"
+				],
+				durationLimit: "native",
+				elapsedTime: "nativeMedia",
+				output: {
+					mimeType: "video/quicktime",
+					container: "mov",
+					storage: "appPrivateFile",
+					destinationFileUrl: true
+				}
+			};
+		},
+		previewReady: () => previewReadyFlag && !interrupted,
+		attachPreview: (host, listener) => {
+			let target;
+			try {
+				target = ensureSession();
+			} catch (error) {
+				throw error instanceof CameraCaptureError ? error : new CameraCaptureError({
+					kind: "unavailable",
+					operation: "startPreview",
+					message: error instanceof Error ? error.message : String(error),
+					cause: error
+				});
+			}
+			const view = host;
+			const nativeView = view?.ios ?? view?.nativeViewProtected;
+			if (!nativeView?.layer) throw new CameraCaptureError({
+				kind: "invalidArgument",
+				operation: "attachPreview",
+				message: "Camera preview host is unavailable"
+			});
+			const layer = AVCaptureVideoPreviewLayer.layerWithSession(target);
+			layer.videoGravity = AVLayerVideoGravityResizeAspectFill;
+			const connection = layer.connection;
+			if (connection) {
+				connection.automaticallyAdjustsVideoMirroring = false;
+				if (connection.supportsVideoMirroring) connection.videoMirrored = device?.position === captureDevicePositionFront;
+			}
+			nativeView.layer.addSublayer(layer);
+			previewLayer = layer;
+			previewHost = view;
+			const updateFrame = () => {
+				layer.frame = nativeView.bounds;
+			};
+			detachFrame = () => view.off?.("layoutChanged", updateFrame);
+			view.on?.("layoutChanged", updateFrame);
+			updateFrame();
+			target.startRunning();
+			previewReadyFlag = true;
+			observer?.previewReady(true);
+			listener?.onReady?.();
+			return () => {
+				previewReadyFlag = false;
+				view.off?.("layoutChanged", updateFrame);
+				layer.removeFromSuperlayer();
+				previewLayer = void 0;
+				previewHost = void 0;
+				detachFrame = void 0;
+				observer?.previewReady(false);
+				stopSessionIfIdle();
+			};
+		},
+		configure: (next) => {
+			const previous = currentConfig;
+			currentConfig = { ...next };
+			const target = session;
+			if (!target || !device) return;
+			target.beginConfiguration();
+			const wanted = selectDevice(next.camera ?? previous.camera, listCameras());
+			if (wanted && wanted !== device && videoInput) {
+				const input = AVCaptureDeviceInput.deviceInputWithDeviceError(wanted, void 0);
+				if (input && target.canAddInput(input)) {
+					target.removeInput(videoInput);
+					target.addInput(input);
+					videoInput = input;
+					device = wanted;
+				}
+			}
+			if (next.audio === true && readPermission("microphone") === "granted") ensureAudioInput(target);
+			else if (next.audio === false && audioInput) {
+				target.removeInput(audioInput);
+				audioInput = void 0;
+			}
+			target.commitConfiguration();
+		},
+		startCapture: (request, sink) => {
+			const target = session;
+			if (!target || !movieOutput || !device) {
+				sink.settled({
+					kind: "failed",
+					stage: "preparation",
+					issue: emitIssue("unavailable", "startRecording", "The camera session is not running")
+				});
+				return;
+			}
+			if (!hasUsageDeclaration("camera")) {
+				sink.settled({
+					kind: "failed",
+					stage: "preparation",
+					issue: emitIssue("configurationMissing", "startRecording", "Missing NSCameraUsageDescription in the host app's Info.plist")
+				});
+				return;
+			}
+			if (request.audio) {
+				if (!hasUsageDeclaration("microphone")) {
+					sink.settled({
+						kind: "failed",
+						stage: "preparation",
+						issue: emitIssue("configurationMissing", "startRecording", "Missing NSMicrophoneUsageDescription in the host app's Info.plist")
+					});
+					return;
+				}
+				const micStatus = readPermission("microphone");
+				if (micStatus !== "granted") {
+					sink.settled({
+						kind: "failed",
+						stage: "preparation",
+						issue: emitIssue(micStatus === "restricted" ? "permissionRestricted" : "permissionDenied", "startRecording", `Microphone permission is ${micStatus}`, { permission: "microphone" })
+					});
+					return;
+				}
+				if (!audioInput) {
+					target.beginConfiguration();
+					const added = ensureAudioInput(target);
+					target.commitConfiguration();
+					if (!added) {
+						sink.settled({
+							kind: "failed",
+							stage: "preparation",
+							issue: emitIssue("unavailable", "startRecording", "No audio input device is available")
+						});
+						return;
+					}
+				}
+			}
+			const connection = movieOutput.connectionWithMediaType(AVMediaTypeVideo);
+			if (request.orientation) {
+				const angle = orientationToRotationAngle(request.orientation);
+				const legacy = orientationToLegacyConstant(request.orientation);
+				let applied = false;
+				if (connection && angle !== void 0 && typeof connection.isVideoRotationAngleSupported === "function" && connection.isVideoRotationAngleSupported(angle)) {
+					connection.videoRotationAngle = angle;
+					applied = true;
+				} else if (connection && legacy !== void 0 && connection.supportsVideoOrientation) {
+					connection.videoOrientation = legacy;
+					applied = true;
+				}
+				if (!applied) {
+					sink.settled({
+						kind: "failed",
+						stage: "preparation",
+						issue: emitIssue("unsupportedConfiguration", "startRecording", `Orientation '${request.orientation}' is not supported by this connection`)
+					});
+					return;
+				}
+			}
+			if (connection) {
+				connection.automaticallyAdjustsVideoMirroring = false;
+				if (connection.supportsVideoMirroring) connection.videoMirrored = false;
+			}
+			let filePath;
+			if (request.destinationPath) {
+				const directory = request.destinationPath.slice(0, request.destinationPath.lastIndexOf("/"));
+				if (!File.exists(directory) || File.exists(request.destinationPath)) {
+					sink.settled({
+						kind: "failed",
+						stage: "preparation",
+						issue: emitIssue("destinationUnavailable", "startRecording", File.exists(request.destinationPath) ? "destinationFileUrl already exists" : "destinationFileUrl directory does not exist")
+					});
+					return;
+				}
+				filePath = request.destinationPath;
+			} else try {
+				filePath = path.join(recordingsDirectory(), `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.mov`);
+			} catch (cause) {
+				sink.settled({
+					kind: "failed",
+					stage: "preparation",
+					issue: emitIssue("destinationUnavailable", "startRecording", cause instanceof Error ? cause.message : String(cause), cause)
+				});
+				return;
+			}
+			if (freeDiskBytes() < minFreeDiskBytes) {
+				sink.settled({
+					kind: "failed",
+					stage: "preparation",
+					issue: emitIssue("insufficientStorage", "startRecording", "Not enough local storage for a movie recording")
+				});
+				return;
+			}
+			limitRequested = request.maximumDurationMs !== void 0;
+			movieOutput.maxRecordedDuration = request.maximumDurationMs !== void 0 ? CMTimeMakeWithSeconds(request.maximumDurationMs / 1e3, 600) : noDurationLimit ?? movieOutput.maxRecordedDuration;
+			captureRequest = request;
+			captureSink = sink;
+			try {
+				movieOutput.startRecordingToOutputFileURLRecordingDelegate(NSURL.fileURLWithPath(filePath), recordingDelegate);
+			} catch (cause) {
+				captureRequest = void 0;
+				captureSink = void 0;
+				sink.settled({
+					kind: "failed",
+					stage: "preparation",
+					issue: emitIssue("captureFailed", "startRecording", cause instanceof Error ? cause.message : String(cause), cause)
+				});
+			}
+		},
+		stopCapture: () => {
+			try {
+				if (movieOutput?.recording) movieOutput.stopRecording();
+			} catch {}
+		},
+		elapsedMs: () => {
+			try {
+				const duration = movieOutput?.recordedDuration;
+				if (!duration) return 0;
+				return Math.max(0, Math.round(CMTimeGetSeconds(duration) * 1e3));
+			} catch {
+				return 0;
+			}
+		},
+		openOutput: async (output) => {
+			if (output.kind !== "nativeFile") throw new CameraCaptureError({
+				kind: "invalidArgument",
+				operation: "openOutput",
+				message: "Only file-backed output can be opened on iOS"
+			});
+			const filePath = output.fileUrl.slice(7);
+			if (!File.exists(filePath)) throw new CameraCaptureError({
+				kind: "unavailable",
+				operation: "openOutput",
+				message: `Movie file is missing at ${output.fileUrl}`
+			});
+			return {
+				url: output.fileUrl,
+				fileUrl: output.fileUrl,
+				release: () => {}
+			};
+		},
+		release: async () => {
+			previewReadyFlag = false;
+			detachFrame?.();
+			detachFrame = void 0;
+			if (previewHost) try {
+				previewLayer?.removeFromSuperlayer();
+			} catch {}
+			previewHost = void 0;
+			previewLayer = void 0;
+			captureRequest = void 0;
+			captureSink = void 0;
+			clearObservers();
+			try {
+				session?.stopRunning();
+			} catch {}
+			session = void 0;
+			videoInput = void 0;
+			audioInput = void 0;
+			movieOutput = void 0;
+			device = void 0;
+		},
+		onPreviewDetached: () => {
+			stopSessionIfIdle();
+		},
+		setObserver: (next) => {
+			observer = next;
+		}
+	};
+}
+//#endregion
+export { createSessionBackend };