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

package/dist/ekycStateMachine-x6Klot8g.esm.js

@@ -0,0 +1,1444 @@
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-DHzlkQNe.esm.js";
+import { _ as STATE_CODE_HINTS, a as toEkycConfig, c as CITY_SOURCES, d as EMAIL_SOURCES, f as HOUSE_NO_SOURCES, g as POSTAL_CODE_SOURCES, h as ONE_OF_REQUIRED_GROUPS, i as resolveEkycSource, l as COUNTRY_CODE_OMITTED_SOURCES, m as NAME_SOURCES, n as getEKYCFields, o as ADDRESS_STATE_SOURCES, p as MIDDLE_NAME_SOURCES, r as isFieldOptional, s as APARTMENT_SOURCES, t as getEKYCCountry, u as COUNTRY_SELECTOR_DISABLED_SOURCES, v as STREET_SOURCES, y as TAX_ID_SOURCES } from "./ekycUtils-zY8CdKJL.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";
+import { n as DateFormattingProvider, t as validateCPF } from "./cpf-uAZTPUBy.esm.js";
+import { n as loadPhoneValidation, t as getPhoneValidation } from "./phoneValidation-DnBcNUNh.esm.js";
+//#region src/modules/ekyc/ekycValidators.ts
+async function loadPhoneValidator() {
+	if (!await loadPhoneValidation()) throw new Error("Failed to load the phone validation rules");
+}
+/** Progressively formats an SSN as XXX-XX-XXXX */
+function formatSSN(value) {
+	const ssn = value?.replace(/\D/g, "") ?? "";
+	if (ssn.length < 4) return ssn;
+	if (ssn.length < 6) return `${ssn.slice(0, 3)}-${ssn.slice(3)}`;
+	return `${ssn.slice(0, 3)}-${ssn.slice(3, 5)}-${ssn.slice(5, 9)}`;
+}
+/**
+* Strips invalid characters from a name.
+* Fixes SDKv1 regex syntax issue — allows letters, accented chars, spaces, commas, apostrophes.
+*/
+function cleanName(name) {
+	return (name ?? "").replace(/[^a-zA-ZñÑáéíóúÁÉÍÓÚ\s,'´]/g, "").slice(0, 100);
+}
+const PO_BOX_REGEX = /POBox|P\.O\.Box|pobox|postofficebox|postbox|po\.box|p\.o\.box/i;
+/** Returns true if the address looks like a P.O. Box */
+function isPoBox(address) {
+	return PO_BOX_REGEX.test(address.replace(/\s/g, ""));
+}
+function validatePhone(phone, country) {
+	return getPhoneValidation()?.isValid(phone, country) ?? false;
+}
+function formatPhoneE164(phone, country) {
+	return getPhoneValidation()?.formatE164(phone, country) ?? phone;
+}
+const ONE_OF_REQUIRED_ERROR_KEY = "verification.errors.dobOrSsnRequired";
+const normalizeFieldValue = (value) => typeof value === "string" ? value : String(value ?? "");
+const SSN_FORMAT_REGEX = /^\d{3}-\d{2}-\d{4}$/;
+const EMAIL_FORMAT_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const buildPostalCodeParams = (country) => {
+	const fixedLen = FIXED_DIGIT_POSTAL_CODE_LENGTH[country];
+	if (fixedLen !== void 0) return { length: fixedLen };
+	let maxLen = getPostalCodeMaxLength(country);
+	if (country === "US" || country === "BR") maxLen = maxLen - 1;
+	return { maxLength: maxLen };
+};
+const createValidators = () => ({
+	required: (value, _rule, field) => {
+		if (value.trim().length > 0) return void 0;
+		const fieldName = field.displayLabel ?? field.label;
+		return fieldName ? {
+			key: DYNAMIC_REQUIRED_KEY,
+			params: { fieldName }
+		} : { key: DYNAMIC_REQUIRED_KEY };
+	},
+	streetLevelRequired: (value) => {
+		if (value.trim().length > 0) return void 0;
+		return STREET_LEVEL_REQUIRED_ERROR;
+	},
+	cpf: (value) => {
+		if (value.trim().length === 0) return void 0;
+		return validateCPF(value) ? void 0 : { key: "verification.errors.invalidTaxId" };
+	},
+	ssnFormat: (value) => {
+		if (value.trim().length === 0) return void 0;
+		return SSN_FORMAT_REGEX.test(value) ? void 0 : { key: "verification.errors.ssnFormat" };
+	},
+	noPoBox: (value) => {
+		if (value.trim().length === 0) return void 0;
+		return isPoBox(value) ? { key: "verification.errors.poBox" } : void 0;
+	},
+	postalCodeFormat: (value, rule) => {
+		if (rule.type !== "postalCodeFormat") return void 0;
+		if (value.trim().length === 0) return void 0;
+		if (validatePostalCode(value, rule.country)) return void 0;
+		return {
+			key: getPostalCodeErrorKey(rule.country),
+			params: buildPostalCodeParams(rule.country)
+		};
+	},
+	phoneFormat: (value, rule) => {
+		if (rule.type !== "phoneFormat") return void 0;
+		const trimmed = value.trim();
+		if (rule.optional && trimmed.length === 0) return void 0;
+		return validatePhone(trimmed, rule.country) ? void 0 : { key: "verification.errors.phoneInvalid" };
+	},
+	emailFormat: (value) => {
+		if (value.trim().length === 0) return void 0;
+		return EMAIL_FORMAT_REGEX.test(value) ? void 0 : { key: "verification.errors.emailInvalid" };
+	},
+	exactLength: (value, rule) => {
+		if (rule.type !== "exactLength") return void 0;
+		if (value.trim().length === 0) return void 0;
+		return value.length === rule.length ? void 0 : { key: "verification.errors.exactly10Characters" };
+	},
+	oneOfRequired: (_value, rule, _field, values) => {
+		if (rule.type !== "oneOfRequired") return void 0;
+		return rule.fields.some((name) => normalizeFieldValue(values[name]).trim().length > 0) ? void 0 : { key: ONE_OF_REQUIRED_ERROR_KEY };
+	}
+});
+const evaluateRules = (value, rules, field, values, validators) => {
+	if (!rules) return void 0;
+	for (const rule of rules) {
+		const error = validators[rule.type](value, rule, field, values);
+		if (error) return error;
+	}
+};
+function validateEkycForm(values, fields) {
+	const validators = createValidators();
+	return fields.reduce((errors, field) => {
+		const value = normalizeFieldValue(values[field.name]);
+		const error = evaluateRules(value, field.validation, field, values, validators);
+		if (error) errors[field.name] = error;
+		return errors;
+	}, {});
+}
+function validateEkycField(values, fieldName, fields) {
+	const field = fields.find((f) => f.name === fieldName);
+	if (!field) return void 0;
+	const validators = createValidators();
+	const value = normalizeFieldValue(values[field.name]);
+	return evaluateRules(value, field.validation, field, values, validators);
+}
+//#endregion
+//#region ../form-definitions/generated/ekyc.ts
+const EKYC_DEFINITIONS = {
+	"ekyc/BR/BR_GOVT_1": {
+		schemaVersion: 1,
+		vocabulary: "1.0",
+		id: "ekyc/BR/BR_GOVT_1",
+		module: "ekyc",
+		country: "BR",
+		source: "BR_GOVT_1",
+		sections: [{ id: "address" }, { id: "driverLicense" }],
+		fields: [
+			{
+				name: "firstName",
+				kind: "text",
+				group: "name",
+				required: true,
+				label: { key: "verification.labels.firstName" },
+				placeholder: { key: "verification.placeholder.firstName" },
+				input: {
+					maxLength: 100,
+					autofill: "givenName"
+				}
+			},
+			{
+				name: "surName",
+				kind: "text",
+				group: "name",
+				required: true,
+				label: { key: "verification.labels.surName" },
+				placeholder: { key: "verification.placeholder.surname" },
+				input: {
+					maxLength: 100,
+					autofill: "familyName"
+				}
+			},
+			{
+				name: "dateOfBirth",
+				kind: "date",
+				group: "dateOfBirth",
+				required: true,
+				label: { key: "verification.labels.dateOfBirth" },
+				input: { autofill: "birthday" }
+			},
+			{
+				name: "email",
+				kind: "text",
+				group: "email",
+				required: true,
+				label: { key: "verification.labels.email" },
+				placeholder: { key: "verification.placeholder.email" },
+				input: {
+					keyboard: "email",
+					autofill: "email"
+				},
+				rules: [{ id: "emailFormat" }]
+			},
+			{
+				name: "phone",
+				kind: "phone",
+				group: "phone",
+				required: true,
+				label: { key: "verification.labels.phone" },
+				input: { autofill: "phone" },
+				phone: { lockCountry: "whenPhoneRisk" },
+				rules: [{ id: "phoneFormat" }],
+				payload: { transforms: [{ id: "e164" }] }
+			},
+			{
+				name: "taxId",
+				kind: "text",
+				group: "ssn",
+				required: true,
+				label: { key: "verification.labels.taxId" },
+				displayLabel: {
+					key: "verification.labels.cpf",
+					text: "CPF"
+				},
+				rules: [{ id: "cpf" }]
+			},
+			{
+				name: "nationality",
+				kind: "choice",
+				group: "nationality",
+				required: true,
+				widget: "select",
+				label: { key: "verification.labels.nationality" },
+				options: [
+					{
+						value: "brazilian",
+						label: { key: "verification.labels.brazilian" }
+					},
+					{
+						value: "naturalizedBrazilian",
+						label: { key: "verification.labels.naturalizedBrazilian" }
+					},
+					{
+						value: "foreigner",
+						label: { key: "verification.labels.foreigner" }
+					},
+					{
+						value: "brazilianBornAbroad",
+						label: { key: "verification.labels.brazilianBornAbroad" }
+					}
+				],
+				payload: { transforms: [{ id: "uppercase" }] }
+			},
+			{
+				name: "last4SSN",
+				kind: "text",
+				group: "last4SSN",
+				required: true,
+				label: { key: "verification.labels.last4SSN" },
+				input: {
+					maxLength: 4,
+					keyboard: "numeric"
+				}
+			},
+			{
+				name: "idNum",
+				kind: "text",
+				group: "idNumber",
+				required: true,
+				label: { key: "verification.labels.idNum" },
+				input: { maxLength: 13 }
+			},
+			{
+				name: "idNum1",
+				kind: "text",
+				group: "idNumber1",
+				required: true,
+				label: { key: "verification.labels.idNum1" }
+			},
+			{
+				name: "gender",
+				kind: "choice",
+				group: "gender",
+				required: true,
+				widget: "radio",
+				label: { key: "verification.labels.gender" },
+				options: [{
+					value: "F",
+					label: { key: "common.female" }
+				}, {
+					value: "M",
+					label: { key: "common.male" }
+				}]
+			},
+			{
+				name: "panNumber",
+				kind: "text",
+				group: "panNumber",
+				required: true,
+				label: { key: "verification.labels.panNumber" },
+				input: { maxLength: 10 },
+				rules: [{
+					id: "exactLength",
+					params: { length: 10 }
+				}]
+			},
+			{
+				name: "houseNo",
+				kind: "text",
+				group: "address",
+				section: "address",
+				required: true,
+				label: { key: "verification.labels.houseNo" }
+			},
+			{
+				name: "street",
+				kind: "text",
+				group: "address",
+				section: "address",
+				required: true,
+				widget: "addressSearch",
+				label: { key: "verification.labels.street" },
+				input: { autofill: "addressLine1" },
+				rules: [{ id: "noPoBox" }]
+			},
+			{
+				name: "city",
+				kind: "text",
+				group: "address",
+				section: "address",
+				required: true,
+				label: { key: "verification.labels.city" },
+				input: { autofill: "addressLevel2" }
+			},
+			{
+				name: "state",
+				kind: "text",
+				group: "address",
+				section: "address",
+				required: true,
+				label: { key: "verification.labels.state" },
+				placeholder: {
+					key: "verification.placeholder.stateCode",
+					params: { states: "RJ, SP" }
+				},
+				input: { autofill: "addressLevel1" },
+				payload: { transforms: [{ id: "uppercase" }] }
+			},
+			{
+				name: "postalCode",
+				kind: "text",
+				group: "address",
+				section: "address",
+				required: true,
+				label: { key: "verification.labels.postalCode" },
+				input: {
+					maxLength: 9,
+					autofill: "postalCode"
+				},
+				rules: [{ id: "postalCodeFormat" }],
+				payload: { transforms: [{
+					id: "stripSeparators",
+					params: { chars: "- " }
+				}] }
+			},
+			{
+				name: "dlNumber",
+				kind: "text",
+				group: "dlNumber",
+				section: "driverLicense",
+				required: true,
+				label: { key: "verification.labels.dlNumber" }
+			},
+			{
+				name: "dlState",
+				kind: "choice",
+				group: "dlState",
+				section: "driverLicense",
+				required: true,
+				widget: "select",
+				label: { key: "verification.labels.dlState" },
+				placeholder: { key: "verification.placeholder.state" },
+				optionsRef: "US_STATES"
+			},
+			{
+				name: "dlExpireAt",
+				kind: "date",
+				group: "dlExpireAt",
+				section: "driverLicense",
+				required: true,
+				label: { key: "verification.labels.dlExpireAt" }
+			}
+		],
+		submit: {
+			static: { plugins: ["kyc"] },
+			context: {
+				source: "source",
+				countryCode: "country"
+			}
+		}
+	},
+	"ekyc/US/US_CREDIT_TELCO": {
+		schemaVersion: 1,
+		vocabulary: "1.0",
+		id: "ekyc/US/US_CREDIT_TELCO",
+		module: "ekyc",
+		country: "US",
+		source: "US_CREDIT_TELCO",
+		sections: [{ id: "address" }, { id: "driverLicense" }],
+		groups: [{
+			group: "name",
+			whenDisabled: "forceShow"
+		}],
+		fields: [
+			{
+				name: "firstName",
+				kind: "text",
+				group: "name",
+				required: true,
+				label: { key: "verification.labels.firstName" },
+				placeholder: { key: "verification.placeholder.firstName" },
+				input: {
+					maxLength: 100,
+					autofill: "givenName"
+				}
+			},
+			{
+				name: "surName",
+				kind: "text",
+				group: "name",
+				required: true,
+				label: { key: "verification.labels.lastName" },
+				placeholder: { key: "verification.placeholder.lastName" },
+				input: {
+					maxLength: 100,
+					autofill: "familyName"
+				}
+			},
+			{
+				name: "dateOfBirth",
+				kind: "date",
+				group: "dateOfBirth",
+				label: { key: "verification.labels.dateOfBirth" },
+				input: { autofill: "birthday" }
+			},
+			{
+				name: "email",
+				kind: "text",
+				group: "email",
+				required: true,
+				label: { key: "verification.labels.email" },
+				placeholder: { key: "verification.placeholder.email" },
+				input: {
+					keyboard: "email",
+					autofill: "email"
+				},
+				rules: [{ id: "emailFormat" }]
+			},
+			{
+				name: "phone",
+				kind: "phone",
+				group: "phone",
+				label: { key: "verification.labels.phone" },
+				input: { autofill: "phone" },
+				phone: { lockCountry: true },
+				rules: [{ id: "phoneFormat" }],
+				payload: { transforms: [{ id: "e164" }] }
+			},
+			{
+				name: "ssn",
+				kind: "text",
+				group: "ssn",
+				widget: "masked",
+				label: { key: "verification.labels.ssn" },
+				input: {
+					maxLength: 11,
+					keyboard: "numeric"
+				},
+				rules: [{ id: "ssnFormat" }],
+				payload: { transforms: [{
+					id: "stripSeparators",
+					params: { chars: "-" }
+				}] }
+			},
+			{
+				name: "nationality",
+				kind: "text",
+				group: "nationality",
+				required: true,
+				label: { key: "verification.labels.nationality" },
+				payload: { transforms: [{ id: "uppercase" }] }
+			},
+			{
+				name: "last4SSN",
+				kind: "text",
+				group: "last4SSN",
+				required: true,
+				label: { key: "verification.labels.last4SSN" },
+				input: {
+					maxLength: 4,
+					keyboard: "numeric"
+				}
+			},
+			{
+				name: "idNum",
+				kind: "text",
+				group: "idNumber",
+				required: true,
+				label: { key: "verification.labels.idNum" },
+				input: { maxLength: 13 }
+			},
+			{
+				name: "idNum1",
+				kind: "text",
+				group: "idNumber1",
+				required: true,
+				label: { key: "verification.labels.idNum1" }
+			},
+			{
+				name: "gender",
+				kind: "choice",
+				group: "gender",
+				required: true,
+				widget: "radio",
+				label: { key: "verification.labels.gender" },
+				options: [{
+					value: "F",
+					label: { key: "common.female" }
+				}, {
+					value: "M",
+					label: { key: "common.male" }
+				}]
+			},
+			{
+				name: "panNumber",
+				kind: "text",
+				group: "panNumber",
+				required: true,
+				label: { key: "verification.labels.panNumber" },
+				input: { maxLength: 10 },
+				rules: [{
+					id: "exactLength",
+					params: { length: 10 }
+				}]
+			},
+			{
+				name: "street",
+				kind: "text",
+				group: "address",
+				section: "address",
+				widget: "addressSearch",
+				label: { key: "verification.labels.street" },
+				input: { autofill: "addressLine1" },
+				rules: [{ id: "noPoBox" }]
+			},
+			{
+				name: "apartment",
+				kind: "text",
+				group: "address",
+				section: "address",
+				label: { key: "verification.labels.apartment" },
+				placeholder: { key: "verification.placeholder.apartment" },
+				input: { autofill: "addressLine2" }
+			},
+			{
+				name: "city",
+				kind: "text",
+				group: "address",
+				section: "address",
+				label: { key: "verification.labels.city" },
+				input: { autofill: "addressLevel2" }
+			},
+			{
+				name: "state",
+				kind: "choice",
+				group: "address",
+				section: "address",
+				widget: "select",
+				label: { key: "verification.labels.chooseState" },
+				placeholder: { key: "verification.placeholder.state" },
+				input: { autofill: "addressLevel1" },
+				optionsRef: "US_STATES",
+				payload: { transforms: [{ id: "uppercase" }] }
+			},
+			{
+				name: "postalCode",
+				kind: "text",
+				group: "address",
+				section: "address",
+				label: { key: "verification.labels.zipCode" },
+				input: {
+					maxLength: 10,
+					autofill: "postalCode"
+				},
+				rules: [{ id: "postalCodeFormat" }],
+				payload: { transforms: [{
+					id: "stripSeparators",
+					params: { chars: "- " }
+				}] }
+			},
+			{
+				name: "dlNumber",
+				kind: "text",
+				group: "dlNumber",
+				section: "driverLicense",
+				required: true,
+				label: { key: "verification.labels.dlNumber" }
+			},
+			{
+				name: "dlState",
+				kind: "choice",
+				group: "dlState",
+				section: "driverLicense",
+				required: true,
+				widget: "select",
+				label: { key: "verification.labels.dlState" },
+				placeholder: { key: "verification.placeholder.state" },
+				optionsRef: "US_STATES"
+			},
+			{
+				name: "dlExpireAt",
+				kind: "date",
+				group: "dlExpireAt",
+				section: "driverLicense",
+				required: true,
+				label: { key: "verification.labels.dlExpireAt" }
+			}
+		],
+		groupRules: [{
+			id: "oneOfRequired",
+			fields: ["dateOfBirth", "ssn"],
+			message: { key: "verification.errors.dobOrSsnRequired" }
+		}],
+		submit: {
+			static: { plugins: ["kyc"] },
+			context: {
+				source: "source",
+				countryCode: "country"
+			}
+		}
+	}
+};
+//#endregion
+//#region src/modules/ekyc/ekycForm.ts
+/**
+* eKYC adapter for form definitions.
+*
+* Selects the bundled definition for a source and country, resolves it against
+* the verification fields from module configuration, and projects the result
+* to today's public `EkycFieldDef[]` shape, including the `validation` arrays
+* today's validators run. A pair without a definition this projection can
+* express keeps the current builder.
+*/
+/** eKYC group id → the key `getEKYCFields` sets in `EkycVerificationFields`. */
+const EKYC_GROUP_KEYS = {
+	name: "name",
+	dateOfBirth: "date of birth",
+	email: "email",
+	phone: "phone",
+	address: "address",
+	ssn: "SSN",
+	last4SSN: "last4SSN",
+	idNumber: "idNum",
+	idNumber1: "idNum1",
+	nationality: "nationality",
+	gender: "gender",
+	panNumber: "panNumber",
+	dlNumber: "dlNumber",
+	dlState: "dlState",
+	dlExpireAt: "dlExpireAt"
+};
+const OPTION_LISTS = { US_STATES: usStateOptions };
+/** Vocabulary rules expressed as today's `EkycValidationRule` objects. */
+const RULES = {
+	cpf: () => ({ type: "cpf" }),
+	ssnFormat: () => ({ type: "ssnFormat" }),
+	noPoBox: () => ({ type: "noPoBox" }),
+	emailFormat: () => ({ type: "emailFormat" }),
+	postalCodeFormat: ({ country }) => ({
+		type: "postalCodeFormat",
+		country
+	}),
+	phoneFormat: ({ country, required }) => ({
+		type: "phoneFormat",
+		country,
+		optional: !required
+	}),
+	exactLength: ({ params }) => ({
+		type: "exactLength",
+		length: params.length
+	})
+};
+/**
+* Params a projected rule reads. The compiler checks params against the
+* vocabulary too; this keeps a definition that skipped it, such as a served
+* one later, from projecting a broken rule.
+*/
+const RULE_PARAMS = { exactLength: ({ length }) => typeof length === "number" && Number.isInteger(length) && length > 0 };
+/**
+* What the projection can express today. Request-body transforms are listed
+* because `buildSubmitPayload` already applies them, on the fields
+* `legacyPayloadTransforms` names; `requiredWhen` waits for decision B20, so
+* no condition is supported yet.
+*/
+const EKYC_SUPPORTED_IDS = {
+	schemaVersions: [1],
+	vocabulary: "1.0",
+	kinds: /* @__PURE__ */ new Set([
+		"text",
+		"date",
+		"choice",
+		"phone"
+	]),
+	groups: new Set(Object.keys(EKYC_GROUP_KEYS)),
+	rules: new Set(Object.keys(RULES)),
+	transforms: /* @__PURE__ */ new Set([
+		"stripSeparators",
+		"e164",
+		"uppercase"
+	]),
+	groupRules: /* @__PURE__ */ new Set(["oneOfRequired"]),
+	optionLists: new Set(Object.keys(OPTION_LISTS)),
+	conditions: /* @__PURE__ */ new Set()
+};
+/** Today's field shape only flags `middleName` as optional. */
+const LEGACY_OPTIONAL_FLAG = /* @__PURE__ */ new Set(["middleName"]);
+/** The sections the eKYC UI has headers for. */
+const UI_SECTIONS = /* @__PURE__ */ new Set(["address", "driverLicense"]);
+/** The fields today's DOB-or-SSN group rule and its message are for. */
+const ONE_OF_REQUIRED_FIELDS = ["dateOfBirth", "ssn"];
+/** A Text today's field shape can carry: a key only, or `text` where shown. */
+const plainKey = (text) => !text?.params;
+/**
+* The request-body transforms `buildSubmitPayload` applies to a field. It
+* reads values by field name and transforms them in fixed branches, not from
+* the definition, so until the kernel builds request bodies (P2) a definition
+* must declare exactly these. Otherwise a transform it declares on another
+* field would pass `checkSupport` and then not be applied. Mirrors those
+* branches by hand: change both together.
+*/
+function legacyPayloadTransforms(name, country) {
+	switch (name) {
+		case "phone": return [{ id: "e164" }];
+		case "nationality":
+		case "state": return [{ id: "uppercase" }];
+		case "postalCode": return [{
+			id: "stripSeparators",
+			params: { chars: "- " }
+		}];
+		case "ssn": return country === "US" || country === "CA" ? [{
+			id: "stripSeparators",
+			params: { chars: "-" }
+		}] : [];
+		default: return [];
+	}
+}
+function sameTransforms(declared, expected) {
+	return declared.length === expected.length && declared.every((transform, i) => {
+		const params = transform.params ?? {};
+		const want = expected[i].params ?? {};
+		return transform.id === expected[i].id && Object.keys(params).length === Object.keys(want).length && Object.entries(want).every(([key, value]) => params[key] === value);
+	});
+}
+/**
+* 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 or suggestions, and only placeholders take params. Input
+* formatting (`processFieldValue`) and the request body (`buildSubmitPayload`)
+* stay keyed by field name until P2.
+*/
+function isProjectableField(field, country) {
+	return !field.hint && !field.suggestionsRef && plainKey(field.label) && plainKey(field.displayLabel) && (field.options ?? []).every((option) => plainKey(option.label)) && (!field.section || UI_SECTIONS.has(field.section)) && (field.rules ?? []).every((rule) => !rule.message && (RULE_PARAMS[rule.id]?.(rule.params ?? {}) ?? true)) && !field.input?.format?.length && (field.payload?.key ?? field.name) === field.name && !field.payload?.omit && sameTransforms(field.payload?.transforms ?? [], legacyPayloadTransforms(field.name, country));
+}
+/**
+* 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 `EkycFieldDef`. */
+function isProjectableEkycDefinition(definition) {
+	let result = projectable.get(definition);
+	if (result === void 0) {
+		result = definition.module === "ekyc" && checkSupport(definition, EKYC_SUPPORTED_IDS).supported && definition.fields.every((field) => isProjectableField(field, definition.country ?? "")) && (definition.sections ?? []).every((section) => !section.title && UI_SECTIONS.has(section.id)) && (definition.groupRules ?? []).every((rule) => rule.fields.length === ONE_OF_REQUIRED_FIELDS.length && ONE_OF_REQUIRED_FIELDS.every((name) => rule.fields.includes(name)) && (!rule.message || rule.message.key === "verification.errors.dobOrSsnRequired" && !rule.message.params));
+		projectable.set(definition, result);
+	}
+	return result;
+}
+const bundled = createBundledDefinitionSource(EKYC_DEFINITIONS);
+/** The bundled definition for exactly this source and country, if it is projectable. */
+function selectEkycDefinition(source, country) {
+	const definition = bundled.select({
+		module: "ekyc",
+		source,
+		country
+	});
+	return definition && isProjectableEkycDefinition(definition) ? definition : void 0;
+}
+function toEkycResolveContext(verificationFields, enablePhoneRisk) {
+	return {
+		groups: Object.fromEntries(Object.entries(EKYC_GROUP_KEYS).map(([group, key]) => [group, Boolean(verificationFields[key])])),
+		phoneRisk: enablePhoneRisk
+	};
+}
+function fieldType(field) {
+	if (field.kind === "choice") return field.widget === "radio" ? "radio" : "dropdown";
+	return field.kind === "date" || field.kind === "phone" ? field.kind : "text";
+}
+function fieldOptions(field) {
+	if (field.optionsRef) return OPTION_LISTS[field.optionsRef];
+	return field.options?.map((option) => ({
+		value: option.value,
+		label: option.label.key
+	}));
+}
+function projectField(resolved, verificationFields, country) {
+	const { field, required } = resolved;
+	const groupKey = EKYC_GROUP_KEYS[field.group];
+	const source = groupKey && verificationFields[groupKey] || "user_input";
+	const def = {
+		name: field.name,
+		type: fieldType(field),
+		label: field.label.key,
+		source,
+		required
+	};
+	if (field.placeholder) {
+		def.placeholder = field.placeholder.key;
+		if (field.placeholder.params) def.placeholderParams = { ...field.placeholder.params };
+	}
+	if (field.displayLabel) def.displayLabel = field.displayLabel.text ?? field.displayLabel.key;
+	if (field.input?.maxLength !== void 0) def.maxLength = field.input.maxLength;
+	const options = fieldOptions(field);
+	if (options) def.options = options;
+	if (field.section) def.section = field.section;
+	if (field.kind === "phone") def.disableCountrySelector = resolved.phoneLocked;
+	if (LEGACY_OPTIONAL_FLAG.has(field.name)) def.optional = true;
+	const validation = required ? [{ type: "required" }] : [];
+	for (const rule of field.rules ?? []) {
+		const project = RULES[rule.id];
+		if (project) validation.push(project({
+			country,
+			required,
+			params: rule.params ?? {}
+		}));
+	}
+	if (validation.length > 0) def.validation = validation;
+	return def;
+}
+/**
+* Projects a resolved definition to today's `EkycFieldDef[]`, identical to
+* what `legacyBuildFieldDefs` returns for the same source and country.
+*/
+function projectEkycFields(form, verificationFields, country) {
+	const defs = form.fields.map((resolved) => projectField(resolved, verificationFields, country));
+	for (const { fields } of form.groupRules) for (const def of defs) if (fields.includes(def.name)) def.validation = [{
+		type: "oneOfRequired",
+		fields: [...fields]
+	}, ...def.validation ?? []];
+	return defs;
+}
+//#endregion
+//#region src/modules/ekyc/ekycActions.ts
+const dateFormattingInstance = new DateFormattingProvider();
+function buildValidationRules(field, country, configSource) {
+	const rules = [];
+	if (field.required) rules.push({ type: "required" });
+	if (field.name === "taxId" && country === "BR") rules.push({ type: "cpf" });
+	if (field.name === "ssn" && (country === "US" || country === "CA")) rules.push({ type: "ssnFormat" });
+	if (field.name === "street") rules.push({ type: "noPoBox" });
+	if (field.name === "postalCode") rules.push({
+		type: "postalCodeFormat",
+		country
+	});
+	if (field.name === "phone") rules.push({
+		type: "phoneFormat",
+		country,
+		optional: isFieldOptional("phone", configSource)
+	});
+	if (field.name === "email") rules.push({ type: "emailFormat" });
+	if (field.name === "panNumber") rules.push({
+		type: "exactLength",
+		length: 10
+	});
+	return rules;
+}
+function applyOneOfRequiredGroups(defs, configSource) {
+	for (const group of ONE_OF_REQUIRED_GROUPS[configSource] ?? []) {
+		const members = defs.filter((def) => group.includes(def.name));
+		const fields = members.map((def) => def.name);
+		for (const def of members) def.validation = [{
+			type: "oneOfRequired",
+			fields
+		}, ...def.validation ?? []];
+	}
+}
+/**
+* Builds the form's field defs. A source with a form definition for exactly
+* this country reads it (`packages/form-definitions/catalog/ekyc`); any other
+* pair keeps the current builder.
+*/
+function buildFieldDefs(fields, configSource, country, enablePhoneRisk = false) {
+	const definition = selectEkycDefinition(configSource, country);
+	if (definition) return projectEkycFields(resolveForm(definition, toEkycResolveContext(fields, enablePhoneRisk)), fields, country);
+	return legacyBuildFieldDefs(fields, configSource, country, enablePhoneRisk);
+}
+/** The per-source builder for sources without a form definition yet. */
+function legacyBuildFieldDefs(fields, configSource, country, enablePhoneRisk = false) {
+	const defs = [];
+	const add = (name, type, label, source, opts) => {
+		if (source === false) return;
+		const def = {
+			name,
+			type,
+			label,
+			source,
+			required: !isFieldOptional(name, configSource),
+			...opts
+		};
+		const validation = buildValidationRules(def, country, configSource);
+		if (validation.length > 0) def.validation = validation;
+		defs.push(def);
+	};
+	const nameSource = fields.name || (NAME_SOURCES.includes(configSource) ? "user_input" : false);
+	if (nameSource) {
+		add("firstName", "text", "verification.labels.firstName", nameSource, {
+			maxLength: 100,
+			placeholder: "verification.placeholder.firstName"
+		});
+		if (MIDDLE_NAME_SOURCES.includes(configSource)) add("middleName", "text", "verification.labels.middleName", nameSource, {
+			maxLength: 100,
+			placeholder: "verification.placeholder.middleName",
+			optional: true
+		});
+		add("surName", "text", country === "US" ? "verification.labels.lastName" : "verification.labels.surName", nameSource, {
+			maxLength: 100,
+			placeholder: country === "US" ? "verification.placeholder.lastName" : "verification.placeholder.surname"
+		});
+		if (country === "MX") add("maternalSurname", "text", "verification.labels.maternalSurname", nameSource, {
+			maxLength: 100,
+			placeholder: "verification.placeholder.maternalSurname"
+		});
+	}
+	if (fields["date of birth"]) add("dateOfBirth", "date", "verification.labels.dateOfBirth", fields["date of birth"]);
+	const emailSource = fields.email || (EMAIL_SOURCES.includes(configSource) ? "user_input" : false);
+	if (emailSource) add("email", "text", "verification.labels.email", emailSource, { placeholder: "verification.placeholder.email" });
+	if (fields.phone) {
+		const phoneCountrySelectorDisabled = enablePhoneRisk && configSource !== "PHONE_RISK_1" || COUNTRY_SELECTOR_DISABLED_SOURCES.includes(configSource);
+		add("phone", "phone", "verification.labels.phone", fields.phone, { disableCountrySelector: phoneCountrySelectorDisabled });
+	}
+	if (fields.SSN) if (country === "BR" || TAX_ID_SOURCES.includes(configSource)) add("taxId", "text", "verification.labels.taxId", fields.SSN, { ...country === "BR" && { displayLabel: "CPF" } });
+	else if (country === "CN") add("ssn", "text", "verification.labels.prcId", fields.SSN);
+	else add("ssn", "text", "verification.labels.ssn", fields.SSN, { maxLength: 11 });
+	if (fields.nationality) if (country === "BR") add("nationality", "dropdown", "verification.labels.nationality", fields.nationality, { options: [
+		{
+			value: "brazilian",
+			label: "verification.labels.brazilian"
+		},
+		{
+			value: "naturalizedBrazilian",
+			label: "verification.labels.naturalizedBrazilian"
+		},
+		{
+			value: "foreigner",
+			label: "verification.labels.foreigner"
+		},
+		{
+			value: "brazilianBornAbroad",
+			label: "verification.labels.brazilianBornAbroad"
+		}
+	] });
+	else add("nationality", "text", "verification.labels.nationality", fields.nationality);
+	if (fields.last4SSN) add("last4SSN", "text", "verification.labels.last4SSN", fields.last4SSN, { maxLength: 4 });
+	if (fields.idNum) add("idNum", "text", "verification.labels.idNum", fields.idNum, { maxLength: 13 });
+	if (fields.idNum1) add("idNum1", "text", "verification.labels.idNum1", fields.idNum1);
+	if (fields.gender) add("gender", "radio", "verification.labels.gender", fields.gender, { options: [{
+		value: "F",
+		label: "common.female"
+	}, {
+		value: "M",
+		label: "common.male"
+	}] });
+	if (fields.panNumber) add("panNumber", "text", "verification.labels.panNumber", fields.panNumber, { maxLength: 10 });
+	const addAddressFields = () => {
+		const addrSource = fields.address;
+		if (!addrSource) return;
+		if (HOUSE_NO_SOURCES.includes(configSource)) add("houseNo", "text", "verification.labels.houseNo", addrSource, { section: "address" });
+		if (STREET_SOURCES.includes(configSource)) add("street", "text", "verification.labels.street", addrSource, { section: "address" });
+		if (APARTMENT_SOURCES.includes(configSource)) add("apartment", "text", "verification.labels.apartment", addrSource, {
+			section: "address",
+			placeholder: "verification.placeholder.apartment"
+		});
+		if (CITY_SOURCES.includes(configSource)) add("city", "text", "verification.labels.city", addrSource, { section: "address" });
+		if (ADDRESS_STATE_SOURCES.includes(configSource)) add("state", country === "US" ? "dropdown" : "text", country === "US" ? "verification.labels.chooseState" : "verification.labels.state", addrSource, {
+			section: "address",
+			...country === "US" ? {
+				options: usStateOptions,
+				placeholder: "verification.placeholder.state"
+			} : {
+				placeholder: "verification.placeholder.stateCode",
+				placeholderParams: { states: STATE_CODE_HINTS[country] ?? "" }
+			}
+		});
+		if (POSTAL_CODE_SOURCES.includes(configSource)) add("postalCode", "text", country === "US" ? "verification.labels.zipCode" : "verification.labels.postalCode", addrSource, {
+			section: "address",
+			maxLength: getPostalCodeMaxLength(country)
+		});
+	};
+	const addDriversLicenseFields = () => {
+		if (fields.dlNumber) add("dlNumber", "text", "verification.labels.dlNumber", fields.dlNumber, { section: "driverLicense" });
+		if (fields.dlState) add("dlState", "dropdown", "verification.labels.dlState", fields.dlState, {
+			section: "driverLicense",
+			options: usStateOptions,
+			placeholder: "verification.placeholder.state"
+		});
+		if (fields.dlExpireAt) add("dlExpireAt", "date", "verification.labels.dlExpireAt", fields.dlExpireAt, { section: "driverLicense" });
+	};
+	if (configSource === "US_TELCO_1") {
+		addDriversLicenseFields();
+		addAddressFields();
+	} else {
+		addAddressFields();
+		addDriversLicenseFields();
+	}
+	applyOneOfRequiredGroups(defs, configSource);
+	return defs;
+}
+function applyPrefill(fields, ocrData, otpStatus, _country) {
+	const values = {};
+	const prefilled = {};
+	const readonlyFields = [];
+	let hideEmail = false;
+	if (fields.name === "document_scan" && ocrData?.name) {
+		if (ocrData.name.firstName) {
+			values.firstName = ocrData.name.firstName;
+			prefilled.firstName = true;
+		}
+		if (ocrData.name.paternalLastName) {
+			values.surName = ocrData.name.paternalLastName;
+			prefilled.surName = true;
+		}
+		if (ocrData.name.middleName) {
+			values.middleName = ocrData.name.middleName;
+			prefilled.middleName = true;
+		}
+		if (ocrData.name.maternalLastName) {
+			values.maternalSurname = ocrData.name.maternalLastName;
+			prefilled.maternalSurname = true;
+		}
+	}
+	const ocrBirthDate = dateFormattingInstance.utcToIsoDateString(ocrData?.birthDate);
+	if (fields["date of birth"] === "document_scan" && ocrBirthDate) {
+		values.dateOfBirth = ocrBirthDate;
+		prefilled.dateOfBirth = true;
+	}
+	const addressSource = fields.address;
+	if (addressSource === "document_scan" || addressSource === "poa_document") {
+		const addrData = addressSource === "poa_document" ? ocrData?.addressFieldsFromStatement ?? void 0 : ocrData?.addressFields ?? ocrData?.checkedAddressBean ?? void 0;
+		if (addrData) {
+			if (addrData.street) {
+				values.street = addrData.street;
+				prefilled.street = true;
+			}
+			if (addrData.city) {
+				values.city = addrData.city;
+				prefilled.city = true;
+			}
+			if (addrData.state) {
+				values.state = addrData.state;
+				prefilled.state = true;
+			}
+			if (addrData.postalCode) {
+				values.postalCode = addrData.postalCode;
+				prefilled.postalCode = true;
+			}
+			if (addrData.houseNumber) {
+				values.houseNo = addrData.houseNumber;
+				prefilled.houseNo = true;
+			}
+		}
+	}
+	if (fields.phone === "phone_module_input" && otpStatus?.phone) {
+		values.phone = otpStatus.phone;
+		prefilled.phone = true;
+		readonlyFields.push("phone");
+	}
+	if (fields.email === "email_module_input" && otpStatus?.email) {
+		values.email = otpStatus.email;
+		prefilled.email = true;
+		hideEmail = true;
+	}
+	return {
+		values,
+		prefilled,
+		hideEmail,
+		readonlyFields
+	};
+}
+/**
+* Builds the request body. Keep the per-field transforms below in sync with
+* `legacyPayloadTransforms` in `ekycForm.ts`: definitions are projectable only
+* when they declare exactly these, until P2 builds request bodies from them.
+*/
+function buildSubmitPayload(ctx) {
+	const payload = {};
+	for (const field of ctx.fields) {
+		const val = ctx.values[field.name];
+		if (val !== void 0 && val !== "") payload[field.name] = val;
+	}
+	if (payload.nationality) payload.nationality = payload.nationality.toUpperCase();
+	if (ctx.fieldsCountry && !COUNTRY_CODE_OMITTED_SOURCES.includes(ctx.configSource)) payload.countryCode = ctx.fieldsCountry;
+	if (ctx.hideEmail && ctx.values.email) payload.email = ctx.values.email;
+	if (payload.ssn && (ctx.fieldsCountry === "US" || ctx.fieldsCountry === "CA")) payload.ssn = payload.ssn.replace(/-/g, "");
+	if (payload.postalCode) payload.postalCode = payload.postalCode.replace(/[-\s]/g, "");
+	if (payload.phone) payload.phone = formatPhoneE164(payload.phone, ctx.fieldsCountry);
+	if (payload.state) payload.state = payload.state.toUpperCase();
+	if (ctx.configSource === "UK_CREDIT_BUREAU_1" && payload.countryCode) payload.country = payload.countryCode;
+	if (ctx.configSource === "US_DRIVERS_LICENSE_1" && payload.dlState) payload.state = payload.dlState;
+	return {
+		...payload,
+		plugins: ["kyc"],
+		source: ctx.configSource
+	};
+}
+function processFieldValue(name, value, fieldsCountry) {
+	if ((name === "firstName" || name === "surName" || name === "middleName" || name === "maternalSurname") && value) return cleanName(value);
+	if (name === "ssn" && (fieldsCountry === "US" || fieldsCountry === "CA")) return formatSSN(value);
+	if (name === "postalCode") return formatPostalCode(value, fieldsCountry);
+	if (name === "panNumber") return value.replace(/[^a-zA-Z0-9]/g, "").toUpperCase();
+	return value;
+}
+//#endregion
+//#region src/modules/ekyc/ekycServices.ts
+/** Fetches module configuration for EXTERNAL_VERIFICATION */
+async function fetchModuleConfig(flowId, signal) {
+	const url = `${endpoints.moduleConfig}?id=${encodeURIComponent(flowId)}&moduleKey=EXTERNAL_VERIFICATION`;
+	const res = await api.get(url, { signal });
+	if (!res.ok) throw new Error(`GET ${url} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+/** Fetches OCR data for pre-fill */
+async function fetchOcrData(signal) {
+	const res = await api.get(endpoints.ocrData, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.ocrData} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+/** Fetches phone/email from prior OTP modules */
+async function fetchOtpStatus(signal) {
+	const res = await api.get(endpoints.otpStatus, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.otpStatus} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+var EkycSubmitError = class extends Error {
+	constructor(status, apiError) {
+		super(`POST ${endpoints.ekycSubmit} failed: ${status} – ${apiError}`);
+		this.name = "EkycSubmitError";
+		this.status = status;
+		this.apiError = apiError;
+	}
+};
+/** Submits eKYC verification */
+async function submitEkyc(data, signal) {
+	try {
+		return (await api.post(endpoints.ekycSubmit, data, { signal })).data;
+	} catch (err) {
+		const httpErr = err;
+		if (typeof httpErr.status === "number") {
+			const body = httpErr.data;
+			const apiError = body?.error ?? body?.message ?? String(err);
+			throw new EkycSubmitError(httpErr.status, apiError);
+		}
+		throw err;
+	}
+}
+//#endregion
+//#region src/modules/ekyc/ekycGuards.ts
+const hasNoValidationErrorsGuard = ({ context }) => Object.keys(context.validationErrors ?? {}).length === 0;
+const hasFlowIdGuard = ({ context }) => !!context.config.flowId;
+const hasVerificationFieldsGuard = ({ context }) => !!context.config.verificationFields;
+const COUNTRY_NOT_SUPPORTED_MSG = "Request unsuccessful. Country not supported for EKYC.";
+const isCountryNotSupportedGuard = ({ event }) => {
+	const err = event.error;
+	return err instanceof EkycSubmitError && err.status === 400 && err.apiError === COUNTRY_NOT_SUPPORTED_MSG;
+};
+//#endregion
+//#region src/modules/ekyc/ekycActors.ts
+const fetchModuleConfigActor = fromPromise(async ({ input, signal }) => {
+	const phoneRules = loadPhoneValidator();
+	phoneRules.catch(() => void 0);
+	const config = await fetchModuleConfig(input.flowId, signal);
+	if (getEKYCFields(config).phone !== false) await phoneRules;
+	return config;
+});
+const fetchPrefillDataActor = fromPromise(async ({ signal }) => {
+	const [ocrData, otpStatus] = await Promise.all([fetchOcrData(signal).catch(() => void 0), fetchOtpStatus(signal).catch(() => void 0)]);
+	return {
+		ocrData,
+		otpStatus
+	};
+});
+const submitEkycActor = fromPromise(async ({ input, signal }) => submitEkyc(input, signal));
+//#endregion
+//#region src/modules/ekyc/ekycStateMachine.ts
+const ADDRESS_AUTOCOMPLETE_KEYS = [
+	"street",
+	"city",
+	"state",
+	"postalCode",
+	"houseNo"
+];
+const omitKeys = (errors, keys) => {
+	if (!errors) return void 0;
+	const next = { ...errors };
+	for (const key of keys) delete next[key];
+	return Object.keys(next).length > 0 ? next : void 0;
+};
+const ekycMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchModuleConfig: fetchModuleConfigActor,
+		fetchPrefillData: fetchPrefillDataActor,
+		submitEkyc: submitEkycActor,
+		debounceSearch: debounceSearchActor
+	},
+	actions: {
+		setModuleConfig: assign(({ context, event }) => {
+			const config = event.output;
+			const source = resolveEkycSource(config.source ?? context.config.source ?? "", config.riskAddons);
+			const country = context.config.fieldsCountry ?? getEKYCCountry(source);
+			const vFields = getEKYCFields(config);
+			return {
+				moduleConfig: config,
+				verificationFields: vFields,
+				configSource: source,
+				fieldsCountry: country,
+				fields: buildFieldDefs(vFields, source, country, config.enablePhoneRisk)
+			};
+		}),
+		applyPrefillData: assign(({ context, event }) => {
+			const { ocrData, otpStatus } = event.output;
+			const { values, prefilled, hideEmail, readonlyFields } = applyPrefill(context.verificationFields, ocrData, otpStatus, context.fieldsCountry);
+			return {
+				values,
+				prefilled,
+				hideEmail,
+				fields: context.fields.map((f) => ({
+					...f,
+					readonly: readonlyFields.includes(f.name) ? true : f.readonly
+				}))
+			};
+		}),
+		updateField: assign(({ context, event }) => {
+			if (event.type !== "DATA_CHANGED") return {};
+			const processedValue = processFieldValue(event.name, event.value, context.fieldsCountry);
+			return {
+				values: {
+					...context.values,
+					[event.name]: processedValue
+				},
+				submitError: ""
+			};
+		}),
+		clearFieldValidationError: assign(({ context, event }) => {
+			if (event.type !== "DATA_CHANGED") return {};
+			const errs = context.validationErrors;
+			if (!errs) return {};
+			const next = { ...errs };
+			delete next[event.name];
+			const oneOfRule = context.fields.find((f) => f.name === event.name)?.validation?.find((rule) => rule.type === "oneOfRequired");
+			if (oneOfRule?.type === "oneOfRequired") {
+				for (const sibling of oneOfRule.fields) if (next[sibling]?.key === "verification.errors.dobOrSsnRequired") delete next[sibling];
+			}
+			if (Object.keys(next).length === Object.keys(errs).length) return {};
+			return { validationErrors: Object.keys(next).length > 0 ? next : void 0 };
+		}),
+		validateFormField: assign(({ context, event }) => {
+			if (event.type !== "VALIDATE_FIELD") return {};
+			const message = validateEkycField(context.values, event.name, context.fields);
+			const next = { ...context.validationErrors ?? {} };
+			if (message) next[event.name] = message;
+			else delete next[event.name];
+			return { validationErrors: Object.keys(next).length > 0 ? next : void 0 };
+		}),
+		computeValidationResult: assign(({ context }) => {
+			const errors = validateEkycForm(context.values, context.fields);
+			return { validationErrors: Object.keys(errors).length > 0 ? errors : void 0 };
+		}),
+		fillAddressFields: assign(({ context, event }) => {
+			const { suggestion } = event;
+			const activeFields = new Set(context.fields.map((f) => f.name));
+			const { values: newValues } = fillFromSuggestion(context.values, {}, suggestion, activeFields);
+			const clearedErrors = omitKeys(context.validationErrors, ADDRESS_AUTOCOMPLETE_KEYS);
+			const streetError = getStreetLevelErrorForSuggestion(suggestion, activeFields);
+			const validationErrors = {
+				...clearedErrors ?? {},
+				...streetError !== void 0 ? { street: streetError } : {}
+			};
+			return {
+				values: newValues,
+				addressSuggestions: [],
+				_searchQuery: "",
+				validationErrors: Object.keys(validationErrors).length > 0 ? validationErrors : void 0,
+				submitError: ""
+			};
+		}),
+		setAddressSuggestions: assign(({ event }) => ({ addressSuggestions: event.suggestions })),
+		setErrorMessage: assign(({ event }) => ({ errorMessage: String(event.error ?? "verification.error") })),
+		clearErrorMessage: assign({ errorMessage: () => "" }),
+		setSubmitError: assign(() => ({ submitError: "verification.errors.countryNotSupported" })),
+		clearSubmitError: assign({ submitError: () => "" })
+	},
+	guards: {
+		hasNoValidationErrors: hasNoValidationErrorsGuard,
+		hasFlowId: hasFlowIdGuard,
+		hasVerificationFields: hasVerificationFieldsGuard,
+		isCountryNotSupported: isCountryNotSupportedGuard
+	}
+}).createMachine({
+	id: "ekyc",
+	initial: "idle",
+	context: ({ input }) => {
+		const config = toEkycConfig(input.config);
+		return {
+			config,
+			moduleConfig: void 0,
+			verificationFields: {},
+			configSource: config.source ?? "",
+			fieldsCountry: config.fieldsCountry ?? "",
+			fields: [],
+			values: {},
+			addressSuggestions: [],
+			prefilled: {},
+			hideEmail: false,
+			errorMessage: "",
+			submitError: "",
+			_searchQuery: ""
+		};
+	},
+	states: {
+		idle: { on: { LOAD: [
+			{
+				target: "loading",
+				guard: "hasFlowId"
+			},
+			{
+				target: "prefilling",
+				guard: "hasVerificationFields",
+				actions: assign(({ context }) => {
+					const vFields = context.config.verificationFields;
+					const source = context.config.source ?? "";
+					const country = context.config.fieldsCountry ?? getEKYCCountry(source);
+					return {
+						verificationFields: vFields,
+						configSource: source,
+						fieldsCountry: country,
+						fields: buildFieldDefs(vFields, source, country, context.config.enablePhoneRisk)
+					};
+				})
+			},
+			{ target: "misconfigured" }
+		] } },
+		loading: { invoke: {
+			id: "fetchModuleConfig",
+			src: "fetchModuleConfig",
+			input: ({ context }) => ({ flowId: context.config.flowId }),
+			onDone: {
+				target: "prefilling",
+				actions: "setModuleConfig"
+			},
+			onError: {
+				target: "error",
+				actions: "setErrorMessage"
+			}
+		} },
+		prefilling: { invoke: {
+			id: "fetchPrefillData",
+			src: "fetchPrefillData",
+			onDone: {
+				target: "form",
+				actions: "applyPrefillData"
+			},
+			onError: { target: "form" }
+		} },
+		form: {
+			initial: "inputting",
+			states: {
+				inputting: { on: {
+					DATA_CHANGED: { actions: ["updateField", "clearFieldValidationError"] },
+					VALIDATE_FIELD: { actions: "validateFormField" },
+					SUBMIT: { target: "validatingSubmit" }
+				} },
+				searching: {
+					invoke: {
+						id: "debounceSearch",
+						src: "debounceSearch",
+						input: ({ context }) => ({ query: context._searchQuery })
+					},
+					on: {
+						DATA_CHANGED: { actions: ["updateField", "clearFieldValidationError"] },
+						VALIDATE_FIELD: { actions: "validateFormField" },
+						RESULTS: {
+							target: "inputting",
+							actions: "setAddressSuggestions"
+						}
+					}
+				},
+				validatingSubmit: {
+					entry: "computeValidationResult",
+					always: [{
+						guard: "hasNoValidationErrors",
+						target: "#ekyc.submitting"
+					}, { target: "inputting" }]
+				}
+			},
+			on: {
+				SEARCH_ADDRESS: {
+					target: ".searching",
+					actions: assign(({ event }) => ({
+						_searchQuery: event.query,
+						addressSuggestions: []
+					}))
+				},
+				SELECT_ADDRESS: {
+					target: ".inputting",
+					actions: "fillAddressFields"
+				},
+				SKIP: { target: "#ekyc.finished" },
+				CLOSE: { target: "#ekyc.closed" }
+			}
+		},
+		submitting: { invoke: {
+			id: "submitEkyc",
+			src: "submitEkyc",
+			input: ({ context }) => buildSubmitPayload(context),
+			onDone: { target: "success" },
+			onError: [{
+				target: "form",
+				guard: "isCountryNotSupported",
+				actions: "setSubmitError"
+			}, {
+				target: "error",
+				actions: "setErrorMessage"
+			}]
+		} },
+		success: { after: { 3e3: "finished" } },
+		error: { on: {
+			RETRY: {
+				target: "form",
+				actions: "clearErrorMessage"
+			},
+			SKIP: { target: "finished" },
+			CLOSE: { target: "closed" }
+		} },
+		misconfigured: { on: { CLOSE: { target: "closed" } } },
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+//#endregion
+export { ekycMachine as t };