@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/authentication.esm.js

@@ -0,0 +1,25 @@
+import "./BaseWasmProvider-C_DLEI40.esm.js";
+import "./WasmUtilProvider-j98OJf-S.esm.js";
+import "./api-CESGtpbH.esm.js";
+import "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import "./browserSimulation-gxD8cSpM.esm.js";
+import "./xstate.esm-B70JrNqo.esm.js";
+import "./faceCaptureManagerFactory-Dh2PdGlF.esm.js";
+import "./BrowserStorageProvider-CuOW1Er2.esm.js";
+import "./faceCaptureSetup-B3faSpYA.esm.js";
+import "./ITimerCapability-C67ZRskg.esm.js";
+import "./camera-PA2Ljri3.esm.js";
+import "./deepsightService-O74l4Y__.esm.js";
+import "./recordingService-Ig2UgbLv.esm.js";
+import "./platform-CfrjKhmi.esm.js";
+import "./backCameraStream-DMdMeGk2.esm.js";
+import "./getBrowser-BSXUTWXw.esm.js";
+import "./stats-CIfiPzb1.esm.js";
+import "./getDeviceClass-BSntT9_j.esm.js";
+import "./MotionSensorProvider-4v7xkqAp.esm.js";
+import "./permissionServices-D_i6nzEw.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-BMZqatiF.esm.js";
+import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-5M-fKzXx.esm.js";
+
+export { authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/authenticationManager-5M-fKzXx.esm.js

@@ -0,0 +1,67 @@
+import { t as WasmUtilProvider } from "./WasmUtilProvider-j98OJf-S.esm.js";
+import { n as eventModuleNames } from "./events-D6-e4vok.esm.js";
+import { s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-Dh2PdGlF.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CuOW1Er2.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-BMZqatiF.esm.js";
+
+//#region src/modules/authentication/authenticationActor.ts
+function createAuthenticationActor(options) {
+	const dependencies = options.dependencies ?? {
+		storage: new BrowserStorageProvider(),
+		getWasmUtil: () => WasmUtilProvider.getInstance()
+	};
+	return createActor(authenticationMachine, { input: {
+		config: options.config,
+		dependencies,
+		authHint: options.authHint
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/authentication/authenticationManager.ts
+function createAuthenticationManagerFromActor(actor) {
+	return createFaceCaptureManagerFromActor(actor, eventModuleNames.authFace);
+}
+/**
+* Creates an authentication manager instance for handling face authentication flow.
+*
+* The authentication manager provides:
+* - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
+* - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
+* - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
+* - Camera stream access when in `capture` state
+* - Detection status feedback during face detection
+* - Attempt tracking with `attemptsRemaining`
+*
+* @param options - Configuration for the authentication actor
+* @param options.config - The authentication module configuration from the flow
+* @param options.authHint - Hint for identifying the user (e.g., phone number, email)
+* @returns A manager instance with state subscription, API methods, and lifecycle controls
+*
+* @example
+* ```ts
+* const authManager = createAuthenticationManager({
+*   config: authConfig,
+*   authHint: 'user@example.com'
+* });
+*
+* authManager.subscribe((state) => {
+*   if (state.status === 'capture') {
+*     console.log('Camera ready:', state.stream);
+*     console.log('Detection status:', state.detectionStatus);
+*   }
+*   if (state.status === 'finished') {
+*     console.log('Authentication successful!');
+*   }
+* });
+*
+* authManager.load();
+* ```
+*/
+function createAuthenticationManager(options) {
+	return createFaceCaptureManagerFromActor(createAuthenticationActor(options), eventModuleNames.authFace);
+}
+
+//#endregion
+export { createAuthenticationManagerFromActor as n, createAuthenticationActor as r, createAuthenticationManager as t };

package/dist/authenticationManager-C83GNIhl.d.ts

@@ -0,0 +1,66 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import { b as CreateAuthenticationActorOptions, n as FaceCaptureManagerState, t as FaceCaptureManager, y as AuthenticationActor } from "./faceCaptureManagerFactory-yqtpxjnN.js";
+
+//#region src/modules/authentication/authenticationManager.d.ts
+type AuthenticationState = FaceCaptureManagerState;
+declare function createAuthenticationManagerFromActor(actor: AuthenticationActor): Manager<FaceCaptureManagerState> & {
+  load(): void;
+  nextStep(): void;
+  requestPermission(): void;
+  goToLearnMore(): void;
+  back(): void;
+  close(): void;
+  reset(): void;
+  retryCapture(): void;
+  capture(): void;
+};
+/**
+ * Creates an authentication manager instance for handling face authentication flow.
+ *
+ * The authentication manager provides:
+ * - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
+ * - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
+ * - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
+ * - Camera stream access when in `capture` state
+ * - Detection status feedback during face detection
+ * - Attempt tracking with `attemptsRemaining`
+ *
+ * @param options - Configuration for the authentication actor
+ * @param options.config - The authentication module configuration from the flow
+ * @param options.authHint - Hint for identifying the user (e.g., phone number, email)
+ * @returns A manager instance with state subscription, API methods, and lifecycle controls
+ *
+ * @example
+ * ```ts
+ * const authManager = createAuthenticationManager({
+ *   config: authConfig,
+ *   authHint: 'user@example.com'
+ * });
+ *
+ * authManager.subscribe((state) => {
+ *   if (state.status === 'capture') {
+ *     console.log('Camera ready:', state.stream);
+ *     console.log('Detection status:', state.detectionStatus);
+ *   }
+ *   if (state.status === 'finished') {
+ *     console.log('Authentication successful!');
+ *   }
+ * });
+ *
+ * authManager.load();
+ * ```
+ */
+declare function createAuthenticationManager(options: CreateAuthenticationActorOptions): Manager<FaceCaptureManagerState> & {
+  load(): void;
+  nextStep(): void;
+  requestPermission(): void;
+  goToLearnMore(): void;
+  back(): void;
+  close(): void;
+  reset(): void;
+  retryCapture(): void;
+  capture(): void;
+};
+type AuthenticationManager = FaceCaptureManager;
+//#endregion
+export { createAuthenticationManagerFromActor as i, AuthenticationState as n, createAuthenticationManager as r, AuthenticationManager as t };

package/dist/authenticationStateMachine-BMZqatiF.esm.js

@@ -0,0 +1,139 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, r as assign } from "./xstate.esm-B70JrNqo.esm.js";
+import { a as prepareOnDeviceFaceUpload, i as postOnDeviceFaceResults, n as defaultPrepareFaceUpload, r as isOnDeviceMode, t as faceCaptureMachine } from "./faceCaptureSetup-B3faSpYA.esm.js";
+import { m as FACE_ERROR_CODES } from "./recordingService-Ig2UgbLv.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-BSntT9_j.esm.js";
+
+//#region src/modules/authentication/authenticationErrorUtils.ts
+const AUTH_ERROR_MAP = {
+	SPOOF_ATTEMPT_DETECTED: FACE_ERROR_CODES.SPOOF_ATTEMPT_DETECTED,
+	SELFIE_FACE_OCCLUDED: FACE_ERROR_CODES.FACE_OCCLUDED,
+	FACE_OCCLUDED: FACE_ERROR_CODES.FACE_OCCLUDED,
+	FACE_TOO_DARK: FACE_ERROR_CODES.FACE_TOO_DARK,
+	LENSES_DETECTED: FACE_ERROR_CODES.LENSES_DETECTED,
+	FACE_MASK_DETECTED: FACE_ERROR_CODES.FACE_MASK_DETECTED,
+	CLOSED_EYES_DETECTED: FACE_ERROR_CODES.CLOSED_EYES_DETECTED,
+	HEAD_COVER_DETECTED: FACE_ERROR_CODES.HEAD_COVER_DETECTED,
+	FACE_NOT_FOUND: FACE_ERROR_CODES.FACE_NOT_FOUND,
+	FACE_CROPPING_FAILED: FACE_ERROR_CODES.FACE_CROPPING_FAILED,
+	FACE_TOO_SMALL: FACE_ERROR_CODES.FACE_TOO_SMALL,
+	FACE_TOO_BLURRY: FACE_ERROR_CODES.FACE_TOO_BLURRY,
+	BAD_PHOTO_QUALITY: FACE_ERROR_CODES.BAD_PHOTO_QUALITY,
+	PROCESSING_ERROR: FACE_ERROR_CODES.PROCESSING_ERROR,
+	BAD_REQUEST: FACE_ERROR_CODES.BAD_REQUEST,
+	SERVER: FACE_ERROR_CODES.SERVER,
+	USER_IS_NOT_RECOGNIZED: FACE_ERROR_CODES.USER_IS_NOT_RECOGNIZED,
+	NONEXISTENT_CUSTOMER: FACE_ERROR_CODES.NONEXISTENT_CUSTOMER,
+	HINT_NOT_PROVIDED: FACE_ERROR_CODES.HINT_NOT_PROVIDED
+};
+const TERMINAL_AUTH_ERROR_CODES = [FACE_ERROR_CODES.NONEXISTENT_CUSTOMER, FACE_ERROR_CODES.HINT_NOT_PROVIDED];
+const validateAuthUploadResponse = (response) => {
+	if (!response) return FACE_ERROR_CODES.SERVER;
+	if (response.overallStatus !== "PASS") return AUTH_ERROR_MAP[response.error?.name] ?? FACE_ERROR_CODES.SERVER;
+};
+const isTerminalAuthError = (response, attemptsRemaining) => {
+	if (!response) return false;
+	const mappedError = AUTH_ERROR_MAP[response.error?.name];
+	if (mappedError && TERMINAL_AUTH_ERROR_CODES.includes(mappedError)) return true;
+	if (attemptsRemaining <= 0) return true;
+	return false;
+};
+
+//#endregion
+//#region src/modules/authentication/authenticationUploadService.ts
+async function uploadAuthFace(params) {
+	try {
+		const payload = {
+			base64Image: params.encryptedBase64Image,
+			faceCoordinates: params.faceCoordinates ?? void 0,
+			encrypted: true,
+			clientInfo: { deviceClass: getDeviceClass() },
+			metadata: params.metadata ?? void 0,
+			...params.authHint !== void 0 && { hint: params.authHint }
+		};
+		const query = {};
+		if (params.recordingId) query.recordingId = params.recordingId;
+		const res = await api.post(endpoints.authenticate, payload, {
+			signal: params.signal,
+			query
+		});
+		if (!res.ok) throw new Error(`POST ${endpoints.authenticate} failed: ${res.status} ${res.statusText}`);
+		return res.data;
+	} catch (error) {
+		const errorCode = getAuthErrorCodeFromHttpError(error);
+		if (errorCode) throw new Error(errorCode);
+		throw new Error(FACE_ERROR_CODES.SERVER);
+	}
+}
+const getAuthErrorCodeFromHttpError = (error) => {
+	const err = error;
+	if (err.ok !== false || typeof err.status !== "number") return;
+	if (err.status !== 400) return FACE_ERROR_CODES.SERVER;
+	const errorName = err.data?.error?.name;
+	if (!errorName) return FACE_ERROR_CODES.BAD_REQUEST;
+	return AUTH_ERROR_MAP[errorName] ?? FACE_ERROR_CODES.BAD_REQUEST;
+};
+
+//#endregion
+//#region src/modules/authentication/authenticationStateMachine.ts
+const _authenticationMachine = faceCaptureMachine.provide({
+	actors: {
+		prepareFaceUpload: fromPromise(async ({ input }) => {
+			const ctx = input;
+			return isOnDeviceMode(ctx.config) ? prepareOnDeviceFaceUpload(ctx) : defaultPrepareFaceUpload(ctx);
+		}),
+		uploadFace: fromPromise(async ({ input, signal }) => {
+			const ctx = input;
+			if (isOnDeviceMode(ctx.config)) return postOnDeviceFaceResults(ctx, signal);
+			return uploadAuthFace({
+				encryptedBase64Image: ctx.encryptedBase64Image,
+				faceCoordinates: ctx.faceCoordinates,
+				authHint: ctx.authHint,
+				metadata: ctx.deepsightService?.getMetadata(),
+				recordingId: ctx.uploadRecordingId,
+				signal
+			});
+		}),
+		processFace: fromPromise(async () => ({}))
+	},
+	actions: {
+		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => {
+			if (isOnDeviceMode(context.config)) return;
+			const resp = context.uploadResponse;
+			return validateAuthUploadResponse(resp) ?? FACE_ERROR_CODES.SERVER;
+		} }),
+		setTerminalError: assign({ error: ({ context }) => {
+			const resp = context.uploadResponse;
+			if (context.attemptsRemaining <= 0) return {
+				type: "FACE_AUTH_ERROR",
+				message: "No more attempts remaining"
+			};
+			if (!resp) return {
+				type: "FACE_AUTH_ERROR",
+				message: "Authentication failed"
+			};
+			return {
+				type: "FACE_AUTH_ERROR",
+				message: resp.error?.message ?? resp.error?.name ?? "Face authentication error"
+			};
+		} })
+	},
+	guards: {
+		hasUploadValidationError: ({ context }) => {
+			if (isOnDeviceMode(context.config)) return false;
+			const resp = context.uploadResponse;
+			return validateAuthUploadResponse(resp) !== void 0;
+		},
+		isTerminalUploadError: ({ context }) => {
+			if (isOnDeviceMode(context.config)) return false;
+			const resp = context.uploadResponse;
+			return isTerminalAuthError(resp, context.attemptsRemaining);
+		},
+		isNoAttemptsTerminal: () => true
+	}
+});
+const authenticationMachine = _authenticationMachine;
+
+//#endregion
+export { authenticationMachine as t };

package/dist/backCameraStream-DMdMeGk2.esm.js

@@ -0,0 +1,346 @@
+import { t as sleep } from "./ITimerCapability-C67ZRskg.esm.js";
+import { i as stopCameraStream, n as enumerateVideoDevices, r as requestCameraAccess, t as applyTrackConstraints } from "./camera-PA2Ljri3.esm.js";
+import { a as isIPhone14OrHigher, o as isSafari, r as isIOS, t as isAndroid } from "./platform-CfrjKhmi.esm.js";
+
+//#region src/internal/camera/backCameraStream.ts
+const BACK_CAMERA_KEYWORDS = [
+	"rear",
+	"back",
+	"rück",
+	"arrière",
+	"trasera",
+	"trás",
+	"traseira",
+	"posteriore",
+	"后面",
+	"後面",
+	"背面",
+	"后置",
+	"後置",
+	"背置",
+	"задней",
+	"الخلفية",
+	"후",
+	"arka",
+	"achterzijde",
+	"หลัง",
+	"baksidan",
+	"bagside",
+	"sau",
+	"bak",
+	"tylny",
+	"takakamera",
+	"belakang",
+	"אחורית",
+	"πίσω",
+	"spate",
+	"hátsó",
+	"zadní",
+	"darrere",
+	"zadná",
+	"задня",
+	"stražnja",
+	"बैक"
+];
+function isBackCameraLabel(label) {
+	const lowercaseLabel = label.toLowerCase();
+	return BACK_CAMERA_KEYWORDS.some((keyword) => lowercaseLabel.includes(keyword));
+}
+function classifyCamera(device, index, totalDevices) {
+	let cameraType;
+	if (device.label === "") cameraType = totalDevices === 1 || index + 1 <= totalDevices / 2 ? "front" : "back";
+	else cameraType = isBackCameraLabel(device.label) ? "back" : "front";
+	return {
+		deviceId: device.deviceId,
+		label: device.label,
+		cameraType
+	};
+}
+async function getCameras() {
+	const videoDevices = await enumerateVideoDevices();
+	const cameras = videoDevices.map((d, i) => classifyCamera(d, i, videoDevices.length));
+	if (cameras.length > 1 && !cameras.some((c) => c.cameraType === "back")) {
+		const resolutions = cameras.map((c) => {
+			const match = c.label.match(/\b([0-9]+)MP?\b/i);
+			return match ? parseInt(match[1], 10) : NaN;
+		});
+		let backCameraIndex = cameras.length - 1;
+		if (!resolutions.some(isNaN)) backCameraIndex = resolutions.lastIndexOf(Math.max(...resolutions));
+		cameras[backCameraIndex].cameraType = "back";
+	}
+	return cameras;
+}
+function selectBestBackCamera(track, backCameras) {
+	if (backCameras.length === 0) return void 0;
+	if (backCameras.length === 1) return backCameras[0];
+	const withMp = backCameras.map((c) => {
+		const match = c.label.match(/\b([0-9]+)\s*MP?\b/i);
+		return {
+			camera: c,
+			mp: match ? parseInt(match[1], 10) : 0
+		};
+	});
+	const maxMp = Math.max(...withMp.map((w) => w.mp));
+	if (maxMp > 0) {
+		const best = withMp.find((w) => w.mp === maxMp);
+		if (best) return best.camera;
+	}
+	const settings = track.getSettings();
+	const browserPick = backCameras.find((c) => c.deviceId === settings.deviceId || c.label === track.label);
+	if (browserPick) return browserPick;
+	return backCameras[0];
+}
+function selectMainCameraFromStream(track, cameras) {
+	const settings = track.getSettings();
+	const activeCamera = cameras.find((c) => c.deviceId === settings.deviceId || c.label !== "" && c.label === track.label);
+	if (!activeCamera) return void 0;
+	if ((settings.facingMode === "environment" || isBackCameraLabel(track.label)) && cameras.length > 1) {
+		cameras.forEach((camera) => {
+			if (camera.deviceId === activeCamera.deviceId) camera.cameraType = "back";
+			else if (!isBackCameraLabel(camera.label)) camera.cameraType = "front";
+		});
+		return selectBestBackCamera(track, cameras.filter((c) => c.cameraType === "back"));
+	}
+	if (cameras.length === 1) return activeCamera;
+}
+function getAndroidVideoConstraints(level) {
+	const base = {
+		resizeMode: "none",
+		facingMode: "environment"
+	};
+	switch (level) {
+		case 0: return {
+			...base,
+			height: { ideal: 720 }
+		};
+		case 1: return {
+			...base,
+			width: {
+				min: 3200,
+				ideal: 3840,
+				max: 4096
+			},
+			height: {
+				min: 1800,
+				ideal: 2160,
+				max: 2400
+			}
+		};
+		case 2: return {
+			...base,
+			width: {
+				min: 1400,
+				ideal: 1920,
+				max: 2160
+			},
+			height: {
+				min: 900,
+				ideal: 1080,
+				max: 1440
+			}
+		};
+		case 3: return {
+			...base,
+			width: {
+				min: 800,
+				ideal: 1400,
+				max: 1920
+			},
+			height: {
+				min: 600,
+				ideal: 900,
+				max: 1080
+			}
+		};
+		case 4: return {
+			...base,
+			width: {
+				min: 640,
+				ideal: 800,
+				max: 1400
+			},
+			height: {
+				min: 480,
+				ideal: 480,
+				max: 900
+			}
+		};
+		case 5: return {
+			...base,
+			width: {
+				min: 640,
+				ideal: 640,
+				max: 800
+			},
+			height: {
+				min: 480,
+				ideal: 480,
+				max: 600
+			}
+		};
+		default: return {};
+	}
+}
+function getAndroidFinalConstraints(mainCamera, fallbackLevel) {
+	const base = {
+		deviceId: { exact: mainCamera.deviceId },
+		resizeMode: "none"
+	};
+	if (fallbackLevel <= 1) return {
+		...base,
+		width: { ideal: 1920 },
+		height: { ideal: 1080 }
+	};
+	const full = getAndroidVideoConstraints(fallbackLevel);
+	return {
+		...base,
+		width: full.width,
+		height: full.height
+	};
+}
+async function getAndroidBackCameraStream(fallbackLevel = 0) {
+	if (fallbackLevel > 5) throw new Error("Failed to get camera after all fallback attempts");
+	try {
+		const initialStream = await requestCameraAccess({ video: getAndroidVideoConstraints(fallbackLevel) });
+		const track = initialStream.getVideoTracks()[0];
+		const mainCamera = selectMainCameraFromStream(track, await getCameras());
+		stopCameraStream(initialStream);
+		if (!mainCamera) throw new Error("Could not identify main camera");
+		const finalStream = await requestCameraAccess({ video: getAndroidFinalConstraints(mainCamera, fallbackLevel) });
+		await applyFocusHint(finalStream);
+		return {
+			stream: finalStream,
+			fallbackLevel
+		};
+	} catch (error) {
+		const errorName = error instanceof Error ? error.name : "UnknownError";
+		const nextLevel = Math.min(fallbackLevel + 1, 5);
+		if (errorName === "NotReadableError") {
+			await sleep(300);
+			return getAndroidBackCameraStream(nextLevel);
+		}
+		if (errorName === "AbortError") {
+			await sleep(300);
+			return getAndroidBackCameraStream(fallbackLevel);
+		}
+		return getAndroidBackCameraStream(nextLevel);
+	}
+}
+async function applyFocusHint(stream) {
+	const videoTrack = stream.getVideoTracks()[0];
+	try {
+		await applyTrackConstraints(videoTrack, { advanced: [{ focusDistance: 1 }] });
+	} catch {}
+}
+function getIOSConstraints() {
+	return {
+		audio: false,
+		video: {
+			resizeMode: "none",
+			facingMode: "environment",
+			height: { ideal: isIPhone14OrHigher() ? 1080 : 720 }
+		}
+	};
+}
+async function getIOSCameraStream() {
+	const stream = await requestCameraAccess(getIOSConstraints());
+	await applyFocusHint(stream);
+	return stream;
+}
+function getDesktopVideoConstraints(level) {
+	switch (level) {
+		case 0: return {
+			width: {
+				min: 3200,
+				ideal: 3840,
+				max: 4096
+			},
+			height: {
+				min: 1800,
+				ideal: 2160,
+				max: 2400
+			}
+		};
+		case 1: return {
+			width: {
+				min: 1400,
+				ideal: 1920,
+				max: 2160
+			},
+			height: {
+				min: 900,
+				ideal: 1080,
+				max: 1440
+			}
+		};
+		case 2: return {
+			width: {
+				min: 800,
+				ideal: 1400,
+				max: 1920
+			},
+			height: {
+				min: 600,
+				ideal: 900,
+				max: 1080
+			}
+		};
+		case 3: return {
+			width: {
+				min: 640,
+				ideal: 800,
+				max: 1400
+			},
+			height: {
+				min: 480,
+				ideal: 480,
+				max: 900
+			}
+		};
+		case 4: return {
+			width: {
+				min: 640,
+				ideal: 640,
+				max: 800
+			},
+			height: {
+				min: 480,
+				ideal: 480,
+				max: 600
+			}
+		};
+		case 5:
+		default: return {};
+	}
+}
+function getDesktopConstraints(options, level = 0) {
+	const { deviceId } = options;
+	const resolution = getDesktopVideoConstraints(level);
+	return {
+		audio: isSafari(),
+		video: {
+			facingMode: "user",
+			deviceId: deviceId ? { exact: deviceId } : void 0,
+			...resolution
+		}
+	};
+}
+async function getDesktopCameraStream(options, fallbackLevel = 0) {
+	if (fallbackLevel > 5) throw new Error("Failed to get desktop camera after all fallback attempts");
+	const constraints = getDesktopConstraints(options, fallbackLevel);
+	try {
+		return await requestCameraAccess(constraints);
+	} catch (error) {
+		const nextLevel = fallbackLevel + 1;
+		if (nextLevel > 5) throw error;
+		return getDesktopCameraStream(options, nextLevel);
+	}
+}
+async function getBackCameraStream(deviceId) {
+	if (isIOS()) return { stream: await getIOSCameraStream() };
+	if (isAndroid()) return getAndroidBackCameraStream(0);
+	return { stream: await getDesktopCameraStream({ deviceId }) };
+}
+
+//#endregion
+export { getDesktopCameraStream as n, getBackCameraStream as t };

package/dist/browserSimulation-gxD8cSpM.esm.js

@@ -0,0 +1,20 @@
+//#region src/internal/device/browserSimulation.ts
+const AUTOMATION_MARKERS = {
+	window: [
+		"callPhantom",
+		"_phantom",
+		"phantom",
+		"__nightmare",
+		"domAutomation",
+		"domAutomationController"
+	],
+	navigator: ["webdriver"]
+};
+function isBrowserSimulation(browserEnv) {
+	for (const prop of AUTOMATION_MARKERS.window) if (browserEnv.getWindowProperty(prop)) return true;
+	for (const prop of AUTOMATION_MARKERS.navigator) if (browserEnv.getNavigatorProperty(prop)) return true;
+	return false;
+}
+
+//#endregion
+export { isBrowserSimulation as t };

package/dist/camera-DBSxa6ML.d.ts

@@ -0,0 +1,4 @@
+//#region ../infra/src/media/camera.d.ts
+type CameraStream = MediaStream;
+//#endregion
+export { CameraStream as t };

package/dist/camera-PA2Ljri3.esm.js

@@ -0,0 +1,22 @@
+//#region ../infra/src/media/camera.ts
+/**
+* Request camera access with specific constraints.
+* Throws if the request fails - no automatic fallback.
+*/
+async function requestCameraAccess(constraints) {
+	if (typeof navigator === "undefined" || !navigator.mediaDevices) throw new Error("MediaDevices API not available");
+	return navigator.mediaDevices.getUserMedia(constraints);
+}
+function stopCameraStream(stream) {
+	for (const track of stream.getTracks()) track.stop();
+}
+async function enumerateVideoDevices() {
+	if (typeof navigator === "undefined" || !navigator.mediaDevices) return [];
+	return (await navigator.mediaDevices.enumerateDevices()).filter((d) => d.kind === "videoinput");
+}
+async function applyTrackConstraints(track, constraints) {
+	await track.applyConstraints(constraints);
+}
+
+//#endregion
+export { stopCameraStream as i, enumerateVideoDevices as n, requestCameraAccess as r, applyTrackConstraints as t };