@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.3

package/dist/geolocationManager-BP2Do9O-.esm.js

@@ -0,0 +1,123 @@
+import { n as createManagerInstrumentation } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import { l as createManager, s as createActor } from "./xstate.esm-Bomq1a0z.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-BYfOOOG0.esm.js";
+
+//#region ../infra/src/providers/browser/BrowserGeolocationProvider.ts
+var BrowserGeolocationProvider = class {
+	getCurrentPosition() {
+		return new Promise((resolve, reject) => {
+			navigator.geolocation.getCurrentPosition((pos) => resolve({
+				latitude: pos.coords.latitude,
+				longitude: pos.coords.longitude
+			}), reject);
+		});
+	}
+};
+
+//#endregion
+//#region src/modules/geolocation/geolocationActor.ts
+function createGeolocationActor(options) {
+	const geolocation = options.geolocation ?? new BrowserGeolocationProvider();
+	return createActor(geolocationMachine, { input: {
+		config: options.config,
+		geolocation
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/geolocation/geolocationManager.ts
+/**
+* Maps a Geolocation state-machine snapshot to the exact Figma "Tracked
+* Events" screen name. Returned strings are the absolute analytics screen
+* (module prefix included) and are emitted verbatim by
+* `createManagerInstrumentation`'s `getEventScreenName` short-circuit.
+*
+* Source of truth: Geolocation Figma file → Tracked Events canvas
+* (`https://www.figma.com/design/xg1t3GnUS95A4bLrM3lyOG/Geolocation---Latest-Design?node-id=2652-17008`).
+*
+* Deferred Figma screens that have no state-machine counterpart yet:
+* `Geolocation.error.locationUnavailable` and `Geolocation.error.noNetwork`.
+* Both kinds of failure currently collapse into `permissionDenied`
+* (`requestPosition` `onError`) or `locationAcquired` with `location: null`
+* (`submitPosition` `onError`), so the machine cannot distinguish them today.
+*/
+function getGeolocationScreenName(snapshot) {
+	const { value } = snapshot;
+	if (typeof value !== "string") return void 0;
+	switch (value) {
+		case "idle": return "Geolocation.default";
+		case "requestingLocation":
+		case "submitting": return "Geolocation.permission";
+		case "locationAcquired":
+		case "finished": return "Geolocation.continue";
+		case "permissionDenied": return "Geolocation.allowLocation";
+		default: return;
+	}
+}
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("requestingLocation")) return { status: "requestingLocation" };
+	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
+	if (typedSnapshot.matches("locationAcquired")) return {
+		status: "locationAcquired",
+		location: context.location ?? null
+	};
+	if (typedSnapshot.matches("permissionDenied")) return {
+		status: "permissionDenied",
+		deviceType: context.deviceType,
+		canSkip: context.config.allowUserToSkipGeolocation === true
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		request() {
+			trackElementClicked?.("request");
+			actor.send({ type: "REQUEST" });
+		},
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		},
+		skip() {
+			trackElementClicked?.("skip");
+			actor.send({ type: "SKIP" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+/**
+* Creates a geolocation manager for headless or UI-driven usage.
+*
+* @example Headless usage
+* ```typescript
+* const manager = createGeolocationManager({ config: { allowUserToSkipGeolocation: true } });
+* manager.subscribe((state) => console.log(state.status));
+* manager.request();
+* ```
+*/
+function createGeolocationManager(options) {
+	return createGeolocationManagerFromActor(createGeolocationActor(options));
+}
+/**
+* Creates a geolocation manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createGeolocationManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.geolocation, { getEventScreenName: getGeolocationScreenName })
+	});
+}
+
+//#endregion
+export { createGeolocationManagerFromActor as n, createGeolocationManager as t };

package/dist/geolocationManager-Cs50eRlC.d.ts

@@ -0,0 +1,156 @@
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import { t as ActorRefFrom } from "./Actor-CGEelYtQ.js";
+
+//#region ../infra/src/capabilities/IGeolocationCapability.d.ts
+type GeolocationCoords = {
+  latitude: number;
+  longitude: number;
+};
+type IGeolocationCapability = {
+  getCurrentPosition(): Promise<GeolocationCoords>;
+};
+//#endregion
+//#region src/modules/geolocation/types.d.ts
+/**
+ * Configuration options for the Geolocation module.
+ *
+ * @example
+ * ```typescript
+ * const config: GeolocationConfig = {
+ *   allowUserToSkipGeolocation: true,
+ * };
+ * ```
+ */
+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
+   */
+  allowUserToSkipGeolocation?: boolean;
+};
+//#endregion
+//#region src/modules/geolocation/geolocationStateMachine.d.ts
+type GeolocationDeviceType = 'ios' | 'android' | 'desktop';
+declare const geolocationMachine: any;
+type GeolocationMachine = typeof geolocationMachine;
+//#endregion
+//#region src/modules/geolocation/geolocationActor.d.ts
+type CreateGeolocationActorOptions = {
+  config: GeolocationConfig;
+  geolocation?: IGeolocationCapability;
+};
+type GeolocationActor = ActorRefFrom<GeolocationMachine>;
+//#endregion
+//#region src/modules/geolocation/geolocationManager.d.ts
+
+/** Geolocation manager is in initial state, waiting for `request()` to be called */
+type GeolocationIdleState = {
+  status: 'idle';
+};
+/** Browser geolocation permission prompt is active */
+type GeolocationRequestingState = {
+  status: 'requestingLocation';
+};
+/** Coordinates are being submitted to the backend */
+type GeolocationSubmittingState = {
+  status: 'submitting';
+};
+/**
+ * Location successfully acquired — call `continue()` to proceed
+ * @property location - Location name returned from backend, or null
+ */
+type GeolocationAcquiredState = {
+  status: 'locationAcquired';
+  location: string | null;
+};
+/**
+ * User denied geolocation permission — shows device-specific instructions
+ * @property deviceType - Used by UI to render the correct instruction panel
+ * @property canSkip - Whether the skip button should be shown
+ */
+type GeolocationPermissionDeniedState = {
+  status: 'permissionDenied';
+  deviceType: GeolocationDeviceType;
+  canSkip: boolean;
+};
+/** Geolocation flow completed successfully */
+type GeolocationFinishedState = {
+  status: 'finished';
+};
+/**
+ * Union of all possible geolocation manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = geolocationManager.getState();
+ * if (state.status === 'locationAcquired') {
+ *   console.log(state.location);
+ * }
+ * if (state.status === 'permissionDenied') {
+ *   console.log(state.deviceType); // 'ios' | 'android' | 'desktop'
+ * }
+ * ```
+ */
+type GeolocationState = GeolocationIdleState | GeolocationRequestingState | GeolocationSubmittingState | GeolocationAcquiredState | GeolocationPermissionDeniedState | GeolocationFinishedState;
+/**
+ * Creates a geolocation manager for headless or UI-driven usage.
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createGeolocationManager({ config: { allowUserToSkipGeolocation: true } });
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.request();
+ * ```
+ */
+declare function createGeolocationManager(options: CreateGeolocationActorOptions): Manager<GeolocationState> & {
+  /**
+   * Initiates the browser geolocation permission request.
+   * Transitions from 'idle' to 'requestingLocation'.
+   */
+  request(): void;
+  /**
+   * Confirms the acquired location and completes the module.
+   * Should be called when state is 'locationAcquired'.
+   */
+  continue(): void;
+  /**
+   * Skips geolocation when the user has denied permission.
+   * Only works when `config.allowUserToSkipGeolocation` is true.
+   */
+  skip(): void;
+  /**
+   * Resets the manager back to initial state.
+   */
+  reset(): void;
+};
+/**
+ * Creates a geolocation manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or for story-isolation testing.
+ */
+declare function createGeolocationManagerFromActor(actor: GeolocationActor): Manager<GeolocationState> & {
+  /**
+   * Initiates the browser geolocation permission request.
+   * Transitions from 'idle' to 'requestingLocation'.
+   */
+  request(): void;
+  /**
+   * Confirms the acquired location and completes the module.
+   * Should be called when state is 'locationAcquired'.
+   */
+  continue(): void;
+  /**
+   * Skips geolocation when the user has denied permission.
+   * Only works when `config.allowUserToSkipGeolocation` is true.
+   */
+  skip(): void;
+  /**
+   * Resets the manager back to initial state.
+   */
+  reset(): void;
+};
+type GeolocationManager = ReturnType<typeof createGeolocationManager>;
+//#endregion
+export { GeolocationActor as a, createGeolocationManagerFromActor as i, GeolocationState as n, geolocationMachine as o, createGeolocationManager as r, GeolocationConfig as s, GeolocationManager as t };

package/dist/{geolocationStateMachine-Dvh7X0wF.esm.js → geolocationStateMachine-BYfOOOG0.esm.js}

@@ -1,7 +1,7 @@
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { r as isIOS, t as isAndroid } from "./platform-SKvEfCBh.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { r as isIOS, t as isAndroid } from "./platform-uIVQUnJP.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
 
 //#region src/modules/geolocation/geolocationServices.ts
 async function addGeolocation(params, signal) {

package/dist/{getDeviceClass-C8Do2qYu.esm.js → getDeviceClass-DGGzzfqm.esm.js}

@@ -1,4 +1,4 @@
-import { t as getDeviceInfo } from "./getDeviceClass-C0olyNFS.esm.js";
+import { t as getDeviceInfo } from "./getDeviceClass-DavNdcxh.esm.js";
 
 //#region src/internal/device/getDeviceClass.ts
 function getDeviceClass() {

package/dist/getDeviceData-TrKM8NPh.esm.js

@@ -0,0 +1,101 @@
+import { i as getParsedUserAgent } from "./browserSimulation-TsSoavQv.esm.js";
+
+//#region ../infra/src/device/getDeviceData.ts
+const HIGH_ENTROPY_HINTS = new Set([
+	"model",
+	"platformVersion",
+	"fullVersionList",
+	"brands",
+	"platform"
+]);
+function getFallbackDeviceInfo() {
+	const parsed = getParsedUserAgent();
+	return {
+		device: { model: parsed.device.model },
+		os: {
+			name: parsed.os.name,
+			version: parsed.os.version
+		},
+		browser: {
+			name: parsed.browser.name,
+			version: parsed.browser.version
+		}
+	};
+}
+function sanitizeString(value) {
+	return value?.trim() || void 0;
+}
+function extractPrimaryBrandInfo(fullVersionList, brands) {
+	const primaryBrand = fullVersionList?.[0] || brands?.[0];
+	return {
+		name: sanitizeString(primaryBrand?.brand),
+		version: sanitizeString(primaryBrand?.version)
+	};
+}
+async function getHighEntropyDeviceInfo(userAgentData) {
+	const highEntropyValues = await userAgentData.getHighEntropyValues(Array.from(HIGH_ENTROPY_HINTS));
+	const { name: browserName, version: browserVersion } = extractPrimaryBrandInfo(highEntropyValues.fullVersionList, userAgentData.brands);
+	return {
+		device: { model: sanitizeString(highEntropyValues.model) },
+		os: {
+			name: sanitizeString(highEntropyValues.platform),
+			version: sanitizeString(highEntropyValues.platformVersion)
+		},
+		browser: {
+			name: browserName,
+			version: browserVersion
+		}
+	};
+}
+const checkForUnbrandedBrowser = (browser) => {
+	const userAgent = typeof navigator !== "undefined" ? navigator.userAgent : "";
+	const fallback = getFallbackDeviceInfo();
+	if (!userAgent) return browser;
+	try {
+		return {
+			...browser,
+			name: fallback.browser.name,
+			version: fallback.browser.version
+		};
+	} catch {
+		return {
+			...browser,
+			name: "Unknown",
+			version: "Unknown"
+		};
+	}
+};
+function mergeDeviceInfo(fallback, enhanced) {
+	return {
+		device: { model: enhanced.device?.model || fallback.device.model },
+		os: {
+			name: enhanced.os?.name || fallback.os.name,
+			version: enhanced.os?.version || fallback.os.version
+		},
+		browser: checkForUnbrandedBrowser({
+			name: enhanced.browser?.name || fallback.browser.name,
+			version: enhanced.browser?.version || fallback.browser.version
+		})
+	};
+}
+function isUserAgentClientHintsSupported(navigator$1) {
+	return Boolean(navigator$1.userAgentData?.getHighEntropyValues && typeof navigator$1.userAgentData.getHighEntropyValues === "function");
+}
+async function getDeviceFingerprintInfo() {
+	if (typeof navigator === "undefined") return {
+		device: {},
+		os: {},
+		browser: {}
+	};
+	const customNavigator = navigator;
+	const fallbackInfo = getFallbackDeviceInfo();
+	if (!isUserAgentClientHintsSupported(customNavigator)) return fallbackInfo;
+	try {
+		return mergeDeviceInfo(fallbackInfo, await getHighEntropyDeviceInfo(customNavigator.userAgentData));
+	} catch {
+		return fallbackInfo;
+	}
+}
+
+//#endregion
+export { getDeviceFingerprintInfo as t };

package/dist/government-validation.d.ts

@@ -1,6 +1,7 @@
-import { t as Manager } from "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
-import { t as OtpValidationErrors } from "./otp-DF5A0sFx.js";
+import "./StateMachine-C_AY4cs7.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import "./Actor-CGEelYtQ.js";
+import { t as OtpValidationErrors } from "./otp-M4iy57XY.js";
 
 //#region src/modules/government-validation/types.d.ts
 type GovernmentValidationConfig = {

package/dist/government-validation.esm.js

@@ -1,10 +1,11 @@
-import "./BrowserTimerProvider-DhNc_x02.esm.js";
-import "./api-CESGtpbH.esm.js";
-import { o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
-import { t as OTP_CODE_LENGTH } from "./otp-CGMdUzBC.esm.js";
-import { t as governmentValidationMachine } from "./governmentValidationStateMachine-DcJ-BfsC.esm.js";
+import "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import { n as createManagerInstrumentation, t as topLevelStateName } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import "./endpoints-BzMJFAPV.esm.js";
+import { l as createManager, s as createActor } from "./xstate.esm-Bomq1a0z.esm.js";
+import { t as OTP_CODE_LENGTH } from "./otp-Bfnzf7I3.esm.js";
+import { t as governmentValidationMachine } from "./governmentValidationStateMachine-CwoPPO8b.esm.js";
 
 //#region src/modules/government-validation/governmentValidationActor.ts
 function createGovernmentValidationActor(options) {
@@ -13,6 +14,40 @@ function createGovernmentValidationActor(options) {
 
 //#endregion
 //#region src/modules/government-validation/governmentValidationManager.ts
+/**
+* Maps a Government Validation state-machine snapshot to the exact Figma
+* "Tracked Events" screen name. Source: Government Record Verification
+* Figma file (`https://www.figma.com/design/5J4kaLMl19s8cLyRMUMW32/Government-Record-Verification---Latest-Design?node-id=25911-4095`).
+* Family is `GovernmentRecordValidation.*` (PascalCase verbatim from
+* Figma); spans the background record-lookup flow only. The mapper returns
+* Figma-verbatim spellings which the adapter emits as-is on `event.screen`
+* (e.g. `GovernmentRecordValidation.analyzing.default`). See
+* `docs/patterns/INSTRUMENTATION.md`.
+*
+* Figma sub-states the state machine does not surface as discrete states
+* (intentionally not mapped here):
+*
+* - The OTP sub-flow (`awaitingOtp`, `verifyingOtp`) is the
+*   INE_VALIDATION variant. Figma does not define screens for it under
+*   this family; those states fall back to the generic
+*   `<module>.<state>` default.
+* - `displayUnknown` reflects an unrecognised API status code. Figma does
+*   not define a tracked-event surface for it.
+*
+* `idle` and `finished` are intentionally unmapped — Figma does not
+* define screens for them and `finished` collapses into `moduleClosed`.
+*/
+function getGovernmentValidationScreenName(snapshot) {
+	const stateName = topLevelStateName(snapshot.value);
+	if (stateName === void 0) return void 0;
+	switch (stateName) {
+		case "loading":
+		case "displayProcessing": return "GovernmentRecordValidation.analyzing.default";
+		case "displaySuccess": return "GovernmentRecordValidation.success.default";
+		case "displayError": return "GovernmentRecordValidation.error.usernotfound";
+		default: return;
+	}
+}
 function mapState(snapshot) {
 	const typedSnapshot = snapshot;
 	const { context } = typedSnapshot;
@@ -84,7 +119,7 @@ function createGovernmentValidationManager(options) {
 		actor: createGovernmentValidationActor(options),
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation("GOVERNMENT_VALIDATION")
+		instrumentation: createManagerInstrumentation(eventModuleNames.governmentValidation, { getEventScreenName: getGovernmentValidationScreenName })
 	});
 }
 

package/dist/{governmentValidationStateMachine-DcJ-BfsC.esm.js → governmentValidationStateMachine-CwoPPO8b.esm.js}

@@ -1,8 +1,8 @@
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
-import { n as computeOtpValidationErrors, r as isOtpComplete } from "./otp-CGMdUzBC.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
+import { n as computeOtpValidationErrors, r as isOtpComplete } from "./otp-Bfnzf7I3.esm.js";
 
 //#region src/modules/government-validation/governmentValidationServices.ts
 async function processGovernmentValidation(signal) {

package/dist/home.d.ts

@@ -1,9 +1,12 @@
-import { t as Manager } from "./Manager-BHn8wH8K.js";
-import "./camera-SRBpPq2X.js";
-import "./types-Bj9hdFjU.js";
-import "./types-DvGZI7BF.js";
-import { t as EmptyConfig } from "./types-DOUhndhT.js";
-import * as xstate1070 from "xstate";
+import "./StateMachine-C_AY4cs7.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import "./camera-CNVUo-bC.js";
+import "./types-DgGlgyZT.js";
+import "./types-D_IceWxT.js";
+import "./canvas-CJUmoXSD.js";
+import "./createFaceAvatar-B8pFpy6o.js";
+import { t as EmptyConfig } from "./types-BsYXnC5s.js";
+import * as xstate1051 from "xstate";
 
 //#region src/modules/home/types.d.ts
 type HomeConfig = EmptyConfig;
@@ -35,41 +38,41 @@ type HomeContext = {
 type HomeInput = {
   config: EmptyConfig;
 };
-declare const homeMachine: xstate1070.StateMachine<HomeContext, {
+declare const homeMachine: xstate1051.StateMachine<HomeContext, {
   type: "LOAD";
 } | {
   type: "COMPLETE";
 } | {
   type: "RESET";
-}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate1070.NonReducibleUnknown, xstate1070.EventObject, xstate1070.MetaObject, {
+}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate1051.NonReducibleUnknown, xstate1051.EventObject, xstate1051.MetaObject, {
   readonly id: "home";
   readonly initial: "idle";
   readonly context: ({
     input
   }: {
     spawn: {
-      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate1070.ActorRefFromLogic<never>;
-      <TLogic extends xstate1070.AnyActorLogic>(src: TLogic, ...[options]: xstate1070.ConditionalRequired<[options?: ({
+      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate1051.ActorRefFromLogic<never>;
+      <TLogic extends xstate1051.AnyActorLogic>(src: TLogic, ...[options]: xstate1051.ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate1070.InputFrom<TLogic> | undefined;
+        input?: xstate1051.InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate1070.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate1070.IsNotNever<xstate1070.RequiredLogicInput<TLogic>>>): xstate1070.ActorRefFromLogic<TLogic>;
+      } & { [K in xstate1051.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate1051.IsNotNever<xstate1051.RequiredLogicInput<TLogic>>>): xstate1051.ActorRefFromLogic<TLogic>;
     };
     input: HomeInput;
-    self: xstate1070.ActorRef<xstate1070.MachineSnapshot<HomeContext, {
+    self: xstate1051.ActorRef<xstate1051.MachineSnapshot<HomeContext, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, Record<string, xstate1070.AnyActorRef | undefined>, xstate1070.StateValue, string, unknown, any, any>, {
+    }, Record<string, xstate1051.AnyActorRef | undefined>, xstate1051.StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, xstate1070.AnyEventObject>;
+    }, xstate1051.AnyEventObject>;
   }) => {
     config: EmptyConfig;
   };

package/dist/home.esm.js

@@ -1,6 +1,7 @@
-import "./api-CESGtpbH.esm.js";
-import { o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
-import { c as createManager, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import { n as createManagerInstrumentation } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import { l as createManager, s as createActor, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
 
 //#region src/modules/home/homeStateMachine.ts
 const homeMachine = setup({ types: {
@@ -53,7 +54,7 @@ function createHomeManager(options = {}) {
 		actor: createHomeActor({ config: options.config }),
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation("HOME")
+		instrumentation: createManagerInstrumentation(eventModuleNames.home)
 	});
 }
 

package/dist/http.d.ts

@@ -54,6 +54,7 @@ type MethodConfig = {
   query?: Record<string, string | number | boolean | undefined>;
   onUploadProgress?: (progress: number) => void;
   keepalive?: boolean;
+  parse?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'response';
 };
 type ApiClient = {
   get<T>(url: string, config?: MethodConfig): Promise<HttpResponse<T>>;

package/dist/http.esm.js

@@ -1,4 +1,4 @@
-import { n as getApi, t as api } from "./api-CESGtpbH.esm.js";
-import "./http-Cai3IoLS.esm.js";
+import { n as getApi, t as api } from "./api-DsbUi7TO.esm.js";
+import "./http-BkiUT7EB.esm.js";
 
 export { api, getApi };