@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/videoSelfieStepDetector-D3oo2ofo.d.ts

@@ -0,0 +1,123 @@
+import { t as CameraStream } from "./camera-9wWD-pwg.js";
+import { i as FlowModuleConfig } from "./types-KPvmag_B.js";
+import { n as DetectionStatus } from "./types-Hmd7U0JA.js";
+import { t as DetectionOrientation } from "./IIdCaptureCapability-DHTT3FC2.js";
+//#region src/modules/video-selfie/types.d.ts
+/**
+ * The capture steps a Video Selfie session can run, in flow order. Which steps
+ * are active is derived from the module config (e.g. `checkIdScan` enables
+ * `frontId`/`backId`, `checkVoiceConsent` enables `speech`).
+ */
+type VideoSelfieStep = 'selfie' | 'frontId' | 'backId' | 'poa' | 'questions' | 'speech';
+/**
+ * Public Video Selfie configuration. Mirrors the backend `VIDEO_ONBOARDING`
+ * workflow module.
+ *
+ * The whole session is recorded on-device and streamed to the backend via S3
+ * multipart upload (`internal/recordings/multipartRecordingService`) — the
+ * client-side replacement for V1's server-side OpenVidu recording. See
+ * `docs/features/VIDEO_SELFIE.md`.
+ */
+type VideoSelfieConfig = FlowModuleConfig['VIDEO_ONBOARDING'];
+//#endregion
+//#region ../infra/src/capabilities/ICameraCapability.d.ts
+type FacingMode = 'user' | 'environment';
+//#endregion
+//#region ../infra/src/media/CameraCompositor.d.ts
+type CameraCompositorOptions = {
+  fps?: number;
+};
+/**
+ * Composites the *active* camera into a canvas and exposes the canvas as a
+ * single, stable `MediaStream` to record. Switching cameras (front ↔ back)
+ * just repoints what the canvas draws — the output stream and its audio track
+ * are never replaced — so a single `MediaRecorder` produces one continuous
+ * video that follows the camera switches (V1 parity), instead of restarting
+ * per camera.
+ *
+ * The audio track from the initial stream is carried through unchanged across
+ * video switches, so there's no audio glitch when the camera flips.
+ */
+declare class CameraCompositor {
+  private readonly fps;
+  private readonly frameIntervalMs;
+  private canvas;
+  private ctx;
+  private video;
+  private frameRequestId;
+  private frameRequestKind;
+  private lastDrawTimeMs;
+  private lastVideoTimeSeconds;
+  private audioTrack;
+  private videoTrack;
+  private composite;
+  constructor(options?: CameraCompositorOptions);
+  /**
+   * Begin compositing `stream` and return the composite stream to record. The
+   * stream's audio track (if any) is carried through unchanged across later
+   * `switchVideo` calls.
+   */
+  start(stream: CameraStream): MediaStream;
+  /**
+   * Swap the camera feeding the canvas without interrupting the composite
+   * stream. Pass a video-only stream (audio is kept from `start`). The previous
+   * video track is stopped.
+   */
+  switchVideo(stream: CameraStream): void;
+  /** The composite stream being recorded, if compositing is active. */
+  get stream(): MediaStream | undefined;
+  /** Stop compositing and release the canvas, audio, and video tracks. */
+  stop(): void;
+  private setVideoSource;
+  private startDrawLoop;
+  private scheduleNextFrame;
+  private cancelDrawLoop;
+  private drawCurrentFrame;
+  private getBoundedDimensions;
+}
+//#endregion
+//#region src/modules/video-selfie/videoSelfieStepDetector.d.ts
+type VideoSelfieDetectionStatus = DetectionStatus | 'wrongSide';
+type VideoSelfieValidationFailure = 'selfieVerificationFailed' | 'nameVerificationFailed' | 'photoVerificationFailed' | 'idTypeMismatch' | 'idScanFailed' | 'selfieUploadFailed';
+/**
+ * Failures that re-run the current step WITHOUT consuming an attempt or the
+ * recording: the capture itself was fine — a transport-level problem kept
+ * the backend from delivering a verdict.
+ */
+type VideoSelfieRetryableFailure = 'idScanFailed' | 'selfieUploadFailed';
+type StepDetectionResult = {
+  outcome: 'success';
+} | {
+  outcome: 'validationFailed';
+  failure: VideoSelfieValidationFailure;
+} | {
+  outcome: 'retryableFailure';
+  failure: VideoSelfieRetryableFailure;
+};
+/**
+ * Runs the WASM detection + backend validation for a single capture step over
+ * the given camera stream. Returns either success or a typed validation
+ * failure, rejects on technical failures, and never settles for manual steps.
+ */
+type StepDetector = (params: {
+  step: VideoSelfieStep;
+  stream: MediaStream;
+  signal: AbortSignal;
+  onStatus?: (status: VideoSelfieDetectionStatus) => void;
+  /**
+   * Live ID orientation from the detector (regular ID pipeline only), so the
+   * mask can follow a rotated document. The Video Selfie detector never emits
+   * it — its simplified ID pipeline reports no orientation.
+   */
+  onOrientation?: (orientation: DetectionOrientation) => void;
+  /**
+   * Hands the caller a trigger that captures + uploads the current frame
+   * (regular ID pipeline only). The detector reports `manualCapture` via
+   * `onStatus` when autocapture times out; the host then shows a capture
+   * button wired to this trigger. The Video Selfie detector never registers
+   * one.
+   */
+  registerManualCapture?: (trigger: () => void) => void;
+}) => Promise<StepDetectionResult>;
+//#endregion
+export { FacingMode as a, CameraCompositor as i, VideoSelfieDetectionStatus as n, VideoSelfieConfig as o, VideoSelfieValidationFailure as r, VideoSelfieStep as s, StepDetector as t };

package/dist/wasm.d.ts

@@ -1,7 +1,5 @@
-import { n as WasmPipeline, r as warmupWasm, t as WarmupConfig } from "./warmup-Dd0iq6KF.js";
-import "./index-BAyZ8_iI.js";
-import { i as initializeWasmUtil, l as upgradeToWasmHttpClient, n as WasmConfig, r as ensureWasmPipelines, s as setWasmConfig } from "./setup-CmA2apmN.js";
-
+import { n as WasmPipeline, r as warmupWasm, t as WarmupConfig } from "./warmup-Dv2alr2-.js";
+import { i as initializeWasmUtil, l as upgradeToWasmHttpClient, n as WasmConfig, r as ensureWasmPipelines, s as setWasmConfig } from "./setup-DywQeePQ.js";
 //#region ../infra/src/wasm/wasmDefaults.d.ts
 /** The WASM version bundled and tested with this SDK release. */
 declare const DEFAULT_WASM_VERSION = "v2.14.07-post7-post3";

package/dist/wasm.esm.js

@@ -1,15 +1,4 @@
-import { i as warmupWasm } from "./WasmUtilProvider-BgzcXBdl.esm.js";
-import { a as setWasmConfig, c as DEFAULT_WASM_VERSION, d as resolveWasmConfig, l as buildDefaultWasmConfig, n as initializeWasmUtil, s as upgradeToWasmHttpClient, t as ensureWasmPipelines, u as buildWasmConfigFromBasePath } from "./setup-CfNsYAeB.esm.js";
-import "./BrowserTimerProvider-CHloo0eQ.esm.js";
-import "./api-DsbUi7TO.esm.js";
-import "./clientLifecycle-VyzRfALg.esm.js";
-import "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import "./stats-BVy52wLy.esm.js";
-import "./sessionInitializer-Dj7-aJaP.esm.js";
-import "./browserSimulation-DZwEy9bu.esm.js";
-import "./platform-0Ot-bF_a.esm.js";
-import "./getBrowser-1yNcfFZR.esm.js";
-import "./tri-CFAPtAUM.esm.js";
-
-export { DEFAULT_WASM_VERSION, buildDefaultWasmConfig, buildWasmConfigFromBasePath, ensureWasmPipelines, initializeWasmUtil, resolveWasmConfig, setWasmConfig, upgradeToWasmHttpClient, warmupWasm };
+import { a as resolveWasmConfig, n as buildDefaultWasmConfig, r as buildWasmConfigFromBasePath, t as DEFAULT_WASM_VERSION } from "./wasmDefaults-DTUrftxR.esm.js";
+import { s as warmupWasm } from "./safeStorage-Ep56I-f_.esm.js";
+import { a as setWasmConfig, n as initializeWasmUtil, s as upgradeToWasmHttpClient, t as ensureWasmPipelines } from "./setup-CYdVacqv.esm.js";
+export { DEFAULT_WASM_VERSION, buildDefaultWasmConfig, buildWasmConfigFromBasePath, ensureWasmPipelines, initializeWasmUtil, resolveWasmConfig, setWasmConfig, upgradeToWasmHttpClient, warmupWasm };

package/dist/wasmDefaults-DTUrftxR.esm.js

@@ -0,0 +1,125 @@
+import { u as deriveSiblingJsPath } from "./wasmWebClient-DM8lkb0z.esm.js";
+//#region ../infra/src/wasm/wasmDefaults.ts
+const WASM_CDN_BASE_URL = "https://cdn.incodesmile.com/ml-wasm-kit-release";
+/** The WASM version bundled and tested with this SDK release. */
+const DEFAULT_WASM_VERSION = "v2.14.07-post7-post3";
+const PATH_KEYS = [
+	"wasmPath",
+	"wasmSimdPath",
+	"glueCodePath",
+	"glueCodeSimdPath",
+	"modelsBasePath"
+];
+function isBlank(value) {
+	return value.trim() === "";
+}
+function hasDisallowedControlChars(value) {
+	for (let i = 0; i < value.length; i += 1) {
+		const code = value.charCodeAt(i);
+		if (code < 32 || code === 127) return true;
+	}
+	return false;
+}
+function isMalformedPath(value) {
+	const trimmed = value.trim();
+	if (trimmed === "") return false;
+	if (hasDisallowedControlChars(trimmed)) return true;
+	if (/^https?:\/\//i.test(trimmed)) try {
+		new URL(trimmed);
+		return false;
+	} catch {
+		return true;
+	}
+	return false;
+}
+function warnInvalidWasmPath(field, reason) {
+	if (reason === "empty") {
+		console.warn(`[Incode SDK] wasm.${field} is empty. Falling back to CDN default.`);
+		return;
+	}
+	console.warn(`[Incode SDK] wasm.${field} appears malformed. Falling back to CDN default.`);
+}
+function warnMalformedWasmPath(field) {
+	console.warn(`[Incode SDK] wasm.${field} appears malformed. Check the URL or path.`);
+}
+/**
+* Validates merged WASM path strings. When overrides contained blank path
+* values, callers should have already fallen back to defaults before this runs.
+*/
+function validateWasmPaths(config) {
+	for (const key of PATH_KEYS) {
+		const value = config[key];
+		if (typeof value === "string" && isMalformedPath(value)) warnMalformedWasmPath(key);
+	}
+}
+function pickPath(key, overrides, defaultValue) {
+	if (!overrides || !(key in overrides)) return defaultValue;
+	const raw = overrides[key];
+	if (raw === void 0) return defaultValue;
+	if (typeof raw !== "string") return defaultValue;
+	if (isBlank(raw)) {
+		warnInvalidWasmPath(key, "empty");
+		return defaultValue;
+	}
+	if (isMalformedPath(raw)) {
+		warnInvalidWasmPath(key, "malformed");
+		return defaultValue;
+	}
+	return raw.trim();
+}
+/** Builds a WarmupConfig from a directory that mirrors the ml-wasm-kit CDN layout. */
+function buildWasmConfigFromBasePath(basePath) {
+	const base = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+	return {
+		wasmPath: `${base}/webLib.wasm`,
+		wasmSimdPath: `${base}/webLibSimd.wasm`,
+		glueCodePath: `${base}/webLib.js`,
+		glueCodeSimdPath: `${base}/webLibSimd.js`,
+		modelsBasePath: `${base}/models`
+	};
+}
+/** Builds the standard WarmupConfig from the Incode CDN. */
+function buildDefaultWasmConfig() {
+	return buildWasmConfigFromBasePath(`${WASM_CDN_BASE_URL}/${DEFAULT_WASM_VERSION}`);
+}
+const BARCODE_ENHANCE_MODEL_FILE = "barcode_enhance_896x224_fp16.ortmodelv2";
+/**
+* URL of the lazily-loaded PDF417 barcode enhancement model (US Smart Capture).
+* Derived from the resolved `modelsBasePath` so self-hosted / air-gapped
+* deployments resolve it correctly, falling back to the CDN default. Loaded on
+* demand via `IIdCaptureCapability.setBarcodeEnhancementModel` — deliberately
+* NOT part of any warmup model bundle.
+*/
+function getBarcodeEnhanceModelUrl(modelsBasePath) {
+	const base = modelsBasePath ?? `${WASM_CDN_BASE_URL}/v2.14.07-post7-post3/models`;
+	return `${base.endsWith("/") ? base.slice(0, -1) : base}/${BARCODE_ENHANCE_MODEL_FILE}`;
+}
+/**
+* Merges optional WASM path overrides with CDN defaults. Explicit non-blank
+* paths take precedence. Blank override strings log a warning and fall back to defaults.
+*/
+function resolveWasmConfig(overrides) {
+	if (!overrides) return buildDefaultWasmConfig();
+	const defaults = buildWasmConfigFromBasePath(pickPath("basePath", overrides, `${WASM_CDN_BASE_URL}/${DEFAULT_WASM_VERSION}`));
+	const simdDefault = defaults.wasmSimdPath ?? defaults.wasmPath;
+	const modelsDefault = defaults.modelsBasePath ?? (() => {
+		const lastSlash = defaults.wasmPath.lastIndexOf("/");
+		return lastSlash === -1 ? "models" : `${defaults.wasmPath.substring(0, lastSlash)}/models`;
+	})();
+	const resolvedWasmSimdPath = pickPath("wasmSimdPath", overrides, simdDefault);
+	const glueCodeSimdDefault = deriveSiblingJsPath(resolvedWasmSimdPath);
+	const merged = {
+		wasmPath: pickPath("wasmPath", overrides, defaults.wasmPath),
+		wasmSimdPath: resolvedWasmSimdPath,
+		glueCodePath: pickPath("glueCodePath", overrides, defaults.glueCodePath),
+		glueCodeSimdPath: pickPath("glueCodeSimdPath", overrides, glueCodeSimdDefault),
+		modelsBasePath: pickPath("modelsBasePath", overrides, modelsDefault),
+		useSimd: overrides.useSimd,
+		pipelines: overrides.pipelines,
+		pipelineModels: overrides.pipelineModels
+	};
+	validateWasmPaths(merged);
+	return merged;
+}
+//#endregion
+export { resolveWasmConfig as a, getBarcodeEnhanceModelUrl as i, buildDefaultWasmConfig as n, buildWasmConfigFromBasePath as r, DEFAULT_WASM_VERSION as t };

package/dist/{wasmDsFlagSync-Ch0mFJNT.esm.js → wasmDsFlagSync-BqUCwLY8.esm.js}

@@ -1,5 +1,4 @@
-import { a as mlWasmJSApi_default } from "./WasmUtilProvider-BgzcXBdl.esm.js";
-
+import { c as mlWasmJSApi_default } from "./safeStorage-Ep56I-f_.esm.js";
 //#region ../infra/src/wasm/wasmDsFlagSync.ts
 /**
 * Sets the Deepsight (ds) flag that the WASM utility API receives on every
@@ -9,6 +8,5 @@ import { a as mlWasmJSApi_default } from "./WasmUtilProvider-BgzcXBdl.esm.js";
 function setWasmDsFlagSync(enabled) {
 	mlWasmJSApi_default.setDsEnabled(enabled);
 }
-
 //#endregion
-export { setWasmDsFlagSync as t };
+export { setWasmDsFlagSync as t };