@incodetech/core 2.0.1-rc.0 → 2.1.0-rc.0

package/dist/mandatoryConsentManager-KfIlURRY.d.ts

@@ -0,0 +1,429 @@
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+import { a as RegulationTypes } from "./types-DOUhndhT.js";
+import * as xstate591 from "xstate";
+
+//#region src/modules/mandatory-consent/types.d.ts
+type RegulatoryConsentType = 'MANDATORY' | 'ML';
+type MandatoryConsentConfig = {
+  consentType: RegulationTypes;
+  language?: string;
+  /** 'MANDATORY' (default) for MANDATORY_CONSENT, 'ML' for ML_CONSENT. */
+  type?: RegulatoryConsentType;
+};
+type MandatoryConsent = {
+  id: string;
+  title: string;
+  text: string;
+  description?: string;
+  consentType: string;
+};
+type FetchMandatoryConsentResponse = {
+  consents: MandatoryConsent[];
+};
+//#endregion
+//#region src/modules/mandatory-consent/mandatoryConsentStateMachine.d.ts
+type MandatoryConsentContext = {
+  config: MandatoryConsentConfig;
+  consent: MandatoryConsent | undefined;
+  isSigned: boolean;
+  error: string | undefined;
+};
+type MandatoryConsentInput = {
+  config: MandatoryConsentConfig;
+};
+declare const mandatoryConsentMachine: xstate591.StateMachine<MandatoryConsentContext, {
+  type: "LOAD";
+} | {
+  type: "TOGGLE";
+} | {
+  type: "SUBMIT";
+} | {
+  type: "CANCEL";
+} | {
+  type: "RETRY";
+} | {
+  type: "RESET";
+}, {
+  [x: string]: xstate591.ActorRefFromLogic<xstate591.PromiseActorLogic<FetchMandatoryConsentResponse, {
+    config: MandatoryConsentConfig;
+  }, xstate591.EventObject>> | xstate591.ActorRefFromLogic<xstate591.PromiseActorLogic<void, {
+    consentId: string;
+    isSigned: boolean;
+  }, xstate591.EventObject>> | undefined;
+}, xstate591.Values<{
+  fetchConsent: {
+    src: "fetchConsent";
+    logic: xstate591.PromiseActorLogic<FetchMandatoryConsentResponse, {
+      config: MandatoryConsentConfig;
+    }, xstate591.EventObject>;
+    id: string | undefined;
+  };
+  submitConsent: {
+    src: "submitConsent";
+    logic: xstate591.PromiseActorLogic<void, {
+      consentId: string;
+      isSigned: boolean;
+    }, xstate591.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate591.Values<{
+  setConsent: {
+    type: "setConsent";
+    params: xstate591.NonReducibleUnknown;
+  };
+  setError: {
+    type: "setError";
+    params: xstate591.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate591.NonReducibleUnknown;
+  };
+  toggleSigned: {
+    type: "toggleSigned";
+    params: xstate591.NonReducibleUnknown;
+  };
+  resetContext: {
+    type: "resetContext";
+    params: xstate591.NonReducibleUnknown;
+  };
+}>, {
+  type: "canSubmit";
+  params: unknown;
+}, never, "error" | "idle" | "closed" | "finished" | "loading" | "submitting" | "display", string, MandatoryConsentInput, xstate591.NonReducibleUnknown, xstate591.EventObject, xstate591.MetaObject, {
+  readonly id: "mandatoryConsent";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "fetchConsent" | "submitConsent">(logic: TSrc, ...[options]: ({
+        src: "fetchConsent";
+        logic: xstate591.PromiseActorLogic<FetchMandatoryConsentResponse, {
+          config: MandatoryConsentConfig;
+        }, xstate591.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "fetchConsent";
+        logic: xstate591.PromiseActorLogic<FetchMandatoryConsentResponse, {
+          config: MandatoryConsentConfig;
+        }, xstate591.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate591.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate591.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate591.RequiredActorOptions<T>]: unknown }) | undefined], xstate591.IsNotNever<xstate591.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "submitConsent";
+        logic: xstate591.PromiseActorLogic<void, {
+          consentId: string;
+          isSigned: boolean;
+        }, xstate591.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "submitConsent";
+        logic: xstate591.PromiseActorLogic<void, {
+          consentId: string;
+          isSigned: boolean;
+        }, xstate591.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate591.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate591.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate591.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate591.IsNotNever<xstate591.RequiredActorOptions<T_1>>> : never : never : never)): xstate591.ActorRefFromLogic<xstate591.GetConcreteByKey<xstate591.Values<{
+        fetchConsent: {
+          src: "fetchConsent";
+          logic: xstate591.PromiseActorLogic<FetchMandatoryConsentResponse, {
+            config: MandatoryConsentConfig;
+          }, xstate591.EventObject>;
+          id: string | undefined;
+        };
+        submitConsent: {
+          src: "submitConsent";
+          logic: xstate591.PromiseActorLogic<void, {
+            consentId: string;
+            isSigned: boolean;
+          }, xstate591.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate591.AnyActorLogic>(src: TLogic, ...[options]: xstate591.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate591.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate591.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate591.IsNotNever<xstate591.RequiredLogicInput<TLogic>>>): xstate591.ActorRefFromLogic<TLogic>;
+    };
+    input: MandatoryConsentInput;
+    self: xstate591.ActorRef<xstate591.MachineSnapshot<MandatoryConsentContext, {
+      type: "LOAD";
+    } | {
+      type: "TOGGLE";
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "CANCEL";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "RESET";
+    }, Record<string, xstate591.AnyActorRef | undefined>, xstate591.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "TOGGLE";
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "CANCEL";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "RESET";
+    }, xstate591.AnyEventObject>;
+  }) => {
+    config: MandatoryConsentConfig;
+    consent: undefined;
+    isSigned: false;
+    error: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly id: "fetchConsent";
+        readonly src: "fetchConsent";
+        readonly input: ({
+          context
+        }: {
+          context: MandatoryConsentContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          };
+          self: xstate591.ActorRef<xstate591.MachineSnapshot<MandatoryConsentContext, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, Record<string, xstate591.AnyActorRef>, xstate591.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, xstate591.AnyEventObject>;
+        }) => {
+          config: MandatoryConsentConfig;
+        };
+        readonly onDone: {
+          readonly target: "display";
+          readonly actions: "setConsent";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly display: {
+      readonly on: {
+        readonly TOGGLE: {
+          readonly actions: "toggleSigned";
+        };
+        readonly SUBMIT: {
+          readonly target: "submitting";
+          readonly guard: "canSubmit";
+        };
+        readonly CANCEL: {
+          readonly target: "closed";
+        };
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+      };
+    };
+    readonly submitting: {
+      readonly invoke: {
+        readonly id: "submitConsent";
+        readonly src: "submitConsent";
+        readonly input: ({
+          context
+        }: {
+          context: MandatoryConsentContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          };
+          self: xstate591.ActorRef<xstate591.MachineSnapshot<MandatoryConsentContext, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, Record<string, xstate591.AnyActorRef>, xstate591.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, xstate591.AnyEventObject>;
+        }) => {
+          consentId: string;
+          isSigned: boolean;
+        };
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: {
+          readonly target: "display";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+        readonly CANCEL: {
+          readonly target: "closed";
+        };
+        readonly RESET: {
+          readonly target: "idle";
+          readonly actions: "resetContext";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly closed: {
+      readonly type: "final";
+    };
+  };
+}>;
+type MandatoryConsentMachine = typeof mandatoryConsentMachine;
+//#endregion
+//#region src/modules/mandatory-consent/mandatoryConsentActor.d.ts
+type CreateMandatoryConsentActorOptions = {
+  config: MandatoryConsentConfig;
+};
+type MandatoryConsentActor = ActorRefFrom<MandatoryConsentMachine>;
+//#endregion
+//#region src/modules/mandatory-consent/mandatoryConsentManager.d.ts
+type MandatoryConsentIdleState = {
+  status: 'idle';
+};
+type MandatoryConsentLoadingState = {
+  status: 'loading';
+};
+type MandatoryConsentDisplayState = {
+  status: 'display';
+  title: string;
+  text: string;
+  isSigned: boolean;
+  canSubmit: boolean;
+  error?: string;
+};
+type MandatoryConsentSubmittingState = {
+  status: 'submitting';
+  title: string;
+  text: string;
+  isSigned: boolean;
+  canSubmit: false;
+};
+type MandatoryConsentFinishedState = {
+  status: 'finished';
+};
+type MandatoryConsentClosedState = {
+  status: 'closed';
+};
+type MandatoryConsentErrorState = {
+  status: 'error';
+  error: string;
+};
+type MandatoryConsentState = MandatoryConsentIdleState | MandatoryConsentLoadingState | MandatoryConsentDisplayState | MandatoryConsentSubmittingState | MandatoryConsentFinishedState | MandatoryConsentClosedState | MandatoryConsentErrorState;
+declare function createMandatoryConsentManager(options: CreateMandatoryConsentActorOptions): Manager<MandatoryConsentState> & {
+  load(): void;
+  toggle(): void;
+  submit(): void;
+  cancel(): void;
+  retry(): void;
+  reset(): void;
+};
+/**
+ * Creates a mandatory-consent manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or for story-isolation testing.
+ */
+declare function createMandatoryConsentManagerFromActor(actor: MandatoryConsentActor): Manager<MandatoryConsentState> & {
+  load(): void;
+  toggle(): void;
+  submit(): void;
+  cancel(): void;
+  retry(): void;
+  reset(): void;
+};
+type MandatoryConsentManager = ReturnType<typeof createMandatoryConsentManager>;
+//#endregion
+export { MandatoryConsentActor as a, createMandatoryConsentManagerFromActor as i, MandatoryConsentState as n, mandatoryConsentMachine as o, createMandatoryConsentManager as r, MandatoryConsentConfig as s, MandatoryConsentManager as t };

package/dist/{mandatoryConsentStateMachine-Cnco1jvn.esm.js → mandatoryConsentStateMachine-DtQNW1ji.esm.js}

@@ -1,14 +1,14 @@
 import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
 
 //#region src/modules/mandatory-consent/mandatoryConsentServices.ts
-async function fetchMandatoryConsent(regulationType, signal) {
+async function fetchMandatoryConsent(regulationType, language, type, signal) {
 	const res = await api.get(endpoints.getConsents, {
 		signal,
 		query: {
-			type: "MANDATORY",
-			language: "en",
+			type,
+			language: language ?? "en",
 			regulationType
 		}
 	});
@@ -29,7 +29,7 @@ const mandatoryConsentMachine = setup({
 		input: {}
 	},
 	actors: {
-		fetchConsent: fromPromise(async ({ input, signal }) => fetchMandatoryConsent(input.config.consentType, signal)),
+		fetchConsent: fromPromise(async ({ input, signal }) => fetchMandatoryConsent(input.config.consentType, input.config.language, input.config.type ?? "MANDATORY", signal)),
 		submitConsent: fromPromise(async ({ input, signal }) => submitMandatoryConsent({ consents: [{
 			id: input.consentId,
 			isSigned: input.isSigned

package/dist/openviduLazy-B8L--0oe.esm.js

@@ -0,0 +1,3 @@
+import { t as loadOpenVidu } from "./openviduLazy-Dh14JNJc.esm.js";
+
+export { loadOpenVidu };

package/dist/{openviduLazy-Cok70ZSg.esm.js → openviduLazy-Dh14JNJc.esm.js}

@@ -1,10 +1,10 @@
-import { a as __toDynamicImportESM } from "./chunk-CRF6K_H_.esm.js";
+import { a as __toDynamicImportESM } from "./chunk-CMUKZ2uL.esm.js";
 
 //#region ../infra/src/providers/browser/openviduLazy.ts
 let openViduImport;
 async function loadOpenVidu() {
 	if (openViduImport) return openViduImport;
-	openViduImport = import("./lib-BB0B_qQX.esm.js").then(__toDynamicImportESM(1));
+	openViduImport = import("./lib-BY67lgbq.esm.js").then(__toDynamicImportESM(1));
 	return openViduImport;
 }
 

package/dist/otp-CGMdUzBC.esm.js

@@ -0,0 +1,33 @@
+//#region src/shared/otp.ts
+/**
+* Expected length of an OTP verification code.
+*
+* Owned by Core so the phone, email, and government-validation modules — and
+* the UI (via each manager's exposed `otpLength`) — agree on a single value.
+* This is a pure leaf utility: modules import it independently, so it never
+* introduces a dependency between them.
+*/
+const OTP_CODE_LENGTH = 6;
+/** Validation-error code for an OTP code that is not yet complete. */
+const OTP_INCOMPLETE_ERROR = "incompleteOtp";
+/**
+* Returns true when the code has exactly the expected number of characters.
+* Normalization (casing, stripping separators) is the caller's responsibility.
+*/
+function isOtpComplete(code, length = OTP_CODE_LENGTH) {
+	return code.length === length;
+}
+/**
+* Computes client-side OTP validation errors for the given code.
+*
+* Returns `{ otp: OTP_INCOMPLETE_ERROR }` when the code is incomplete (including
+* empty), or an empty object when complete. Mirrors the phone/email
+* `computeValidationErrors` shape so state machines can treat it identically.
+*/
+function computeOtpValidationErrors(code, length = OTP_CODE_LENGTH) {
+	if (!isOtpComplete(code, length)) return { otp: OTP_INCOMPLETE_ERROR };
+	return {};
+}
+
+//#endregion
+export { computeOtpValidationErrors as n, isOtpComplete as r, OTP_CODE_LENGTH as t };

package/dist/otp-DF5A0sFx.d.ts

@@ -0,0 +1,8 @@
+//#region src/shared/otp.d.ts
+
+/** Client-side OTP validation errors, keyed by field. Empty when valid. */
+type OtpValidationErrors = {
+  otp?: string;
+};
+//#endregion
+export { OtpValidationErrors as t };

package/dist/permissionGuards-C1ispV96.esm.js

@@ -0,0 +1,23 @@
+import { a as isWasmMotionPrimedForModule } from "./permissionServices-CG3bMSfG.esm.js";
+
+//#region src/internal/permissions/permissionGuards.ts
+function resolveStoredPermissionResult(fromEvent, fromContext) {
+	if (fromEvent === "granted" || fromEvent === "denied" || fromEvent === "prompt" || fromEvent === "refresh") return fromEvent;
+	return fromContext;
+}
+function isMotionPermissionSatisfiedForDeepsight(ds) {
+	if (ds !== true) return true;
+	return isWasmMotionPrimedForModule();
+}
+function isReadyForCaptureFromPermission(permissionResult, ds) {
+	if (permissionResult !== "granted") return false;
+	return isMotionPermissionSatisfiedForDeepsight(ds);
+}
+function needsMotionPrimeOnlyFromPermission(permissionResult, ds) {
+	if (permissionResult !== "granted") return false;
+	if (ds !== true) return false;
+	return !isWasmMotionPrimedForModule();
+}
+
+//#endregion
+export { needsMotionPrimeOnlyFromPermission as n, resolveStoredPermissionResult as r, isReadyForCaptureFromPermission as t };

package/dist/permissionServices-CG3bMSfG.esm.js

@@ -0,0 +1,130 @@
+import { t as WasmUtilProvider } from "./WasmUtilProvider-CiEN7Gjn.esm.js";
+import { t as MotionSensorProvider } from "./MotionSensorProvider-Bx7Mpzt0.esm.js";
+import { i as stopCameraStream, r as requestCameraAccess } from "./camera-DJWm3V4g.esm.js";
+
+//#region ../infra/src/media/cameraPermissionSession.ts
+const CAMERA_PERMISSIONS_GRANTED_KEY = "cameraPermissionsGranted";
+function isCameraGrantedInSession() {
+	if (typeof sessionStorage === "undefined") return false;
+	return sessionStorage.getItem(CAMERA_PERMISSIONS_GRANTED_KEY) === "true";
+}
+function markCameraPermissionsGrantedInSession() {
+	if (typeof sessionStorage === "undefined") return;
+	sessionStorage.setItem(CAMERA_PERMISSIONS_GRANTED_KEY, String(true));
+}
+
+//#endregion
+//#region ../infra/src/media/permissions.ts
+async function queryPermission(name) {
+	try {
+		if (typeof navigator === "undefined" || !navigator.permissions) return "prompt";
+		return (await navigator.permissions.query({ name })).state;
+	} catch {
+		return "prompt";
+	}
+}
+async function queryCameraPermission() {
+	return queryPermission("camera");
+}
+
+//#endregion
+//#region src/internal/permissions/wasmMotionPrimeState.ts
+let wasmMotionPrimedForModule = false;
+function resetWasmMotionPrimedForModule() {
+	wasmMotionPrimedForModule = false;
+}
+function markWasmMotionPrimedForModule() {
+	wasmMotionPrimedForModule = true;
+}
+function isWasmMotionPrimedForModule() {
+	return wasmMotionPrimedForModule;
+}
+
+//#endregion
+//#region src/internal/permissions/permissionServices.ts
+function isCameraGrantedForMotionPrime(options) {
+	return options.cameraGranted === true || isCameraGrantedInSession();
+}
+async function resolveMotionOsPermission(motionSensor) {
+	if (motionSensor.hasBeenRequestedThisSession()) return "granted";
+	if (motionSensor.hasMotionPermissionDeniedThisSession()) return "denied";
+	return requestMotionOsPermission(motionSensor);
+}
+/**
+* On mobile, motion permission (iOS OS dialog when required) and WASM sensor
+* priming (rsp/ssl) must run during a user gesture. When camera is already
+* granted (cached permission), V1 requests motion on tutorial Continue before
+* any async permission actors run.
+*/
+async function primeMotionFromUserGestureIfNeeded(options) {
+	if (options.ds !== true) return;
+	if (isWasmMotionPrimedForModule()) return;
+	if (!isCameraGrantedForMotionPrime(options)) return;
+	const motionSensor = new MotionSensorProvider();
+	const motionResult = await resolveMotionOsPermission(motionSensor);
+	if (motionResult === "denied") return;
+	if (motionResult !== "granted" && motionResult !== "not-required") return;
+	await primeWasmMotionSensor(motionSensor);
+}
+async function checkPermission() {
+	const queryResult = await queryCameraPermission();
+	if (queryResult === "granted") {
+		markCameraPermissionsGrantedInSession();
+		return "granted";
+	}
+	if (queryResult === "denied") return "denied";
+	return "prompt";
+}
+async function requestMotionOsPermission(motionSensor = new MotionSensorProvider()) {
+	return motionSensor.requestPermission();
+}
+async function primeWasmMotionSensor(motionSensor = new MotionSensorProvider()) {
+	if (motionSensor.hasMotionPermissionDeniedThisSession() || !motionSensor.hasPermission) return false;
+	try {
+		await motionSensor.start();
+		const wasmUtil = await WasmUtilProvider.getInstance();
+		await wasmUtil.rsp();
+		wasmUtil.ssl();
+		markWasmMotionPrimedForModule();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Requests camera permission by attempting to access the camera, then immediately
+* stops the obtained stream. When `requestMotion` is true (deepsight), requests
+* motion OS permission, primes WASM sensors, then camera — all in one user gesture
+* chain, matching SDK v1.
+*/
+async function requestPermission(options = {}) {
+	try {
+		if (options.requestMotion) {
+			const motionSensor = new MotionSensorProvider();
+			if (await resolveMotionOsPermission(motionSensor) === "denied") return "denied";
+			if (!isWasmMotionPrimedForModule()) await primeWasmMotionSensor(motionSensor);
+		}
+		stopCameraStream(await requestCameraAccess({ video: true }));
+		markCameraPermissionsGrantedInSession();
+		return "granted";
+	} catch (error) {
+		const name = error instanceof Error ? error.name : void 0;
+		if (name === "NotAllowedError" || name === "PermissionDeniedError") return "denied";
+		return "prompt";
+	}
+}
+async function invokeRequestPermissionActor(input) {
+	if (!input.requestMotionPermission) return requestPermission();
+	if (input.permissionResult === "granted") {
+		if (!isWasmMotionPrimedForModule()) {
+			const motionSensor = new MotionSensorProvider();
+			if (await resolveMotionOsPermission(motionSensor) === "denied") return "denied";
+			if (!await primeWasmMotionSensor(motionSensor)) return "denied";
+		}
+		return "granted";
+	}
+	return requestPermission({ requestMotion: true });
+}
+
+//#endregion
+export { isWasmMotionPrimedForModule as a, requestPermission as i, invokeRequestPermissionActor as n, resetWasmMotionPrimedForModule as o, primeMotionFromUserGestureIfNeeded as r, checkPermission as t };

package/dist/phone.d.ts

@@ -1,4 +1,5 @@
-import "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.js";
-import { a as phoneMachine, n as PhoneState, o as PhoneConfig, r as createPhoneManager, t as PhoneManager } from "./phoneManager-B6M30hKE.js";
+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";
 export { type PhoneConfig, type PhoneManager, type PhoneState, createPhoneManager, phoneMachine };