@incodetech/core 2.4.0 → 2.4.1-agentic.1

package/dist/WorkerEncoderRecordingProvider-B1ODYtgN.esm.js

@@ -0,0 +1,80 @@
+import { n as __exportAll } from "./rolldown-runtime-B-1-B7_t.esm.js";
+import { t as MultipartRecordingProvider } from "./MultipartRecordingProvider-D9mauUdS.esm.js";
+//#region ../infra/src/providers/browser/WorkerEncoderRecordingProvider.ts
+var WorkerEncoderRecordingProvider_exports = /* @__PURE__ */ __exportAll({ WorkerEncoderRecordingProvider: () => WorkerEncoderRecordingProvider });
+/**
+* Multipart recorder for a `CameraCompositor` that encodes inside its worker
+* (ENG-55397): emits the worker's WebM clusters as parts, in order. When the
+* compositor could not start in-worker encoding (no insertable streams or
+* WebCodecs, strict CSP), it records the composite stream with
+* `MediaRecorder` instead, so callers wire it unconditionally.
+*
+* Why not always `MediaRecorder`: Chrome hands every recorded frame through
+* the page main thread and drops frames while it is blocked. On a Galaxy A01
+* Core the ID flow blocks it for 3–5 s (WASM + 1080p readbacks); a
+* `MediaRecorder` fed by the worker kept 74 of 149 frames under 1.5 s
+* freezes, the in-worker encoder 150 of 151.
+*/
+var WorkerEncoderRecordingProvider = class {
+	constructor(compositor) {
+		this.compositor = compositor;
+		this._isRecording = false;
+		this._error = null;
+		this.partNumber = 0;
+		this.fallback = null;
+	}
+	get isRecording() {
+		return this.fallback ? this.fallback.isRecording : this._isRecording;
+	}
+	get hasError() {
+		return this.error !== null;
+	}
+	get error() {
+		if (this.fallback) return this.fallback.error;
+		return this._error ?? this.compositor.workerRecordingErrorMessage;
+	}
+	startRecording(stream, onPart) {
+		this.reset();
+		if (!this.compositor.encodesInWorker) {
+			this.fallback = new MultipartRecordingProvider();
+			this.fallback.startRecording(stream, onPart);
+			return;
+		}
+		this.partNumber = 0;
+		const started = this.compositor.startWorkerRecording((chunk) => {
+			this.partNumber += 1;
+			onPart({
+				chunk,
+				partNumber: this.partNumber
+			});
+		});
+		this._isRecording = started;
+		this._error = started ? null : "Failed to start recording: no encoder";
+	}
+	pauseRecording() {
+		if (this.fallback) return this.fallback.pauseRecording();
+		return this._isRecording && this.compositor.pauseWorkerRecording();
+	}
+	resumeRecording() {
+		if (this.fallback) return this.fallback.resumeRecording();
+		return this._isRecording && this.compositor.resumeWorkerRecording();
+	}
+	async stopRecording() {
+		if (this.fallback) {
+			await this.fallback.stopRecording();
+			return;
+		}
+		if (!this._isRecording) return;
+		this._isRecording = false;
+		await this.compositor.stopWorkerRecording();
+	}
+	reset() {
+		this.fallback?.reset();
+		this.fallback = null;
+		this.compositor.cancelWorkerRecording();
+		this._isRecording = false;
+		this._error = null;
+	}
+};
+//#endregion
+export { WorkerEncoderRecordingProvider_exports as n, WorkerEncoderRecordingProvider as t };

package/dist/addressSearch-DzbE9Ogt.esm.js

@@ -0,0 +1,254 @@
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { t as fromCallback } from "./xstate-actors.esm-8Gzepa_A.esm.js";
+//#region src/shared/addressSuggestion.ts
+/** Shown when an autocomplete suggestion has no street (city/region-level result). */
+const STREET_LEVEL_REQUIRED_ERROR = { key: "verification.errors.streetLevelRequired" };
+function isStreetMissingFromSuggestion(suggestion) {
+	return !suggestion.street?.trim();
+}
+/**
+* Validation error for `street` after selecting a suggestion without `street`,
+* or `undefined` when the suggestion is street-level or street is not active.
+*/
+function getStreetLevelErrorForSuggestion(suggestion, activeFields) {
+	if (!activeFields.has("street")) return void 0;
+	return isStreetMissingFromSuggestion(suggestion) ? STREET_LEVEL_REQUIRED_ERROR : void 0;
+}
+/**
+* Fills form values from an address autocomplete suggestion.
+* Shared between eKYC and eKYB address forms.
+*/
+function fillFromSuggestion(values, touched, suggestion, activeFields) {
+	const newValues = { ...values };
+	const newTouched = { ...touched };
+	const hasHouseNoField = !activeFields || activeFields.has("houseNo");
+	const hasStreetField = !activeFields || activeFields.has("street");
+	const streetValue = buildStreetValue(suggestion.street, suggestion.houseNumber, hasHouseNoField);
+	if (hasStreetField) {
+		newValues.street = streetValue;
+		newTouched.street = true;
+	}
+	if (suggestion.city) {
+		newValues.city = suggestion.city;
+		newTouched.city = true;
+	}
+	if (suggestion.stateCode) {
+		newValues.state = suggestion.stateCode;
+		newTouched.state = true;
+	}
+	if (suggestion.postalCode) {
+		newValues.postalCode = suggestion.postalCode;
+		newTouched.postalCode = true;
+	}
+	if (suggestion.houseNumber && hasHouseNoField) {
+		newValues.houseNo = suggestion.houseNumber;
+		newTouched.houseNo = true;
+	}
+	return {
+		values: newValues,
+		touched: newTouched
+	};
+}
+function buildStreetValue(street, houseNumber, hasHouseNoField) {
+	if (hasHouseNoField) return street ?? "";
+	if (houseNumber && street) return `${houseNumber} ${street}`;
+	return houseNumber ?? street ?? "";
+}
+const POSTAL_CODE_MAX_LENGTH_BY_COUNTRY = {
+	US: 10,
+	BR: 9,
+	GB: 8,
+	UK: 8,
+	AR: 8,
+	CA: 7,
+	NL: 6,
+	PT: 8
+};
+const FIXED_LENGTH_KEY = "verification.errors.invalidPostalCodeFixedLength";
+/**
+* Countries whose postal code is a fixed number of digits. It sets the
+* check, the input's max length and the digits-only typing mask.
+*/
+const FIXED_DIGIT_POSTAL_CODE_LENGTH = {
+	BE: 4,
+	DK: 4,
+	NO: 4,
+	PH: 4,
+	DE: 5,
+	ES: 5,
+	FI: 5,
+	FR: 5,
+	GR: 5,
+	IT: 5,
+	KE: 5,
+	MX: 5,
+	CN: 6,
+	IN: 6,
+	NG: 6,
+	SG: 6,
+	IL: 7
+};
+function getPostalCodeMaxLength(country) {
+	return POSTAL_CODE_MAX_LENGTH_BY_COUNTRY[country] ?? FIXED_DIGIT_POSTAL_CODE_LENGTH[country] ?? 8;
+}
+function getPostalCodeErrorKey(country) {
+	if (country in FIXED_DIGIT_POSTAL_CODE_LENGTH) return FIXED_LENGTH_KEY;
+	if (country === "CA") return "verification.errors.CAPostalCodeInvalidFormat";
+	if (country === "AR") return "verification.errors.ARPostalCodeInvalidFormat";
+	if (country === "GB" || country === "UK") return "verification.errors.UKPostalCodeInvalidFormat";
+	if (country === "NL") return "verification.errors.NLPostalCodeInvalidFormat";
+	if (country === "PT") return "verification.errors.PTPostalCodeInvalidFormat";
+	if (country === "US") return "verification.errors.zipCodeInvalidFormat";
+	return "verification.errors.postalCodeInvalidFormat";
+}
+const US_POSTAL_CODE_REGEX = /^(?:\d{5}|\d{9}|\d{5}-\d{4})$/;
+const BR_POSTAL_CODE_REGEX = /^(?:\d{5}|\d{8}|\d{5}-\d{3})$/;
+const CA_POSTAL_CODE_REGEX = /^[A-Za-z]\d[A-Za-z] \d[A-Za-z]\d$/;
+const UK_POSTAL_CODE_REGEX = /^(?:[A-Z]{2}\d|[A-Z]{2}\d{2}|[A-Z]\d|[A-Z]\d{2}|[A-Z]\d[A-Z]|[A-Z]{2}\d[A-Z]) \d[A-Z]{2}$/;
+const AR_POSTAL_CODE_REGEX = /^[A-Za-z]\d{4}[A-Za-z]{3}$/;
+/** Four digits and two uppercase letters, such as 1016DV. */
+const NL_POSTAL_CODE_REGEX = /^\d{4}[A-Z]{2}$/;
+/** Seven digits, the first 1 to 9, with or without a hyphen: 4430-458. */
+const PT_POSTAL_CODE_REGEX = /^[1-9]\d{3}-?\d{3}$/;
+/**
+* Validates a postal code by country.
+* Covers all countries used by eKYC and eKYB.
+*/
+function validatePostalCode(postalCode, country) {
+	if (!postalCode) return false;
+	const fixedDigits = FIXED_DIGIT_POSTAL_CODE_LENGTH[country];
+	if (fixedDigits !== void 0) return postalCode.length === fixedDigits && /^\d+$/.test(postalCode);
+	switch (country) {
+		case "US": return US_POSTAL_CODE_REGEX.test(postalCode);
+		case "BR": return BR_POSTAL_CODE_REGEX.test(postalCode);
+		case "CA": return CA_POSTAL_CODE_REGEX.test(postalCode);
+		case "GB":
+		case "UK": return UK_POSTAL_CODE_REGEX.test(postalCode.toUpperCase());
+		case "AR": return AR_POSTAL_CODE_REGEX.test(postalCode.replace(/\s/g, "").toUpperCase());
+		case "NL": return NL_POSTAL_CODE_REGEX.test(postalCode);
+		case "PT": return PT_POSTAL_CODE_REGEX.test(postalCode);
+		case "CM": return postalCode.length > 0;
+		default: {
+			const stripped = postalCode.replace(/\D/g, "");
+			return /^\d+$/.test(stripped) && [5, 8].includes(stripped.length);
+		}
+	}
+}
+/**
+* Progressively formats postal code input by country.
+* Covers all countries used by eKYC and eKYB.
+*/
+function formatPostalCode(value, country) {
+	const fixedDigits = FIXED_DIGIT_POSTAL_CODE_LENGTH[country];
+	if (fixedDigits !== void 0) return value.replace(/\D/g, "").slice(0, fixedDigits);
+	if (country === "US" || country === "BR") {
+		const maxDigits = country === "US" ? 9 : 8;
+		const hasDash = value.includes("-");
+		const digits = value.replace(/\D/g, "").slice(0, maxDigits);
+		if (digits.length <= 5) {
+			if (hasDash && digits.length === 5) return `${digits}-`;
+			return digits;
+		}
+		if (hasDash) return `${digits.slice(0, 5)}-${digits.slice(5)}`;
+		return digits;
+	}
+	if (country === "CA") {
+		const normalized = value.replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 6);
+		if (normalized.length <= 3) return normalized;
+		return `${normalized.slice(0, 3)} ${normalized.slice(3)}`;
+	}
+	if (country === "GB" || country === "UK") {
+		const normalized = value.replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 7);
+		if (normalized.length <= 3) return normalized;
+		return `${normalized.slice(0, -3)} ${normalized.slice(-3)}`;
+	}
+	if (country === "AR") return value.replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 8);
+	if (country === "PT") {
+		const digits = value.replace(/\D/g, "").slice(0, 7);
+		return digits.length <= 4 ? digits : `${digits.slice(0, 4)}-${digits.slice(4)}`;
+	}
+	if (country === "NL") return `${value.replace(/\D/g, "").slice(0, 4)}${value.replace(/[^A-Za-z]/g, "").slice(0, 2).toUpperCase()}`;
+	return value.slice(0, 8);
+}
+//#endregion
+//#region src/internal/forms/definitionSource.ts
+const queryKey = ({ module, source, country }) => `${module}|${source ?? ""}|${country ?? ""}`;
+/**
+* The definitions bundled with this build. Matches module, source and country
+* exactly, so a pair without its own definition keeps the current builder.
+*/
+function createBundledDefinitionSource(definitions) {
+	const byQuery = new Map(Object.values(definitions).map((definition) => [queryKey(definition), definition]));
+	return { select: (query) => byQuery.get(queryKey(query)) };
+}
+//#endregion
+//#region src/internal/formDefinitionsRollout/formDefinitionsRollout.ts
+/**
+* The rollout switch for form definitions (ENG-59781): one all-or-nothing
+* answer to "do eKYC and eKYB build their forms from catalog definitions, or
+* with today's builders?". Both module adapters ask it before selecting a
+* definition (`selectEkycDefinition`, `selectEkybForm`); the forms kernel
+* (`internal/forms`) knows nothing about it.
+*
+* Off by default, so every source and country keeps today's builder. A
+* catalog-only eKYC source, one today's builder never knew, uses its
+* definition either way, since it has no old path to fall back to.
+*
+* This is Incode's rollout decision, not the integrator's: it is not a
+* `setup()` option. A later step reads a Statsig gate here instead of the
+* constant.
+*/
+const ENABLED_BY_DEFAULT = false;
+/** Whether sources and countries with a form definition use it. */
+function isFormDefinitionsEnabled() {
+	return ENABLED_BY_DEFAULT;
+}
+//#endregion
+//#region src/shared/addressSearch.ts
+/** Searches for address suggestions via the address autocomplete API. */
+async function searchAddress(query, signal) {
+	const res = await api.post(endpoints.addressAutocomplete, { search: query }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addressAutocomplete} failed: ${res.status} ${res.statusText}`);
+	return { apiResponse: { items: (res.data.apiResponse?.items ?? []).map((item, i) => {
+		const addr = item.address ?? item;
+		return {
+			id: item.id ?? i,
+			label: addr.label ?? item.title ?? "",
+			street: addr.street,
+			city: addr.city,
+			stateCode: addr.stateCode ?? addr.state,
+			postalCode: addr.postalCode,
+			houseNumber: addr.houseNumber,
+			countryCode: addr.countryCode
+		};
+	}) } };
+}
+const DEBOUNCE_MS = 300;
+/**
+* XState callback actor that debounces address search requests.
+* Cancels in-flight HTTP requests when the actor is stopped.
+*/
+const debounceSearchActor = fromCallback(({ input, sendBack }) => {
+	const timerProvider = BrowserTimerProvider.getInstance();
+	const controller = new AbortController();
+	const handle = timerProvider.setTimeout(async () => {
+		try {
+			sendBack({
+				type: "RESULTS",
+				suggestions: (await searchAddress(input.query, controller.signal)).apiResponse?.items ?? []
+			});
+		} catch {
+			if (!controller.signal.aborted) sendBack({
+				type: "RESULTS",
+				suggestions: []
+			});
+		}
+	}, DEBOUNCE_MS);
+	return () => {
+		timerProvider.clearTimeout(handle);
+		controller.abort();
+	};
+});
+//#endregion
+export { FIXED_DIGIT_POSTAL_CODE_LENGTH as a, getPostalCodeMaxLength as c, fillFromSuggestion as d, getStreetLevelErrorForSuggestion as f, createBundledDefinitionSource as i, validatePostalCode as l, searchAddress as n, formatPostalCode as o, isFormDefinitionsEnabled as r, getPostalCodeErrorKey as s, debounceSearchActor as t, STREET_LEVEL_REQUIRED_ERROR as u };

package/dist/{advanceableErrors-q_pfU3Cn.esm.js → advanceableErrors-k-U-cL5m.esm.js}

@@ -13,8 +13,7 @@ const VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE = "VIDEO_SELFIE_VALIDATION
 const ADVANCEABLE_ERROR_CODES = [
 	"NONEXISTENT_CUSTOMER",
 	"HINT_NOT_PROVIDED",
-	"NO_MORE_ATTEMPTS",
-	VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE
+	"NO_MORE_ATTEMPTS"
 ];
 /** True when the given code is a module terminal error the flow should advance past rather than fail on. */
 const isAdvanceableError = (moduleErrorCode) => moduleErrorCode !== void 0 && ADVANCEABLE_ERROR_CODES.includes(moduleErrorCode);

package/dist/ae-signature.esm.js

@@ -1,4 +1,4 @@
-import { c as areAllConsented, i as AE_CONSENT_KEYS, r as electronicSignatureMachine, t as createElectronicSignatureManager, u as getDefaultConsentChecks } from "./electronicSignatureManager-CcIMOb_Y.esm.js";
+import { c as areAllConsented, i as AE_CONSENT_KEYS, r as electronicSignatureMachine, t as createElectronicSignatureManager, u as getDefaultConsentChecks } from "./electronicSignatureManager-BCE3uA3z.esm.js";
 //#region src/modules/ae-signature/index.ts
 function createAeSignatureManager(options) {
 	return createElectronicSignatureManager({ config: {

package/dist/antifraud.esm.js

@@ -1,3 +1,3 @@
-import { t as antifraudMachine } from "./antifraudStateMachine-DRl0UVyA.esm.js";
-import { n as createAntifraudManagerFromActor, t as createAntifraudManager } from "./antifraudManager-CaweCYnY.esm.js";
+import { t as antifraudMachine } from "./antifraudStateMachine-Dfrd2-26.esm.js";
+import { n as createAntifraudManagerFromActor, t as createAntifraudManager } from "./antifraudManager-BObuHBjn.esm.js";
 export { antifraudMachine, createAntifraudManager, createAntifraudManagerFromActor };

package/dist/{antifraudManager-CaweCYnY.esm.js → antifraudManager-BObuHBjn.esm.js}

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Du2A4-Qr.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ggpBBaZ8.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
-import { t as antifraudMachine } from "./antifraudStateMachine-DRl0UVyA.esm.js";
+import { t as antifraudMachine } from "./antifraudStateMachine-Dfrd2-26.esm.js";
 //#region src/modules/antifraud/antifraudActor.ts
 function createAntifraudActor() {
 	return createActor(antifraudMachine).start();

package/dist/{antifraudStateMachine-DRl0UVyA.esm.js → antifraudStateMachine-Dfrd2-26.esm.js}

@@ -1,4 +1,4 @@
-import { t as api, u as endpoints } from "./api-Cz90EHyu.esm.js";
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
 import { t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-8Gzepa_A.esm.js";
 //#region src/modules/antifraud/antifraudServices.ts

package/dist/{api-Cz90EHyu.esm.js → api-CpP4PS4S.esm.js}

@@ -1,7 +1,8 @@
-import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
+import { n as getTimestamp } from "./IBrowserEnvironmentCapability-D7JG7ML3.esm.js";
 //#region src/internal/http/endpoints.ts
 const endpoints = {
 	createSession: "/omni/start",
+	sessionContinue: "/omni/session/continue",
 	flow: "/omni/onboarding/flow",
 	events: "/omni/interview-events",
 	selfie: "/omni/add/face",
@@ -63,6 +64,8 @@ const endpoints = {
 	addGeolocation: "/omni/add/geolocation",
 	ekycSubmit: "/omni/externalVerification/ekyc",
 	ekybSubmit: "/omni/externalVerification/ekyb",
+	kybForm: "/omni/kyb/form",
+	kybSubmit: "/omni/kyb",
 	getCombinedConsent: "/omni/get/combined-consent",
 	signCombinedConsent: "/omni/sign-combined-consent",
 	getConsents: "/omni/consents",
@@ -270,10 +273,10 @@ async function withTiming(method, url, call) {
 * (later keys overwrite earlier ones in object spread).
 *
 * Existing call sites that already pass an explicit
-* `X-Incode-Hardware-Id` header (`recordingsRepository.uploadDeepsightVideo`,
-* `internal/virtualCameraCheck.logFrame`) now use the value they
-* passed in unconditionally — previously the auto-injection silently
-* clobbered them. Both call sites pass tokens that are already
+* `X-Incode-Hardware-Id` header (`recordingsRepository.uploadDeepsightVideo`;
+* the retired `internal/virtualCameraCheck.logFrame` did too) now use the
+* value they passed in unconditionally — previously the auto-injection
+* silently clobbered them. Those call sites pass tokens that are already
 * supposed to be the active session token, so behaviour is
 * unchanged in practice; the change unblocks personhood (which
 * needs to attach its own slot's token) without bypassing the

package/dist/{apiError-DPwFas2f.esm.js → apiError-DH-CH4Nz.esm.js}

@@ -1,4 +1,4 @@
-import { d as categoryForEndpoint, u as trueSightLog } from "./trueSightService-BMT-TubT.esm.js";
+import { d as categoryForEndpoint, u as trueSightLog } from "./trueSightService-GuLthUVK.esm.js";
 //#region src/internal/http/apiError.ts
 /**
 * Incode API error.

package/dist/attemptCarry-WOkfvFMw.esm.js

@@ -0,0 +1,45 @@
+import { r as getToken } from "./api-CpP4PS4S.esm.js";
+import { a as watchConnectivity } from "./connectivity-BCuEoQ-n.esm.js";
+//#region src/internal/session/attemptCarry.ts
+const carried = /* @__PURE__ */ new Map();
+/**
+* Keeps spent attempts across the remount after a connectivity loss: the
+* session boundary stops the step while offline and mounts a new manager on
+* recovery. Call once in the machine's `context` factory.
+*
+* `read` sees every snapshot until connectivity is lost, so an attempt whose
+* outcome arrives after the loss is not charged. It returns the counters the
+* next mount starts with; a step that reached its no-attempts outcome must
+* return a value its start guard reads as spent. Only an actor that ends while
+* connectivity is lost leaves a carry, and the next actor of the same machine
+* in the session takes it once.
+*/
+function carryAttempts(machineId, self, read) {
+	const token = getToken();
+	if (token === null) return {};
+	const key = `${token}:${machineId}`;
+	const restored = carried.get(key) ?? {};
+	carried.delete(key);
+	let carry = restored;
+	let lost = false;
+	const unwatch = watchConnectivity((next) => {
+		lost = next;
+	});
+	const end = () => {
+		unwatch();
+		if (lost) carried.set(key, carry);
+	};
+	self.subscribe({
+		next: (snapshot) => {
+			if (!lost) carry = read(snapshot, carry);
+		},
+		complete: end,
+		error: (err) => {
+			end();
+			throw err;
+		}
+	});
+	return restored;
+}
+//#endregion
+export { carryAttempts as t };

package/dist/authentication.d.ts

@@ -1,4 +1,4 @@
-import { C as authenticationMachine, S as createAuthenticationActor, b as AuthenticationActor, x as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-1hzeS_rB.js";
-import { t as AuthenticationConfig } from "./types-zOgZqMni.js";
-import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-BIZC55Bi.js";
+import { C as authenticationMachine, S as createAuthenticationActor, b as AuthenticationActor, x as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-DV2ULUYS.js";
+import { t as AuthenticationConfig } from "./types-J6g6iKe_.js";
+import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-CWmh7aSY.js";
 export { type AuthenticationActor, type AuthenticationConfig, type AuthenticationManager, type AuthenticationState, type CreateAuthenticationActorOptions, authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/authentication.esm.js

@@ -1,3 +1,3 @@
-import { t as authenticationMachine } from "./authenticationStateMachine-C99B0GFP.esm.js";
-import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-2Lr5V_7p.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-BMbZL8wm.esm.js";
+import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-DjX0XDyH.esm.js";
 export { authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/{authenticationManager-BIZC55Bi.d.ts → authenticationManager-CWmh7aSY.d.ts}

@@ -1,6 +1,6 @@
 import { t as Manager } from "./Manager-C9T5amUN.js";
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
-import { b as AuthenticationActor, n as FaceCaptureManagerState, t as FaceCaptureManager, x as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-1hzeS_rB.js";
+import { b as AuthenticationActor, n as FaceCaptureManagerState, t as FaceCaptureManager, x as CreateAuthenticationActorOptions } from "./faceCaptureManagerFactory-DV2ULUYS.js";
 //#region src/modules/authentication/authenticationManager.d.ts
 type AuthenticationState = FaceCaptureManagerState;
 /**

package/dist/{authenticationManager-2Lr5V_7p.esm.js → authenticationManager-DjX0XDyH.esm.js}

@@ -1,9 +1,9 @@
-import { u as BrowserStorageProvider } from "./setup-BInNAvQw.esm.js";
-import { t as WasmUtilProvider } from "./WasmUtilProvider-DtJuBdt-.esm.js";
-import { n as eventModuleNames } from "./events-Du2A4-Qr.esm.js";
+import { u as BrowserStorageProvider } from "./setup-DDahygZs.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-Dp2V-Uct.esm.js";
+import { n as eventModuleNames } from "./events-ggpBBaZ8.esm.js";
 import { s as createActor } from "./xstate.esm-DSajW7CJ.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-BlGvXzXA.esm.js";
-import { t as authenticationMachine } from "./authenticationStateMachine-C99B0GFP.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-Dp90bedH.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-BMbZL8wm.esm.js";
 //#region src/modules/authentication/authenticationActor.ts
 function createAuthenticationActor(options) {
 	const dependencies = options.dependencies ?? {

package/dist/{authenticationStateMachine-C99B0GFP.esm.js → authenticationStateMachine-BMbZL8wm.esm.js}

@@ -1,8 +1,8 @@
 import { i as assign } from "./xstate.esm-DSajW7CJ.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-8Gzepa_A.esm.js";
-import { n as createDefaultProtectedFaceControllerActor, t as faceCaptureMachine } from "./faceCaptureSetup-TY8RXc2N.esm.js";
-import { d as FACE_ERROR_CODES, f as isOnDeviceMode } from "./FaceDetectionProvider-DcPOC2gS.esm.js";
-import { o as PROTECTED_CAPTURE_TARGET } from "./createCameraCycleOwnership-Dj_LHUvN.esm.js";
+import { n as createDefaultProtectedFaceControllerActor, t as faceCaptureMachine } from "./faceCaptureSetup-ZfiWg0fo.esm.js";
+import { d as isOnDeviceMode, u as FACE_ERROR_CODES } from "./FaceDetectionProvider-CAY43vSI.esm.js";
+import { s as PROTECTED_CAPTURE_TARGET } from "./desktopCameraElection-BGMtYwk3.esm.js";
 //#region src/modules/authentication/authenticationErrorUtils.ts
 const AUTH_ERROR_MAP = {
 	SPOOF_ATTEMPT_DETECTED: FACE_ERROR_CODES.SPOOF_ATTEMPT_DETECTED,

package/dist/backCameraLabel-yda5ugE4.esm.js

@@ -0,0 +1,67 @@
+//#region src/internal/camera/backCameraLabel.ts
+const BACK_CAMERA_KEYWORDS = [
+	"rear",
+	"back",
+	"rück",
+	"arrière",
+	"trasera",
+	"trás",
+	"traseira",
+	"posteriore",
+	"后面",
+	"後面",
+	"背面",
+	"后置",
+	"後置",
+	"背置",
+	"задней",
+	"الخلفية",
+	"후",
+	"arka",
+	"achterzijde",
+	"หลัง",
+	"baksidan",
+	"bagside",
+	"sau",
+	"bak",
+	"tylny",
+	"takakamera",
+	"belakang",
+	"אחורית",
+	"πίσω",
+	"spate",
+	"hátsó",
+	"zadní",
+	"darrere",
+	"zadná",
+	"задня",
+	"stražnja",
+	"बैक"
+];
+function isBackCameraLabel(label) {
+	const lowercaseLabel = label.toLowerCase();
+	return BACK_CAMERA_KEYWORDS.some((keyword) => lowercaseLabel.includes(keyword));
+}
+function isBackFacingTrack(track) {
+	const settings = track.getSettings();
+	return isBackCameraLabel(track.label) || settings.facingMode === "environment";
+}
+/**
+* Pick the best back-facing device from a list already filtered by label.
+* Prefers the highest megapixel count when labels advertise it, else the first.
+*/
+function selectBestBackDevice(devices) {
+	if (devices.length === 1) return devices[0];
+	const withMp = devices.map((d) => {
+		const match = d.label.match(/\b([0-9]+)\s*MP?\b/i);
+		return {
+			device: d,
+			mp: match ? parseInt(match[1], 10) : 0
+		};
+	});
+	const maxMp = Math.max(...withMp.map((w) => w.mp));
+	const best = withMp.find((w) => w.mp === maxMp);
+	return best ? best.device : devices[0];
+}
+//#endregion
+export { isBackFacingTrack as n, selectBestBackDevice as r, isBackCameraLabel as t };