@incodetech/core 2.4.0 → 2.4.1-agentic.1

package/dist/recordingService-CTko6Cjn.esm.js

@@ -0,0 +1,397 @@
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
+import { t as BrowserLazyImportProvider } from "./BrowserLazyImportProvider-BhoA957O.esm.js";
+import { r as createRecordingCompositor } from "./CameraCompositor-DN7NkJzV.esm.js";
+import { t as getAdaptiveMediaRecorderOptions } from "./mediaRecorderOptions-B9-IEVtV.esm.js";
+import { t as WorkerEncoderRecordingProvider } from "./WorkerEncoderRecordingProvider-B1ODYtgN.esm.js";
+import { t as MultipartRecordingService } from "./multipartRecordingService-BTqkHGG9.esm.js";
+//#region ../infra/src/media/VideoTrimmer.ts
+/** A trim that runs longer than this uploads the full recording instead. */
+const TRIM_TIMEOUT_MS = 1e4;
+const trimmer = BrowserLazyImportProvider.getInstance().create(() => import("./videoTrimByCopy-BFfAiNpv.esm.js").then((module) => module.trimLastNSecondsByCopy), {
+	label: "Video liveness",
+	moduleName: "mediabunny",
+	timeoutMs: 1e4,
+	disabledMessage: "the full recording will be uploaded untrimmed."
+});
+/** Starts loading the trimmer, e.g. when a recording that will be trimmed starts. */
+function preloadVideoTrimmer() {
+	trimmer.load();
+}
+/**
+* Keeps about the last `seconds` of a recording. Never rejects and never
+* hangs: when the trimmer cannot load, fails, or takes longer than
+* {@link TRIM_TIMEOUT_MS}, it resolves the untrimmed recording.
+*/
+async function trimLastNSeconds(videoBlob, seconds) {
+	const trim = await trimmer.load();
+	if (!trim) return videoBlob;
+	let timeout;
+	try {
+		return await Promise.race([trim(videoBlob, seconds), new Promise((resolve) => {
+			timeout = setTimeout(() => {
+				console.warn("[Video liveness] Trimming timed out; the full recording will be uploaded untrimmed.");
+				resolve(videoBlob);
+			}, TRIM_TIMEOUT_MS);
+		})]);
+	} catch (error) {
+		console.warn("[Video liveness] Trimming failed; the full recording will be uploaded untrimmed.", error);
+		return videoBlob;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+//#endregion
+//#region ../infra/src/providers/browser/LocalRecordingProvider.ts
+function toBase64(videoBlob) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onloadend = () => {
+			const base64 = reader.result.split(",")[1];
+			resolve(base64);
+		};
+		reader.onerror = () => reject(reader.error ?? /* @__PURE__ */ new Error("FileReader error"));
+		reader.readAsDataURL(videoBlob);
+	});
+}
+/** `MediaRecorderOptions.videoKeyFrameIntervalDuration`, see `startRecording`. */
+const KEYFRAME_INTERVAL_MS = 1e3;
+var LocalRecordingProvider = class {
+	constructor() {
+		this.mediaRecorder = null;
+		this._isRecording = false;
+		this._hasError = false;
+		this._error = null;
+		this.mimeType = "";
+		this.stream = null;
+		this.pauseRecordingBound = this.pauseRecording.bind(this);
+	}
+	get isRecording() {
+		return this._isRecording;
+	}
+	get hasError() {
+		return this._hasError;
+	}
+	get error() {
+		return this._error;
+	}
+	startRecording(stream) {
+		this.reset();
+		preloadVideoTrimmer();
+		this.registerEventListeners();
+		this.stream = stream;
+		try {
+			const options = getAdaptiveMediaRecorderOptions();
+			this.mimeType = options.mimeType;
+			const recorder = new MediaRecorder(stream.clone(), {
+				...options,
+				videoKeyFrameIntervalDuration: KEYFRAME_INTERVAL_MS
+			});
+			recorder.onerror = (event) => {
+				this._error = `Recording error: ${event}`;
+				this._isRecording = false;
+				this._hasError = true;
+			};
+			recorder.start();
+			this.mediaRecorder = recorder;
+			this._isRecording = true;
+			this._error = null;
+			this._hasError = false;
+		} catch (err) {
+			this._error = `Failed to start recording: ${err}`;
+			this._hasError = true;
+		}
+	}
+	async stopRecording(trimSeconds, encrypt, generateChecksum) {
+		const recorder = this.mediaRecorder;
+		return new Promise((resolve, reject) => {
+			this.removeEventListeners();
+			if (recorder && this._isRecording) {
+				const chunks = [];
+				recorder.ondataavailable = (event) => {
+					if (event.data.size > 0) chunks.push(event.data);
+				};
+				recorder.onstop = async () => {
+					try {
+						const trimmedVideo = await trimLastNSeconds(new Blob(chunks, { type: this.mimeType }), trimSeconds);
+						const encryptedVideoBase64 = encrypt(await toBase64(trimmedVideo));
+						generateChecksum(await trimmedVideo.arrayBuffer());
+						this._isRecording = false;
+						resolve({
+							trimmedBlob: trimmedVideo,
+							encryptedVideo: encryptedVideoBase64
+						});
+					} catch (error) {
+						this._isRecording = false;
+						this._error = `Recording stop failed: ${error}`;
+						this._hasError = true;
+						reject(error);
+					}
+				};
+				recorder.stop();
+				this._isRecording = false;
+			} else resolve({
+				trimmedBlob: new Blob([], { type: this.mimeType }),
+				encryptedVideo: ""
+			});
+			recorder?.stream?.getTracks().forEach((track) => track.stop());
+		});
+	}
+	/**
+	* Discards the in-progress recording without producing a result: detaches
+	* the recorder's handlers, stops it, releases its cloned tracks and clears
+	* the flags. Idempotent, and safe after `stopRecording` or when never
+	* started. Mirrors `MultipartRecordingProvider.reset()` so an attempt that is
+	* released before finalization cannot leave a live camera clone behind
+	* (ENG-56648).
+	*/
+	reset() {
+		this.removeEventListeners();
+		const recorder = this.mediaRecorder;
+		if (recorder) {
+			recorder.ondataavailable = null;
+			recorder.onerror = null;
+			recorder.onstop = null;
+			if (recorder.state !== "inactive") try {
+				recorder.stop();
+			} catch {}
+			recorder.stream?.getTracks().forEach((track) => track.stop());
+			this.mediaRecorder = null;
+		}
+		this.stream = null;
+		this._isRecording = false;
+		this._error = null;
+		this._hasError = false;
+	}
+	pauseRecording() {
+		if (!this._isRecording) return;
+		if (this.mediaRecorder?.state === "recording") try {
+			this.mediaRecorder.pause();
+		} catch {}
+	}
+	registerEventListeners() {
+		document.addEventListener("visibilitychange", this.pauseRecordingBound);
+	}
+	removeEventListeners() {
+		document.removeEventListener("visibilitychange", this.pauseRecordingBound);
+	}
+};
+//#endregion
+//#region src/internal/recordings/recordingsRepository.ts
+async function uploadDeepsightVideo(encryptedVideo, token) {
+	try {
+		return (await api.post(endpoints.deepsightVideoImport, {
+			video: encryptedVideo,
+			type: "selfie"
+		}, { headers: { "X-Incode-Hardware-Id": token } })).data.recordingId ?? "";
+	} catch {
+		return "";
+	}
+}
+//#endregion
+//#region src/internal/faceCapture/recordingService.ts
+/**
+* Records on-device and uploads encrypted video for liveness.
+*/
+var LocalRecordingService = class {
+	constructor(wasmUtil, sessionToken) {
+		this.recorder = new LocalRecordingProvider();
+		this.sessionToken = sessionToken;
+		this.wasmUtil = wasmUtil;
+	}
+	async start(stream) {
+		this.recorder.startRecording(stream);
+		this.wasmUtil.osv();
+	}
+	async stop() {
+		if (!this.recorder.isRecording) return { recordingId: null };
+		this.wasmUtil.oev();
+		const result = await this.recorder.stopRecording(10, (base64) => this.wasmUtil.encryptImage(base64), (buffer) => this.wasmUtil.ckvcks(buffer));
+		if (!this.sessionToken) return { recordingId: null };
+		return { recordingId: await uploadDeepsightVideo(result.encryptedVideo, this.sessionToken) };
+	}
+	prepareUpload() {
+		return this.stop();
+	}
+	async stopAndGetVideo() {
+		if (!this.recorder.isRecording) return { videoBase64: void 0 };
+		try {
+			this.wasmUtil.oev();
+			const videoBase64 = (await this.recorder.stopRecording(10, (base64) => base64, () => {})).encryptedVideo;
+			return { videoBase64: videoBase64 ? videoBase64 : void 0 };
+		} catch {
+			return { videoBase64: void 0 };
+		}
+	}
+	cleanup() {
+		this.recorder.reset();
+	}
+};
+/**
+* Records a regular Selfie capture locally and streams it through the scoped
+* video-selfie-service multipart protocol. The recording is associated with
+* the interview asynchronously by the backend's `selfie` scope consumer, so
+* its upload id must not be forwarded to `/omni/add/face` as a legacy
+* `recordingId`.
+*
+* The recording is scoped to the capture step (ENG-56648). The recorder
+* records a stable `CameraCompositor` stream instead of a raw camera clone, so
+* every attempt can end its own clone before PRC and POC run and the next
+* attempt swaps a fresh clone into the same multipart upload. The owning
+* controller completes the upload once the backend accepts a capture or the
+* step ends without a retry.
+*/
+var MultipartFaceRecordingService = class {
+	constructor() {
+		this.recordingCompositor = createRecordingCompositor();
+		this.service = new MultipartRecordingService("selfie", new WorkerEncoderRecordingProvider(this.recordingCompositor));
+		this.audioSource = [];
+		this.needsVideoSourceReplacement = false;
+		this.pausedForAttempt = false;
+		this.startInFlight = false;
+		this.suspendRequested = false;
+		this.stopping = false;
+	}
+	async start(stream) {
+		if (this.stopping) throw new Error("Face recording already completed");
+		if (this.compositor) {
+			await this.resume(stream);
+			return;
+		}
+		const recordingSource = stream.clone();
+		const compositor = this.recordingCompositor;
+		this.startInFlight = true;
+		try {
+			const composite = compositor.start(recordingSource);
+			await this.service.start(composite);
+		} catch (error) {
+			compositor.stop();
+			recordingSource.getTracks().forEach((track) => track.stop());
+			this.service.cleanup();
+			throw error;
+		} finally {
+			this.startInFlight = false;
+		}
+		if (this.stopping) {
+			compositor.stop();
+			recordingSource.getTracks().forEach((track) => track.stop());
+			this.service.cleanup();
+			return;
+		}
+		this.compositor = compositor;
+		this.recordingSource = recordingSource;
+		this.audioSource = recordingSource.getAudioTracks();
+		if (this.suspendRequested) {
+			this.suspendRequested = false;
+			this.suspend();
+		}
+	}
+	/**
+	* Pauses the container and ends the camera clone on the calling thread. The
+	* composite stream and the upload stay open for the next attempt.
+	*/
+	suspend() {
+		if (this.stopping) return;
+		if (!this.compositor) {
+			this.suspendRequested = this.startInFlight;
+			return;
+		}
+		if (!this.pausedForAttempt) this.pausedForAttempt = this.service.pause();
+		this.releaseCameraClone({ keepAudio: true });
+		this.needsVideoSourceReplacement = true;
+	}
+	async prepareUpload() {
+		this.suspend();
+		return { recordingId: null };
+	}
+	async stop() {
+		await this.complete();
+		return { recordingId: null };
+	}
+	pauseForBackground() {
+		this.suspend();
+	}
+	async resumeFromBackground(stream) {
+		if (!this.compositor || this.stopping) return;
+		await this.resume(stream);
+	}
+	async stopAndGetVideo() {
+		await this.complete();
+		return { videoBase64: void 0 };
+	}
+	cleanup() {
+		this.suspendRequested = false;
+		this.pausedForAttempt = false;
+		this.needsVideoSourceReplacement = false;
+		this.releaseCameraClone({ keepAudio: false });
+		this.compositor?.stop();
+		this.compositor = void 0;
+		this.recordingSource = void 0;
+		this.audioSource = [];
+		this.service.cleanup();
+	}
+	/** Swaps this attempt's camera clone into the composite and resumes. */
+	async resume(stream) {
+		const compositor = this.compositor;
+		if (!compositor) return;
+		if (this.needsVideoSourceReplacement) {
+			const recordingSource = stream.clone();
+			recordingSource.getAudioTracks().forEach((track) => track.stop());
+			compositor.switchVideo(recordingSource);
+			this.needsVideoSourceReplacement = false;
+			this.recordingSource = recordingSource;
+			const result = await compositor.resume();
+			if (result !== "resumed") throw new Error(`Face recording camera did not resume: ${result}`);
+		}
+		if (this.pausedForAttempt && !this.service.resume()) throw new Error("Face recording did not resume");
+		this.pausedForAttempt = false;
+	}
+	/**
+	* Completes the scoped upload. The camera clone ends synchronously before the
+	* drain so a step that ends mid-attempt never pins the camera; the composite
+	* stays alive until the recorder has emitted its final chunk.
+	*/
+	async complete() {
+		this.stopping = true;
+		this.suspendRequested = false;
+		this.releaseCameraClone({ keepAudio: false });
+		try {
+			await this.service.stop();
+		} finally {
+			this.compositor?.stop();
+			this.compositor = void 0;
+			this.recordingSource = void 0;
+			this.audioSource = [];
+			this.pausedForAttempt = false;
+			this.needsVideoSourceReplacement = false;
+		}
+	}
+	releaseCameraClone(options) {
+		try {
+			this.compositor?.pause();
+		} catch {}
+		const tracks = options.keepAudio ? this.recordingSource?.getVideoTracks() ?? [] : /* @__PURE__ */ new Set([...this.recordingSource?.getTracks() ?? [], ...this.audioSource]);
+		for (const track of tracks) try {
+			track.stop();
+		} catch {}
+	}
+};
+/**
+* Creates the recording service for the current configuration.
+*
+* Order of precedence:
+* 1. `onDeviceFaceResultsSubmissionEnabled === true` → no recording. The
+*    on-device workflow never uploads media, only the staged face-results
+*    JSON via `WebApi.postFaceResults`. Mirrors V1's
+*    `FaceFlowManager.setRecorders()` early return.
+* 2. `deepsightLiveness === 'VIDEOLIVENESS'` → local Deepsight recorder.
+* 3. `enableFaceRecording === true` → scoped multipart recorder.
+* 4. otherwise → no recording.
+*/
+function createRecordingService(params) {
+	if (params.config.onDeviceFaceResultsSubmissionEnabled === true) return;
+	if (params.localDelivery === true) return params.config.enableFaceRecording === true || params.config.deepsightLiveness === "VIDEOLIVENESS" ? new LocalRecordingService(params.wasmUtil, null) : void 0;
+	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return new LocalRecordingService(params.wasmUtil, params.sessionToken);
+	if (params.config.enableFaceRecording === true) return new MultipartFaceRecordingService();
+}
+//#endregion
+export { createRecordingService };

package/dist/redirect-to-mobile.d.ts

@@ -1,5 +1,5 @@
-import { n as RedirectToMobileServices, t as RedirectToMobileConfig } from "./types-DPIDuhut.js";
-import { a as RedirectToMobileActor, i as createRedirectToMobileManagerFromActor, n as RedirectToMobileState, o as redirectToMobileMachine, r as createRedirectToMobileManager, t as RedirectToMobileManager } from "./redirectToMobileManager-CVsvpVbQ.js";
+import { r as RedirectToMobileServices, t as RedirectToMobileConfig } from "./types-DNVzoRvi.js";
+import { a as RedirectToMobileActor, i as createRedirectToMobileManagerFromActor, n as RedirectToMobileState, o as redirectToMobileMachine, r as createRedirectToMobileManager, t as RedirectToMobileManager } from "./redirectToMobileManager-Dm9ctRCC.js";
 //#region src/modules/redirect-to-mobile/redirectToMobileServices.d.ts
 declare const defaultRedirectToMobileServices: RedirectToMobileServices;
 //#endregion

package/dist/redirect-to-mobile.esm.js

@@ -1,3 +1,3 @@
-import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices } from "./redirectToMobileStateMachine-b-H-ipGM.esm.js";
-import { n as createRedirectToMobileManagerFromActor, t as createRedirectToMobileManager } from "./redirectToMobileManager-uHW3dyuQ.esm.js";
+import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices } from "./redirectToMobileStateMachine-CbhN8uVN.esm.js";
+import { n as createRedirectToMobileManagerFromActor, t as createRedirectToMobileManager } from "./redirectToMobileManager-CgGaT2NP.esm.js";
 export { createRedirectToMobileManager, createRedirectToMobileManagerFromActor, defaultRedirectToMobileServices, redirectToMobileMachine };

package/dist/{redirectToMobileManager-uHW3dyuQ.esm.js → redirectToMobileManager-CgGaT2NP.esm.js}

@@ -1,8 +1,8 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Du2A4-Qr.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ggpBBaZ8.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-8Gzepa_A.esm.js";
-import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices, t as canResendSmsFromContext } from "./redirectToMobileStateMachine-b-H-ipGM.esm.js";
+import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices, t as canResendSmsFromContext } from "./redirectToMobileStateMachine-CbhN8uVN.esm.js";
 //#region src/modules/redirect-to-mobile/redirectToMobileActor.ts
 const POLL_INTERVAL_MS = 5e3;
 const QR_REFRESH_INTERVAL_MS = 5e3;
@@ -58,7 +58,7 @@ function mapState(snapshot) {
 	const typedSnapshot = snapshot;
 	const { context } = typedSnapshot;
 	if (typedSnapshot.matches("idle")) return { status: "idle" };
-	if (typedSnapshot.matches("generatingUrl") || typedSnapshot.matches("loadingStartInfo")) return { status: "loading" };
+	if (typedSnapshot.matches("generatingUrl")) return { status: "loading" };
 	if (typedSnapshot.matches("showingQr")) return {
 		status: "redirecting",
 		redirectUrl: context.redirectUrl,
@@ -74,7 +74,8 @@ function mapState(snapshot) {
 	if (typedSnapshot.matches("closed")) return { status: "closed" };
 	if (typedSnapshot.matches("error")) return {
 		status: "error",
-		error: context.error ?? "An error occurred"
+		error: context.error ?? "An error occurred",
+		moduleErrorCode: context.moduleErrorCode
 	};
 	return { status: "idle" };
 }

package/dist/{redirectToMobileManager-CVsvpVbQ.d.ts → redirectToMobileManager-Dm9ctRCC.d.ts}

@@ -1,7 +1,7 @@
 import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
 import { t as Manager } from "./Manager-C9T5amUN.js";
 import "./Actor-DpTj5PFb.js";
-import { n as RedirectToMobileServices, t as RedirectToMobileConfig } from "./types-DPIDuhut.js";
+import { n as RedirectToMobileErrorCode, r as RedirectToMobileServices, t as RedirectToMobileConfig } from "./types-DNVzoRvi.js";
 //#region src/modules/redirect-to-mobile/redirectToMobileStateMachine.d.ts
 declare const redirectToMobileMachine: any;
 type RedirectToMobileMachine = typeof redirectToMobileMachine;
@@ -48,6 +48,8 @@ type RedirectToMobileClosedState = {
 type RedirectToMobileErrorState = {
   status: 'error';
   error: string;
+  /** Machine-readable code, forwarded as `onError`'s third argument. */
+  moduleErrorCode: RedirectToMobileErrorCode | undefined;
 };
 type RedirectToMobileState = RedirectToMobileIdleState | RedirectToMobileLoadingState | RedirectToMobileRedirectingState | RedirectToMobileFinishedState | RedirectToMobileContinueState | RedirectToMobileClosedState | RedirectToMobileErrorState;
 /**

package/dist/{redirectToMobileStateMachine-b-H-ipGM.esm.js → redirectToMobileStateMachine-CbhN8uVN.esm.js}

@@ -1,8 +1,8 @@
-import { t as api, u as endpoints } from "./api-Cz90EHyu.esm.js";
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { i as assign, t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-8Gzepa_A.esm.js";
-import { n as getUrlSearchParam, t as buildUrlWithSearchParams } from "./urlUtils-6jsE6rKp.esm.js";
+import { n as getUrlSearchParam, r as resolveAgainstPageOrigin, t as buildUrlWithSearchParams } from "./urlUtils-eYiyWjh0.esm.js";
 //#region src/modules/redirect-to-mobile/redirectToMobileServices.ts
 async function fetchRedirectUrl(signal) {
 	const res = await api.get(endpoints.onboardingUrl, { signal });
@@ -59,6 +59,14 @@ function buildRedirectUrl(baseUrl, customUrl, config, urlUuid) {
 		url_uuid: urlUuid || void 0
 	});
 }
+const INVALID_URL_ERROR = "Invalid Redirect to Mobile URL. Use an absolute http or https URL.";
+const ABSOLUTE_HTTP_URL = /^https?:\/\//i;
+function withAbsoluteUrl(config) {
+	return config.url?.startsWith("/") ? {
+		...config,
+		url: resolveAgainstPageOrigin(config.url)
+	} : config;
+}
 function extractUuidFromUrl(url) {
 	return getUrlSearchParam(url, "uuid") ?? "";
 }
@@ -132,6 +140,10 @@ const redirectToMobileMachine = setup({
 			return { phonePrefix: event.output.phonePrefix };
 		}),
 		setError: assign(({ event }) => ({ error: String(event.error) })),
+		setInvalidUrlError: assign(() => ({
+			error: INVALID_URL_ERROR,
+			moduleErrorCode: "INVALID_REDIRECT_URL"
+		})),
 		completeSmsSend: assign(() => {
 			return {
 				smsSent: true,
@@ -172,13 +184,14 @@ const redirectToMobileMachine = setup({
 	},
 	guards: {
 		hasPhishingResistance: ({ context }) => context.config.qrPhishingResistance === true,
+		hasInvalidUrl: ({ context }) => context.config.url !== void 0 && !ABSOLUTE_HTTP_URL.test(context.config.url),
 		canResendSms: ({ context }) => canResendSmsFromContext(context)
 	}
 }).createMachine({
 	id: "redirectToMobile",
 	initial: "idle",
 	context: ({ input }) => ({
-		config: input.config,
+		config: withAbsoluteUrl(input.config),
 		redirectUrl: "",
 		fetchedBaseUrl: "",
 		uuid: "",
@@ -188,31 +201,54 @@ const redirectToMobileMachine = setup({
 		smsFailed: false,
 		smsResendTimer: 0,
 		smsResendTimerActive: false,
-		error: void 0
+		error: void 0,
+		moduleErrorCode: void 0
 	}),
 	states: {
-		idle: { on: { LOAD: "generatingUrl" } },
-		generatingUrl: { invoke: {
-			id: "fetchRedirectUrl",
-			src: "fetchRedirectUrl",
-			onDone: {
-				target: "loadingStartInfo",
-				actions: "setBaseUrl"
-			},
-			onError: {
-				target: "error",
-				actions: "setError"
-			}
-		} },
-		loadingStartInfo: { invoke: {
-			id: "fetchStartInfo",
-			src: "fetchStartInfo",
-			onDone: {
-				target: "showingQr",
-				actions: "setStartInfo"
+		idle: { on: { LOAD: [{
+			target: "error",
+			guard: "hasInvalidUrl",
+			actions: "setInvalidUrlError"
+		}, { target: "generatingUrl" }] } },
+		generatingUrl: {
+			type: "parallel",
+			states: {
+				redirectUrl: {
+					initial: "loading",
+					states: {
+						loading: { invoke: {
+							id: "fetchRedirectUrl",
+							src: "fetchRedirectUrl",
+							onDone: {
+								target: "done",
+								actions: "setBaseUrl"
+							},
+							onError: {
+								target: "#redirectToMobile.error",
+								actions: "setError"
+							}
+						} },
+						done: { type: "final" }
+					}
+				},
+				startInfo: {
+					initial: "loading",
+					states: {
+						loading: { invoke: {
+							id: "fetchStartInfo",
+							src: "fetchStartInfo",
+							onDone: {
+								target: "done",
+								actions: "setStartInfo"
+							},
+							onError: { target: "done" }
+						} },
+						done: { type: "final" }
+					}
+				}
 			},
-			onError: { target: "showingQr" }
-		} },
+			onDone: { target: "showingQr" }
+		},
 		showingQr: {
 			type: "parallel",
 			states: {
@@ -294,7 +330,10 @@ const redirectToMobileMachine = setup({
 		},
 		continue: { type: "final" },
 		closed: { type: "final" },
-		error: { on: { RETRY: "generatingUrl" } }
+		error: { on: { RETRY: [{
+			guard: "hasInvalidUrl",
+			actions: "setInvalidUrlError"
+		}, { target: "generatingUrl" }] } }
 	}
 });
 //#endregion