@incodetech/core 0.0.0-dev-20260209-168e887 → 0.0.0-dev-20260212-7db2d06

package/dist/curp-validation.esm.js

@@ -0,0 +1,548 @@
+import { n as eventModuleNames, r as eventScreenNames, u as screenOpened } from "./events-CuIAKgDr.esm.js";
+import { E as createManager } from "./src-CGwA8Bgy.esm.js";
+import { a as fromPromise, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-DxmUJ8rX.esm.js";
+import { t as api } from "./api-DlSxxyGw.esm.js";
+
+//#region src/modules/curp-validation/curpValidationUtils.ts
+const CURP_PATTERN = /^([A-Z][AEIOUX][A-Z]{2}\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])[HMX](?:AS|B[CS]|C[CLMSH]|D[FG]|G[TR]|HG|JC|M[CNS]|N[ETL]|OC|PL|Q[TR]|S[PLR]|T[CSL]|VZ|YN|ZS)[B-DF-HJ-NP-TV-Z]{3}[A-Z\d])(\d)$/;
+const CURP_LENGTH = 18;
+function isValidCurp(curp) {
+	return typeof curp === "string" && curp.length === CURP_LENGTH && CURP_PATTERN.test(curp.toUpperCase());
+}
+/** Convert YYYY-MM-DD to DD/MM/YYYY for the API */
+function formatDateForApi(date) {
+	const [year, month, day] = date.split("-");
+	return `${day}/${month}/${year}`;
+}
+const mexicanStates = [
+	{
+		value: "NE",
+		label: "Born Abroad"
+	},
+	{
+		value: "AS",
+		label: "Aguascalientes"
+	},
+	{
+		value: "BC",
+		label: "Baja California"
+	},
+	{
+		value: "BS",
+		label: "Baja California Sur"
+	},
+	{
+		value: "CC",
+		label: "Campeche"
+	},
+	{
+		value: "CL",
+		label: "Coahuila de Zaragoza"
+	},
+	{
+		value: "CM",
+		label: "Colima"
+	},
+	{
+		value: "CS",
+		label: "Chiapas"
+	},
+	{
+		value: "CH",
+		label: "Chihuahua"
+	},
+	{
+		value: "DF",
+		label: "Distrito Federal"
+	},
+	{
+		value: "DG",
+		label: "Durango"
+	},
+	{
+		value: "GT",
+		label: "Guanajuato"
+	},
+	{
+		value: "GR",
+		label: "Guerrero"
+	},
+	{
+		value: "HG",
+		label: "Hidalgo"
+	},
+	{
+		value: "JC",
+		label: "Jalisco"
+	},
+	{
+		value: "MC",
+		label: "Estado de México"
+	},
+	{
+		value: "MN",
+		label: "Michoacan de Ocampo"
+	},
+	{
+		value: "MS",
+		label: "Morelos"
+	},
+	{
+		value: "NT",
+		label: "Nayarit"
+	},
+	{
+		value: "NL",
+		label: "Nuevo León"
+	},
+	{
+		value: "OC",
+		label: "Oaxaca"
+	},
+	{
+		value: "PL",
+		label: "Puebla"
+	},
+	{
+		value: "QT",
+		label: "Queretaro de Arteaga"
+	},
+	{
+		value: "QR",
+		label: "Quintana Roo"
+	},
+	{
+		value: "SP",
+		label: "San Luis Potosi"
+	},
+	{
+		value: "SL",
+		label: "Sinaloa"
+	},
+	{
+		value: "SR",
+		label: "Sonora"
+	},
+	{
+		value: "TC",
+		label: "Tabasco"
+	},
+	{
+		value: "TS",
+		label: "Tamaulipas"
+	},
+	{
+		value: "TL",
+		label: "Tlaxcala"
+	},
+	{
+		value: "VZ",
+		label: "Veracruz"
+	},
+	{
+		value: "YN",
+		label: "Yucatan"
+	},
+	{
+		value: "ZS",
+		label: "Zacatecas"
+	}
+];
+function isGenerateFormValid(form) {
+	return !!(form.name && form.firstLastName && form.gender && form.birthDate && form.birthState);
+}
+
+//#endregion
+//#region src/modules/curp-validation/curpValidationServices.ts
+async function fetchOcrData(signal) {
+	const res = await api.get(endpoints.ocrData, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.ocrData} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function addCurp(curp, signal) {
+	const res = await api.post(endpoints.addCurp, { curp }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addCurp} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function addCurpV2(form, signal) {
+	const payload = {
+		name: form.name,
+		firstLastName: form.firstLastName,
+		secondLastName: form.secondLastName,
+		gender: form.gender,
+		birthDate: formatDateForApi(form.birthDate),
+		state: form.birthState
+	};
+	const res = await api.post(endpoints.addCurpV2, payload, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addCurpV2} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/curp-validation/curpValidationStateMachine.ts
+const DEFAULT_GENERATE_FORM = {
+	name: "",
+	firstLastName: "",
+	secondLastName: "",
+	gender: "",
+	birthDate: "",
+	birthState: ""
+};
+const curpValidationMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchOcrData: fromPromise(async ({ signal }) => {
+			return fetchOcrData(signal);
+		}),
+		verifyCurp: fromPromise(async ({ input, signal }) => {
+			return addCurp(input.curp, signal);
+		}),
+		generateCurpActor: fromPromise(async ({ input, signal }) => {
+			return addCurpV2(input.form, signal);
+		})
+	},
+	actions: {
+		setCurpFromOcr: assign(({ event }) => {
+			const curp = (event.output?.curp ?? "").toUpperCase();
+			return {
+				curp,
+				isValid: isValidCurp(curp)
+			};
+		}),
+		setCurp: assign(({ event }) => {
+			const curp = event.curp.toUpperCase();
+			return {
+				curp,
+				isValid: isValidCurp(curp)
+			};
+		}),
+		setGenerateForm: assign(({ context, event }) => {
+			const e = event;
+			const form = {
+				...context.generateForm,
+				...e.form
+			};
+			return {
+				generateForm: form,
+				isGenerateFormValid: isGenerateFormValid(form)
+			};
+		}),
+		setGeneratedCurp: assign(({ event }) => {
+			const curp = event.output?.curp ?? "";
+			return {
+				generatedCurp: curp,
+				curp,
+				isValid: isValidCurp(curp)
+			};
+		}),
+		decrementRetries: assign(({ context }) => ({ retriesLeft: Math.max(0, context.retriesLeft - 1) })),
+		setFromGenerate: assign({ fromGenerate: () => true }),
+		clearFromGenerate: assign({ fromGenerate: () => false }),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		trackEnterCurp: () => {
+			screenOpened(eventModuleNames.curpValidation, eventScreenNames.curpEnter);
+		},
+		trackGenerateCurp: () => {
+			screenOpened(eventModuleNames.curpValidation, eventScreenNames.curpGenerate);
+		},
+		trackValidationProgress: () => {
+			screenOpened(eventModuleNames.curpValidation, eventScreenNames.curpValidation);
+		},
+		trackValidationSuccess: () => {
+			screenOpened(eventModuleNames.curpValidation, eventScreenNames.curpValidationSuccess);
+		},
+		trackValidationFailed: () => {
+			screenOpened(eventModuleNames.curpValidation, eventScreenNames.curpValidationFailed);
+		}
+	},
+	guards: {
+		hasPrefillFromOcr: ({ context }) => context.config.prefillFromOcr !== false,
+		hasOcrCurp: ({ event }) => {
+			return !!event.output?.curp?.trim();
+		},
+		canRetry: ({ context }) => context.retriesLeft > 0,
+		isDeceased: ({ event }) => {
+			return event.output?.deceasedStatus === "DECEASED";
+		},
+		isScrapingFallback: ({ event }) => {
+			return event.output?.result === "Attempting validation by scraping method";
+		},
+		isGenerateSuccess: ({ event }) => {
+			const output = event.output;
+			return !!(output?.success && output?.curp);
+		},
+		isVerifySuccess: ({ event }) => {
+			return event.output?.success === true;
+		},
+		fromGeneratePath: ({ context }) => context.fromGenerate,
+		isGenerateFormValidGuard: ({ context }) => context.isGenerateFormValid,
+		isValidCurpGuard: ({ context }) => context.isValid
+	}
+}).createMachine({
+	id: "curpValidation",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		curp: "",
+		isValid: false,
+		generateForm: { ...DEFAULT_GENERATE_FORM },
+		isGenerateFormValid: false,
+		retriesLeft: input.config.maxRetries ?? 1,
+		generatedCurp: void 0,
+		error: void 0,
+		fromGenerate: false
+	}),
+	states: {
+		idle: { on: {
+			LOAD: [{
+				target: "loading",
+				guard: "hasPrefillFromOcr"
+			}, {
+				target: "enterCurp",
+				actions: "trackEnterCurp"
+			}],
+			CLOSE: "closed"
+		} },
+		loading: {
+			invoke: {
+				id: "fetchOcrData",
+				src: "fetchOcrData",
+				onDone: [{
+					target: "verifying",
+					guard: "hasOcrCurp",
+					actions: ["setCurpFromOcr", "trackValidationProgress"]
+				}, {
+					target: "enterCurp",
+					actions: "trackEnterCurp"
+				}],
+				onError: {
+					target: "enterCurp",
+					actions: "trackEnterCurp"
+				}
+			},
+			on: { CLOSE: "closed" }
+		},
+		enterCurp: { on: {
+			SET_CURP: { actions: "setCurp" },
+			VERIFY: {
+				target: "verifying",
+				guard: "isValidCurpGuard",
+				actions: "trackValidationProgress"
+			},
+			SWITCH_TO_GENERATE: {
+				target: "generateCurp",
+				actions: ["setFromGenerate", "trackGenerateCurp"]
+			},
+			CLOSE: "closed"
+		} },
+		verifying: {
+			invoke: {
+				id: "verifyCurp",
+				src: "verifyCurp",
+				input: ({ context }) => ({ curp: context.curp }),
+				onDone: [{
+					target: "success",
+					guard: "isVerifySuccess"
+				}, {
+					target: "failure",
+					actions: ["decrementRetries", "trackValidationFailed"]
+				}],
+				onError: {
+					target: "failure",
+					actions: [
+						"decrementRetries",
+						"setError",
+						"trackValidationFailed"
+					]
+				}
+			},
+			on: { CLOSE: "closed" }
+		},
+		success: {
+			entry: "trackValidationSuccess",
+			after: { 3e3: "finished" },
+			on: { CLOSE: "closed" }
+		},
+		failure: {
+			entry: "trackValidationFailed",
+			on: {
+				RETRY: [{
+					target: "generateCurp",
+					guard: ({ context }) => context.retriesLeft > 0 && context.fromGenerate,
+					actions: "trackGenerateCurp"
+				}, {
+					target: "enterCurp",
+					guard: ({ context }) => context.retriesLeft > 0 && !context.fromGenerate,
+					actions: ["clearFromGenerate", "trackEnterCurp"]
+				}],
+				CLOSE: "closed"
+			},
+			after: { 3e3: [{
+				target: "finished",
+				guard: ({ context }) => context.retriesLeft <= 0
+			}] }
+		},
+		generateCurp: { on: {
+			SET_GENERATE_FORM: { actions: "setGenerateForm" },
+			GENERATE: {
+				target: "generating",
+				guard: "isGenerateFormValidGuard",
+				actions: "trackValidationProgress"
+			},
+			CLOSE: "closed"
+		} },
+		generating: {
+			invoke: {
+				id: "generateCurpActor",
+				src: "generateCurpActor",
+				input: ({ context }) => ({ form: context.generateForm }),
+				onDone: [
+					{
+						target: "finished",
+						guard: "isScrapingFallback"
+					},
+					{
+						target: "finished",
+						guard: "isDeceased"
+					},
+					{
+						target: "confirmCurp",
+						guard: "isGenerateSuccess",
+						actions: "setGeneratedCurp"
+					},
+					{
+						target: "generateError",
+						actions: ["setFromGenerate", "trackValidationFailed"]
+					}
+				],
+				onError: {
+					target: "generateError",
+					actions: [
+						"setFromGenerate",
+						"setError",
+						"trackValidationFailed"
+					]
+				}
+			},
+			on: { CLOSE: "closed" }
+		},
+		confirmCurp: { on: {
+			CONFIRM: {
+				target: "verifying",
+				actions: "trackValidationProgress"
+			},
+			CLOSE: "closed"
+		} },
+		generateError: {
+			entry: "trackValidationFailed",
+			on: {
+				RETRY: {
+					target: "generateCurp",
+					guard: "canRetry",
+					actions: ["decrementRetries", "trackGenerateCurp"]
+				},
+				CLOSE: "closed"
+			},
+			after: { 3e3: [{
+				target: "finished",
+				guard: ({ context }) => context.retriesLeft <= 0
+			}] }
+		},
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/curp-validation/curpValidationActor.ts
+function createCurpValidationActor(options) {
+	return createActor(curpValidationMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/curp-validation/curpValidationManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loading")) return { status: "loading" };
+	if (typedSnapshot.matches("enterCurp")) return {
+		status: "enterCurp",
+		curp: context.curp,
+		isValid: context.isValid
+	};
+	if (typedSnapshot.matches("verifying")) return { status: "verifying" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("failure")) return {
+		status: "failure",
+		retriesLeft: context.retriesLeft
+	};
+	if (typedSnapshot.matches("generateCurp")) return {
+		status: "generateCurp",
+		form: context.generateForm,
+		isValid: context.isGenerateFormValid
+	};
+	if (typedSnapshot.matches("generating")) return { status: "generating" };
+	if (typedSnapshot.matches("confirmCurp")) return {
+		status: "confirmCurp",
+		curp: context.curp
+	};
+	if (typedSnapshot.matches("generateError")) return {
+		status: "generateError",
+		retriesLeft: context.retriesLeft
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setCurp(curp) {
+			actor.send({
+				type: "SET_CURP",
+				curp
+			});
+		},
+		verify() {
+			actor.send({ type: "VERIFY" });
+		},
+		switchToGenerate() {
+			actor.send({ type: "SWITCH_TO_GENERATE" });
+		},
+		setGenerateForm(form) {
+			actor.send({
+				type: "SET_GENERATE_FORM",
+				form
+			});
+		},
+		generate() {
+			actor.send({ type: "GENERATE" });
+		},
+		confirmGenerated() {
+			actor.send({ type: "CONFIRM" });
+		},
+		retry() {
+			actor.send({ type: "RETRY" });
+		},
+		close() {
+			actor.send({ type: "CLOSE" });
+		}
+	};
+}
+function createCurpValidationManager(options) {
+	return createManager({
+		actor: createCurpValidationActor(options),
+		mapState,
+		createApi
+	});
+}
+
+//#endregion
+export { createCurpValidationManager, curpValidationMachine, mexicanStates };

package/dist/{deepsightLoader-DHzfMqHS.esm.js → deepsightLoader-ClEe-KdI.esm.js}

@@ -1,7 +1,7 @@
-import { g as BrowserEnvironmentProvider, l as MotionSensorProvider, r as WasmUtilProvider, s as VisibilityProvider } from "./src-BFHUdMI6.esm.js";
-import { t as createDeepsightService } from "./deepsightService-DLabZ49g.esm.js";
-import "./api-Cqrn4bGi.esm.js";
-import "./stats-DuS7aVaJ.esm.js";
+import { g as BrowserEnvironmentProvider, l as MotionSensorProvider, r as WasmUtilProvider, s as VisibilityProvider } from "./src-CGwA8Bgy.esm.js";
+import { t as createDeepsightService } from "./deepsightService-DY1w5Amz.esm.js";
+import "./api-DlSxxyGw.esm.js";
+import "./stats-ftyC31aH.esm.js";
 
 //#region src/internal/deepsight/deepsightLoader.ts
 const SDK_VERSION = "2.0.0";

package/dist/{deepsightService-DLabZ49g.esm.js → deepsightService-DY1w5Amz.esm.js}

@@ -1,6 +1,6 @@
-import { A as getUserAgent, O as getDeviceInfo, T as stopCameraStream, b as createHiddenVideoElement, w as requestCameraAccess, x as IncodeCanvas } from "./src-BFHUdMI6.esm.js";
-import { t as api } from "./api-Cqrn4bGi.esm.js";
-import { t as addDeviceStats } from "./stats-DuS7aVaJ.esm.js";
+import { A as getUserAgent, O as getDeviceInfo, T as stopCameraStream, b as createHiddenVideoElement, w as requestCameraAccess, x as IncodeCanvas } from "./src-CGwA8Bgy.esm.js";
+import { t as api } from "./api-DlSxxyGw.esm.js";
+import { t as addDeviceStats } from "./stats-ftyC31aH.esm.js";
 
 //#region src/internal/device/browserSimulation.ts
 const AUTOMATION_MARKERS = {

package/dist/{deepsightService-D9Isk8fg.d.ts → deepsightService-X02Vowli.d.ts}

@@ -1,5 +1,5 @@
-import { r as CameraStream } from "./types-u31qr1MR.js";
-import { s as WasmPipeline } from "./types-Dc1nBvy2.js";
+import { r as CameraStream } from "./types-DGhQYTse.js";
+import { r as WasmPipeline } from "./StateMachine-BTwgcH8g.js";
 
 //#region ../infra/src/media/canvas.d.ts
 /**

package/dist/email.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-BiAYYF50.js";
+import { t as Manager } from "./Manager-DfrNSCCo.js";
 
 //#region src/modules/email/types.d.ts
 

package/dist/email.esm.js

@@ -1,7 +1,7 @@
-import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-CieIKgPk.esm.js";
-import { E as createManager, p as BrowserTimerProvider } from "./src-BFHUdMI6.esm.js";
-import { a as fromPromise, i as fromCallback, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-CJtl25ka.esm.js";
-import { t as api } from "./api-Cqrn4bGi.esm.js";
+import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-CuIAKgDr.esm.js";
+import { E as createManager, p as BrowserTimerProvider } from "./src-CGwA8Bgy.esm.js";
+import { a as fromPromise, i as fromCallback, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-DxmUJ8rX.esm.js";
+import { t as api } from "./api-DlSxxyGw.esm.js";
 
 //#region src/modules/email/emailServices.ts
 async function fetchEmail(signal) {

package/dist/{endpoints-CJtl25ka.esm.js → endpoints-DxmUJ8rX.esm.js}

@@ -3291,7 +3291,10 @@ const endpoints = {
 	deviceFingerprint: "/omni/add/device-fingerprint",
 	onboardingStatus: "/omni/get/onboarding/status",
 	customFields: "/omni/get/custom-fields",
-	deviceRiskClientId: "/omni/device-risk-client-id"
+	deviceRiskClientId: "/omni/device-risk-client-id",
+	ocrData: "/omni/get/ocr-data",
+	addCurp: "/omni/add/curp",
+	addCurpV2: "/omni/add/curp/v2"
 };
 
 //#endregion

package/dist/{events-CieIKgPk.esm.js → events-CuIAKgDr.esm.js}

@@ -1,5 +1,5 @@
-import { t as endpoints } from "./endpoints-CJtl25ka.esm.js";
-import { i as isApiConfigured, r as getToken, t as api } from "./api-Cqrn4bGi.esm.js";
+import { t as endpoints } from "./endpoints-DxmUJ8rX.esm.js";
+import { i as isApiConfigured, r as getToken, t as api } from "./api-DlSxxyGw.esm.js";
 
 //#region ../infra/src/capabilities/IBrowserEnvironmentCapability.ts
 function getTimestamp() {

package/dist/face-match.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-BiAYYF50.js";
+import { t as Manager } from "./Manager-DfrNSCCo.js";
 
 //#region src/modules/face-match/types.d.ts
 

package/dist/face-match.esm.js

@@ -1,7 +1,7 @@
-import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-CieIKgPk.esm.js";
-import { E as createManager } from "./src-BFHUdMI6.esm.js";
-import { a as fromPromise, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-CJtl25ka.esm.js";
-import { t as api } from "./api-Cqrn4bGi.esm.js";
+import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-CuIAKgDr.esm.js";
+import { E as createManager } from "./src-CGwA8Bgy.esm.js";
+import { a as fromPromise, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-DxmUJ8rX.esm.js";
+import { t as api } from "./api-DlSxxyGw.esm.js";
 
 //#region src/modules/face-match/faceMatchServices.ts
 /**

package/dist/{faceCaptureManagerFactory-CZgmP4pc.d.ts → faceCaptureManagerFactory-CNQN7doV.d.ts}

@@ -1,6 +1,7 @@
-import { a as IRecordingCapability, c as MLProviderConfig, i as IStorageCapability, n as PermissionStatus, r as CameraStream } from "./types-u31qr1MR.js";
-import { s as WasmPipeline, t as Flow } from "./types-Dc1nBvy2.js";
-import { t as Manager } from "./Manager-BiAYYF50.js";
+import { a as IRecordingCapability, c as MLProviderConfig, i as IStorageCapability, n as PermissionStatus, r as CameraStream } from "./types-DGhQYTse.js";
+import { r as WasmPipeline } from "./StateMachine-BTwgcH8g.js";
+import { t as Manager } from "./Manager-DfrNSCCo.js";
+import { t as Flow } from "./types-c0XgGLsM.js";
 
 //#region ../infra/src/capabilities/IWasmUtilCapability.d.ts
 type WasmUtilConfig = MLProviderConfig & {

package/dist/{faceCaptureSetup-DRbBF7AJ.esm.js → faceCaptureSetup-iJblI_NP.esm.js}

@@ -1,9 +1,9 @@
-import { d as addEvent, n as eventModuleNames } from "./events-CieIKgPk.esm.js";
-import { E as createManager, T as stopCameraStream, _ as StreamCanvasProcessingSession, a as FaceDetectionProvider, c as OpenViduRecordingProvider, u as LocalRecordingProvider, v as StreamCanvasCapture, w as requestCameraAccess } from "./src-BFHUdMI6.esm.js";
-import { a as fromPromise, i as fromCallback, n as setup, r as assign, t as endpoints } from "./endpoints-CJtl25ka.esm.js";
-import { a as uploadDeepsightVideo, c as getDeviceClass, i as stopRecording$1, n as createRecordingSession, o as checkPermission, r as startRecording, s as requestPermission, t as streamingEvents } from "./streamingEvents-DM6KFfsz.esm.js";
-import { r as getToken, t as api } from "./api-Cqrn4bGi.esm.js";
-import { t as addDeviceStats } from "./stats-DuS7aVaJ.esm.js";
+import { d as addEvent, n as eventModuleNames } from "./events-CuIAKgDr.esm.js";
+import { E as createManager, T as stopCameraStream, _ as StreamCanvasProcessingSession, a as FaceDetectionProvider, c as OpenViduRecordingProvider, u as LocalRecordingProvider, v as StreamCanvasCapture, w as requestCameraAccess } from "./src-CGwA8Bgy.esm.js";
+import { a as fromPromise, i as fromCallback, n as setup, r as assign, t as endpoints } from "./endpoints-DxmUJ8rX.esm.js";
+import { a as uploadDeepsightVideo, c as getDeviceClass, i as stopRecording$1, n as createRecordingSession, o as checkPermission, r as startRecording, s as requestPermission, t as streamingEvents } from "./streamingEvents-IkhAllE0.esm.js";
+import { r as getToken, t as api } from "./api-DlSxxyGw.esm.js";
+import { t as addDeviceStats } from "./stats-ftyC31aH.esm.js";
 
 //#region src/internal/faceCapture/faceCaptureManagerFactory.ts
 function getPermissionStatus(snapshot) {
@@ -444,7 +444,7 @@ function stopRecording(session) {
 	})();
 }
 async function initializeDeepsightSession(options) {
-	const { loadDeepsightSession } = await import("./deepsightLoader-DHzfMqHS.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-ClEe-KdI.esm.js");
 	return loadDeepsightSession({
 		ds: options.ds,
 		storage: options.storage

package/dist/flow.d.ts

@@ -1,5 +1,6 @@
-import { a as AnyStateMachine, n as FlowModule, r as FlowModuleConfig, s as WasmPipeline, t as Flow } from "./types-Dc1nBvy2.js";
-import { t as Manager } from "./Manager-BiAYYF50.js";
+import { r as WasmPipeline, t as AnyStateMachine } from "./StateMachine-BTwgcH8g.js";
+import { t as Manager } from "./Manager-DfrNSCCo.js";
+import { n as FlowModule, r as FlowModuleConfig, t as Flow } from "./types-c0XgGLsM.js";
 
 //#region src/modules/flow/flowAnalyzer.d.ts