@incodetech/core 2.0.1 → 2.1.0-rc.0

package/dist/{faceCaptureSetup-B3faSpYA.esm.js → faceCaptureSetup-CtvHWd3x.esm.js}

@@ -1,164 +1,11 @@
 import { r as getToken } from "./api-CESGtpbH.esm.js";
-import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
-import { t as sleep } from "./ITimerCapability-C67ZRskg.esm.js";
-import { a as StreamCanvasCapture, c as initializeDeepsightSession, d as stopStream, l as sendLabelInspectionEvent, m as FACE_ERROR_CODES, n as preloadOpenViduProvider, o as encryptSelfieImage, r as flagFaceManualReview, s as initializeCamera, t as createRecordingService, u as startDetection } from "./recordingService-Ig2UgbLv.esm.js";
-import { n as requestPermission, t as checkPermission } from "./permissionServices-D_i6nzEw.esm.js";
+import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-CG3bMSfG.esm.js";
+import { d as sendLabelInspectionEvent, f as startDetection, l as initializeCamera, n as preloadOpenViduProvider, p as stopStream, r as flagFaceManualReview, t as createRecordingService, u as initializeDeepsightSession } from "./recordingService-Bn9EdCmz.esm.js";
+import { t as FACE_ERROR_CODES } from "./types-DsnEVMhr.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-ImiDQdVA.esm.js";
+import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-C1ispV96.esm.js";
 
-//#region ../infra/src/scheduling/yieldUntilNextPaint.ts
-/**
-* Resolves after the browser has had a chance to commit and paint a queued
-* render.
-*
-* Strategy:
-* - `requestAnimationFrame` callbacks fire BEFORE the paint of the frame
-*   they belong to (per the HTML5 "update the rendering" step). If we
-*   resolve the promise inside a rAF callback, the await-continuation
-*   runs as a microtask immediately after the callback returns — still
-*   before the paint phase of that frame. A caller that then blocks the
-*   main thread (e.g. synchronous WASM `processPhoto`) starves the paint.
-* - We therefore chain rAF → setTimeout: the rAF fires before frame N's
-*   paint, the setTimeout runs as a macrotask scheduled after frame N's
-*   "update the rendering" step, which the browser will only get to once
-*   the paint actually lands. By the time setTimeout fires, the paint
-*   for the queued render is on screen.
-* - In environments where rAF never ticks (jsdom, happy-dom, backgrounded
-*   tabs), a parallel `setTimeout` fallback at 100 ms resolves instead.
-*   100 ms is comfortably longer than two real-browser frames so rAF +
-*   setTimeout wins reliably in any foregrounded browser. (An earlier
-*   implementation raced rAF against a `MessageChannel` macrotask, but
-*   MessageChannel drains immediately after the current task's
-*   microtasks — before the next paint — so it resolved the promise too
-*   early and defeated the whole point of the helper.)
-*
-* Lives in infra because it touches browser APIs (`requestAnimationFrame`,
-* `setTimeout`) that the architecture rules forbid from core. Core modules
-* that need to yield to the browser render loop should import this helper
-* directly via its file path.
-*/
-function yieldUntilNextPaint() {
-	return new Promise((resolve) => {
-		let resolved = false;
-		const done = () => {
-			if (resolved) return;
-			resolved = true;
-			resolve();
-		};
-		if (typeof requestAnimationFrame === "function") requestAnimationFrame(() => {
-			requestAnimationFrame(() => {
-				setTimeout(done, 0);
-			});
-		});
-		setTimeout(done, 100);
-	});
-}
-
-//#endregion
-//#region src/internal/faceCapture/onDeviceFaceResults.ts
-/**
-* On-device face-results submission helpers.
-*
-* When a SELFIE or AUTHENTICATION module has
-* `onDeviceFaceResultsSubmissionEnabled: true`, face analysis runs entirely
-* inside the WASM `OnDeviceSelfieWorkflow` pipeline. Captured images are
-* never uploaded — only the staged face-results JSON is POSTed via the WASM
-* `WebApi` to `/omni/add/face-results`. The C++ side encrypts that JSON via
-* `SessionEncryptor`, so this path does NOT require WebClient E2EE.
-*
-* These helpers are deliberately variant-agnostic: both the selfie and auth
-* state machine variants delegate their `prepareFaceUpload`, `uploadFace`,
-* and `processFace` actors here to share behavior. See the "Runtime modes
-* within a module" section of `docs/patterns/XSTATE.md` for the broader
-* pattern.
-*/
-const isOnDeviceMode = (config) => config.onDeviceFaceResultsSubmissionEnabled === true;
-/**
-* The default (non-on-device) prepare-upload body shared by selfie and auth.
-* Stops any active recording, runs deepsight virtual-camera + frame checks,
-* tracks the capture attempt, and encrypts the captured image.
-*
-* Lifted out of `faceCaptureSetup.ts`'s base `prepareFaceUpload` actor so the
-* default path can be reused by both variants while leaving room for an
-* on-device branch alongside it.
-*/
-async function defaultPrepareFaceUpload(ctx) {
-	const sessionToken = getToken();
-	const recordingId = (await ctx.recordingService?.stop())?.recordingId ?? null;
-	try {
-		if (ctx.deepsightService) await Promise.all([ctx.deepsightService.performVirtualCameraCheck(sessionToken, "SELFIE"), ctx.deepsightService.analyzeFrame(ctx.capturedImage.getImageData())]);
-	} catch (error) {}
-	const logs = ctx.deepsightService?.getPipelineState() ?? "";
-	ctx.dependencies.trackCaptureAttemptFinished?.({ logs });
-	return {
-		encryptedBase64Image: await encryptSelfieImage({
-			canvas: ctx.capturedImage,
-			dependencies: ctx.dependencies
-		}),
-		recordingId
-	};
-}
-/**
-* On-device prepare-upload. No recording to stop (the recording service is
-* never created when the flag is on), no image encryption needed.
-*
-* Behavior depends on which capture path got us here:
-*
-* - **Auto-capture path**: the WASM `OnDeviceSelfiePipeline` has been
-*   consuming every video frame via `processFrame()` and aggregating
-*   results across them. When it picks a best-shot, the C++
-*   `OnDeviceSelfieWorkflow::createOnCaptureHandler` calls
-*   `WebApi::setFaceResults(...)` automatically — staging strong,
-*   aggregated `BestShotData` for the subsequent `postFaceResults` call.
-*   We must NOT call `processPhoto` here: `applyFaceResults` would
-*   overwrite that staged state with a weaker single-frame analysis of a
-*   post-capture snapshot (camera state has already changed: autocapture
-*   freeze, stream pause, post-detection latency), and the server then
-*   rejects the submission as "image quality too low".
-*
-* - **Manual-capture path**: the auto-capture timer expired without a
-*   successful best-shot, so the C++ pipeline has nothing staged. We
-*   need to run a single-frame analysis on the manually captured canvas
-*   via `processPhoto`, which itself calls
-*   `OnDeviceSelfieWorkflow::applyFaceResults` → `WebApi::setFaceResults`
-*   to stage results. Mirrors V1 (`packages/incode-welcome/src/camera/useSelfie.ts`)
-*   where `processPhoto` is only invoked from `handleManualCapture`.
-*
-* Returns sentinel values for `encryptedBase64Image` and `recordingId` so
-* the existing FaceCaptureContext shape remains stable; downstream actors
-* for the on-device path simply ignore them.
-*/
-async function prepareOnDeviceFaceUpload(ctx) {
-	if (!ctx.capturedImage) throw new Error("On-device capture requires a captured image canvas");
-	if (!ctx.provider) throw new Error("On-device capture requires the FaceDetectionProvider to be initialized");
-	if (ctx.manualCaptureTriggered) {
-		await yieldUntilNextPaint();
-		await sleep(350);
-		ctx.provider.processPhoto(ctx.capturedImage.canvas);
-	}
-	return {
-		encryptedBase64Image: "",
-		recordingId: null
-	};
-}
-/**
-* POSTs the staged on-device face-results JSON to `/omni/add/face-results`
-* through the WASM `WebApi`. Used as the `uploadFace` actor body for both
-* selfie and auth variants when on-device mode is enabled.
-*
-* The C++ `WebApi` handles `SessionEncryptor` encryption and the actual
-* HTTP via the WASM `WebClient` — so callers don't need to thread the
-* session-encryption details through JS.
-*/
-async function postOnDeviceFaceResults(ctx, signal) {
-	const provider = ctx.provider;
-	if (!provider) throw new Error("On-device upload requires the FaceDetectionProvider to be initialized");
-	const sessionToken = getToken();
-	return await provider.postFaceResults({
-		headers: sessionToken ? { "X-Incode-Hardware-Id": sessionToken } : void 0,
-		timeout: 3e4
-	}) ?? {};
-}
-
-//#endregion
 //#region src/internal/faceCapture/faceCaptureSetup.ts
 const getAttemptsFromConfig = (config) => {
 	return config.captureAttempts ?? config.numberOfAttempts ?? 3;
@@ -174,7 +21,7 @@ const _faceCaptureMachine = setup({
 			return checkPermission();
 		}),
 		requestPermission: fromPromise(async ({ input }) => {
-			return requestPermission({ requestMotion: input.requestMotionPermission });
+			return invokeRequestPermissionActor(input);
 		}),
 		initializeCamera: fromPromise(async ({ input }) => {
 			return initializeCamera({
@@ -379,6 +226,12 @@ const _faceCaptureMachine = setup({
 			if ("output" in event) return event.output === "granted";
 			return false;
 		},
+		isReadyForCapture: ({ context, event }) => {
+			return isReadyForCaptureFromPermission(resolveStoredPermissionResult("output" in event ? event.output : void 0, context.permissionResult), context.config.ds);
+		},
+		needsMotionPrimeOnly: ({ context, event }) => {
+			return needsMotionPrimeOnlyFromPermission(resolveStoredPermissionResult("output" in event ? event.output : void 0, context.permissionResult), context.config.ds);
+		},
 		isPermissionDeniedError: ({ event }) => {
 			if ("error" in event) {
 				const error = event.error;
@@ -435,7 +288,7 @@ const _faceCaptureMachine = setup({
 				src: "checkPermission",
 				onDone: [{
 					target: "capture",
-					guard: "isPermissionGranted",
+					guard: "isReadyForCapture",
 					actions: "setPermissionResultFromEvent"
 				}, {
 					target: "permissions",
@@ -461,7 +314,7 @@ const _faceCaptureMachine = setup({
 					src: "checkPermission",
 					onDone: [{
 						target: "initializingCamera",
-						guard: "isPermissionGranted",
+						guard: "isReadyForCapture",
 						actions: "setPermissionResultFromEvent"
 					}, {
 						target: "ready",
@@ -553,14 +406,22 @@ const _faceCaptureMachine = setup({
 				waitingForPermission: { invoke: {
 					id: "checkPermissionWaiting",
 					src: "checkPermission",
-					onDone: [{
-						target: "#faceCapture.capture",
-						guard: "isPermissionGranted",
-						actions: "setPermissionResultFromEvent"
-					}, {
-						target: "#faceCapture.permissions",
-						actions: "setPermissionResultFromEvent"
-					}]
+					onDone: [
+						{
+							target: "#faceCapture.capture",
+							guard: "isReadyForCapture",
+							actions: "setPermissionResultFromEvent"
+						},
+						{
+							target: "#faceCapture.permissions.requesting",
+							guard: "needsMotionPrimeOnly",
+							actions: "setPermissionResultFromEvent"
+						},
+						{
+							target: "#faceCapture.permissions",
+							actions: "setPermissionResultFromEvent"
+						}
+					]
 				} }
 			}
 		},
@@ -589,21 +450,42 @@ const _faceCaptureMachine = setup({
 					invoke: {
 						id: "checkPermissionIdle",
 						src: "checkPermission",
-						onDone: [{
-							target: "#faceCapture.capture",
-							guard: "isPermissionGranted",
-							actions: "setPermissionResultFromEvent"
-						}, {
-							target: "denied",
-							guard: ({ event }) => event.output === "denied",
-							actions: "setPermissionResultFromEvent"
-						}]
+						onDone: [
+							{
+								target: "#faceCapture.capture",
+								guard: "isReadyForCapture",
+								actions: "setPermissionResultFromEvent"
+							},
+							{
+								target: "denied",
+								guard: ({ event }) => event.output === "denied",
+								actions: "setPermissionResultFromEvent"
+							},
+							{
+								target: "motionOnly",
+								guard: "needsMotionPrimeOnly",
+								actions: "setPermissionResultFromEvent"
+							},
+							{
+								target: "waitingForUser",
+								actions: "setPermissionResultFromEvent"
+							}
+						],
+						onError: {
+							target: "waitingForUser",
+							actions: assign({ permissionResult: () => "prompt" })
+						}
 					},
 					on: {
 						REQUEST_PERMISSION: "requesting",
 						GO_TO_LEARN_MORE: "learnMore"
 					}
 				},
+				waitingForUser: { on: {
+					REQUEST_PERMISSION: "requesting",
+					GO_TO_LEARN_MORE: "learnMore"
+				} },
+				motionOnly: { on: { REQUEST_PERMISSION: "requesting" } },
 				learnMore: { on: {
 					BACK: "idle",
 					REQUEST_PERMISSION: "requesting"
@@ -611,11 +493,14 @@ const _faceCaptureMachine = setup({
 				requesting: { invoke: {
 					id: "requestPermission",
 					src: "requestPermission",
-					input: ({ context }) => ({ requestMotionPermission: context.config.ds === true }),
+					input: ({ context }) => ({
+						permissionResult: context.permissionResult === "refresh" ? void 0 : context.permissionResult,
+						requestMotionPermission: context.config.ds === true
+					}),
 					onDone: [
 						{
 							target: "#faceCapture.capture",
-							guard: "isPermissionGranted",
+							guard: "isReadyForCapture",
 							actions: "setPermissionResultFromEvent"
 						},
 						{
@@ -624,7 +509,7 @@ const _faceCaptureMachine = setup({
 							actions: "setPermissionResultFromEvent"
 						},
 						{
-							target: "idle",
+							target: "waitingForUser",
 							actions: "setPermissionResultFromEvent"
 						}
 					],
@@ -870,4 +755,4 @@ const _faceCaptureMachine = setup({
 const faceCaptureMachine = _faceCaptureMachine;
 
 //#endregion
-export { prepareOnDeviceFaceUpload as a, postOnDeviceFaceResults as i, defaultPrepareFaceUpload as n, isOnDeviceMode as r, faceCaptureMachine as t };
+export { faceCaptureMachine as t };

package/dist/{faceMatchStateMachine-DNFrxTFS.esm.js → faceMatchStateMachine-DdGXUBnx.esm.js}

@@ -1,7 +1,31 @@
 import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
 
+//#region src/modules/face-match/constants.ts
+/**
+* Backend error code returned by face-match endpoints (e.g. `/omni/process/face`,
+* `/omni/get/score`) when the session was captured with `extractIdFace: false`.
+* No biometric ID template exists, so face-match cannot run and should be
+* skipped on the client (continue to the next step instead of erroring).
+*/
+const ID_FACE_EXTRACTION_SKIPPED_CODE = 4084;
+/**
+* Determines whether a thrown HTTP error represents the "ID face extraction
+* skipped" case (backend status `4084`).
+*
+* The backend exposes the code either as the top-level `status` field of the
+* rejected value or nested inside the response body (`data.status`), depending
+* on the transport. The HTTP client surfaces non-2xx responses as a
+* `FetchHttpError` whose `data` holds the parsed error body.
+*/
+function isFaceExtractionSkippedError(error) {
+	if (!error || typeof error !== "object") return false;
+	const err = error;
+	return err.status === ID_FACE_EXTRACTION_SKIPPED_CODE || err.data?.status === ID_FACE_EXTRACTION_SKIPPED_CODE;
+}
+
+//#endregion
 //#region src/modules/face-match/faceMatchServices.ts
 /**
 * Fetches cropped face images from the backend.
@@ -41,9 +65,33 @@ async function fetchSecondIdImages(signal) {
 	return { secondIdFace: res.data.croppedIDFace ?? null };
 }
 /**
+* Triggers server-side face processing/matching for the captured selfie.
+*
+* Used when an AUTHENTICATION module is present in the flow (`processFaceBeforeMatch`):
+* the auth capture step skips server-side processing, so the match must be triggered here
+* before `GET /omni/get/score` reflects it. Mirrors SDK 1's FaceMatch module.
+*
+* The response body is intentionally ignored — face-match re-reads the result via
+* `fetchScore`. A non-ok response throws an Error carrying the backend `status`/`data` so
+* the state machine's `onError` can both produce a readable message and detect the
+* "ID face extraction skipped" case (status 4084) via `isFaceExtractionSkippedError`.
+*/
+async function processFaceForMatch(matchingType, signal) {
+	const endpoint = matchingType === "secondId" ? endpoints.processFaceSecondId : endpoints.processFace;
+	const res = await api.post(endpoint, {}, {
+		query: { imageType: "selfie" },
+		signal
+	});
+	if (!res.ok) throw Object.assign(/* @__PURE__ */ new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`), {
+		status: res.status,
+		data: res.data
+	});
+}
+/**
 * Fetches all face match data in parallel (images, score, and optionally second ID images).
 */
 async function fetchFaceMatchData(config, signal) {
+	if (config.processFaceBeforeMatch) await processFaceForMatch(config.matchingType, signal);
 	const promises = [fetchFaceMatchImages(signal), fetchScore(signal)];
 	if (config.matchingType === "secondId") promises.push(fetchSecondIdImages(signal));
 	const [imagesRes, resultRes, secondIdRes] = await Promise.all(promises);
@@ -84,7 +132,10 @@ const faceMatchMachine = setup({
 			error: void 0
 		}))
 	},
-	guards: { isAnimationDisabled: ({ context }) => context.config.disableFaceMatchAnimation === true }
+	guards: {
+		isAnimationDisabled: ({ context }) => context.config.disableFaceMatchAnimation === true,
+		isFaceExtractionSkipped: ({ event }) => isFaceExtractionSkippedError(event.error)
+	}
 }).createMachine({
 	id: "faceMatch",
 	initial: "idle",
@@ -108,10 +159,13 @@ const faceMatchMachine = setup({
 				target: "animating",
 				actions: "setData"
 			}],
-			onError: {
+			onError: [{
+				target: "finished",
+				guard: "isFaceExtractionSkipped"
+			}, {
 				target: "error",
 				actions: "setError"
-			}
+			}]
 		} },
 		animating: { on: { ANIMATION_COMPLETE: { target: "result" } } },
 		result: { on: { CONTINUE: { target: "finished" } } },
@@ -124,4 +178,4 @@ const faceMatchMachine = setup({
 });
 
 //#endregion
-export { faceMatchMachine as t };
+export { ID_FACE_EXTRACTION_SKIPPED_CODE as n, isFaceExtractionSkippedError as r, faceMatchMachine as t };

package/dist/field-comparison.d.ts

@@ -0,0 +1,4 @@
+import "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
+import { a as FieldComparisonActor, c as FieldComparisonFields, i as createFieldComparisonManagerFromActor, n as FieldComparisonState, o as fieldComparisonMachine, r as createFieldComparisonManager, s as FieldComparisonConfig, t as FieldComparisonManager } from "./fieldComparisonManager-Bu5TaSr3.js";
+export { type FieldComparisonActor, type FieldComparisonConfig, type FieldComparisonFields, type FieldComparisonManager, type FieldComparisonState, createFieldComparisonManager, createFieldComparisonManagerFromActor, fieldComparisonMachine };

package/dist/field-comparison.esm.js

@@ -0,0 +1,7 @@
+import "./api-CESGtpbH.esm.js";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./xstate.esm-C9wncMQa.esm.js";
+import { n as createFieldComparisonManagerFromActor, r as fieldComparisonMachine, t as createFieldComparisonManager } from "./fieldComparisonManager-COGI2ARD.esm.js";
+
+export { createFieldComparisonManager, createFieldComparisonManagerFromActor, fieldComparisonMachine };

package/dist/fieldComparisonManager-Bu5TaSr3.d.ts

@@ -0,0 +1,76 @@
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+
+//#region src/modules/field-comparison/types.d.ts
+
+/**
+ * Configuration options for the field comparison module.
+ *
+ * The backend currently sends an empty module configuration for this step.
+ */
+type FieldComparisonConfig = Record<string, never>;
+/** First and last name collected for backend field comparison. */
+type FieldComparisonFields = {
+  firstName: string;
+  lastName: string;
+};
+//#endregion
+//#region src/modules/field-comparison/fieldComparisonStateMachine.d.ts
+
+declare const fieldComparisonMachine: any;
+type FieldComparisonMachine = typeof fieldComparisonMachine;
+//#endregion
+//#region src/modules/field-comparison/fieldComparisonActor.d.ts
+/** Options for {@link createFieldComparisonActor}. */
+type CreateFieldComparisonActorOptions = {
+  /** Module configuration from the flow (currently always empty). */
+  config?: FieldComparisonConfig;
+};
+/** Started actor ref for the field comparison state machine. */
+type FieldComparisonActor = ActorRefFrom<FieldComparisonMachine>;
+//#endregion
+//#region src/modules/field-comparison/fieldComparisonManager.d.ts
+type FieldComparisonIdleState = {
+  status: 'idle';
+};
+type FieldComparisonInputtingState = {
+  status: 'inputting';
+  fields: FieldComparisonFields;
+  canSubmit: boolean;
+};
+type FieldComparisonSubmittingState = {
+  status: 'submitting';
+  fields: FieldComparisonFields;
+};
+type FieldComparisonSuccessState = {
+  status: 'success';
+};
+type FieldComparisonErrorState = {
+  status: 'error';
+};
+type FieldComparisonFinishedState = {
+  status: 'finished';
+};
+type FieldComparisonState = FieldComparisonIdleState | FieldComparisonInputtingState | FieldComparisonSubmittingState | FieldComparisonFinishedState | FieldComparisonSuccessState | FieldComparisonErrorState;
+declare function createFieldComparisonManager(options?: CreateFieldComparisonActorOptions): Manager<FieldComparisonState> & {
+  load(): void;
+  setField(field: keyof FieldComparisonFields, value: string): void;
+  submit(): void;
+  retry(): void;
+  skip(): void;
+};
+/**
+ * Creates a field-comparison manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or for story-isolation testing.
+ */
+declare function createFieldComparisonManagerFromActor(actor: FieldComparisonActor): Manager<FieldComparisonState> & {
+  load(): void;
+  setField(field: keyof FieldComparisonFields, value: string): void;
+  submit(): void;
+  retry(): void;
+  skip(): void;
+};
+type FieldComparisonManager = ReturnType<typeof createFieldComparisonManager>;
+//#endregion
+export { FieldComparisonActor as a, FieldComparisonFields as c, createFieldComparisonManagerFromActor as i, FieldComparisonState as n, fieldComparisonMachine as o, createFieldComparisonManager as r, FieldComparisonConfig as s, FieldComparisonManager as t };

package/dist/fieldComparisonManager-COGI2ARD.esm.js

@@ -0,0 +1,162 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+
+//#region src/modules/field-comparison/fieldComparisonServices.ts
+/** Submit first and last name for backend field comparison. Throws on failure. */
+async function submitFieldComparison(params, signal) {
+	const res = await api.post(endpoints.addCustomFields, params, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addCustomFields} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/field-comparison/fieldComparisonUtils.ts
+/** Returns true when both first and last name are non-empty after trimming. */
+function isFormComplete(fields) {
+	return fields.firstName.trim() !== "" && fields.lastName.trim() !== "";
+}
+
+//#endregion
+//#region src/modules/field-comparison/fieldComparisonStateMachine.ts
+const emptyFields = () => ({
+	firstName: "",
+	lastName: ""
+});
+const fieldComparisonMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { submitFields: fromPromise(async ({ input, signal }) => {
+		return submitFieldComparison({ customFields: input }, signal);
+	}) },
+	actions: { setField: assign(({ context, event }) => {
+		const e = event;
+		return { fields: {
+			...context.fields,
+			[e.field]: e.value
+		} };
+	}) },
+	guards: {
+		canSubmit: ({ context }) => isFormComplete(context.fields),
+		apiSucceeded: ({ event }) => event.output.success
+	}
+}).createMachine({
+	id: "fieldComparison",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		fields: emptyFields()
+	}),
+	states: {
+		idle: { on: { LOAD: "inputting" } },
+		inputting: { on: {
+			FIELD_CHANGED: { actions: "setField" },
+			SUBMIT: {
+				target: "submitting",
+				guard: "canSubmit"
+			}
+		} },
+		submitting: { invoke: {
+			id: "submitFields",
+			src: "submitFields",
+			input: ({ context }) => context.fields,
+			onDone: [{
+				target: "success",
+				guard: "apiSucceeded"
+			}, { target: "error" }],
+			onError: { target: "error" }
+		} },
+		success: { after: { 3e3: { target: "finished" } } },
+		error: { on: {
+			RETRY: { target: "inputting" },
+			SKIP: { target: "finished" }
+		} },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/field-comparison/fieldComparisonActor.ts
+/**
+* Creates and starts the field comparison state machine actor.
+*
+* @param options - Optional actor configuration
+*/
+function createFieldComparisonActor(options = {}) {
+	return createActor(fieldComparisonMachine, { input: { config: options.config ?? {} } }).start();
+}
+
+//#endregion
+//#region src/modules/field-comparison/fieldComparisonManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { fields } = typedSnapshot.context;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("inputting")) return {
+		status: "inputting",
+		canSubmit: isFormComplete(fields),
+		fields
+	};
+	if (typedSnapshot.matches("submitting")) return {
+		status: "submitting",
+		fields
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("error")) return { status: "error" };
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setField(field, value) {
+			actor.send({
+				type: "FIELD_CHANGED",
+				field,
+				value
+			});
+		},
+		submit() {
+			trackElementClicked?.("submit");
+			actor.send({ type: "SUBMIT" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		skip() {
+			trackElementClicked?.("skip");
+			actor.send({ type: "SKIP" });
+		}
+	};
+}
+function createFieldComparisonManager(options = {}) {
+	return createManager({
+		actor: createFieldComparisonActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.fieldComparison)
+	});
+}
+/**
+* Creates a field-comparison manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createFieldComparisonManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.fieldComparison)
+	});
+}
+
+//#endregion
+export { createFieldComparisonManagerFromActor as n, fieldComparisonMachine as r, createFieldComparisonManager as t };