@octane-xplat/camera 0.14.0 → 0.15.0

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

@@ -1,905 +0,0 @@
-import { CameraCaptureError } from "./types.js";
-import { Application } from "@nativescript/core";
-//#region src/session-backend.windows.ts
-/** Windows adapter: one `Windows.Media.Capture.MediaCapture` shared between a
-*  `Microsoft.UI.Xaml.Controls.CaptureElement` preview and a single
-*  `StartRecordToStorageFileAsync` capture attempt. Everything reaches WinRT
-*  through the runtime's dynamic projection (`Windows`/`Microsoft`/`NSWinRT`
-*  globals), so every call site is guarded — a projection miss reports
-*  `unsupported`/`unavailable`, never fabricated capture. */
-var deviceAccessUnspecified = 0;
-var deviceAccessAllowed = 1;
-var deviceAccessDeniedByUser = 2;
-var deviceAccessDeniedBySystem = 3;
-var appCapabilityDeniedBySystem = 0;
-var appCapabilityNotDeclaredByApp = 1;
-var appCapabilityDeniedByUser = 2;
-var appCapabilityUserPromptRequired = 3;
-var appCapabilityAllowed = 4;
-var panelFront = 1;
-var panelBack = 2;
-var captureModeVideo = 0;
-var captureModeAudioAndVideo = 2;
-var recordRotationNone = 0;
-var recordRotation90 = 1;
-var recordRotation180 = 2;
-var recordRotation270 = 3;
-var collisionGenerateUniqueName = 0;
-var collisionFailIfExists = 1;
-var collisionOpenIfExists = 2;
-var fileOrientationNormal = 0;
-var fileOrientation90 = 90;
-var fileOrientation180 = 180;
-var fileOrientation270 = 270;
-var capabilityNameFor = (kind) => kind === "camera" ? "webcam" : "microphone";
-var minFreeDiskBytes = 67108864;
-var projection = () => {
-	const host = globalThis;
-	return {
-		Windows: host.Windows,
-		Microsoft: host.Microsoft,
-		NSWinRT: host.NSWinRT
-	};
-};
-var error = (kind, operation, message, cause) => new CameraCaptureError({
-	kind,
-	operation,
-	message,
-	cause
-});
-var issue = (kind, operation, message, extra) => ({
-	kind,
-	operation,
-	message,
-	...extra
-});
-/** AppCapabilityAccessStatus → portable permission. `notDeclared` is a
-*  setup error, not a status — callers surface `configurationMissing`. */
-var accessStatusToPermission = (status) => {
-	switch (status) {
-		case appCapabilityAllowed: return "granted";
-		case appCapabilityDeniedByUser: return "denied";
-		case appCapabilityDeniedBySystem: return "restricted";
-		case appCapabilityUserPromptRequired: return "notDetermined";
-		case appCapabilityNotDeclaredByApp: return "notDeclared";
-		default: return "unknown";
-	}
-};
-/** DeviceAccessStatus → portable permission for hosts without AppCapability. */
-var deviceAccessStatusToPermission = (status) => {
-	switch (status) {
-		case deviceAccessAllowed: return "granted";
-		case deviceAccessDeniedByUser: return "denied";
-		case deviceAccessDeniedBySystem: return "restricted";
-		case deviceAccessUnspecified: return "notDetermined";
-		default: return "unknown";
-	}
-};
-/** Enclosure panel → facing. Desktop cameras often report no panel — an
-*  external webcam never fabricates front/back semantics. */
-var panelToFacing = (panel) => panel === panelFront ? "front" : panel === panelBack ? "back" : void 0;
-/** Stored display rotation (degrees CW) → cardinal orientation, matching the
-*  iOS transform mapping. Missing or unrecognized values stay `unspecified`. */
-var videoOrientationToOrientation = (degrees) => {
-	switch (degrees) {
-		case fileOrientation90: return "portrait";
-		case fileOrientation180: return "landscapeLeft";
-		case fileOrientation270: return "portraitUpsideDown";
-		case fileOrientationNormal: return "landscapeRight";
-		default: return "unspecified";
-	}
-};
-var orientationToRotation = (orientation) => orientation === "portrait" ? recordRotation90 : orientation === "portraitUpsideDown" ? recordRotation270 : orientation === "landscapeLeft" ? recordRotation180 : orientation === "landscapeRight" ? recordRotationNone : void 0;
-/** Camera selection: explicit deviceId wins; front/back match the enclosure
-*  panel; `default` takes the OS-preferred camera then the first device. */
-var selectCameraDevice = (camera, devices, defaultId) => {
-	if (camera && typeof camera === "object" && "deviceId" in camera) return devices.find((entry) => entry.id === camera.deviceId);
-	if (camera === "front" || camera === "back") return devices.find((entry) => entry.facing === camera);
-	return devices.find((entry) => entry.id === defaultId) ?? devices.find((entry) => entry.facing === "back") ?? devices[0];
-};
-/** Pick the standard profile: 1280x720 @ 30 fps when the source offers it,
-*  otherwise the smallest stream then lowest frame rate. The selected
-*  combination is disclosed — never an idealized 720p claim. */
-var chooseStandardProfile = (profiles) => {
-	if (!profiles.length) return;
-	const exact = profiles.find((entry) => entry.width === 1280 && entry.height === 720 && Math.round(entry.frameRate) === 30);
-	if (exact) return exact;
-	return [...profiles].sort((a, b) => {
-		const areaDelta = a.width * a.height - b.width * b.height;
-		if (areaDelta !== 0) return areaDelta;
-		return a.frameRate - b.frameRate;
-	})[0];
-};
-/** Classify a native failure without depending on projected error shapes.
-*  HRESULTs surface as `number`/`hresult`; MediaCapture failures also carry a
-*  numeric `code`. */
-var captureFailureKind = (cause) => {
-	const code = Number(cause?.number ?? cause?.hresult ?? cause?.code ?? NaN);
-	const message = String(cause?.message ?? cause ?? "").toLowerCase();
-	if (code === -2147024891 || /access is denied|unauthorizedaccess|e_accessdenied/.test(message)) return "permissionDenied";
-	if (code === -2147024814 || /sharing violation|in use|0x800700aa/.test(message)) return "unavailable";
-	if (/no capture devices|device (is )?not (available|found|ready)|cannot find/.test(message)) return "unavailable";
-	if (/quota|disk|storage|no space|insufficient/.test(message)) return "insufficientStorage";
-	return "captureFailed";
-};
-/** WinRT TimeSpan marshals as `{ Duration: bigint|number }` of 100-ns ticks;
-*  some projections surface the raw tick count. */
-var timeSpanToMs = (value) => {
-	const ticks = typeof value === "bigint" ? Number(value) : typeof value === "number" ? value : Number(value?.Duration ?? value?.duration ?? NaN);
-	return Number.isFinite(ticks) ? ticks / 1e4 : NaN;
-};
-var toPromise = async (op) => {
-	const { NSWinRT } = projection();
-	if (NSWinRT?.toPromise && op != null) return NSWinRT.toPromise(op);
-	if (op?.done) return new Promise((resolve, reject) => {
-		try {
-			op.done(resolve, reject);
-		} catch (cause) {
-			reject(cause);
-		}
-	});
-	return op;
-};
-var vectorToArray = (items) => {
-	const result = [];
-	const size = Number(items?.Size ?? items?.Count ?? 0);
-	for (let index = 0; index < size; index += 1) result.push(items.GetAt(index));
-	return result;
-};
-/** The first backend that initializes a device claims it — a new owner
-*  cannot seize the same hardware while the previous one is finalizing. */
-var claimedDevices = /* @__PURE__ */ new Map();
-var normalizePath = (value) => {
-	let next = value.replace(/\//g, "\\");
-	next = next.replace(/^\\(?=[A-Za-z]:)/, "");
-	return next;
-};
-var fileUrlForPath = (value) => `file:///${value.replace(/\\/g, "/").replace(/^\/+/, "")}`;
-function createSessionBackend(config) {
-	let currentConfig = { ...config };
-	let observer;
-	let host;
-	let listener;
-	let capture;
-	let captureElement;
-	let captureDevice;
-	let captureAudioMode = false;
-	let previewReadyFlag = false;
-	let interrupted = false;
-	let released = false;
-	let generation = 0;
-	let watcher;
-	let watcherDelegates = [];
-	let captureDelegates = [];
-	let sink;
-	let request;
-	let recordFile;
-	let recordStartedAt = 0;
-	let wantStop = false;
-	let finalizing = false;
-	const lease = {};
-	const projectionAvailable = () => {
-		const { Windows, Microsoft } = projection();
-		return !!(Windows?.Media?.Capture?.MediaCapture && Windows?.Media?.Capture?.MediaCaptureInitializationSettings && Windows?.Devices?.Enumeration?.DeviceInformation && Windows?.Storage?.ApplicationData && Microsoft?.UI?.Xaml?.Controls?.CaptureElement);
-	};
-	const markReady = (value) => {
-		if (previewReadyFlag === value) return;
-		previewReadyFlag = value;
-		observer?.previewReady(value);
-	};
-	const appCapability = (kind) => {
-		try {
-			return projection().Windows?.Security?.Authorization?.AppCapabilityAccess?.AppCapability?.Create(capabilityNameFor(kind));
-		} catch {
-			return;
-		}
-	};
-	const deviceAccessInfo = (kind) => {
-		try {
-			const enumeration = projection().Windows?.Devices?.Enumeration;
-			const deviceClass = kind === "camera" ? enumeration?.DeviceClass?.VideoCapture : enumeration?.DeviceClass?.AudioCapture;
-			return deviceClass === void 0 ? void 0 : enumeration?.DeviceAccessInformation?.CreateFromDeviceClass(deviceClass);
-		} catch {
-			return;
-		}
-	};
-	const checkPermission = async (kind) => {
-		const capability = appCapability(kind);
-		if (capability) try {
-			const mapped = accessStatusToPermission(capability.CheckAccess());
-			return mapped === "notDeclared" ? "unknown" : mapped;
-		} catch {}
-		const info = deviceAccessInfo(kind);
-		if (info) try {
-			return deviceAccessStatusToPermission(info.CurrentStatus);
-		} catch {
-			return "unknown";
-		}
-		return "unknown";
-	};
-	let permissionChain = Promise.resolve();
-	const requestPermission = (kind) => {
-		const result = permissionChain.then(async () => {
-			const status = await checkPermission(kind);
-			if (status !== "notDetermined") {
-				if (status === "unknown") try {
-					if (accessStatusToPermission(appCapability(kind)?.CheckAccess()) === "notDeclared") throw error("configurationMissing", "requestPermission", `Missing '${capabilityNameFor(kind)}' device capability in the host app's Package.appxmanifest`, { permission: kind });
-				} catch (cause) {
-					if (cause instanceof CameraCaptureError) throw cause;
-				}
-				return status;
-			}
-			const capability = appCapability(kind);
-			if (!capability?.RequestAccessAsync) return "unknown";
-			try {
-				const next = accessStatusToPermission(await toPromise(capability.RequestAccessAsync()));
-				return next === "notDeclared" ? "unknown" : next;
-			} catch (cause) {
-				throw error("unavailable", "requestPermission", `The system ${kind} permission request could not run`, cause);
-			}
-		});
-		permissionChain = result.catch(() => {});
-		return result;
-	};
-	const listDevices = async () => {
-		const enumeration = projection().Windows?.Devices?.Enumeration;
-		const deviceClass = enumeration?.DeviceClass?.VideoCapture;
-		if (!enumeration?.DeviceInformation?.FindAllAsync || deviceClass === void 0) return [];
-		return vectorToArray(await toPromise(enumeration.DeviceInformation.FindAllAsync(deviceClass))).map((device) => ({
-			id: String(device?.Id ?? device?.id ?? ""),
-			label: String(device?.Name ?? device?.name ?? device?.Id ?? ""),
-			facing: panelToFacing(Number(device?.EnclosureLocation?.Panel ?? device?.EnclosureLocation?.panel))
-		}));
-	};
-	const listAudioDevices = async () => {
-		try {
-			const enumeration = projection().Windows?.Devices?.Enumeration;
-			const deviceClass = enumeration?.DeviceClass?.AudioCapture;
-			if (!enumeration?.DeviceInformation?.FindAllAsync || deviceClass === void 0) return 0;
-			const found = await toPromise(enumeration.DeviceInformation.FindAllAsync(deviceClass));
-			return Number(found?.Size ?? found?.Count ?? 0);
-		} catch {
-			return 0;
-		}
-	};
-	const defaultDeviceId = () => {
-		try {
-			const devices = projection().Windows?.Media?.Devices;
-			const kind = devices?.AudioVideoCaptureDeviceKind?.Video;
-			const id = devices?.MediaDevice?.GetDefaultVideoCaptureId?.(kind);
-			return typeof id === "string" && id ? id : void 0;
-		} catch {
-			return;
-		}
-	};
-	const streamProfiles = (target, streamKind) => {
-		const controller = target?.VideoDeviceController;
-		if (!controller?.GetAvailableMediaStreamProperties || streamKind === void 0) return [];
-		try {
-			return vectorToArray(controller.GetAvailableMediaStreamProperties(streamKind)).map((entry) => ({
-				width: Number(entry?.Width ?? 0),
-				height: Number(entry?.Height ?? 0),
-				frameRate: Number(entry?.FrameRate?.Numerator ?? 0) / Math.max(1, Number(entry?.FrameRate?.Denominator ?? 1)),
-				subtype: typeof entry?.Subtype === "string" ? entry.Subtype : void 0
-			})).filter((entry) => entry.width > 0 && entry.height > 0);
-		} catch {
-			return [];
-		}
-	};
-	const recordStreamProfiles = () => streamProfiles(capture, projection().Windows?.Media?.Capture?.MediaStreamType?.VideoRecord);
-	const detachCaptureDelegates = () => {
-		for (const entry of captureDelegates) try {
-			capture[entry.event] = null;
-		} catch {}
-		captureDelegates = [];
-	};
-	const onCaptureFailed = (_sender, args) => {
-		const message = String(args?.Message ?? args?.message ?? "Camera capture failed");
-		markReady(false);
-		observer?.availability(false);
-		observer?.interruption("began", /in use|denied|access/i.test(message) ? "cameraInUse" : "unknown");
-		if (sink) {
-			sink.finishing(/device|available|found/i.test(message) ? "cameraUnavailable" : "captureError");
-			stopRecording();
-		}
-	};
-	const onRecordLimitationExceeded = () => {
-		sink?.finishing("interrupted");
-		stopRecording();
-	};
-	const attachCaptureDelegates = (target) => {
-		const { NSWinRT } = projection();
-		const subscribe = (event, type, handler) => {
-			try {
-				const delegate = NSWinRT?.asDelegate ? NSWinRT.asDelegate(type, handler) : handler;
-				target[event] = delegate;
-				captureDelegates.push({
-					event,
-					delegate
-				});
-			} catch {
-				try {
-					target[event] = handler;
-					captureDelegates.push({
-						event,
-						delegate: handler
-					});
-				} catch {}
-			}
-		};
-		subscribe("Failed", "Windows.Foundation.TypedEventHandler`2<Windows.Media.Capture.MediaCapture,Windows.Media.Capture.MediaCaptureFailedEventArgs>", onCaptureFailed);
-		subscribe("RecordLimitationExceeded", "Windows.Media.Capture.RecordLimitationExceededEventHandler", onRecordLimitationExceeded);
-	};
-	const stopWatcher = () => {
-		if (!watcher) return;
-		for (const entry of watcherDelegates) try {
-			watcher[entry.event] = null;
-		} catch {}
-		watcherDelegates = [];
-		try {
-			watcher.Stop();
-		} catch {}
-		watcher = void 0;
-	};
-	const ensureWatcher = () => {
-		if (watcher) return;
-		const enumeration = projection().Windows?.Devices?.Enumeration;
-		const deviceClass = enumeration?.DeviceClass?.VideoCapture;
-		if (!enumeration?.DeviceInformation?.CreateWatcher || deviceClass === void 0) return;
-		try {
-			const target = enumeration.DeviceInformation.CreateWatcher(deviceClass);
-			const { NSWinRT } = projection();
-			const subscribe = (event, type, handler) => {
-				const delegate = NSWinRT?.asDelegate ? NSWinRT.asDelegate(type, handler) : handler;
-				target[event] = delegate;
-				watcherDelegates.push({
-					event,
-					delegate
-				});
-			};
-			subscribe("Removed", "Windows.Foundation.TypedEventHandler`2<Windows.Devices.Enumeration.DeviceWatcher,Windows.Devices.Enumeration.DeviceInformationUpdate>", (_sender, update) => {
-				const id = String(update?.Id ?? update?.id ?? "");
-				if (!id || id === captureDevice?.id) observer?.availability(false);
-			});
-			subscribe("Added", "Windows.Foundation.TypedEventHandler`2<Windows.Devices.Enumeration.DeviceWatcher,Windows.Devices.Enumeration.DeviceInformation>", () => observer?.availability(true));
-			target.Start();
-			watcher = target;
-		} catch {
-			watcher = void 0;
-			watcherDelegates = [];
-		}
-	};
-	const applyStreamProperties = async (target) => {
-		const streamType = projection().Windows?.Media?.Capture?.MediaStreamType;
-		const controller = target?.VideoDeviceController;
-		const candidates = streamProfiles(target, streamType?.VideoRecord);
-		const chosen = chooseStandardProfile(candidates);
-		if (!controller?.SetMediaStreamPropertiesAsync || !chosen || !streamType) return;
-		const props = candidates.length ? vectorToArray(controller.GetAvailableMediaStreamProperties(streamType.VideoRecord)).find((entry) => Number(entry?.Width) === chosen.width && Number(entry?.Height) === chosen.height) : void 0;
-		if (!props) return;
-		try {
-			await toPromise(controller.SetMediaStreamPropertiesAsync(streamType.VideoRecord, props));
-			try {
-				await toPromise(controller.SetMediaStreamPropertiesAsync(streamType.VideoPreview, props));
-			} catch {}
-		} catch {}
-	};
-	const releaseClaim = () => {
-		if (captureDevice && claimedDevices.get(captureDevice.id) === lease) claimedDevices.delete(captureDevice.id);
-	};
-	const closeCapture = () => {
-		detachCaptureDelegates();
-		releaseClaim();
-		const target = capture;
-		capture = void 0;
-		captureDevice = void 0;
-		captureAudioMode = false;
-		if (!target) return;
-		try {
-			target.Close();
-		} catch {
-			try {
-				target.Dispose();
-			} catch {}
-		}
-	};
-	const ensureCapture = async () => {
-		const epoch = generation;
-		if (capture) return capture;
-		const { Windows } = projection();
-		const devices = await listDevices();
-		const selected = selectCameraDevice(currentConfig.camera, devices, defaultDeviceId());
-		if (!selected) throw error("unavailable", "startPreview", "No camera device is available");
-		const owner = claimedDevices.get(selected.id);
-		if (owner && owner !== lease) throw error("busy", "startPreview", "Another camera session still owns this device");
-		const settings = new Windows.Media.Capture.MediaCaptureInitializationSettings();
-		settings.VideoDeviceId = selected.id;
-		settings.StreamingCaptureMode = currentConfig.audio === true ? captureModeAudioAndVideo : captureModeVideo;
-		const target = new Windows.Media.Capture.MediaCapture();
-		try {
-			await toPromise(target.InitializeAsync(settings));
-		} catch (cause) {
-			try {
-				target.Close();
-			} catch {}
-			throw error(captureFailureKind(cause), "startPreview", "The camera could not be initialized", cause);
-		}
-		if (epoch !== generation || released) {
-			try {
-				target.Close();
-			} catch {}
-			throw error("unavailable", "startPreview", "The camera session was released");
-		}
-		capture = target;
-		captureDevice = selected;
-		captureAudioMode = currentConfig.audio === true;
-		claimedDevices.set(selected.id, lease);
-		attachCaptureDelegates(target);
-		ensureWatcher();
-		await applyStreamProperties(target);
-		try {
-			if (selected.facing === "front" && typeof target.SetPreviewMirroring === "function") target.SetPreviewMirroring(true);
-		} catch {}
-		return target;
-	};
-	const activate = async () => {
-		const epoch = ++generation;
-		try {
-			const target = await ensureCapture();
-			if (!captureElement || epoch !== generation) return;
-			try {
-				captureElement.Source = target;
-			} catch (cause) {
-				throw error("unavailable", "startPreview", "The preview element rejected the source", cause);
-			}
-			await toPromise(target.StartPreviewAsync());
-			if (epoch !== generation) return;
-			markReady(true);
-			listener?.onReady?.();
-		} catch (cause) {
-			if (epoch === generation) {
-				markReady(false);
-				listener?.onError?.(cause instanceof CameraCaptureError ? cause : error("unavailable", "startPreview", "Camera preview could not start", cause));
-			}
-		}
-	};
-	const deactivate = async () => {
-		generation += 1;
-		markReady(false);
-		const target = capture;
-		if (captureElement) try {
-			captureElement.Source = null;
-		} catch {}
-		if (target && !sink) try {
-			await toPromise(target.StopPreviewAsync());
-		} catch {}
-	};
-	const recordingsFolder = async () => {
-		const folder = (projection().Windows?.Storage)?.ApplicationData?.Current?.LocalFolder;
-		if (!folder?.CreateFolderAsync) throw error("destinationUnavailable", "startRecording", "App-private storage is unavailable");
-		return toPromise(folder.CreateFolderAsync("octane-camera", collisionOpenIfExists));
-	};
-	const reserveDestination = async (destinationPath) => {
-		const storage = projection().Windows?.Storage;
-		if (!destinationPath) {
-			const folder = await recordingsFolder();
-			const name = `clip-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.mp4`;
-			return toPromise(folder.CreateFileAsync(name, collisionGenerateUniqueName));
-		}
-		const filePath = normalizePath(destinationPath);
-		const directory = filePath.slice(0, filePath.lastIndexOf("\\"));
-		const name = filePath.slice(filePath.lastIndexOf("\\") + 1);
-		if (!directory || !name) throw error("destinationUnavailable", "startRecording", "destinationFileUrl is not a file path");
-		const tempPath = String(storage?.ApplicationData?.Current?.TemporaryFolder?.Path ?? "");
-		if (tempPath && filePath.toLowerCase().startsWith(tempPath.toLowerCase())) throw error("destinationUnavailable", "startRecording", "Temporary storage does not satisfy durable output");
-		return toPromise((await toPromise(storage.StorageFolder.GetFolderFromPathAsync(directory)).catch((cause) => {
-			throw error("destinationUnavailable", "startRecording", "destinationFileUrl directory is not writable", cause);
-		})).CreateFileAsync(name, collisionFailIfExists)).catch((cause) => {
-			throw error("destinationUnavailable", "startRecording", "destinationFileUrl already exists or cannot be created", cause);
-		});
-	};
-	const freeDiskBytes = async () => {
-		try {
-			const folder = projection().Windows?.Storage?.ApplicationData?.Current?.LocalFolder;
-			const result = await toPromise(folder.Properties.RetrievePropertiesAsync(["System.FreeSpace"]));
-			const value = result?.["System.FreeSpace"] ?? result?.Lookup?.("System.FreeSpace");
-			return Number.isFinite(Number(value)) ? Number(value) : Number.MAX_SAFE_INTEGER;
-		} catch {
-			return Number.MAX_SAFE_INTEGER;
-		}
-	};
-	const removeFileQuietly = async (file) => {
-		if (!file) return;
-		try {
-			await toPromise(file.DeleteAsync());
-		} catch {}
-	};
-	const nativeVideoMetadata = async (file, audioRequested) => {
-		const { Windows } = projection();
-		const basic = await toPromise(file.GetBasicPropertiesAsync());
-		if (!(Number(basic?.Size ?? 0) > 0)) throw error("noMedia", "finalize", "The recorder produced an empty movie file");
-		const video = await toPromise(file.Properties.GetVideoPropertiesAsync());
-		const width = Number(video?.Width ?? 0);
-		const height = Number(video?.Height ?? 0);
-		let durationMs = timeSpanToMs(video?.Duration);
-		let hasAudio = false;
-		let audioKnown = true;
-		try {
-			const source = Windows.Media.Core.MediaSource.CreateFromStorageFile(file);
-			const audioTracks = new Windows.Media.Playback.MediaPlaybackItem(source)?.AudioTracks;
-			hasAudio = Number(audioTracks?.Size ?? audioTracks?.Count ?? 0) > 0;
-			if (!Number.isFinite(durationMs) || durationMs <= 0) durationMs = timeSpanToMs(source?.Duration);
-		} catch {
-			audioKnown = false;
-		}
-		if (audioRequested && !audioKnown) throw error("finalizationFailed", "finalize", "The audio track could not be verified in the finalized movie");
-		return {
-			durationMs,
-			width,
-			height,
-			hasAudio: audioKnown && hasAudio,
-			orientation: videoOrientationToOrientation(Number(video?.Orientation))
-		};
-	};
-	const mediabunnyMetadata = async (file) => {
-		const { Windows } = projection();
-		const buffer = await toPromise(Windows.Storage.FileIO.ReadBufferAsync(file));
-		const length = Number(buffer?.Length ?? 0);
-		if (!(length > 0)) throw error("noMedia", "finalize", "The recorder produced an empty movie file");
-		const reader = Windows.Storage.Streams.DataReader.FromBuffer(buffer);
-		const bytes = new Uint8Array(length);
-		reader.ReadBytes(bytes);
-		const { BufferSource, BlobSource, Input, MP4 } = await import("mediabunny");
-		const input = new Input({
-			source: new (BufferSource ?? BlobSource)(bytes),
-			formats: [MP4]
-		});
-		try {
-			const video = await input.getPrimaryVideoTrack();
-			if (!video) throw error("noMedia", "finalize", "The movie contains no video track");
-			const audio = await input.getPrimaryAudioTrack();
-			const hasAudio = audio !== null && await audio.computeDuration() > 0;
-			return {
-				durationMs: await input.computeDuration() * 1e3,
-				width: await video.getDisplayWidth(),
-				height: await video.getDisplayHeight(),
-				hasAudio,
-				orientation: "unspecified"
-			};
-		} finally {
-			input.dispose();
-		}
-	};
-	const teardown = () => {
-		if (!host) deactivate().then(() => {
-			if (!host && !sink) closeCapture();
-		});
-	};
-	const finishWithError = (stage, cause) => {
-		const target = sink;
-		sink = void 0;
-		request = void 0;
-		finalizing = false;
-		wantStop = false;
-		recordStartedAt = 0;
-		const file = recordFile;
-		recordFile = void 0;
-		removeFileQuietly(file);
-		target?.settled({
-			kind: "failed",
-			stage,
-			issue: cause
-		});
-		teardown();
-	};
-	const settleClip = async (file) => {
-		const target = sink;
-		const take = request;
-		if (!target || !take) return;
-		try {
-			let metadata;
-			try {
-				metadata = await nativeVideoMetadata(file, take.audio);
-			} catch (nativeCause) {
-				if (nativeCause instanceof CameraCaptureError && nativeCause.kind === "noMedia") throw nativeCause;
-				metadata = await mediabunnyMetadata(file);
-			}
-			if (!(metadata.durationMs > 0) || !(metadata.width > 0) || !(metadata.height > 0)) throw error("noMedia", "finalize", "The finalized movie has no usable video media");
-			if (take.audio && !metadata.hasAudio) throw error("captureFailed", "finalize", "Requested audio is absent from the finalized movie");
-			const filePath = String(file?.Path ?? "");
-			sink = void 0;
-			request = void 0;
-			recordFile = void 0;
-			finalizing = false;
-			wantStop = false;
-			target.settled({
-				kind: "clip",
-				output: {
-					kind: "nativeFile",
-					resourceId: `file:${filePath}`,
-					fileUrl: fileUrlForPath(filePath)
-				},
-				mimeType: "video/mp4",
-				durationMs: Math.round(metadata.durationMs),
-				width: metadata.width,
-				height: metadata.height,
-				orientation: take.orientation && take.orientation !== "unspecified" ? take.orientation : metadata.orientation,
-				hasAudio: take.audio && metadata.hasAudio
-			});
-		} catch (cause) {
-			sink = void 0;
-			request = void 0;
-			recordFile = void 0;
-			finalizing = false;
-			wantStop = false;
-			removeFileQuietly(file);
-			target.settled({
-				kind: "failed",
-				stage: "finalization",
-				issue: cause instanceof CameraCaptureError ? cause : issue("finalizationFailed", "finalize", cause instanceof Error ? cause.message : String(cause), { cause })
-			});
-		}
-		recordStartedAt = 0;
-		teardown();
-	};
-	const stopRecording = async () => {
-		const target = capture;
-		const file = recordFile;
-		if (!target || !file || finalizing || recordStartedAt === 0) return;
-		finalizing = true;
-		try {
-			await toPromise(target.StopRecordAsync());
-		} catch (cause) {
-			finishWithError("finalization", error("finalizationFailed", "finalize", "The movie could not be finalized", cause));
-			return;
-		}
-		await settleClip(file);
-	};
-	const onSuspend = () => {
-		interrupted = true;
-		markReady(false);
-		observer?.interruption("began", "background");
-	};
-	const onResume = () => {
-		interrupted = false;
-		observer?.interruption("ended", "background");
-		if (capture) {
-			observer?.availability(true);
-			markReady(!!captureElement);
-		}
-	};
-	let lifecycleBound = false;
-	const bindLifecycle = () => {
-		if (lifecycleBound) return;
-		lifecycleBound = true;
-		try {
-			Application.on(Application.suspendEvent, onSuspend);
-			Application.on(Application.resumeEvent, onResume);
-		} catch {}
-	};
-	const unbindLifecycle = () => {
-		if (!lifecycleBound) return;
-		lifecycleBound = false;
-		try {
-			Application.off(Application.suspendEvent, onSuspend);
-			Application.off(Application.resumeEvent, onResume);
-		} catch {}
-	};
-	return {
-		platform: "windows",
-		get supported() {
-			return projectionAvailable();
-		},
-		checkPermission,
-		requestPermission: async (kind) => {
-			const status = await requestPermission(kind);
-			if (kind === "camera" && status === "granted" && host && !sink && !released && !capture) try {
-				await activate();
-			} catch {}
-			return status;
-		},
-		getCapabilities: async () => {
-			const cameras = (await listDevices()).map((entry) => ({
-				id: entry.id,
-				label: entry.label,
-				facing: entry.facing
-			}));
-			const supported = projectionAvailable() && cameras.length > 0;
-			const cameraStatus = await checkPermission("camera");
-			const available = supported && cameraStatus === "granted";
-			const profile = (capture ? chooseStandardProfile(recordStreamProfiles()) : void 0) ?? {
-				width: 1280,
-				height: 720,
-				frameRate: 30
-			};
-			return {
-				supported,
-				reason: !projectionAvailable() ? "The WinUI camera runtime is unavailable" : cameras.length === 0 ? "No camera device is available on this host" : cameraStatus !== "granted" ? "Camera permission has not been granted" : void 0,
-				available,
-				cameras,
-				profiles: [{
-					profile: "standard",
-					...profile
-				}],
-				audio: await listAudioDevices() > 0,
-				orientations: capture && typeof capture.SetRecordRotationAsync === "function" ? [
-					"portrait",
-					"portraitUpsideDown",
-					"landscapeLeft",
-					"landscapeRight"
-				] : [],
-				durationLimit: "bestEffort",
-				elapsedTime: "estimated",
-				output: {
-					mimeType: "video/mp4",
-					container: "mp4",
-					storage: "appPrivateFile",
-					destinationFileUrl: true
-				}
-			};
-		},
-		previewReady: () => previewReadyFlag && !interrupted,
-		validateStart: (options) => {
-			if (options.orientation && options.orientation !== "unspecified" && (!capture || typeof capture.SetRecordRotationAsync !== "function")) throw error("unsupportedConfiguration", "startRecording", "Fixed cardinal orientation has not been qualified on this Windows source");
-		},
-		attachPreview: (target, callbacks) => {
-			if (released || sink) throw error("invalidState", "attachPreview", "The camera is disposed or finalizing");
-			host = target;
-			listener = callbacks;
-			const view = target;
-			captureElement = view?.nativeViewProtected ?? view;
-			bindLifecycle();
-			checkPermission("camera").then((status) => {
-				if (released || !host) return;
-				if (status !== "granted") {
-					listener?.onError?.(error(status === "restricted" ? "permissionRestricted" : "permissionDenied", "preview", "Request camera permission before activating this preview", { permission: "camera" }));
-					return;
-				}
-				activate();
-			});
-			return () => {
-				host = void 0;
-				listener = void 0;
-				captureElement = void 0;
-				deactivate().then(() => {
-					if (!sink) closeCapture();
-				});
-			};
-		},
-		configure: (next) => {
-			const changed = JSON.stringify(next.camera) !== JSON.stringify(currentConfig.camera) || (next.audio ?? false) !== (currentConfig.audio ?? false);
-			currentConfig = { ...next };
-			if (!changed || !capture) return;
-			const hadPreview = !!captureElement;
-			deactivate().then(() => {
-				closeCapture();
-				if (hadPreview && host) return activate();
-			}).catch(() => {
-				observer?.availability(false);
-			});
-		},
-		startCapture: (take, target) => {
-			if (!capture || !captureDevice || !previewReadyFlag || interrupted) {
-				target.settled({
-					kind: "failed",
-					stage: "preparation",
-					issue: issue("unavailable", "startRecording", "The camera preview is not running")
-				});
-				return;
-			}
-			sink = target;
-			request = take;
-			const active = capture;
-			const run = async () => {
-				if (take.audio) {
-					const micStatus = await checkPermission("microphone");
-					if (micStatus !== "granted") throw error(micStatus === "restricted" ? "permissionRestricted" : micStatus === "unavailable" ? "unavailable" : "permissionDenied", "startRecording", `Microphone permission is ${micStatus}`, { permission: "microphone" });
-					if (!captureAudioMode) throw error("unsupportedConfiguration", "startRecording", "This session was created without audio; configure audio before recording");
-				}
-				if (await freeDiskBytes() < minFreeDiskBytes) throw error("insufficientStorage", "startRecording", "Not enough local storage for a movie recording");
-				if (take.orientation) {
-					const rotation = orientationToRotation(take.orientation);
-					if (rotation === void 0 || typeof active.SetRecordRotationAsync !== "function") throw error("unsupportedConfiguration", "startRecording", `Orientation '${take.orientation}' is not supported by this camera`);
-					try {
-						await toPromise(active.SetRecordRotationAsync(rotation));
-					} catch (cause) {
-						throw error("unsupportedConfiguration", "startRecording", `Orientation '${take.orientation}' was rejected by this camera`, cause);
-					}
-				}
-				const file = await reserveDestination(take.destinationPath);
-				const media = projection().Windows?.Media;
-				const profile = media?.MediaProperties?.MediaEncodingProfile?.CreateMp4(media?.MediaProperties?.VideoEncodingQuality?.Auto ?? 0);
-				if (!profile) {
-					await removeFileQuietly(file);
-					throw error("unsupportedPlatform", "startRecording", "MP4 encoding profiles are unavailable on this host");
-				}
-				const chosen = chooseStandardProfile(recordStreamProfiles());
-				try {
-					if (chosen && profile.Video) {
-						profile.Video.Width = chosen.width;
-						profile.Video.Height = chosen.height;
-						if (profile.Video.FrameRate) {
-							profile.Video.FrameRate.Numerator = Math.max(1, Math.round(chosen.frameRate * 1e3));
-							profile.Video.FrameRate.Denominator = 1e3;
-						}
-					}
-				} catch {}
-				if (!take.audio) try {
-					profile.Audio = null;
-				} catch {}
-				recordFile = file;
-				wantStop = false;
-				try {
-					await toPromise(active.StartRecordToStorageFileAsync(profile, file));
-				} catch (cause) {
-					recordFile = void 0;
-					await removeFileQuietly(file);
-					throw error(captureFailureKind(cause), "startRecording", "MediaCapture could not begin recording", cause);
-				}
-				recordStartedAt = Date.now();
-				const stream = chooseStandardProfile(recordStreamProfiles());
-				const configuration = {
-					cameraId: captureDevice.id,
-					facing: captureDevice.facing,
-					audio: take.audio && captureAudioMode,
-					width: stream?.width ?? chosen?.width ?? 0,
-					height: stream?.height ?? chosen?.height ?? 0,
-					frameRate: stream?.frameRate ?? chosen?.frameRate ?? 0,
-					orientation: take.orientation ?? "unspecified",
-					mimeType: "video/mp4",
-					container: "mp4"
-				};
-				target.started(configuration);
-				if (wantStop) stopRecording();
-			};
-			run().catch((cause) => {
-				finishWithError("preparation", cause instanceof CameraCaptureError ? cause : issue("captureFailed", "startRecording", cause instanceof Error ? cause.message : String(cause), { cause }));
-			});
-		},
-		stopCapture: () => {
-			wantStop = true;
-			stopRecording();
-		},
-		elapsedMs: () => recordStartedAt > 0 ? Math.max(0, Date.now() - recordStartedAt) : 0,
-		openOutput: async (output) => {
-			if (output.kind !== "nativeFile" || output.synthetic) throw error("invalidArgument", "openOutput", "Expected a native Windows movie reference");
-			const filePath = normalizePath(output.fileUrl.slice(7));
-			const storage = projection().Windows?.Storage;
-			try {
-				await toPromise(storage.StorageFile.GetFileFromPathAsync(filePath));
-			} catch (cause) {
-				throw error("unavailable", "openOutput", `Movie file is missing at ${output.fileUrl}`, cause);
-			}
-			return {
-				url: output.fileUrl,
-				fileUrl: output.fileUrl,
-				release: () => {}
-			};
-		},
-		release: async () => {
-			released = true;
-			generation += 1;
-			unbindLifecycle();
-			sink = void 0;
-			request = void 0;
-			wantStop = false;
-			finalizing = false;
-			recordStartedAt = 0;
-			const file = recordFile;
-			recordFile = void 0;
-			removeFileQuietly(file);
-			markReady(false);
-			await deactivate();
-			stopWatcher();
-			closeCapture();
-			host = void 0;
-			captureElement = void 0;
-		},
-		onPreviewDetached: () => {},
-		setObserver: (next) => {
-			observer = next;
-		}
-	};
-}
-//#endregion
-export { accessStatusToPermission, captureFailureKind, chooseStandardProfile, createSessionBackend, deviceAccessStatusToPermission, orientationToRotation, panelToFacing, selectCameraDevice, videoOrientationToOrientation };