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

package/dist/workflow.esm.js

@@ -0,0 +1,600 @@
+import "./BaseWasmProvider-DoYDYH1z.esm.js";
+import { t as api } from "./api-aa9Mx20l.esm.js";
+import { _ as endpoints, o as createManagerInstrumentation } from "./events-W91zLpx4.esm.js";
+import { n as getSessionFingerprintResult, r as initializeSession } from "./session-B_rKSRql.esm.js";
+import "./BrowserEnvironmentProvider-BtKLxTx4.esm.js";
+import "./browserSimulation-DFqGKQAD.esm.js";
+import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-B7FPE6br.esm.js";
+import { t as antifraudMachine } from "./antifraudStateMachine-B74mO8vr.esm.js";
+import "./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 authenticationMachine } from "./authenticationStateMachine-DCJ0ArAt.esm.js";
+import { t as consentMachine } from "./consentStateMachine-DIdJXJW0.esm.js";
+import { t as curpValidationMachine } from "./curpValidationStateMachine-Dp5WB6__.esm.js";
+import { t as documentCaptureMachine } from "./documentCaptureStateMachine-ByYOCKz5.esm.js";
+import { t as ekybMachine } from "./ekybStateMachine-DRku_YmR.esm.js";
+import "./addressSearch-C26OZIx0.esm.js";
+import "./flowServices-YATk0fgY.esm.js";
+import "./BrowserTimerProvider-v7bpbrAk.esm.js";
+import { t as ekycMachine } from "./ekycStateMachine-CSWaaWVl.esm.js";
+import { t as emailMachine } from "./emailStateMachine-BoIkeCw5.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-3b19ON1z.esm.js";
+import { t as idCaptureMachine } from "./idCaptureStateMachine-gf-Q9piu.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-Cc_w4tC0.esm.js";
+import { t as faceMatchMachine } from "./faceMatchStateMachine-CLterVEC.esm.js";
+import { t as getFinishStatus } from "./flowCompletionService-DZSDUXus.esm.js";
+import { t as runChildModule } from "./runChildModule-DVC4JEjp.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-CRRUCl9K.esm.js";
+import { t as governmentValidationMachine } from "./governmentValidationStateMachine-C_iPX9VE.esm.js";
+import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-BZNBJ1fK.esm.js";
+import { t as redirectToMobileMachine } from "./redirectToMobileStateMachine-vOe27Ufw.esm.js";
+import { t as signatureMachine } from "./signatureStateMachine-CU92zCXU.esm.js";
+
+//#region src/modules/workflow/workflowServices.ts
+function assertWorkflowNode(data, endpoint) {
+	const obj = data;
+	if (!obj || typeof obj.nodeType !== "string") throw new Error(`Invalid response from ${endpoint}: missing nodeType`);
+}
+function assertWorkflowConfig(data, endpoint) {
+	const obj = data;
+	if (!obj || typeof obj.id !== "string") throw new Error(`Invalid response from ${endpoint}: missing id`);
+}
+async function getCurrentNode(signal) {
+	const res = await api.get(endpoints.workflowCurrentNode, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.workflowCurrentNode} failed: ${res.status} ${res.statusText}`);
+	assertWorkflowNode(res.data, endpoints.workflowCurrentNode);
+	return res.data;
+}
+async function processNode(signal) {
+	const res = await api.post(endpoints.workflowProcessNode, {}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.workflowProcessNode} failed: ${res.status} ${res.statusText}`);
+	assertWorkflowNode(res.data, endpoints.workflowProcessNode);
+	return res.data;
+}
+async function getWorkflowConfig(signal) {
+	const res = await api.get(endpoints.workflowInfo, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.workflowInfo} failed: ${res.status} ${res.statusText}`);
+	assertWorkflowConfig(res.data, endpoints.workflowInfo);
+	return res.data;
+}
+async function processCustomNode(data, signal) {
+	const res = await api.post(endpoints.customModuleExecution, data, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.customModuleExecution} failed: ${res.status} ${res.statusText}`);
+}
+
+//#endregion
+//#region src/modules/workflow/workflowActors.ts
+async function loadWorkflow(input, signal) {
+	await initializeSession({ signal }).catch(() => void 0);
+	const workflowConfig = await getWorkflowConfig(signal);
+	const realNode = await getCurrentNode(signal);
+	const fingerprintResult = getSessionFingerprintResult();
+	let currentNode = realNode;
+	let firstNode;
+	let isInjectedNode = false;
+	if (fingerprintResult?.showMandatoryConsent) {
+		firstNode = realNode;
+		isInjectedNode = true;
+		currentNode = {
+			id: "injected-mandatory-consent",
+			nodeType: "MODULE",
+			moduleKey: "MANDATORY_CONSENT",
+			moduleConfiguration: { consentType: fingerprintResult.regulationType ?? "Other" },
+			status: "INJECTED",
+			workflowId: workflowConfig.id
+		};
+	} else if (workflowConfig.redirectDesktopToMobile && input.isDesktop) {
+		firstNode = realNode;
+		isInjectedNode = true;
+		currentNode = {
+			id: "injected-redirect-to-mobile",
+			nodeType: "MODULE",
+			moduleKey: "REDIRECT_TO_MOBILE",
+			moduleConfiguration: {
+				disableSmsOption: workflowConfig.disableSmsOption ?? false,
+				addContinueToDesktop: workflowConfig.addContinueToDesktop ?? false,
+				qrPhishingResistance: workflowConfig.qrPhishingResistance ?? false
+			},
+			status: "INJECTED",
+			workflowId: workflowConfig.id
+		};
+	}
+	return {
+		workflowConfig,
+		currentNode,
+		firstNode,
+		isInjectedNode
+	};
+}
+async function processNextNode(input, signal) {
+	if (input.isInjectedNode && input.firstNode) {
+		if (input.currentNodeModuleKey === "MANDATORY_CONSENT" && input.workflowRedirectDesktopToMobile && input.isDesktop) return {
+			nextNode: {
+				id: "injected-redirect-to-mobile",
+				nodeType: "MODULE",
+				moduleKey: "REDIRECT_TO_MOBILE",
+				moduleConfiguration: {
+					disableSmsOption: input.workflowDisableSmsOption,
+					addContinueToDesktop: input.workflowAddContinueToDesktop,
+					qrPhishingResistance: input.workflowQrPhishingResistance
+				},
+				status: "INJECTED",
+				workflowId: input.workflowConfigId ?? ""
+			},
+			isInjectedNode: true
+		};
+		return {
+			nextNode: input.firstNode,
+			isInjectedNode: false
+		};
+	}
+	return {
+		nextNode: await processNode(signal),
+		isInjectedNode: false
+	};
+}
+async function handleCustomModule(input, signal) {
+	const { currentNode, interviewId, customModuleCallback } = input;
+	const callbackName = currentNode.moduleConfiguration?.callbackName ?? "";
+	const customData = {
+		interviewId,
+		status: "UNKNOWN",
+		message: null,
+		callbackName,
+		nodeId: currentNode.id
+	};
+	if (customModuleCallback) {
+		const result = await new Promise((resolve, reject) => {
+			const onAbort = () => reject(/* @__PURE__ */ new Error("Custom module aborted"));
+			signal.addEventListener("abort", onAbort);
+			customModuleCallback({
+				onSuccess: (message) => {
+					signal.removeEventListener("abort", onAbort);
+					resolve({
+						status: "OK",
+						message: message ?? null
+					});
+				},
+				onError: (message) => {
+					signal.removeEventListener("abort", onAbort);
+					resolve({
+						status: "FAIL",
+						message: message ?? null
+					});
+				},
+				interviewId,
+				nodeId: currentNode.id,
+				name: callbackName
+			});
+		});
+		customData.status = result.status;
+		customData.message = result.message;
+	}
+	await processCustomNode(customData, signal);
+	return await processNode(signal);
+}
+async function resolveModule(input) {
+	const entry = input.registeredModules[input.moduleKey];
+	if (!entry) throw new Error(`Unknown module type: ${input.moduleKey}. Ensure all workflow modules are registered.`);
+	if (typeof entry === "function") return entry();
+	return entry;
+}
+
+//#endregion
+//#region src/modules/workflow/workflowStateMachine.ts
+function extractErrorInfo(err) {
+	const error = err;
+	return {
+		message: error?.message ?? String(err),
+		code: error?.status
+	};
+}
+function extractNodeFromOutput(output) {
+	const obj = output;
+	if ("nextNode" in obj) return obj.nextNode;
+	if ("currentNode" in obj) return obj.currentNode;
+	if ("nodeType" in obj) return obj;
+	throw new Error("Unexpected actor output shape: cannot extract WorkflowNode");
+}
+const workflowMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		loadWorkflow: fromPromise(({ input, signal }) => loadWorkflow(input, signal)),
+		processNextNode: fromPromise(({ input, signal }) => processNextNode(input, signal)),
+		handleCustomModule: fromPromise(({ input, signal }) => handleCustomModule(input, signal)),
+		resolveModule: fromPromise(({ input }) => resolveModule(input)),
+		notifyBackend: fromPromise(async ({ input, signal }) => {
+			return input.getFinishStatus(input.workflowId, signal);
+		}),
+		runChildModule
+	},
+	actions: {
+		setLoadingResult: assign(({ event }) => {
+			const result = event.output;
+			return {
+				workflowConfig: result.workflowConfig,
+				currentNode: result.currentNode,
+				firstNode: result.firstNode,
+				isInjectedNode: result.isInjectedNode
+			};
+		}),
+		setNextNode: assign(({ event }) => {
+			const result = event.output;
+			return {
+				currentNode: result.nextNode,
+				isInjectedNode: result.isInjectedNode
+			};
+		}),
+		setCustomModuleResult: assign(({ event }) => {
+			return {
+				currentNode: event.output,
+				isInjectedNode: false
+			};
+		}),
+		setResolvedMachine: assign(({ event }) => ({ resolvedMachine: event.output })),
+		setFinishStatus: assign(({ event }) => ({ finishStatus: event.output })),
+		setError: assign(({ event }) => {
+			const { message, code } = extractErrorInfo(event.error);
+			return {
+				error: message,
+				errorCode: code
+			};
+		}),
+		setModuleError: assign(({ event }) => ({ error: String(event.error) }))
+	},
+	guards: {
+		isModuleNode: ({ event }) => {
+			const output = event.output;
+			return extractNodeFromOutput(output).nodeType === "MODULE";
+		},
+		isFinishNode: ({ event }) => {
+			const output = event.output;
+			return extractNodeFromOutput(output).nodeType === "FINISH";
+		},
+		isAsyncResolutionNode: ({ event }) => {
+			const output = event.output;
+			return extractNodeFromOutput(output).nodeType === "ASYNC_RESOLUTION";
+		},
+		isCustomModule: ({ context }) => {
+			return context.currentNode?.moduleKey === "CUSTOM_MODULE";
+		}
+	}
+}).createMachine({
+	id: "workflow",
+	initial: "idle",
+	context: ({ input }) => ({
+		workflowConfig: void 0,
+		currentNode: void 0,
+		firstNode: void 0,
+		resolvedMachine: void 0,
+		error: void 0,
+		errorCode: void 0,
+		registeredModules: input.modules,
+		finishStatus: void 0,
+		customModuleCallback: input.customModuleCallback,
+		interviewId: input.interviewId ?? "",
+		isDesktop: input.isDesktop ?? true,
+		isInjectedNode: false,
+		getFinishStatus: input.getFinishStatus ?? getFinishStatus
+	}),
+	states: {
+		idle: { on: { LOAD: "loading" } },
+		loading: { invoke: {
+			id: "loadWorkflow",
+			src: "loadWorkflow",
+			input: ({ context }) => ({ isDesktop: context.isDesktop }),
+			onDone: [
+				{
+					target: "resolvingModule",
+					guard: "isModuleNode",
+					actions: "setLoadingResult"
+				},
+				{
+					target: "completing",
+					guard: "isFinishNode",
+					actions: "setLoadingResult"
+				},
+				{
+					target: "asyncResolution",
+					guard: "isAsyncResolutionNode",
+					actions: "setLoadingResult"
+				}
+			],
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		resolvingModule: {
+			always: [{
+				target: "handlingCustomModule",
+				guard: "isCustomModule"
+			}],
+			invoke: {
+				id: "resolveModule",
+				src: "resolveModule",
+				input: ({ context }) => ({
+					moduleKey: context.currentNode.moduleKey,
+					registeredModules: context.registeredModules
+				}),
+				onDone: {
+					target: "runningModule",
+					actions: "setResolvedMachine"
+				},
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			}
+		},
+		runningModule: {
+			invoke: {
+				id: "currentModule",
+				src: "runChildModule",
+				input: ({ context }) => {
+					const config = {
+						...context.currentNode?.moduleConfiguration,
+						ds: context.workflowConfig?.ds
+					};
+					return {
+						machine: context.resolvedMachine,
+						config
+					};
+				}
+			},
+			on: {
+				MODULE_COMPLETE: "processingNode",
+				MODULE_ERROR: {
+					target: "error",
+					actions: "setModuleError"
+				},
+				COMPLETE_FLOW: "completing"
+			}
+		},
+		handlingCustomModule: { invoke: {
+			id: "customModule",
+			src: "handleCustomModule",
+			input: ({ context }) => ({
+				currentNode: context.currentNode,
+				interviewId: context.interviewId,
+				customModuleCallback: context.customModuleCallback
+			}),
+			onDone: [
+				{
+					target: "resolvingModule",
+					guard: "isModuleNode",
+					actions: "setCustomModuleResult"
+				},
+				{
+					target: "completing",
+					guard: "isFinishNode",
+					actions: "setCustomModuleResult"
+				},
+				{
+					target: "asyncResolution",
+					guard: "isAsyncResolutionNode",
+					actions: "setCustomModuleResult"
+				}
+			],
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		processingNode: { invoke: {
+			id: "processNext",
+			src: "processNextNode",
+			input: ({ context }) => ({
+				isInjectedNode: context.isInjectedNode,
+				firstNode: context.firstNode,
+				currentNodeModuleKey: context.currentNode?.moduleKey,
+				workflowConfigId: context.workflowConfig?.id,
+				workflowRedirectDesktopToMobile: context.workflowConfig?.redirectDesktopToMobile ?? false,
+				workflowDisableSmsOption: context.workflowConfig?.disableSmsOption ?? false,
+				workflowAddContinueToDesktop: context.workflowConfig?.addContinueToDesktop ?? false,
+				workflowQrPhishingResistance: context.workflowConfig?.qrPhishingResistance ?? false,
+				isDesktop: context.isDesktop
+			}),
+			onDone: [
+				{
+					target: "resolvingModule",
+					guard: "isModuleNode",
+					actions: "setNextNode",
+					reenter: true
+				},
+				{
+					target: "completing",
+					guard: "isFinishNode",
+					actions: "setNextNode"
+				},
+				{
+					target: "asyncResolution",
+					guard: "isAsyncResolutionNode",
+					actions: "setNextNode"
+				}
+			],
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		completing: { invoke: {
+			id: "notifyBackend",
+			src: "notifyBackend",
+			input: ({ context }) => ({
+				getFinishStatus: context.getFinishStatus,
+				workflowId: context.workflowConfig?.id
+			}),
+			onDone: {
+				target: "finished",
+				actions: "setFinishStatus"
+			},
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		finished: { type: "final" },
+		asyncResolution: { type: "final" },
+		closed: { type: "final" },
+		error: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/workflow/workflowActor.ts
+function createWorkflowActor(options) {
+	return createActor(workflowMachine, { input: {
+		modules: options.modules,
+		customModuleCallback: options.customModuleCallback,
+		interviewId: options.interviewId,
+		isDesktop: options.isDesktop
+	} }).start();
+}
+
+//#endregion
+//#region src/internal/orchestration/defaultModules.ts
+/**
+* Shared default module registry — single source of truth for module key → machine mappings.
+* Used by Workflow (eager loading). Flow uses lazy imports instead (see flowInit.ts).
+*
+* When adding a new module to the SDK, add it here AND to Flow's getLazyCoreMachineLoader.
+*/
+/**
+* Base module registry with all known SDK modules.
+* Module keys match what the backend sends in flow/workflow configuration.
+*/
+const DEFAULT_MODULE_REGISTRY = {
+	PHONE: phoneMachine,
+	EMAIL: emailMachine,
+	SELFIE: selfieMachine,
+	AUTHENTICATION: authenticationMachine,
+	ID: idCaptureMachine,
+	TUTORIAL_ID: idCaptureMachine,
+	SECOND_ID: idCaptureMachine,
+	FACE_MATCH: faceMatchMachine,
+	CURP_VALIDATION: curpValidationMachine,
+	GOVT_VALIDATION_PROVISIONING: governmentValidationMachine,
+	GEOLOCATION: geolocationMachine,
+	EXTERNAL_VERIFICATION: ekycMachine,
+	EKYB: ekybMachine,
+	DOCUMENT_CAPTURE: documentCaptureMachine,
+	ADDRESS: documentCaptureMachine,
+	COMBINED_CONSENT: consentMachine,
+	MANDATORY_CONSENT: mandatoryConsentMachine,
+	SIGNATURE: signatureMachine,
+	ANTIFRAUD: antifraudMachine
+};
+
+//#endregion
+//#region src/modules/workflow/workflowManager.ts
+const DEFAULT_MODULES = {
+	...DEFAULT_MODULE_REGISTRY,
+	ID_CAPTURE: idCaptureMachine,
+	REDIRECT_TO_MOBILE: redirectToMobileMachine
+};
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle")) return { status: "idle" };
+	if (snapshot.matches("runningModule")) {
+		const childSnapshot = snapshot.children.currentModule?.getSnapshot();
+		return {
+			status: "ready",
+			workflowConfig: context.workflowConfig,
+			currentNode: context.currentNode,
+			config: {
+				...context.currentNode?.moduleConfiguration,
+				ds: context.workflowConfig?.ds
+			},
+			moduleState: childSnapshot ?? null
+		};
+	}
+	if (snapshot.matches("finished")) return {
+		status: "finished",
+		workflowConfig: context.workflowConfig,
+		finishStatus: context.finishStatus ?? {
+			redirectionUrl: "",
+			action: "none",
+			scoreStatus: "UNKNOWN"
+		}
+	};
+	if (snapshot.matches("asyncResolution")) return {
+		status: "asyncResolution",
+		workflowConfig: context.workflowConfig,
+		currentNode: context.currentNode
+	};
+	if (snapshot.matches("closed")) return { status: "closed" };
+	if (snapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Unknown error",
+		errorCode: context.errorCode
+	};
+	return { status: "loading" };
+}
+function createApi({ actor, getSnapshot, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		completeModule() {
+			trackElementClicked?.("completeModule");
+			actor.send({ type: "MODULE_COMPLETE" });
+		},
+		completeFlow() {
+			trackElementClicked?.("completeFlow");
+			actor.send({ type: "COMPLETE_FLOW" });
+		},
+		errorModule(error) {
+			actor.send({
+				type: "MODULE_ERROR",
+				error
+			});
+		},
+		getModuleConfig() {
+			const snapshot = getSnapshot();
+			if (snapshot.value !== "runningModule") return void 0;
+			return {
+				...snapshot.context.currentNode?.moduleConfiguration,
+				ds: snapshot.context.workflowConfig?.ds
+			};
+		}
+	};
+}
+/**
+* Creates a workflow manager for server-driven onboarding flows.
+*
+* Only one orchestrator (Flow or Workflow) should be active per session.
+* Each session token maps to a single orchestrator run. To start a new
+* workflow, create a new session and call `setup()` with the new token
+* before creating a new manager.
+*/
+function createWorkflowManager(options = {}) {
+	return createManager({
+		actor: createWorkflowActor({
+			modules: DEFAULT_MODULES,
+			customModuleCallback: options.customModuleCallback,
+			interviewId: options.interviewId,
+			isDesktop: options.isDesktop
+		}),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation("WORKFLOW")
+	});
+}
+
+//#endregion
+export { createWorkflowManager, workflowMachine };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@incodetech/core",
-  "version": "0.0.0-dev-20260409-a38d5e8",
+  "version": "0.0.0-dev-20260409-09dfd52",
   "type": "module",
   "main": "./dist/index.esm.js",
   "types": "./dist/index.d.ts",
@@ -113,6 +113,10 @@
       "types": "./dist/antifraud.d.ts",
       "import": "./dist/antifraud.esm.js"
     },
+    "./workflow": {
+      "types": "./dist/workflow.d.ts",
+      "import": "./dist/workflow.esm.js"
+    },
     "./cross-document-data-match": {
       "types": "./dist/cross-document-data-match.d.ts",
       "import": "./dist/cross-document-data-match.esm.js"
@@ -126,8 +130,8 @@
     "tsdown": "^0.16.6",
     "typescript": "^5.9.3",
     "vitest": "^4.0.13",
-    "@incodetech/infra": "1.0.0",
-    "@incodetech/config": "1.0.0"
+    "@incodetech/config": "1.0.0",
+    "@incodetech/infra": "1.0.0"
   },
   "scripts": {
     "build": "tsdown -c tsdown.config.ts",

package/dist/openviduLazy-BIPHozOu.esm.js

@@ -1,3 +0,0 @@
-import { t as loadOpenVidu } from "./openviduLazy-vhrVZCr_.esm.js";
-
-export { loadOpenVidu };