@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.3

package/dist/dynamicFormsManager-CUYLOj9g.d.ts

@@ -0,0 +1,239 @@
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import { t as ActorRefFrom } from "./Actor-CGEelYtQ.js";
+
+//#region src/modules/dynamic-forms/types.d.ts
+
+/**
+ * Input types supported by dynamic form questions.
+ * `inputType` on `Question` is optional so unknown future API values degrade
+ * gracefully to the text fallback rather than requiring this union to be widened.
+ */
+type InputType = 'TEXT' | 'DATE' | 'COUNTRY' | 'NATIONALITY' | 'NUMBER' | 'EMAIL' | 'PHONE' | 'CPF' | 'NAME' | 'YESNO' | 'SELECT' | 'MULTISELECT';
+/**
+ * A single question within a dynamic form screen.
+ */
+type Question = {
+  questionId: string;
+  /** Display label shown to the user */
+  question: string;
+  inputType?: InputType;
+  /** Fallback type used when `inputType` is absent */
+  overrides?: InputType;
+  isPredefined?: boolean;
+  isOptional?: boolean;
+  options?: string[];
+};
+/**
+ * A single screen within the dynamic form flow.
+ */
+type Screen = {
+  title?: string;
+  hideTitle?: boolean;
+  questions: Question[];
+};
+/**
+ * Configuration for the dynamic forms module.
+ * Provide either `screens` (pre-loaded) or `flowId` (fetched from API).
+ */
+type DynamicFormsConfig = {
+  /** Flow ID used to fetch screens from the API when `screens` is not provided */
+  flowId?: string;
+  /** Pre-loaded screens — skips the API fetch when provided */
+  screens?: Screen[];
+};
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsFields.d.ts
+/** Map of `questionId` → currently-displayed i18n error key. */
+type DynamicFormsValidationErrors = Partial<Record<string, string>>;
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsStateMachine.d.ts
+/** Whether the form completed normally or was skipped due to a screen-loading failure. */
+type DynamicFormsResult = 'completed' | 'skipped';
+declare const dynamicFormsMachine: any;
+type DynamicFormsMachine = typeof dynamicFormsMachine;
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsActor.d.ts
+type CreateDynamicFormsActorOptions = {
+  config: DynamicFormsConfig;
+};
+type DynamicFormsActor = ActorRefFrom<DynamicFormsMachine>;
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsManager.d.ts
+/** Dynamic forms manager is in initial state, waiting for `load()` */
+type DynamicFormsIdleState = {
+  status: 'idle';
+};
+/** Fetching screen configuration from the backend */
+type DynamicFormsLoadingState = {
+  status: 'loadingScreens';
+};
+/**
+ * Ready for user input on the current screen.
+ * @property currentScreen - The screen definition to render
+ * @property screenIndex - 0-based index of the current screen
+ * @property totalScreens - Total number of screens in the form
+ * @property answers - Current answer values keyed by questionId
+ * @property answerValidity - Per-question format validity reported via `setAnswerValidity` (phone, email, CPF, etc.)
+ * @property validationErrors - Errors currently surfaced to the user, keyed by questionId. Entries appear on blur or submit, clear on type. Render as-is — no further UI-side gating.
+ * @property canSubmit - True when no validation errors are currently displayed. Optimistic semantic: enabled on initial empty form; disables only after a submit attempt populates errors.
+ */
+type DynamicFormsInputtingState = {
+  status: 'inputting';
+  currentScreen: Screen;
+  screenIndex: number;
+  totalScreens: number;
+  answers: Record<string, string>;
+  answerValidity: Record<string, boolean>;
+  validationErrors?: DynamicFormsValidationErrors;
+  canSubmit: boolean;
+};
+/**
+ * Submitting the current screen's answers to the backend.
+ * The screen data is preserved so the UI can keep the form visible (with
+ * disabled fields and a button spinner) while the request is in-flight.
+ * @property screenIndex - Index of the screen being submitted
+ * @property totalScreens - Total number of screens in the form
+ * @property currentScreen - The screen whose answers are being submitted
+ * @property answers - Frozen answer values at submission time
+ * @property answerValidity - Frozen validity flags at submission time
+ */
+type DynamicFormsSubmittingState = {
+  status: 'submitting';
+  screenIndex: number;
+  totalScreens: number;
+  currentScreen: Screen;
+  answers: Record<string, string>;
+  answerValidity: Record<string, boolean>;
+  validationErrors?: DynamicFormsValidationErrors;
+};
+/**
+ * All screens submitted — success screen visible for ~3 s before
+ * transitioning to `finished`.
+ */
+type DynamicFormsSuccessState = {
+  status: 'success';
+};
+/**
+ * All screens completed or skipped.
+ * @property result - `'completed'` when all screens were submitted successfully;
+ *   `'skipped'` when screen configuration could not be loaded (fire-and-forget).
+ */
+type DynamicFormsFinishedState = {
+  status: 'finished';
+  result: DynamicFormsResult;
+};
+/**
+ * Neither `screens` nor `flowId` was provided — misconfiguration, not a runtime error.
+ * Call `close()` to dismiss. Fix the config (provide `screens` or `flowId`) instead.
+ */
+type DynamicFormsMisconfiguredState = {
+  status: 'misconfigured';
+};
+/** User dismissed the module */
+type DynamicFormsClosedState = {
+  status: 'closed';
+};
+/**
+ * Union of all possible dynamic forms manager states.
+ */
+type DynamicFormsState = DynamicFormsIdleState | DynamicFormsLoadingState | DynamicFormsInputtingState | DynamicFormsSubmittingState | DynamicFormsSuccessState | DynamicFormsFinishedState | DynamicFormsMisconfiguredState | DynamicFormsClosedState;
+/**
+ * Creates a dynamic forms manager for headless or UI-driven usage.
+ *
+ * @param options - Configuration options
+ * @param options.config - Dynamic forms configuration (flowId or pre-loaded screens)
+ *
+ * @returns Dynamic forms manager with state, API methods, and subscription
+ */
+declare function createDynamicFormsManager(options: CreateDynamicFormsActorOptions): Manager<DynamicFormsState> & {
+  /**
+   * Initializes the dynamic forms flow.
+   * Transitions from 'idle' to 'loadingScreens' or 'inputting'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Updates the answer value for a single question.
+   * Should be called when state is 'inputting'.
+   *
+   * @param questionId - The question ID from the screen definition
+   * @param value - The raw user input value (formatting is stripped in Core before submission)
+   */
+  setAnswer(questionId: string, value: string): void;
+  /**
+   * Reports the format validity of a question's current value.
+   * Used for fields with format constraints (PHONE, EMAIL, CPF).
+   * A `false` entry feeds into the `formatViaAnswerValidity` validation rule
+   * and surfaces as a `validationErrors[questionId]` entry once validated.
+   *
+   * @param questionId - The question ID from the screen definition
+   * @param isValid - Whether the current value passes format validation
+   */
+  setAnswerValidity(questionId: string, isValid: boolean): void;
+  /**
+   * Triggers validation for a single field (e.g., on blur).
+   * Populates or clears `validationErrors[questionId]` accordingly.
+   *
+   * @param questionId - The question ID from the screen definition
+   */
+  validateField(questionId: string): void;
+  /**
+   * Submits the current screen's answers.
+   * Transitions to 'submitting', then advances to the next screen or 'finished'.
+   * Answer submission failures are fire-and-forget and do not block progression.
+   */
+  submit(): void;
+  /**
+   * Dismisses the module from 'misconfigured' state.
+   * Fix the config (provide `screens` or `flowId`) rather than calling `reset()`.
+   */
+  close(): void;
+};
+declare function createDynamicFormsManagerFromActor(actor: DynamicFormsActor): Manager<DynamicFormsState> & {
+  /**
+   * Initializes the dynamic forms flow.
+   * Transitions from 'idle' to 'loadingScreens' or 'inputting'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Updates the answer value for a single question.
+   * Should be called when state is 'inputting'.
+   *
+   * @param questionId - The question ID from the screen definition
+   * @param value - The raw user input value (formatting is stripped in Core before submission)
+   */
+  setAnswer(questionId: string, value: string): void;
+  /**
+   * Reports the format validity of a question's current value.
+   * Used for fields with format constraints (PHONE, EMAIL, CPF).
+   * A `false` entry feeds into the `formatViaAnswerValidity` validation rule
+   * and surfaces as a `validationErrors[questionId]` entry once validated.
+   *
+   * @param questionId - The question ID from the screen definition
+   * @param isValid - Whether the current value passes format validation
+   */
+  setAnswerValidity(questionId: string, isValid: boolean): void;
+  /**
+   * Triggers validation for a single field (e.g., on blur).
+   * Populates or clears `validationErrors[questionId]` accordingly.
+   *
+   * @param questionId - The question ID from the screen definition
+   */
+  validateField(questionId: string): void;
+  /**
+   * Submits the current screen's answers.
+   * Transitions to 'submitting', then advances to the next screen or 'finished'.
+   * Answer submission failures are fire-and-forget and do not block progression.
+   */
+  submit(): void;
+  /**
+   * Dismisses the module from 'misconfigured' state.
+   * Fix the config (provide `screens` or `flowId`) rather than calling `reset()`.
+   */
+  close(): void;
+};
+/** Type representing a dynamic forms manager instance. */
+type DynamicFormsManager = ReturnType<typeof createDynamicFormsManager>;
+//#endregion
+export { DynamicFormsActor as a, DynamicFormsValidationErrors as c, Question as d, Screen as f, createDynamicFormsManagerFromActor as i, DynamicFormsConfig as l, DynamicFormsState as n, DynamicFormsResult as o, createDynamicFormsManager as r, dynamicFormsMachine as s, DynamicFormsManager as t, InputType as u };

package/dist/dynamicFormsStateMachine-BXHcaocI.esm.js

@@ -0,0 +1,284 @@
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
+import { t as isoDateToMs } from "./dateUtils-7-tQYRNN.esm.js";
+
+//#region src/modules/dynamic-forms/dynamicFormsFields.ts
+function getEffectiveType(question) {
+	return question.inputType ?? question.overrides ?? "TEXT";
+}
+const FORMAT_ERROR_KEY_BY_TYPE = {
+	PHONE: "phone.invalidPhone",
+	EMAIL: "verification.errors.emailInvalid",
+	CPF: "dynamicForms.invalidCpf"
+};
+function buildQuestionValidation(question) {
+	const effectiveType = getEffectiveType(question);
+	const rules = [];
+	if (!question.isOptional) rules.push({ type: "required" });
+	const formatErrorKey = FORMAT_ERROR_KEY_BY_TYPE[effectiveType];
+	if (formatErrorKey) rules.push({
+		type: "formatViaAnswerValidity",
+		errorKey: formatErrorKey
+	});
+	return rules;
+}
+function buildScreenFields(formScreen) {
+	return formScreen.questions.map((q) => ({
+		questionId: q.questionId,
+		inputType: getEffectiveType(q),
+		isOptional: q.isOptional ?? false,
+		validation: buildQuestionValidation(q)
+	}));
+}
+
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsValidators.ts
+const VALIDATORS = {
+	required: ({ value }) => value.trim().length === 0 ? "dynamicForms.fieldRequired" : void 0,
+	formatViaAnswerValidity: ({ questionId, answerValidity }, rule) => answerValidity[questionId] === false ? rule.errorKey : void 0
+};
+const normalizeValue = (value) => typeof value === "string" ? value : String(value ?? "");
+function evaluateRules(input, rules) {
+	for (const rule of rules) {
+		const error = rule.type === "required" ? VALIDATORS.required(input) : VALIDATORS.formatViaAnswerValidity(input, rule);
+		if (error) return error;
+	}
+}
+/** Runs full-screen validation. Returns first failing key per field; empty = pass. */
+function validateScreenForm(answers, fields, answerValidity) {
+	return fields.reduce((errors, field) => {
+		const error = evaluateRules({
+			value: normalizeValue(answers[field.questionId]),
+			questionId: field.questionId,
+			answerValidity
+		}, field.validation);
+		if (error) errors[field.questionId] = error;
+		return errors;
+	}, {});
+}
+/** Runs single-field validation (blur). Unknown `questionId` → `undefined`. */
+function validateScreenField(answers, questionId, fields, answerValidity) {
+	const field = fields.find((f) => f.questionId === questionId);
+	if (!field) return void 0;
+	return evaluateRules({
+		value: normalizeValue(answers[questionId]),
+		questionId,
+		answerValidity
+	}, field.validation);
+}
+
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsServices.ts
+async function fetchForms(flowId, signal) {
+	const url = `${endpoints.moduleConfig}?id=${encodeURIComponent(flowId)}&moduleKey=DYNAMIC_FORMS`;
+	const res = await api.get(url, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.moduleConfig} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function submitFormAnswer(params, signal) {
+	const res = await api.post(endpoints.dynamicFormsSubmitAnswer, {
+		questionId: params.questionId,
+		answerDetails: { singleAnswer: params.singleAnswer }
+	}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.dynamicFormsSubmitAnswer} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/dynamic-forms/dynamicFormsStateMachine.ts
+function transformAnswerValue(inputType, value) {
+	switch (inputType) {
+		case "CPF": return value.replace(/[-.]/g, "");
+		case "DATE": return isoDateToMs(value).toString();
+		default: return value;
+	}
+}
+const removeKey = (errors, key) => {
+	if (!errors?.[key]) return errors;
+	const next = { ...errors };
+	delete next[key];
+	return Object.keys(next).length > 0 ? next : void 0;
+};
+const upsertKey = (errors, key, message) => {
+	const next = { ...errors ?? {} };
+	if (message) next[key] = message;
+	else delete next[key];
+	return Object.keys(next).length > 0 ? next : void 0;
+};
+const dynamicFormsMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchScreens: fromPromise(async ({ input, signal }) => {
+			return fetchForms(input.flowId, signal);
+		}),
+		submitScreenAnswers: fromPromise(async ({ input, signal }) => {
+			const { screen: formScreen, answers } = input;
+			for (const question of formScreen.questions) {
+				const singleAnswer = transformAnswerValue(question.inputType ?? question.overrides ?? "TEXT", answers[question.questionId] ?? "");
+				try {
+					await submitFormAnswer({
+						questionId: question.questionId,
+						singleAnswer
+					}, signal);
+				} catch {}
+			}
+			return { success: true };
+		})
+	},
+	actions: {
+		setScreens: assign(({ event }) => {
+			const screens = event.output.screens;
+			const firstScreen = screens[0];
+			return {
+				screens,
+				answers: {},
+				currentScreenFields: firstScreen ? buildScreenFields(firstScreen) : []
+			};
+		}),
+		setAnswer: assign(({ context, event }) => {
+			const e = event;
+			return {
+				answers: {
+					...context.answers,
+					[e.questionId]: e.value
+				},
+				validationErrors: removeKey(context.validationErrors, e.questionId)
+			};
+		}),
+		setAnswerValidity: assign(({ context, event }) => {
+			const e = event;
+			return {
+				answerValidity: {
+					...context.answerValidity,
+					[e.questionId]: e.isValid
+				},
+				validationErrors: removeKey(context.validationErrors, e.questionId)
+			};
+		}),
+		validateFormField: assign(({ context, event }) => {
+			if (event.type !== "VALIDATE_FIELD") return {};
+			const message = validateScreenField(context.answers, event.questionId, context.currentScreenFields, context.answerValidity);
+			return { validationErrors: upsertKey(context.validationErrors, event.questionId, message) };
+		}),
+		computeValidationResult: assign(({ context }) => {
+			const errors = validateScreenForm(context.answers, context.currentScreenFields, context.answerValidity);
+			return { validationErrors: Object.keys(errors).length > 0 ? errors : void 0 };
+		}),
+		advanceScreen: assign(({ context }) => {
+			const nextIndex = context.currentScreenIndex + 1;
+			const nextScreen = context.screens[nextIndex];
+			return {
+				currentScreenIndex: nextIndex,
+				answers: {},
+				answerValidity: {},
+				currentScreenFields: nextScreen ? buildScreenFields(nextScreen) : [],
+				validationErrors: void 0
+			};
+		}),
+		markCompleted: assign({ result: "completed" }),
+		markSkipped: assign({ result: "skipped" })
+	},
+	guards: {
+		hasPreloadedScreens: ({ context }) => (context.config.screens?.length ?? 0) > 0,
+		hasFlowId: ({ context }) => !!context.config.flowId,
+		isLastScreen: ({ context }) => context.currentScreenIndex >= context.screens.length - 1,
+		isScreenValid: ({ context }) => Object.keys(context.validationErrors ?? {}).length === 0
+	}
+}).createMachine({
+	id: "dynamicForms",
+	initial: "idle",
+	context: ({ input }) => {
+		const screens = input.config.screens ?? [];
+		const firstScreen = screens[0];
+		return {
+			config: input.config,
+			screens,
+			currentScreenIndex: 0,
+			answers: {},
+			answerValidity: {},
+			currentScreenFields: firstScreen ? buildScreenFields(firstScreen) : [],
+			result: null
+		};
+	},
+	states: {
+		idle: { on: { LOAD: [
+			{
+				target: "inputting",
+				guard: "hasPreloadedScreens"
+			},
+			{
+				target: "loadingScreens",
+				guard: "hasFlowId"
+			},
+			{ target: "misconfigured" }
+		] } },
+		loadingScreens: { invoke: {
+			id: "fetchScreens",
+			src: "fetchScreens",
+			input: ({ context }) => ({ flowId: context.config.flowId ?? "" }),
+			onDone: {
+				target: "inputting",
+				actions: "setScreens"
+			},
+			onError: {
+				target: "finished",
+				actions: "markSkipped"
+			}
+		} },
+		inputting: {
+			initial: "editing",
+			states: {
+				editing: { on: {
+					ANSWER_CHANGED: { actions: "setAnswer" },
+					ANSWER_VALIDITY_CHANGED: { actions: "setAnswerValidity" },
+					VALIDATE_FIELD: { actions: "validateFormField" },
+					SUBMIT: { target: "validatingSubmit" }
+				} },
+				validatingSubmit: {
+					entry: "computeValidationResult",
+					always: [{
+						guard: "isScreenValid",
+						target: "#dynamicForms.submitting"
+					}, { target: "editing" }]
+				}
+			}
+		},
+		submitting: { invoke: {
+			id: "submitScreenAnswers",
+			src: "submitScreenAnswers",
+			input: ({ context }) => ({
+				screen: context.screens[context.currentScreenIndex],
+				answers: context.answers
+			}),
+			onDone: [{
+				target: "success",
+				guard: "isLastScreen"
+			}, {
+				target: "inputting",
+				actions: "advanceScreen"
+			}],
+			onError: [{
+				target: "success",
+				guard: "isLastScreen"
+			}, {
+				target: "inputting",
+				actions: "advanceScreen"
+			}]
+		} },
+		success: { after: { 3e3: {
+			target: "finished",
+			actions: "markCompleted"
+		} } },
+		finished: { type: "final" },
+		misconfigured: { on: { CLOSE: { target: "closed" } } },
+		closed: { type: "final" }
+	}
+});
+
+//#endregion
+export { dynamicFormsMachine as t };

package/dist/ekyb.d.ts

@@ -1,9 +1,12 @@
-import { t as Manager } from "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
-import "./camera-SRBpPq2X.js";
-import "./types-Bj9hdFjU.js";
-import { c as AddressSuggestion, l as FieldDef } from "./types-DvGZI7BF.js";
-import { i as FlowModuleConfig } from "./types-DOUhndhT.js";
+import "./StateMachine-C_AY4cs7.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import "./Actor-CGEelYtQ.js";
+import "./camera-CNVUo-bC.js";
+import "./types-DgGlgyZT.js";
+import { c as AddressSuggestion, l as FieldDef } from "./types-D_IceWxT.js";
+import "./canvas-CJUmoXSD.js";
+import "./createFaceAvatar-B8pFpy6o.js";
+import { i as FlowModuleConfig } from "./types-BsYXnC5s.js";
 
 //#region src/modules/ekyb/types.d.ts
 type UboEntry = {
@@ -60,6 +63,7 @@ type CreateEkybActorOptions = {
 };
 //#endregion
 //#region src/modules/ekyb/ekybManager.d.ts
+
 type EkybLoadingState = {
   status: 'loading';
 };

package/dist/ekyb.esm.js

@@ -1,19 +1,23 @@
-import "./BrowserTimerProvider-DhNc_x02.esm.js";
-import "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import "./stats-BMNUG1AU.esm.js";
-import "./IpifyProvider-D4LWD15E.esm.js";
-import "./browserSimulation-B1dWiXp7.esm.js";
-import "./sessionInitializer-DRB-hgbV.esm.js";
-import "./platform-SKvEfCBh.esm.js";
-import "./getBrowser-C8DP7oTB.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
-import "./apiError-B-j-gyDx.esm.js";
-import { a as SUPPORTED_COUNTRIES, i as DEV_ONLY_COUNTRIES, n as toEkybConfig, o as isSupportedCountry, r as ALL_COUNTRIES, t as ekybMachine } from "./ekybStateMachine-klc-AImJ.esm.js";
-import "./addressSearch-DvmWXKZg.esm.js";
-import "./session-DoVb-OcB.esm.js";
-import "./flowServices-ChgTNggJ.esm.js";
+import "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import { n as createManagerInstrumentation, t as topLevelStateName } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import "./endpoints-BzMJFAPV.esm.js";
+import "./stats-CYcScXcO.esm.js";
+import "./browserSimulation-TsSoavQv.esm.js";
+import "./sessionInitializer-C_TYIgyk.esm.js";
+import "./getDeviceData-TrKM8NPh.esm.js";
+import "./thumbmarkAdapter-fHBUDlAP.esm.js";
+import "./IpifyProvider-BRW14_uo.esm.js";
+import "./platform-uIVQUnJP.esm.js";
+import "./tri-BG1iJsr4.esm.js";
+import { l as createManager, s as createActor } from "./xstate.esm-Bomq1a0z.esm.js";
+import "./apiError-DNS2OCEX.esm.js";
+import { a as SUPPORTED_COUNTRIES, i as DEV_ONLY_COUNTRIES, n as toEkybConfig, o as isSupportedCountry, r as ALL_COUNTRIES, t as ekybMachine } from "./ekybStateMachine-CCSeqjCt.esm.js";
+import "./addressSearch-DJyNTg5S.esm.js";
+import "./session-9jIfKFCc.esm.js";
+import "./videoSelfieSteps-7M5vxKn-.esm.js";
+import "./flowServices-C4piblgx.esm.js";
 
 //#region src/modules/ekyb/ekybActor.ts
 /**
@@ -26,6 +30,47 @@ function createEkybActor(options) {
 
 //#endregion
 //#region src/modules/ekyb/ekybManager.ts
+/**
+* Maps an eKYB state-machine snapshot to the exact Figma "Tracked
+* Events" screen name. Source: eKYC / eKYB Figma file → Tracked Events
+* canvas
+* (`https://www.figma.com/design/TWgYZVhurQCizfC4tfLEut/eKYC---eKYB---Ready-for-Dev?node-id=2977-10474`).
+* Family is `eKYB.*` and section names are returned verbatim, emitted as-is
+* on `event.screen` by `createManagerInstrumentation` (e.g. `eKYB.default`,
+* `eKYB.processing`). See `docs/patterns/INSTRUMENTATION.md`.
+*
+* Figma sub-states not currently surfaced by the state machine (the form
+* state machine collapses country selection, business details, and UBO
+* entry into a single `form` compound state):
+*
+* - `eKYB.bdetails` (business details, empty) — UI step after country
+*   selection.
+* - `eKYB.filled` (business details filled) — UI sub-state when required
+*   fields have values.
+* - `eKYB.UBO` (empty / filled — the Figma canvas duplicates the section
+*   name for both variants) — UBO entry step.
+*
+* All three collapse onto `eKYB.default` (the country selection / form
+* entry surface). Promoting them requires the state machine to surface
+* step-based sub-states; tracked for a follow-up.
+*
+* `closed` is intentionally unmapped (terminal user-dismissed state —
+* handled by `moduleClosed`).
+*/
+function getEkybScreenName(snapshot) {
+	const stateName = topLevelStateName(snapshot.value);
+	if (stateName === void 0) return void 0;
+	switch (stateName) {
+		case "idle":
+		case "loading":
+		case "form": return "eKYB.default";
+		case "submitting": return "eKYB.processing";
+		case "success":
+		case "finished": return "eKYB.success";
+		case "error": return "eKYB.error";
+		default: return;
+	}
+}
 function mapState(snapshot) {
 	const typedSnapshot = snapshot;
 	const { context } = typedSnapshot;
@@ -129,7 +174,7 @@ function createEkybManager(options) {
 		actor: createEkybActor(options),
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.ekyb)
+		instrumentation: createManagerInstrumentation(eventModuleNames.ekyb, { getEventScreenName: getEkybScreenName })
 	});
 }
 

package/dist/{ekybStateMachine-klc-AImJ.esm.js → ekybStateMachine-CCSeqjCt.esm.js}

@@ -1,8 +1,8 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
-import { a as getPostalCodeMaxLength, c as STREET_LEVEL_REQUIRED_ERROR, d as usStateOptions, i as getPostalCodeErrorKey, l as fillFromSuggestion, n as FIXED_DIGIT_POSTAL_CODE_LENGTH, o as validatePostalCode, r as formatPostalCode, s as DYNAMIC_REQUIRED_KEY, t as debounceSearchActor, u as getStreetLevelErrorForSuggestion } from "./addressSearch-DvmWXKZg.esm.js";
-import { t as getFlow } from "./flowServices-ChgTNggJ.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
+import { a as getPostalCodeMaxLength, c as STREET_LEVEL_REQUIRED_ERROR, d as usStateOptions, i as getPostalCodeErrorKey, l as fillFromSuggestion, n as FIXED_DIGIT_POSTAL_CODE_LENGTH, o as validatePostalCode, r as formatPostalCode, s as DYNAMIC_REQUIRED_KEY, t as debounceSearchActor, u as getStreetLevelErrorForSuggestion } from "./addressSearch-DJyNTg5S.esm.js";
+import { t as getFlow } from "./flowServices-C4piblgx.esm.js";
 
 //#region src/modules/ekyb/ekybConstants.ts
 const UBO_INPUT_LIMIT = 8;

package/dist/ekyc.d.ts

@@ -1,6 +1,7 @@
-import { t as Manager } from "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
-import { a as EkycValidationError, c as AddressSuggestion, i as EkycModuleConfig, n as EkycFieldDef, o as EkycValidationErrors, r as EkycFormValues, t as EkycConfig } from "./types-DvGZI7BF.js";
+import "./StateMachine-C_AY4cs7.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import "./Actor-CGEelYtQ.js";
+import { a as EkycValidationError, c as AddressSuggestion, i as EkycModuleConfig, n as EkycFieldDef, o as EkycValidationErrors, r as EkycFormValues, t as EkycConfig } from "./types-D_IceWxT.js";
 
 //#region src/modules/ekyc/ekycStateMachine.d.ts
 declare const ekycMachine: any;
@@ -11,6 +12,7 @@ type CreateEkycActorOptions = {
 };
 //#endregion
 //#region src/modules/ekyc/ekycManager.d.ts
+
 type EkycLoadingState = {
   status: 'loading';
 };