@incodetech/core 2.2.0 → 2.3.0-rc.0

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-DYiyoSlx.esm.js";
-import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.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-2j_PBq4U.esm.js";
+export { createCustomFieldsManager, createCustomFieldsManagerFromActor, customFieldsMachine };

package/dist/custom-watchlist.d.ts

@@ -1,53 +1,4 @@
-import { t as Manager } from "./Manager-CQQ99QOI.js";
-//#region src/modules/custom-watchlist/customWatchlistStateMachine.d.ts
-type CustomWatchlistResult = 'success' | 'skipped';
-declare const customWatchlistMachine: any;
-//#endregion
-//#region src/modules/custom-watchlist/customWatchlistManager.d.ts
-type CustomWatchlistIdleState = {
-  status: 'idle';
-};
-type CustomWatchlistProcessingState = {
-  status: 'processing';
-};
-type CustomWatchlistSuccessState = {
-  status: 'success';
-};
-type CustomWatchlistFinishedState = {
-  status: 'finished';
-  result: CustomWatchlistResult;
-};
-/**
- * Union of all possible custom watchlist manager states.
- *
- * @example
- * ```typescript
- * const state = customWatchlistManager.getState();
- * if (state.status === 'finished') {
- *   console.log('Custom watchlist check complete');
- * }
- * ```
- */
-type CustomWatchlistState = CustomWatchlistIdleState | CustomWatchlistProcessingState | CustomWatchlistSuccessState | CustomWatchlistFinishedState;
-/**
- * Creates a custom watchlist manager for headless or UI-driven usage.
- *
- * @example Headless usage
- * ```typescript
- * const manager = createCustomWatchlistManager();
- * manager.subscribe((state) => console.log(state.status));
- * manager.load();
- * ```
- */
-declare function createCustomWatchlistManager(): Manager<CustomWatchlistState> & {
-  /**
-   * Kicks off the custom watchlist check.
-   * Transitions from 'idle' to 'processing'.
-   */
-  load(): void;
-};
-type CustomWatchlistManager = ReturnType<typeof createCustomWatchlistManager>;
-//#endregion
+import { a as CustomWatchlistActor, i as createCustomWatchlistManagerFromActor, n as CustomWatchlistState, o as customWatchlistMachine, r as createCustomWatchlistManager, t as CustomWatchlistManager } from "./customWatchlistManager-PBWHr_oM.js";
 //#region src/modules/custom-watchlist/types.d.ts
 /**
  * Configuration for the custom watchlist module (INCODE_WATCHLIST flow key).
@@ -62,4 +13,4 @@ type CustomWatchlistConfig = {
   autoExecution: boolean;
 };
 //#endregion
-export { type CustomWatchlistConfig, type CustomWatchlistManager, type CustomWatchlistState, createCustomWatchlistManager, customWatchlistMachine };
+export { type CustomWatchlistActor, type CustomWatchlistConfig, type CustomWatchlistManager, type CustomWatchlistState, createCustomWatchlistManager, createCustomWatchlistManagerFromActor, customWatchlistMachine };

package/dist/custom-watchlist.esm.js

@@ -1,70 +1,3 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
-import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
-import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as customWatchlistMachine } from "./customWatchlistStateMachine-YWSgKLbF.esm.js";
-//#region src/modules/custom-watchlist/customWatchlistActor.ts
-function createCustomWatchlistActor() {
-	return createActor(customWatchlistMachine).start();
-}
-//#endregion
-//#region src/modules/custom-watchlist/customWatchlistManager.ts
-/**
-* Maps a Custom Watchlist state-machine snapshot to the exact Figma
-* "Tracked Events" screen name. Source: Watchlist | Custom Watchlist
-* Figma file (`https://www.figma.com/design/Xm4BgXotNwdi5iRdHTIX0N/Watchlist-%7C-Custom-Watchlist----Latest-Design?node-id=3031-82920`).
-* Family is `watchlist.*`, shared with the global watchlist manager — both
-* keep their own module token (`watchlist` vs `customWatchlist`) per the
-* AdSign/QSign precedent.
-*
-* `idle` and `finished` are intentionally unmapped — the Figma canvas does
-* not define screens for them; `finished` collapses into `moduleClosed`.
-*/
-function getCustomWatchlistScreenName(snapshot) {
-	const stateName = topLevelStateName(snapshot.value);
-	if (stateName === void 0) return void 0;
-	switch (stateName) {
-		case "processing": return "watchlist.processing";
-		case "success": return "watchlist.success";
-		default: return;
-	}
-}
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	if (typedSnapshot.matches("processing")) return { status: "processing" };
-	if (typedSnapshot.matches("success")) return { status: "success" };
-	if (typedSnapshot.matches("finished")) return {
-		status: "finished",
-		result: typedSnapshot.context.result ?? "skipped"
-	};
-	return { status: "idle" };
-}
-function createApi({ actor }) {
-	return { 
-	/**
-	* Kicks off the custom watchlist check.
-	* Transitions from 'idle' to 'processing'.
-	*/
-load() {
-		actor.send({ type: "LOAD" });
-	} };
-}
-/**
-* Creates a custom watchlist manager for headless or UI-driven usage.
-*
-* @example Headless usage
-* ```typescript
-* const manager = createCustomWatchlistManager();
-* manager.subscribe((state) => console.log(state.status));
-* manager.load();
-* ```
-*/
-function createCustomWatchlistManager() {
-	return createManager({
-		actor: createCustomWatchlistActor(),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.customWatchList, { getEventScreenName: getCustomWatchlistScreenName })
-	});
-}
-//#endregion
-export { createCustomWatchlistManager, customWatchlistMachine };
+import { t as customWatchlistMachine } from "./customWatchlistStateMachine-qZVgkKgP.esm.js";
+import { n as createCustomWatchlistManagerFromActor, t as createCustomWatchlistManager } from "./customWatchlistManager-DUVrEdw9.esm.js";
+export { createCustomWatchlistManager, createCustomWatchlistManagerFromActor, customWatchlistMachine };

package/dist/customFieldsManager-2j_PBq4U.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-ijlbX_Wx.esm.js";
+import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
+import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
+import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.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 };