@incodetech/core 0.0.0-dev-20260207-ef0d08c → 0.0.0-dev-20260209-168e887

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (40) hide show
  1. package/dist/Actor-uC1hxvGo.d.ts +2 -0
  2. package/dist/{OpenViduLogger-DrE4_cHh.esm.js → OpenViduLogger-Cut9zn-U.esm.js} +1 -1
  3. package/dist/OpenViduLogger-D_YCgaLD.esm.js +3 -0
  4. package/dist/authentication.d.ts +75 -0
  5. package/dist/authentication.esm.js +194 -0
  6. package/dist/{deepsightLoader-CHzDt5p2.esm.js → deepsightLoader-DHzfMqHS.esm.js} +4 -4
  7. package/dist/{deepsightService-D8qaikEi.d.ts → deepsightService-D9Isk8fg.d.ts} +4 -134
  8. package/dist/{deepsightService-C_AyxXhJ.esm.js → deepsightService-DLabZ49g.esm.js} +3 -3
  9. package/dist/email.d.ts +1 -1
  10. package/dist/email.esm.js +4 -4
  11. package/dist/{endpoints-Q2cBwc8v.esm.js → endpoints-CJtl25ka.esm.js} +1 -0
  12. package/dist/{events-BN5bIhsN.esm.js → events-CieIKgPk.esm.js} +3 -2
  13. package/dist/face-match.d.ts +1 -1
  14. package/dist/face-match.esm.js +4 -4
  15. package/dist/faceCaptureManagerFactory-CZgmP4pc.d.ts +227 -0
  16. package/dist/faceCaptureSetup-DRbBF7AJ.esm.js +1202 -0
  17. package/dist/flow.d.ts +2 -2
  18. package/dist/flow.esm.js +3 -3
  19. package/dist/{id-B6VREnGU.esm.js → id-2r4nZyH_.esm.js} +8 -8
  20. package/dist/id.d.ts +6 -4
  21. package/dist/id.esm.js +8 -8
  22. package/dist/{index-BOpNqAs7.d.ts → index-C0SJR9cc.d.ts} +5 -4
  23. package/dist/index.d.ts +7 -4
  24. package/dist/index.esm.js +8 -8
  25. package/dist/{lib-ieMlAKG1.esm.js → lib-BbiUxUyg.esm.js} +2 -2
  26. package/dist/phone.d.ts +1 -1
  27. package/dist/phone.esm.js +4 -4
  28. package/dist/selfie.d.ts +38 -224
  29. package/dist/selfie.esm.js +22 -1145
  30. package/dist/{src-B0UBQ8zw.esm.js → src-BFHUdMI6.esm.js} +3 -3
  31. package/dist/{stats-CpcCA-Ml.esm.js → stats-DuS7aVaJ.esm.js} +1 -1
  32. package/dist/stats.esm.js +2 -2
  33. package/dist/{streamingEvents-DhMoimL8.esm.js → streamingEvents-DM6KFfsz.esm.js} +3 -3
  34. package/dist/types-u31qr1MR.d.ts +133 -0
  35. package/package.json +5 -1
  36. package/dist/OpenViduLogger-B6-UWyJe.esm.js +0 -3
  37. /package/dist/{Manager-CWwvSZqZ.d.ts → Manager-BiAYYF50.d.ts} +0 -0
  38. /package/dist/{api-BkkE6cfa.esm.js → api-Cqrn4bGi.esm.js} +0 -0
  39. /package/dist/{chunk-CiY78uGR.esm.js → chunk-CbPq_V01.esm.js} +0 -0
  40. /package/dist/{types-BHcijCvX.d.ts → types-Dc1nBvy2.d.ts} +0 -0
@@ -0,0 +1,1202 @@
1
+ import { d as addEvent, n as eventModuleNames } from "./events-CieIKgPk.esm.js";
2
+ import { E as createManager, T as stopCameraStream, _ as StreamCanvasProcessingSession, a as FaceDetectionProvider, c as OpenViduRecordingProvider, u as LocalRecordingProvider, v as StreamCanvasCapture, w as requestCameraAccess } from "./src-BFHUdMI6.esm.js";
3
+ import { a as fromPromise, i as fromCallback, n as setup, r as assign, t as endpoints } from "./endpoints-CJtl25ka.esm.js";
4
+ import { a as uploadDeepsightVideo, c as getDeviceClass, i as stopRecording$1, n as createRecordingSession, o as checkPermission, r as startRecording, s as requestPermission, t as streamingEvents } from "./streamingEvents-DM6KFfsz.esm.js";
5
+ import { r as getToken, t as api } from "./api-Cqrn4bGi.esm.js";
6
+ import { t as addDeviceStats } from "./stats-DuS7aVaJ.esm.js";
7
+
8
+ //#region src/internal/faceCapture/faceCaptureManagerFactory.ts
9
+ function getPermissionStatus(snapshot) {
10
+ if (!snapshot.matches("permissions")) return;
11
+ if (snapshot.matches({ permissions: "idle" })) return "idle";
12
+ if (snapshot.matches({ permissions: "learnMore" })) return "learnMore";
13
+ if (snapshot.matches({ permissions: "requesting" })) return "requesting";
14
+ if (snapshot.matches({ permissions: "denied" })) return "denied";
15
+ }
16
+ function getCaptureStatus(snapshot) {
17
+ if (snapshot.matches({ capture: "initializing" })) return "initializing";
18
+ if (snapshot.matches({ capture: "detecting" })) return "detecting";
19
+ if (snapshot.matches({ capture: "capturing" })) return "capturing";
20
+ if (snapshot.matches({ capture: "capturingManual" })) return "capturing";
21
+ if (snapshot.matches({ capture: "uploading" })) return "uploading";
22
+ if (snapshot.matches({ capture: "uploadError" })) return "uploadError";
23
+ if (snapshot.matches({ capture: "success" })) return "success";
24
+ }
25
+ function mapState(snapshot) {
26
+ const { context } = snapshot;
27
+ if (snapshot.matches("idle")) return { status: "idle" };
28
+ if (snapshot.matches("loading")) return { status: "loading" };
29
+ if (snapshot.matches("tutorial")) return { status: "tutorial" };
30
+ if (snapshot.matches("closed")) return { status: "closed" };
31
+ if (snapshot.matches("permissions")) {
32
+ const permissionStatus = getPermissionStatus(snapshot);
33
+ if (permissionStatus === void 0) return {
34
+ status: "permissions",
35
+ permissionStatus: "idle"
36
+ };
37
+ return {
38
+ status: "permissions",
39
+ permissionStatus
40
+ };
41
+ }
42
+ if (snapshot.matches("capture")) return {
43
+ status: "capture",
44
+ captureStatus: getCaptureStatus(snapshot) ?? "initializing",
45
+ stream: context.stream,
46
+ detectionStatus: context.detectionStatus ?? "idle",
47
+ debugFrame: context.debugFrame,
48
+ attemptsRemaining: context.attemptsRemaining ?? 0,
49
+ uploadError: context.uploadError
50
+ };
51
+ if (snapshot.matches("processing")) return { status: "processing" };
52
+ if (snapshot.matches("finished")) return {
53
+ status: "finished",
54
+ processResponse: context.processResponse
55
+ };
56
+ if (snapshot.matches("error")) {
57
+ const errorValue = context.error;
58
+ return {
59
+ status: "error",
60
+ error: typeof errorValue === "string" ? errorValue : errorValue ? errorValue.message : "Unknown error"
61
+ };
62
+ }
63
+ return { status: "idle" };
64
+ }
65
+ function createApi({ actor }) {
66
+ return {
67
+ load() {
68
+ actor.send({ type: "LOAD" });
69
+ },
70
+ nextStep() {
71
+ actor.send({ type: "NEXT_STEP" });
72
+ },
73
+ requestPermission() {
74
+ actor.send({ type: "REQUEST_PERMISSION" });
75
+ },
76
+ goToLearnMore() {
77
+ actor.send({ type: "GO_TO_LEARN_MORE" });
78
+ },
79
+ back() {
80
+ actor.send({ type: "BACK" });
81
+ },
82
+ close() {
83
+ actor.send({ type: "QUIT" });
84
+ },
85
+ reset() {
86
+ actor.send({ type: "RESET" });
87
+ },
88
+ retryCapture() {
89
+ actor.send({ type: "RETRY_CAPTURE" });
90
+ },
91
+ capture() {
92
+ actor.send({ type: "MANUAL_CAPTURE" });
93
+ }
94
+ };
95
+ }
96
+ function createFaceCaptureManager(actor) {
97
+ return createManager({
98
+ actor,
99
+ mapState,
100
+ createApi
101
+ });
102
+ }
103
+
104
+ //#endregion
105
+ //#region src/internal/faceCapture/types.ts
106
+ const FACE_ERROR_CODES = {
107
+ FACE_OCCLUDED: "FACE_OCCLUDED",
108
+ LIVENESS: "LIVENESS_ERROR",
109
+ BRIGHTNESS: "BRIGHTNESS_ERROR",
110
+ LENSES: "LENSES_ERROR",
111
+ MASK: "MASK_ERROR",
112
+ CLOSED_EYES: "CLOSED_EYES_ERROR",
113
+ HEAD_COVER: "HEAD_COVER_ERROR",
114
+ SERVER: "SERVER_ERROR",
115
+ FACE_NOT_FOUND: "FACE_NOT_FOUND",
116
+ MULTIPLE_FACES: "MULTIPLE_FACES",
117
+ TOO_BLURRY: "TOO_BLURRY_ERROR",
118
+ TOO_DARK: "TOO_DARK_ERROR",
119
+ USER_IS_NOT_RECOGNIZED: "USER_IS_NOT_RECOGNIZED",
120
+ SPOOF_ATTEMPT_DETECTED: "SPOOF_ATTEMPT_DETECTED",
121
+ FACE_TOO_DARK: "FACE_TOO_DARK",
122
+ LENSES_DETECTED: "LENSES_DETECTED",
123
+ FACE_MASK_DETECTED: "FACE_MASK_DETECTED",
124
+ CLOSED_EYES_DETECTED: "CLOSED_EYES_DETECTED",
125
+ HEAD_COVER_DETECTED: "HEAD_COVER_DETECTED",
126
+ FACE_CROPPING_FAILED: "FACE_CROPPING_FAILED",
127
+ FACE_TOO_SMALL: "FACE_TOO_SMALL",
128
+ FACE_TOO_BLURRY: "FACE_TOO_BLURRY",
129
+ BAD_PHOTO_QUALITY: "BAD_PHOTO_QUALITY",
130
+ PROCESSING_ERROR: "PROCESSING_ERROR",
131
+ BAD_REQUEST: "BAD_REQUEST",
132
+ NONEXISTENT_CUSTOMER: "NONEXISTENT_CUSTOMER",
133
+ HINT_NOT_PROVIDED: "HINT_NOT_PROVIDED",
134
+ SELFIE_IMAGE_LOW_QUALITY: "SELFIE_IMAGE_LOW_QUALITY"
135
+ };
136
+
137
+ //#endregion
138
+ //#region src/modules/selfie/selfieUploadService.ts
139
+ /**
140
+ * Uploads a selfie image to the backend.
141
+ */
142
+ async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal, metadata, recordingId }) {
143
+ try {
144
+ const payload = {
145
+ base64Image: encryptedBase64Image,
146
+ faceCoordinates: faceCoordinates ?? void 0,
147
+ encrypted: true,
148
+ clientInfo: { deviceClass: getDeviceClass() },
149
+ metadata: metadata ?? void 0
150
+ };
151
+ const query = { imageType: "selfie" };
152
+ if (recordingId) query.recordingId = recordingId;
153
+ const res = await api.post(endpoints.selfie, payload, {
154
+ signal,
155
+ query
156
+ });
157
+ if (!res.ok) throw new Error(`POST ${endpoints.selfie} failed: ${res.status} ${res.statusText}`);
158
+ return res.data;
159
+ } catch (error) {
160
+ const errorCode = getFaceErrorCodeFromHttpError(error);
161
+ if (errorCode) throw new Error(errorCode);
162
+ throw new Error(FACE_ERROR_CODES.SERVER);
163
+ }
164
+ }
165
+ const getFaceErrorCodeFromHttpError = (error) => {
166
+ const err = error;
167
+ if (err.ok !== false || typeof err.status !== "number") return;
168
+ if (err.status !== 400) return FACE_ERROR_CODES.SERVER;
169
+ if (typeof err.data?.status !== "number") return FACE_ERROR_CODES.BAD_REQUEST;
170
+ return {
171
+ 3004: FACE_ERROR_CODES.FACE_NOT_FOUND,
172
+ 3005: FACE_ERROR_CODES.FACE_NOT_FOUND,
173
+ 3006: FACE_ERROR_CODES.TOO_BLURRY,
174
+ 3007: FACE_ERROR_CODES.TOO_DARK,
175
+ 4010: FACE_ERROR_CODES.MULTIPLE_FACES,
176
+ 4019: FACE_ERROR_CODES.FACE_NOT_FOUND,
177
+ 4077: FACE_ERROR_CODES.BAD_PHOTO_QUALITY,
178
+ 4078: FACE_ERROR_CODES.FACE_OCCLUDED
179
+ }[err.data.status] ?? FACE_ERROR_CODES.BAD_REQUEST;
180
+ };
181
+ async function processFace(imageType = "selfie", signal) {
182
+ return (await api.post(endpoints.processFace, {}, {
183
+ query: { imageType },
184
+ signal
185
+ })).data;
186
+ }
187
+
188
+ //#endregion
189
+ //#region src/internal/faceCapture/faceCaptureServices.ts
190
+ function sendLabelInspectionEvent() {
191
+ return addDeviceStats({ cameraLabelInspectionStatus: "FAIL" });
192
+ }
193
+ const CAMERA_CONSTRAINTS = {
194
+ video: {
195
+ facingMode: "user",
196
+ height: { ideal: 480 },
197
+ width: { ideal: 640 }
198
+ },
199
+ audio: false
200
+ };
201
+ function stopStream(stream) {
202
+ stopCameraStream(stream);
203
+ }
204
+ async function initializeCamera(params) {
205
+ const { config } = params;
206
+ const provider = new FaceDetectionProvider();
207
+ await provider.initialize({ autocaptureInterval: config.autoCaptureTimeout * 1e3 });
208
+ provider.setChecksEnabled({
209
+ lenses: config.validateLenses ?? false,
210
+ mask: config.validateFaceMask ?? false,
211
+ closedEyes: config.validateClosedEyes ?? false,
212
+ headWear: config.validateHeadCover ?? false,
213
+ occlusion: false
214
+ });
215
+ await params.deepsightService.performPrcCheck({ constraints: { video: CAMERA_CONSTRAINTS.video } });
216
+ return {
217
+ stream: await requestCameraAccess({
218
+ video: CAMERA_CONSTRAINTS.video,
219
+ audio: false
220
+ }),
221
+ provider
222
+ };
223
+ }
224
+ /**
225
+ * Encrypts the provided selfie image using WASM.
226
+ */
227
+ async function encryptSelfieImage({ canvas, dependencies }) {
228
+ const base64Image = canvas.getBase64Image();
229
+ if (!base64Image) throw new Error("Canvas image is empty or null");
230
+ return (await dependencies.getWasmUtil()).encryptImage(base64Image);
231
+ }
232
+ function startDetection(params) {
233
+ let lastStatus;
234
+ let session;
235
+ const { provider } = params;
236
+ const setStatus = (status) => {
237
+ if (session?.isDisposed() === true) return;
238
+ if (lastStatus === status) return;
239
+ lastStatus = status;
240
+ params.onUpdate(status);
241
+ };
242
+ const stopDetectionLoop = () => {
243
+ session?.dispose();
244
+ };
245
+ const reset = () => {
246
+ provider.reset();
247
+ };
248
+ const cleanup = () => {
249
+ stopDetectionLoop();
250
+ };
251
+ (async () => {
252
+ try {
253
+ provider.setCallbacks({
254
+ onFarAway: () => setStatus("tooFar"),
255
+ onTooClose: () => setStatus("tooClose"),
256
+ onTooManyFaces: () => setStatus("tooManyFaces"),
257
+ onNoFace: () => setStatus("idle"),
258
+ onCenterFace: () => setStatus("centerFace"),
259
+ onGetReady: () => setStatus("getReady"),
260
+ onGetReadyFinished: () => setStatus("getReadyFinished"),
261
+ onDark: () => {
262
+ if (params.config.validateBrightness) setStatus("dark");
263
+ },
264
+ onBlur: () => setStatus("blur"),
265
+ onFaceAngle: () => setStatus("faceAngle"),
266
+ onLenses: () => {
267
+ if (params.config.validateLenses) setStatus("lenses");
268
+ },
269
+ onMask: () => {
270
+ if (params.config.validateFaceMask) setStatus("faceMask");
271
+ },
272
+ onEyesClosed: () => {
273
+ if (params.config.validateClosedEyes) setStatus("eyesClosed");
274
+ },
275
+ onHeadWear: () => {
276
+ if (params.config.validateHeadCover) setStatus("headWear");
277
+ },
278
+ onFaceOccluded: () => {},
279
+ onSwitchToManualCapture: () => {
280
+ setStatus("manualCapture");
281
+ stopDetectionLoop();
282
+ },
283
+ onCapture: (canvas, faceCoordinates) => {
284
+ setStatus("success");
285
+ params.onSuccess(canvas, faceCoordinates);
286
+ cleanup();
287
+ }
288
+ });
289
+ setStatus("detecting");
290
+ session = new StreamCanvasProcessingSession({
291
+ capturer: params.capturer,
292
+ provider,
293
+ onFrame: params.onFrame
294
+ });
295
+ } catch {
296
+ setStatus("error");
297
+ cleanup();
298
+ }
299
+ })();
300
+ return {
301
+ cleanup,
302
+ reset
303
+ };
304
+ }
305
+ function buildResolutionFromStream(stream) {
306
+ const track = stream.getVideoTracks()[0];
307
+ if (!track) return;
308
+ const settings = track.getSettings();
309
+ const width = settings.width;
310
+ const height = settings.height;
311
+ if (typeof width === "number" && typeof height === "number") return `${width}x${height}`;
312
+ }
313
+ async function startRecordingSession(params) {
314
+ if (params.config.deepsightLiveness === "VIDEOLIVENESS") return;
315
+ if (params.config.enableFaceRecording !== true) return;
316
+ if (params.existing) return params.existing;
317
+ const provider = params.config.recording?.capability ?? new OpenViduRecordingProvider();
318
+ const clonedStream = params.clonedStream;
319
+ const hasAudio = clonedStream.getAudioTracks().length > 0;
320
+ const resolution = buildResolutionFromStream(clonedStream);
321
+ const session = await createRecordingSession("selfie");
322
+ const connection = await provider.connect({
323
+ sessionToken: session.token,
324
+ stream: clonedStream,
325
+ events: {
326
+ onSessionConnected: (sessionId) => {
327
+ addEvent({
328
+ code: streamingEvents.strSessionDidConnect,
329
+ module: eventModuleNames.selfie,
330
+ payload: {
331
+ message: "Recording session connected",
332
+ sessionId
333
+ }
334
+ });
335
+ },
336
+ onSessionDisconnected: (sessionId) => {
337
+ addEvent({
338
+ code: streamingEvents.strSessionDidDisconnect,
339
+ module: eventModuleNames.selfie,
340
+ payload: {
341
+ message: "Recording session disconnected",
342
+ sessionId
343
+ }
344
+ });
345
+ },
346
+ onSessionException: (event) => {
347
+ addEvent({
348
+ code: streamingEvents.strSessionDidFailWithError,
349
+ module: eventModuleNames.selfie,
350
+ payload: {
351
+ message: "Recording session failed due to an error",
352
+ eventName: event.name,
353
+ type: "OpenViduException",
354
+ errorMessage: event.message,
355
+ sessionId: event.sessionId
356
+ }
357
+ });
358
+ },
359
+ onPublisherCreated: (p) => {
360
+ addEvent({
361
+ code: streamingEvents.strStreamPublisherCreated,
362
+ module: eventModuleNames.selfie,
363
+ payload: {
364
+ message: "Recording publisher created",
365
+ sessionId: p.sessionId,
366
+ streamId: p.streamId
367
+ }
368
+ });
369
+ },
370
+ onPublisherError: (p) => {
371
+ addEvent({
372
+ code: streamingEvents.strStreamPublisherDidFailWithError,
373
+ module: eventModuleNames.selfie,
374
+ payload: {
375
+ message: "Recording publisher failed due to an error",
376
+ sessionId: p.sessionId,
377
+ streamId: p.streamId,
378
+ error: { message: p.message ?? "Unknown error" }
379
+ }
380
+ });
381
+ }
382
+ }
383
+ });
384
+ await startRecording({
385
+ videoRecordingId: session.videoRecordingId,
386
+ type: "selfie",
387
+ resolution,
388
+ hasAudio
389
+ });
390
+ addEvent({
391
+ code: streamingEvents.strStreamVideoCaptureStart,
392
+ module: eventModuleNames.selfie,
393
+ payload: {
394
+ message: "Recording capture started",
395
+ resolution,
396
+ videoRecordingId: session.videoRecordingId,
397
+ sessionId: session.sessionId,
398
+ streamId: connection.publisher.getStreamId()
399
+ }
400
+ });
401
+ return {
402
+ token: session.token,
403
+ sessionId: session.sessionId,
404
+ videoRecordingId: session.videoRecordingId,
405
+ connection,
406
+ resolution,
407
+ hasAudio
408
+ };
409
+ }
410
+ function stopRecording(session) {
411
+ (async () => {
412
+ try {
413
+ addEvent({
414
+ code: streamingEvents.strStreamVideoCaptureStop,
415
+ module: eventModuleNames.selfie,
416
+ payload: {
417
+ message: "Recording capture stopped",
418
+ videoRecordingId: session.videoRecordingId,
419
+ sessionId: session.sessionId,
420
+ streamId: session.connection.publisher.getStreamId()
421
+ }
422
+ });
423
+ await stopRecording$1(session.videoRecordingId);
424
+ addEvent({
425
+ code: streamingEvents.strStreamPublisherDestroyed,
426
+ module: eventModuleNames.selfie,
427
+ payload: {
428
+ message: "Recording publisher destroyed",
429
+ sessionId: session.sessionId,
430
+ streamId: session.connection.publisher.getStreamId()
431
+ }
432
+ });
433
+ } finally {
434
+ await session.connection.disconnect();
435
+ addEvent({
436
+ code: streamingEvents.strSessionDidDisconnect,
437
+ module: eventModuleNames.selfie,
438
+ payload: {
439
+ message: "Recording session disconnected",
440
+ sessionId: session.sessionId
441
+ }
442
+ });
443
+ }
444
+ })();
445
+ }
446
+ async function initializeDeepsightSession(options) {
447
+ const { loadDeepsightSession } = await import("./deepsightLoader-DHzfMqHS.esm.js");
448
+ return loadDeepsightSession({
449
+ ds: options.ds,
450
+ storage: options.storage
451
+ });
452
+ }
453
+
454
+ //#endregion
455
+ //#region src/internal/faceCapture/recordingService.ts
456
+ /**
457
+ * Records on-device and uploads encrypted video for liveness.
458
+ */
459
+ var LocalRecordingService = class {
460
+ constructor(wasmUtil, sessionToken) {
461
+ this.recorder = new LocalRecordingProvider();
462
+ this.sessionToken = sessionToken;
463
+ this.wasmUtil = wasmUtil;
464
+ }
465
+ async start(stream) {
466
+ this.recorder.startRecording(stream);
467
+ }
468
+ async stop() {
469
+ if (!this.recorder.isRecording) return { recordingId: null };
470
+ const result = await this.recorder.stopRecording(10, (base64) => this.wasmUtil.encryptImage(base64), (buffer) => this.wasmUtil.ckvcks(buffer));
471
+ if (!this.sessionToken) return { recordingId: null };
472
+ return { recordingId: await uploadDeepsightVideo(result.encryptedVideo, this.sessionToken) };
473
+ }
474
+ cleanup() {
475
+ this.recorder.reset();
476
+ }
477
+ };
478
+ /**
479
+ * Records through OpenVidu and manages the session lifecycle.
480
+ */
481
+ var OpenViduRecordingService = class {
482
+ constructor(config) {
483
+ this.provider = new OpenViduRecordingProvider();
484
+ this.config = config;
485
+ }
486
+ async start(stream) {
487
+ this.session = await startRecordingSession({
488
+ config: {
489
+ ...this.config,
490
+ recording: { capability: this.provider }
491
+ },
492
+ clonedStream: stream.clone(),
493
+ existing: this.session
494
+ });
495
+ }
496
+ async stop() {
497
+ if (this.session) {
498
+ stopRecording(this.session);
499
+ this.session = void 0;
500
+ }
501
+ return { recordingId: null };
502
+ }
503
+ cleanup() {
504
+ if (this.session) stopRecording(this.session);
505
+ }
506
+ };
507
+ /**
508
+ * Creates the recording service for the current configuration.
509
+ */
510
+ function createRecordingService(params) {
511
+ if (params.config.deepsightLiveness === "VIDEOLIVENESS") return new LocalRecordingService(params.wasmUtil, params.sessionToken);
512
+ if (params.config.enableFaceRecording === true) return new OpenViduRecordingService(params.config);
513
+ }
514
+
515
+ //#endregion
516
+ //#region src/internal/faceCapture/faceCaptureSetup.ts
517
+ const FACE_CAPTURE_EVENT_CODES = {
518
+ TUTORIAL_SELFIE: "tutorialSelfie",
519
+ CONTINUE: "continue"
520
+ };
521
+ const getAttemptsFromConfig = (config) => {
522
+ return config.captureAttempts ?? config.numberOfAttempts ?? 3;
523
+ };
524
+ const _faceCaptureMachine = setup({
525
+ types: {
526
+ context: {},
527
+ events: {},
528
+ input: {}
529
+ },
530
+ actors: {
531
+ checkPermission: fromPromise(async () => {
532
+ return checkPermission();
533
+ }),
534
+ requestPermission: fromPromise(async () => {
535
+ return requestPermission();
536
+ }),
537
+ initializeCamera: fromPromise(async ({ input }) => {
538
+ return initializeCamera({
539
+ config: input.config,
540
+ deepsightService: input.deepsightService
541
+ });
542
+ }),
543
+ runDetection: fromCallback(({ input, sendBack }) => {
544
+ if (!input.frameCapturer || !input.provider) {
545
+ sendBack({
546
+ type: "DETECTION_UPDATE",
547
+ status: "error"
548
+ });
549
+ return () => {};
550
+ }
551
+ const { cleanup, reset } = startDetection({
552
+ config: input.config,
553
+ capturer: input.frameCapturer,
554
+ onUpdate: (status) => sendBack({
555
+ type: "DETECTION_UPDATE",
556
+ status
557
+ }),
558
+ onFrame: (frame) => sendBack({
559
+ type: "DETECTION_FRAME",
560
+ frame
561
+ }),
562
+ onSuccess: (canvas, faceCoordinates) => sendBack({
563
+ type: "DETECTION_SUCCESS",
564
+ canvas,
565
+ faceCoordinates
566
+ }),
567
+ provider: input.provider
568
+ });
569
+ sendBack({
570
+ type: "DETECTION_RESET_READY",
571
+ reset
572
+ });
573
+ return cleanup;
574
+ }),
575
+ initializeDeepsightSession: fromPromise(async ({ input }) => {
576
+ return await initializeDeepsightSession({
577
+ ds: input.ds,
578
+ storage: input.storage
579
+ });
580
+ }),
581
+ startRecording: fromPromise(async ({ input }) => {
582
+ if (!input.stream) return input.recordingService;
583
+ const wasmUtil = await input.dependencies.getWasmUtil();
584
+ const sessionToken = getToken();
585
+ const service = input.recordingService ?? createRecordingService({
586
+ config: input.config,
587
+ wasmUtil,
588
+ sessionToken
589
+ });
590
+ if (service) await service.start(input.stream);
591
+ return service;
592
+ }),
593
+ checkVirtualCamera: fromPromise(async ({ input }) => {
594
+ if (!input.deepsightService || !input.stream) return false;
595
+ const videoTrack = input.stream.getVideoTracks()[0];
596
+ if (!videoTrack) return false;
597
+ return input.deepsightService.checkVirtualCamera(videoTrack);
598
+ }),
599
+ prepareFaceUpload: fromPromise(async ({ input }) => {
600
+ const ctx = input;
601
+ const sessionToken = getToken();
602
+ let recordingId = null;
603
+ try {
604
+ if (ctx.deepsightService) {
605
+ const [_, recordingResult] = await Promise.all([
606
+ ctx.deepsightService.performVirtualCameraCheck(sessionToken, "SELFIE"),
607
+ ctx.recordingService?.stop(),
608
+ ctx.deepsightService.analyzeFrame(ctx.capturedImage.getImageData())
609
+ ]);
610
+ recordingId = recordingResult?.recordingId ?? null;
611
+ }
612
+ } catch (error) {}
613
+ return {
614
+ encryptedBase64Image: await encryptSelfieImage({
615
+ canvas: ctx.capturedImage,
616
+ dependencies: ctx.dependencies
617
+ }),
618
+ recordingId
619
+ };
620
+ }),
621
+ uploadFace: fromPromise(async () => {
622
+ throw new Error("uploadFace must be provided by variant");
623
+ }),
624
+ processFace: fromPromise(async () => {
625
+ throw new Error("processFace must be provided by variant");
626
+ })
627
+ },
628
+ actions: {
629
+ stopMediaStream: assign(({ context }) => {
630
+ context.frameCapturer?.dispose();
631
+ if (context.stream) stopStream(context.stream);
632
+ context.provider?.dispose();
633
+ return {
634
+ stream: void 0,
635
+ provider: void 0,
636
+ frameCapturer: void 0
637
+ };
638
+ }),
639
+ setStreamAndCapturer: assign({
640
+ stream: ({ event }) => {
641
+ if ("output" in event) return event.output.stream;
642
+ },
643
+ provider: ({ event }) => {
644
+ if ("output" in event) return event.output.provider;
645
+ },
646
+ frameCapturer: ({ event }) => {
647
+ if ("output" in event) return new StreamCanvasCapture(event.output.stream);
648
+ }
649
+ }),
650
+ trackTutorial: () => {
651
+ addEvent({
652
+ code: FACE_CAPTURE_EVENT_CODES.TUTORIAL_SELFIE,
653
+ module: eventModuleNames.selfie,
654
+ payload: { tutorialSelfie: true }
655
+ });
656
+ },
657
+ trackContinue: () => {},
658
+ resetContext: assign(({ context }) => ({
659
+ stream: void 0,
660
+ provider: void 0,
661
+ frameCapturer: void 0,
662
+ error: void 0,
663
+ detectionStatus: "idle",
664
+ debugFrame: void 0,
665
+ capturedImage: void 0,
666
+ faceCoordinates: void 0,
667
+ uploadResponse: void 0,
668
+ processResponse: void 0,
669
+ recordingService: void 0,
670
+ attemptsRemaining: getAttemptsFromConfig(context.config),
671
+ uploadError: void 0,
672
+ permissionResult: void 0,
673
+ resetDetection: void 0,
674
+ deepsightService: void 0
675
+ })),
676
+ resetDetection: ({ context }) => {
677
+ context.resetDetection?.();
678
+ },
679
+ captureImage: assign({ capturedImage: ({ context }) => {
680
+ if (context.capturedImage) return context.capturedImage;
681
+ return context.frameCapturer?.getLatestCanvas() ?? void 0;
682
+ } }),
683
+ captureLatestFrame: assign({ capturedImage: ({ context }) => {
684
+ return context.frameCapturer?.getLatestCanvas() ?? void 0;
685
+ } }),
686
+ clearUploadFailure: assign({
687
+ uploadError: () => void 0,
688
+ detectionStatus: () => "idle",
689
+ capturedImage: () => void 0
690
+ }),
691
+ clearStreamForRetry: assign(({ context }) => {
692
+ context.frameCapturer?.dispose();
693
+ if (context.stream) stopStream(context.stream);
694
+ context.provider?.dispose();
695
+ return {
696
+ stream: void 0,
697
+ provider: void 0,
698
+ frameCapturer: void 0
699
+ };
700
+ }),
701
+ decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
702
+ setUploadErrorFromUploadValidation: assign({ uploadError: () => FACE_ERROR_CODES.SERVER }),
703
+ setTerminalError: assign({ error: () => "Authentication failed" }),
704
+ clearRecordingService: assign({ recordingService: () => void 0 }),
705
+ cleanup: ({ context }) => {
706
+ context.deepsightService?.cleanup();
707
+ context.recordingService?.cleanup();
708
+ },
709
+ setPermissionResultFromEvent: assign({ permissionResult: ({ event }) => event.output }),
710
+ setPermissionDenied: assign({ permissionResult: () => "denied" }),
711
+ setPermissionRefresh: assign({ permissionResult: () => "refresh" }),
712
+ setDeepsightServiceFromEvent: assign({ deepsightService: ({ event }) => event.output }),
713
+ setErrorFromEvent: assign({ error: ({ event }) => String(event.error) }),
714
+ setDetectionStatusDetecting: assign({ detectionStatus: () => "detecting" }),
715
+ setRecordingServiceFromEvent: assign({ recordingService: ({ context, event }) => {
716
+ return event.output ?? context.recordingService;
717
+ } }),
718
+ setDetectionStatusFromEvent: assign({ detectionStatus: ({ event }) => event.status }),
719
+ setDebugFrameFromEvent: assign({ debugFrame: ({ event }) => event.frame }),
720
+ setResetDetectionFromEvent: assign({ resetDetection: ({ event }) => event.reset }),
721
+ setCapturedImageFromEvent: assign({
722
+ capturedImage: ({ event }) => event.canvas,
723
+ faceCoordinates: ({ event }) => event.faceCoordinates
724
+ }),
725
+ setUploadPreparationFromEvent: assign({
726
+ encryptedBase64Image: ({ event }) => event.output.encryptedBase64Image,
727
+ uploadRecordingId: ({ event }) => event.output.recordingId
728
+ }),
729
+ setUploadResponseFromEvent: assign({ uploadResponse: ({ event }) => event.output }),
730
+ setProcessResponseFromEvent: assign({ processResponse: ({ event }) => event.output }),
731
+ setServerErrorAndDecrement: assign(({ context }) => ({
732
+ uploadError: FACE_ERROR_CODES.SERVER,
733
+ attemptsRemaining: context.attemptsRemaining - 1
734
+ })),
735
+ sendLabelInspection: () => {
736
+ sendLabelInspectionEvent();
737
+ },
738
+ noOp: () => void 0
739
+ },
740
+ guards: {
741
+ hasShowTutorial: ({ context }) => context.config.showTutorial,
742
+ isPermissionGranted: ({ event }) => {
743
+ if ("output" in event) return event.output === "granted";
744
+ return false;
745
+ },
746
+ isPermissionDeniedError: ({ event }) => {
747
+ if ("error" in event) {
748
+ const error = event.error;
749
+ return error?.name === "NotAllowedError" || error?.name === "PermissionDeniedError";
750
+ }
751
+ return false;
752
+ },
753
+ hasStream: ({ context }) => context.stream !== void 0,
754
+ isCameraAndDeepsightReady: ({ context }) => context.stream !== void 0 && context.deepsightService !== void 0,
755
+ hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
756
+ hasCapturedImage: ({ context }) => context.capturedImage !== void 0,
757
+ hasUploadValidationError: () => false,
758
+ isTerminalUploadError: () => false
759
+ }
760
+ }).createMachine({
761
+ id: "faceCapture",
762
+ initial: "idle",
763
+ context: ({ input }) => ({
764
+ config: input.config,
765
+ dependencies: input.dependencies,
766
+ authHint: input.authHint,
767
+ stream: void 0,
768
+ provider: void 0,
769
+ frameCapturer: void 0,
770
+ error: void 0,
771
+ detectionStatus: "idle",
772
+ debugFrame: void 0,
773
+ capturedImage: void 0,
774
+ faceCoordinates: void 0,
775
+ uploadResponse: void 0,
776
+ processResponse: void 0,
777
+ recordingService: void 0,
778
+ attemptsRemaining: getAttemptsFromConfig(input.config),
779
+ uploadError: void 0,
780
+ permissionResult: void 0,
781
+ resetDetection: void 0,
782
+ deepsightService: void 0,
783
+ encryptedBase64Image: void 0,
784
+ uploadRecordingId: void 0
785
+ }),
786
+ on: { QUIT: { target: "#faceCapture.closed" } },
787
+ states: {
788
+ idle: { on: { LOAD: [{
789
+ target: "tutorial",
790
+ guard: "hasShowTutorial"
791
+ }, { target: "loading" }] } },
792
+ loading: { invoke: [{
793
+ id: "checkPermissionLoading",
794
+ src: "checkPermission",
795
+ onDone: [{
796
+ target: "capture",
797
+ guard: "isPermissionGranted",
798
+ actions: "setPermissionResultFromEvent"
799
+ }, {
800
+ target: "permissions",
801
+ actions: "setPermissionResultFromEvent"
802
+ }]
803
+ }, {
804
+ id: "loadingInitDeepsight",
805
+ src: "initializeDeepsightSession",
806
+ input: ({ context }) => ({
807
+ ds: context.config.ds,
808
+ storage: context.dependencies.storage
809
+ }),
810
+ onDone: { actions: "setDeepsightServiceFromEvent" },
811
+ onError: { actions: "noOp" }
812
+ }] },
813
+ tutorial: {
814
+ initial: "checkingPermission",
815
+ entry: "trackTutorial",
816
+ states: {
817
+ checkingPermission: { invoke: {
818
+ id: "checkPermissionTutorial",
819
+ src: "checkPermission",
820
+ onDone: [{
821
+ target: "initializingCamera",
822
+ guard: "isPermissionGranted",
823
+ actions: "setPermissionResultFromEvent"
824
+ }, {
825
+ target: "ready",
826
+ actions: "setPermissionResultFromEvent"
827
+ }]
828
+ } },
829
+ initializingCamera: {
830
+ type: "parallel",
831
+ states: {
832
+ cameraInit: {
833
+ initial: "initializingDeepsight",
834
+ states: {
835
+ initializingDeepsight: { invoke: {
836
+ id: "tutorialInitDeepsight",
837
+ src: "initializeDeepsightSession",
838
+ input: ({ context }) => ({
839
+ ds: context.config.ds,
840
+ storage: context.dependencies.storage
841
+ }),
842
+ onDone: {
843
+ target: "initializingStream",
844
+ actions: "setDeepsightServiceFromEvent"
845
+ },
846
+ onError: { target: "#faceCapture.tutorial.ready" }
847
+ } },
848
+ initializingStream: { invoke: {
849
+ id: "tutorialInitCamera",
850
+ src: "initializeCamera",
851
+ input: ({ context }) => ({
852
+ config: context.config,
853
+ dependencies: context.dependencies,
854
+ deepsightService: context.deepsightService
855
+ }),
856
+ onDone: {
857
+ target: "ready",
858
+ actions: "setStreamAndCapturer"
859
+ },
860
+ onError: [{
861
+ target: "#faceCapture.tutorial.ready",
862
+ guard: "isPermissionDeniedError",
863
+ actions: "setPermissionDenied"
864
+ }, {
865
+ target: "#faceCapture.tutorial.ready",
866
+ actions: "setErrorFromEvent"
867
+ }]
868
+ } },
869
+ ready: { type: "final" }
870
+ }
871
+ },
872
+ userIntent: {
873
+ initial: "waiting",
874
+ states: {
875
+ waiting: { on: { NEXT_STEP: {
876
+ target: "clicked",
877
+ actions: "trackContinue"
878
+ } } },
879
+ clicked: { type: "final" }
880
+ }
881
+ }
882
+ },
883
+ onDone: { target: "#faceCapture.capture" }
884
+ },
885
+ ready: {
886
+ initial: "idle",
887
+ states: {
888
+ idle: { always: [{
889
+ target: "initializingDeepsight",
890
+ guard: ({ context }) => context.deepsightService === void 0
891
+ }, { target: "readyForNext" }] },
892
+ initializingDeepsight: { invoke: {
893
+ id: "initializeDeepsightTutorial",
894
+ src: "initializeDeepsightSession",
895
+ input: ({ context }) => ({
896
+ ds: context.config.ds,
897
+ storage: context.dependencies.storage
898
+ }),
899
+ onDone: {
900
+ target: "readyForNext",
901
+ actions: "setDeepsightServiceFromEvent"
902
+ },
903
+ onError: { target: "readyForNext" }
904
+ } },
905
+ readyForNext: { on: { NEXT_STEP: {
906
+ target: "#faceCapture.tutorial.waitingForPermission",
907
+ actions: "trackContinue"
908
+ } } }
909
+ }
910
+ },
911
+ waitingForPermission: { invoke: {
912
+ id: "checkPermissionWaiting",
913
+ src: "checkPermission",
914
+ onDone: [{
915
+ target: "#faceCapture.capture",
916
+ guard: "isPermissionGranted",
917
+ actions: "setPermissionResultFromEvent"
918
+ }, {
919
+ target: "#faceCapture.permissions",
920
+ actions: "setPermissionResultFromEvent"
921
+ }]
922
+ } }
923
+ }
924
+ },
925
+ permissions: {
926
+ initial: "checkingDeepsight",
927
+ states: {
928
+ checkingDeepsight: { always: [{
929
+ target: "initializingDeepsight",
930
+ guard: ({ context }) => context.deepsightService === void 0
931
+ }, { target: "idle" }] },
932
+ initializingDeepsight: { invoke: {
933
+ id: "initializeDeepsightPerms",
934
+ src: "initializeDeepsightSession",
935
+ input: ({ context }) => ({
936
+ ds: context.config.ds,
937
+ storage: context.dependencies.storage
938
+ }),
939
+ onDone: {
940
+ target: "idle",
941
+ actions: "setDeepsightServiceFromEvent"
942
+ },
943
+ onError: { target: "idle" }
944
+ } },
945
+ idle: {
946
+ invoke: {
947
+ id: "checkPermissionIdle",
948
+ src: "checkPermission",
949
+ onDone: [{
950
+ target: "#faceCapture.capture",
951
+ guard: "isPermissionGranted",
952
+ actions: "setPermissionResultFromEvent"
953
+ }, {
954
+ target: "denied",
955
+ guard: ({ event }) => event.output === "denied",
956
+ actions: "setPermissionResultFromEvent"
957
+ }]
958
+ },
959
+ on: {
960
+ REQUEST_PERMISSION: "requesting",
961
+ GO_TO_LEARN_MORE: "learnMore"
962
+ }
963
+ },
964
+ learnMore: { on: {
965
+ BACK: "idle",
966
+ REQUEST_PERMISSION: "requesting"
967
+ } },
968
+ requesting: { invoke: {
969
+ id: "requestPermission",
970
+ src: "requestPermission",
971
+ onDone: [
972
+ {
973
+ target: "#faceCapture.capture",
974
+ guard: "isPermissionGranted",
975
+ actions: "setPermissionResultFromEvent"
976
+ },
977
+ {
978
+ target: "denied",
979
+ guard: ({ event }) => event.output === "denied",
980
+ actions: "setPermissionResultFromEvent"
981
+ },
982
+ {
983
+ target: "idle",
984
+ actions: "setPermissionResultFromEvent"
985
+ }
986
+ ],
987
+ onError: { target: "denied" }
988
+ } },
989
+ denied: { entry: "setPermissionRefresh" }
990
+ }
991
+ },
992
+ capture: {
993
+ initial: "checkingDeepsight",
994
+ exit: [
995
+ "stopMediaStream",
996
+ "cleanup",
997
+ "clearRecordingService"
998
+ ],
999
+ states: {
1000
+ checkingDeepsight: { always: [{
1001
+ target: "initializingDeepsight",
1002
+ guard: ({ context }) => context.deepsightService === void 0
1003
+ }, { target: "checkingStream" }] },
1004
+ initializingDeepsight: { invoke: {
1005
+ id: "initializeDeepsightCapture",
1006
+ src: "initializeDeepsightSession",
1007
+ input: ({ context }) => ({
1008
+ ds: context.config.ds,
1009
+ storage: context.dependencies.storage
1010
+ }),
1011
+ onDone: {
1012
+ target: "checkingStream",
1013
+ actions: ["setDeepsightServiceFromEvent"]
1014
+ },
1015
+ onError: { target: "#faceCapture.permissions" }
1016
+ } },
1017
+ checkingStream: { always: [
1018
+ {
1019
+ target: "initializingDeepsight",
1020
+ guard: ({ context }) => context.deepsightService === void 0
1021
+ },
1022
+ {
1023
+ target: "detecting",
1024
+ guard: "hasStream"
1025
+ },
1026
+ { target: "initializing" }
1027
+ ] },
1028
+ initializing: { invoke: {
1029
+ id: "initializeCamera",
1030
+ src: "initializeCamera",
1031
+ input: ({ context }) => ({
1032
+ config: context.config,
1033
+ dependencies: context.dependencies,
1034
+ deepsightService: context.deepsightService
1035
+ }),
1036
+ onDone: {
1037
+ target: "detecting",
1038
+ actions: ["setStreamAndCapturer"]
1039
+ },
1040
+ onError: [{
1041
+ target: "#faceCapture.permissions",
1042
+ guard: "isPermissionDeniedError",
1043
+ actions: "setPermissionDenied"
1044
+ }, {
1045
+ target: "#faceCapture.error",
1046
+ actions: "setErrorFromEvent"
1047
+ }]
1048
+ } },
1049
+ detecting: {
1050
+ entry: ["setDetectionStatusDetecting"],
1051
+ invoke: [
1052
+ {
1053
+ id: "checkVirtualCamera",
1054
+ src: "checkVirtualCamera",
1055
+ input: ({ context }) => ({
1056
+ stream: context.stream,
1057
+ deepsightService: context.deepsightService
1058
+ }),
1059
+ onDone: [{
1060
+ target: "#faceCapture.processing",
1061
+ guard: ({ event }) => event.output === true,
1062
+ actions: "sendLabelInspection"
1063
+ }],
1064
+ onError: { actions: "noOp" }
1065
+ },
1066
+ {
1067
+ id: "startRecording",
1068
+ src: "startRecording",
1069
+ input: ({ context }) => ({
1070
+ config: context.config,
1071
+ dependencies: context.dependencies,
1072
+ recordingService: context.recordingService,
1073
+ stream: context.stream
1074
+ }),
1075
+ onDone: { actions: "setRecordingServiceFromEvent" },
1076
+ onError: { actions: "noOp" }
1077
+ },
1078
+ {
1079
+ id: "runDetection",
1080
+ src: "runDetection",
1081
+ input: ({ context }) => ({
1082
+ frameCapturer: context.frameCapturer,
1083
+ provider: context.provider,
1084
+ config: context.config
1085
+ })
1086
+ }
1087
+ ],
1088
+ on: {
1089
+ DETECTION_UPDATE: { actions: "setDetectionStatusFromEvent" },
1090
+ DETECTION_FRAME: { actions: "setDebugFrameFromEvent" },
1091
+ DETECTION_RESET_READY: { actions: "setResetDetectionFromEvent" },
1092
+ DETECTION_SUCCESS: {
1093
+ target: "capturing",
1094
+ actions: "setCapturedImageFromEvent"
1095
+ },
1096
+ MANUAL_CAPTURE: { target: "capturingManual" }
1097
+ }
1098
+ },
1099
+ capturing: {
1100
+ entry: ["captureImage"],
1101
+ always: [{
1102
+ target: "preparingUpload",
1103
+ guard: "hasCapturedImage"
1104
+ }, {
1105
+ target: "uploadError",
1106
+ actions: "setServerErrorAndDecrement"
1107
+ }]
1108
+ },
1109
+ capturingManual: {
1110
+ entry: ["captureLatestFrame"],
1111
+ always: [{
1112
+ target: "preparingUpload",
1113
+ guard: "hasCapturedImage"
1114
+ }, {
1115
+ target: "uploadError",
1116
+ actions: "setServerErrorAndDecrement"
1117
+ }]
1118
+ },
1119
+ preparingUpload: { invoke: {
1120
+ id: "prepareFaceUpload",
1121
+ src: "prepareFaceUpload",
1122
+ input: ({ context }) => context,
1123
+ onDone: {
1124
+ target: "uploading",
1125
+ actions: "setUploadPreparationFromEvent"
1126
+ },
1127
+ onError: {
1128
+ target: "uploadError",
1129
+ actions: "setServerErrorAndDecrement"
1130
+ }
1131
+ } },
1132
+ uploading: { invoke: {
1133
+ id: "uploadFace",
1134
+ src: "uploadFace",
1135
+ input: ({ context }) => context,
1136
+ onDone: {
1137
+ target: "validatingUpload",
1138
+ actions: "setUploadResponseFromEvent"
1139
+ },
1140
+ onError: {
1141
+ target: "uploadError",
1142
+ actions: "setServerErrorAndDecrement"
1143
+ }
1144
+ } },
1145
+ validatingUpload: { always: [
1146
+ {
1147
+ target: "#faceCapture.error",
1148
+ guard: "isTerminalUploadError",
1149
+ actions: "setTerminalError"
1150
+ },
1151
+ {
1152
+ target: "uploadError",
1153
+ guard: "hasUploadValidationError",
1154
+ actions: ["setUploadErrorFromUploadValidation", "decrementAttemptsRemaining"]
1155
+ },
1156
+ { target: "success" }
1157
+ ] },
1158
+ uploadError: { on: { RETRY_CAPTURE: {
1159
+ target: "checkingStream",
1160
+ guard: "hasAttemptsRemaining",
1161
+ actions: [
1162
+ "resetDetection",
1163
+ "clearUploadFailure",
1164
+ "clearStreamForRetry"
1165
+ ]
1166
+ } } },
1167
+ success: {
1168
+ entry: "cleanup",
1169
+ after: { 3e3: { target: "#faceCapture.processing" } }
1170
+ }
1171
+ }
1172
+ },
1173
+ processing: { invoke: {
1174
+ id: "processFace",
1175
+ src: "processFace",
1176
+ onDone: {
1177
+ target: "finished",
1178
+ actions: "setProcessResponseFromEvent"
1179
+ },
1180
+ onError: { target: "finished" }
1181
+ } },
1182
+ finished: {
1183
+ entry: "stopMediaStream",
1184
+ type: "final"
1185
+ },
1186
+ closed: {
1187
+ entry: "stopMediaStream",
1188
+ type: "final"
1189
+ },
1190
+ error: {
1191
+ entry: "stopMediaStream",
1192
+ on: { RESET: {
1193
+ target: "idle",
1194
+ actions: "resetContext"
1195
+ } }
1196
+ }
1197
+ }
1198
+ });
1199
+ const faceCaptureMachine = _faceCaptureMachine;
1200
+
1201
+ //#endregion
1202
+ export { FACE_ERROR_CODES as a, uploadSelfie as i, faceCaptureMachine as n, createFaceCaptureManager as o, processFace as r, FACE_CAPTURE_EVENT_CODES as t };