@incodetech/core 0.0.0-dev-20261014-e4db9c02 → 0.0.0-dev-20261014-82c6fd33

package/dist/{ekycStateMachine-DnKlILfu.esm.js → ekycStateMachine-BqacNxVI.esm.js}

@@ -1,11 +1,146 @@
 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-3FIL6m1x.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-DrRSBMVL.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 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-Bm8zTbQJ.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/internal/forms/checkSupport.ts
+const GROUP_POLICIES = /* @__PURE__ */ new Set(["hide", "forceShow"]);
+/** Compares `major.minor` vocabulary versions. */
+function compareVocabulary(a, b) {
+	const [aMajor = 0, aMinor = 0] = a.split(".").map(Number);
+	const [bMajor = 0, bMinor = 0] = b.split(".").map(Number);
+	return aMajor - bMajor || aMinor - bMinor;
+}
+/**
+* Whether this build can use a definition. Any id it doesn't implement makes
+* the definition unsupported, so the caller falls back to its bundled
+* definition or current form. Presentation hints (widget, keyboard, autofill)
+* never fail: an unknown hint falls back to the platform default.
+*/
+function checkSupport(definition, ids) {
+	const problems = [];
+	const need = (category, known, id, path) => {
+		if (!known.has(id)) problems.push({
+			category,
+			id,
+			path
+		});
+	};
+	if (!ids.schemaVersions.includes(definition.schemaVersion)) problems.push({
+		category: "schemaVersion",
+		id: String(definition.schemaVersion),
+		path: "schemaVersion"
+	});
+	if (compareVocabulary(definition.vocabulary, ids.vocabulary) > 0) problems.push({
+		category: "vocabulary",
+		id: definition.vocabulary,
+		path: "vocabulary"
+	});
+	const checkField = (field, path) => {
+		need("kind", ids.kinds, field.kind, `${path}.kind`);
+		need("group", ids.groups, field.group, `${path}.group`);
+		field.rules?.forEach((rule, i) => need("rule", ids.rules, rule.id, `${path}.rules[${i}]`));
+		field.input?.format?.forEach((t, i) => need("transform", ids.transforms, t.id, `${path}.input.format[${i}]`));
+		field.payload?.transforms?.forEach((t, i) => need("transform", ids.transforms, t.id, `${path}.payload.transforms[${i}]`));
+		if (field.optionsRef) need("optionList", ids.optionLists, field.optionsRef, `${path}.optionsRef`);
+		if (field.suggestionsRef) need("optionList", ids.optionLists, field.suggestionsRef, `${path}.suggestionsRef`);
+		field.requiredWhen?.forEach((condition, i) => {
+			const keys = Object.keys(condition);
+			if (keys.length !== 1) problems.push({
+				category: "condition",
+				id: keys.join("+") || "(empty)",
+				path: `${path}.requiredWhen[${i}]`
+			});
+			for (const key of keys) need("condition", ids.conditions, key, `${path}.requiredWhen[${i}]`);
+		});
+		const lock = field.phone?.lockCountry;
+		if (typeof lock === "string" && lock !== "whenPhoneRisk") problems.push({
+			category: "phoneLock",
+			id: lock,
+			path: `${path}.phone`
+		});
+	};
+	definition.fields.forEach((field) => checkField(field, `fields.${field.name}`));
+	definition.groups?.forEach((policy) => {
+		need("group", ids.groups, policy.group, `groups.${policy.group}`);
+		if (!GROUP_POLICIES.has(policy.whenDisabled)) problems.push({
+			category: "groupPolicy",
+			id: policy.whenDisabled,
+			path: `groups.${policy.group}`
+		});
+	});
+	definition.groupRules?.forEach((rule, i) => need("groupRule", ids.groupRules, rule.id, `groupRules[${i}]`));
+	definition.collections?.forEach((collection) => {
+		need("group", ids.groups, collection.group, `collections.${collection.id}`);
+		collection.fields.forEach((field) => checkField(field, `collections.${collection.id}.fields.${field.name}`));
+	});
+	return problems.length === 0 ? { supported: true } : {
+		supported: false,
+		problems
+	};
+}
+//#endregion
+//#region src/internal/forms/definitionSource.ts
+const queryKey = ({ module, source, country }) => `${module}|${source ?? ""}|${country ?? ""}`;
+/**
+* The definitions bundled with this build. Matches module, source and country
+* exactly, so a pair without its own definition keeps the current builder.
+*/
+function createBundledDefinitionSource(definitions) {
+	const byQuery = new Map(Object.values(definitions).map((definition) => [queryKey(definition), definition]));
+	return { select: (query) => byQuery.get(queryKey(query)) };
+}
+//#endregion
+//#region src/internal/forms/resolveForm.ts
+const FORCE_SHOW = "forceShow";
+const WHEN_PHONE_RISK = "whenPhoneRisk";
+/**
+* Resolves a definition against module configuration: which fields show,
+* which are required, whether the phone is locked, and which group rules and
+* collections apply. Pure and synchronous, so it runs inside an assign action.
+*
+* Call `checkSupport` first for any definition that wasn't bundled with this
+* build; `resolveForm` ignores ids it doesn't know.
+*/
+function resolveForm(definition, context) {
+	const forcedGroups = new Set((definition.groups ?? []).filter((policy) => policy.whenDisabled === FORCE_SHOW).map((policy) => policy.group));
+	const isOn = (group) => context.groups[group] === true;
+	const isShown = (group) => isOn(group) || forcedGroups.has(group);
+	const riskAddons = new Set(context.riskAddons ?? []);
+	const shownFields = definition.fields.filter((field) => isShown(field.group));
+	const shownNames = new Set(shownFields.map((field) => field.name));
+	const fields = shownFields.map((field) => {
+		const conditions = field.requiredWhen ?? [];
+		const addonRequired = conditions.some((condition) => condition.riskAddon !== void 0 && riskAddons.has(condition.riskAddon));
+		const requiredIfFilled = conditions.map((condition) => condition.fieldFilled).filter((name) => name !== void 0 && shownNames.has(name));
+		const lock = field.phone?.lockCountry;
+		return {
+			field,
+			required: field.required === true || addonRequired,
+			requiredIfFilled,
+			forced: !isOn(field.group),
+			phoneLocked: field.kind === "phone" && (lock === true || lock === WHEN_PHONE_RISK && context.phoneRisk === true)
+		};
+	});
+	const order = shownFields.map((field) => field.name);
+	return {
+		definition,
+		fields,
+		groupRules: (definition.groupRules ?? []).map((rule) => ({
+			rule,
+			fields: order.filter((name) => rule.fields.includes(name))
+		})).filter((resolved) => resolved.fields.length > 0),
+		collections: (definition.collections ?? []).filter((collection) => isShown(collection.group)).map((collection) => ({
+			collection,
+			min: collection.min ?? 0,
+			max: collection.max
+		}))
+	};
+}
+//#endregion
 //#region src/modules/ekyc/ekycValidators.ts
 async function loadPhoneValidator() {
 	if (!await loadPhoneValidation()) throw new Error("Failed to load the phone validation rules");
@@ -124,6 +259,662 @@ function validateEkycField(values, fieldName, fields) {
 	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: Number(params.length)
+	})
+};
+/**
+* What the projection can express today. Request-body transforms are listed
+* because `buildSubmitPayload` already applies them; `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"]);
+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.groupRules ?? []).every((rule) => !rule.message || rule.message.key === "verification.errors.dobOrSsnRequired");
+		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) {
@@ -158,7 +949,18 @@ function applyOneOfRequiredGroups(defs, configSource) {
 		}, ...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;