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

package/dist/phone.d.ts

@@ -1,5 +1,6 @@
-import "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
-import "./otp-DF5A0sFx.js";
-import { n as PhoneState, o as phoneMachine, r as createPhoneManager, s as PhoneConfig, t as PhoneManager } from "./phoneManager-fPmIBYQK.js";
+import "./StateMachine-C_AY4cs7.js";
+import "./Manager-CJ3G2zqi.js";
+import "./Actor-CGEelYtQ.js";
+import "./otp-M4iy57XY.js";
+import { n as PhoneState, o as phoneMachine, r as createPhoneManager, s as PhoneConfig, t as PhoneManager } from "./phoneManager-BOTcjXgs.js";
 export { type PhoneConfig, type PhoneManager, type PhoneState, createPhoneManager, phoneMachine };

package/dist/phone.esm.js

@@ -1,10 +1,11 @@
-import "./BrowserTimerProvider-DhNc_x02.esm.js";
-import "./api-CESGtpbH.esm.js";
-import "./events-Dvvriq9l.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import "./xstate.esm-C9wncMQa.esm.js";
-import "./otp-CGMdUzBC.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-BiV0yoEx.esm.js";
-import { t as createPhoneManager } from "./phoneManager-BmF-0Ez4.esm.js";
+import "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import "./events-CqGY1yMq.esm.js";
+import "./types-ElOJAGaM.esm.js";
+import "./endpoints-BzMJFAPV.esm.js";
+import "./xstate.esm-Bomq1a0z.esm.js";
+import "./otp-Bfnzf7I3.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-B_V9nODs.esm.js";
+import { t as createPhoneManager } from "./phoneManager-BWlxqbyD.esm.js";
 
 export { createPhoneManager, phoneMachine };

package/dist/{phoneManager-fPmIBYQK.d.ts → phoneManager-BOTcjXgs.d.ts}

@@ -1,6 +1,6 @@
-import { t as Manager } from "./Manager-BHn8wH8K.js";
-import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
-import { t as OtpValidationErrors } from "./otp-DF5A0sFx.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import { t as ActorRefFrom } from "./Actor-CGEelYtQ.js";
+import { t as OtpValidationErrors } from "./otp-M4iy57XY.js";
 
 //#region src/modules/phone/types.d.ts
 
@@ -80,6 +80,7 @@ type CreatePhoneActorOptions = {
 type PhoneActor = ActorRefFrom<PhoneMachine>;
 //#endregion
 //#region src/modules/phone/phoneManager.d.ts
+
 /** Phone manager is in initial state, waiting for `load()` to be called */
 type PhoneIdleState = {
   status: 'idle';

package/dist/{phoneManager-BmF-0Ez4.esm.js → phoneManager-BWlxqbyD.esm.js}

@@ -1,7 +1,8 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.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 phoneMachine } from "./phoneStateMachine-BiV0yoEx.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 } from "./xstate.esm-Bomq1a0z.esm.js";
+import { t as OTP_CODE_LENGTH } from "./otp-Bfnzf7I3.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-B_V9nODs.esm.js";
 
 //#region src/modules/phone/phoneActor.ts
 function createPhoneActor(options) {
@@ -98,6 +99,47 @@ function createPhoneActor(options) {
 * }, 100);
 * ```
 */
+/**
+* Maps a Phone 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: Phone Input Module Figma file → Tracked Events canvas
+* (`https://www.figma.com/design/nIj8kklozEOMs2e5sLzGFi/Phone-Input-Module?node-id=3031-82920`).
+*
+* Figma screens that have no dedicated state-machine counterpart yet
+* (intentionally not mapped here — they collapse into the section's primary
+* screen until the SM surfaces them):
+*
+* - `phoneNumber.verify.countryCode` — country-picker overlay; no separate SM state.
+* - `phoneNumber.verify.phoneTyping` / `phoneNumber.verify.phoneFilled` — UI sub-states of `inputting`.
+* - `phoneNumber.OTP.filled` — UI sub-state of `awaitingOtp`.
+*
+* `finished` and `error` are mapped to terminal Figma screens to keep the
+* adapter from falling back to the generic `<module>.finished` /
+* `<module>.error` defaults.
+*/
+function getPhoneScreenName(snapshot) {
+	const { value } = snapshot;
+	if (typeof value !== "string") return void 0;
+	switch (value) {
+		case "idle":
+		case "inputting":
+		case "validatingSubmit": return "phoneNumber.verify.default";
+		case "loadingPrefill":
+		case "loadingStartInfo": return "phoneNumber.verify.loading";
+		case "submitting": return snapshot.context?.config?.isInstantVerify ? "phoneNumber.SNA.loading" : "phoneNumber.verify.loading";
+		case "sendingInitialOtp":
+		case "resendingOtp":
+		case "awaitingOtp": return "phoneNumber.OTP.typing";
+		case "verifyingOtp": return "phoneNumber.OTP.processing";
+		case "otpError":
+		case "error": return "phoneNumber.OTP.error";
+		case "finished": return "phoneNumber.success";
+		default: return;
+	}
+}
 function mapState(snapshot) {
 	const typedSnapshot = snapshot;
 	const { context } = typedSnapshot;
@@ -263,7 +305,7 @@ function createPhoneManager(options) {
 		actor: createPhoneActor(options),
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.phone)
+		instrumentation: createManagerInstrumentation(eventModuleNames.phone, { getEventScreenName: getPhoneScreenName })
 	});
 }
 function createPhoneManagerFromActor(actor) {
@@ -271,7 +313,7 @@ function createPhoneManagerFromActor(actor) {
 		actor,
 		mapState,
 		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.phone)
+		instrumentation: createManagerInstrumentation(eventModuleNames.phone, { getEventScreenName: getPhoneScreenName })
 	});
 }
 

package/dist/{phoneStateMachine-BiV0yoEx.esm.js → phoneStateMachine-B_V9nODs.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/phone/phoneServices.ts
 function getPhoneServerFailureReason(error, invalidStatus) {

package/dist/{qe-signature-CUYPcHVo.esm.js → qe-signature-BhFnI9pT.esm.js}

@@ -1,4 +1,4 @@
-import { t as createElectronicSignatureManager } from "./electronicSignatureManager-BaECdJ1u.esm.js";
+import { t as createElectronicSignatureManager } from "./electronicSignatureManager-DjzUzqZj.esm.js";
 
 //#region src/modules/qe-signature/index.ts
 function createQeSignatureManager(options) {

package/dist/qe-signature.d.ts

@@ -1,6 +1,7 @@
-import { t as Manager } from "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
-import { c as ConsentKey, f as QE_CONSENT_KEYS, g as getDefaultConsentChecks, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, s as ConsentChecks, u as ElectronicSignatureDocument } from "./index-B9NysVDB.js";
+import "./StateMachine-C_AY4cs7.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import "./Actor-CGEelYtQ.js";
+import { c as ConsentKey, f as QE_CONSENT_KEYS, g as getDefaultConsentChecks, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, s as ConsentChecks, u as ElectronicSignatureDocument } from "./index-Icld-cKW.js";
 
 //#region src/modules/qe-signature/index.d.ts
 

package/dist/qe-signature.esm.js

@@ -1,9 +1,12 @@
-import "./api-CESGtpbH.esm.js";
-import "./events-Dvvriq9l.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import "./xstate.esm-C9wncMQa.esm.js";
-import "./apiError-B-j-gyDx.esm.js";
-import { a as areAllConsented, i as QE_CONSENT_KEYS, n as electronicSignatureMachine, s as getDefaultConsentChecks } from "./electronicSignatureManager-BaECdJ1u.esm.js";
-import { t as createQeSignatureManager } from "./qe-signature-CUYPcHVo.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import "./events-CqGY1yMq.esm.js";
+import "./types-ElOJAGaM.esm.js";
+import "./endpoints-BzMJFAPV.esm.js";
+import "./xstate.esm-Bomq1a0z.esm.js";
+import "./urlUtils-BZqFU9rR.esm.js";
+import "./externalFetch-CyhBfD-n.esm.js";
+import "./apiError-DNS2OCEX.esm.js";
+import { a as areAllConsented, i as QE_CONSENT_KEYS, n as electronicSignatureMachine, s as getDefaultConsentChecks } from "./electronicSignatureManager-DjzUzqZj.esm.js";
+import { t as createQeSignatureManager } from "./qe-signature-BhFnI9pT.esm.js";
 
 export { QE_CONSENT_KEYS, areAllConsented, createQeSignatureManager, getDefaultConsentChecks, electronicSignatureMachine as qeSignatureMachine };

package/dist/recordingService-m_1xCthr.esm.js

@@ -0,0 +1,347 @@
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { t as isAndroid } from "./platform-uIVQUnJP.esm.js";
+import { d as stopRecording, u as startRecordingSession, v as uploadDeepsightVideo } from "./onDeviceFaceResults-DVBggeq8.esm.js";
+import { t as getAdaptiveMediaRecorderOptions } from "./mediaRecorderOptions-C3NAkVgK.esm.js";
+
+//#region src/internal/manualReview/manualReviewService.ts
+async function flagFaceManualReview() {
+	try {
+		await api.put(endpoints.updateSession, { manualSelfieCheckNeeded: true });
+	} catch {}
+}
+async function flagIdManualReview() {
+	try {
+		await api.put(endpoints.updateSession, { manualIdCheckNeeded: true });
+	} catch {}
+}
+
+//#endregion
+//#region ../infra/src/media/VideoTrimmer.ts
+async function getDurationBySeek(videoBlob) {
+	const video = document.createElement("video");
+	video.preload = "metadata";
+	video.src = URL.createObjectURL(videoBlob);
+	try {
+		if (!Number.isFinite(video.duration)) {
+			video.currentTime = Number.MAX_SAFE_INTEGER;
+			await new Promise((resolve) => {
+				const onDurationChange = () => {
+					if (Number.isFinite(video.duration)) {
+						video.removeEventListener("durationchange", onDurationChange);
+						video.removeEventListener("timeupdate", onTimeUpdate);
+						resolve(video.duration);
+					}
+				};
+				const onTimeUpdate = () => {
+					if (Number.isFinite(video.duration)) {
+						video.removeEventListener("timeupdate", onTimeUpdate);
+						video.removeEventListener("durationchange", onDurationChange);
+						resolve(video.duration);
+					}
+				};
+				video.addEventListener("durationchange", onDurationChange);
+				video.addEventListener("timeupdate", onTimeUpdate);
+			});
+		}
+		const duration = video.duration;
+		return Number.isFinite(duration) ? duration : null;
+	} finally {
+		URL.revokeObjectURL(video.src);
+		video.src = "";
+	}
+}
+async function trimLastNSecondsUsingPlayback(videoBlob, seconds) {
+	const video = document.createElement("video");
+	video.preload = "metadata";
+	video.playsInline = true;
+	video.muted = true;
+	const videoURL = URL.createObjectURL(videoBlob);
+	video.src = videoURL;
+	const duration = await getDurationBySeek(videoBlob);
+	if (!duration || duration < seconds) {
+		URL.revokeObjectURL(videoURL);
+		return videoBlob;
+	}
+	const startTime = Math.max(0, Math.floor(duration) - seconds);
+	await new Promise((resolve) => {
+		if (video.readyState >= 2) resolve();
+		else video.addEventListener("loadedmetadata", () => resolve(), { once: true });
+	});
+	const canvas = document.createElement("canvas");
+	canvas.width = 230;
+	canvas.height = 320;
+	const captureFps = isAndroid() ? 15 : 24;
+	const stream = canvas.captureStream(captureFps);
+	const ctx = canvas.getContext("2d");
+	video.currentTime = startTime;
+	await new Promise((resolve) => {
+		video.addEventListener("seeked", () => resolve(), { once: true });
+	});
+	ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+	const mimeType = videoBlob.type || (MediaRecorder.isTypeSupported("video/webm") ? "video/webm" : "video/mp4");
+	const mediaRecorder = new MediaRecorder(stream.clone(), {
+		mimeType,
+		videoBitsPerSecond: 5e5,
+		bitsPerSecond: 5e5
+	});
+	const chunks = [];
+	mediaRecorder.ondataavailable = (event) => {
+		if (event.data.size > 0) chunks.push(event.data);
+	};
+	const recordingPromise = new Promise((resolve) => {
+		mediaRecorder.onstop = () => {
+			const trimmedBlob$1 = new Blob(chunks, { type: mimeType });
+			URL.revokeObjectURL(videoURL);
+			mediaRecorder.stream?.getTracks().forEach((track) => track.stop());
+			stream.getTracks().forEach((track) => track.stop());
+			video.src = "";
+			resolve(trimmedBlob$1);
+		};
+	});
+	video.addEventListener("play", () => {
+		function drawVideo() {
+			if (video.currentTime >= duration) {
+				mediaRecorder.stop();
+				video.pause();
+				return;
+			}
+			ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+			requestAnimationFrame(drawVideo);
+		}
+		drawVideo();
+		setTimeout(() => {
+			mediaRecorder.start(100);
+		}, 500);
+	});
+	video.play().catch(() => {
+		URL.revokeObjectURL(videoURL);
+	});
+	const trimmedBlob = await recordingPromise;
+	console.timeEnd("trimLastNSecondsUsingPlayback");
+	return trimmedBlob;
+}
+async function trimLastNSeconds(videoBlob, seconds) {
+	return await trimLastNSecondsUsingPlayback(videoBlob, seconds);
+}
+
+//#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);
+	});
+}
+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();
+		this.registerEventListeners();
+		this.stream = stream;
+		try {
+			const options = getAdaptiveMediaRecorderOptions();
+			this.mimeType = options.mimeType;
+			const recorder = new MediaRecorder(stream.clone(), options);
+			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());
+		});
+	}
+	reset() {
+		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/faceCapture/recordingService.ts
+let openViduProviderImportPromise;
+let openViduBrowserImportPromise;
+function loadOpenViduProviderModule() {
+	if (!openViduProviderImportPromise) openViduProviderImportPromise = import("./OpenViduRecordingProvider-B_0GKkzc.esm.js");
+	return openViduProviderImportPromise;
+}
+function loadOpenViduBrowserModule() {
+	if (!openViduBrowserImportPromise) openViduBrowserImportPromise = (async () => {
+		return (await import("./openviduLazy-Dov8oKfL.esm.js")).loadOpenVidu();
+	})();
+	return openViduBrowserImportPromise;
+}
+function preloadOpenViduProvider() {
+	loadOpenViduProviderModule();
+	loadOpenViduBrowserModule();
+}
+/**
+* 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) };
+	}
+	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 through OpenVidu and manages the session lifecycle.
+*/
+var OpenViduRecordingService = class {
+	constructor(config) {
+		this.config = config;
+	}
+	async start(stream) {
+		if (!this.provider) {
+			const { OpenViduRecordingProvider } = await loadOpenViduProviderModule();
+			this.provider = new OpenViduRecordingProvider();
+		}
+		this.session = await startRecordingSession({
+			config: {
+				...this.config,
+				recording: { capability: this.provider }
+			},
+			clonedStream: stream.clone(),
+			existing: this.session
+		});
+	}
+	async stop() {
+		if (this.session) {
+			stopRecording(this.session);
+			this.session = void 0;
+		}
+		return { recordingId: null };
+	}
+	async stopAndGetVideo() {
+		if (this.session) {
+			stopRecording(this.session);
+			this.session = void 0;
+		}
+		return { videoBase64: void 0 };
+	}
+	cleanup() {
+		if (this.session) stopRecording(this.session);
+	}
+};
+/**
+* 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` → server-side OpenVidu recorder.
+* 4. otherwise → no recording.
+*/
+function createRecordingService(params) {
+	if (params.config.onDeviceFaceResultsSubmissionEnabled === true) return;
+	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return new LocalRecordingService(params.wasmUtil, params.sessionToken);
+	if (params.config.enableFaceRecording === true) return new OpenViduRecordingService(params.config);
+}
+
+//#endregion
+export { flagIdManualReview as i, preloadOpenViduProvider as n, flagFaceManualReview as r, createRecordingService as t };

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

@@ -1,6 +1,7 @@
-import "./Manager-BHn8wH8K.js";
-import "./Actor-Y0_Fj-KL.js";
-import { a as RedirectToMobileActor, c as RedirectToMobileServices, i as createRedirectToMobileManagerFromActor, n as RedirectToMobileState, o as redirectToMobileMachine, r as createRedirectToMobileManager, s as RedirectToMobileConfig, t as RedirectToMobileManager } from "./redirectToMobileManager-BNe3IzC_.js";
+import "./StateMachine-C_AY4cs7.js";
+import "./Manager-CJ3G2zqi.js";
+import "./Actor-CGEelYtQ.js";
+import { a as RedirectToMobileActor, c as RedirectToMobileServices, i as createRedirectToMobileManagerFromActor, n as RedirectToMobileState, o as redirectToMobileMachine, r as createRedirectToMobileManager, s as RedirectToMobileConfig, t as RedirectToMobileManager } from "./redirectToMobileManager-Br0KZK1G.js";
 
 //#region src/modules/redirect-to-mobile/redirectToMobileServices.d.ts
 

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

@@ -1,9 +1,11 @@
-import "./BrowserTimerProvider-DhNc_x02.esm.js";
-import "./api-CESGtpbH.esm.js";
-import "./events-Dvvriq9l.esm.js";
-import "./endpoints-BeTK0Mlt.esm.js";
-import "./xstate.esm-C9wncMQa.esm.js";
-import { n as defaultRedirectToMobileServices, t as redirectToMobileMachine } from "./redirectToMobileStateMachine-DyAdRxfP.esm.js";
-import { n as createRedirectToMobileManagerFromActor, t as createRedirectToMobileManager } from "./redirectToMobileManager-Dy3t7o0C.esm.js";
+import "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import "./events-CqGY1yMq.esm.js";
+import "./types-ElOJAGaM.esm.js";
+import "./endpoints-BzMJFAPV.esm.js";
+import "./xstate.esm-Bomq1a0z.esm.js";
+import "./urlUtils-BZqFU9rR.esm.js";
+import { n as defaultRedirectToMobileServices, t as redirectToMobileMachine } from "./redirectToMobileStateMachine-DoAnf2ql.esm.js";
+import { n as createRedirectToMobileManagerFromActor, t as createRedirectToMobileManager } from "./redirectToMobileManager-BaAo9rgi.esm.js";
 
 export { createRedirectToMobileManager, createRedirectToMobileManagerFromActor, defaultRedirectToMobileServices, redirectToMobileMachine };

package/dist/{redirectToMobileManager-Dy3t7o0C.esm.js → redirectToMobileManager-BaAo9rgi.esm.js}

@@ -1,7 +1,8 @@
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
-import { a as fromPromise, c as createManager, i as fromCallback, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
-import { n as defaultRedirectToMobileServices, t as redirectToMobileMachine } from "./redirectToMobileStateMachine-DyAdRxfP.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import { n as createManagerInstrumentation } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import { a as fromPromise, i as fromCallback, l as createManager, s as createActor } from "./xstate.esm-Bomq1a0z.esm.js";
+import { n as defaultRedirectToMobileServices, t as redirectToMobileMachine } from "./redirectToMobileStateMachine-DoAnf2ql.esm.js";
 
 //#region src/modules/redirect-to-mobile/redirectToMobileActor.ts
 const POLL_INTERVAL_MS = 5e3;

package/dist/{redirectToMobileManager-BNe3IzC_.d.ts → redirectToMobileManager-Br0KZK1G.d.ts}

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-BHn8wH8K.js";
-import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import { t as ActorRefFrom } from "./Actor-CGEelYtQ.js";
 
 //#region src/modules/redirect-to-mobile/types.d.ts
 type RedirectToMobileConfig = {

package/dist/{redirectToMobileStateMachine-DyAdRxfP.esm.js → redirectToMobileStateMachine-DoAnf2ql.esm.js}

@@ -1,7 +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 { 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 getUrlSearchParam, t as buildUrlWithSearchParams } from "./urlUtils-BZqFU9rR.esm.js";
 
 //#region src/modules/redirect-to-mobile/redirectToMobileServices.ts
 async function fetchRedirectUrl(signal) {
@@ -41,21 +42,6 @@ const defaultRedirectToMobileServices = {
 	fetchStartInfo
 };
 
-//#endregion
-//#region ../infra/src/url/urlUtils.ts
-function getUrlSearchParam(url, param) {
-	try {
-		return new URL(url).searchParams.get(param);
-	} catch {
-		return null;
-	}
-}
-function buildUrlWithSearchParams(baseUrl, params) {
-	const url = new URL(baseUrl);
-	for (const [key, value] of Object.entries(params)) if (value !== void 0) url.searchParams.set(key, value);
-	return url.href;
-}
-
 //#endregion
 //#region src/modules/redirect-to-mobile/redirectToMobileStateMachine.ts
 const POLL_INTERVAL_MS = 5e3;
@@ -78,7 +64,8 @@ const redirectToMobileMachine = setup({
 	types: {
 		context: {},
 		events: {},
-		input: {}
+		input: {},
+		output: {}
 	},
 	actors: {
 		fetchRedirectUrl: fromPromise(async ({ signal }) => {
@@ -213,6 +200,10 @@ const redirectToMobileMachine = setup({
 				},
 				sms: {
 					initial: "idle",
+					on: { RESET_SMS: {
+						target: ".idle",
+						actions: "resetSmsSent"
+					} },
 					states: {
 						idle: { on: { SEND_SMS: "sending" } },
 						sending: { invoke: {
@@ -232,13 +223,7 @@ const redirectToMobileMachine = setup({
 								actions: "setSmsError"
 							}
 						} },
-						sent: { on: {
-							SEND_SMS: "sending",
-							RESET_SMS: {
-								target: "idle",
-								actions: "resetSmsSent"
-							}
-						} }
+						sent: { on: { SEND_SMS: "sending" } }
 					}
 				}
 			},
@@ -247,7 +232,10 @@ const redirectToMobileMachine = setup({
 				CLOSE: "closed"
 			}
 		},
-		finished: { type: "final" },
+		finished: {
+			type: "final",
+			output: { action: "onboardingFinished" }
+		},
 		continue: { type: "final" },
 		closed: { type: "final" },
 		error: { on: { RETRY: "generatingUrl" } }