@octane-xplat/camera 0.13.0 → 0.14.0

package/dist/web/CameraView.web.tsrx.js

@@ -1,3 +1,4 @@
+import { attachSessionPreview } from "./session.js";
 import { applyEscapeProps, layoutChildProps } from "./layout-child.web.js";
 import { __s, bag15, bag5, child, clone, delegateEvents, evt2e, evt2u, hookSlots, ifBlock, markDangerouslySetInnerHTMLChildren, queueRefAttach, queueRefDetach, setStyleProperty, snapshotSpread, template, useEffect, useImperativeHandle, useRef } from "octane";
 import { bindSignalHostPropSources, enableSignalBindings, replaceRef, setAttributeIfChanged } from "octane/internal/client";
@@ -7,8 +8,8 @@ delegateEvents(["playing"]);
 var _t$0 = /* @__PURE__ */ template("<video autoplay=\"\" playsinline=\"\" style=\"display: block; width: 100%; height: 100%; object-fit: cover;\"></video>");
 var _t$1 = /* @__PURE__ */ template("<div><!></div>");
 var _hs$ = /* @__PURE__ */ hookSlots(5);
-var __event = (__eventArg, readyFired, props) => {
-	if (readyFired.current) return;
+var __event = (__eventArg, props, readyFired) => {
+	if (props.session || readyFired.current) return;
 	readyFired.current = true;
 	props.onReady?.();
 };
@@ -34,7 +35,7 @@ function __then$0(__props, __s, __extra) {
 			applyEscapeProps(element, props);
 		}, _root);
 		(__s.cleanups ??= []).push(() => _b && queueRefDetach(_b.b, _b.a));
-		_m4 = evt2e(_root, "$oplaying", __event, readyFired, props);
+		_m4 = evt2e(_root, "$oplaying", __event, props, readyFired);
 		_b = bag5(__s, _root, _root, _m1, void 0, __s, _m4);
 		__s.refFields = _rm$1;
 	} else {
@@ -47,7 +48,7 @@ function __then$0(__props, __s, __extra) {
 			};
 			if (_r !== _b.b) _b.b = replaceRef(__s, _b.b, _r, _b.a);
 		}
-		evt2u(_b.e, __event, readyFired, props);
+		evt2u(_b.e, __event, props, readyFired);
 	}
 	_b.c = setAttributeIfChanged(true, _b.c, _b.a, "muted");
 	{
@@ -72,6 +73,21 @@ var CameraView = /* @__PURE__ */ __s(function CameraView(props, __s, __extra) {
 	useEffect(() => {
 		const element = video.current;
 		if (!element || !active) return;
+		if (props.session) {
+			if (props.facing !== void 0) {
+				props.onError?.({ message: "camera session conflicts with facing" });
+				return;
+			}
+			try {
+				return attachSessionPreview(props.session, element, {
+					onReady: props.onReady,
+					onError: (issue) => props.onError?.({ message: issue.message })
+				});
+			} catch (error) {
+				props.onError?.({ message: error?.message ?? "camera session error" });
+				return;
+			}
+		}
 		const mediaDevices = navigator.mediaDevices;
 		if (!mediaDevices?.getUserMedia) {
 			props.onError?.({ message: "camera unsupported" });
@@ -99,7 +115,11 @@ var CameraView = /* @__PURE__ */ __s(function CameraView(props, __s, __extra) {
 			element.srcObject = null;
 			if (stream) for (const track of stream.getTracks()) track.stop();
 		};
-	}, [active, facing], _hs$ + 3);
+	}, [
+		active,
+		facing,
+		props.session
+	], _hs$ + 3);
 	useImperativeHandle(props.ref, () => ({ native: hostRef.current }), void 0, _hs$ + 4);
 	let _b = __s.slots[0];
 	if (_b === void 0) {
@@ -183,7 +203,7 @@ var CameraView = /* @__PURE__ */ __s(function CameraView(props, __s, __extra) {
 				"aria-live",
 				_m11
 			]
-		], "b:25f1aaa9", true);
+		], "b:d3c40afd", true);
 		markDangerouslySetInnerHTMLChildren(_root);
 		_m14 = child(_root);
 		_b = bag15(__s, _root, _m0, _m1, _m2, _m3, _m4, _m5, _m6, _m7, _m8, _m9, _m10, _m11, _root, _m13, _m14);
@@ -300,7 +320,7 @@ var CameraView = /* @__PURE__ */ __s(function CameraView(props, __s, __extra) {
 				"aria-live",
 				_b.l
 			]
-		], "b:25f1aaa9", true);
+		], "b:d3c40afd", true);
 	}
 	{
 		const __ifCondition = active;

package/dist/web/host-movie.web.js

@@ -0,0 +1,100 @@
+import { CameraCaptureError } from "./types.js";
+import { createHostClient } from "@octane-xplat/platform/host";
+import { createWebKitTransport } from "@octane-xplat/platform/host/web";
+//#region src/host-movie.web.ts
+var requiredMethods = [
+	"permissionStatus",
+	"requestPermission",
+	"movieDirectory",
+	"reserveMoviePath",
+	"writeMovieFile",
+	"movieFileInfo",
+	"readMovieFile",
+	"deleteMovieFile"
+];
+var hostProbe;
+/** The camera-capable desktop host client, or null outside a qualified host. */
+function cameraHost() {
+	hostProbe ??= (async () => {
+		try {
+			const transport = createWebKitTransport();
+			if (!transport) return null;
+			const client = createHostClient(transport);
+			const methods = (await client.capabilities().catch(() => null))?.camera;
+			if (Array.isArray(methods) && requiredMethods.every((name) => methods.includes(name))) return client;
+			client.dispose();
+			return null;
+		} catch {
+			return null;
+		}
+	})();
+	return hostProbe;
+}
+var error = (kind, message) => new CameraCaptureError({
+	kind,
+	operation: "storage",
+	message
+});
+var blobToBase64 = async (bytes) => {
+	const data = new Uint8Array(await bytes.arrayBuffer());
+	let binary = "";
+	const chunk = 32768;
+	for (let offset = 0; offset < data.length; offset += chunk) binary += String.fromCharCode(...data.subarray(offset, offset + chunk));
+	return btoa(binary);
+};
+var base64ToBlob = (base64, type) => {
+	const binary = atob(base64);
+	const data = new Uint8Array(binary.length);
+	for (let index = 0; index < binary.length; index++) data[index] = binary.charCodeAt(index);
+	return new Blob([data], { type });
+};
+var mimeForFileUrl = (fileUrl) => fileUrl.endsWith(".webm") ? "video/webm" : fileUrl.endsWith(".mov") ? "video/quicktime" : "video/mp4";
+/** Reserve a host-side movie file. `destinationFileUrl` is validated
+*  host-side: it must be a new file inside the app-private storage root. */
+var reserveHostMovie = async (host, options) => {
+	const { reservation } = await host.call("camera", "reserveMoviePath", {
+		fileUrl: options.destinationFileUrl,
+		container: options.container
+	});
+	if (!reservation?.fileUrl) throw error("destinationUnavailable", options.destinationFileUrl ? "destinationFileUrl must be a new file inside the app-private recordings directory" : "The host could not allocate a movie recording file");
+	return reservation;
+};
+/** Commit finalized movie bytes to host-side app-private storage. */
+var commitHostMovie = async (host, fileUrl, bytes) => {
+	const base64 = await blobToBase64(bytes);
+	const { file } = await host.call("camera", "writeMovieFile", {
+		fileUrl,
+		base64
+	});
+	if (!file?.uri) throw error("storageFailed", "The host could not write the recorded movie");
+	return {
+		kind: "nativeFile",
+		resourceId: file.uri,
+		fileUrl: file.uri
+	};
+};
+/** Drop an uncommitted host reservation after a failed attempt. */
+var removeHostReservation = async (host, fileUrl) => {
+	await host.call("camera", "deleteMovieFile", { fileUrl }).catch(() => {});
+};
+/** Reopen a host-stored movie as a temporary playback URL. The durable
+*  reference remains `fileUrl`; the returned url lives until `release()`. */
+var openHostMovie = async (host, output) => {
+	if (output.kind !== "nativeFile" || !output.fileUrl) throw new CameraCaptureError({
+		kind: "invalidArgument",
+		operation: "openOutput",
+		message: "Only file-backed output can be opened through the desktop host"
+	});
+	const { info } = await host.call("camera", "movieFileInfo", { fileUrl: output.fileUrl });
+	if (!info?.exists) throw error("unavailable", `Movie file is missing at ${output.fileUrl}`);
+	const { base64 } = await host.call("camera", "readMovieFile", { fileUrl: output.fileUrl });
+	if (!base64) throw error("unavailable", `Movie file could not be read at ${output.fileUrl}`);
+	const url = URL.createObjectURL(base64ToBlob(base64, mimeForFileUrl(output.fileUrl)));
+	return {
+		url,
+		fileUrl: output.fileUrl,
+		release: () => URL.revokeObjectURL(url)
+	};
+};
+//#endregion
+export { cameraHost, commitHostMovie, openHostMovie, removeHostReservation, reserveHostMovie };

package/dist/web/index.js

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

package/dist/web/movie-metadata.web.js

@@ -0,0 +1,65 @@
+import { CameraCaptureError } from "./types.js";
+import { BlobSource, Input, MP4, WEBM } from "mediabunny";
+//#region src/movie-metadata.web.ts
+/** Read packet end timestamps and track metadata, never the wall-clock stop time. */
+async function inspectMovie(bytes, audioRequested) {
+	if (!bytes.size) throw new CameraCaptureError({
+		kind: "noMedia",
+		operation: "finalize",
+		message: "The recorder produced no movie bytes"
+	});
+	const input = new Input({
+		source: new BlobSource(bytes),
+		formats: [WEBM, MP4]
+	});
+	const read = async () => {
+		const video = await input.getPrimaryVideoTrack();
+		const audio = await input.getPrimaryAudioTrack();
+		if (!video) throw new CameraCaptureError({
+			kind: "noMedia",
+			operation: "finalize",
+			message: "The movie contains no video track"
+		});
+		const videoDuration = await video.computeDuration();
+		const hasAudio = audio !== null && await audio.computeDuration() > 0;
+		const durationMs = await input.computeDuration() * 1e3;
+		const width = await video.getDisplayWidth();
+		const height = await video.getDisplayHeight();
+		if (!Number.isFinite(durationMs) || durationMs <= 0 || videoDuration <= 0 || width <= 0 || height <= 0) throw new CameraCaptureError({
+			kind: "noMedia",
+			operation: "finalize",
+			message: "The movie has no usable video media"
+		});
+		if (audioRequested && !hasAudio) throw new CameraCaptureError({
+			kind: "captureFailed",
+			operation: "finalize",
+			message: "Requested audio is absent from the finalized movie"
+		});
+		return {
+			durationMs,
+			width,
+			height,
+			hasAudio,
+			mimeType: await input.getMimeType(),
+			orientation: "unspecified"
+		};
+	};
+	let timer;
+	try {
+		return await Promise.race([read(), new Promise((_resolve, reject) => {
+			timer = setTimeout(() => {
+				input.dispose();
+				reject(new CameraCaptureError({
+					kind: "finalizationFailed",
+					operation: "metadata",
+					message: "Movie metadata verification timed out"
+				}));
+			}, 3e4);
+		})]);
+	} finally {
+		clearTimeout(timer);
+		input.dispose();
+	}
+}
+//#endregion
+export { inspectMovie };

package/dist/web/movie-storage.web.js

@@ -0,0 +1,119 @@
+import { CameraCaptureError } from "./types.js";
+//#region src/movie-storage.web.ts
+var databaseName = "octane-xplat-camera";
+var storeName = "movies";
+var storageError = (cause) => new CameraCaptureError({
+	kind: cause instanceof DOMException && cause.name === "QuotaExceededError" ? "insufficientStorage" : "storageFailed",
+	operation: "storage",
+	message: "The movie could not be committed to origin-local storage",
+	cause
+});
+/** Each operation closes its database; playback survives session and page lifetimes. */
+async function transact(mode, operation) {
+	return new Promise((resolve, reject) => {
+		let database;
+		let transaction;
+		let result;
+		let done = false;
+		const finish = (cause) => {
+			if (done) return;
+			done = true;
+			clearTimeout(timer);
+			database?.close();
+			if (cause) reject(storageError(cause));
+			else resolve(result);
+		};
+		const timer = setTimeout(() => {
+			transaction?.abort();
+			finish(/* @__PURE__ */ new Error("Storage transaction timed out"));
+		}, 15e3);
+		const request = indexedDB.open(databaseName, 1);
+		request.onupgradeneeded = () => request.result.createObjectStore(storeName, { keyPath: "id" });
+		request.onerror = () => finish(request.error);
+		request.onblocked = () => finish(/* @__PURE__ */ new Error("Storage upgrade is blocked by another page"));
+		request.onsuccess = () => {
+			database = request.result;
+			if (done) {
+				database.close();
+				return;
+			}
+			try {
+				transaction = database.transaction(storeName, mode, { durability: "strict" });
+				transaction.oncomplete = () => finish();
+				transaction.onabort = () => finish(transaction?.error ?? /* @__PURE__ */ new Error("Storage transaction aborted"));
+				transaction.onerror = () => finish(transaction?.error ?? /* @__PURE__ */ new Error("Storage transaction failed"));
+				operation(transaction.objectStore(storeName), (value) => {
+					result = value;
+				});
+			} catch (cause) {
+				finish(cause);
+			}
+		};
+	});
+}
+async function reserveMovie() {
+	const estimate = await navigator.storage.estimate();
+	if (estimate.quota !== void 0 && estimate.usage !== void 0 && estimate.quota - estimate.usage < 1048576) throw new CameraCaptureError({
+		kind: "insufficientStorage",
+		operation: "reserve",
+		message: "Origin storage has less than 1 MiB free"
+	});
+	const id = crypto.randomUUID();
+	await transact("readwrite", (store) => {
+		store.add({ id });
+	});
+	return id;
+}
+async function commitMovie(id, bytes, clip) {
+	if (!await navigator.storage.persisted()) throw new CameraCaptureError({
+		kind: "destinationUnavailable",
+		operation: "storage",
+		message: "Persistent origin storage is no longer granted"
+	});
+	await transact("readwrite", (store) => {
+		store.put({
+			id,
+			bytes,
+			clip
+		});
+	});
+	const stored = await readMovie(id);
+	if (!stored.bytes || stored.bytes.size !== bytes.size || !stored.clip) throw storageError(/* @__PURE__ */ new Error("Committed movie cannot be reopened"));
+}
+async function removeReservation(id) {
+	await transact("readwrite", (store) => {
+		store.delete(id);
+	});
+}
+async function readMovie(id) {
+	return transact("readonly", (store, result) => {
+		const request = store.get(id);
+		request.onsuccess = () => result(request.result ?? { id });
+	});
+}
+async function openStoredMovie(output) {
+	if (output.kind !== "browserStorage" || output.synthetic) throw new CameraCaptureError({
+		kind: "invalidArgument",
+		operation: "openOutput",
+		message: "Expected an origin-local movie reference"
+	});
+	const stored = await readMovie(output.resourceId);
+	if (!stored.bytes || !stored.clip) throw new CameraCaptureError({
+		kind: "destinationUnavailable",
+		operation: "openOutput",
+		message: "Movie is missing or site data was cleared"
+	});
+	const url = URL.createObjectURL(stored.bytes);
+	let released = false;
+	return {
+		url,
+		release: () => {
+			if (!released) {
+				released = true;
+				URL.revokeObjectURL(url);
+			}
+		}
+	};
+}
+//#endregion
+export { commitMovie, openStoredMovie, removeReservation, reserveMovie };

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

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "buildId": "96cb43a6-c424-49f9-aceb-4c944dfc819a",
+  "buildId": "80726f7b-b224-48a6-a9cc-c07753fd63c4",
   "mode": "production",
   "capabilities": {
     "independentHydration": false