@octane-xplat/camera 0.13.0 → 0.14.0

package/dist/native/CameraView.android.js

@@ -1,3 +1,4 @@
+import { attachSessionPreview } from "./session.js";
 import { cameraHardwarePresent, ensureCameraPermission } from "./camera-permission.mobile.js";
 import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from "./layout-child.js";
 import { cx } from "./cx.mobile.js";
@@ -48,6 +49,25 @@ var CameraView = defineUniversalComponent("nativescript", function CameraView(pr
 		nativeView.setCameraActive(active);
 		if (!active) return () => nativeView.setCameraActive(false);
 		const fail = (message) => props.onError?.({ message });
+		if (props.session) {
+			if (props.facing !== void 0) {
+				fail("camera session conflicts with facing");
+				return () => nativeView.setCameraActive(false);
+			}
+			try {
+				const detach = attachSessionPreview(props.session, nativeView, {
+					onReady: props.onReady,
+					onError: (issue) => fail(issue.message)
+				});
+				return () => {
+					detach();
+					nativeView.setCameraActive(false);
+				};
+			} catch (error) {
+				fail(error?.message ?? "camera session error");
+				return () => nativeView.setCameraActive(false);
+			}
+		}
 		if (!cameraHardwarePresent()) {
 			fail("camera unsupported");
 			return () => nativeView.setCameraActive(false);
@@ -89,7 +109,11 @@ var CameraView = defineUniversalComponent("nativescript", function CameraView(pr
 				provider.unbind(preview);
 			} catch {}
 		};
-	}, [active, facing], _h$3);
+	}, [
+		active,
+		facing,
+		props.session
+	], _h$3);
 	useEffect(() => {
 		const view = host.current;
 		if (!view) return;

package/dist/native/CameraView.ios.js

@@ -1,3 +1,4 @@
+import { attachSessionPreview } from "./session.js";
 import { cameraHardwarePresent, ensureCameraPermission } from "./camera-permission.mobile.js";
 import { startCameraPreview } from "./camera-session.ios.js";
 import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from "./layout-child.js";
@@ -29,6 +30,24 @@ var CameraView = defineUniversalComponent("nativescript", function CameraView(pr
 		let disposed = false;
 		let stopPreview;
 		const fail = (message) => props.onError?.({ message });
+		if (props.session) {
+			if (props.facing !== void 0) {
+				fail("camera session conflicts with facing");
+				return;
+			}
+			try {
+				const detach = attachSessionPreview(props.session, view, { onReady: () => {
+					if (!disposed) props.onReady?.();
+				} });
+				return () => {
+					disposed = true;
+					detach();
+				};
+			} catch (error) {
+				fail(error?.message ?? "camera session error");
+				return;
+			}
+		}
 		if (!cameraHardwarePresent()) {
 			fail("camera unsupported");
 			return;
@@ -49,7 +68,11 @@ var CameraView = defineUniversalComponent("nativescript", function CameraView(pr
 			disposed = true;
 			stopPreview?.();
 		};
-	}, [active, facing], _h$3);
+	}, [
+		active,
+		facing,
+		props.session
+	], _h$3);
 	useEffect(() => {
 		const view = host.current;
 		if (!view) return;

package/dist/native/CameraView.windows.js

@@ -0,0 +1,173 @@
+import { attachSessionPreview } from "./session.js";
+import { cameraHardwarePresent, ensureCameraPermission } from "./camera-permission.windows.js";
+import { startCameraPreview } from "./camera-session.windows.js";
+import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from "./layout-child.windows.js";
+import { cx } from "./cx.windows.js";
+import { defineUniversalComponent, hookSlots, registerElement, universalPlan, universalProps, universalValue, useCallback, useEffect, useImperativeHandle, useRef } from "@nativescript-community/octane";
+import { View } from "@nativescript/core";
+//#region src/CameraView.windows.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(5);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
+var _h$3 = /* @__PURE__ */ Symbol(_hs$ + 3);
+var _h$4 = /* @__PURE__ */ Symbol(_hs$ + 4);
+var __octaneUniversalPlan0 = universalPlan("nativescript", {
+	"kind": "host",
+	"type": "gridlayout",
+	"propsSlot": 0,
+	"children": [{
+		"kind": "host",
+		"type": "camerapreview",
+		"props": {
+			"row": 0,
+			"col": 0
+		},
+		"bindings": [["ref", 1]]
+	}]
+});
+var CameraPreview = class extends View {
+	createNativeView() {
+		const { Microsoft } = globalThis;
+		return new Microsoft.UI.Xaml.Controls.CaptureElement();
+	}
+};
+registerElement("camerapreview", CameraPreview);
+var CameraView = defineUniversalComponent("nativescript", function CameraView(props) {
+	const host = useRef(null, _h$0);
+	const active = props.active !== false;
+	const facing = props.facing ?? "back";
+	useImperativeHandle(props.ref, () => ({ native: host.current?.nativeViewProtected }), [], _h$1);
+	const bindHost = useCallback((view) => {
+		host.current = view;
+	}, [], _h$2);
+	useEffect(() => {
+		const view = host.current;
+		if (!view || !active) return;
+		let disposed = false;
+		let stopPreview;
+		const fail = (message) => props.onError?.({ message });
+		if (props.session) {
+			if (props.facing !== void 0) {
+				fail("camera session conflicts with facing");
+				return;
+			}
+			try {
+				const detach = attachSessionPreview(props.session, view, {
+					onReady: () => {
+						if (!disposed) props.onReady?.();
+					},
+					onError: (issue) => {
+						if (!disposed) fail(issue.message);
+					}
+				});
+				return () => {
+					disposed = true;
+					detach();
+				};
+			} catch (error) {
+				fail(error?.message ?? "camera session error");
+				return;
+			}
+		}
+		if (!cameraHardwarePresent()) {
+			fail("camera unsupported");
+			return;
+		}
+		ensureCameraPermission().then(async (granted) => {
+			if (disposed) return;
+			if (!granted) {
+				fail("camera permission denied");
+				return;
+			}
+			try {
+				stopPreview = await startCameraPreview(view, facing, () => {
+					if (!disposed) props.onReady?.();
+				});
+			} catch (error) {
+				if (!disposed) fail(error?.message ?? "camera error");
+			}
+		});
+		return () => {
+			disposed = true;
+			stopPreview?.();
+		};
+	}, [
+		active,
+		facing,
+		props.session
+	], _h$3);
+	useEffect(() => {
+		const view = host.current;
+		if (!view) return;
+		applyEscapeProps(view.nativeViewProtected, props);
+	}, [props.ref, props.windows], _h$4);
+	return universalValue(__octaneUniversalPlan0, [universalProps([
+		[
+			"set",
+			"id",
+			props.id
+		],
+		[
+			"set",
+			"rows",
+			"*"
+		],
+		[
+			"set",
+			"columns",
+			"*"
+		],
+		[
+			"set",
+			"className",
+			cx("vx-layers", "vx-cameraview", props.className)
+		],
+		[
+			"set",
+			"style",
+			{
+				backgroundColor: "#000",
+				...props.style
+			}
+		],
+		["spread", layoutChildProps(props)],
+		[
+			"set",
+			"accessible",
+			props.accessible
+		],
+		[
+			"set",
+			"accessibilityLabel",
+			props.accessibilityLabel
+		],
+		[
+			"set",
+			"accessibilityRole",
+			nativeAccessibilityRole(props.accessibilityRole)
+		],
+		[
+			"set",
+			"accessibilityHint",
+			props.accessibilityHint
+		],
+		[
+			"set",
+			"accessibilityValue",
+			props.accessibilityValue
+		],
+		[
+			"set",
+			"accessibilityState",
+			nativeAccessibilityState(props.accessibilityState)
+		],
+		[
+			"set",
+			"accessibilityLiveRegion",
+			props.accessibilityLiveRegion
+		]
+	]), bindHost]);
+}, { "module": "@nativescript-community/octane" });
+//#endregion
+export { CameraView };

package/dist/native/camera-permission.windows.js

@@ -0,0 +1,43 @@
+//#region src/camera-permission.windows.ts
+/** Windows camera-permission probe for preview-only `CameraView` callers.
+*  Uses `AppCapability` when projected and falls back to
+*  `DeviceAccessInformation`; both are non-prompting checks — only
+*  `RequestAccessAsync` may show the system prompt. */
+var windows = () => globalThis;
+var toPromise = (op) => {
+	const { NSWinRT } = windows();
+	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 Promise.resolve(op);
+};
+function cameraHardwarePresent() {
+	const { Windows, Microsoft } = windows();
+	return !!(Windows?.Media?.Capture?.MediaCapture && Windows?.Devices?.Enumeration?.DeviceInformation && Microsoft?.UI?.Xaml?.Controls?.CaptureElement);
+}
+async function ensureCameraPermission() {
+	try {
+		const { Windows } = windows();
+		const capability = Windows?.Security?.Authorization?.AppCapabilityAccess?.AppCapability?.Create?.("webcam");
+		if (capability) {
+			const status = capability.CheckAccess();
+			if (status === 4) return true;
+			if (status === 3) return await toPromise(capability.RequestAccessAsync()) === 4;
+			return false;
+		}
+		const enumeration = Windows?.Devices?.Enumeration;
+		const deviceClass = enumeration?.DeviceClass?.VideoCapture;
+		const info = deviceClass === void 0 ? void 0 : enumeration?.DeviceAccessInformation?.CreateFromDeviceClass(deviceClass);
+		if (info) return info.CurrentStatus !== 2 && info.CurrentStatus !== 3;
+	} catch {
+		return false;
+	}
+	return false;
+}
+//#endregion
+export { cameraHardwarePresent, ensureCameraPermission };

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

@@ -0,0 +1,78 @@
+//#region src/camera-session.windows.ts
+/** Standalone (non-session) WinUI preview for `CameraView` without a
+*  `session` prop. Owns a private `MediaCapture` bound to a
+*  `CaptureElement`; the returned function stops preview and closes the
+*  device. Session-backed previews share their capture through
+*  `session-backend.windows.ts` instead. */
+var windows = () => globalThis;
+var toPromise = (op) => {
+	const { NSWinRT } = windows();
+	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 Promise.resolve(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;
+};
+/** Attach a MediaCapture preview to the view's `CaptureElement`.
+*  `facing` maps to enclosure panels; desktop cameras without a panel fall
+*  back to the OS default — front/back is a preference, never a fabrication. */
+async function startCameraPreview(view, facing, onReady) {
+	const { Windows } = windows();
+	const enumeration = Windows?.Devices?.Enumeration;
+	const captureApi = Windows?.Media?.Capture;
+	if (!enumeration || !captureApi) throw new Error("camera preview unsupported");
+	const devices = vectorToArray(await toPromise(enumeration.DeviceInformation.FindAllAsync(enumeration.DeviceClass.VideoCapture)));
+	if (!devices.length) throw new Error("camera unavailable");
+	const wantedPanel = facing === "front" ? 1 : 2;
+	const device = devices.find((entry) => Number(entry?.EnclosureLocation?.Panel) === wantedPanel) ?? devices[0];
+	const settings = new captureApi.MediaCaptureInitializationSettings();
+	settings.VideoDeviceId = String(device?.Id ?? device?.id ?? "");
+	settings.StreamingCaptureMode = 0;
+	const capture = new captureApi.MediaCapture();
+	try {
+		await toPromise(capture.InitializeAsync(settings));
+	} catch (cause) {
+		try {
+			capture.Close();
+		} catch {
+			try {
+				capture.Dispose();
+			} catch {}
+		}
+		throw cause instanceof Error ? cause : /* @__PURE__ */ new Error("camera unavailable");
+	}
+	const element = view?.nativeViewProtected ?? view;
+	element.Source = capture;
+	try {
+		if (Number(device?.EnclosureLocation?.Panel) === 1 && typeof capture.SetPreviewMirroring === "function") capture.SetPreviewMirroring(true);
+	} catch {}
+	await toPromise(capture.StartPreviewAsync());
+	onReady?.();
+	return async () => {
+		try {
+			element.Source = null;
+		} catch {}
+		try {
+			await toPromise(capture.StopPreviewAsync());
+		} catch {}
+		try {
+			capture.Close();
+		} catch {
+			try {
+				capture.Dispose();
+			} catch {}
+		}
+	};
+}
+//#endregion
+export { startCameraPreview };

package/dist/native/cx.windows.js

@@ -0,0 +1,9 @@
+//#region src/cx.windows.ts
+/** Imperative `view.className` writes still need a pre-joined string —
+* NativeScript's className setter splits on ' ' only. Normalize arrays here
+* so they stay space separated. */
+function cx(...parts) {
+	return parts.flat(Infinity).filter(Boolean).join(" ");
+}
+//#endregion
+export { cx };

package/dist/native/index.js

@@ -1,2 +1,5 @@
+import { CameraCaptureError } from "./types.js";
+import { createCameraSession } from "./session.js";
+import { createMemoryCameraStorage, createSyntheticCameraSession } from "./synthetic-session.js";
 import { CameraView } from "./src/CameraView";
-export { CameraView };
+export { CameraCaptureError, CameraView, createCameraSession, createMemoryCameraStorage, createSyntheticCameraSession };

package/dist/native/layout-child.windows.js

@@ -0,0 +1,53 @@
+//#region src/layout-child.windows.ts
+/** Windows twins of the layout-child helpers — the unsuffixed module
+*  resolves the platform escape bag through `isIOS`, which has no Windows
+*  branch. Pure helpers are re-declared here to keep divergence at the file
+*  boundary. */
+function layoutChildProps(props) {
+	const result = {};
+	for (const key of [
+		"row",
+		"col",
+		"rowSpan",
+		"colSpan",
+		"dock",
+		"left",
+		"top",
+		"flexGrow",
+		"flexShrink",
+		"alignSelf",
+		"order"
+	]) if (props[key] !== void 0) result[key] = props[key];
+	return result;
+}
+function applyEscapeProps(view, props) {
+	if (view && props.windows) Object.assign(view, props.windows);
+}
+var nativeRoles = {
+	button: "button",
+	link: "link",
+	search: "search",
+	image: "image",
+	heading: "header",
+	adjustable: "adjustable",
+	summary: "summary",
+	text: "text",
+	none: "none",
+	progressbar: "progressBar",
+	checkbox: "checkbox",
+	switch: "switch",
+	radio: "radioButton",
+	spinbutton: "spinButton",
+	tab: "button"
+};
+function nativeAccessibilityRole(role) {
+	return role ? nativeRoles[role] : void 0;
+}
+function nativeAccessibilityState(state) {
+	if (state?.disabled) return "disabled";
+	if (state?.selected) return "selected";
+	if (state?.checked === true) return "checked";
+	if (state?.checked === false) return "unchecked";
+}
+//#endregion
+export { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState };

package/dist/native/octane-client-build.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "buildId": "97c54242-b0e6-41e8-b10c-ee0ed976b44b",
+  "buildId": "1f1a64b1-cefc-4981-aaa1-ec37fe3f7c71",
   "mode": "production",
   "capabilities": {
     "independentHydration": false

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

@@ -0,0 +1,234 @@
+import { CameraCaptureError } from "./types.js";
+import { Application } from "@nativescript/core";
+//#region src/session-backend.android.ts
+var requestCode = 7820;
+var permissionChain = Promise.resolve();
+var owner;
+var nativeBridge = () => globalThis.com?.octanexplat?.camera?.CameraSessionBridge;
+var permissionName = (kind) => kind === "camera" ? "android.permission.CAMERA" : "android.permission.RECORD_AUDIO";
+var error = (kind, operation, message, cause) => new CameraCaptureError({
+	kind,
+	operation,
+	message,
+	cause
+});
+var context = () => Application.android.context;
+var preferences = () => context().getSharedPreferences("octane-camera-permissions", 0);
+async function checkPermission(kind) {
+	const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
+	if (!activity) return "unavailable";
+	const permission = permissionName(kind);
+	if (activity.checkSelfPermission(permission) === 0) return "granted";
+	return preferences().getBoolean(kind, false) ? activity.shouldShowRequestPermissionRationale(permission) ? "denied" : "blocked" : "notDetermined";
+}
+function requestPermission(kind) {
+	const result = permissionChain.then(async () => {
+		const status = await checkPermission(kind);
+		if (status !== "notDetermined") return status;
+		const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
+		if (!activity) return "unavailable";
+		return new Promise((resolve) => {
+			const code = requestCode++;
+			const finish = (value) => {
+				clearTimeout(timer);
+				Application.android.off(Application.android.activityRequestPermissionsEvent, onResult);
+				resolve(value);
+			};
+			const onResult = (args) => {
+				if (args.requestCode !== code) return;
+				if (!args.grantResults?.length) {
+					finish("unknown");
+					return;
+				}
+				preferences().edit().putBoolean(kind, true).apply();
+				finish(args.grantResults[0] === 0 ? "granted" : activity.shouldShowRequestPermissionRationale(permissionName(kind)) ? "denied" : "blocked");
+			};
+			const timer = setTimeout(() => finish("unknown"), 12e4);
+			Application.android.on(Application.android.activityRequestPermissionsEvent, onResult);
+			try {
+				activity.requestPermissions([permissionName(kind)], code);
+			} catch {
+				finish("unavailable");
+			}
+		});
+	});
+	permissionChain = result.catch(() => {});
+	return result;
+}
+function createSessionBackend(config) {
+	let currentConfig = { ...config };
+	let observer;
+	let bridge;
+	let host;
+	let listener;
+	let sink;
+	let released = false;
+	const lease = {};
+	const selected = () => typeof currentConfig.camera === "object" ? `id:${currentConfig.camera.deviceId}` : currentConfig.camera ?? "default";
+	const releaseLease = () => {
+		if (owner === lease) owner = void 0;
+	};
+	const onSuspend = () => bridge?.background();
+	const onResume = () => bridge?.foreground();
+	const ensureBridge = () => {
+		if (bridge) return;
+		const Bridge = nativeBridge();
+		if (!Bridge) throw error("unsupportedPlatform", "preview", "CameraX video bridge is missing from the native build");
+		bridge = new Bridge(context(), new Bridge.Listener({ event(type, payload) {
+			if (type === "ready") {
+				observer?.previewReady(payload === "true");
+				if (payload === "true") listener?.onReady?.();
+			} else if (type === "availability") observer?.availability(payload === "true");
+			else if (type === "interruption") observer?.interruption("began", payload);
+			else if (type === "recovered") observer?.interruption("ended", payload);
+			else if (type === "previewError") {
+				observer?.availability(false);
+				listener?.onError?.(error("unavailable", "preview", payload));
+				if (!host) releaseLease();
+			} else if (type === "finishing") sink?.finishing(payload ? payload : void 0);
+			else if (type === "started") sink?.started(JSON.parse(payload));
+			else if (type === "finished" || type === "failed") {
+				const target = sink;
+				sink = void 0;
+				if (!host) releaseLease();
+				const result = JSON.parse(payload);
+				target?.settled(type === "finished" ? result : {
+					kind: "failed",
+					stage: result.stage,
+					issue: error(result.kind, result.stage, result.message)
+				});
+			}
+		} }));
+		Application.on(Application.suspendEvent, onSuspend);
+		Application.on(Application.resumeEvent, onResume);
+	};
+	return {
+		platform: "android",
+		get supported() {
+			return !!nativeBridge();
+		},
+		checkPermission,
+		requestPermission: async (kind) => {
+			const status = await requestPermission(kind);
+			if (kind === "camera" && status === "granted" && host && !sink && !released && !bridge?.isReady()) try {
+				ensureBridge();
+				bridge.attach(host, selected());
+			} catch (cause) {
+				observer?.availability(false);
+				listener?.onError?.(error("unavailable", "preview", "Could not activate CameraX after permission approval", cause));
+			}
+			return status;
+		},
+		getCapabilities: async () => {
+			const value = bridge ? JSON.parse(bridge.capabilities()) : {
+				cameras: [],
+				profiles: []
+			};
+			const supported = !!nativeBridge();
+			return {
+				supported,
+				available: !!bridge?.isReady(),
+				reason: !supported ? "CameraX video bridge is missing from the native build" : !bridge?.isReady() ? "An active permitted preview is required" : void 0,
+				cameras: value.cameras,
+				profiles: value.profiles,
+				audio: context().getPackageManager().hasSystemFeature("android.hardware.microphone"),
+				orientations: [],
+				durationLimit: "native",
+				elapsedTime: "nativeMedia",
+				output: {
+					mimeType: "video/mp4",
+					container: "mp4",
+					storage: "appPrivateFile",
+					destinationFileUrl: true
+				}
+			};
+		},
+		previewReady: () => !!bridge?.isReady(),
+		validateStart: (options) => {
+			if (options.maximumDurationMs !== void 0 && options.maximumDurationMs > 9223372036854) throw error("unsupportedConfiguration", "startRecording", "The duration exceeds CameraX media-time range");
+			if (options.orientation && options.orientation !== "unspecified") throw error("unsupportedConfiguration", "startRecording", "Fixed cardinal orientation has not been qualified on this Android source");
+		},
+		attachPreview: (target, callbacks) => {
+			if (released || sink) throw error("invalidState", "attachPreview", "The camera is disposed or finalizing");
+			if (owner && owner !== lease) throw error("busy", "attachPreview", "Another camera session is still finalizing");
+			owner = lease;
+			host = target;
+			listener = callbacks;
+			try {
+				ensureBridge();
+			} catch (cause) {
+				host = void 0;
+				listener = void 0;
+				releaseLease();
+				throw error("unavailable", "attachPreview", "Could not construct the CameraX native bridge", cause);
+			}
+			checkPermission("camera").then((status) => {
+				if (released || !host) return;
+				if (status !== "granted") {
+					listener?.onError?.(error("permissionDenied", "preview", "Request camera permission before activating this preview"));
+					return;
+				}
+				try {
+					bridge.attach(host, selected());
+				} catch (cause) {
+					listener?.onError?.(error("unavailable", "preview", "Could not bind shared CameraX preview", cause));
+				}
+			});
+			return () => {
+				host = void 0;
+				listener = void 0;
+				bridge.detach();
+				if (!sink) releaseLease();
+			};
+		},
+		configure: (next) => {
+			const sourceChanged = JSON.stringify(next.camera) !== JSON.stringify(currentConfig.camera) || next.profile !== currentConfig.profile;
+			currentConfig = { ...next };
+			if (host && sourceChanged) {
+				bridge.detach();
+				bridge.attach(host, selected());
+			}
+		},
+		startCapture: (request, target) => {
+			sink = target;
+			try {
+				bridge.start(request.audio, request.destinationPath ?? "", request.maximumDurationMs === void 0 ? 0 : Math.max(1, Math.ceil(request.maximumDurationMs)));
+			} catch (cause) {
+				sink = void 0;
+				target.settled({
+					kind: "failed",
+					stage: "preparation",
+					issue: error("captureFailed", "startRecording", "CameraX could not begin recording", cause)
+				});
+			}
+		},
+		stopCapture: () => bridge?.stop(),
+		elapsedMs: () => Number(bridge?.elapsedMs() ?? 0),
+		openOutput: async (output) => {
+			if (output.kind !== "nativeFile" || output.synthetic) throw error("invalidArgument", "openOutput", "Expected a native Android movie reference");
+			try {
+				const url = nativeBridge().openOutput(output.resourceId, output.fileUrl);
+				return {
+					url,
+					fileUrl: url,
+					release: () => {}
+				};
+			} catch (cause) {
+				throw error("destinationUnavailable", "openOutput", "The stored Android movie cannot be reopened", cause);
+			}
+		},
+		release: async () => {
+			released = true;
+			Application.off(Application.suspendEvent, onSuspend);
+			Application.off(Application.resumeEvent, onResume);
+			bridge?.release();
+			host = void 0;
+			releaseLease();
+		},
+		setObserver: (value) => {
+			observer = value;
+		}
+	};
+}
+//#endregion
+export { createSessionBackend };