@incodetech/core 0.0.0-dev-20260717-87fac45b → 0.0.0-dev-20260717-8aab9f6d

package/dist/geolocationManager-BOuGkRoP.d.ts

@@ -0,0 +1,500 @@
+import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, i as ActorRefFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.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;
+  /**
+   * Maximum number of backend submit attempts before the error screen stops
+   * offering "Try again" and falls back to skip/quit.
+   * @default 3
+   */
+  maxAttempts?: number;
+};
+type AddGeolocationParams = {
+  latitude: number;
+  longitude: number;
+};
+//#endregion
+//#region src/modules/geolocation/geolocationStateMachine.d.ts
+type GeolocationDeviceType = 'ios' | 'android' | 'desktop';
+type GeolocationContext = {
+  config: GeolocationConfig;
+  geolocation: IGeolocationCapability;
+  coords: AddGeolocationParams | undefined;
+  location: string | null | undefined;
+  deviceType: GeolocationDeviceType;
+  attemptsRemaining: number;
+};
+type GeolocationInput = {
+  config: GeolocationConfig;
+  geolocation: IGeolocationCapability;
+};
+declare const geolocationMachine: StateMachine<GeolocationContext, {
+  type: "REQUEST";
+} | {
+  type: "CONTINUE";
+} | {
+  type: "SKIP";
+} | {
+  type: "RETRY";
+} | {
+  type: "QUIT";
+}, {
+  [x: string]: ActorRefFromLogic<PromiseActorLogic<AddGeolocationParams, {
+    geolocation: IGeolocationCapability;
+  }, EventObject>> | ActorRefFromLogic<PromiseActorLogic<{
+    location: string | null;
+  }, AddGeolocationParams, EventObject>> | undefined;
+}, Values<{
+  requestPosition: {
+    src: "requestPosition";
+    logic: PromiseActorLogic<AddGeolocationParams, {
+      geolocation: IGeolocationCapability;
+    }, EventObject>;
+    id: string | undefined;
+  };
+  submitPosition: {
+    src: "submitPosition";
+    logic: PromiseActorLogic<{
+      location: string | null;
+    }, AddGeolocationParams, EventObject>;
+    id: string | undefined;
+  };
+}>, Values<{
+  setCoords: {
+    type: "setCoords";
+    params: NonReducibleUnknown;
+  };
+  setLocation: {
+    type: "setLocation";
+    params: NonReducibleUnknown;
+  };
+  setDeviceType: {
+    type: "setDeviceType";
+    params: NonReducibleUnknown;
+  };
+  decrementAttemptsRemaining: {
+    type: "decrementAttemptsRemaining";
+    params: NonReducibleUnknown;
+  };
+}>, Values<{
+  canSkip: {
+    type: "canSkip";
+    params: unknown;
+  };
+  hasAttemptsRemaining: {
+    type: "hasAttemptsRemaining";
+    params: unknown;
+  };
+  isNetworkError: {
+    type: "isNetworkError";
+    params: unknown;
+  };
+  isPermissionDenied: {
+    type: "isPermissionDenied";
+    params: unknown;
+  };
+}>, never, "error" | "idle" | "finished" | "requestingLocation" | "submitting" | "permissionDenied" | "locationAcquired" | "noNetwork", string, GeolocationInput, NonReducibleUnknown, EventObject, MetaObject, {
+  readonly id: "geolocation";
+  readonly initial: "idle";
+  readonly context: ({ input }: {
+    spawn: {
+      <TSrc extends "requestPosition" | "submitPosition">(logic: TSrc, ...[options]: ({
+        src: "requestPosition";
+        logic: PromiseActorLogic<AddGeolocationParams, {
+          geolocation: IGeolocationCapability;
+        }, EventObject>;
+        id: string | undefined;
+      } extends (infer T) ? T extends {
+        src: "requestPosition";
+        logic: PromiseActorLogic<AddGeolocationParams, {
+          geolocation: IGeolocationCapability;
+        }, EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "submitPosition";
+        logic: PromiseActorLogic<{
+          location: string | null;
+        }, AddGeolocationParams, EventObject>;
+        id: string | undefined;
+      } extends (infer T_1) ? T_1 extends {
+        src: "submitPosition";
+        logic: PromiseActorLogic<{
+          location: string | null;
+        }, AddGeolocationParams, EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never)): ActorRefFromLogic<GetConcreteByKey<Values<{
+        requestPosition: {
+          src: "requestPosition";
+          logic: PromiseActorLogic<AddGeolocationParams, {
+            geolocation: IGeolocationCapability;
+          }, EventObject>;
+          id: string | undefined;
+        };
+        submitPosition: {
+          src: "submitPosition";
+          logic: PromiseActorLogic<{
+            location: string | null;
+          }, AddGeolocationParams, EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
+    };
+    input: GeolocationInput;
+    self: ActorRef<MachineSnapshot<GeolocationContext, {
+      type: "REQUEST";
+    } | {
+      type: "CONTINUE";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "QUIT";
+    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
+      type: "REQUEST";
+    } | {
+      type: "CONTINUE";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "QUIT";
+    }, AnyEventObject>;
+  }) => {
+    config: GeolocationConfig;
+    geolocation: IGeolocationCapability;
+    coords: undefined;
+    location: undefined;
+    deviceType: GeolocationDeviceType;
+    attemptsRemaining: number;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly REQUEST: {
+          readonly target: "requestingLocation";
+        };
+      };
+    };
+    readonly requestingLocation: {
+      readonly invoke: {
+        readonly id: "requestPosition";
+        readonly src: "requestPosition";
+        readonly input: ({ context }: {
+          context: GeolocationContext;
+          event: {
+            type: "REQUEST";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "QUIT";
+          };
+          self: ActorRef<MachineSnapshot<GeolocationContext, {
+            type: "REQUEST";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "QUIT";
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+            type: "REQUEST";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "QUIT";
+          }, AnyEventObject>;
+        }) => {
+          geolocation: IGeolocationCapability;
+        };
+        readonly onDone: {
+          readonly target: "submitting";
+          readonly actions: "setCoords";
+        };
+        readonly onError: readonly [{
+          readonly target: "permissionDenied";
+          readonly guard: "isPermissionDenied";
+          readonly actions: "setDeviceType";
+        }, {
+          readonly target: "error";
+          readonly actions: "decrementAttemptsRemaining";
+        }];
+      };
+    };
+    readonly submitting: {
+      readonly invoke: {
+        readonly id: "submitPosition";
+        readonly src: "submitPosition";
+        readonly input: ({ context }: {
+          context: GeolocationContext;
+          event: {
+            type: "REQUEST";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "QUIT";
+          };
+          self: ActorRef<MachineSnapshot<GeolocationContext, {
+            type: "REQUEST";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "QUIT";
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+            type: "REQUEST";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "SKIP";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "QUIT";
+          }, AnyEventObject>;
+        }) => {
+          latitude: number;
+          longitude: number;
+        };
+        readonly onDone: {
+          readonly target: "locationAcquired";
+          readonly actions: "setLocation";
+        };
+        readonly onError: readonly [{
+          readonly target: "noNetwork";
+          readonly guard: "isNetworkError";
+        }, {
+          readonly target: "error";
+          readonly actions: "decrementAttemptsRemaining";
+        }];
+      };
+    };
+    readonly noNetwork: {};
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "idle";
+          readonly guard: "hasAttemptsRemaining";
+        };
+        readonly SKIP: {
+          readonly target: "finished";
+          readonly guard: "canSkip";
+        };
+        readonly QUIT: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly locationAcquired: {
+      readonly on: {
+        readonly CONTINUE: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly permissionDenied: {
+      readonly on: {
+        readonly SKIP: {
+          readonly target: "finished";
+          readonly guard: "canSkip";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+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;
+};
+type GeolocationErrorState = {
+  status: 'error';
+  attemptsRemaining: number;
+  canSkip: boolean;
+};
+/**
+ * A backend request failed due to lost connectivity (device offline/network
+ * error) = the user refreshes once the connection returns.
+ */
+type GeolocationNoNetworkState = {
+  status: 'noNetwork';
+};
+/**
+ * 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 | GeolocationErrorState | GeolocationNoNetworkState | 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;
+  retry(): void;
+  quit(): 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;
+  retry(): void;
+  quit(): 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/{geolocationManager-D58ehBHU.esm.js → geolocationManager-CUchGjvz.esm.js}

@@ -1,6 +1,6 @@
 import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dy8PyVO5.esm.js";
 import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
-import { t as geolocationMachine } from "./geolocationStateMachine-BorcBNZ6.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-DRAULUHq.esm.js";
 //#region ../infra/src/providers/browser/BrowserGeolocationProvider.ts
 var BrowserGeolocationProvider = class {
 	getCurrentPosition() {
@@ -8,7 +8,7 @@ var BrowserGeolocationProvider = class {
 			navigator.geolocation.getCurrentPosition((pos) => resolve({
 				latitude: pos.coords.latitude,
 				longitude: pos.coords.longitude
-			}), reject);
+			}), (err) => reject(Object.assign(new Error(err.message), { code: err.code })));
 		});
 	}
 };
@@ -32,11 +32,17 @@ function createGeolocationActor(options) {
 * 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.
+* Failure mapping: a device-level failure (`requestPosition` `onError`) splits
+* by `GeolocationPositionError.code` — a real permission denial (code 1) routes
+* to `permissionDenied` (device-specific "enable location" instructions), while
+* a transient failure (position unavailable / timeout, e.g. the browser's
+* `kCLErrorLocationUnknown`) routes to the attempt-limited `error` state so the
+* user can retry. A backend submit failure (`submitPosition` `onError`) splits
+* by cause: a connectivity error routes to `noNetwork`
+* (`Geolocation.error.noNetwork`), while a server-side rejection routes to the
+* same attempt-limited `error` state (`Geolocation.error`). The deferred Figma
+* sub-screen `Geolocation.error.locationUnavailable` shares the `Geolocation.error`
+* screen name for now rather than emitting a distinct one.
 */
 function getGeolocationScreenName(snapshot) {
 	const { value } = snapshot;
@@ -48,6 +54,8 @@ function getGeolocationScreenName(snapshot) {
 		case "locationAcquired":
 		case "finished": return "Geolocation.continue";
 		case "permissionDenied": return "Geolocation.allowLocation";
+		case "error": return "Geolocation.error";
+		case "noNetwork": return "Geolocation.error.noNetwork";
 		default: return;
 	}
 }
@@ -66,6 +74,12 @@ function mapState(snapshot) {
 		deviceType: context.deviceType,
 		canSkip: context.config.allowUserToSkipGeolocation === true
 	};
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		attemptsRemaining: context.attemptsRemaining,
+		canSkip: context.config.allowUserToSkipGeolocation === true
+	};
+	if (typedSnapshot.matches("noNetwork")) return { status: "noNetwork" };
 	if (typedSnapshot.matches("finished")) return { status: "finished" };
 	return { status: "idle" };
 }
@@ -95,11 +109,13 @@ function createApi({ actor, trackElementClicked }) {
 			trackElementClicked?.("skip");
 			actor.send({ type: "SKIP" });
 		},
-		/**
-		* Resets the manager back to initial state.
-		*/
-		reset() {
-			actor.send({ type: "RESET" });
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		quit() {
+			trackElementClicked?.("quit");
+			actor.send({ type: "QUIT" });
 		}
 	};
 }

package/dist/{geolocationStateMachine-BorcBNZ6.esm.js → geolocationStateMachine-DRAULUHq.esm.js}

@@ -3,6 +3,7 @@ import { t as endpoints } from "./endpoints-DLQ0g4-R.esm.js";
 import { r as isIOS, t as isAndroid } from "./platform-wmV7oTAJ.esm.js";
 import { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
+import { n as isConnectivityError } from "./apiError-B-PkYxln.esm.js";
 //#region src/modules/geolocation/geolocationServices.ts
 async function addGeolocation(params, signal) {
 	const res = await api.post(endpoints.addGeolocation, {
@@ -19,6 +20,16 @@ function detectDeviceType() {
 	if (isAndroid()) return "android";
 	return "desktop";
 }
+const DEFAULT_MAX_ATTEMPTS = 3;
+/**
+* `GeolocationPositionError.PERMISSION_DENIED`. Only this code means the user
+* has to change a setting; the other codes (`POSITION_UNAVAILABLE`, `TIMEOUT`)
+* are transient device failures that route to the retryable `error` flow.
+*/
+const GEOLOCATION_PERMISSION_DENIED = 1;
+function resolveMaxAttempts(config) {
+	return config.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+}
 const geolocationMachine = setup({
 	types: {
 		context: {},
@@ -30,26 +41,21 @@ const geolocationMachine = setup({
 			return input.geolocation.getCurrentPosition();
 		}),
 		submitPosition: fromPromise(async ({ input, signal }) => {
-			try {
-				return await addGeolocation(input, signal);
-			} catch {
-				return { location: null };
-			}
+			return await addGeolocation(input, signal);
 		})
 	},
 	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()
-		}))
+		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 }))
 	},
-	guards: { canSkip: ({ context }) => context.config.allowUserToSkipGeolocation === true }
+	guards: {
+		canSkip: ({ context }) => context.config.allowUserToSkipGeolocation === true,
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
+		isNetworkError: ({ event }) => isConnectivityError(event.error),
+		isPermissionDenied: ({ event }) => event.error?.code === GEOLOCATION_PERMISSION_DENIED
+	}
 }).createMachine({
 	id: "geolocation",
 	initial: "idle",
@@ -58,7 +64,8 @@ const geolocationMachine = setup({
 		geolocation: input.geolocation,
 		coords: void 0,
 		location: void 0,
-		deviceType: detectDeviceType()
+		deviceType: detectDeviceType(),
+		attemptsRemaining: resolveMaxAttempts(input.config)
 	}),
 	states: {
 		idle: { on: { REQUEST: { target: "requestingLocation" } } },
@@ -70,10 +77,14 @@ const geolocationMachine = setup({
 				target: "submitting",
 				actions: "setCoords"
 			},
-			onError: {
+			onError: [{
 				target: "permissionDenied",
+				guard: "isPermissionDenied",
 				actions: "setDeviceType"
-			}
+			}, {
+				target: "error",
+				actions: "decrementAttemptsRemaining"
+			}]
 		} },
 		submitting: { invoke: {
 			id: "submitPosition",
@@ -86,10 +97,25 @@ const geolocationMachine = setup({
 				target: "locationAcquired",
 				actions: "setLocation"
 			},
-			onError: {
-				target: "locationAcquired",
-				actions: assign({ location: () => null })
-			}
+			onError: [{
+				target: "noNetwork",
+				guard: "isNetworkError"
+			}, {
+				target: "error",
+				actions: "decrementAttemptsRemaining"
+			}]
+		} },
+		noNetwork: {},
+		error: { on: {
+			RETRY: {
+				target: "idle",
+				guard: "hasAttemptsRemaining"
+			},
+			SKIP: {
+				target: "finished",
+				guard: "canSkip"
+			},
+			QUIT: { target: "finished" }
 		} },
 		locationAcquired: { on: { CONTINUE: { target: "finished" } } },
 		permissionDenied: { on: { SKIP: {

package/dist/id-ocr.d.ts

@@ -1,4 +1,4 @@
-import { a as IdOcrActor, c as IdOcrConfig, d as UpdateOcrDataParams, f as ValidationRule, i as createIdOcrManagerFromActor, l as OcrData, n as IdOcrState, o as IdOcrOcrDocument, r as createIdOcrManager, s as idOcrStateMachine, t as IdOcrManager, u as OcrFieldConfig } from "./idOcrManager-vXa7GdRh.js";
+import { a as IdOcrActor, c as IdOcrConfig, d as UpdateOcrDataParams, f as ValidationRule, i as createIdOcrManagerFromActor, l as OcrData, n as IdOcrState, o as IdOcrOcrDocument, r as createIdOcrManager, s as idOcrStateMachine, t as IdOcrManager, u as OcrFieldConfig } from "./idOcrManager-B-JyjyPb.js";
 //#region src/modules/id-ocr/idOcrFields.d.ts
 declare const OCR_FIELDS: OcrFieldConfig[];
 declare const getOcrFields: (config: Pick<IdOcrConfig, "flowId">) => OcrFieldConfig[];