@incodetech/core 0.0.0-dev-20260505-e06a25f → 0.0.0-dev-20260505-4dd3003

package/dist/faceCaptureManagerFactory-Dix0LYX3.esm.js

@@ -0,0 +1,288 @@
+import { n as eventModuleNames, o as createManagerInstrumentation, r as eventScreenNames } from "./events-s0VL5FYh.esm.js";
+import { o as createManager } from "./xstate.esm-cL1KdW6d.esm.js";
+
+//#region src/internal/faceCapture/faceCaptureManagerFactory.ts
+function getPermissionStatus(snapshot) {
+	if (!snapshot.matches("permissions")) return;
+	if (snapshot.matches({ permissions: "idle" })) return "idle";
+	if (snapshot.matches({ permissions: "learnMore" })) return "learnMore";
+	if (snapshot.matches({ permissions: "requesting" })) return "requesting";
+	if (snapshot.matches({ permissions: "denied" })) return "denied";
+}
+function getCaptureStatus(snapshot) {
+	if (snapshot.matches({ capture: "initializing" })) return "initializing";
+	if (snapshot.matches({ capture: "detecting" })) return "detecting";
+	if (snapshot.matches({ capture: "capturing" })) return "capturing";
+	if (snapshot.matches({ capture: "capturingManual" })) return "capturing";
+	if (snapshot.matches({ capture: "uploading" })) return "uploading";
+	if (snapshot.matches({ capture: "uploadError" })) return "uploadError";
+	if (snapshot.matches({ capture: "success" })) return "success";
+}
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle")) return { status: "idle" };
+	if (snapshot.matches("loading")) return { status: "loading" };
+	if (snapshot.matches("tutorial")) return {
+		status: "tutorial",
+		ageAssurance: context.config?.ageAssurance === true
+	};
+	if (snapshot.matches("closed")) return { status: "closed" };
+	if (snapshot.matches("permissions")) {
+		const permissionStatus = getPermissionStatus(snapshot);
+		if (permissionStatus === void 0) return {
+			status: "permissions",
+			permissionStatus: "idle"
+		};
+		return {
+			status: "permissions",
+			permissionStatus
+		};
+	}
+	if (snapshot.matches("capture")) return {
+		status: "capture",
+		captureStatus: getCaptureStatus(snapshot) ?? "initializing",
+		stream: context.stream,
+		detectionStatus: context.detectionStatus ?? "idle",
+		debugFrame: context.debugFrame,
+		attemptsRemaining: context.attemptsRemaining ?? 0,
+		uploadError: context.uploadError,
+		assistedOnboarding: context.config?.assistedOnboarding ?? false,
+		ageAssurance: context.config?.ageAssurance === true
+	};
+	if (snapshot.matches("processing")) return { status: "processing" };
+	if (snapshot.matches("finished")) return {
+		status: "finished",
+		processResponse: context.processResponse
+	};
+	if (snapshot.matches("error")) {
+		const errorValue = context.error;
+		return {
+			status: "error",
+			error: typeof errorValue === "string" ? errorValue : errorValue ? errorValue.message : "Unknown error"
+		};
+	}
+	return { status: "idle" };
+}
+function getFaceCaptureTutorialScreen(snapshot) {
+	if (snapshot.context?.config?.ageAssurance === true) return "faceCapture.tutorial.ageAssurance";
+	if (typeof snapshot.value === "object" && snapshot.value !== null) {
+		const tutorialValue = snapshot.value.tutorial;
+		if (typeof tutorialValue === "object" && tutorialValue !== null && "initializingCamera" in tutorialValue) return "faceCapture.tutorial.loading";
+	}
+	return "faceCapture.tutorial.default";
+}
+function getCapturingScreen(detectionStatus) {
+	switch (detectionStatus) {
+		case "getReady":
+		case "getReadyFinished": return "faceCapture.capturing.getReady";
+		case "dark": return "faceCapture.capturing.tooDark";
+		case "tooBright": return "faceCapture.capturing.tooBright";
+		case "tooClose": return "faceCapture.capturing.moveAway";
+		case "tooFar": return "faceCapture.capturing.moveCloser";
+		case "moveLeft": return "faceCapture.capturing.moveLeft";
+		case "moveRight": return "faceCapture.capturing.moveRight";
+		case "blur":
+		case "centerFace":
+		case "noFace":
+		case "tooManyFaces": return "faceCapture.capturing.alignFace";
+		case "faceAngle":
+		case "lookAtCamera": return "faceCapture.capturing.lookAtCamera";
+		case "eyesClosed": return "faceCapture.capturing.eyesClosed";
+		case "faceMask": return "faceCapture.capturing.maskDetected";
+		case "lenses": return "faceCapture.capturing.glassesDetected";
+		case "headWear": return "faceCapture.capturing.hatDetected";
+		case "faceOcclusion": return "faceCapture.capturing.faceOcclusion";
+		case "manualCapture": return "faceCapture.manualCapture.default";
+		case "capturing": return "faceCapture.loading.processing";
+		case "detecting":
+		case "idle":
+		case "offline": return "faceCapture.genericErrors.noConnection";
+		case "success":
+		case "error":
+		default: return "faceCapture.capturing.initiatingState";
+	}
+}
+function getResultErrorScreen(errorCode, attemptsRemaining) {
+	const exhaustedSuffix = attemptsRemaining === 0 ? "Exhausted" : "";
+	switch (errorCode) {
+		case "LENSES_ERROR":
+		case "LENSES_DETECTED": return `faceCapture.resultError.lensesDetected${exhaustedSuffix}`;
+		case "BRIGHTNESS_ERROR": return `faceCapture.resultError.tooBright${exhaustedSuffix}`;
+		case "MASK_ERROR":
+		case "FACE_MASK_DETECTED": return `faceCapture.resultError.faceMaskDetected${exhaustedSuffix}`;
+		case "FACE_TOO_DARK":
+		case "TOO_DARK_ERROR": return `faceCapture.resultError.tooDark${exhaustedSuffix}`;
+		case "CLOSED_EYES_ERROR":
+		case "CLOSED_EYES_DETECTED": return `faceCapture.resultError.eyesClosed${exhaustedSuffix}`;
+		case "HEAD_COVER_ERROR":
+		case "HEAD_COVER_DETECTED": return `faceCapture.resultError.headCovered${exhaustedSuffix}`;
+		case "FACE_OCCLUDED": return `faceCapture.resultError.faceOcclusion${exhaustedSuffix}`;
+		case "TOO_BLURRY_ERROR":
+		case "FACE_TOO_BLURRY":
+		case "BAD_PHOTO_QUALITY":
+		case "SELFIE_IMAGE_LOW_QUALITY": return `faceCapture.resultError.lowQuality${exhaustedSuffix}`;
+		case "SERVER_ERROR":
+		case "PROCESSING_ERROR":
+		case "BAD_REQUEST": return `faceCapture.resultError.processingFailed${exhaustedSuffix}`;
+		case "FACE_NOT_FOUND":
+		case "MULTIPLE_FACES":
+		case "FACE_CROPPING_FAILED":
+		case "FACE_TOO_SMALL":
+		case "LIVENESS_ERROR":
+		default: return `faceCapture.resultError.faceNotAligned${exhaustedSuffix}`;
+	}
+}
+function getCaptureSubstateScreen(snapshot) {
+	const { value, context } = snapshot;
+	if (typeof value !== "object" || value === null) return void 0;
+	const captureValue = value.capture;
+	if (captureValue === void 0) return void 0;
+	if (typeof captureValue === "string") switch (captureValue) {
+		case "checkingDeepsight":
+		case "initializingDeepsight":
+		case "checkingStream":
+		case "initializing": return "faceCapture.capturing.initiatingState";
+		case "detecting": return getCapturingScreen(context?.detectionStatus);
+		case "capturing": return "faceCapture.loading.processing";
+		case "capturingManual": return "faceCapture.manualCapture.default";
+		case "preparingUpload":
+		case "uploading":
+		case "validatingUpload": return "faceCapture.loading.uploading";
+		case "uploadError": return getResultErrorScreen(context?.uploadError, context?.attemptsRemaining);
+		case "success": return "faceCapture.resultSuccess.default";
+	}
+	if (typeof captureValue === "object" && captureValue !== null) {
+		const substates = Object.keys(captureValue);
+		if (substates.includes("uploading")) return "faceCapture.loading.uploading";
+		if (substates.includes("uploadError")) return getResultErrorScreen(context?.uploadError, context?.attemptsRemaining);
+		if (substates.includes("success")) return "faceCapture.resultSuccess.default";
+	}
+	return "faceCapture.capturing.initiatingState";
+}
+function getAuthFaceCaptureSubstateScreen(snapshot) {
+	const { value } = snapshot;
+	if (typeof value !== "object" || value === null) return void 0;
+	const captureValue = value.capture;
+	if (captureValue === void 0) return void 0;
+	if (typeof captureValue === "string") switch (captureValue) {
+		case "preparingUpload":
+		case "uploading":
+		case "validatingUpload": return eventScreenNames.authFaceUpload;
+		case "uploadError": return eventScreenNames.authFaceError;
+		case "success": return eventScreenNames.authFaceUploadSuccess;
+		case "checkingDeepsight":
+		case "initializingDeepsight":
+		case "checkingStream":
+		case "initializing":
+		case "detecting":
+		case "capturing":
+		case "capturingManual": return eventScreenNames.authFace;
+	}
+	if (typeof captureValue === "object" && captureValue !== null) {
+		const substates = Object.keys(captureValue);
+		if (substates.includes("uploading") || substates.includes("validatingUpload")) return eventScreenNames.authFaceUpload;
+		if (substates.includes("uploadError")) return eventScreenNames.authFaceError;
+		if (substates.includes("success")) return eventScreenNames.authFaceUploadSuccess;
+	}
+	return eventScreenNames.authFace;
+}
+function getTopLevelState(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "object") return Object.keys(value)[0];
+}
+function getAuthFaceScreenName(snapshot) {
+	const { value } = snapshot;
+	if (value === void 0 || value === null) return void 0;
+	const topLevel = getTopLevelState(value);
+	if (topLevel === void 0) return void 0;
+	switch (topLevel) {
+		case "tutorial": return eventScreenNames.authFaceTutorial;
+		case "capture": return getAuthFaceCaptureSubstateScreen(snapshot);
+		case "finished": return eventScreenNames.authFaceUploadSuccess;
+		case "error": return eventScreenNames.authFaceUploadFailed;
+		case "idle":
+		case "loading":
+		case "permissions":
+		case "processing":
+		case "closed":
+		default: return eventScreenNames.authFace;
+	}
+}
+function getFaceCaptureScreenName(snapshot, moduleName) {
+	if (moduleName === eventModuleNames.authFace || moduleName === eventModuleNames.authentication) return getAuthFaceScreenName(snapshot);
+	const { value } = snapshot;
+	if (value === void 0 || value === null) return void 0;
+	const topLevel = getTopLevelState(value);
+	if (topLevel === void 0) return void 0;
+	switch (topLevel) {
+		case "idle": return "faceCapture.loading.processing";
+		case "loading": return "faceCapture.loading.processing";
+		case "tutorial": return getFaceCaptureTutorialScreen(snapshot);
+		case "permissions": return "faceCapture.tutorial.default";
+		case "capture": return getCaptureSubstateScreen(snapshot);
+		case "processing": return "faceCapture.loading.processing";
+		case "finished": return "faceCapture.resultSuccess.default";
+		case "closed": return "faceCapture.closed";
+		case "error": return "faceCapture.resultError.processingFailed";
+		default: return `faceCapture.${topLevel}`;
+	}
+}
+function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished }) {
+	const snapshot = actor.getSnapshot();
+	snapshot.context.dependencies.trackCaptureAttemptFinished = trackCaptureAttemptFinished;
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		nextStep() {
+			trackElementClicked?.("nextStep");
+			actor.send({ type: "NEXT_STEP" });
+		},
+		requestPermission() {
+			trackElementClicked?.("requestPermission");
+			actor.send({ type: "REQUEST_PERMISSION" });
+		},
+		goToLearnMore() {
+			trackElementClicked?.("goToLearnMore");
+			actor.send({ type: "GO_TO_LEARN_MORE" });
+		},
+		back() {
+			trackElementClicked?.("back");
+			actor.send({ type: "BACK" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "QUIT" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		},
+		retryCapture() {
+			trackElementClicked?.("retryCapture");
+			actor.send({ type: "RETRY_CAPTURE" });
+		},
+		capture() {
+			trackElementClicked?.("capture");
+			actor.send({ type: "MANUAL_CAPTURE" });
+		}
+	};
+}
+function getFaceCaptureErrorPayload(snapshot) {
+	const errorCode = snapshot.context.uploadError;
+	if (typeof errorCode !== "string" || errorCode.length === 0) return;
+	return { errorCode };
+}
+function createFaceCaptureManagerFromActor(actor, moduleName) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(moduleName, {
+			getEventScreenName: (snapshot) => getFaceCaptureScreenName(snapshot, moduleName),
+			getErrorPayload: getFaceCaptureErrorPayload
+		})
+	});
+}
+
+//#endregion
+export { createFaceCaptureManagerFromActor as t };

package/dist/{faceCaptureSetup-Cclz77d6.esm.js → faceCaptureSetup-GGxPo8Cc.esm.js}

@@ -1,6 +1,6 @@
 import { r as getToken } from "./api-3IquGyW5.esm.js";
-import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-CSiDcEjt.esm.js";
-import { _ as StreamCanvasCapture, a as initializeDeepsightSession, c as stopStream, h as flagFaceManualReview, i as initializeCamera, n as preloadOpenViduProvider, o as sendLabelInspectionEvent, r as encryptSelfieImage, s as startDetection, t as createRecordingService, v as FACE_ERROR_CODES } from "./recordingService-Cen0Qmop.esm.js";
+import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-cL1KdW6d.esm.js";
+import { _ as StreamCanvasCapture, a as initializeDeepsightSession, c as stopStream, h as flagFaceManualReview, i as initializeCamera, n as preloadOpenViduProvider, o as sendLabelInspectionEvent, r as encryptSelfieImage, s as startDetection, t as createRecordingService, v as FACE_ERROR_CODES } from "./recordingService-Nn-BBO6j.esm.js";
 import { n as requestPermission, r as clearCameraPermissionCache, t as checkPermission } from "./permissionServices-DiAThhLg.esm.js";
 
 //#region src/internal/faceCapture/faceCaptureSetup.ts

package/dist/{faceMatchStateMachine-Cd70G-3Q.esm.js → faceMatchStateMachine-Cjc-2700.esm.js}

@@ -1,6 +1,6 @@
 import { t as api } from "./api-3IquGyW5.esm.js";
-import { v as endpoints } from "./events-237AXtL7.esm.js";
-import { i as fromPromise, n as assign, t as setup } from "./xstate.esm-CSiDcEjt.esm.js";
+import { v as endpoints } from "./events-s0VL5FYh.esm.js";
+import { i as fromPromise, n as assign, t as setup } from "./xstate.esm-cL1KdW6d.esm.js";
 
 //#region src/modules/face-match/faceMatchServices.ts
 /**

package/dist/flow.d.ts

@@ -7,7 +7,7 @@ import { i as FlowModuleConfig, n as Flow, r as FlowModule } from "./types-DFwAu
 import { n as GetFinishStatusFn, t as FinishStatus } from "./flowCompletionService-U6Ov6LFb.js";
 import { o as FlowEventSubscribable } from "./index-BIhqszMN.js";
 import { t as ModuleRegistry } from "./types-DxQ9z4r7.js";
-import * as xstate487 from "xstate";
+import * as xstate961 from "xstate";
 
 //#region src/modules/flow/flowUtils.d.ts
 type NormalizeFlowModulesOptions = {
@@ -55,7 +55,7 @@ type GetFlow = (signal: AbortSignal, options?: GetFlowOptions) => Promise<Flow>;
 declare const getFlow: GetFlow;
 //#endregion
 //#region src/modules/flow/noOpFlowModuleMachine.d.ts
-declare const noOpFlowModuleMachine: xstate487.StateMachine<xstate487.MachineContext, xstate487.AnyEventObject, {}, never, never, never, never, "finished", string, xstate487.NonReducibleUnknown, xstate487.NonReducibleUnknown, xstate487.EventObject, xstate487.MetaObject, {
+declare const noOpFlowModuleMachine: xstate961.StateMachine<xstate961.MachineContext, xstate961.AnyEventObject, {}, never, never, never, never, "finished", string, xstate961.NonReducibleUnknown, xstate961.NonReducibleUnknown, xstate961.EventObject, xstate961.MetaObject, {
   readonly id: "noOpFlowModule";
   readonly initial: "finished";
   readonly states: {

package/dist/flow.esm.js

@@ -1,12 +1,12 @@
 import "./api-3IquGyW5.esm.js";
-import { o as createManagerInstrumentation } from "./events-237AXtL7.esm.js";
-import "./session-DcLfiFln.esm.js";
+import "./events-s0VL5FYh.esm.js";
+import "./session-oIjERqhS.esm.js";
 import "./IpifyProvider-CVIOst3c.esm.js";
 import "./browserSimulation-DMJIC-23.esm.js";
-import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-CSiDcEjt.esm.js";
-import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-Bh4UKZez.esm.js";
-import { n as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-BiTJSa1K.esm.js";
-import { t as getFinishStatus } from "./flowCompletionService-DKHUsKiX.esm.js";
+import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-cL1KdW6d.esm.js";
+import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-QTK0C4Ek.esm.js";
+import { n as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-DP-gEBHS.esm.js";
+import { t as getFinishStatus } from "./flowCompletionService-DhTdMWSB.esm.js";
 
 //#region src/modules/flow/noOpFlowModuleMachine.ts
 const noOpFlowModuleMachine = setup({}).createMachine({
@@ -248,8 +248,7 @@ function createFlowManager(options) {
 	return attachFlowEventEmitter(createManager({
 		actor: createFlowActor(options),
 		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation("FLOW")
+		createApi
 	}));
 }
 
@@ -809,8 +808,7 @@ function createOrchestratedFlowManager(options) {
 	return attachFlowEventEmitter(createManager({
 		actor,
 		mapState: (snapshot) => mapOrchestratedFlowState(snapshot, uiOpts),
-		createApi: (apiOpts) => createOrchestratedFlowApi(apiOpts, { enableHome }),
-		instrumentation: createManagerInstrumentation("FLOW")
+		createApi: (apiOpts) => createOrchestratedFlowApi(apiOpts, { enableHome })
 	}));
 }
 

package/dist/{flowCompletionService-DKHUsKiX.esm.js → flowCompletionService-DhTdMWSB.esm.js}

@@ -1,5 +1,5 @@
 import { t as api } from "./api-3IquGyW5.esm.js";
-import { v as endpoints } from "./events-237AXtL7.esm.js";
+import { v as endpoints } from "./events-s0VL5FYh.esm.js";
 
 //#region src/modules/flow/flowCompletionService.ts
 const getFinishStatus = async (flowId, signal) => {

package/dist/{flowServices-Bh4UKZez.esm.js → flowServices-QTK0C4Ek.esm.js}

@@ -1,6 +1,6 @@
 import { t as api } from "./api-3IquGyW5.esm.js";
-import { v as endpoints } from "./events-237AXtL7.esm.js";
-import { n as getSessionFingerprintResult, r as initializeSession } from "./session-DcLfiFln.esm.js";
+import { v as endpoints } from "./events-s0VL5FYh.esm.js";
+import { n as getSessionFingerprintResult, r as initializeSession } from "./session-oIjERqhS.esm.js";
 
 //#region src/modules/flow/flowUtils.ts
 const WASM_MODULE_PIPELINES = {

package/dist/geolocation.esm.js

@@ -1,8 +1,8 @@
 import "./api-3IquGyW5.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-237AXtL7.esm.js";
-import { a as createActor, o as createManager } from "./xstate.esm-CSiDcEjt.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-s0VL5FYh.esm.js";
+import { a as createActor, o as createManager } from "./xstate.esm-cL1KdW6d.esm.js";
 import "./platform-BtdVAeAg.esm.js";
-import { t as geolocationMachine } from "./geolocationStateMachine-CFsc46Hs.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-BUp3qs8o.esm.js";
 
 //#region ../infra/src/providers/browser/BrowserGeolocationProvider.ts
 var BrowserGeolocationProvider = class {

package/dist/{geolocationStateMachine-CFsc46Hs.esm.js → geolocationStateMachine-BUp3qs8o.esm.js}

@@ -1,6 +1,6 @@
 import { t as api } from "./api-3IquGyW5.esm.js";
-import { v as endpoints } from "./events-237AXtL7.esm.js";
-import { i as fromPromise, n as assign, t as setup } from "./xstate.esm-CSiDcEjt.esm.js";
+import { v as endpoints } from "./events-s0VL5FYh.esm.js";
+import { i as fromPromise, n as assign, t as setup } from "./xstate.esm-cL1KdW6d.esm.js";
 import { r as isIOS, t as isAndroid } from "./platform-BtdVAeAg.esm.js";
 
 //#region src/modules/geolocation/geolocationServices.ts

package/dist/government-validation.esm.js

@@ -1,8 +1,8 @@
 import "./api-3IquGyW5.esm.js";
-import { o as createManagerInstrumentation } from "./events-237AXtL7.esm.js";
-import { a as createActor, o as createManager } from "./xstate.esm-CSiDcEjt.esm.js";
+import { o as createManagerInstrumentation } from "./events-s0VL5FYh.esm.js";
+import { a as createActor, o as createManager } from "./xstate.esm-cL1KdW6d.esm.js";
 import "./BrowserTimerProvider-Bc6BRm6-.esm.js";
-import { t as governmentValidationMachine } from "./governmentValidationStateMachine-BGGZE44p.esm.js";
+import { t as governmentValidationMachine } from "./governmentValidationStateMachine-DBAuZdbq.esm.js";
 
 //#region src/modules/government-validation/governmentValidationActor.ts
 function createGovernmentValidationActor(options) {

package/dist/{governmentValidationStateMachine-BGGZE44p.esm.js → governmentValidationStateMachine-DBAuZdbq.esm.js}

@@ -1,6 +1,6 @@
 import { t as api } from "./api-3IquGyW5.esm.js";
-import { v as endpoints } from "./events-237AXtL7.esm.js";
-import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-CSiDcEjt.esm.js";
+import { v as endpoints } from "./events-s0VL5FYh.esm.js";
+import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-cL1KdW6d.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-Bc6BRm6-.esm.js";
 
 //#region src/modules/government-validation/governmentValidationServices.ts

package/dist/home.d.ts

@@ -2,7 +2,7 @@ import { t as Manager } from "./Manager-CcbnIt3T.js";
 import "./camera-CS1twtEg.js";
 import "./types-DdYIMV6w.js";
 import { t as EmptyConfig } from "./types-DFwAuzk2.js";
-import * as xstate1246 from "xstate";
+import * as xstate461 from "xstate";
 
 //#region src/modules/home/types.d.ts
 type HomeConfig = EmptyConfig;
@@ -34,41 +34,41 @@ type HomeContext = {
 type HomeInput = {
   config: EmptyConfig;
 };
-declare const homeMachine: xstate1246.StateMachine<HomeContext, {
+declare const homeMachine: xstate461.StateMachine<HomeContext, {
   type: "LOAD";
 } | {
   type: "COMPLETE";
 } | {
   type: "RESET";
-}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate1246.NonReducibleUnknown, xstate1246.EventObject, xstate1246.MetaObject, {
+}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate461.NonReducibleUnknown, xstate461.EventObject, xstate461.MetaObject, {
   readonly id: "home";
   readonly initial: "idle";
   readonly context: ({
     input
   }: {
     spawn: {
-      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate1246.ActorRefFromLogic<never>;
-      <TLogic extends xstate1246.AnyActorLogic>(src: TLogic, ...[options]: xstate1246.ConditionalRequired<[options?: ({
+      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate461.ActorRefFromLogic<never>;
+      <TLogic extends xstate461.AnyActorLogic>(src: TLogic, ...[options]: xstate461.ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate1246.InputFrom<TLogic> | undefined;
+        input?: xstate461.InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate1246.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate1246.IsNotNever<xstate1246.RequiredLogicInput<TLogic>>>): xstate1246.ActorRefFromLogic<TLogic>;
+      } & { [K in xstate461.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate461.IsNotNever<xstate461.RequiredLogicInput<TLogic>>>): xstate461.ActorRefFromLogic<TLogic>;
     };
     input: HomeInput;
-    self: xstate1246.ActorRef<xstate1246.MachineSnapshot<HomeContext, {
+    self: xstate461.ActorRef<xstate461.MachineSnapshot<HomeContext, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, Record<string, xstate1246.AnyActorRef | undefined>, xstate1246.StateValue, string, unknown, any, any>, {
+    }, Record<string, xstate461.AnyActorRef | undefined>, xstate461.StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, xstate1246.AnyEventObject>;
+    }, xstate461.AnyEventObject>;
   }) => {
     config: EmptyConfig;
   };

package/dist/home.esm.js

@@ -1,6 +1,6 @@
 import "./api-3IquGyW5.esm.js";
-import { o as createManagerInstrumentation } from "./events-237AXtL7.esm.js";
-import { a as createActor, o as createManager, t as setup } from "./xstate.esm-CSiDcEjt.esm.js";
+import { o as createManagerInstrumentation } from "./events-s0VL5FYh.esm.js";
+import { a as createActor, o as createManager, t as setup } from "./xstate.esm-cL1KdW6d.esm.js";
 
 //#region src/modules/home/homeStateMachine.ts
 const homeMachine = setup({ types: {