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

package/dist/curpValidationManager-RttixpIc.d.ts

@@ -0,0 +1,184 @@
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+import { i as FlowModuleConfig } from "./types-DOUhndhT.js";
+
+//#region src/modules/curp-validation/types.d.ts
+type CurpValidationConfig = FlowModuleConfig['CURP_VALIDATION'] & {
+  /** Maximum validation retries before auto-advancing. @default 1 */
+  maxRetries?: number;
+  /** Whether to attempt OCR pre-fill on load. @default true */
+  prefillFromOcr?: boolean;
+};
+/** CURP generation form data */
+type GenerateCurpForm = {
+  name: string;
+  firstLastName: string;
+  secondLastName: string;
+  gender: 'H' | 'M' | 'X' | '';
+  birthDate: string;
+  birthState: string;
+};
+type GenerateCurpFieldType = 'text' | 'date' | 'dropdown';
+/**
+ * Discriminated union of validation rules supported across both CURP screens.
+ * `required` is used by Generate-CURP fields; `curpFormat` is used by the
+ * single-field CURP entry.
+ */
+type CurpValidationRule = {
+  type: 'required';
+} | {
+  type: 'curpFormat';
+};
+type GenerateCurpFieldDef = {
+  key: keyof GenerateCurpForm;
+  labelKey: string;
+  type: GenerateCurpFieldType;
+  required: boolean;
+  autoComplete?: string;
+  /**
+   * Validation rules evaluated by the state machine on blur (per-field) and
+   * on submit (full form). Required fields should include `{ type: 'required' }`.
+   * Optional fields (e.g. `secondLastName`) omit this entirely.
+   */
+  validation?: CurpValidationRule[];
+};
+/**
+ * Configuration for the single CURP-entry field on the gateway screen.
+ * Intentionally has no `required` rule: the user can leave it empty and
+ * use the "I don't have my CURP" escape-hatch button instead.
+ */
+type EnterCurpFieldDef = {
+  key: 'curp';
+  labelKey: string;
+  validation?: CurpValidationRule[];
+};
+/**
+ * Map of field-key → i18n error key currently displayed for that field.
+ * Empty/undefined means no errors are currently shown. The state machine
+ * is the single source of truth for which entries exist here — UI must
+ * render this map as-is without further gating.
+ */
+type CurpValidationErrors = Partial<Record<string, string>>;
+//#endregion
+//#region src/modules/curp-validation/curpValidationStateMachine.d.ts
+
+declare const curpValidationMachine: any;
+type CurpValidationMachine = typeof curpValidationMachine;
+//#endregion
+//#region src/modules/curp-validation/curpValidationActor.d.ts
+type CreateCurpValidationActorOptions = {
+  config: CurpValidationConfig;
+};
+type CurpValidationActor = ActorRefFrom<CurpValidationMachine>;
+//#endregion
+//#region src/modules/curp-validation/curpValidationManager.d.ts
+type CurpValidationIdleState = {
+  status: 'idle';
+};
+type CurpValidationLoadingState = {
+  status: 'loading';
+};
+/**
+ * State exposed to UI for the CURP entry gateway screen.
+ *
+ * `isValid` is **derived** from `validationErrors`: it is `true` whenever
+ * no errors are currently displayed (including the initial empty render).
+ * The UI must not treat `isValid` as "the form would pass full validation
+ * right now" — that was the old pessimistic semantic. Use the absence of
+ * errors plus an additional `curp.length === 0` no-op guard on the submit
+ * button instead.
+ */
+type CurpValidationEnterCurpState = {
+  status: 'enterCurp';
+  curp: string;
+  isValid: boolean;
+  validationErrors?: CurpValidationErrors;
+};
+type CurpValidationVerifyingState = {
+  status: 'verifying';
+};
+type CurpValidationSuccessState = {
+  status: 'success';
+};
+type CurpValidationFailureState = {
+  status: 'failure';
+  retriesLeft: number;
+  /** True for auto OCR-prefilled failures; UI shows "Verify manually". */
+  fromAutoVerify: boolean;
+};
+/**
+ * State exposed to UI for the multi-field Generate CURP form.
+ *
+ * `isValid` is derived: `true` when no errors are currently displayed.
+ * Validation runs on blur (single field) and on submit (full form);
+ * `validationErrors` reflects exactly what should be rendered next
+ * to each input.
+ */
+type CurpValidationGenerateCurpState = {
+  status: 'generateCurp';
+  form: GenerateCurpForm;
+  isValid: boolean;
+  validationErrors?: CurpValidationErrors;
+};
+type CurpValidationGeneratingState = {
+  status: 'generating';
+};
+type CurpValidationConfirmCurpState = {
+  status: 'confirmCurp';
+  curp: string;
+};
+type CurpValidationGenerateErrorState = {
+  status: 'generateError';
+  retriesLeft: number;
+};
+type CurpValidationFinishedState = {
+  status: 'finished';
+};
+type CurpValidationClosedState = {
+  status: 'closed';
+};
+type CurpValidationState = CurpValidationIdleState | CurpValidationLoadingState | CurpValidationEnterCurpState | CurpValidationVerifyingState | CurpValidationSuccessState | CurpValidationFailureState | CurpValidationGenerateCurpState | CurpValidationGeneratingState | CurpValidationConfirmCurpState | CurpValidationGenerateErrorState | CurpValidationFinishedState | CurpValidationClosedState;
+declare function createCurpValidationManager(options: CreateCurpValidationActorOptions): Manager<CurpValidationState> & {
+  load(): void;
+  setCurp(curp: string): void;
+  /**
+   * Triggers single-field on-blur validation. The state machine routes
+   * the event to the validator for the currently active screen and
+   * updates the corresponding `validationErrors` map. Sending a field
+   * key that does not belong to the active screen is a no-op.
+   */
+  validateField(field: "curp" | keyof GenerateCurpForm): void;
+  verify(): void;
+  switchToGenerate(): void;
+  setGenerateForm(form: Partial<GenerateCurpForm>): void;
+  generate(): void;
+  confirmGenerated(): void;
+  retry(): void;
+  close(): void;
+};
+/**
+ * Creates a CURP-validation manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or for story-isolation testing.
+ */
+declare function createCurpValidationManagerFromActor(actor: CurpValidationActor): Manager<CurpValidationState> & {
+  load(): void;
+  setCurp(curp: string): void;
+  /**
+   * Triggers single-field on-blur validation. The state machine routes
+   * the event to the validator for the currently active screen and
+   * updates the corresponding `validationErrors` map. Sending a field
+   * key that does not belong to the active screen is a no-op.
+   */
+  validateField(field: "curp" | keyof GenerateCurpForm): void;
+  verify(): void;
+  switchToGenerate(): void;
+  setGenerateForm(form: Partial<GenerateCurpForm>): void;
+  generate(): void;
+  confirmGenerated(): void;
+  retry(): void;
+  close(): void;
+};
+type CurpValidationManager = ReturnType<typeof createCurpValidationManager>;
+//#endregion
+export { CurpValidationActor as a, CurpValidationErrors as c, GenerateCurpFieldDef as d, GenerateCurpFieldType as f, createCurpValidationManagerFromActor as i, CurpValidationRule as l, CurpValidationState as n, curpValidationMachine as o, GenerateCurpForm as p, createCurpValidationManager as r, CurpValidationConfig as s, CurpValidationManager as t, EnterCurpFieldDef as u };

package/dist/{curpValidationStateMachine-CitWLr2c.esm.js → curpValidationStateMachine-B7V_qp66.esm.js}

@@ -1,6 +1,6 @@
 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/curp-validation/curpValidationUtils.ts
 const CURP_PATTERN = /^([A-Z][AEIOUX][A-Z]{2}\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])[HMX](?:AS|B[CS]|C[CLMSH]|D[FG]|G[TR]|HG|JC|M[CNS]|N[ETL]|OC|PL|Q[TR]|S[PLR]|T[CSL]|VZ|YN|ZS)[B-DF-HJ-NP-TV-Z]{3}[A-Z\d])(\d)$/;
@@ -196,6 +196,7 @@ const GENERATE_CURP_FIELDS = [
 		labelKey: "curp.labels.firstLast",
 		type: "text",
 		required: true,
+		autoComplete: "family-name",
 		validation: [{ type: "required" }]
 	},
 	{
@@ -216,6 +217,7 @@ const GENERATE_CURP_FIELDS = [
 		labelKey: "curp.labels.dob",
 		type: "date",
 		required: true,
+		autoComplete: "bday",
 		validation: [{ type: "required" }]
 	},
 	{
@@ -392,6 +394,8 @@ const curpValidationMachine = setup({
 		decrementRetries: assign(({ context }) => ({ retriesLeft: Math.max(0, context.retriesLeft - 1) })),
 		setFromGenerate: assign({ fromGenerate: () => true }),
 		clearFromGenerate: assign({ fromGenerate: () => false }),
+		setAutoVerify: assign({ fromAutoVerify: () => true }),
+		clearAutoVerify: assign({ fromAutoVerify: () => false }),
 		setError: assign(({ event }) => ({ error: String(event.error) }))
 	},
 	guards: {
@@ -426,7 +430,8 @@ const curpValidationMachine = setup({
 		retriesLeft: input.config.maxRetries ?? 1,
 		generatedCurp: void 0,
 		error: void 0,
-		fromGenerate: false
+		fromGenerate: false,
+		fromAutoVerify: false
 	}),
 	states: {
 		idle: { on: {
@@ -443,7 +448,7 @@ const curpValidationMachine = setup({
 				onDone: [{
 					target: "verifying",
 					guard: "hasOcrCurp",
-					actions: "setCurpFromOcr"
+					actions: ["setCurpFromOcr", "setAutoVerify"]
 				}, { target: "enterCurp" }],
 				onError: { target: "enterCurp" }
 			},
@@ -469,7 +474,8 @@ const curpValidationMachine = setup({
 					entry: "computeEnterCurpValidationResult",
 					always: [{
 						guard: "shouldVerify",
-						target: "#curpValidation.verifying"
+						target: "#curpValidation.verifying",
+						actions: "clearAutoVerify"
 					}, { target: "inputting" }]
 				}
 			},
@@ -483,13 +489,10 @@ const curpValidationMachine = setup({
 				onDone: [{
 					target: "success",
 					guard: "isVerifySuccess"
-				}, {
-					target: "failure",
-					actions: "decrementRetries"
-				}],
+				}, { target: "failure" }],
 				onError: {
 					target: "failure",
-					actions: ["decrementRetries", "setError"]
+					actions: "setError"
 				}
 			},
 			on: { CLOSE: "closed" }
@@ -502,11 +505,12 @@ const curpValidationMachine = setup({
 			on: {
 				RETRY: [{
 					target: "generateCurp",
-					guard: ({ context }) => context.retriesLeft > 0 && context.fromGenerate
+					guard: ({ context }) => context.retriesLeft > 0 && context.fromGenerate,
+					actions: "decrementRetries"
 				}, {
 					target: "enterCurp",
 					guard: ({ context }) => context.retriesLeft > 0 && !context.fromGenerate,
-					actions: "clearFromGenerate"
+					actions: ["decrementRetries", "clearFromGenerate"]
 				}],
 				CLOSE: "closed"
 			},
@@ -569,7 +573,10 @@ const curpValidationMachine = setup({
 			on: { CLOSE: "closed" }
 		},
 		confirmCurp: { on: {
-			CONFIRM: { target: "verifying" },
+			CONFIRM: {
+				target: "verifying",
+				actions: "clearAutoVerify"
+			},
 			CLOSE: "closed"
 		} },
 		generateError: {

package/dist/custom-fields.d.ts

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.js";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
 
 //#region src/modules/custom-fields/types.d.ts
 type CustomFieldType = 'INTEGER' | 'DOUBLE' | 'BOOLEAN' | 'STRING' | 'DATE';

package/dist/custom-fields.esm.js

@@ -1,8 +1,8 @@
 import { t as api } from "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
-import { t as isoDateToMs } from "./dateUtils-UoN5xswP.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as isoDateToMs } from "./dateUtils-AksLQmgV.esm.js";
 
 //#region src/modules/custom-fields/customFieldsServices.ts
 async function submitCustomFields(params, signal) {

package/dist/custom-watchlist.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
 
 //#region src/modules/custom-watchlist/customWatchlistStateMachine.d.ts
 type CustomWatchlistResult = 'success' | 'skipped';

package/dist/custom-watchlist.esm.js

@@ -1,46 +1,9 @@
 import "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
-import { t as processWatchlist } from "./watchlistServices-DMbUhkBX.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as customWatchlistMachine } from "./customWatchlistStateMachine-HmFybXLX.esm.js";
 
-//#region src/modules/custom-watchlist/customWatchlistStateMachine.ts
-const customWatchlistMachine = setup({
-	types: {
-		context: {},
-		events: {}
-	},
-	actors: { processWatchlist: fromPromise(async ({ signal }) => {
-		await processWatchlist(signal);
-	}) },
-	actions: {
-		markSuccess: assign({ result: "success" }),
-		markSkipped: assign({ result: "skipped" })
-	}
-}).createMachine({
-	id: "customWatchlist",
-	initial: "idle",
-	context: { result: null },
-	states: {
-		idle: { on: { LOAD: { target: "processing" } } },
-		processing: { invoke: {
-			id: "processWatchlist",
-			src: "processWatchlist",
-			onDone: { target: "success" },
-			onError: {
-				target: "finished",
-				actions: "markSkipped"
-			}
-		} },
-		success: { after: { 3e3: {
-			target: "finished",
-			actions: "markSuccess"
-		} } },
-		finished: { type: "final" }
-	}
-});
-
-//#endregion
 //#region src/modules/custom-watchlist/customWatchlistActor.ts
 function createCustomWatchlistActor() {
 	return createActor(customWatchlistMachine).start();

package/dist/customWatchlistStateMachine-HmFybXLX.esm.js

@@ -0,0 +1,50 @@
+import { t as api } from "./api-CESGtpbH.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/custom-watchlist/customWatchlistServices.ts
+async function processWatchlist(signal) {
+	const res = await api.post(endpoints.processWatchlist, {}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.processWatchlist} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/custom-watchlist/customWatchlistStateMachine.ts
+const customWatchlistMachine = setup({
+	types: {
+		context: {},
+		events: {}
+	},
+	actors: { processWatchlist: fromPromise(async ({ signal }) => {
+		await processWatchlist(signal);
+	}) },
+	actions: {
+		markSuccess: assign({ result: "success" }),
+		markSkipped: assign({ result: "skipped" })
+	}
+}).createMachine({
+	id: "customWatchlist",
+	initial: "idle",
+	context: { result: null },
+	states: {
+		idle: { on: { LOAD: { target: "processing" } } },
+		processing: { invoke: {
+			id: "processWatchlist",
+			src: "processWatchlist",
+			onDone: { target: "success" },
+			onError: {
+				target: "finished",
+				actions: "markSkipped"
+			}
+		} },
+		success: { after: { 3e3: {
+			target: "finished",
+			actions: "markSuccess"
+		} } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+export { customWatchlistMachine as t };

package/dist/{deepsightLoader-Cm4JIT_z.esm.js → deepsightLoader-65k1Appi.esm.js}

@@ -1,13 +1,16 @@
-import "./BaseWasmProvider-C_DLEI40.esm.js";
-import { t as WasmUtilProvider } from "./WasmUtilProvider-j98OJf-S.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-CiEN7Gjn.esm.js";
 import "./api-CESGtpbH.esm.js";
-import { r as BrowserEnvironmentProvider, t as IpifyProvider } from "./IpifyProvider-D7jx52AL.esm.js";
-import "./browserSimulation-gxD8cSpM.esm.js";
-import "./camera-PA2Ljri3.esm.js";
-import { t as createDeepsightService } from "./deepsightService-O74l4Y__.esm.js";
-import "./getBrowser-BSXUTWXw.esm.js";
-import "./stats-CIfiPzb1.esm.js";
-import { t as MotionSensorProvider } from "./MotionSensorProvider-4v7xkqAp.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./stats-BMNUG1AU.esm.js";
+import { r as BrowserEnvironmentProvider, t as IpifyProvider } from "./IpifyProvider-D4LWD15E.esm.js";
+import "./browserSimulation-B1dWiXp7.esm.js";
+import "./platform-SKvEfCBh.esm.js";
+import "./getBrowser-C8DP7oTB.esm.js";
+import { t as MotionSensorProvider } from "./MotionSensorProvider-Bx7Mpzt0.esm.js";
+import "./camera-DJWm3V4g.esm.js";
+import "./canvas-SKcRBxsk.esm.js";
+import { t as createDeepsightService } from "./deepsightService-CrHmvx8X.esm.js";
+import "./getDeviceClass-C0olyNFS.esm.js";
 
 //#region ../infra/src/providers/browser/VisibilityProvider.ts
 var VisibilityProvider = class {
@@ -30,11 +33,17 @@ var VisibilityProvider = class {
 	}
 };
 
+//#endregion
+//#region src/internal/deepsight/wasmDsFlag.ts
+async function setWasmDsFlag(storage, enabled) {
+	await storage.set("ds", enabled ? 1 : 0);
+}
+
 //#endregion
 //#region src/internal/deepsight/deepsightLoader.ts
 const SDK_VERSION = "2.0.0";
 async function loadDeepsightSession(options) {
-	await options.storage.set("ds", options.ds ? 1 : 0);
+	await setWasmDsFlag(options.storage, options.ds === true);
 	const service = createDeepsightService({
 		sdkVersion: SDK_VERSION,
 		wasmUtil: await WasmUtilProvider.getInstance(),

package/dist/{deepsightService-CEVxzehb.d.ts → deepsightService-B7ShOkWL.d.ts}

@@ -1,5 +1,4 @@
-import { n as WasmPipeline } from "./warmup-CEcppFiS.js";
-import { t as CameraStream } from "./camera-DBSxa6ML.js";
+import { n as WasmPipeline } from "./warmup-Dg8Lh-50.js";
 
 //#region ../infra/src/capabilities/IRecordingCapability.d.ts
 type RecordingPublisher = {
@@ -178,6 +177,11 @@ type IWasmUtilCapability = {
   isVirtualCamera(label: string | null): boolean;
   prc(): Promise<void>;
   poc(output: VirtualCameraCheckOutput): Promise<void>;
+  rsp(): Promise<void>;
+  ssl(): void;
+  stl(): void;
+  osv(): void;
+  oev(): void;
   ckvcks(data: ArrayBuffer): void;
   getVersions(): Promise<unknown>;
   /**
@@ -186,166 +190,9 @@ type IWasmUtilCapability = {
   dispose(): Promise<void>;
 };
 //#endregion
-//#region ../infra/src/media/canvas.d.ts
-/**
- * Class representing a canvas element for image capture and manipulation.
- */
-declare class IncodeCanvas {
-  canvas: HTMLCanvasElement;
-  private base64Image;
-  private blobData;
-  /**
-   * Creates an {@link IncodeCanvas} from a raw {@link ImageData} frame.
-   * @param imageData - Frame pixels in RGBA format
-   * @returns An {@link IncodeCanvas} containing the provided pixels
-   */
-  static fromImageData(imageData: ImageData): IncodeCanvas;
-  /**
-   * Create a new canvas element.
-   * @param canvas_ - The canvas element to clone.
-   */
-  constructor(canvas_: HTMLCanvasElement);
-  /**
-   * Check if the current canvas is valid.
-   */
-  private checkCanvas;
-  /**
-   * Disposes of resources, including revoking object URLs to prevent memory leaks.
-   */
-  dispose(): void;
-  /**
-   * Release the data stored by IncodeCanvas.
-   */
-  release(): void;
-  /**
-   * Revokes the object URL if one exists, preventing memory leaks.
-   * Use this when you no longer need the preview image URL.
-   */
-  revokeObjectURL(): void;
-  /**
-   * Get the width of the canvas.
-   */
-  width(): number | null;
-  /**
-   * Get the height of the canvas.
-   */
-  height(): number | null;
-  /**
-   * Set the width of the canvas.
-   */
-  setWidth(width: number): void;
-  /**
-   * Set the height of the canvas.
-   */
-  setHeight(height: number): void;
-  /**
-   * Clone the current canvas.
-   */
-  clone(): IncodeCanvas | null;
-  /**
-   * Deep clone the current IncodeCanvas including blob data.
-   */
-  deepClone(): Promise<IncodeCanvas | null>;
-  /**
-   * Returns the drawing context on the canvas.
-   */
-  getContext(contextId: '2d', contextAttributes?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
-  /**
-   * Retrieves the image data from the canvas.
-   */
-  getImageData(): ImageData | null;
-  /**
-   * Updates the base64 representation of the current canvas image.
-   */
-  updateBase64Image(jpegQuality?: number): void;
-  /**
-   * Converts the current canvas element to a base64 string.
-   */
-  getBase64Image(jpegQuality?: number, includeDataURLPrefix?: boolean): string | null;
-  /**
-   * Sets the base64 representation of the current canvas image.
-   */
-  setBase64Image(base64Image: string | null): void;
-  /**
-   * Updates the Blob representation of the current canvas image.
-   */
-  updateBlob(jpegQuality?: number, includeDataURLPrefix?: boolean): void;
-  /**
-   * Converts a base64 string to a Blob and creates a URL for it.
-   */
-  static base64ToBlob(base64: string): {
-    blob: Blob;
-    url: string;
-  } | null;
-  /**
-   * Retrieves the Blob data and its URL from the current canvas.
-   */
-  getBlobData(jpegQuality?: number, includeDataURLPrefix?: boolean): {
-    blob: Blob;
-    url: string;
-  } | null;
-  /**
-   * Sets the Blob data of the current canvas image.
-   */
-  setBlobData(blobData: {
-    blob: Blob;
-    url: string;
-  }): Promise<void>;
-  /**
-   * Returns a resized canvas according to video element size.
-   */
-  getResizedCanvas(videoElementWidth: number, videoElementHeight: number): IncodeCanvas | null;
-}
-//#endregion
-//#region ../infra/src/media/StreamCanvasCapture.d.ts
-type StreamCanvasCaptureOptions = {
-  fps?: number;
-  width?: number;
-  height?: number;
-};
-type StreamCanvasCaptureEventMap = {
-  frame: Event;
-};
-declare class StreamCanvasCapture {
-  private video;
-  private canvas;
-  private ctx;
-  private rafId;
-  private lastFrameTimeSeconds;
-  private lastTickTimeMs;
-  private hasFrame;
-  private disposed;
-  private eventTarget;
-  constructor(stream: CameraStream, options?: StreamCanvasCaptureOptions);
-  addEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
-  removeEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
-  /**
-   * Returns the latest cached frame as an {@link IncodeCanvas}.
-   */
-  getLatestCanvas(): IncodeCanvas | null;
-  /**
-   * Returns the latest cached frame as raw {@link ImageData}.
-   */
-  getLatestFrame(): ImageData | null;
-  /**
-   * Disposes internal resources and stops the capture loop.
-   */
-  dispose(): void;
-  private rafLoop;
-  private tick;
-}
-//#endregion
 //#region ../infra/src/capabilities/IMotionSensorCapability.d.ts
 type MotionStatus = 'PASS' | 'FAIL' | 'UNCLEAR';
 type MotionPermissionState = 'granted' | 'denied' | 'not-required';
-type IMotionSensorCapability = {
-  requestPermission(): Promise<MotionPermissionState>;
-  start(): Promise<void>;
-  stop(): void;
-  check(): MotionStatus;
-  readonly isRunning: boolean;
-  readonly hasPermission: boolean;
-};
 //#endregion
 //#region src/internal/deepsight/metadataService.d.ts
 type MetadataService = {
@@ -391,6 +238,7 @@ type DeepsightService = {
   initialize(disableIpify?: boolean): Promise<void>;
   requestMotionPermission(): Promise<'granted' | 'denied' | 'not-required'>;
   startMotionSensors(): Promise<void>;
+  primeWasmMotionSensor(): Promise<void>;
   stopMotionSensors(): void;
   checkVirtualCamera(videoTrack: MediaStreamTrack): Promise<boolean>;
   performVirtualCameraCheck(sessionToken: string | null, source: FrameSource): Promise<void>;
@@ -409,4 +257,4 @@ type DeepsightPrcCheckParams = {
   constraints: MediaStreamConstraints;
 };
 //#endregion
-export { IWasmUtilCapability as a, IMLProviderCapability as c, IRecordingCapability as d, RecordingConnection as f, IncodeCanvas as i, MLProviderConfig as l, IMotionSensorCapability as n, VirtualCameraCheckOutput as o, StreamCanvasCapture as r, WasmUtilConfig as s, DeepsightService as t, IStorageCapability as u };
+export { IMLProviderCapability as a, IRecordingCapability as c, WasmUtilConfig as i, RecordingConnection as l, IWasmUtilCapability as n, MLProviderConfig as o, VirtualCameraCheckOutput as r, IStorageCapability as s, DeepsightService as t };