@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/authentication.esm.js

@@ -1,25 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,346 +0,0 @@
-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

@@ -1,20 +0,0 @@
-//#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

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

package/dist/camera-PA2Ljri3.esm.js

@@ -1,22 +0,0 @@
-//#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 };