@incodetech/core 0.0.0-dev-20260409-a38d5e8 → 0.0.0-dev-20260409-09dfd52

package/dist/flow.esm.js

@@ -1,11 +1,12 @@
-import "./api-DzpnV6O7.esm.js";
-import { o as createManagerInstrumentation } from "./events-DlHrOIRc.esm.js";
-import "./session-CUh77zj3.esm.js";
-import "./BrowserEnvironmentProvider-DaHeLJQw.esm.js";
-import "./browserSimulation-B4ubb2OL.esm.js";
-import { a as createActor, i as fromPromise, n as assign, o as createManager, r as fromCallback, t as setup } from "./xstate.esm-Bv55-lJ4.esm.js";
-import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-p22wrYPf.esm.js";
-import { t as getFinishStatus } from "./flowCompletionService-B5JemmC6.esm.js";
+import "./api-aa9Mx20l.esm.js";
+import { o as createManagerInstrumentation } from "./events-W91zLpx4.esm.js";
+import "./session-B_rKSRql.esm.js";
+import "./BrowserEnvironmentProvider-BtKLxTx4.esm.js";
+import "./browserSimulation-DFqGKQAD.esm.js";
+import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-B7FPE6br.esm.js";
+import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-YATk0fgY.esm.js";
+import { t as getFinishStatus } from "./flowCompletionService-DZSDUXus.esm.js";
+import { t as runChildModule } from "./runChildModule-DVC4JEjp.esm.js";
 
 //#region src/modules/flow/flowStateMachine.ts
 const flowMachine = setup({
@@ -299,27 +300,7 @@ const orchestratedFlowMachine = setup({
 		notifyBackend: fromPromise(async ({ input, signal }) => {
 			return await input.getFinishStatus(input.flowId, signal);
 		}),
-		runChildModule: fromCallback(({ sendBack, input }) => {
-			const { machine, config } = input;
-			if (!machine) return () => {};
-			const actor = createActor(machine, { input: { config } });
-			const subscription = actor.subscribe({
-				complete: () => {
-					sendBack({ type: "MODULE_COMPLETE" });
-				},
-				error: (err) => {
-					sendBack({
-						type: "MODULE_ERROR",
-						error: err
-					});
-				}
-			});
-			actor.start();
-			return () => {
-				subscription.unsubscribe();
-				actor.stop();
-			};
-		}),
+		runChildModule,
 		resolveCurrentModuleMachine: fromPromise(async ({ input }) => {
 			if (!input.moduleKey) return;
 			const eagerMachine = input.modules[input.moduleKey];

package/dist/{flowCompletionService-B5JemmC6.esm.js → flowCompletionService-DZSDUXus.esm.js}

@@ -1,5 +1,5 @@
-import { t as api } from "./api-DzpnV6O7.esm.js";
-import { _ as endpoints } from "./events-DlHrOIRc.esm.js";
+import { t as api } from "./api-aa9Mx20l.esm.js";
+import { _ as endpoints } from "./events-W91zLpx4.esm.js";
 
 //#region src/modules/flow/flowCompletionService.ts
 const getFinishStatus = async (flowId, signal) => {

package/dist/{flowServices-p22wrYPf.esm.js → flowServices-YATk0fgY.esm.js}

@@ -1,6 +1,6 @@
-import { t as api } from "./api-DzpnV6O7.esm.js";
-import { _ as endpoints } from "./events-DlHrOIRc.esm.js";
-import { n as getSessionFingerprintResult, r as initializeSession } from "./session-CUh77zj3.esm.js";
+import { t as api } from "./api-aa9Mx20l.esm.js";
+import { _ as endpoints } from "./events-W91zLpx4.esm.js";
+import { n as getSessionFingerprintResult, r as initializeSession } from "./session-B_rKSRql.esm.js";
 
 //#region src/modules/flow/flowUtils.ts
 const WASM_MODULE_PIPELINES = {

package/dist/geolocation.d.ts

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-BN2g_I8W.js";
-import "./Actor-Ba71-_30.js";
+import { t as Manager } from "./Manager-DcPMRgTm.js";
+import "./Actor-DbWH1K6E.js";
 
 //#region ../infra/src/capabilities/IGeolocationCapability.d.ts
 type GeolocationCoords = {
@@ -17,7 +17,7 @@ type IGeolocationCapability = {
  * @example
  * ```typescript
  * const config: GeolocationConfig = {
- *   allowSkip: true,
+ *   allowUserToSkipGeolocation: true,
  * };
  * ```
  */
@@ -25,9 +25,10 @@ type GeolocationConfig = {
   /**
    * Whether the user is allowed to skip geolocation capture.
    * When true, a skip button is shown on the permission-denied screen.
+   * Backend field name from flow/workflow configuration.
    * @default false
    */
-  allowSkip?: boolean;
+  allowUserToSkipGeolocation?: boolean;
 };
 //#endregion
 //#region src/modules/geolocation/geolocationStateMachine.d.ts
@@ -95,7 +96,7 @@ type GeolocationState = GeolocationIdleState | GeolocationRequestingState | Geol
  *
  * @example Headless usage
  * ```typescript
- * const manager = createGeolocationManager({ config: { allowSkip: true } });
+ * const manager = createGeolocationManager({ config: { allowUserToSkipGeolocation: true } });
  * manager.subscribe((state) => console.log(state.status));
  * manager.request();
  * ```
@@ -113,7 +114,7 @@ declare function createGeolocationManager(options: CreateGeolocationActorOptions
   continue(): void;
   /**
    * Skips geolocation when the user has denied permission.
-   * Only works when `config.allowSkip` is true.
+   * Only works when `config.allowUserToSkipGeolocation` is true.
    */
   skip(): void;
   /**

package/dist/geolocation.esm.js

@@ -1,7 +1,8 @@
-import { t as api } from "./api-DzpnV6O7.esm.js";
-import { _ as endpoints, n as eventModuleNames, o as createManagerInstrumentation } from "./events-DlHrOIRc.esm.js";
-import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-Bv55-lJ4.esm.js";
-import { r as isIOS, t as isAndroid } from "./platform-Dv7a2fv-.esm.js";
+import "./api-aa9Mx20l.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-W91zLpx4.esm.js";
+import { a as createActor, o as createManager } from "./xstate.esm-B7FPE6br.esm.js";
+import "./platform-DctkySJU.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-CRRUCl9K.esm.js";
 
 //#region ../infra/src/providers/browser/BrowserGeolocationProvider.ts
 var BrowserGeolocationProvider = class {
@@ -15,105 +16,6 @@ var BrowserGeolocationProvider = class {
 	}
 };
 
-//#endregion
-//#region src/modules/geolocation/geolocationServices.ts
-async function addGeolocation(params, signal) {
-	const res = await api.post(endpoints.addGeolocation, {
-		latitude: params.latitude,
-		longitude: params.longitude
-	}, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.addGeolocation} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-
-//#endregion
-//#region src/modules/geolocation/geolocationStateMachine.ts
-function detectDeviceType() {
-	if (isIOS()) return "ios";
-	if (isAndroid()) return "android";
-	return "desktop";
-}
-const geolocationMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: {
-		requestPosition: fromPromise(async ({ input }) => {
-			return input.geolocation.getCurrentPosition();
-		}),
-		submitPosition: fromPromise(async ({ input, signal }) => {
-			try {
-				return await addGeolocation(input, signal);
-			} catch {
-				return { location: "Unknown" };
-			}
-		})
-	},
-	actions: {
-		setCoords: assign(({ event }) => ({ coords: event.output })),
-		setLocation: assign(({ event }) => ({ location: event.output.location })),
-		setDeviceType: assign({ deviceType: () => detectDeviceType() }),
-		resetContext: assign(({ context }) => ({
-			config: context.config,
-			geolocation: context.geolocation,
-			coords: void 0,
-			location: void 0,
-			deviceType: detectDeviceType()
-		}))
-	},
-	guards: { canSkip: ({ context }) => context.config.allowSkip === true }
-}).createMachine({
-	id: "geolocation",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		geolocation: input.geolocation,
-		coords: void 0,
-		location: void 0,
-		deviceType: detectDeviceType()
-	}),
-	states: {
-		idle: { on: { REQUEST: { target: "requestingLocation" } } },
-		requestingLocation: { invoke: {
-			id: "requestPosition",
-			src: "requestPosition",
-			input: ({ context }) => ({ geolocation: context.geolocation }),
-			onDone: {
-				target: "submitting",
-				actions: "setCoords"
-			},
-			onError: {
-				target: "permissionDenied",
-				actions: "setDeviceType"
-			}
-		} },
-		submitting: { invoke: {
-			id: "submitPosition",
-			src: "submitPosition",
-			input: ({ context }) => ({
-				latitude: context.coords?.latitude ?? 0,
-				longitude: context.coords?.longitude ?? 0
-			}),
-			onDone: {
-				target: "locationAcquired",
-				actions: "setLocation"
-			},
-			onError: {
-				target: "locationAcquired",
-				actions: assign({ location: () => "Unknown" })
-			}
-		} },
-		locationAcquired: { on: { CONTINUE: { target: "finished" } } },
-		permissionDenied: { on: { SKIP: {
-			target: "finished",
-			guard: "canSkip"
-		} } },
-		finished: { type: "final" }
-	}
-});
-
 //#endregion
 //#region src/modules/geolocation/geolocationActor.ts
 function createGeolocationActor(options) {
@@ -139,7 +41,7 @@ function mapState(snapshot) {
 	if (typedSnapshot.matches("permissionDenied")) return {
 		status: "permissionDenied",
 		deviceType: context.deviceType,
-		canSkip: context.config.allowSkip === true
+		canSkip: context.config.allowUserToSkipGeolocation === true
 	};
 	if (typedSnapshot.matches("finished")) return { status: "finished" };
 	return { status: "idle" };
@@ -168,7 +70,7 @@ function createApi({ actor, trackElementClicked }) {
 *
 * @example Headless usage
 * ```typescript
-* const manager = createGeolocationManager({ config: { allowSkip: true } });
+* const manager = createGeolocationManager({ config: { allowUserToSkipGeolocation: true } });
 * manager.subscribe((state) => console.log(state.status));
 * manager.request();
 * ```

package/dist/geolocationStateMachine-CRRUCl9K.esm.js

@@ -0,0 +1,105 @@
+import { t as api } from "./api-aa9Mx20l.esm.js";
+import { _ as endpoints } from "./events-W91zLpx4.esm.js";
+import { i as fromPromise, n as assign, t as setup } from "./xstate.esm-B7FPE6br.esm.js";
+import { r as isIOS, t as isAndroid } from "./platform-DctkySJU.esm.js";
+
+//#region src/modules/geolocation/geolocationServices.ts
+async function addGeolocation(params, signal) {
+	const res = await api.post(endpoints.addGeolocation, {
+		latitude: params.latitude,
+		longitude: params.longitude
+	}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addGeolocation} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/geolocation/geolocationStateMachine.ts
+function detectDeviceType() {
+	if (isIOS()) return "ios";
+	if (isAndroid()) return "android";
+	return "desktop";
+}
+const geolocationMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		requestPosition: fromPromise(async ({ input }) => {
+			return input.geolocation.getCurrentPosition();
+		}),
+		submitPosition: fromPromise(async ({ input, signal }) => {
+			try {
+				return await addGeolocation(input, signal);
+			} catch {
+				return { location: "Unknown" };
+			}
+		})
+	},
+	actions: {
+		setCoords: assign(({ event }) => ({ coords: event.output })),
+		setLocation: assign(({ event }) => ({ location: event.output.location })),
+		setDeviceType: assign({ deviceType: () => detectDeviceType() }),
+		resetContext: assign(({ context }) => ({
+			config: context.config,
+			geolocation: context.geolocation,
+			coords: void 0,
+			location: void 0,
+			deviceType: detectDeviceType()
+		}))
+	},
+	guards: { canSkip: ({ context }) => context.config.allowUserToSkipGeolocation === true }
+}).createMachine({
+	id: "geolocation",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		geolocation: input.geolocation,
+		coords: void 0,
+		location: void 0,
+		deviceType: detectDeviceType()
+	}),
+	states: {
+		idle: { on: { REQUEST: { target: "requestingLocation" } } },
+		requestingLocation: { invoke: {
+			id: "requestPosition",
+			src: "requestPosition",
+			input: ({ context }) => ({ geolocation: context.geolocation }),
+			onDone: {
+				target: "submitting",
+				actions: "setCoords"
+			},
+			onError: {
+				target: "permissionDenied",
+				actions: "setDeviceType"
+			}
+		} },
+		submitting: { invoke: {
+			id: "submitPosition",
+			src: "submitPosition",
+			input: ({ context }) => ({
+				latitude: context.coords?.latitude ?? 0,
+				longitude: context.coords?.longitude ?? 0
+			}),
+			onDone: {
+				target: "locationAcquired",
+				actions: "setLocation"
+			},
+			onError: {
+				target: "locationAcquired",
+				actions: assign({ location: () => "Unknown" })
+			}
+		} },
+		locationAcquired: { on: { CONTINUE: { target: "finished" } } },
+		permissionDenied: { on: { SKIP: {
+			target: "finished",
+			guard: "canSkip"
+		} } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+export { geolocationMachine as t };

package/dist/{getDeviceClass-DEzz4cmY.esm.js → getDeviceClass-DBF-ExLR.esm.js}

@@ -1,4 +1,4 @@
-import { n as getDeviceInfo } from "./getBrowser-Dtyt9J_h.esm.js";
+import { n as getDeviceInfo } from "./getBrowser-DCcD7H-M.esm.js";
 
 //#region src/internal/device/getDeviceClass.ts
 function getDeviceClass() {

package/dist/government-validation.d.ts

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-BN2g_I8W.js";
-import "./Actor-Ba71-_30.js";
+import { t as Manager } from "./Manager-DcPMRgTm.js";
+import "./Actor-DbWH1K6E.js";
 
 //#region src/modules/government-validation/types.d.ts
 type GovernmentValidationConfig = {

package/dist/government-validation.esm.js

@@ -1,273 +1,9 @@
-import { t as api } from "./api-DzpnV6O7.esm.js";
-import { _ as endpoints, o as createManagerInstrumentation } from "./events-DlHrOIRc.esm.js";
-import { a as createActor, i as fromPromise, n as assign, o as createManager, r as fromCallback, t as setup } from "./xstate.esm-Bv55-lJ4.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BhD2MlHg.esm.js";
+import "./api-aa9Mx20l.esm.js";
+import { o as createManagerInstrumentation } from "./events-W91zLpx4.esm.js";
+import { a as createActor, o as createManager } from "./xstate.esm-B7FPE6br.esm.js";
+import "./BrowserTimerProvider-v7bpbrAk.esm.js";
+import { t as governmentValidationMachine } from "./governmentValidationStateMachine-C_iPX9VE.esm.js";
 
-//#region src/modules/government-validation/governmentValidationServices.ts
-async function processGovernmentValidation(signal) {
-	const res = await api.post(endpoints.governmentValidation, {}, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.governmentValidation} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-async function submitGovernmentValidationOtp(params, signal) {
-	const res = await api.post(endpoints.governmentValidation, { otpCode: params.code }, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.governmentValidation} (OTP) failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-
-//#endregion
-//#region src/modules/government-validation/governmentValidationStateMachine.ts
-const RESEND_TIMER_SECONDS = 30;
-const POLL_INTERVAL_MS = 2e3;
-const MAX_POLL_COUNT = 60;
-const AUTO_PROCEED_DELAY_MS = 3e3;
-const governmentValidationMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	delays: { AUTO_PROCEED: AUTO_PROCEED_DELAY_MS },
-	actors: {
-		processValidation: fromPromise(async ({ signal }) => {
-			return processGovernmentValidation(signal);
-		}),
-		submitOtp: fromPromise(async ({ input, signal }) => {
-			return submitGovernmentValidationOtp({ code: input.code }, signal);
-		}),
-		pollingTimer: fromCallback(({ sendBack }) => {
-			const timer = BrowserTimerProvider.getInstance();
-			const interval = timer.setInterval(() => {
-				sendBack({ type: "POLL" });
-			}, POLL_INTERVAL_MS);
-			return () => timer.clearInterval(interval);
-		}),
-		resendTimer: fromCallback(({ sendBack }) => {
-			const timer = BrowserTimerProvider.getInstance();
-			let seconds = RESEND_TIMER_SECONDS;
-			const interval = timer.setInterval(() => {
-				seconds -= 1;
-				sendBack({ type: "TICK" });
-				if (seconds <= 0) timer.clearInterval(interval);
-			}, 1e3);
-			return () => timer.clearInterval(interval);
-		})
-	},
-	actions: {
-		setError: assign(({ event }) => ({ error: String(event.error) })),
-		setErrorFromResponse: assign({ error: () => "Government validation failed" }),
-		setUnknownError: assign({ error: () => "Unknown validation status" }),
-		clearError: assign({ error: () => void 0 }),
-		setOtpCode: assign(({ event }) => ({
-			otpCode: event.code,
-			otpError: void 0
-		})),
-		setOtpError: assign(({ context }) => ({
-			otpError: "Invalid OTP code",
-			attemptsRemaining: context.attemptsRemaining - 1
-		})),
-		clearOtpError: assign({
-			otpError: () => void 0,
-			otpCode: () => ""
-		}),
-		startResendTimer: assign({
-			resendTimer: () => RESEND_TIMER_SECONDS,
-			resendTimerActive: () => true
-		}),
-		tickResendTimer: assign(({ context }) => {
-			const newTimer = Math.max(0, context.resendTimer - 1);
-			return {
-				resendTimer: newTimer,
-				resendTimerActive: newTimer > 0
-			};
-		}),
-		incrementPollCount: assign(({ context }) => ({ pollCount: context.pollCount + 1 })),
-		resetPollCount: assign({ pollCount: () => 0 }),
-		resetContext: assign(({ context }) => ({
-			config: context.config,
-			error: void 0,
-			otpCode: "",
-			otpError: void 0,
-			attemptsRemaining: context.config.maxOtpAttempts ?? 3,
-			resendTimer: 0,
-			resendTimerActive: false,
-			pollCount: 0
-		}))
-	},
-	guards: {
-		isProcessing: (_, params) => params.response.statusCode === -1,
-		isSuccess: (_, params) => params.response.statusCode === 0 && params.response.validationStatus?.status !== "UNKNOWN",
-		isError: (_, params) => params.response.statusCode > 0,
-		isOtpRequested: (_, params) => params.response.otpResponse?.authBridge?.otpCodeRequested === true,
-		isUnknown: (_, params) => params.response.validationStatus?.status === "UNKNOWN",
-		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
-		canResend: ({ context }) => !context.resendTimerActive,
-		hasReachedMaxPolls: ({ context }) => context.pollCount >= MAX_POLL_COUNT
-	}
-}).createMachine({
-	id: "governmentValidation",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		error: void 0,
-		otpCode: "",
-		otpError: void 0,
-		attemptsRemaining: input.config.maxOtpAttempts ?? 3,
-		resendTimer: 0,
-		resendTimerActive: false,
-		pollCount: 0
-	}),
-	states: {
-		idle: { on: { LOAD: { target: "loading" } } },
-		loading: { invoke: {
-			id: "processValidation",
-			src: "processValidation",
-			onDone: [
-				{
-					target: "awaitingOtp",
-					guard: {
-						type: "isOtpRequested",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "displaySuccess",
-					guard: {
-						type: "isSuccess",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "polling",
-					guard: {
-						type: "isProcessing",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "displayUnknown",
-					guard: {
-						type: "isUnknown",
-						params: ({ event }) => ({ response: event.output })
-					},
-					actions: "setUnknownError"
-				},
-				{
-					target: "displayError",
-					actions: "setErrorFromResponse"
-				}
-			],
-			onError: {
-				target: "displayError",
-				actions: "setError"
-			}
-		} },
-		polling: {
-			invoke: {
-				id: "pollingTimer",
-				src: "pollingTimer"
-			},
-			on: { POLL: [{
-				target: "displayError",
-				guard: "hasReachedMaxPolls",
-				actions: assign({ error: () => "Validation timed out" })
-			}, {
-				target: "pollingRequest",
-				actions: "incrementPollCount"
-			}] }
-		},
-		pollingRequest: { invoke: {
-			id: "pollValidation",
-			src: "processValidation",
-			onDone: [
-				{
-					target: "displaySuccess",
-					guard: {
-						type: "isSuccess",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "polling",
-					guard: {
-						type: "isProcessing",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "displayUnknown",
-					guard: {
-						type: "isUnknown",
-						params: ({ event }) => ({ response: event.output })
-					},
-					actions: "setUnknownError"
-				},
-				{
-					target: "displayError",
-					actions: "setErrorFromResponse"
-				}
-			],
-			onError: {
-				target: "displayError",
-				actions: "setError"
-			}
-		} },
-		awaitingOtp: {
-			entry: "startResendTimer",
-			invoke: {
-				id: "resendTimer",
-				src: "resendTimer"
-			},
-			on: {
-				TICK: { actions: "tickResendTimer" },
-				OTP_CHANGED: { actions: "setOtpCode" },
-				SUBMIT_OTP: { target: "verifyingOtp" },
-				RESEND_OTP: {
-					target: "loading",
-					guard: "canResend"
-				}
-			}
-		},
-		verifyingOtp: { invoke: {
-			id: "submitOtp",
-			src: "submitOtp",
-			input: ({ context }) => ({ code: context.otpCode }),
-			onDone: [
-				{
-					target: "displaySuccess",
-					guard: {
-						type: "isSuccess",
-						params: ({ event }) => ({ response: event.output })
-					}
-				},
-				{
-					target: "awaitingOtp",
-					guard: "hasAttemptsRemaining",
-					actions: "setOtpError"
-				},
-				{
-					target: "displayError",
-					actions: assign({ error: () => "Maximum OTP attempts exceeded" })
-				}
-			],
-			onError: [{
-				target: "awaitingOtp",
-				guard: "hasAttemptsRemaining",
-				actions: "setOtpError"
-			}, {
-				target: "displayError",
-				actions: "setError"
-			}]
-		} },
-		displaySuccess: { after: { AUTO_PROCEED: { target: "finished" } } },
-		displayProcessing: { after: { AUTO_PROCEED: { target: "finished" } } },
-		displayError: { after: { AUTO_PROCEED: { target: "finished" } } },
-		displayUnknown: { after: { AUTO_PROCEED: { target: "finished" } } },
-		finished: { type: "final" }
-	}
-});
-
-//#endregion
 //#region src/modules/government-validation/governmentValidationActor.ts
 function createGovernmentValidationActor(options) {
 	return createActor(governmentValidationMachine, { input: { config: options.config } }).start();