@incodetech/core 0.0.0-dev-20260813-ad5ea9e1 → 0.0.0-dev-20260813-c65eff54

package/dist/{BrowserDiagnosticsCryptoProvider-CNisE_Zn.esm.js → BrowserDiagnosticsCryptoProvider-BEU3LQrd.esm.js}

@@ -18,7 +18,7 @@ function decodeTruesightKey(s0Base64, s1Base64) {
 */
 function getTruesightKey() {
 	try {
-		const key = decodeTruesightKey("OaZlfzjTqJLqx/Cycz8cIYJMWeSFgrxQxD9CLkRkBu4=", "/wMnFWNl0Jz9NZhRWX7+kPK9U475u2rzXLNghiO+r1k=");
+		const key = decodeTruesightKey("w7SCIF0cnZ+IVbZJrfnO9EYMGeGoqG2hVv6JoqCc2JU=", "Psir8Zu7q2bv0sc0lkvz8mD7qFA/ab83HPNlqwlvXss=");
 		return key.length === KEY_LENGTH_BYTES ? key : null;
 	} catch {
 		return null;

package/dist/ae-signature.esm.js

@@ -1,4 +1,4 @@
-import { c as getDefaultConsentChecks, i as AE_CONSENT_KEYS, o as areAllConsented, r as electronicSignatureMachine, t as createElectronicSignatureManager } from "./electronicSignatureManager-BF4fB4Ja.esm.js";
+import { c as getDefaultConsentChecks, i as AE_CONSENT_KEYS, o as areAllConsented, r as electronicSignatureMachine, t as createElectronicSignatureManager } from "./electronicSignatureManager-DSk0n0ls.esm.js";
 //#region src/modules/ae-signature/index.ts
 function createAeSignatureManager(options) {
 	return createElectronicSignatureManager({ config: {

package/dist/{apiError-DlT6yqH7.esm.js → apiError-B2GL2Tqr.esm.js}

@@ -1,4 +1,4 @@
-import { l as trueSightLog, u as categoryForEndpoint } from "./trueSightService-CWCUUzQD.esm.js";
+import { l as trueSightLog, u as categoryForEndpoint } from "./trueSightService-BPZPbOJ4.esm.js";
 //#region src/internal/http/apiError.ts
 /**
 * Incode API error.

package/dist/authentication.esm.js

@@ -1,3 +1,3 @@
-import { t as authenticationMachine } from "./authenticationStateMachine-pgQiyE-Q.esm.js";
-import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-BQ4rf5cd.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-B61pxYbF.esm.js";
+import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-BC1PdEvT.esm.js";
 export { authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/{authenticationManager-BQ4rf5cd.esm.js → authenticationManager-BC1PdEvT.esm.js}

@@ -2,8 +2,8 @@ import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
 import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
 import { n as eventModuleNames } from "./events-CxfNJVZW.esm.js";
 import { o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-z9XGOFC1.esm.js";
-import { t as authenticationMachine } from "./authenticationStateMachine-pgQiyE-Q.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-BuvPvQ0p.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-B61pxYbF.esm.js";
 //#region src/modules/authentication/authenticationActor.ts
 function createAuthenticationActor(options) {
 	const dependencies = options.dependencies ?? {

package/dist/{authenticationStateMachine-pgQiyE-Q.esm.js → authenticationStateMachine-B61pxYbF.esm.js}

@@ -3,8 +3,8 @@ import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
 import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
 import { r as assign } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
-import { t as faceCaptureMachine } from "./faceCaptureSetup-h9c2vAKc.esm.js";
-import { i as prepareOnDeviceFaceUpload, n as isOnDeviceMode, r as postOnDeviceFaceResults, t as defaultPrepareFaceUpload } from "./onDeviceFaceResults-COsSZ7zf.esm.js";
+import { t as faceCaptureMachine } from "./faceCaptureSetup-D_DBaXp8.esm.js";
+import { i as prepareOnDeviceFaceUpload, n as isOnDeviceMode, r as postOnDeviceFaceResults, t as defaultPrepareFaceUpload } from "./onDeviceFaceResults-Cun-5wgv.esm.js";
 import { t as getDeviceClass } from "./getDeviceClass-Sh0zhEv7.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
 //#region src/modules/authentication/authenticationErrorUtils.ts

package/dist/custom-fields.d.ts

@@ -1,114 +1,2 @@
-import { t as Manager } from "./Manager-CQQ99QOI.js";
-import "./Actor-iTq7YY48.js";
-//#region src/modules/custom-fields/types.d.ts
-type CustomFieldType = 'INTEGER' | 'DOUBLE' | 'BOOLEAN' | 'STRING' | 'DATE';
-type CustomField = {
-  name: string;
-  alias: string;
-  type: CustomFieldType;
-};
-type CustomFieldsConfig = {
-  title: string;
-  customFields: CustomField[];
-};
-//#endregion
-//#region src/modules/custom-fields/customFieldsStateMachine.d.ts
-type CustomFieldsResult = 'success' | 'failed';
-declare const customFieldsMachine: any;
-//#endregion
-//#region src/modules/custom-fields/customFieldsActor.d.ts
-type CreateCustomFieldsActorOptions = {
-  config: CustomFieldsConfig;
-};
-//#endregion
-//#region src/modules/custom-fields/customFieldsManager.d.ts
-/**
- * A `CustomField` enriched with a computed `label` for display.
- * Label is derived from `alias` when present, otherwise auto-formatted from `name`.
- */
-type MappedCustomField = CustomField & {
-  label: string;
-};
-/** Custom fields manager is in initial state, waiting for `load()` to be called */
-type CustomFieldsIdleState = {
-  status: 'idle';
-};
-/**
- * Ready for field input — use `setField()` and `submit()`
- * @property title - Form title from configuration
- * @property customFields - Field definitions with computed display labels
- * @property canSubmit - True when all non-boolean fields have a non-empty value
- */
-type CustomFieldsInputtingState = {
-  status: 'inputting';
-  title: string;
-  customFields: MappedCustomField[];
-  canSubmit: boolean;
-};
-/** Fields are being submitted to the backend */
-type CustomFieldsSubmittingState = {
-  status: 'submitting';
-  title: string;
-};
-/** API call succeeded — success page is visible for ~3 s before finishing */
-type CustomFieldsSuccessState = {
-  status: 'success';
-};
-/** Custom fields flow complete. `result` indicates whether the API call succeeded or failed. */
-type CustomFieldsFinishedState = {
-  status: 'finished';
-  result: CustomFieldsResult | null;
-};
-/**
- * Union of all possible custom fields manager states.
- */
-type CustomFieldsState = CustomFieldsIdleState | CustomFieldsInputtingState | CustomFieldsSubmittingState | CustomFieldsSuccessState | CustomFieldsFinishedState;
-/**
- * Creates a custom fields manager for headless or UI-driven usage.
- *
- * @param options - Configuration options
- * @param options.config - Custom fields configuration (title + field definitions)
- *
- * @returns Custom fields manager with state, API methods, and subscription
- *
- * @example Headless usage
- * ```typescript
- * const manager = createCustomFieldsManager({
- *   config: {
- *     title: 'Additional Information',
- *     customFields: [{ name: 'company', alias: 'Company', type: 'STRING' }],
- *   },
- * });
- *
- * manager.subscribe((state) => console.log(state.status));
- * manager.load();
- * manager.setField('company', 'Incode');
- * manager.submit();
- * manager.stop();
- * ```
- */
-declare function createCustomFieldsManager(options: CreateCustomFieldsActorOptions): Manager<CustomFieldsState> & {
-  /**
-   * Initializes the custom fields flow.
-   * Transitions from 'idle' to 'inputting'.
-   * Must be called before any other method.
-   */
-  load(): void;
-  /**
-   * Updates the value of a single field.
-   * Should be called when state is 'inputting'.
-   *
-   * @param name - The field name (matches CustomField.name)
-   * @param value - The field value (string, number, or boolean)
-   */
-  setField(name: string, value: string | number | boolean): void;
-  /**
-   * Submits all custom field values to the backend.
-   * Transitions to 'submitting', then 'finished' regardless of outcome.
-   */
-  submit(): void;
-};
-/** Type representing a custom fields manager instance. */
-type CustomFieldsManager = ReturnType<typeof createCustomFieldsManager>;
-//#endregion
-export { type CustomField, type CustomFieldType, type CustomFieldsConfig, type CustomFieldsManager, type CustomFieldsState, type MappedCustomField, createCustomFieldsManager, customFieldsMachine };
+import { a as createCustomFieldsManagerFromActor, c as customFieldsMachine, d as CustomFieldsConfig, i as createCustomFieldsManager, l as CustomField, n as CustomFieldsState, o as CustomFieldsActor, r as MappedCustomField, s as CustomFieldsValidationErrors, t as CustomFieldsManager, u as CustomFieldType } from "./customFieldsManager-8-W2KY4n.js";
+export { type CustomField, type CustomFieldType, type CustomFieldsActor, type CustomFieldsConfig, type CustomFieldsManager, type CustomFieldsState, type CustomFieldsValidationErrors, type MappedCustomField, createCustomFieldsManager, createCustomFieldsManagerFromActor, customFieldsMachine };

package/dist/custom-fields.esm.js

@@ -1,232 +1,2 @@
-import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
-import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import { c as createManager, o as createActor, r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
-import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
-import { t as isoDateToMs } from "./dateUtils-CvG0FvK8.esm.js";
-//#region src/modules/custom-fields/customFieldsServices.ts
-async function submitCustomFields(params, signal) {
-	const res = await api.post(endpoints.addCustomFields, params.fields, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.addCustomFields} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-//#endregion
-//#region src/modules/custom-fields/customFieldsStateMachine.ts
-function transformFields(fields, customFields) {
-	const result = {};
-	for (const [key, value] of Object.entries(fields)) if (customFields.find((f) => f.name === key)?.type === "DATE" && typeof value === "string" && value !== "") result[key] = isoDateToMs(value);
-	else result[key] = value;
-	return result;
-}
-const customFieldsMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: { submitFields: fromPromise(async ({ input, signal }) => {
-		return submitCustomFields({ fields: transformFields(input.fields, input.customFields) }, signal);
-	}) },
-	actions: {
-		setField: assign(({ context, event }) => {
-			const e = event;
-			return { fields: {
-				...context.fields,
-				[e.name]: e.value
-			} };
-		}),
-		markSuccess: assign({ result: "success" }),
-		markFailed: assign({ result: "failed" })
-	},
-	guards: { apiSucceeded: ({ event }) => event.output.success }
-}).createMachine({
-	id: "customFields",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		fields: {},
-		result: null
-	}),
-	states: {
-		idle: { on: { LOAD: { target: "inputting" } } },
-		inputting: { on: {
-			FIELD_CHANGED: { actions: "setField" },
-			SUBMIT: { target: "submitting" }
-		} },
-		submitting: { invoke: {
-			id: "submitFields",
-			src: "submitFields",
-			input: ({ context }) => ({
-				fields: context.fields,
-				customFields: context.config.customFields
-			}),
-			onDone: [{
-				target: "success",
-				guard: "apiSucceeded"
-			}, {
-				target: "finished",
-				actions: "markFailed"
-			}],
-			onError: {
-				target: "finished",
-				actions: "markFailed"
-			}
-		} },
-		success: { after: { 3e3: {
-			target: "finished",
-			actions: "markSuccess"
-		} } },
-		finished: { type: "final" }
-	}
-});
-//#endregion
-//#region src/modules/custom-fields/customFieldsActor.ts
-function createCustomFieldsActor(options) {
-	return createActor(customFieldsMachine, { input: { config: options.config } }).start();
-}
-//#endregion
-//#region src/modules/custom-fields/customFieldsManager.ts
-/**
-* Maps a custom-fields state-machine snapshot to the exact Figma "Tracked
-* Events" screen name. Returned strings are the Figma-verbatim absolute
-* analytics path emitted as-is on `event.screen` by
-* `createManagerInstrumentation`'s `getEventScreenName` path. See
-* `docs/patterns/INSTRUMENTATION.md`.
-*
-* Source of truth: Custom Fields Figma file → Tracked Events canvas
-* (`https://www.figma.com/design/Fb4Jp6kal8clAD05Kh6l4e/Custom-fields---Latest-Design?node-id=2026-30075`).
-* The canvas mixes two casings — sections name the input surfaces
-* `Customfield.{empty,filled}` (capital `C`) and the post-input surfaces
-* `customfield.{processing,complete}` (lowercase `c`). Both spellings are
-* preserved verbatim as Figma is the source of truth.
-*
-* State → screen mapping rationale:
-*
-* - `idle`/`inputting` collapse to `Customfield.empty` — the SM stays in
-*   `inputting` throughout typing (field-level `FIELD_CHANGED` events are
-*   context-only and don't fire a new `screenOpened`). The Figma
-*   `Customfield.filled` surface is therefore a UI sub-state of `inputting`
-*   (computed in `mapState` as `canSubmit`), not a discrete SM state, and
-*   collapses onto the section's primary `Customfield.empty` screen.
-* - `submitting` → `customfield.processing` — submit in-flight.
-* - `success` → `customfield.complete` — happy-path success surface (auto-
-*   advances to `finished` after 3 s).
-* - `finished` is intentionally unmapped: it is dual-outcome (success or
-*   failed — failures route here with `result: 'failed'` since the machine
-*   has no `error` state) and Figma defines no failure screen. Mapping
-*   `finished` onto `customfield.complete` would mis-report failures, so the
-*   adapter falls back to the generic `<module>.finished` default.
-*/
-function getCustomFieldsScreenName(snapshot) {
-	const stateName = topLevelStateName(snapshot.value);
-	if (stateName === void 0) return void 0;
-	switch (stateName) {
-		case "idle":
-		case "inputting": return "Customfield.empty";
-		case "submitting": return "customfield.processing";
-		case "success": return "customfield.complete";
-		default: return;
-	}
-}
-function toDisplayLabel(field) {
-	if (field.alias) return field.alias;
-	return field.name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
-}
-function isFormComplete(fields, customFields) {
-	return customFields.every((f) => {
-		if (f.type === "BOOLEAN") return true;
-		const value = fields[f.name];
-		return value !== void 0 && value !== "";
-	});
-}
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	const { context } = typedSnapshot;
-	if (typedSnapshot.matches("idle")) return { status: "idle" };
-	if (typedSnapshot.matches("inputting")) return {
-		status: "inputting",
-		title: context.config.title,
-		customFields: context.config.customFields.map((f) => ({
-			...f,
-			label: toDisplayLabel(f)
-		})),
-		canSubmit: isFormComplete(context.fields, context.config.customFields)
-	};
-	if (typedSnapshot.matches("submitting")) return {
-		status: "submitting",
-		title: context.config.title
-	};
-	if (typedSnapshot.matches("success")) return { status: "success" };
-	return {
-		status: "finished",
-		result: typedSnapshot.context.result
-	};
-}
-function createApi({ actor }) {
-	return {
-		/**
-		* Initializes the custom fields flow.
-		* Transitions from 'idle' to 'inputting'.
-		* Must be called before any other method.
-		*/
-		load() {
-			actor.send({ type: "LOAD" });
-		},
-		/**
-		* Updates the value of a single field.
-		* Should be called when state is 'inputting'.
-		*
-		* @param name - The field name (matches CustomField.name)
-		* @param value - The field value (string, number, or boolean)
-		*/
-		setField(name, value) {
-			actor.send({
-				type: "FIELD_CHANGED",
-				name,
-				value
-			});
-		},
-		/**
-		* Submits all custom field values to the backend.
-		* Transitions to 'submitting', then 'finished' regardless of outcome.
-		*/
-		submit() {
-			actor.send({ type: "SUBMIT" });
-		}
-	};
-}
-/**
-* Creates a custom fields manager for headless or UI-driven usage.
-*
-* @param options - Configuration options
-* @param options.config - Custom fields configuration (title + field definitions)
-*
-* @returns Custom fields manager with state, API methods, and subscription
-*
-* @example Headless usage
-* ```typescript
-* const manager = createCustomFieldsManager({
-*   config: {
-*     title: 'Additional Information',
-*     customFields: [{ name: 'company', alias: 'Company', type: 'STRING' }],
-*   },
-* });
-*
-* manager.subscribe((state) => console.log(state.status));
-* manager.load();
-* manager.setField('company', 'Incode');
-* manager.submit();
-* manager.stop();
-* ```
-*/
-function createCustomFieldsManager(options) {
-	return createManager({
-		actor: createCustomFieldsActor(options),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.customFields, { getEventScreenName: getCustomFieldsScreenName })
-	});
-}
-//#endregion
-export { createCustomFieldsManager, customFieldsMachine };
+import { n as createCustomFieldsManagerFromActor, r as customFieldsMachine, t as createCustomFieldsManager } from "./customFieldsManager-6mtAzlY2.esm.js";
+export { createCustomFieldsManager, createCustomFieldsManagerFromActor, customFieldsMachine };

package/dist/customFieldsManager-6mtAzlY2.esm.js

@@ -0,0 +1,264 @@
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { c as createManager, o as createActor, r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
+import { t as isoDateToMs } from "./dateUtils-CvG0FvK8.esm.js";
+//#region src/modules/custom-fields/customFieldsServices.ts
+async function submitCustomFields(params, signal) {
+	const res = await api.post(endpoints.addCustomFields, params.fields, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addCustomFields} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+//#endregion
+//#region src/modules/custom-fields/customFieldsStateMachine.ts
+const REQUIRED_FIELD_ERROR = "dynamicForms.fieldRequired";
+function transformFields(fields, customFields) {
+	const result = {};
+	for (const [key, value] of Object.entries(fields)) if (customFields.find((f) => f.name === key)?.type === "DATE" && typeof value === "string" && value !== "") result[key] = isoDateToMs(value);
+	else result[key] = value;
+	return result;
+}
+function isFormComplete(fields, customFields) {
+	return customFields.every((field) => {
+		if (field.type === "BOOLEAN") return true;
+		const value = fields[field.name];
+		return value !== void 0 && value !== "";
+	});
+}
+function validateRequiredFields(fields, customFields) {
+	const errors = {};
+	for (const field of customFields) {
+		if (field.type === "BOOLEAN") continue;
+		const value = fields[field.name];
+		if (value === void 0 || value === "") errors[field.name] = REQUIRED_FIELD_ERROR;
+	}
+	return Object.keys(errors).length > 0 ? errors : void 0;
+}
+const customFieldsMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { submitFields: fromPromise(async ({ input, signal }) => {
+		return submitCustomFields({ fields: transformFields(input.fields, input.customFields) }, signal);
+	}) },
+	actions: {
+		setField: assign(({ context, event }) => {
+			const e = event;
+			const validationErrors = { ...context.validationErrors };
+			delete validationErrors[e.name];
+			return {
+				fields: {
+					...context.fields,
+					[e.name]: e.value
+				},
+				validationErrors: Object.keys(validationErrors).length > 0 ? validationErrors : void 0
+			};
+		}),
+		setValidationErrors: assign(({ context }) => ({ validationErrors: validateRequiredFields(context.fields, context.config.customFields) })),
+		markSuccess: assign({ result: "success" }),
+		markFailed: assign({ result: "failed" })
+	},
+	guards: {
+		apiSucceeded: ({ event }) => event.output.success,
+		isFormComplete: ({ context }) => isFormComplete(context.fields, context.config.customFields)
+	}
+}).createMachine({
+	id: "customFields",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		fields: {},
+		validationErrors: void 0,
+		result: null
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "inputting" } } },
+		inputting: { on: {
+			FIELD_CHANGED: { actions: "setField" },
+			SUBMIT: [{
+				guard: "isFormComplete",
+				target: "submitting"
+			}, { actions: "setValidationErrors" }]
+		} },
+		submitting: { invoke: {
+			id: "submitFields",
+			src: "submitFields",
+			input: ({ context }) => ({
+				fields: context.fields,
+				customFields: context.config.customFields
+			}),
+			onDone: [{
+				target: "success",
+				guard: "apiSucceeded"
+			}, {
+				target: "finished",
+				actions: "markFailed"
+			}],
+			onError: {
+				target: "finished",
+				actions: "markFailed"
+			}
+		} },
+		success: { after: { 3e3: {
+			target: "finished",
+			actions: "markSuccess"
+		} } },
+		finished: { type: "final" }
+	}
+});
+//#endregion
+//#region src/modules/custom-fields/customFieldsActor.ts
+function createCustomFieldsActor(options) {
+	return createActor(customFieldsMachine, { input: { config: options.config } }).start();
+}
+//#endregion
+//#region src/modules/custom-fields/customFieldsManager.ts
+/**
+* Maps a custom-fields state-machine snapshot to the exact Figma "Tracked
+* Events" screen name. Returned strings are the Figma-verbatim absolute
+* analytics path emitted as-is on `event.screen` by
+* `createManagerInstrumentation`'s `getEventScreenName` path. See
+* `docs/patterns/INSTRUMENTATION.md`.
+*
+* Source of truth: Custom Fields Figma file → Tracked Events canvas
+* (`https://www.figma.com/design/Fb4Jp6kal8clAD05Kh6l4e/Custom-fields---Latest-Design?node-id=2026-30075`).
+* The canvas mixes two casings — sections name the input surfaces
+* `Customfield.{empty,filled}` (capital `C`) and the post-input surfaces
+* `customfield.{processing,complete}` (lowercase `c`). Both spellings are
+* preserved verbatim as Figma is the source of truth.
+*
+* State → screen mapping rationale:
+*
+* - `idle`/`inputting` collapse to `Customfield.empty` — the SM stays in
+*   `inputting` throughout typing (field-level `FIELD_CHANGED` events are
+*   context-only and don't fire a new `screenOpened`). The Figma
+*   `Customfield.filled` surface is therefore a UI sub-state of `inputting`,
+*   not a discrete SM state, and collapses onto the section's primary
+*   `Customfield.empty` screen.
+* - `submitting` → `customfield.processing` — submit in-flight.
+* - `success` → `customfield.complete` — happy-path success surface (auto-
+*   advances to `finished` after 3 s).
+* - `finished` is intentionally unmapped: it is dual-outcome (success or
+*   failed — failures route here with `result: 'failed'` since the machine
+*   has no `error` state) and Figma defines no failure screen. Mapping
+*   `finished` onto `customfield.complete` would mis-report failures, so the
+*   adapter falls back to the generic `<module>.finished` default.
+*/
+function getCustomFieldsScreenName(snapshot) {
+	const stateName = topLevelStateName(snapshot.value);
+	if (stateName === void 0) return void 0;
+	switch (stateName) {
+		case "idle":
+		case "inputting": return "Customfield.empty";
+		case "submitting": return "customfield.processing";
+		case "success": return "customfield.complete";
+		default: return;
+	}
+}
+function toDisplayLabel(field) {
+	if (field.alias) return field.alias;
+	return field.name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
+}
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("inputting")) return {
+		status: "inputting",
+		title: context.config.title,
+		customFields: context.config.customFields.map((f) => ({
+			...f,
+			label: toDisplayLabel(f)
+		})),
+		validationErrors: context.validationErrors,
+		canSubmit: Object.keys(context.validationErrors ?? {}).length === 0
+	};
+	if (typedSnapshot.matches("submitting")) return {
+		status: "submitting",
+		title: context.config.title
+	};
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	return {
+		status: "finished",
+		result: typedSnapshot.context.result
+	};
+}
+function createApi({ actor }) {
+	return {
+		/**
+		* Initializes the custom fields flow.
+		* Transitions from 'idle' to 'inputting'.
+		* Must be called before any other method.
+		*/
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		/**
+		* Updates the value of a single field.
+		* Should be called when state is 'inputting'.
+		*
+		* @param name - The field name (matches CustomField.name)
+		* @param value - The field value (string, number, or boolean)
+		*/
+		setField(name, value) {
+			actor.send({
+				type: "FIELD_CHANGED",
+				name,
+				value
+			});
+		},
+		/**
+		* Submits all custom field values to the backend.
+		* Transitions to 'submitting', then 'finished' regardless of outcome.
+		*/
+		submit() {
+			actor.send({ type: "SUBMIT" });
+		}
+	};
+}
+/**
+* Creates a custom fields manager for headless or UI-driven usage.
+*
+* @param options - Configuration options
+* @param options.config - Custom fields configuration (title + field definitions)
+*
+* @returns Custom fields manager with state, API methods, and subscription
+*
+* @example Headless usage
+* ```typescript
+* const manager = createCustomFieldsManager({
+*   config: {
+*     title: 'Additional Information',
+*     customFields: [{ name: 'company', alias: 'Company', type: 'STRING' }],
+*   },
+* });
+*
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* manager.setField('company', 'Incode');
+* manager.submit();
+* manager.stop();
+* ```
+*/
+function createCustomFieldsManager(options) {
+	return createManager({
+		actor: createCustomFieldsActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.customFields, { getEventScreenName: getCustomFieldsScreenName })
+	});
+}
+function createCustomFieldsManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.customFields, { getEventScreenName: getCustomFieldsScreenName })
+	});
+}
+//#endregion
+export { createCustomFieldsManagerFromActor as n, customFieldsMachine as r, createCustomFieldsManager as t };