@incodetech/core 0.0.0-dev-20260407-4677d7f → 0.0.0-dev-20260407-2c382da

package/dist/{xstate.esm-BXrcOcSC.esm.js → Manager-C6AGXEq_.esm.js}

@@ -1,106 +1,6 @@
-//#region ../infra/src/manager/Manager.ts
-/**
-* Creates a manager that wraps a state machine actor with a clean public API.
-*
-* The manager provides:
-* - `getState()` - Returns the mapped public state
-* - `subscribe()` - Listen to state changes
-* - `stop()` - Stop the actor
-* - Plus any custom API methods from `createApi`
-*
-* @template TMachine - The state machine type
-* @template TMapState - Function type that maps raw snapshot to public state
-* @template TCreateApi - Function type that creates the custom API
-*
-* @param options - Configuration options
-* @param options.actor - The started actor instance
-* @param options.mapState - Function to transform raw snapshot into public state
-* @param options.createApi - Factory function to create custom API methods
-*
-* @returns Combined manager with base methods and custom API
-*
-* @example
-* ```ts
-* const manager = createManager({
-*   actor: createActor(myMachine).start(),
-*   mapState: (snapshot) => ({ status: snapshot.value }),
-*   createApi: ({ actor }) => ({
-*     doSomething() { actor.send({ type: 'DO_IT' }); }
-*   }),
-* });
-* ```
-*/
-function createManager(options) {
-	const { actor, mapState, createApi, instrumentation } = options;
-	function getSnapshot() {
-		return actor.getSnapshot();
-	}
-	function getState() {
-		return mapState(getSnapshot());
-	}
-	function subscribe(listener) {
-		const subscription = actor.subscribe(() => {
-			listener(getState());
-		});
-		return () => subscription.unsubscribe();
-	}
-	let currentScreenName = instrumentation.getScreenName(getSnapshot());
-	let currentErrorName = instrumentation.getErrorName(getSnapshot());
-	let currentErrorPayload = instrumentation.getErrorPayload(getSnapshot());
-	const api = createApi({
-		actor,
-		getSnapshot,
-		trackElementClicked: (elementName, payload) => {
-			instrumentation.onElementClicked?.(instrumentation.moduleName, currentScreenName, {
-				element: elementName,
-				action: payload?.action,
-				metadata: payload?.metadata
-			});
-		},
-		trackCaptureAttemptFinished: (payload) => {
-			instrumentation.onCaptureAttemptFinished?.(instrumentation.moduleName, currentScreenName, { logs: payload.logs });
-		}
-	});
-	instrumentation.onModuleOpened(instrumentation.moduleName);
-	if (currentScreenName !== void 0) instrumentation.onScreenOpened(instrumentation.moduleName, currentScreenName);
-	if (currentErrorName !== void 0) instrumentation.onErrorTriggered(instrumentation.moduleName, currentErrorName, currentErrorPayload);
-	const actorSubscription = actor.subscribe((snapshot) => {
-		const nextScreenName = instrumentation.getScreenName(snapshot);
-		const nextErrorName = instrumentation.getErrorName(snapshot);
-		const nextErrorPayload = instrumentation.getErrorPayload(snapshot);
-		if (currentScreenName === nextScreenName) {
-			if (nextErrorName !== void 0 && nextErrorName !== currentErrorName) instrumentation.onErrorTriggered(instrumentation.moduleName, nextErrorName, nextErrorPayload);
-			currentErrorName = nextErrorName;
-			currentErrorPayload = nextErrorPayload;
-			return;
-		}
-		if (currentScreenName !== void 0) instrumentation.onScreenClosed(instrumentation.moduleName, currentScreenName);
-		if (nextScreenName !== void 0) instrumentation.onScreenOpened(instrumentation.moduleName, nextScreenName);
-		currentScreenName = nextScreenName;
-		if (nextErrorName !== void 0 && nextErrorName !== currentErrorName) instrumentation.onErrorTriggered(instrumentation.moduleName, nextErrorName, nextErrorPayload);
-		currentErrorName = nextErrorName;
-		currentErrorPayload = nextErrorPayload;
-	});
-	let isStopped = false;
-	const base = {
-		getState,
-		subscribe,
-		stop() {
-			if (isStopped) return;
-			isStopped = true;
-			actorSubscription.unsubscribe();
-			if (currentScreenName !== void 0) instrumentation.onScreenClosed(instrumentation.moduleName, currentScreenName);
-			currentScreenName = void 0;
-			currentErrorName = void 0;
-			currentErrorPayload = void 0;
-			instrumentation.onModuleClosed(instrumentation.moduleName);
-			actor.stop();
-		}
-	};
-	return Object.defineProperties(base, Object.getOwnPropertyDescriptors(api));
-}
+import { i as isApiConfigured, r as getToken, t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-CI5-28jT.esm.js";
 
-//#endregion
 //#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dev/dist/xstate-dev.esm.js
 function getGlobal() {
 	if (typeof globalThis !== "undefined") return globalThis;
@@ -3361,4 +3261,508 @@ function setup({ schemas, actors, actions, guards, delays }) {
 }
 
 //#endregion
-export { createActor as a, fromPromise as i, assign as n, createManager as o, fromCallback as r, setup as t };
+//#region ../infra/src/capabilities/IBrowserEnvironmentCapability.ts
+function getTimestamp() {
+	return Date.now();
+}
+function revokeObjectURL(url) {
+	URL.revokeObjectURL(url);
+}
+
+//#endregion
+//#region src/internal/events/addEvent.ts
+const INTERVIEW_EVENTS_MAX_SCREEN_LENGTH = 50;
+function normalizeScreenForInterviewEventsApi(screenValue) {
+	const limit = INTERVIEW_EVENTS_MAX_SCREEN_LENGTH;
+	if (screenValue.length <= limit) return screenValue;
+	const head = screenValue.slice(0, limit);
+	const lastDot = head.lastIndexOf(".");
+	const lastPlus = head.lastIndexOf("+");
+	const lastBoundary = Math.max(lastDot, lastPlus);
+	if (lastBoundary > 0) return head.slice(0, lastBoundary);
+	return head;
+}
+const eventsQueue = [];
+const eventSubscribers = [];
+/**
+* Subscribes to all SDK events for logging, debugging, or custom analytics.
+* Returns an unsubscribe function.
+*
+* @param listener - Callback function that receives each event
+* @returns Unsubscribe function to remove the listener
+*
+* @example
+* ```typescript
+* const unsubscribe = subscribeEvent((event) => {
+*   console.log('[Event]', event.code, event.module);
+* });
+*
+* // Later
+* unsubscribe();
+* ```
+*/
+function subscribeEvent(listener) {
+	eventSubscribers.push(listener);
+	return () => {
+		const index = eventSubscribers.indexOf(listener);
+		if (index > -1) eventSubscribers.splice(index, 1);
+	};
+}
+function notifySubscribers(event) {
+	eventSubscribers.forEach((listener) => {
+		try {
+			listener(event);
+		} catch (_error) {}
+	});
+}
+/**
+* Sends an event to the dashboard for tracking.
+* Fire-and-forget: never blocks, never throws.
+* Events are queued if SDK is not configured yet.
+*/
+function addEvent(event) {
+	notifySubscribers(event);
+	const token = getToken();
+	if (!isApiConfigured() || !token) {
+		eventsQueue.push(event);
+		return;
+	}
+	const screenForApi = event.screen !== void 0 ? normalizeScreenForInterviewEventsApi(event.screen) : void 0;
+	api.post(endpoints.events, [{
+		code: event.code,
+		module: event.module,
+		screen: screenForApi,
+		clientTimestamp: event.clientTimestamp ?? getTimestamp(),
+		payload: event.payload ?? {}
+	}]).catch(() => {});
+}
+/**
+* Flushes any queued events that were sent before SDK was configured.
+* Called automatically by setup() after token is set.
+*/
+function flushEventQueue() {
+	if (!isApiConfigured() || !getToken()) return;
+	const queuedEvents = [...eventsQueue];
+	eventsQueue.length = 0;
+	for (const event of queuedEvents) addEvent(event);
+}
+
+//#endregion
+//#region src/internal/events/helpers.ts
+function screenEvent(params) {
+	addEvent({
+		code: params.code,
+		module: params.module,
+		screen: params.screen,
+		clientTimestamp: getTimestamp(),
+		payload: params.payload
+	});
+}
+function moduleOpened(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "moduleOpened",
+		payload
+	});
+}
+function moduleClosed(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "moduleClosed",
+		payload
+	});
+}
+function screenOpened(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "screenOpened",
+		payload
+	});
+}
+function screenClosed(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "screenClosed",
+		payload
+	});
+}
+function errorTriggered(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "errorTriggered",
+		payload
+	});
+}
+function elementClicked(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "elementClicked",
+		payload
+	});
+}
+function captureAttemptFinished(module, screen, payload) {
+	screenEvent({
+		module,
+		screen,
+		code: "captureAttemptFinished",
+		payload
+	});
+}
+
+//#endregion
+//#region src/internal/events/managerInstrumentation.ts
+function normalizeSegment(segment) {
+	if (typeof segment !== "string") return "";
+	return segment.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeDottedPath(path) {
+	return path.split("+").map((branch) => branch.split(".").map((segment) => normalizeSegment(segment)).filter((segment) => segment.length > 0).join(".")).filter((branch) => branch.length > 0).join("+");
+}
+function stateValueToScreenSegment(value) {
+	if (typeof value === "string" || typeof value === "number") {
+		const segment = normalizeSegment(String(value));
+		return segment.length > 0 ? segment : void 0;
+	}
+	if (typeof value !== "object" || value === null) return;
+	const entries = Object.entries(value).sort(([left], [right]) => {
+		if (left < right) return -1;
+		if (left > right) return 1;
+		return 0;
+	});
+	if (entries.length === 0) return;
+	const branches = entries.map(([key, nestedValue]) => {
+		const normalizedKey = normalizeSegment(key);
+		const nestedSegment = stateValueToScreenSegment(nestedValue);
+		if (normalizedKey.length === 0) return nestedSegment;
+		if (nestedSegment === void 0) return normalizedKey;
+		return `${normalizedKey}.${nestedSegment}`;
+	}).filter((branch) => branch !== void 0 && branch.length > 0);
+	if (branches.length === 0) return;
+	return branches.join("+");
+}
+function buildScreenName(moduleName, screenName) {
+	const normalizedModuleName = typeof moduleName === "string" ? moduleName.trim() : "";
+	const normalizedScreen = normalizeDottedPath(screenName);
+	if (normalizedModuleName.length === 0) return normalizedScreen;
+	if (normalizedScreen.length === 0) return normalizedModuleName;
+	return `${normalizedModuleName}.${normalizedScreen}`;
+}
+function getDefaultManagerScreenName(snapshot) {
+	return stateValueToScreenSegment(snapshot.value);
+}
+function getManagerScreenName(moduleName, snapshot, options) {
+	const mappedScreen = options?.getScreenName?.(snapshot) ?? getDefaultManagerScreenName(snapshot);
+	if (mappedScreen === void 0) return;
+	return buildScreenName(moduleName, mappedScreen);
+}
+function isErrorLikeSegment(segment) {
+	return segment === "error" || segment.includes("error") || segment.includes("failed") || segment.includes("failure");
+}
+function getDefaultManagerErrorName(snapshot) {
+	const screenSegment = stateValueToScreenSegment(snapshot.value);
+	if (screenSegment === void 0) return;
+	const normalizedSegment = normalizeDottedPath(screenSegment);
+	if (normalizedSegment.length === 0) return;
+	if (normalizedSegment === "error") return "error.unknown";
+	if (!isErrorLikeSegment(normalizedSegment)) return;
+	return `error.${normalizedSegment}`;
+}
+function createManagerInstrumentation(moduleName, options) {
+	return {
+		moduleName,
+		onModuleOpened: moduleOpened,
+		onModuleClosed: moduleClosed,
+		onScreenOpened: screenOpened,
+		onScreenClosed: screenClosed,
+		onErrorTriggered: errorTriggered,
+		onElementClicked: (moduleName$1, screenName, payload) => elementClicked(moduleName$1, screenName, payload),
+		onCaptureAttemptFinished: (moduleName$1, screenName, payload) => captureAttemptFinished(moduleName$1, screenName, payload),
+		getScreenName: (snapshot) => getManagerScreenName(moduleName, snapshot, { getScreenName: options?.getScreenName }),
+		getErrorName: (snapshot) => {
+			const mappedError = options?.getErrorName?.(snapshot) ?? getDefaultManagerErrorName(snapshot);
+			if (mappedError === void 0) return;
+			return buildScreenName(moduleName, mappedError);
+		},
+		getErrorPayload: (snapshot) => options?.getErrorPayload?.(snapshot)
+	};
+}
+
+//#endregion
+//#region src/internal/events/types.ts
+const eventModuleNames = {
+	selfie: "SELFIE",
+	authentication: "AUTHENTICATION",
+	authFace: "AUTH_FACE",
+	mlConsent: "ML_CONSENT",
+	combinedConsent: "COMBINED_CONSENT",
+	curpValidation: "CURP_VALIDATION",
+	faceMatch: "FACE_MATCH",
+	qr: "QR",
+	videoSelfie: "VIDEO_ONBOARDING",
+	passport: "ID",
+	front: "ID",
+	back: "ID",
+	id: "ID",
+	document: "DOCUMENT_CAPTURE",
+	creditCard: "CREDIT_CARD_FRONT",
+	creditCardBack: "CREDIT_CARD_BACK",
+	conference: "CONFERENCE",
+	otp: "OTP",
+	signature: "SIGNATURE",
+	ekyc: "EXTERNAL_VERIFICATION",
+	globalWatchList: "GLOBAL_WATCHLIST",
+	customWatchList: "CUSTOM_WATCHLIST",
+	email: "EMAIL",
+	phone: "PHONE",
+	instantVerifyEmail: "INSTANT_VERIFY_EMAIL",
+	instantVerifyConsent: "INSTANT_VERIFY_CONSENT",
+	forms: "FORMS",
+	customModule: "CUSTOM_MODULE",
+	geolocation: "GEOLOCATION",
+	ekyb: "EKYB",
+	antifraud: "ANTIFRAUD"
+};
+const eventScreenNames = {
+	faceMatch: "FACE_MATCH",
+	faceCaptureTutorial: "SELFIE_CAPTURE_TUTORIAL",
+	faceCaptureCamera: "SELFIE_CAMERA_CAPTURE",
+	faceCaptureError: "SELFIE_ATTEMPT_FAILED",
+	faceCaptureSuccess: "SELFIE_UPLOAD_SUCCEEDED",
+	faceCaptureUpload: "SELFIE_UPLOAD_PROGRESS",
+	mlConsent: "MACHINE_LEARNING_CONSENT",
+	combinedConsent: "COMBINED_CONSENT",
+	curpEnter: "ENTER_CURP",
+	curpValidate: "VALIDATE_CURP",
+	curpGenerate: "GENERATE_CURP",
+	curpValidation: "CURP_VALIDATION_PROGRESS",
+	curpValidationFailed: "CURP_VALIDATION_FAILED",
+	curpValidationSuccess: "CURP_VALIDATION_SUCCEEDED",
+	qrTutorial: "QR_TUTORIAL",
+	qrScan: "QR_SCAN",
+	smsOtp: "OTP",
+	simpleOTP: "OTP",
+	signatureInput: "SIGNATURE_INPUT",
+	signatureInitialsInput: "INITIALS_INPUT",
+	frontTutorial: "FRONT_ID_CAPTURE_TUTORIAL",
+	frontCameraCapture: "FRONT_ID_CAMERA_CAPTURE",
+	frontHelp: "FRONT_ID_HELP",
+	frontReviewPhoto: "FRONT_ID_REVIEW_PHOTO",
+	frontUploadProgress: "FRONT_ID_UPLOAD_PROGRESS",
+	frontAttemptFailed: "FRONT_ID_ATTEMPT_FAILED",
+	frontUploadSuccess: "FRONT_ID_UPLOAD_SUCCEEDED",
+	backTutorial: "BACK_ID_CAPTURE_TUTORIAL",
+	backCameraCapture: "BACK_ID_CAMERA_CAPTURE",
+	backReviewPhoto: "BACK_ID_REVIEW_PHOTO",
+	backUploadProgress: "BACK_ID_UPLOAD_PROGRESS",
+	backAttemptFailed: "BACK_ID_ATTEMPT_FAILED",
+	backUploadSuccess: "BACK_ID_UPLOAD_SUCCEEDED",
+	backHelp: "BACK_ID_HELP",
+	passportTutorial: "TUTORIAL_PASSPORT",
+	documentTutorial: "DOCUMENT_CAPTURE_TUTORIAL",
+	documentCameraCapture: "DOCUMENT_CAMERA_CAPTURE",
+	documentHelp: "DOCUMENT_HELP",
+	documentReviewPhoto: "DOCUMENT_REVIEW_PHOTO",
+	documentUploadProgress: "DOCUMENT_UPLOAD_IN_PROGRESS",
+	documentAttemptFailed: "DOCUMENT_ATTEMPT_FAILED",
+	documentUploadSuccess: "DOCUMENT_UPLOAD_SUCCEEDED",
+	conferenceWait: "CONFERENCE_WAIT",
+	conferenceVideoChat: "CONFERENCE_VIDEO_CHAT",
+	conferenceMessageChat: "CONFERENCE_MESSAGE_CHAT",
+	videoSelfieTutorial: "VIDEO_SELFIE_TUTORIAL",
+	videoSelfie: "VIDEO_SELFIE",
+	videoSelfieFaceCapture: "VIDEO_SELFIE_FACE_CAPTURE",
+	videoSelfieFaceUploadProgress: "VIDEO_SELFIE_FACE_UPLOAD_PROGRESS",
+	videoSelfieFaceAttemptFailed: "VIDEO_SELFIE_FACE_ATTEMPT_FAILED",
+	videoSelfieFaceUploadSucceeded: "VIDEO_SELFIE_FACE_UPLOAD_SUCCEEDED",
+	videoSelfieFrontIdCapture: "VIDEO_SELFIE_FRONT_ID_CAPTURE",
+	videoSelfieFrontIdUploadProgress: "VIDEO_SELFIE_FRONT_ID_UPLOAD_PROGRESS",
+	videoSelfieFrontIdAttemptFailed: "VIDEO_SELFIE_FRONT_ID_ATTEMPT_FAILED",
+	videoSelfieFrontIdUploadSucceeded: "VIDEO_SELFIE_FRONT_ID_UPLOAD_SUCCEEDED",
+	videoSelfieBackIdCapture: "VIDEO_SELFIE_BACK_ID_CAPTURE",
+	videoSelfieBackIdUploadProgress: "VIDEO_SELFIE_BACK_ID_UPLOAD_PROGRESS",
+	videoSelfieBackIdAttemptFailed: "VIDEO_SELFIE_BACK_ID_ATTEMPT_FAILED",
+	videoSelfieBackIdUploadSucceeded: "VIDEO_SELFIE_BACK_ID_UPLOAD_SUCCEEDED",
+	videoSelfieDocumentCapture: "VIDEO_SELFIE_DOCUMENT_CAPTURE",
+	videoSelfieVoiceQuestion: "VIDEO_SELFIE_VOICE_QUESTION",
+	videoSelfieVoiceFinalQuestion: "VIDEO_SELFIE_VOICE_FINAL_QUESTION",
+	videoSelfieVideoUpload: "VIDEO SELFIE VIDEO UPLOAD",
+	ekycInput: "EKYC_INPUT",
+	ekycProgress: "EKYC_PROGRESS",
+	ekycSucceeded: "EKYC_SUCCEEDED",
+	ekycFailed: "EKYC_FAILED",
+	forms: "FORMS",
+	globalWatchListInput: "GLOBAL_WATCHLIST_INPUT",
+	globalWatchListProgress: "GLOBAL_WATCHLIST_PROGRESS",
+	globalWatchListSuccess: "GLOBAL_WATCHLIST_SUCCEEDED",
+	globalWatchListFailed: "GLOBAL_WATCHLIST_FAILED",
+	customWatchListInput: "CUSTOM_WATCHLIST_INPUT",
+	customWatchListProgress: "CUSTOM_WATCHLIST_PROGRESS",
+	customWatchListSuccess: "CUSTOM_WATCHLIST_SUCCEEDED",
+	customWatchListFailed: "CUSTOM_WATCHLIST_FAILED",
+	emailInput: "EMAIL_INPUT",
+	phoneInput: "PHONE_INPUT",
+	instantVerify: "INSTANT_VERIFY",
+	authFace: "AUTH_FACE",
+	authFaceError: "AUTH_FACE_ATTEMPT_FAILED",
+	authFaceUpload: "AUTH_FACE_UPLOAD_PROGRESS",
+	authFaceUploadSuccess: "AUTH_FACE_UPLOAD_SUCCEEDED",
+	authFaceUploadFailed: "AUTH_FACE_UPLOAD_FAILED",
+	customModuleCallback: "CUSTOM_MODULE_CALLBACK",
+	customModuleProcessing: "CUSTOM_MODULE_PROCESSING",
+	digitalIdFileSelection: "DIGITAL_ID_FILE_SELECTION",
+	digitalIdFileReview: "DIGITAL_ID_FILE_REVIEW",
+	digitalIdUploadProgress: "DIGITAL_ID_UPLOAD_PROGRESS",
+	digitalIdUploadSuccess: "DIGITAL_ID_UPLOAD_SUCCEEDED",
+	digitalIdUploadFailed: "DIGITAL_ID_UPLOAD_FAILED",
+	digitalIdAnalysisProgress: "DIGITAL_ID_ANALYSIS_PROGRESS",
+	digitalIdVerificationSuccess: "DIGITAL_ID_VERIFICATION_SUCCESS",
+	digitalIdVerificationFailed: "DIGITAL_ID_VERIFICATION_FAILED",
+	ekybForm: "EKYB_FORM"
+};
+const videoSelfieEvents = {
+	imageTooBlurry: "imageTooBlurry",
+	fillFrame: "fillFrame",
+	checkCameraOrLighting: "checkCameraOrLighting",
+	frontIdCaptureStarted: "frontIdCaptureStarted",
+	lookAtCamera: "lookAtCamera",
+	moveCloser: "moveCloser",
+	lookingForFrontId: "lookingForFrontId",
+	lookingForBackId: "lookingForBackId",
+	cameraSwitchToBack: "cameraSwitchToBack",
+	cameraSwitchToFront: "cameraSwitchToFront",
+	audioStreamOpened: "audioStreamOpened",
+	audioStreamClosed: "audioStreamClosed",
+	videoSelfieVideoUploadInProgress: "videoSelfieVideoUploadInProgress",
+	videoSelfieTosNotAccepted: "videoSelfieTosNotAccepted",
+	videoSelfieTosAccepted: "videoSelfieTosAccepted",
+	videoSelfieStreamCreated: "videoSelfieStreamCreated",
+	videoSelfieStreamDestroyed: "videoSelfieStreamDestroyed",
+	videoSelfieReconnecting: "videoSelfieReconnecting",
+	videoSelfieReconnected: "videoSelfieReconnected"
+};
+const tutorialScreenNamesMapper = {
+	passport: eventScreenNames.passportTutorial,
+	front: eventScreenNames.frontTutorial,
+	back: eventScreenNames.backTutorial,
+	selfie: eventScreenNames.faceCaptureTutorial
+};
+const cameraScreenNamesMapper = {
+	front: "front",
+	back: "back",
+	passport: "passport",
+	creditCard: "front",
+	creditCardBack: "back",
+	document: "document"
+};
+
+//#endregion
+//#region ../infra/src/manager/Manager.ts
+/**
+* Creates a manager that wraps a state machine actor with a clean public API.
+*
+* The manager provides:
+* - `getState()` - Returns the mapped public state
+* - `subscribe()` - Listen to state changes
+* - `stop()` - Stop the actor
+* - Plus any custom API methods from `createApi`
+*
+* @template TMachine - The state machine type
+* @template TMapState - Function type that maps raw snapshot to public state
+* @template TCreateApi - Function type that creates the custom API
+*
+* @param options - Configuration options
+* @param options.actor - The started actor instance
+* @param options.mapState - Function to transform raw snapshot into public state
+* @param options.createApi - Factory function to create custom API methods
+*
+* @returns Combined manager with base methods and custom API
+*
+* @example
+* ```ts
+* const manager = createManager({
+*   actor: createActor(myMachine).start(),
+*   mapState: (snapshot) => ({ status: snapshot.value }),
+*   createApi: ({ actor }) => ({
+*     doSomething() { actor.send({ type: 'DO_IT' }); }
+*   }),
+* });
+* ```
+*/
+function createManager(options) {
+	const { actor, mapState, createApi, instrumentation } = options;
+	function getSnapshot() {
+		return actor.getSnapshot();
+	}
+	function getState() {
+		return mapState(getSnapshot());
+	}
+	function subscribe(listener) {
+		const subscription = actor.subscribe(() => {
+			listener(getState());
+		});
+		return () => subscription.unsubscribe();
+	}
+	let currentScreenName = instrumentation.getScreenName(getSnapshot());
+	let currentErrorName = instrumentation.getErrorName(getSnapshot());
+	let currentErrorPayload = instrumentation.getErrorPayload(getSnapshot());
+	const api$1 = createApi({
+		actor,
+		getSnapshot,
+		trackElementClicked: (elementName, payload) => {
+			instrumentation.onElementClicked?.(instrumentation.moduleName, currentScreenName, {
+				element: elementName,
+				action: payload?.action,
+				metadata: payload?.metadata
+			});
+		},
+		trackCaptureAttemptFinished: (payload) => {
+			instrumentation.onCaptureAttemptFinished?.(instrumentation.moduleName, currentScreenName, { logs: payload.logs });
+		}
+	});
+	instrumentation.onModuleOpened(instrumentation.moduleName);
+	if (currentScreenName !== void 0) instrumentation.onScreenOpened(instrumentation.moduleName, currentScreenName);
+	if (currentErrorName !== void 0) instrumentation.onErrorTriggered(instrumentation.moduleName, currentErrorName, currentErrorPayload);
+	const actorSubscription = actor.subscribe((snapshot) => {
+		const nextScreenName = instrumentation.getScreenName(snapshot);
+		const nextErrorName = instrumentation.getErrorName(snapshot);
+		const nextErrorPayload = instrumentation.getErrorPayload(snapshot);
+		if (currentScreenName === nextScreenName) {
+			if (nextErrorName !== void 0 && nextErrorName !== currentErrorName) instrumentation.onErrorTriggered(instrumentation.moduleName, nextErrorName, nextErrorPayload);
+			currentErrorName = nextErrorName;
+			currentErrorPayload = nextErrorPayload;
+			return;
+		}
+		if (currentScreenName !== void 0) instrumentation.onScreenClosed(instrumentation.moduleName, currentScreenName);
+		if (nextScreenName !== void 0) instrumentation.onScreenOpened(instrumentation.moduleName, nextScreenName);
+		currentScreenName = nextScreenName;
+		if (nextErrorName !== void 0 && nextErrorName !== currentErrorName) instrumentation.onErrorTriggered(instrumentation.moduleName, nextErrorName, nextErrorPayload);
+		currentErrorName = nextErrorName;
+		currentErrorPayload = nextErrorPayload;
+	});
+	let isStopped = false;
+	const base = {
+		getState,
+		subscribe,
+		stop() {
+			if (isStopped) return;
+			isStopped = true;
+			actorSubscription.unsubscribe();
+			if (currentScreenName !== void 0) instrumentation.onScreenClosed(instrumentation.moduleName, currentScreenName);
+			currentScreenName = void 0;
+			currentErrorName = void 0;
+			currentErrorPayload = void 0;
+			instrumentation.onModuleClosed(instrumentation.moduleName);
+			actor.stop();
+		}
+	};
+	return Object.defineProperties(base, Object.getOwnPropertyDescriptors(api$1));
+}
+
+//#endregion
+export { createActor as C, fromPromise as S, subscribeEvent as _, tutorialScreenNamesMapper as a, assign as b, captureAttemptFinished as c, moduleOpened as d, screenClosed as f, flushEventQueue as g, addEvent as h, eventScreenNames as i, elementClicked as l, screenOpened as m, cameraScreenNamesMapper as n, videoSelfieEvents as o, screenEvent as p, eventModuleNames as r, createManagerInstrumentation as s, createManager as t, moduleClosed as u, revokeObjectURL as v, fromCallback as x, setup as y };

package/dist/{warmup-CEOVQKby.d.ts → StateMachine-CM_aOfNL.d.ts}

@@ -1,4 +1,7 @@
+import { AnyStateMachine, StateMachine, fromPromise } from "xstate";
+
 //#region ../infra/src/wasm/warmup.d.ts
+
 /**
  * All available ML pipelines in the SDK.
  * - 'selfie' - Face detection for selfie capture
@@ -52,4 +55,4 @@ interface WarmupConfig {
  */
 declare function warmupWasm(config: WarmupConfig): Promise<void>;
 //#endregion
-export { WasmPipeline as n, warmupWasm as r, WarmupConfig as t };
+export { WasmPipeline as a, WarmupConfig as i, StateMachine as n, warmupWasm as o, fromPromise as r, AnyStateMachine as t };