@incodetech/core 0.0.0-dev-20260409-a38d5e8 → 0.0.0-dev-20260409-09dfd52

package/dist/redirect-to-mobile.esm.js

@@ -1,251 +1,9 @@
-import { t as api } from "./api-DzpnV6O7.esm.js";
-import { _ as endpoints, n as eventModuleNames, o as createManagerInstrumentation } from "./events-DlHrOIRc.esm.js";
-import { a as createActor, i as fromPromise, n as assign, o as createManager, r as fromCallback, t as setup } from "./xstate.esm-Bv55-lJ4.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BhD2MlHg.esm.js";
+import "./api-aa9Mx20l.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-W91zLpx4.esm.js";
+import { a as createActor, o as createManager } from "./xstate.esm-B7FPE6br.esm.js";
+import "./BrowserTimerProvider-v7bpbrAk.esm.js";
+import { t as redirectToMobileMachine } from "./redirectToMobileStateMachine-vOe27Ufw.esm.js";
 
-//#region ../infra/src/url/urlUtils.ts
-function getUrlSearchParam(url, param) {
-	try {
-		return new URL(url).searchParams.get(param);
-	} catch {
-		return null;
-	}
-}
-function buildUrlWithSearchParams(baseUrl, params) {
-	const url = new URL(baseUrl);
-	for (const [key, value] of Object.entries(params)) if (value !== void 0) url.searchParams.set(key, value);
-	return url.href;
-}
-
-//#endregion
-//#region src/modules/redirect-to-mobile/redirectToMobileServices.ts
-async function fetchRedirectUrl(signal) {
-	const res = await api.get(endpoints.onboardingUrl, { signal });
-	if (!res.ok) throw new Error(`GET ${endpoints.onboardingUrl} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-async function fetchOnboardingStatus(signal) {
-	const res = await api.get(endpoints.onboardingStatus, { signal });
-	if (!res.ok) throw new Error(`GET ${endpoints.onboardingStatus} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-async function sendRedirectSms(params, signal) {
-	const res = await api.post(endpoints.sendRedirectSms, params, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.sendRedirectSms} failed: ${res.status} ${res.statusText}`);
-}
-async function addPhoneForRedirect(phone, signal) {
-	const res = await api.post(endpoints.phone, { phone }, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.phone} failed: ${res.status} ${res.statusText}`);
-}
-async function refreshQrUuid(onboardingId, signal) {
-	const res = await api.post(endpoints.qrRefreshUuid, { onboardingId }, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.qrRefreshUuid} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-async function fetchStartInfo(signal) {
-	const res = await api.get(endpoints.startInfo, { signal });
-	if (!res.ok) throw new Error(`GET ${endpoints.startInfo} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-
-//#endregion
-//#region src/modules/redirect-to-mobile/redirectToMobileStateMachine.ts
-const POLL_INTERVAL_MS = 5e3;
-const QR_REFRESH_INTERVAL_MS = 5e3;
-function buildRedirectUrl(baseUrl, customUrl, config, urlUuid) {
-	const uuid = getUrlSearchParam(baseUrl, "uuid") ?? "";
-	return buildUrlWithSearchParams(customUrl ?? baseUrl, {
-		uuid,
-		isRedirect: "true",
-		lang: config.lang,
-		externalId: config.externalId,
-		auth_hint: config.authHint,
-		url_uuid: urlUuid || void 0
-	});
-}
-function extractUuidFromUrl(url) {
-	return getUrlSearchParam(url, "uuid") ?? "";
-}
-const redirectToMobileMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: {
-		fetchRedirectUrl: fromPromise(async ({ signal }) => {
-			return fetchRedirectUrl(signal);
-		}),
-		fetchStartInfo: fromPromise(async ({ signal }) => {
-			return fetchStartInfo(signal);
-		}),
-		pollOnboardingStatus: fromCallback(({ sendBack }) => {
-			const timer = BrowserTimerProvider.getInstance();
-			const interval = timer.setInterval(async () => {
-				try {
-					if ((await fetchOnboardingStatus()).onboardingStatus === "ONBOARDING_FINISHED") sendBack({ type: "POLL_TICK" });
-				} catch {}
-			}, POLL_INTERVAL_MS);
-			return () => timer.clearInterval(interval);
-		}),
-		refreshQrUuid: fromCallback(({ sendBack, input }) => {
-			const timer = BrowserTimerProvider.getInstance();
-			const interval = timer.setInterval(async () => {
-				try {
-					const res = await refreshQrUuid(input.uuid);
-					if (res.urlUuid) sendBack({
-						type: "QR_REFRESHED",
-						urlUuid: res.urlUuid
-					});
-				} catch {}
-			}, QR_REFRESH_INTERVAL_MS);
-			return () => timer.clearInterval(interval);
-		}),
-		sendSms: fromPromise(async ({ input, signal }) => {
-			await addPhoneForRedirect(input.phone, signal);
-			const params = input.lang ? [`lang=${input.lang}`] : [];
-			await sendRedirectSms({
-				smsType: "DESKTOP_ONBOARDING",
-				uuid: input.uuid,
-				params
-			}, signal);
-		})
-	},
-	actions: {
-		setBaseUrl: assign(({ context, event }) => {
-			const baseUrl = event.output.url;
-			return {
-				fetchedBaseUrl: baseUrl,
-				uuid: extractUuidFromUrl(baseUrl),
-				redirectUrl: buildRedirectUrl(baseUrl, context.config.url, context.config, context.urlUuid)
-			};
-		}),
-		setStartInfo: assign(({ event }) => {
-			return { phonePrefix: event.output.phonePrefix };
-		}),
-		setError: assign(({ event }) => ({ error: String(event.error) })),
-		setSmsSent: assign({ smsSent: () => true }),
-		resetSmsSent: assign({
-			smsSent: () => false,
-			error: () => void 0
-		}),
-		setSmsError: assign(({ event }) => ({ error: String(event.error) })),
-		updateQrUrl: assign(({ context, event }) => {
-			const { urlUuid } = event;
-			return {
-				urlUuid,
-				redirectUrl: buildRedirectUrl(context.fetchedBaseUrl, context.config.url, context.config, urlUuid)
-			};
-		})
-	},
-	guards: { hasPhishingResistance: ({ context }) => context.config.qrPhishingResistance === true }
-}).createMachine({
-	id: "redirectToMobile",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		redirectUrl: "",
-		fetchedBaseUrl: "",
-		uuid: "",
-		urlUuid: "",
-		phonePrefix: "",
-		smsSent: false,
-		error: void 0
-	}),
-	states: {
-		idle: { on: { LOAD: "generatingUrl" } },
-		generatingUrl: { invoke: {
-			id: "fetchRedirectUrl",
-			src: "fetchRedirectUrl",
-			onDone: {
-				target: "loadingStartInfo",
-				actions: "setBaseUrl"
-			},
-			onError: {
-				target: "error",
-				actions: "setError"
-			}
-		} },
-		loadingStartInfo: { invoke: {
-			id: "fetchStartInfo",
-			src: "fetchStartInfo",
-			onDone: {
-				target: "showingQr",
-				actions: "setStartInfo"
-			},
-			onError: { target: "showingQr" }
-		} },
-		showingQr: {
-			type: "parallel",
-			states: {
-				polling: {
-					invoke: {
-						id: "pollOnboardingStatus",
-						src: "pollOnboardingStatus"
-					},
-					on: { POLL_TICK: { target: "#redirectToMobile.finished" } }
-				},
-				qrRefresh: {
-					initial: "checking",
-					states: {
-						checking: { always: [{
-							target: "refreshing",
-							guard: "hasPhishingResistance"
-						}, { target: "inactive" }] },
-						refreshing: {
-							invoke: {
-								id: "refreshQrUuid",
-								src: "refreshQrUuid",
-								input: ({ context }) => ({ uuid: context.uuid })
-							},
-							on: { QR_REFRESHED: { actions: "updateQrUrl" } }
-						},
-						inactive: { type: "final" }
-					}
-				},
-				sms: {
-					initial: "idle",
-					states: {
-						idle: { on: { SEND_SMS: "sending" } },
-						sending: { invoke: {
-							id: "sendSms",
-							src: "sendSms",
-							input: ({ context, event }) => ({
-								phone: event.phone,
-								uuid: context.uuid,
-								lang: context.config.lang
-							}),
-							onDone: {
-								target: "sent",
-								actions: "setSmsSent"
-							},
-							onError: {
-								target: "idle",
-								actions: "setSmsError"
-							}
-						} },
-						sent: { on: {
-							SEND_SMS: "sending",
-							RESET_SMS: {
-								target: "idle",
-								actions: "resetSmsSent"
-							}
-						} }
-					}
-				}
-			},
-			on: {
-				CONTINUE_ON_DESKTOP: "closed",
-				CLOSE: "closed"
-			}
-		},
-		finished: { type: "final" },
-		closed: { type: "final" },
-		error: { on: { RETRY: "generatingUrl" } }
-	}
-});
-
-//#endregion
 //#region src/modules/redirect-to-mobile/redirectToMobileActor.ts
 function createRedirectToMobileActor(options) {
 	return createActor(redirectToMobileMachine, { input: { config: options.config } }).start();

package/dist/redirectToMobileStateMachine-vOe27Ufw.esm.js

@@ -0,0 +1,249 @@
+import { t as api } from "./api-aa9Mx20l.esm.js";
+import { _ as endpoints } from "./events-W91zLpx4.esm.js";
+import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-B7FPE6br.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-v7bpbrAk.esm.js";
+
+//#region ../infra/src/url/urlUtils.ts
+function getUrlSearchParam(url, param) {
+	try {
+		return new URL(url).searchParams.get(param);
+	} catch {
+		return null;
+	}
+}
+function buildUrlWithSearchParams(baseUrl, params) {
+	const url = new URL(baseUrl);
+	for (const [key, value] of Object.entries(params)) if (value !== void 0) url.searchParams.set(key, value);
+	return url.href;
+}
+
+//#endregion
+//#region src/modules/redirect-to-mobile/redirectToMobileServices.ts
+async function fetchRedirectUrl(signal) {
+	const res = await api.get(endpoints.onboardingUrl, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.onboardingUrl} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function fetchOnboardingStatus(signal) {
+	const res = await api.get(endpoints.onboardingStatus, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.onboardingStatus} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function sendRedirectSms(params, signal) {
+	const res = await api.post(endpoints.sendRedirectSms, params, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.sendRedirectSms} failed: ${res.status} ${res.statusText}`);
+}
+async function addPhoneForRedirect(phone, signal) {
+	const res = await api.post(endpoints.phone, { phone }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.phone} failed: ${res.status} ${res.statusText}`);
+}
+async function refreshQrUuid(onboardingId, signal) {
+	const res = await api.post(endpoints.qrRefreshUuid, { onboardingId }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.qrRefreshUuid} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function fetchStartInfo(signal) {
+	const res = await api.get(endpoints.startInfo, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.startInfo} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/redirect-to-mobile/redirectToMobileStateMachine.ts
+const POLL_INTERVAL_MS = 5e3;
+const QR_REFRESH_INTERVAL_MS = 5e3;
+function buildRedirectUrl(baseUrl, customUrl, config, urlUuid) {
+	const uuid = getUrlSearchParam(baseUrl, "uuid") ?? "";
+	return buildUrlWithSearchParams(customUrl ?? baseUrl, {
+		uuid,
+		isRedirect: "true",
+		lang: config.lang,
+		externalId: config.externalId,
+		auth_hint: config.authHint,
+		url_uuid: urlUuid || void 0
+	});
+}
+function extractUuidFromUrl(url) {
+	return getUrlSearchParam(url, "uuid") ?? "";
+}
+const redirectToMobileMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchRedirectUrl: fromPromise(async ({ signal }) => {
+			return fetchRedirectUrl(signal);
+		}),
+		fetchStartInfo: fromPromise(async ({ signal }) => {
+			return fetchStartInfo(signal);
+		}),
+		pollOnboardingStatus: fromCallback(({ sendBack }) => {
+			const timer = BrowserTimerProvider.getInstance();
+			const interval = timer.setInterval(async () => {
+				try {
+					if ((await fetchOnboardingStatus()).onboardingStatus === "ONBOARDING_FINISHED") sendBack({ type: "POLL_TICK" });
+				} catch {}
+			}, POLL_INTERVAL_MS);
+			return () => timer.clearInterval(interval);
+		}),
+		refreshQrUuid: fromCallback(({ sendBack, input }) => {
+			const timer = BrowserTimerProvider.getInstance();
+			const interval = timer.setInterval(async () => {
+				try {
+					const res = await refreshQrUuid(input.uuid);
+					if (res.urlUuid) sendBack({
+						type: "QR_REFRESHED",
+						urlUuid: res.urlUuid
+					});
+				} catch {}
+			}, QR_REFRESH_INTERVAL_MS);
+			return () => timer.clearInterval(interval);
+		}),
+		sendSms: fromPromise(async ({ input, signal }) => {
+			await addPhoneForRedirect(input.phone, signal);
+			const params = input.lang ? [`lang=${input.lang}`] : [];
+			await sendRedirectSms({
+				smsType: "DESKTOP_ONBOARDING",
+				uuid: input.uuid,
+				params
+			}, signal);
+		})
+	},
+	actions: {
+		setBaseUrl: assign(({ context, event }) => {
+			const baseUrl = event.output.url;
+			return {
+				fetchedBaseUrl: baseUrl,
+				uuid: extractUuidFromUrl(baseUrl),
+				redirectUrl: buildRedirectUrl(baseUrl, context.config.url, context.config, context.urlUuid)
+			};
+		}),
+		setStartInfo: assign(({ event }) => {
+			return { phonePrefix: event.output.phonePrefix };
+		}),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		setSmsSent: assign({ smsSent: () => true }),
+		resetSmsSent: assign({
+			smsSent: () => false,
+			error: () => void 0
+		}),
+		setSmsError: assign(({ event }) => ({ error: String(event.error) })),
+		updateQrUrl: assign(({ context, event }) => {
+			const { urlUuid } = event;
+			return {
+				urlUuid,
+				redirectUrl: buildRedirectUrl(context.fetchedBaseUrl, context.config.url, context.config, urlUuid)
+			};
+		})
+	},
+	guards: { hasPhishingResistance: ({ context }) => context.config.qrPhishingResistance === true }
+}).createMachine({
+	id: "redirectToMobile",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		redirectUrl: "",
+		fetchedBaseUrl: "",
+		uuid: "",
+		urlUuid: "",
+		phonePrefix: "",
+		smsSent: false,
+		error: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: "generatingUrl" } },
+		generatingUrl: { invoke: {
+			id: "fetchRedirectUrl",
+			src: "fetchRedirectUrl",
+			onDone: {
+				target: "loadingStartInfo",
+				actions: "setBaseUrl"
+			},
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		loadingStartInfo: { invoke: {
+			id: "fetchStartInfo",
+			src: "fetchStartInfo",
+			onDone: {
+				target: "showingQr",
+				actions: "setStartInfo"
+			},
+			onError: { target: "showingQr" }
+		} },
+		showingQr: {
+			type: "parallel",
+			states: {
+				polling: {
+					invoke: {
+						id: "pollOnboardingStatus",
+						src: "pollOnboardingStatus"
+					},
+					on: { POLL_TICK: { target: "#redirectToMobile.finished" } }
+				},
+				qrRefresh: {
+					initial: "checking",
+					states: {
+						checking: { always: [{
+							target: "refreshing",
+							guard: "hasPhishingResistance"
+						}, { target: "inactive" }] },
+						refreshing: {
+							invoke: {
+								id: "refreshQrUuid",
+								src: "refreshQrUuid",
+								input: ({ context }) => ({ uuid: context.uuid })
+							},
+							on: { QR_REFRESHED: { actions: "updateQrUrl" } }
+						},
+						inactive: { type: "final" }
+					}
+				},
+				sms: {
+					initial: "idle",
+					states: {
+						idle: { on: { SEND_SMS: "sending" } },
+						sending: { invoke: {
+							id: "sendSms",
+							src: "sendSms",
+							input: ({ context, event }) => ({
+								phone: event.phone,
+								uuid: context.uuid,
+								lang: context.config.lang
+							}),
+							onDone: {
+								target: "sent",
+								actions: "setSmsSent"
+							},
+							onError: {
+								target: "idle",
+								actions: "setSmsError"
+							}
+						} },
+						sent: { on: {
+							SEND_SMS: "sending",
+							RESET_SMS: {
+								target: "idle",
+								actions: "resetSmsSent"
+							}
+						} }
+					}
+				}
+			},
+			on: {
+				CONTINUE_ON_DESKTOP: "closed",
+				CLOSE: "closed"
+			}
+		},
+		finished: { type: "final" },
+		closed: { type: "final" },
+		error: { on: { RETRY: "generatingUrl" } }
+	}
+});
+
+//#endregion
+export { redirectToMobileMachine as t };

package/dist/runChildModule-DVC4JEjp.esm.js

@@ -0,0 +1,27 @@
+import { a as createActor, r as fromCallback } from "./xstate.esm-B7FPE6br.esm.js";
+
+//#region src/internal/orchestration/runChildModule.ts
+const runChildModule = fromCallback(({ sendBack, input }) => {
+	const { machine, config } = input;
+	if (!machine) return () => {};
+	const actor = createActor(machine, { input: { config } });
+	const subscription = actor.subscribe({
+		complete: () => {
+			sendBack({ type: "MODULE_COMPLETE" });
+		},
+		error: (err) => {
+			sendBack({
+				type: "MODULE_ERROR",
+				error: err
+			});
+		}
+	});
+	actor.start();
+	return () => {
+		subscription.unsubscribe();
+		actor.stop();
+	};
+});
+
+//#endregion
+export { runChildModule as t };

package/dist/selfie.d.ts

@@ -1,12 +1,12 @@
-import "./warmup-CIj_wEV_.js";
-import "./Manager-BN2g_I8W.js";
-import "./Actor-Ba71-_30.js";
-import "./StateMachine-BoJsfMvg.js";
-import { a as SelfieMachine, d as SelfieConfig, o as selfieMachine, v as DetectionStatus, y as FaceErrorCode } from "./faceCaptureManagerFactory-Da_-ohdg.js";
-import { t as CameraStream } from "./camera-1eeGnAaL.js";
-import "./types-2OPf1pyv.js";
-import "./types-CVJVQ7fp.js";
-import { t as DeepsightService } from "./deepsightService-ByD6uIs7.js";
-import { n as PermissionStatus, t as PermissionResult } from "./types-D_QfFKxT.js";
-import { a as ProcessFaceResponse, n as SelfieState, o as processFace, r as createSelfieManager, t as SelfieManager } from "./selfieManager-DCRP7X75.js";
+import "./warmup-Ckb1hN85.js";
+import "./Manager-DcPMRgTm.js";
+import "./Actor-DbWH1K6E.js";
+import "./StateMachine-BBuIgsHT.js";
+import { a as SelfieMachine, d as SelfieConfig, o as selfieMachine, v as DetectionStatus, y as FaceErrorCode } from "./faceCaptureManagerFactory-P2yy30KU.js";
+import { t as CameraStream } from "./camera-DATT31my.js";
+import "./types-CYJ0Ish6.js";
+import "./types-DU8HmI5U.js";
+import { t as DeepsightService } from "./deepsightService-S-tU77m-.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-CIjb0FKu.js";
+import { a as ProcessFaceResponse, n as SelfieState, o as processFace, r as createSelfieManager, t as SelfieManager } from "./selfieManager-DNwfxieF.js";
 export { type CameraStream, type DeepsightService, type DetectionStatus, type FaceErrorCode, type PermissionResult, type PermissionStatus, type ProcessFaceResponse, type SelfieConfig, type SelfieMachine, type SelfieManager, type SelfieState, createSelfieManager, processFace, selfieMachine };

package/dist/selfie.esm.js

@@ -1,21 +1,24 @@
-import "./BaseWasmProvider-D-s_6M5H.esm.js";
-import "./WasmUtilProvider-BpZSvZbg.esm.js";
-import "./api-DzpnV6O7.esm.js";
-import "./events-DlHrOIRc.esm.js";
-import "./browserSimulation-B4ubb2OL.esm.js";
-import "./xstate.esm-Bv55-lJ4.esm.js";
-import "./faceCaptureSetup-CaVWkjvE.esm.js";
-import { l as processFace } from "./recordingService-483wQ6kR.esm.js";
-import "./deepsightService-BjgXl5hs.esm.js";
-import "./camera-DmkFpf5N.esm.js";
-import "./getBrowser-Dtyt9J_h.esm.js";
-import "./stats-DHDoqSBV.esm.js";
-import "./MotionSensorProvider-CodM3e0E.esm.js";
-import "./permissionServices-Cskq32Yd.esm.js";
-import "./platform-Dv7a2fv-.esm.js";
-import "./ITimerCapability-oixwa6nj.esm.js";
-import "./backCameraStream-tabTmwDS.esm.js";
-import "./getDeviceClass-DEzz4cmY.esm.js";
-import { r as selfieMachine, t as createSelfieManager } from "./selfieManager-DeOcNel4.esm.js";
+import "./BaseWasmProvider-DoYDYH1z.esm.js";
+import "./WasmUtilProvider-mWSXzp7b.esm.js";
+import "./api-aa9Mx20l.esm.js";
+import "./events-W91zLpx4.esm.js";
+import "./browserSimulation-DFqGKQAD.esm.js";
+import "./xstate.esm-B7FPE6br.esm.js";
+import "./faceCaptureManagerFactory-Bspg2Tyf.esm.js";
+import "./BrowserStorageProvider-CXaS5Ooj.esm.js";
+import { l as processFace } from "./recordingService-CCfxUY7-.esm.js";
+import "./deepsightService-rPGLH8Xp.esm.js";
+import "./camera-DpPQS_-5.esm.js";
+import "./getBrowser-DCcD7H-M.esm.js";
+import "./stats-gFD2351t.esm.js";
+import "./MotionSensorProvider-D90R4qwV.esm.js";
+import "./permissionServices-Cisv73eQ.esm.js";
+import "./platform-DctkySJU.esm.js";
+import "./ITimerCapability-BZO_FsCo.esm.js";
+import "./backCameraStream-D9g2wyil.esm.js";
+import "./getDeviceClass-DBF-ExLR.esm.js";
+import "./faceCaptureSetup-CQevz86q.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-3b19ON1z.esm.js";
+import { t as createSelfieManager } from "./selfieManager-CorEST5h.esm.js";
 
 export { createSelfieManager, processFace, selfieMachine };

package/dist/selfieManager-CorEST5h.esm.js

@@ -0,0 +1,60 @@
+import { t as WasmUtilProvider } from "./WasmUtilProvider-mWSXzp7b.esm.js";
+import { n as eventModuleNames } from "./events-W91zLpx4.esm.js";
+import { a as createActor } from "./xstate.esm-B7FPE6br.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-Bspg2Tyf.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CXaS5Ooj.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-3b19ON1z.esm.js";
+
+//#region src/modules/selfie/selfieActor.ts
+function createSelfieActor(options) {
+	const dependencies = options.dependencies ?? {
+		storage: new BrowserStorageProvider(),
+		getWasmUtil: () => WasmUtilProvider.getInstance()
+	};
+	return createActor(selfieMachine, { input: {
+		config: options.config,
+		dependencies,
+		authHint: options.authHint
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/selfie/selfieManager.ts
+function createSelfieManagerFromActor(actor) {
+	return createFaceCaptureManagerFromActor(actor, eventModuleNames.selfie);
+}
+/**
+* Creates a selfie manager instance for handling selfie capture flow.
+*
+* The selfie 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 selfie actor
+* @param options.config - The selfie module configuration from the flow
+* @returns A manager instance with state subscription, API methods, and lifecycle controls
+*
+* @example
+* ```ts
+* const selfieManager = createSelfieManager({ config: selfieConfig });
+*
+* selfieManager.subscribe((state) => {
+*   if (state.status === 'capture') {
+*     console.log('Camera ready:', state.stream);
+*     console.log('Detection status:', state.detectionStatus);
+*   }
+* });
+*
+* selfieManager.load();
+* ```
+*/
+function createSelfieManager(options) {
+	return createFaceCaptureManagerFromActor(createSelfieActor(options), eventModuleNames.selfie);
+}
+
+//#endregion
+export { createSelfieManagerFromActor as n, createSelfieManager as t };

package/dist/{selfieManager-DCRP7X75.d.ts → selfieManager-DNwfxieF.d.ts}

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-BN2g_I8W.js";
-import { i as SelfieActor, n as FaceCaptureManagerState, r as CreateSelfieActorOptions, t as FaceCaptureManager } from "./faceCaptureManagerFactory-Da_-ohdg.js";
+import { t as Manager } from "./Manager-DcPMRgTm.js";
+import { i as SelfieActor, n as FaceCaptureManagerState, r as CreateSelfieActorOptions, t as FaceCaptureManager } from "./faceCaptureManagerFactory-P2yy30KU.js";
 
 //#region src/modules/selfie/selfieUploadService.d.ts
 type ProcessFaceImageType = 'selfie' | 'videoSelfie';