@incodetech/core 2.2.0-rc.8 → 2.3.0-rc.0

package/dist/createFaceAvatar-BEj18KXi.d.ts

@@ -1,50 +0,0 @@
-import { n as AvatarFaceState, t as AvatarAssetsOverrides } from "./IFaceAvatarCapability-BrL19G0s.js";
-//#region src/internal/avatar/createFaceAvatar.d.ts
-/**
- * Shared face-avatar dispatch — the single code path BOTH the selfie module
- * (`faceCapture` runAvatar actor) and the public `@incodetech/core/avatar` facade
- * use, so every camera module mounts avatars the same way. Lives in `internal/`
- * (not `modules/`) because `internal/` may not import from `modules/`; the public
- * `modules/avatar` entry is a thin re-export of this. See
- * docs/features/FACE_AVATAR.md.
- *
- * Public catalog of shippable face avatars. Each id maps to a lazily-loaded
- * provider, so a module only pays the bundle cost of the avatar it picks:
- *  - `avatar-3d`    → 3D VRM character, MediaPipe-tracked (premium look).
- *  - `avatar-2d`    → stylized 2D "satin" face, MediaPipe-tracked. Also the
- *                     personhood avatar.
- *  - `privacy-lens` → WebGL frosted-glass lens over the real video (no tracking).
- *
- * (The Incode-data 2D avatar is parked — kept in infra, not in the public
- * catalog. See docs/features/FACE_AVATAR.md → Parked: the Incode-data avatar.)
- */
-type AvatarId = 'avatar-3d' | 'avatar-2d' | 'privacy-lens';
-interface FaceAvatarOptions {
-  /** Which avatar to render. */
-  variant: AvatarId;
-  /** The already-acquired camera stream (the host module owns it). */
-  stream: MediaStream;
-  /** Runtime asset overrides (MediaPipe wasm/model, VRM); defaults to the CDN layout. */
-  assets?: AvatarAssetsOverrides;
-  /** Upper bound on the avatar's internal detect/render loop (default 30). */
-  maxFps?: number;
-  /** Initial verdict cue; defaults to `detecting`. */
-  initialState?: AvatarFaceState;
-}
-interface FaceAvatarHandle {
-  /** The canvas to mount in place of the live video. */
-  readonly canvas: HTMLCanvasElement;
-  /** Push a verdict cue (no-op for avatars without a verdict visual). */
-  setState(state: AvatarFaceState): void;
-  /** Tear down the loop, model and hidden decode video. */
-  stop(): void;
-}
-/**
- * Mounts a cosmetic face avatar: lazy-loads the chosen provider, starts it on the
- * given stream, and returns a handle to mount the canvas + push verdict cues. The
- * avatar is **cosmetic-only** — it never feeds the authoritative
- * detection/quality/liveness/upload pipeline.
- */
-declare function createFaceAvatar(options: FaceAvatarOptions): Promise<FaceAvatarHandle>;
-//#endregion
-export { createFaceAvatar as i, FaceAvatarHandle as n, FaceAvatarOptions as r, AvatarId as t };

package/dist/document-upload.d.ts

@@ -1,325 +0,0 @@
-import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
-import "./StateMachine-EDpYWy0i.js";
-import { t as Manager } from "./Manager-CQQ99QOI.js";
-import "./Actor-iTq7YY48.js";
-import { n as DocumentUploadContext, r as DocumentUploadInput, t as DocumentUploadConfig } from "./types-Vb4P9ovf.js";
-//#region src/modules/document-upload/documentUploadStateMachine.d.ts
-declare const documentUploadMachine: StateMachine<DocumentUploadContext, {
-  type: "START";
-} | {
-  type: "CAPTURE";
-  imageBase64: string;
-} | {
-  type: "UPLOAD_PROGRESS";
-  progress: number;
-} | {
-  type: "RETRY";
-} | {
-  type: "CLOSE";
-}, {
-  [x: string]: ActorRefFromLogic<PromiseActorLogic<void, {
-    imageBase64: string;
-    documentType: string;
-    onProgress: (progress: number) => void;
-  }, EventObject>> | ActorRefFromLogic<PromiseActorLogic<MediaStream, void, EventObject>> | undefined;
-}, Values<{
-  uploadDocument: {
-    src: "uploadDocument";
-    logic: PromiseActorLogic<void, {
-      imageBase64: string;
-      documentType: string;
-      onProgress: (progress: number) => void;
-    }, EventObject>;
-    id: string | undefined;
-  };
-  initCamera: {
-    src: "initCamera";
-    logic: PromiseActorLogic<MediaStream, void, EventObject>;
-    id: string | undefined;
-  };
-}>, Values<{
-  setStream: {
-    type: "setStream";
-    params: NonReducibleUnknown;
-  };
-  setImageAndClearError: {
-    type: "setImageAndClearError";
-    params: NonReducibleUnknown;
-  };
-  setProgress: {
-    type: "setProgress";
-    params: NonReducibleUnknown;
-  };
-  setError: {
-    type: "setError";
-    params: NonReducibleUnknown;
-  };
-  clearError: {
-    type: "clearError";
-    params: NonReducibleUnknown;
-  };
-  stopStream: {
-    type: "stopStream";
-    params: NonReducibleUnknown;
-  };
-}>, never, never, "error" | "idle" | "uploading" | "closed" | "finished" | "initCamera" | "capturing", string, DocumentUploadInput, NonReducibleUnknown, EventObject, MetaObject, {
-  readonly id: "documentUpload";
-  readonly initial: "idle";
-  readonly context: ({ input }: {
-    spawn: {
-      <TSrc extends "uploadDocument" | "initCamera">(logic: TSrc, ...[options]: ({
-        src: "uploadDocument";
-        logic: PromiseActorLogic<void, {
-          imageBase64: string;
-          documentType: string;
-          onProgress: (progress: number) => void;
-        }, EventObject>;
-        id: string | undefined;
-      } extends (infer T) ? T extends {
-        src: "uploadDocument";
-        logic: PromiseActorLogic<void, {
-          imageBase64: string;
-          documentType: string;
-          onProgress: (progress: number) => void;
-        }, EventObject>;
-        id: string | undefined;
-      } ? T extends {
-        src: TSrc;
-      } ? ConditionalRequired<[options?: ({
-        id?: T["id"] | undefined;
-        systemId?: string;
-        input?: InputFrom<T["logic"]> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never) | ({
-        src: "initCamera";
-        logic: PromiseActorLogic<MediaStream, void, EventObject>;
-        id: string | undefined;
-      } extends (infer T_1) ? T_1 extends {
-        src: "initCamera";
-        logic: PromiseActorLogic<MediaStream, void, EventObject>;
-        id: string | undefined;
-      } ? T_1 extends {
-        src: TSrc;
-      } ? ConditionalRequired<[options?: ({
-        id?: T_1["id"] | undefined;
-        systemId?: string;
-        input?: InputFrom<T_1["logic"]> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never)): ActorRefFromLogic<GetConcreteByKey<Values<{
-        uploadDocument: {
-          src: "uploadDocument";
-          logic: PromiseActorLogic<void, {
-            imageBase64: string;
-            documentType: string;
-            onProgress: (progress: number) => void;
-          }, EventObject>;
-          id: string | undefined;
-        };
-        initCamera: {
-          src: "initCamera";
-          logic: PromiseActorLogic<MediaStream, void, EventObject>;
-          id: string | undefined;
-        };
-      }>, "src", TSrc>["logic"]>;
-      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
-        id?: never;
-        systemId?: string;
-        input?: InputFrom<TLogic> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
-    };
-    input: DocumentUploadInput;
-    self: ActorRef<MachineSnapshot<DocumentUploadContext, {
-      type: "START";
-    } | {
-      type: "CAPTURE";
-      imageBase64: string;
-    } | {
-      type: "UPLOAD_PROGRESS";
-      progress: number;
-    } | {
-      type: "RETRY";
-    } | {
-      type: "CLOSE";
-    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
-      type: "START";
-    } | {
-      type: "CAPTURE";
-      imageBase64: string;
-    } | {
-      type: "UPLOAD_PROGRESS";
-      progress: number;
-    } | {
-      type: "RETRY";
-    } | {
-      type: "CLOSE";
-    }, AnyEventObject>;
-  }) => {
-    config: DocumentUploadConfig;
-    stream: undefined;
-    imageBase64: undefined;
-    progress: number;
-    error: undefined;
-  };
-  readonly states: {
-    readonly idle: {
-      readonly on: {
-        readonly START: {
-          readonly target: "initCamera";
-        };
-      };
-    };
-    readonly initCamera: {
-      readonly invoke: {
-        readonly id: "initCamera";
-        readonly src: "initCamera";
-        readonly input: undefined;
-        readonly onDone: {
-          readonly target: "capturing";
-          readonly actions: "setStream";
-        };
-        readonly onError: {
-          readonly target: "error";
-          readonly actions: "setError";
-        };
-      };
-      readonly on: {
-        readonly CLOSE: {
-          readonly target: "closed";
-        };
-      };
-    };
-    readonly capturing: {
-      readonly on: {
-        readonly CAPTURE: {
-          readonly target: "uploading";
-          readonly actions: "setImageAndClearError";
-        };
-        readonly CLOSE: {
-          readonly target: "closed";
-          readonly actions: "stopStream";
-        };
-      };
-    };
-    readonly uploading: {
-      readonly invoke: {
-        readonly id: "uploadDocument";
-        readonly src: "uploadDocument";
-        readonly input: ({ context, self }: {
-          context: DocumentUploadContext;
-          event: {
-            type: "START";
-          } | {
-            type: "CAPTURE";
-            imageBase64: string;
-          } | {
-            type: "UPLOAD_PROGRESS";
-            progress: number;
-          } | {
-            type: "RETRY";
-          } | {
-            type: "CLOSE";
-          };
-          self: ActorRef<MachineSnapshot<DocumentUploadContext, {
-            type: "START";
-          } | {
-            type: "CAPTURE";
-            imageBase64: string;
-          } | {
-            type: "UPLOAD_PROGRESS";
-            progress: number;
-          } | {
-            type: "RETRY";
-          } | {
-            type: "CLOSE";
-          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
-            type: "START";
-          } | {
-            type: "CAPTURE";
-            imageBase64: string;
-          } | {
-            type: "UPLOAD_PROGRESS";
-            progress: number;
-          } | {
-            type: "RETRY";
-          } | {
-            type: "CLOSE";
-          }, AnyEventObject>;
-        }) => {
-          imageBase64: string;
-          documentType: string;
-          onProgress: (progress: number) => void;
-        };
-        readonly onDone: {
-          readonly target: "finished";
-          readonly actions: "stopStream";
-        };
-        readonly onError: {
-          readonly target: "error";
-          readonly actions: readonly ["setError", "stopStream"];
-        };
-      };
-      readonly on: {
-        readonly UPLOAD_PROGRESS: {
-          readonly actions: "setProgress";
-        };
-      };
-    };
-    readonly error: {
-      readonly on: {
-        readonly RETRY: {
-          readonly target: "initCamera";
-          readonly actions: "clearError";
-        };
-        readonly CLOSE: {
-          readonly target: "closed";
-          readonly actions: "stopStream";
-        };
-      };
-    };
-    readonly finished: {
-      readonly type: "final";
-    };
-    readonly closed: {
-      readonly type: "final";
-    };
-  };
-}>;
-//#endregion
-//#region src/modules/document-upload/documentUploadActor.d.ts
-type CreateDocumentUploadActorOptions = {
-  config: DocumentUploadConfig;
-};
-//#endregion
-//#region src/modules/document-upload/documentUploadManager.d.ts
-type DocumentUploadInitializingState = {
-  status: 'initializing';
-};
-type DocumentUploadCapturingState = {
-  status: 'capturing';
-  stream: MediaStream;
-};
-type DocumentUploadUploadingState = {
-  status: 'uploading';
-  progress: number;
-};
-type DocumentUploadErrorState = {
-  status: 'error';
-  error: string;
-};
-type DocumentUploadFinishedState = {
-  status: 'finished';
-};
-type DocumentUploadClosedState = {
-  status: 'closed';
-};
-type DocumentUploadState = DocumentUploadInitializingState | DocumentUploadCapturingState | DocumentUploadUploadingState | DocumentUploadErrorState | DocumentUploadFinishedState | DocumentUploadClosedState;
-declare function createDocumentUploadManager(options: CreateDocumentUploadActorOptions): Manager<DocumentUploadState> & {
-  load(): void;
-  capture(imageBase64: string): void;
-  retry(): void;
-  close(): void;
-};
-type DocumentUploadManager = ReturnType<typeof createDocumentUploadManager>;
-//#endregion
-export { type DocumentUploadConfig, type DocumentUploadManager, type DocumentUploadState, createDocumentUploadManager, documentUploadMachine };

package/dist/document-upload.esm.js

@@ -1,197 +0,0 @@
-import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { a as stopCameraStream } from "./camera-_2sXMXiF.esm.js";
-import { n as getBackCameraStream } from "./backCameraStream-CUeYm5eu.esm.js";
-//#region src/modules/document-upload/documentUploadServices.ts
-async function uploadDocument({ imageBase64, documentType, onProgress, signal }) {
-	const url = `${endpoints.addDocument}?type=${encodeURIComponent(documentType)}`;
-	const response = await api.post(url, { base64Image: imageBase64 }, {
-		signal,
-		onUploadProgress: onProgress
-	});
-	if (!response.ok) throw new Error(`Document upload failed: ${response.status} ${response.statusText}`);
-}
-//#endregion
-//#region src/modules/document-upload/documentUploadStateMachine.ts
-const documentUploadMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: {
-		initCamera: fromPromise(async () => {
-			const { stream } = await getBackCameraStream(void 0);
-			return stream;
-		}),
-		uploadDocument: fromPromise(async ({ input, signal }) => {
-			return uploadDocument({
-				imageBase64: input.imageBase64,
-				documentType: input.documentType,
-				onProgress: input.onProgress,
-				signal
-			});
-		})
-	},
-	actions: {
-		setStream: assign(({ event }) => ({ stream: event.output })),
-		setImageAndClearError: assign(({ event }) => {
-			return {
-				imageBase64: event.imageBase64,
-				error: void 0
-			};
-		}),
-		setProgress: assign(({ event }) => ({ progress: event.progress })),
-		setError: assign(({ event }) => ({ error: String(event.error) })),
-		clearError: assign({ error: () => void 0 }),
-		stopStream: assign(({ context }) => {
-			if (context.stream) stopCameraStream(context.stream);
-			return { stream: void 0 };
-		})
-	}
-}).createMachine({
-	id: "documentUpload",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		stream: void 0,
-		imageBase64: void 0,
-		progress: 0,
-		error: void 0
-	}),
-	states: {
-		idle: { on: { START: { target: "initCamera" } } },
-		initCamera: {
-			invoke: {
-				id: "initCamera",
-				src: "initCamera",
-				input: void 0,
-				onDone: {
-					target: "capturing",
-					actions: "setStream"
-				},
-				onError: {
-					target: "error",
-					actions: "setError"
-				}
-			},
-			on: { CLOSE: { target: "closed" } }
-		},
-		capturing: { on: {
-			CAPTURE: {
-				target: "uploading",
-				actions: "setImageAndClearError"
-			},
-			CLOSE: {
-				target: "closed",
-				actions: "stopStream"
-			}
-		} },
-		uploading: {
-			invoke: {
-				id: "uploadDocument",
-				src: "uploadDocument",
-				input: ({ context, self }) => {
-					const imageBase64 = context.imageBase64;
-					if (!imageBase64) throw new Error("No image to upload");
-					return {
-						imageBase64,
-						documentType: context.config.documentType,
-						onProgress: (progress) => {
-							self.send({
-								type: "UPLOAD_PROGRESS",
-								progress
-							});
-						}
-					};
-				},
-				onDone: {
-					target: "finished",
-					actions: "stopStream"
-				},
-				onError: {
-					target: "error",
-					actions: ["setError", "stopStream"]
-				}
-			},
-			on: { UPLOAD_PROGRESS: { actions: "setProgress" } }
-		},
-		error: { on: {
-			RETRY: {
-				target: "initCamera",
-				actions: "clearError"
-			},
-			CLOSE: {
-				target: "closed",
-				actions: "stopStream"
-			}
-		} },
-		finished: { type: "final" },
-		closed: { type: "final" }
-	}
-});
-//#endregion
-//#region src/modules/document-upload/documentUploadActor.ts
-function createDocumentUploadActor(options) {
-	return createActor(documentUploadMachine, { input: { config: options.config } }).start();
-}
-//#endregion
-//#region src/modules/document-upload/documentUploadManager.ts
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	const { context } = typedSnapshot;
-	if (typedSnapshot.matches("idle") || typedSnapshot.matches("initCamera")) return { status: "initializing" };
-	if (typedSnapshot.matches("capturing")) {
-		if (!context.stream) return { status: "initializing" };
-		return {
-			status: "capturing",
-			stream: context.stream
-		};
-	}
-	if (typedSnapshot.matches("uploading")) return {
-		status: "uploading",
-		progress: context.progress
-	};
-	if (typedSnapshot.matches("error")) return {
-		status: "error",
-		error: context.error ?? "Upload failed"
-	};
-	if (typedSnapshot.matches("finished")) return { status: "finished" };
-	if (typedSnapshot.matches("closed")) return { status: "closed" };
-	return { status: "initializing" };
-}
-function createApi({ actor, trackElementClicked }) {
-	return {
-		load() {
-			actor.send({ type: "START" });
-		},
-		capture(imageBase64) {
-			trackElementClicked?.("capture");
-			actor.send({
-				type: "CAPTURE",
-				imageBase64
-			});
-		},
-		retry() {
-			trackElementClicked?.("retry");
-			actor.send({ type: "RETRY" });
-		},
-		close() {
-			trackElementClicked?.("close");
-			actor.send({ type: "CLOSE" });
-		}
-	};
-}
-function createDocumentUploadManager(options) {
-	return createManager({
-		actor: createDocumentUploadActor(options),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.documentUpload)
-	});
-}
-//#endregion
-export { createDocumentUploadManager, documentUploadMachine };