@incodetech/core 2.1.1 → 2.2.0-rc.1

package/dist/personhood.esm.js

@@ -1,45 +1,18 @@
-import { t as WasmUtilProvider } from "./WasmUtilProvider-BgzcXBdl.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { a as createApi_default, t as getStoredHttpConfig } from "./clientLifecycle-VyzRfALg.esm.js";
-import { n as eventModuleNames } from "./events-1wxZ97yf.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import "./stats-BVy52wLy.esm.js";
-import { d as BrowserEnvironmentProvider, n as getFingerprintEnabled, u as getDeviceFingerprintInfo } from "./sessionInitializer-Dj7-aJaP.esm.js";
-import { n as getThumbmarkId, t as isBrowserSimulation } from "./browserSimulation-DZwEy9bu.esm.js";
-import "./platform-0Ot-bF_a.esm.js";
-import "./getBrowser-1yNcfFZR.esm.js";
-import "./tri-CFAPtAUM.esm.js";
-import { a as fromPromise, i as fromCallback, l as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-import "./MotionSensorProvider-BHuHoYvJ.esm.js";
-import { i as requestPermission, t as checkPermission } from "./permissionServices-C_kxhNeo.esm.js";
-import { a as stopCameraStream, r as requestCameraAccess } from "./camera-CxxXV0VN.esm.js";
-import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CBHBhKQN.esm.js";
-import { b as FaceDetectionProvider, f as stopStream, l as startDetection, s as initializeDeepsightSession } from "./onDeviceFaceResults-DILtthks.esm.js";
-import { t as sleep } from "./ITimerCapability-DJ73P4RK.esm.js";
-import "./canvas-Pi10hG_l.esm.js";
-import "./backCameraStream-ChrMTJv-.esm.js";
-import "./video-ZY92rkel.esm.js";
-import "./getDeviceClass-C-Dg6IsJ.esm.js";
-import "./deepsightService-CViys6T4.esm.js";
-import "./getDeviceClass-DIjnTPjR.esm.js";
-import "./types-BKLb3C42.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-CAqUdVkM.esm.js";
-
-//#region ../infra/src/crypto/randomUUID.ts
-/**
-* Cryptographically-strong UUID v4 (RFC 4122).
-*
-* Lives in infra (L0) so Core (L1) can mint secure identifiers without touching
-* the `crypto` browser API directly — Core delegates here, keeping it free of
-* browser globals (enforced by the `no-browser-api-in-core` lint rule). Backed
-* by `crypto.randomUUID`, available in every browser the SDK targets.
-*/
-function randomUUID() {
-	return crypto.randomUUID();
-}
-
-//#endregion
+import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { b as getStoredHttpConfig, w as createApi$1, y as randomUUID } from "./trueSightService-s3T95geD.esm.js";
+import { n as eventModuleNames } from "./events-CxfNJVZW.esm.js";
+import { _ as getDeviceFingerprintInfo, g as getThumbmarkId, n as getFingerprintEnabled, p as isBrowserSimulation, v as BrowserEnvironmentProvider } from "./sessionInitializer-DNgRpf5Y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { c as createManager, o as createActor, r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
+import { a as stopCameraStream, r as requestCameraAccess } from "./camera-_2sXMXiF.esm.js";
+import { i as requestPermission, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
+import { f as stopStream, l as startDetection, s as initializeDeepsightSession, v as FaceDetectionProvider } from "./onDeviceFaceResults-C6IRJHQB.esm.js";
+import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
 //#region src/modules/personhood/personhoodServices.ts
 /**
 * Config used for the passive liveness pass. Deliberately stripped down from
@@ -234,18 +207,6 @@ async function analyzeLiveness(params) {
 	};
 }
 /**
-* Minimum combined yaw+pitch range (in degrees) required across the
-* detection window to clear the no-motion guard. A static photo or a
-* face with no head movement will fall below this.
-*/
-const MIN_POSE_MOTION_DEG = 4;
-/**
-* Upper bound of motion (degrees) that adds confidence — beyond this,
-* additional head movement doesn't increase our belief that there's a
-* human (and may just be noise from a moving phone).
-*/
-const MAX_POSE_MOTION_FOR_BONUS_DEG = 50;
-/**
 * Ceiling for on-device verdicts. Intentionally below 1.0 — nothing short
 * of a signed server round-trip should claim perfect confidence, and the
 * ceiling is strictly below what a server verdict would return so the two
@@ -253,13 +214,6 @@ const MAX_POSE_MOTION_FOR_BONUS_DEG = 50;
 */
 const LOCAL_CONFIDENCE_CEILING = .95;
 /**
-* Default pass threshold when `PersonhoodConfig.threshold` is omitted. Single
-* source of truth — keep `PersonhoodConfig.threshold`'s JSDoc and PERSONHOOD.md
-* in sync with this value. (A clean local pass without strong head motion lands
-* around here, so this is the effective on-device gate.)
-*/
-const DEFAULT_PERSONHOOD_THRESHOLD = .75;
-/**
 * Produces a verdict entirely on-device using an **additive** confidence
 * model. Each positive signal contributes a measurable amount to the score;
 * penalties subtract. This means clean passes vary — a user who swings
@@ -284,7 +238,7 @@ const DEFAULT_PERSONHOOD_THRESHOLD = .75;
 * - Detection didn't reach 'success'          → -0.2
 */
 function produceLocalVerdict(params) {
-	const threshold = params.threshold ?? DEFAULT_PERSONHOOD_THRESHOLD;
+	const threshold = params.threshold ?? .75;
 	const reasons = [];
 	let confidence = .4;
 	if (params.detectionOutcome === "success") confidence += .25;
@@ -294,12 +248,11 @@ function produceLocalVerdict(params) {
 	}
 	if (params.liveness) {
 		const motion = params.liveness.yawRange + params.liveness.pitchRange;
-		if (motion < MIN_POSE_MOTION_DEG) {
+		if (motion < 4) {
 			reasons.push("no_motion");
 			confidence -= .5;
 		} else {
-			const span = MAX_POSE_MOTION_FOR_BONUS_DEG - MIN_POSE_MOTION_DEG;
-			const motionRatio = Math.min(1, Math.max(0, (motion - MIN_POSE_MOTION_DEG) / span));
+			const motionRatio = Math.min(1, Math.max(0, (motion - 4) / 46));
 			confidence += .25 * motionRatio;
 		}
 		if (!hasExplicitSpoofSignal(params.liveness.analysisStatus)) confidence += .05;
@@ -318,7 +271,7 @@ function produceLocalVerdict(params) {
 		reasons.push("emulator");
 		confidence -= .9;
 	}
-	const SUBSUMED_HINTS = new Set(["navigator.webdriver", "automation-marker"]);
+	const SUBSUMED_HINTS = /* @__PURE__ */ new Set(["navigator.webdriver", "automation-marker"]);
 	if (params.signals.headlessHints.filter((hint) => !SUBSUMED_HINTS.has(hint)).length > 0) {
 		reasons.push("headless");
 		confidence -= .3;
@@ -502,7 +455,7 @@ async function fetchPersonhoodAuthToken(params = {}) {
 	};
 	try {
 		let res;
-		if (params.authBaseUrl) res = await createApi_default({
+		if (params.authBaseUrl) res = await createApi$1({
 			apiURL: params.authBaseUrl,
 			customHeaders: getStoredHttpConfig()?.customHeaders
 		}).post(authPath, body, reqConfig);
@@ -582,7 +535,7 @@ function buildSpoofCheckResults(params) {
 			check: "motionLiveness",
 			result: "unknown"
 		});
-		if (liveness.yawRange + liveness.pitchRange >= MIN_POSE_MOTION_DEG) results.push({
+		if (liveness.yawRange + liveness.pitchRange >= 4) results.push({
 			check: "headMotion",
 			result: "passed"
 		});
@@ -695,7 +648,6 @@ function isApiNotConfigured(error) {
 function generateEvidenceId(siteKey) {
 	return `ph_${(siteKey || "site").replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 12)}_${randomUUID().replace(/-/g, "")}`;
 }
-
 //#endregion
 //#region src/modules/personhood/personhoodSignals.ts
 /**
@@ -773,12 +725,19 @@ async function safeGetDeviceInfo() {
 		return;
 	}
 }
-
 //#endregion
 //#region src/modules/personhood/types.ts
 const PERSONHOOD_ERROR_CODES = {
 	CAMERA_DENIED: "CAMERA_DENIED",
 	DETECTION_FAILED: "DETECTION_FAILED",
+	/**
+	* The OAuth2 token fetch (`POST /omni/oauth2/token`,
+	* client-credentials) failed — non-2xx, network error, or no
+	* `access_token` in the response. The flow halts before the user
+	* opens the camera so a misconfigured `clientId` / `clientSecret`
+	* surfaces immediately instead of walking them through a capture we
+	* can't authenticate the verify hop for.
+	*/
 	AUTH_TOKEN_FAILED: "AUTH_TOKEN_FAILED",
 	VERIFY_FAILED: "VERIFY_FAILED",
 	INJECTION_SUSPECTED: "INJECTION_SUSPECTED",
@@ -786,10 +745,13 @@ const PERSONHOOD_ERROR_CODES = {
 	TIMEOUT: "TIMEOUT",
 	UNKNOWN: "UNKNOWN"
 };
-
-//#endregion
-//#region src/modules/personhood/personhoodStateMachine.ts
-const _personhoodMachine = setup({
+/**
+* Public machine value. Typed as `AnyStateMachine` for declaration file
+* portability — mirrors the convention used by `selfieMachine` and the
+* other Core modules. Type safety is enforced by the `setup()` config
+* above, not by the exported binding.
+*/
+const personhoodMachine = setup({
 	types: {
 		context: {},
 		events: {},
@@ -851,6 +813,12 @@ const _personhoodMachine = setup({
 			});
 			return cleanup;
 		}),
+		/**
+		* Local verdict — the PRD's primary path. Runs entirely on-device, no
+		* network round-trip. Wrapped in `fromPromise` only so the machine can
+		* `invoke` it the same way it does an async actor; the body itself is
+		* synchronous and returns immediately.
+		*/
 		produceLocalVerdict: fromPromise(async ({ input }) => {
 			return produceLocalVerdict({
 				siteKey: input.config.siteKey,
@@ -860,6 +828,11 @@ const _personhoodMachine = setup({
 				liveness: input.liveness
 			});
 		}),
+		/**
+		* Server fallback — only reached when the on-device path is impossible
+		* (no camera, permission denied, browser unsupported). Integrators see
+		* the same verdict shape either way.
+		*/
 		requestServerFallback: fromPromise(async ({ input, signal }) => {
 			return requestServerFallbackVerdict({
 				siteKey: input.config.siteKey,
@@ -869,6 +842,21 @@ const _personhoodMachine = setup({
 				signal
 			});
 		}),
+		/**
+		* Mints the OAuth2 Bearer token (client-credentials grant) for the
+		* verify hop. Hits `POST /omni/oauth2/token` on the omni base, or —
+		* when `config.authBaseUrl` is set — the auth server's own
+		* `/oauth2/token` directly (see {@link fetchPersonhoodAuthToken}).
+		* Runs in parallel with the other init tasks (signals + Deepsight) so
+		* the network round-trip overlaps
+		* with the WASM and camera-permission work — token is available
+		* by the time the user finishes the capture and we need to
+		* verify. The fetched token is assigned into actor context
+		* (`context.token`) by `setTokenFromEvent` and threaded into the
+		* downstream `analyzeLiveness` and `verifyOnDevice` actors as an
+		* explicit input, isolated from the main `currentToken` other
+		* modules use and from any concurrent personhood instances.
+		*/
 		fetchToken: fromPromise(async ({ input, signal }) => {
 			return fetchPersonhoodAuthToken({
 				clientId: input.config.clientId,
@@ -878,6 +866,14 @@ const _personhoodMachine = setup({
 				signal
 			});
 		}),
+		/**
+		* On-device verify — POST `/omni/personhood/verify` with the
+		* Deepsight metadata + derived `spoofCheckResults`, returns the
+		* server's authoritative verdict. The local verdict from
+		* {@link produceLocalVerdict} is used as a fallback if the
+		* network call fails. This is what becomes the final
+		* `state.verdict` the UI / integrator sees.
+		*/
 		verifyOnDevice: fromPromise(async ({ input, signal }) => {
 			return verifyPersonhoodOnDevice({
 				metadata: input.liveness?.metadata ?? "",
@@ -899,6 +895,12 @@ const _personhoodMachine = setup({
 			};
 		}),
 		setDetectionStatus: assign({ detectionStatus: ({ event }) => event.status }),
+		/**
+		* Commits the final head-pose ranges reported by the detection callback
+		* into context. This happens ONCE at DETECTION_SUCCESS, not per-frame —
+		* keeping pose off the hot XState path prevents React re-renders on
+		* every detector frame.
+		*/
 		setCapturedImageAndRangeFromEvent: assign(({ event }) => {
 			const e = event;
 			return {
@@ -912,6 +914,14 @@ const _personhoodMachine = setup({
 		setResetDetection: assign({ resetDetection: ({ event }) => event.reset }),
 		setSignalsFromEvent: assign({ signals: ({ event }) => event.output }),
 		setTokenFromEvent: assign({ token: ({ event }) => event.output }),
+		/**
+		* Stash the local verdict from the `processing` step's actor
+		* output so the subsequent `verifyOnServer` step can use it as a
+		* fallback if the network call fails. The same event also drives
+		* `setVerdictFromEvent` (the existing action), but that one
+		* writes to `verdict` — which we DON'T want to set yet because
+		* the final verdict comes from the server.
+		*/
 		setLocalVerdictFromEvent: assign({ localVerdict: ({ event }) => event.output }),
 		setVerdictFromEvent: assign({ verdict: ({ event }) => event.output }),
 		setPermissionResultFromEvent: assign({ permissionResult: ({ event }) => event.output }),
@@ -920,6 +930,11 @@ const _personhoodMachine = setup({
 			error: () => ({ code: PERSONHOOD_ERROR_CODES.CAMERA_DENIED })
 		}),
 		setDetectionError: assign({ error: () => ({ code: PERSONHOOD_ERROR_CODES.DETECTION_FAILED }) }),
+		/**
+		* Records that the server-fallback path is being taken because the camera
+		* could not be initialized (no device / OS block), so the fallback verdict
+		* reports `no_camera` rather than the default `permission_denied`.
+		*/
 		setFallbackReasonNoCamera: assign({ fallbackReason: () => "no_camera" }),
 		setTokenError: assign({ error: ({ event }) => ({
 			code: PERSONHOOD_ERROR_CODES.AUTH_TOKEN_FAILED,
@@ -929,10 +944,21 @@ const _personhoodMachine = setup({
 			code: PERSONHOOD_ERROR_CODES.VERIFY_FAILED,
 			message: String(event.error ?? "verify failed")
 		}) }),
+		/**
+		* Local-synthesis failure — the deterministic on-device verdict
+		* computation threw. Distinct from `setVerifyError` which is for
+		* the server verify hop; the verify hop never even ran here.
+		*/
 		setLocalVerdictError: assign({ error: ({ event }) => ({
 			code: PERSONHOOD_ERROR_CODES.UNKNOWN,
 			message: String(event.error ?? "local verdict synthesis failed")
 		}) }),
+		/**
+		* Server verify hop failed unrecoverably — fall back to the local
+		* verdict the integrator can still trust. Named (vs. an inline
+		* `assign`) so the machine config stays consistent with
+		* `setup({ actions: { ... } })`'s typed-action contract.
+		*/
 		setVerdictToLocal: assign({ verdict: ({ context }) => context.localVerdict }),
 		stopMediaStream: assign(({ context }) => {
 			context.frameCapturer?.dispose();
@@ -1017,6 +1043,12 @@ const _personhoodMachine = setup({
 			guard: "hasShowTutorial"
 		}, { target: "collectingSignals" }] } },
 		tutorial: { on: { NEXT_STEP: { target: "collectingSignals" } } },
+		/**
+		* Two prep tasks run in parallel: collect device/behavioral signals and
+		* boot the Deepsight session (PRC warmup). Both are needed before we
+		* touch the camera; running them concurrently keeps the pre-capture
+		* latency budget under the PRD's 1.5s p50 target.
+		*/
 		collectingSignals: {
 			type: "parallel",
 			states: {
@@ -1054,6 +1086,20 @@ const _personhoodMachine = setup({
 						done: { type: "final" }
 					}
 				},
+				/**
+				* Third parallel branch — fetches the personhood session
+				* token. Latency-overlap with signals + Deepsight init so
+				* the network round-trip is "free" by the time the user
+				* finishes capturing. The mock-verify path returns a
+				* synthetic token without hitting the network, so this
+				* branch only fails when a real backend was configured AND
+				* the call genuinely failed (non-2xx, network error,
+				* missing token in the response). In that case we record
+				* the error and let the parallel `onDone` route the flow
+				* to the terminal `error` state — there's no point opening
+				* the camera if we know we can't authenticate the verify
+				* hop afterwards.
+				*/
 				token: {
 					initial: "running",
 					states: {
@@ -1190,6 +1236,12 @@ const _personhoodMachine = setup({
 				}
 			}
 		},
+		/**
+		* On-device liveness analysis — Deepsight virtual-camera check + pipeline
+		* analysis + pose-motion range. Runs after a good capture but before we
+		* synthesize the verdict, so {@link produceLocalVerdict} can fold these
+		* signals in. This is the actual "local liveness" step per PRD #4.
+		*/
 		analyzing: {
 			exit: "stopMediaStream",
 			invoke: {
@@ -1228,6 +1280,14 @@ const _personhoodMachine = setup({
 				actions: "setLocalVerdictError"
 			}
 		} },
+		/**
+		* On-device verify hop. Sends the Deepsight metadata + derived
+		* `spoofCheckResults` to `/omni/personhood/verify` (authenticated
+		* with `Authorization: Bearer <token>`) and uses the server's
+		* response as the final verdict. Falls back to the local
+		* verdict if the network call fails — better to deliver SOMETHING
+		* than nothing, but a reachable backend always wins.
+		*/
 		verifyingOnServer: { invoke: {
 			id: "verifyOnDevice",
 			src: "verifyOnDevice",
@@ -1246,6 +1306,12 @@ const _personhoodMachine = setup({
 				actions: "setVerdictToLocal"
 			}
 		} },
+		/**
+		* Server fallback path — only reached when on-device liveness can't run
+		* (currently: after the user explicitly denies camera permission). The
+		* network call is gated by `config.mockVerify` the same as the primary
+		* path, so the dev demo works offline.
+		*/
 		serverFallback: { invoke: {
 			id: "requestServerFallback",
 			src: "requestServerFallback",
@@ -1277,14 +1343,6 @@ const _personhoodMachine = setup({
 		}
 	}
 });
-/**
-* Public machine value. Typed as `AnyStateMachine` for declaration file
-* portability — mirrors the convention used by `selfieMachine` and the
-* other Core modules. Type safety is enforced by the `setup()` config
-* above, not by the exported binding.
-*/
-const personhoodMachine = _personhoodMachine;
-
 //#endregion
 //#region src/modules/personhood/personhoodActor.ts
 /**
@@ -1311,7 +1369,6 @@ function createPersonhoodActor(options) {
 		dependencies
 	} }).start();
 }
-
 //#endregion
 //#region src/modules/personhood/personhoodManager.ts
 /**
@@ -1418,32 +1475,44 @@ function mapState(snapshot) {
 }
 function createApi({ actor, trackElementClicked }) {
 	return {
+		/** Starts the flow (goes to tutorial or capture depending on config). */
 		load() {
 			actor.send({ type: "LOAD" });
 		},
+		/** Advances from tutorial → capture. */
 		nextStep() {
 			trackElementClicked?.("nextStep");
 			actor.send({ type: "NEXT_STEP" });
 		},
+		/** Triggers `getUserMedia` when in `permissions.idle`. */
 		requestPermission() {
 			trackElementClicked?.("requestPermission");
 			actor.send({ type: "REQUEST_PERMISSION" });
 		},
+		/** Shows the permission rationale view. */
 		goToLearnMore() {
 			trackElementClicked?.("goToLearnMore");
 			actor.send({ type: "GO_TO_LEARN_MORE" });
 		},
+		/** Returns from learn-more → permission prompt. */
 		back() {
 			trackElementClicked?.("back");
 			actor.send({ type: "BACK" });
 		},
+		/** Dismisses the widget into the terminal `closed` state. */
 		close() {
 			trackElementClicked?.("close");
 			actor.send({ type: "QUIT" });
 		},
+		/** Resets from the (non-final) `error` state back to `idle`. */
 		reset() {
 			actor.send({ type: "RESET" });
 		},
+		/**
+		* Skip the on-device path and hit the server fallback. Wired to the
+		* "Continue without camera" button on the permission-denied screen; also
+		* dispatched automatically when the device has no camera at all.
+		*/
 		useFallback() {
 			trackElementClicked?.("useFallback");
 			actor.send({ type: "USE_FALLBACK" });
@@ -1501,6 +1570,5 @@ function createPersonhoodManagerFromActor(actor) {
 function createPersonhoodManager(options) {
 	return wrapActor(createPersonhoodActor(options));
 }
-
 //#endregion
-export { PERSONHOOD_ERROR_CODES, createPersonhoodActor, createPersonhoodManager, createPersonhoodManagerFromActor, personhoodMachine };
+export { PERSONHOOD_ERROR_CODES, createPersonhoodActor, createPersonhoodManager, createPersonhoodManagerFromActor, personhoodMachine };

package/dist/phone.d.ts

@@ -1,6 +1,2 @@
-import "./StateMachine-D5WO6lHS.js";
-import "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-import "./otp-B1YeyRXu.js";
-import { n as PhoneState, o as phoneMachine, r as createPhoneManager, s as PhoneConfig, t as PhoneManager } from "./phoneManager-_KtitbUA.js";
+import { n as PhoneState, o as phoneMachine, r as createPhoneManager, s as PhoneConfig, t as PhoneManager } from "./phoneManager-BBU8Lq0O.js";
 export { type PhoneConfig, type PhoneManager, type PhoneState, createPhoneManager, phoneMachine };

package/dist/phone.esm.js

@@ -1,10 +1,3 @@
-import "./BrowserTimerProvider-CHloo0eQ.esm.js";
-import "./api-DsbUi7TO.esm.js";
-import "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import "./xstate.esm-nY3M5UYm.esm.js";
-import "./otp-uaXiKt_R.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-DjFGWMjQ.esm.js";
-import { t as createPhoneManager } from "./phoneManager-CRblfdcI.esm.js";
-
-export { createPhoneManager, phoneMachine };
+import { t as phoneMachine } from "./phoneStateMachine-E1fUUcNM.esm.js";
+import { t as createPhoneManager } from "./phoneManager-Cpiai2IM.esm.js";
+export { createPhoneManager, phoneMachine };

package/dist/{phoneManager-_KtitbUA.d.ts → phoneManager-BBU8Lq0O.d.ts}

@@ -1,9 +1,8 @@
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import { t as ActorRefFrom } from "./Actor-BwgmOPkb.js";
-import { t as OtpValidationErrors } from "./otp-B1YeyRXu.js";
-
+import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+import { t as OtpValidationErrors } from "./otp-CEWfTj9v.js";
 //#region src/modules/phone/types.d.ts
-
 /**
  * Configuration options for phone verification.
  *
@@ -69,7 +68,6 @@ type PhoneValidationErrors = {
 };
 //#endregion
 //#region src/modules/phone/phoneStateMachine.d.ts
-
 declare const phoneMachine: any;
 type PhoneMachine = typeof phoneMachine;
 //#endregion
@@ -80,7 +78,6 @@ 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';