@incodetech/core 0.0.0-dev-20260729-9e7b030a → 0.0.0-dev-20260729-a31df3b7

package/dist/id.d.ts

@@ -1,8 +1,9 @@
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
 import { n as PermissionStatus, t as PermissionResult } from "./types-BT-aiBYV.js";
-import { A as ManualUploadSide, C as RecordingSession, D as MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, E as MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, M as DetectionOrientation, O as MANUAL_UPLOAD_MAX_RETRIES, P as IdCaptureSettings, S as IdFlowStep, _ as IdCaptureThresholds, a as DetectionArea, b as IdError, c as IdCaptureConfig, d as IdCaptureEvent, f as IdCaptureGeometry, g as IdCaptureOutput, h as IdCaptureOnlyConfig, i as CapturedImage, j as ManualUploadTab, k as ManualUploadContext, l as IdCaptureContext, m as IdCaptureMode, n as CaptureIdResponse, o as DetectionStatus, p as IdCaptureInput, r as CaptureOnlyResponse, s as ID_ERROR_CODES, t as AddBarcodeV3Response, u as IdCaptureDependencies, v as IdCapturedImageData, w as UploadIdResponse, x as IdErrorCode, y as IdDocumentType } from "./types-4-pU2Nhm.js";
-import { A as createIdCaptureActor, C as CreateIdCaptureOnlyActorOptions, D as idCaptureOnlyMachine, E as IdCaptureOnlyMachine, M as idCaptureMachine, O as CreateIdCaptureActorOptions, S as validateUploadResponse, T as createIdCaptureOnlyActor, _ as startRecordingSession, a as AddBarcodeParams, b as uploadIdImage, c as StartRecordingParams, d as ValidationError, f as addBarcode, g as processId, h as preloadIdRecordingProvider, j as IdCaptureMachine, k as IdCaptureActor, l as UploadIdImageParams, m as initializeIdCapture, n as IdCaptureManager, o as IdCaptureInitResult, p as barcodeToBase64, r as IdCaptureState, s as InitializeIdCaptureParams, t as createIdCaptureManager, u as UploadManualIdFileParams, v as stopRecording, w as IdCaptureOnlyActor, x as uploadManualIdFile, y as stopStream } from "./idCaptureManager-B2w2CGuV.js";
+import { r as IdCaptureSettings, t as DetectionOrientation } from "./IIdCaptureCapability-Cj_aceph.js";
+import { A as ManualUploadSide, C as RecordingSession, D as MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, E as MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, O as MANUAL_UPLOAD_MAX_RETRIES, S as IdFlowStep, _ as IdCaptureThresholds, a as DetectionArea, b as IdError, c as IdCaptureConfig, d as IdCaptureEvent, f as IdCaptureGeometry, g as IdCaptureOutput, h as IdCaptureOnlyConfig, i as CapturedImage, j as ManualUploadTab, k as ManualUploadContext, l as IdCaptureContext, m as IdCaptureMode, n as CaptureIdResponse, o as DetectionStatus, p as IdCaptureInput, r as CaptureOnlyResponse, s as ID_ERROR_CODES, t as AddBarcodeV3Response, u as IdCaptureDependencies, v as IdCapturedImageData, w as UploadIdResponse, x as IdErrorCode, y as IdDocumentType } from "./types-BsTkSXlg2.js";
+import { A as createIdCaptureActor, C as CreateIdCaptureOnlyActorOptions, D as idCaptureOnlyMachine, E as IdCaptureOnlyMachine, M as idCaptureMachine, O as CreateIdCaptureActorOptions, S as validateUploadResponse, T as createIdCaptureOnlyActor, _ as startRecordingSession, a as AddBarcodeParams, b as uploadIdImage, c as StartRecordingParams, d as ValidationError, f as addBarcode, g as processId, h as preloadIdRecordingProvider, j as IdCaptureMachine, k as IdCaptureActor, l as UploadIdImageParams, m as initializeIdCapture, n as IdCaptureManager, o as IdCaptureInitResult, p as barcodeToBase64, r as IdCaptureState, s as InitializeIdCaptureParams, t as createIdCaptureManager, u as UploadManualIdFileParams, v as stopRecording, w as IdCaptureOnlyActor, x as uploadManualIdFile, y as stopStream } from "./idCaptureManager-wKz4MXR8.js";
 //#region src/modules/id/idCaptureOnlyManager.d.ts
 type IdCaptureOnlyManager = IdCaptureManager;
 /**

package/dist/id.esm.js

@@ -2,8 +2,9 @@ import { t as BrowserStorageProvider } from "./BrowserStorageProvider-P6aUarE9.e
 import { n as eventModuleNames } from "./events-ethtfu2b.esm.js";
 import { o as createActor, r as assign } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
-import { _ as MANUAL_UPLOAD_MAX_RETRIES, a as initializeIdCapture, c as startRecordingSession, d as uploadIdImage, f as uploadManualIdFile, g as MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, h as MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, i as barcodeToBase64, l as stopRecording, m as ID_ERROR_CODES, o as preloadIdRecordingProvider, p as validateUploadResponse, r as addBarcode, s as processId, t as idCaptureMachine, u as stopStream } from "./idCaptureStateMachine-BMZCf9M7.esm.js";
-import { n as createIdCaptureActor, r as createIdCaptureManagerFromActor, t as createIdCaptureManager } from "./idCaptureManager-DAsfVDWq.esm.js";
+import { a as MANUAL_UPLOAD_MAX_RETRIES, i as MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, r as MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, t as idCaptureMachine } from "./idCaptureStateMachine-CM8EP_MM.esm.js";
+import { n as createIdCaptureActor, r as createIdCaptureManagerFromActor, t as createIdCaptureManager } from "./idCaptureManager-BokR8KKO.esm.js";
+import { a as processId, c as stopStream, d as validateUploadResponse, f as ID_ERROR_CODES, i as preloadIdRecordingProvider, l as uploadIdImage, n as barcodeToBase64, o as startRecordingSession, r as initializeIdCapture, s as stopRecording, t as addBarcode, u as uploadManualIdFile } from "./idCaptureServices-C3nAZ64o.esm.js";
 import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-DVtdZdpI.esm.js";
 //#region src/modules/id/idCaptureOnlyStateMachine.ts
 function buildSubImage(canvas) {

package/dist/{idCaptureManager-DAsfVDWq.esm.js → idCaptureManager-BokR8KKO.esm.js}

@@ -4,7 +4,7 @@ import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as setWasmDsFlagSync, t as BrowserVisibilityObserverProvider } from "./BrowserVisibilityObserverProvider-sJclps4C.esm.js";
 import { o as resetWasmMotionPrimedForModule, r as primeMotionFromUserGestureIfNeeded } from "./permissionServices-GFikEK6S.esm.js";
-import { n as getManualUploadTabs, t as idCaptureMachine } from "./idCaptureStateMachine-BMZCf9M7.esm.js";
+import { n as getManualUploadTabs, t as idCaptureMachine } from "./idCaptureStateMachine-CM8EP_MM.esm.js";
 //#region src/modules/id/digitalUpload/instrumentation.ts
 const TERMINAL_REASONS = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
 function isHoldingState(value) {
@@ -219,6 +219,7 @@ function mapCaptureState(snapshot, context) {
 		orientation: context.orientation,
 		idType: context.idType,
 		previewImageUrl: context.previewImageUrl,
+		barcodeFastPathCaptured: context.barcodeFastPathCaptured,
 		uploadProgress: context.uploadProgress ?? 0,
 		ageAssurance: context.config.ageAssurance === true,
 		uploadErrorMessage: uploadError ? getErrorTitleKey(uploadError, context.currentMode) : void 0,

package/dist/{idCaptureManager-B2w2CGuV.d.ts → idCaptureManager-wKz4MXR8.d.ts}

@@ -5,10 +5,11 @@ import "./Actor-iTq7YY48.js";
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
 import "./index-B8weJxmL.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { t as DeepsightService } from "./deepsightService-CR-CYdka.js";
 import { a as RegulationTypes } from "./types-KPvmag_B.js";
 import { n as PermissionStatus } from "./types-BT-aiBYV.js";
-import { A as ManualUploadSide, C as RecordingSession, F as Pdf417DecodeResult, M as DetectionOrientation, N as IIdCaptureCapability, T as IAnalyticsCapability, a as DetectionArea, c as IdCaptureConfig, d as IdCaptureEvent, g as IdCaptureOutput, h as IdCaptureOnlyConfig, j as ManualUploadTab, l as IdCaptureContext, m as IdCaptureMode, n as CaptureIdResponse, o as DetectionStatus, p as IdCaptureInput, t as AddBarcodeV3Response, u as IdCaptureDependencies, w as UploadIdResponse, x as IdErrorCode, y as IdDocumentType } from "./types-4-pU2Nhm.js";
+import { t as DeepsightService } from "./deepsightService-DLVQS_RH.js";
+import { i as Pdf417DecodeResult, n as IIdCaptureCapability, t as DetectionOrientation } from "./IIdCaptureCapability-Cj_aceph.js";
+import { A as ManualUploadSide, C as RecordingSession, T as IAnalyticsCapability, a as DetectionArea, c as IdCaptureConfig, d as IdCaptureEvent, g as IdCaptureOutput, h as IdCaptureOnlyConfig, j as ManualUploadTab, l as IdCaptureContext, m as IdCaptureMode, n as CaptureIdResponse, o as DetectionStatus, p as IdCaptureInput, t as AddBarcodeV3Response, u as IdCaptureDependencies, w as UploadIdResponse, x as IdErrorCode, y as IdDocumentType } from "./types-BsTkSXlg2.js";
 //#region src/modules/id/idCaptureStateMachine.d.ts
 declare const idCaptureMachine: AnyStateMachine;
 type IdCaptureMachine = StateMachine<IdCaptureContext, IdCaptureEvent, any, any, any, any, any, any, any, IdCaptureInput, any, any, any, any>;
@@ -205,6 +206,13 @@ type IdCaptureCaptureState = {
   orientation: DetectionOrientation | undefined;
   idType: string | undefined;
   previewImageUrl?: string;
+  /**
+   * Barcode fast-path success — render the checkmark "Successfully processed!"
+   * screen with NO captured image (the grabbed frame is a backend signal only;
+   * `previewImageUrl` is cleared for this path). See the "after barcode capture
+   * (no image)" design.
+   */
+  barcodeFastPathCaptured: boolean;
   uploadProgress?: number;
   ageAssurance: boolean;
   uploadErrorMessage?: string;

package/dist/idCaptureServices-C3nAZ64o.esm.js

@@ -0,0 +1,353 @@
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-DOfmJylF.esm.js";
+import { n as isDesktop } from "./platform-Cd_yWGNG.esm.js";
+import { h as stopRecording$1, m as startRecording, p as createRecordingSession } from "./onDeviceFaceResults-DFEU5wcC.esm.js";
+import { n as getBackCameraStream } from "./backCameraStream-BqiXcU28.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-BGmoQmjj.esm.js";
+import { n as preloadOpenViduProvider } from "./recordingService-BwaHFQSV.esm.js";
+import { r as IdCaptureProvider } from "./idCaptureDefaults-BDS43fFL.esm.js";
+//#region src/modules/id/idCameraStream.ts
+async function getIdCameraStream(deviceId) {
+	return getBackCameraStream(deviceId);
+}
+//#endregion
+//#region src/modules/id/types.ts
+const ID_ERROR_CODES = {
+	UPLOAD_ERROR: "UPLOAD_ERROR",
+	CLASSIFICATION_FAILED: "CLASSIFICATION_FAILED",
+	LOW_SHARPNESS: "LOW_SHARPNESS",
+	GLARE_DETECTED: "GLARE_DETECTED",
+	WRONG_DOCUMENT_SIDE: "WRONG_DOCUMENT_SIDE",
+	ID_TYPE_UNACCEPTABLE: "ID_TYPE_UNACCEPTABLE",
+	READABILITY_ISSUE: "READABILITY_ISSUE",
+	RETRY_EXHAUSTED_CONTINUE_TO_BACK: "RETRY_EXHAUSTED_CONTINUE_TO_BACK",
+	RETRY_EXHAUSTED_SKIP_BACK: "RETRY_EXHAUSTED_SKIP_BACK",
+	NO_MORE_TRIES: "NO_MORE_TRIES",
+	UNEXPECTED_ERROR: "UNEXPECTED_ERROR",
+	NO_TOKEN: "NO_TOKEN",
+	PERMISSION_DENIED: "PERMISSION_DENIED",
+	USER_CANCELLED: "USER_CANCELLED",
+	SERVER: "SERVER_ERROR"
+};
+//#endregion
+//#region src/modules/id/idCaptureServices.ts
+/**
+* Camera constraints used for PRC warmup before ID capture.
+* Uses environment-facing camera on mobile devices (for back camera ID capture)
+* and user-facing camera on desktop.
+*/
+function getPrcCameraConstraints() {
+	if (isDesktop()) return { video: {
+		facingMode: "user",
+		height: { ideal: 480 },
+		width: { ideal: 640 }
+	} };
+	return { video: {
+		facingMode: "environment",
+		height: { ideal: 720 }
+	} };
+}
+function getUploadEndpoint(type, isSecondId) {
+	if (isSecondId) return type === "front" ? endpoints.frontSecondId : endpoints.backSecondId;
+	return type === "front" ? endpoints.frontId : endpoints.backId;
+}
+const SHARPNESS_THRESHOLD = 10;
+const GLARE_THRESHOLD = 10;
+const DEFAULT_ID_CAPTURE_THRESHOLDS = {
+	blurThreshold: .2,
+	blurChangeThreshold: .2,
+	glareThreshold: .3,
+	clsThreshold: .98,
+	sideThreshold: .8,
+	iouThreshold: .8,
+	framesAggregationInterval: 3e3
+};
+const DEFAULT_ID_CAPTURE_SETTINGS = {
+	isFixedMask: false,
+	isIPhone14OrHigher: false,
+	idType: "",
+	blurCheckEnabled: false,
+	glareCheckEnabled: false,
+	faceQualityCheckEnabled: true,
+	iouCheckEnabled: true,
+	fpsLimitEnabled: false
+};
+async function initializeIdCapture(params) {
+	const { config, deepsightService } = params;
+	const provider = new IdCaptureProvider();
+	await provider.initialize({});
+	provider.setThresholds({
+		...DEFAULT_ID_CAPTURE_THRESHOLDS,
+		...config.thresholds,
+		idDetectedTimeout: config.thresholds?.idDetectedTimeout ?? config.deviceIdleTimeout * 1e3,
+		autocaptureTimeout: config.thresholds?.autocaptureTimeout ?? config.autoCaptureTimeout * 1e3
+	});
+	if (config.settings) provider.setSettings({
+		...DEFAULT_ID_CAPTURE_SETTINGS,
+		...config.settings
+	});
+	if (deepsightService && !params.stream) try {
+		await deepsightService.performPrcCheck({ constraints: getPrcCameraConstraints() });
+	} catch {}
+	const { stream, fallbackLevel } = params.stream ? {
+		stream: params.stream,
+		fallbackLevel: params.cameraFallbackLevel
+	} : await getIdCameraStream();
+	const videoTrack = stream.getVideoTracks()[0];
+	let captureResolution;
+	if (videoTrack) {
+		const settings = videoTrack.getSettings();
+		if (typeof settings.width === "number" && typeof settings.height === "number") captureResolution = `${settings.width}x${settings.height}`;
+	}
+	if (deepsightService && videoTrack) deepsightService.metadata.updateCameraInfo(videoTrack);
+	return {
+		stream,
+		provider,
+		captureResolution,
+		cameraFallbackLevel: fallbackLevel
+	};
+}
+function stopStream(stream) {
+	for (const track of stream.getTracks()) track.stop();
+}
+function validateUploadResponse(response, sessionState) {
+	if (response.failReason === "ID_TYPE_UNACCEPTABLE") return {
+		error: true,
+		message: "ID type is not acceptable",
+		messageDescription: "Please use a valid ID type",
+		errorKey: ID_ERROR_CODES.ID_TYPE_UNACCEPTABLE
+	};
+	if (response.failReason === "WRONG_DOCUMENT_SIDE") return {
+		error: true,
+		message: "Wrong side of document",
+		messageDescription: response.side === "back" ? "Please show the back side of your ID" : "Please show the front side of your ID",
+		errorKey: ID_ERROR_CODES.WRONG_DOCUMENT_SIDE
+	};
+	if (!response.classification) return {
+		error: true,
+		message: "ID classification failed",
+		errorKey: ID_ERROR_CODES.CLASSIFICATION_FAILED
+	};
+	const sharpnessThreshold = getDeviceClass() === "desktop" ? -1 : SHARPNESS_THRESHOLD;
+	if (response.sharpness !== void 0 && sharpnessThreshold >= 0 && response.sharpness < sharpnessThreshold) return {
+		error: true,
+		message: "Image is not sharp enough",
+		messageDescription: "Please ensure the image is clear and well-focused",
+		errorKey: ID_ERROR_CODES.LOW_SHARPNESS
+	};
+	if (response.glare !== void 0 && response.glare < GLARE_THRESHOLD && !sessionState?.skipGlareFront && !sessionState?.skipGlareBack) return {
+		error: true,
+		message: "Glare detected on ID",
+		messageDescription: "Please avoid bright reflections on your ID",
+		errorKey: ID_ERROR_CODES.GLARE_DETECTED
+	};
+}
+async function getExtraImages(params) {
+	const extraImages = params.ageAssurance ? [params.type === "back" ? "croppedBackID" : "croppedFrontID"] : [];
+	try {
+		const res = await api.post(endpoints.getImages, { images: ["croppedIDFace", ...extraImages] }, { signal: params.signal });
+		if (!res.ok) throw new Error(`Failed to get extra images: ${res.status}`);
+		return res.data ?? {
+			croppedIDFace: "",
+			croppedFrontID: "",
+			croppedBackID: ""
+		};
+	} catch {
+		return {
+			croppedIDFace: "",
+			croppedFrontID: "",
+			croppedBackID: ""
+		};
+	}
+}
+const getRealQualityValue = (value) => (1 - value) * 100;
+async function uploadIdImage(params) {
+	const { type, image, onProgress, signal, metadata, ageAssurance, glare, sharpness, shouldSkipGlareBack, analyticsProvider, imageData, isSecondId, onlyFront, extractIdFace } = params;
+	let finalMetadata = metadata;
+	if (analyticsProvider && imageData) try {
+		await analyticsProvider.analyzeFrame(imageData);
+		analyticsProvider.update();
+		finalMetadata = analyticsProvider.getMetadata();
+	} catch (error) {
+		console.warn("[IdCapture] Analytics failed:", error);
+	}
+	const endpoint = getUploadEndpoint(type, isSecondId);
+	const body = {
+		base64Image: image,
+		metadata: finalMetadata
+	};
+	const queryParams = { imageType: "id" };
+	if (onlyFront && type === "front") queryParams.onlyFront = true;
+	if (shouldSkipGlareBack && type === "back") queryParams.glare = 0;
+	else if (glare !== void 0) queryParams.glare = getRealQualityValue(glare);
+	if (sharpness !== void 0) queryParams.sharpness = getRealQualityValue(sharpness);
+	if (extractIdFace === false && type === "front") queryParams.extractIdFace = false;
+	try {
+		const res = await api.post(endpoint, body, {
+			signal,
+			query: queryParams,
+			onUploadProgress: onProgress
+		});
+		if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
+		const response = res.data;
+		const extraImages = await getExtraImages({
+			type,
+			ageAssurance,
+			signal
+		});
+		const fullResponse = {
+			...response,
+			originalImage: image,
+			frontIdImage: type === "front" ? image : void 0,
+			backIdImage: extraImages.croppedBackID,
+			...extraImages
+		};
+		onProgress?.(100);
+		return fullResponse;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`${ID_ERROR_CODES.UPLOAD_ERROR}: ${errorMessage}`);
+	}
+}
+function buildStandardResolution(width, height) {
+	return height > width ? {
+		width: 1080,
+		height: 1920
+	} : {
+		width: 1920,
+		height: 1080
+	};
+}
+function buildResolutionFromStream(stream) {
+	const track = stream.getVideoTracks()[0];
+	if (!track) return "1080x1920";
+	const settings = track.getSettings();
+	const width = settings.width;
+	const height = settings.height;
+	if (typeof width === "number" && typeof height === "number") {
+		const standard = buildStandardResolution(width, height);
+		return `${standard.width}x${standard.height}`;
+	}
+	return "1080x1920";
+}
+function preloadIdRecordingProvider(config) {
+	if (config.enableIdRecording !== true) return;
+	preloadOpenViduProvider();
+}
+async function createOpenViduRecordingProvider() {
+	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-Du98qevC.esm.js");
+	return new OpenViduRecordingProvider();
+}
+async function startRecordingSession(params) {
+	if (params.config.enableIdRecording !== true) return;
+	if (params.existing) return params.existing;
+	const provider = params.config.recording?.capability ?? await createOpenViduRecordingProvider();
+	const clonedStream = params.stream.clone();
+	const hasAudio = clonedStream.getAudioTracks().length > 0;
+	const resolution = buildResolutionFromStream(clonedStream);
+	const session = await createRecordingSession(params.type);
+	const connection = await provider.connect({
+		sessionToken: session.token,
+		stream: clonedStream,
+		events: {}
+	});
+	await startRecording({
+		videoRecordingId: session.videoRecordingId,
+		type: params.type,
+		resolution,
+		hasAudio
+	});
+	return {
+		token: session.token,
+		sessionId: session.sessionId,
+		videoRecordingId: session.videoRecordingId,
+		connection,
+		resolution,
+		hasAudio
+	};
+}
+function stopRecording(session) {
+	(async () => {
+		try {
+			await stopRecording$1(session.videoRecordingId);
+		} finally {
+			await session.connection.disconnect();
+		}
+	})();
+}
+async function processId(isSecondId = false, queueName = "", signal) {
+	const endpoint = isSecondId ? endpoints.processSecondId : endpoints.processId;
+	const url = queueName ? `${endpoint}?queueName=${queueName}` : endpoint;
+	return { isDocumentExpired: (await api.post(url, {}, { signal })).data?.isDocumentExpired ?? false };
+}
+/**
+* Upload a user-selected image as front / back / passport ID.
+*
+* Uses the same request shape as the live-camera path (`uploadIdImage`):
+* JSON body `{ base64Image }` with default application/json Content-Type,
+* `captureType=UPLOAD` query param, `retry=true` when retrying.
+* Back is POSTed to `/omni/add/back-id/v2` (or `/omni/add/back-second-id/v2`
+* when `isSecondId`); front and passport go to `/omni/add/front-id/v2` (or
+* `/omni/add/front-second-id/v2` when `isSecondId`).
+*
+* The v2 endpoints reject raw `image/jpeg` bodies with 415, so the caller
+* must convert the File to base64 before calling this service.
+*/
+async function uploadManualIdFile(params) {
+	const { side, base64Image, retry, onlyFront, signal, isSecondId, extractIdFace } = params;
+	const endpoint = getUploadEndpoint(side === "back" ? "back" : "front", isSecondId);
+	const queryParams = { captureType: "UPLOAD" };
+	if (retry) queryParams.retry = true;
+	if (onlyFront && side === "front") queryParams.onlyFront = true;
+	if (extractIdFace === false && side !== "back") queryParams.extractIdFace = false;
+	const res = await api.post(endpoint, { base64Image }, {
+		signal,
+		query: queryParams
+	});
+	if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+/**
+* UTF-8-safe base64 encoding of a decoded barcode payload. Uses the browser
+* `TextEncoder` + `btoa` (always available in the SDK's target environment) so
+* non-ASCII payloads survive `btoa`, which only accepts Latin-1.
+*/
+function barcodeToBase64(raw) {
+	const bytes = new TextEncoder().encode(raw);
+	let binary = "";
+	bytes.forEach((byte) => {
+		binary += String.fromCharCode(byte);
+	});
+	return btoa(binary);
+}
+/**
+* US Smart Capture: submits a decoded PDF417 barcode to
+* `POST /omni/add/barcode/v3`. The response drives the downstream front-capture
+* and Process ID skips (`forceFrontIdCapture` / `idValidationCompleted`).
+* Mirrors SDK 1's `addBarcode`. Throws (carrying `status`/`data`) on a non-OK
+* response so the caller can fall back to a full-frame upload. The
+* hardware-id token is injected by the shared `api` layer, as in `uploadIdImage`.
+*/
+async function addBarcode(params) {
+	const { rawBarcode, processId = true, metrics, signal } = params;
+	const body = { base64Barcode: barcodeToBase64(rawBarcode) };
+	if (metrics) {
+		body.pdf417RowNumber = metrics.rowNumber;
+		body.pdf417ColumnNumber = metrics.columnNumber;
+		body.pdf417CodewordLengthInPixelsMin = metrics.codewordLengthInPixelsMin;
+		body.pdf417CodewordLengthInPixelsMax = metrics.codewordLengthInPixelsMax;
+		body.pdf417CorrectedErrorsCount = metrics.correctedErrorsCount;
+		body.ecLevel = metrics.ecLevel;
+	}
+	const res = await api.post(endpoints.addBarcode, body, {
+		query: { processId },
+		signal
+	});
+	if (!res.ok) throw Object.assign(/* @__PURE__ */ new Error(`POST ${endpoints.addBarcode} failed: ${res.status} ${res.statusText}`), {
+		status: res.status,
+		data: res.data
+	});
+	return res.data;
+}
+//#endregion
+export { processId as a, stopStream as c, validateUploadResponse as d, ID_ERROR_CODES as f, preloadIdRecordingProvider as i, uploadIdImage as l, barcodeToBase64 as n, startRecordingSession as o, getIdCameraStream as p, initializeIdCapture as r, stopRecording as s, addBarcode as t, uploadManualIdFile as u };