@incodetech/core 2.3.2-rc.4 → 2.4.0-rc.0

package/dist/{ekybManager-BwRuGAwt.d.ts → ekybManager-BaZ_7CEu.d.ts}

@@ -1,8 +1,8 @@
 import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
-import { t as Manager } from "./Manager-CQQ99QOI.js";
-import "./Actor-iTq7YY48.js";
-import { c as AddressSuggestion } from "./types-Cx-1zo-i.js";
-import { i as EkybFormValues, o as EkybValidationErrors, r as EkybFieldDef, s as UboEntry, t as EkybConfig } from "./types-C0oWGUzg.js";
+import { t as Manager } from "./Manager-C9T5amUN.js";
+import "./Actor-DpTj5PFb.js";
+import { c as AddressSuggestion } from "./types-BvLo3U4u.js";
+import { i as EkybFormValues, o as EkybValidationErrors, r as EkybFieldDef, s as UboEntry, t as EkybConfig } from "./types-0L-eFDmr.js";
 //#region src/modules/ekyb/ekybStateMachine.d.ts
 declare const ekybMachine: any;
 type EkybMachine = typeof ekybMachine;

package/dist/{ekybManager-CsQMgJDL.esm.js → ekybManager-CazShiQz.esm.js}

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CAgFE-k3.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
-import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as ekybMachine } from "./ekybStateMachine-DBeQNOMo.esm.js";
+import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
+import { t as ekybMachine } from "./ekybStateMachine-hstiCNmW.esm.js";
 //#region src/modules/ekyb/ekybActor.ts
 /**
 * Creates and starts an eKYB actor.
@@ -13,31 +13,17 @@ 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`.
+* Maps the existing combined eKYB form and its outcome screens.
+* https://www.figma.com/design/TWgYZVhurQCizfC4tfLEut?node-id=2977-10474
 *
-* 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):
+* ENG-45716 F3 remains a baseline/UX decision: Figma defines country.empty,
+* country.filled, bdetails.empty, bdetails.filled, director.empty,
+* director.filled and directorloading, while this runtime has one form.
+* Keep its existing eKYB.default until a combined-form taxonomy is approved
+* or the actual steps are implemented. Do not emit fictional step visits.
+* processing/success/error already match the baseline.
 *
-* - `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`).
+* `closed` is a terminal dismissal handled by module lifecycle instrumentation.
 */
 function getEkybScreenName(snapshot) {
 	const stateName = topLevelStateName(snapshot.value);
@@ -160,12 +146,22 @@ function createApi({ actor, trackElementClicked }) {
 		}
 	};
 }
+function hasFormValidationErrors(snapshot) {
+	return topLevelStateName(snapshot.value) === "form" && Object.keys(snapshot.context.validationErrors ?? {}).length > 0;
+}
 function createEkybManagerFromActor(actor) {
 	return createManager({
 		actor,
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.ekyb, { getEventScreenName: getEkybScreenName })
+		instrumentation: createManagerInstrumentation(eventModuleNames.ekyb, {
+			getEventScreenName: getEkybScreenName,
+			getErrorName: (snapshot) => hasFormValidationErrors(snapshot) ? "error.validation" : void 0,
+			getErrorPayload: (snapshot) => hasFormValidationErrors(snapshot) ? {
+				reason: "validation",
+				errorCode: "VALIDATION_FAILED"
+			} : void 0
+		})
 	});
 }
 /**

package/dist/{ekybStateMachine-DBeQNOMo.esm.js → ekybStateMachine-hstiCNmW.esm.js}

@@ -1,9 +1,9 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
-import { A as isSupportedCountry, C as COUNTRIES_WITH_CNPJ_VALIDATION, D as INVALID_CNPJ_PATTERNS, E as FIELD_ORDER, S as CNPJ_SECOND_DIGIT_FACTORS, T as FIELD_NAME_MAPPING, _ as sortModulesByOrder, b as ALL_COUNTRIES, g as requiresAddressValidation, h as isFieldOptional, k as UBO_FIELD_LABELS, m as hasAtLeastOneAddressField, n as getFlow, v as toEkybConfig, x as CNPJ_FIRST_DIGIT_FACTORS, y as ADDRESS_FIELDS } from "./flowServices-JW6uRaUt.esm.js";
-import { i as assign, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.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-DyHGgeX8.esm.js";
+import { t as endpoints } from "./endpoints-DHzlkQNe.esm.js";
+import { A as isSupportedCountry, C as COUNTRIES_WITH_CNPJ_VALIDATION, D as INVALID_CNPJ_PATTERNS, E as FIELD_ORDER, S as CNPJ_SECOND_DIGIT_FACTORS, T as FIELD_NAME_MAPPING, _ as sortModulesByOrder, b as ALL_COUNTRIES, g as requiresAddressValidation, h as isFieldOptional, k as UBO_FIELD_LABELS, m as hasAtLeastOneAddressField, n as getFlow, v as toEkybConfig, x as CNPJ_FIRST_DIGIT_FACTORS, y as ADDRESS_FIELDS } from "./flowServices-DA64AEZC.esm.js";
+import { i as assign, t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-8Gzepa_A.esm.js";
+import { a as FIXED_DIGIT_POSTAL_CODE_LENGTH, c as getPostalCodeMaxLength, d as STREET_LEVEL_REQUIRED_ERROR, f as fillFromSuggestion, i as checkSupport, l as validatePostalCode, m as usStateOptions, n as resolveForm, o as formatPostalCode, p as getStreetLevelErrorForSuggestion, r as createBundledDefinitionSource, s as getPostalCodeErrorKey, t as debounceSearchActor, u as DYNAMIC_REQUIRED_KEY } from "./addressSearch-BiYZjvp3.esm.js";
 //#region src/modules/ekyb/ekybValidators.ts
 function cleanCnpjString(cnpj) {
 	return cnpj.replace(/\./g, "").replace(/\//g, "").replace(/-/g, "");
@@ -175,6 +175,309 @@ function requiresCnpjValidation(country) {
 	return COUNTRIES_WITH_CNPJ_VALIDATION.includes(country);
 }
 //#endregion
+//#region ../form-definitions/generated/ekyb.ts
+const EKYB_DEFINITIONS = {
+	"ekyb/MX": {
+		schemaVersion: 1,
+		vocabulary: "1.0",
+		id: "ekyb/MX",
+		module: "ekyb",
+		country: "MX",
+		fields: [
+			{
+				name: "businessName",
+				kind: "text",
+				group: "businessName",
+				required: true,
+				label: { key: "ekyb.businessName" },
+				input: { autofill: "organization" }
+			},
+			{
+				name: "taxId",
+				kind: "text",
+				group: "taxId",
+				required: true,
+				label: { key: "ekyb.taxId" }
+			},
+			{
+				name: "postalCode",
+				kind: "text",
+				group: "address",
+				required: true,
+				label: { key: "ekyb.postalCode" },
+				input: {
+					maxLength: 5,
+					autofill: "postalCode"
+				},
+				rules: [{ id: "postalCodeFormat" }]
+			}
+		],
+		submit: {
+			static: { plugins: ["ekyb"] },
+			context: { country: "country" }
+		}
+	},
+	"ekyb/US": {
+		schemaVersion: 1,
+		vocabulary: "1.0",
+		id: "ekyb/US",
+		module: "ekyb",
+		country: "US",
+		fields: [
+			{
+				name: "businessName",
+				kind: "text",
+				group: "businessName",
+				required: true,
+				label: { key: "ekyb.businessName" },
+				input: { autofill: "organization" }
+			},
+			{
+				name: "taxId",
+				kind: "text",
+				group: "taxId",
+				required: true,
+				label: { key: "ekyb.taxId" }
+			},
+			{
+				name: "street",
+				kind: "text",
+				group: "address",
+				required: true,
+				widget: "addressSearch",
+				label: { key: "ekyb.street" },
+				input: { autofill: "addressLine1" }
+			},
+			{
+				name: "houseNo",
+				kind: "text",
+				group: "address",
+				required: true,
+				label: { key: "ekyb.houseNo" }
+			},
+			{
+				name: "addressLine2",
+				kind: "text",
+				group: "address",
+				label: { key: "ekyb.addressLine2" },
+				input: { autofill: "addressLine2" }
+			},
+			{
+				name: "city",
+				kind: "text",
+				group: "address",
+				required: true,
+				label: { key: "ekyb.city" },
+				input: { autofill: "addressLevel2" }
+			},
+			{
+				name: "state",
+				kind: "choice",
+				group: "address",
+				required: true,
+				widget: "select",
+				label: { key: "ekyb.state" },
+				placeholder: { key: "verification.placeholder.state" },
+				input: { autofill: "addressLevel1" },
+				optionsRef: "US_STATES"
+			},
+			{
+				name: "postalCode",
+				kind: "text",
+				group: "address",
+				required: true,
+				label: { key: "ekyb.postalCode" },
+				input: {
+					maxLength: 10,
+					autofill: "postalCode"
+				},
+				rules: [{ id: "postalCodeFormat" }]
+			}
+		],
+		collections: [{
+			id: "ubos",
+			group: "ubos",
+			min: 1,
+			max: 8,
+			fields: [{
+				name: "name",
+				kind: "text",
+				group: "ubos",
+				required: true,
+				label: { key: "ekyb.uboName" }
+			}, {
+				name: "surname",
+				kind: "text",
+				group: "ubos",
+				required: true,
+				label: { key: "ekyb.uboSurname" }
+			}],
+			payload: {
+				key: "uboNames",
+				join: ["name", "surname"]
+			}
+		}],
+		submit: {
+			static: { plugins: ["ekyb"] },
+			context: { country: "country" }
+		}
+	}
+};
+//#endregion
+//#region src/modules/ekyb/ekybForm.ts
+/**
+* eKYB adapter for form definitions.
+*
+* Selects the bundled definition for a country, resolves it against the
+* verification fields from module configuration, and projects the result to
+* today's public `EkybFieldDef[]` shape. A country without a projectable
+* definition, or a custom field list that can't be expressed as groups, keeps
+* the current builder.
+*/
+/** eKYB group id → the verification-field entries that turn it on. */
+const EKYB_GROUP_ENTRIES = {
+	businessName: ["name-user_input"],
+	taxId: ["taxId-user_input"],
+	address: [
+		"street-user_input",
+		"houseNo-user_input",
+		"address2-user_input",
+		"city-user_input",
+		"state-user_input",
+		"postalCode-user_input"
+	],
+	ubos: ["ubos-user_input"]
+};
+const KNOWN_ENTRIES = new Set(Object.values(EKYB_GROUP_ENTRIES).flat());
+const OPTION_LISTS = { US_STATES: usStateOptions };
+/** Vocabulary rules expressed as today's `EkybValidationRule` objects. */
+const RULES = {
+	cnpj: () => ({ type: "cnpj" }),
+	postalCodeFormat: (country) => ({
+		type: "postalCodeFormat",
+		country
+	})
+};
+const EKYB_SUPPORTED_IDS = {
+	schemaVersions: [1],
+	vocabulary: "1.0",
+	kinds: /* @__PURE__ */ new Set(["text", "choice"]),
+	groups: new Set(Object.keys(EKYB_GROUP_ENTRIES)),
+	rules: new Set(Object.keys(RULES)),
+	transforms: /* @__PURE__ */ new Set(),
+	groupRules: /* @__PURE__ */ new Set(),
+	optionLists: new Set(Object.keys(OPTION_LISTS)),
+	conditions: /* @__PURE__ */ new Set()
+};
+/** Today's UBO actions use a fixed limit and a single collection. */
+const UBO_COLLECTION = "ubos";
+/**
+* Whether today's code handles a field the way its definition says. Today's
+* validators show their own message, so a rule can't carry one. The field
+* shape has no hint, suggestions, sections or Text params, and the UI shows a
+* placeholder only on dropdowns. `buildEkybSubmitPayload` sends the value
+* under the field name, unchanged. Input formatting and request bodies stay
+* in today's code until P2.
+*/
+function isProjectableField(field) {
+	return !field.hint && !field.suggestionsRef && !field.section && !field.label.params && !field.displayLabel?.params && (field.options ?? []).every((option) => !option.label.params) && (!field.placeholder || field.kind === "choice" && !field.placeholder.params) && (field.rules ?? []).every((rule) => !rule.message) && !field.input?.format?.length && (field.payload?.key ?? field.name) === field.name && !field.payload?.omit;
+}
+/** The only properties today's owner fields honor. */
+const UBO_FIELD_KEYS = /* @__PURE__ */ new Set([
+	"name",
+	"kind",
+	"group",
+	"required",
+	"label"
+]);
+/**
+* Today's owner code is fixed: owner 1 is required, up to `UBO_INPUT_LIMIT`
+* owners, each with a required name and surname under `UBO_FIELD_LABELS`, and
+* the request body joins them into `uboNames`. A collection is projectable
+* only when it declares exactly that.
+*/
+function isProjectableUboCollection(collection) {
+	const { key, join } = collection.payload;
+	const names = collection.fields.map((field) => field.name);
+	return collection.id === UBO_COLLECTION && collection.min === 1 && collection.max === 8 && key === "uboNames" && join.length === 2 && join[0] === "name" && join[1] === "surname" && names.length === 2 && names[0] === "name" && names[1] === "surname" && collection.fields.every((field) => Object.keys(field).every((prop) => UBO_FIELD_KEYS.has(prop)) && field.kind === "text" && field.required === true && Object.keys(field.label).length === 1 && field.label.key === UBO_FIELD_LABELS[field.name]);
+}
+/**
+* Caches the check per definition object. Bundled definitions are singletons
+* created once at module load, so each is checked once. A served source (P4)
+* that builds new objects per call would still be correct, but would miss
+* this cache; key it by definition id and version then.
+*/
+const projectable = /* @__PURE__ */ new WeakMap();
+/** Whether every part of a definition maps onto today's `EkybFieldDef`. */
+function isProjectableEkybDefinition(definition) {
+	let result = projectable.get(definition);
+	if (result === void 0) {
+		result = definition.module === "ekyb" && checkSupport(definition, EKYB_SUPPORTED_IDS).supported && !definition.sections?.length && definition.fields.every(isProjectableField) && (definition.collections ?? []).every(isProjectableUboCollection);
+		projectable.set(definition, result);
+	}
+	return result;
+}
+/**
+* Maps module configuration to groups. Returns `undefined` when the field
+* list can't be expressed as whole groups (an unknown entry, or part of the
+* address), so the current builder keeps handling it.
+*/
+function toEkybResolveContext(config, verificationFields) {
+	const entries = verificationFields.filter((entry) => !entry.startsWith("socure"));
+	if (entries.some((entry) => !KNOWN_ENTRIES.has(entry))) return void 0;
+	const groups = {};
+	for (const [group, groupEntries] of Object.entries(EKYB_GROUP_ENTRIES)) {
+		const present = groupEntries.filter((e) => entries.includes(e)).length;
+		if (present !== 0 && present !== groupEntries.length) return void 0;
+		groups[group] = present > 0;
+	}
+	groups.ubos = groups.ubos === true && config.checkUniqueBeneficialOwner !== false;
+	return { groups };
+}
+const bundled = createBundledDefinitionSource(EKYB_DEFINITIONS);
+/** The resolved definition for this country and configuration, if one applies. */
+function selectEkybForm(config, verificationFields, country) {
+	const context = toEkybResolveContext(config, verificationFields);
+	if (!context) return void 0;
+	const definition = bundled.select({
+		module: "ekyb",
+		country
+	});
+	if (!definition || !isProjectableEkybDefinition(definition)) return void 0;
+	return resolveForm(definition, context);
+}
+function projectField(field, required, country) {
+	const def = {
+		name: field.name,
+		type: field.kind === "choice" ? "dropdown" : "text",
+		label: field.label.key,
+		required
+	};
+	if (field.placeholder) def.placeholder = field.placeholder.key;
+	if (field.displayLabel) def.displayLabel = field.displayLabel.text ?? field.displayLabel.key;
+	if (field.input?.maxLength !== void 0) def.maxLength = field.input.maxLength;
+	if (field.optionsRef) def.options = OPTION_LISTS[field.optionsRef];
+	else if (field.options) def.options = field.options.map((option) => ({
+		value: option.value,
+		label: option.label.key
+	}));
+	const validation = required ? [{ type: "required" }] : [];
+	for (const rule of field.rules ?? []) {
+		const project = RULES[rule.id];
+		if (project) validation.push(project(country));
+	}
+	if (validation.length > 0) def.validation = validation;
+	return def;
+}
+/** Projects a resolved definition to today's `EkybFieldDef[]`. */
+function projectEkybFields(form, country) {
+	return form.fields.map(({ field, required }) => projectField(field, required, country));
+}
+/** Whether the resolved form collects beneficial owners. */
+function hasUboCollection(form) {
+	return form.collections.some((c) => c.collection.id === UBO_COLLECTION);
+}
+//#endregion
 //#region src/modules/ekyb/ekybActions.ts
 function buildEkybValidationRules(fieldName, required, country) {
 	const rules = [];
@@ -186,6 +489,25 @@ function buildEkybValidationRules(fieldName, required, country) {
 	});
 	return rules;
 }
+/**
+* Fields and beneficial-owner state for a country. A country with a form
+* definition (`packages/form-definitions/catalog/ekyb`) reads it; any other
+* country, or a custom field list that isn't whole groups, keeps the current
+* builder and its UBO rule.
+*/
+function buildEkybForm(config, verificationFields, country) {
+	const form = selectEkybForm(config, verificationFields, country);
+	if (form) return {
+		fields: projectEkybFields(form, country),
+		hasUbos: hasUboCollection(form)
+	};
+	const hasUbos = config.checkUniqueBeneficialOwner !== false && verificationFields.includes("ubos-user_input") && country !== "MX";
+	return {
+		fields: buildEkybFields(verificationFields, country, hasUbos),
+		hasUbos
+	};
+}
+/** The per-country builder for countries without a form definition yet. */
 function buildEkybFields(verificationFields, country, _hasUbos) {
 	let modules = verificationFields.filter((f) => f !== "ubos-user_input" && !f.startsWith("socure"));
 	if (country === "GB") modules = modules.filter((m) => m !== "state-user_input");
@@ -233,6 +555,12 @@ function processEkybFieldValue(name, value, country) {
 	if (name === "postalCode") return formatPostalCode(value, country);
 	return value;
 }
+/**
+* Builds the request body. Keep it in sync with `isProjectableField` and
+* `isProjectableUboCollection` in `ekybForm.ts`: definitions are projectable
+* only when they declare exactly this handling, until P2 builds request
+* bodies from them.
+*/
 function buildEkybSubmitPayload(ctx) {
 	const uboNames = ctx.ubos.filter((u) => u.name.trim() || u.surname.trim()).map((u) => `${u.name.trim()} ${u.surname.trim()}`.trim());
 	const payload = {
@@ -307,13 +635,12 @@ const ekybMachine = setup({
 				checkUniqueBeneficialOwner: fetched.checkUniqueBeneficialOwner
 			};
 			const country = "US";
-			const vFields = getDefaultVerificationFields(config);
-			const hasUbos = config.checkUniqueBeneficialOwner !== false && vFields.includes("ubos-user_input");
+			const { fields, hasUbos } = buildEkybForm(config, getDefaultVerificationFields(config), country);
 			return {
 				config,
 				country,
 				availableCountries: ALL_COUNTRIES,
-				fields: buildEkybFields(vFields, country, hasUbos),
+				fields,
 				values: { country },
 				validationErrors: void 0,
 				ubos: hasUbos ? [{
@@ -331,8 +658,7 @@ const ekybMachine = setup({
 		setCountry: assign(({ context, event }) => {
 			const { country } = event;
 			const vFields = getDefaultVerificationFields(context.config);
-			const hasUbos = context.config.checkUniqueBeneficialOwner !== false && vFields.includes("ubos-user_input") && country !== "MX";
-			const fields = buildEkybFields(vFields, country, hasUbos);
+			const { fields, hasUbos } = buildEkybForm(context.config, vFields, country);
 			let nextId = context._nextUboId;
 			let ubos;
 			if (hasUbos) if (context.ubos.length > 0) ubos = context.ubos;
@@ -485,13 +811,12 @@ const ekybMachine = setup({
 	context: ({ input }) => {
 		const config = toEkybConfig(input.config);
 		const country = "US";
-		const vFields = getDefaultVerificationFields(config);
-		const hasUbos = config.checkUniqueBeneficialOwner !== false && vFields.includes("ubos-user_input");
+		const { fields, hasUbos } = buildEkybForm(config, getDefaultVerificationFields(config), country);
 		return {
 			config,
 			country,
 			availableCountries: ALL_COUNTRIES,
-			fields: buildEkybFields(vFields, country, hasUbos),
+			fields,
 			values: { country },
 			validationErrors: void 0,
 			ubos: hasUbos ? [{

package/dist/ekyc.d.ts

@@ -1,5 +1,5 @@
-import { a as EkycValidationError, c as AddressSuggestion, i as EkycModuleConfig, o as EkycValidationErrors, t as EkycConfig } from "./types-Cx-1zo-i.js";
-import { n as EkycState, o as ekycMachine, r as createEkycManager, t as EkycManager } from "./ekycManager-DLzDuBzI.js";
+import { a as EkycValidationError, c as AddressSuggestion, i as EkycModuleConfig, o as EkycValidationErrors, t as EkycConfig } from "./types-BvLo3U4u.js";
+import { n as EkycState, o as ekycMachine, r as createEkycManager, t as EkycManager } from "./ekycManager-DW-ynodd.js";
 //#region src/modules/ekyc/ekycUtils.d.ts
 /**
  * Normalizes any supported eKYC config input into a manager-ready `EkycConfig`.

package/dist/ekyc.esm.js

@@ -1,4 +1,4 @@
-import { i as toEkycConfig } from "./ekycUtils-D6wfSpPN.esm.js";
-import { t as ekycMachine } from "./ekycStateMachine-UeJRO8_p.esm.js";
-import { t as createEkycManager } from "./ekycManager-BX2d46FY.esm.js";
+import { a as toEkycConfig } from "./ekycUtils-zY8CdKJL.esm.js";
+import { t as ekycMachine } from "./ekycStateMachine-x6Klot8g.esm.js";
+import { t as createEkycManager } from "./ekycManager-BdJRUsz0.esm.js";
 export { createEkycManager, ekycMachine, toEkycConfig };

package/dist/{ekycManager-BX2d46FY.esm.js → ekycManager-BdJRUsz0.esm.js}

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CAgFE-k3.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
-import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as ekycMachine } from "./ekycStateMachine-UeJRO8_p.esm.js";
+import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
+import { t as ekycMachine } from "./ekycStateMachine-x6Klot8g.esm.js";
 //#region src/modules/ekyc/ekycActor.ts
 /**
 * Creates and starts an eKYC actor.
@@ -13,34 +13,12 @@ function createEkycActor(options) {
 //#endregion
 //#region src/modules/ekyc/ekycManager.ts
 /**
-* Maps an eKYC state-machine snapshot to the exact Figma "Tracked Events"
-* screen name. Source: eKYC Figma file → Tracked Events canvas
-* (`https://www.figma.com/design/TWgYZVhurQCizfC4tfLEut/eKYC---eKYB---Ready-for-Dev?node-id=2977-10474`).
-* Family is `eKYC.*` and section names are returned verbatim, emitted as-is
-* on `event.screen` by `createManagerInstrumentation` (e.g. `eKYC.filled`,
-* `eKYC.verify`). See `docs/patterns/INSTRUMENTATION.md`.
+* Screen taxonomy: ENG-45716 v4 QA baseline and the eKYC Tracked Events canvas:
+* https://www.figma.com/design/TWgYZVhurQCizfC4tfLEut?node-id=2977-10474
 *
-* Note the canvas uses `eKYC.filled` for the entry surface (not
-* `eKYC.default`) and `eKYC.verify` for the submit-in-flight surface (the
-* success instance lives inside the verify section).
-*
-* State → screen mapping rationale:
-*
-* - `idle` / `loading` / `prefilling` collapse onto `eKYC.filled` — the
-*   prefill round-trip happens before the user sees the form, but Figma does
-*   not define a dedicated loading/prefill surface (the per-country
-*   `eKYC-empty *` instances in the `eKYC-States` section are visual
-*   references, not analytics screens). Keeping the family on `eKYC.filled`
-*   avoids falling back to a generic `eKYC.loading` default and mixing
-*   taxonomies in dashboards.
-* - `submitting` → `eKYC.verify` (verifying surface).
-* - `success`/`finished` → `eKYC.success` so the terminal `finished` state
-*   stays on the visible success canvas.
-* - `misconfigured` is intentionally unmapped — Figma does not define a
-*   misconfiguration surface, and the misconfigured state is an SDK
-*   configuration error rather than a user-visible journey screen.
-* - `closed` is intentionally unmapped (terminal user-dismissed state —
-*   handled by `moduleClosed`).
+* Form completeness follows configured required fields, independently of the
+* optimistic Continue button and validation timing. Finalization can follow a
+* skip, so only the success state reports success.
 */
 function getEkycScreenName(snapshot) {
 	const stateName = topLevelStateName(snapshot.value);
@@ -48,11 +26,16 @@ function getEkycScreenName(snapshot) {
 	switch (stateName) {
 		case "idle":
 		case "loading":
-		case "prefilling":
-		case "form": return "eKYC.filled";
-		case "submitting": return "eKYC.verify";
-		case "success":
-		case "finished": return "eKYC.success";
+		case "prefilling": return "eKYC.loading";
+		case "form": {
+			const { fields, values } = snapshot.context;
+			const required = fields.filter((field) => field.required);
+			const hasValue = (field) => (values[field.name]?.trim().length ?? 0) > 0;
+			return (required.length > 0 ? required.every(hasValue) : fields.some(hasValue)) ? "eKYC.filled" : "eKYC.default";
+		}
+		case "submitting": return "eKYC.processing";
+		case "success": return "eKYC.success";
+		case "finished": return "";
 		case "error": return "eKYC.error";
 		default: return;
 	}
@@ -141,12 +124,22 @@ function createApi({ actor, trackElementClicked }) {
 		}
 	};
 }
+function hasFormValidationErrors(snapshot) {
+	return topLevelStateName(snapshot.value) === "form" && Object.keys(snapshot.context.validationErrors ?? {}).length > 0;
+}
 function createEkycManagerFromActor(actor) {
 	return createManager({
 		actor,
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.ekyc, { getEventScreenName: getEkycScreenName })
+		instrumentation: createManagerInstrumentation(eventModuleNames.ekyc, {
+			getEventScreenName: getEkycScreenName,
+			getErrorName: (snapshot) => hasFormValidationErrors(snapshot) ? "error.validation" : void 0,
+			getErrorPayload: (snapshot) => hasFormValidationErrors(snapshot) ? {
+				reason: "validation",
+				errorCode: "VALIDATION_FAILED"
+			} : void 0
+		})
 	});
 }
 function createEkycManager(options) {

package/dist/{ekycManager-DLzDuBzI.d.ts → ekycManager-DW-ynodd.d.ts}

@@ -1,7 +1,7 @@
 import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
-import { t as Manager } from "./Manager-CQQ99QOI.js";
-import "./Actor-iTq7YY48.js";
-import { c as AddressSuggestion, n as EkycFieldDef, o as EkycValidationErrors, r as EkycFormValues, t as EkycConfig } from "./types-Cx-1zo-i.js";
+import { t as Manager } from "./Manager-C9T5amUN.js";
+import "./Actor-DpTj5PFb.js";
+import { c as AddressSuggestion, n as EkycFieldDef, o as EkycValidationErrors, r as EkycFormValues, t as EkycConfig } from "./types-BvLo3U4u.js";
 //#region src/modules/ekyc/ekycStateMachine.d.ts
 declare const ekycMachine: any;
 type EkycMachine = typeof ekycMachine;