@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/warmup-CUUnwYxe.esm.js

@@ -0,0 +1,714 @@
+import { _ as WASM_PIPELINE_OPTIONAL_MODEL_NAMES, b as resolveWasmSource, d as SemaphoreProvider, h as WASM_PIPELINE_MODELS, l as loadWasmModule, n as createWebApiHostAdapter, p as WASM_MODEL_FILES, u as acquireWasmStorageFallback, v as buildModelVariantSources, y as missingWasmModelError } from "./wasmWebClient-B7baE-Wf.esm.js";
+//#region ../infra/src/wasm/wasmEnumMaps.ts
+function pipelineTypeToWasmEnum(wasmModule, type) {
+	switch (type) {
+		case 0: return wasmModule.WorkflowType.IdBlurGlareWorkflow;
+		case 1: return wasmModule.WorkflowType.IdBarcodeAndTextQualityWorkflow;
+		case 2: return wasmModule.WorkflowType.IdVideoSelfieWorkflow;
+		case 3: return wasmModule.WorkflowType.SelfieWithAggregationMetrics;
+		case 4: return wasmModule.WorkflowType.SelfieWithQualityMetrics;
+		case 5: return wasmModule.WorkflowType.OnDeviceSelfieWorkflow;
+		case 6: return wasmModule.WorkflowType.IdBlurGlareCoreWorkflow;
+		case 7: return wasmModule.WorkflowType.IdBarcodeAndTextQualityCoreWorkflow;
+		case 8: return wasmModule.WorkflowType.IdFaceQualityCoreWorkflow;
+		default: throw new Error("Unknown pipeline type");
+	}
+}
+function pipelineTypeFromWasmEnum(wasmModule, type) {
+	switch (type) {
+		case wasmModule.WorkflowType.IdBlurGlareWorkflow: return 0;
+		case wasmModule.WorkflowType.IdBarcodeAndTextQualityWorkflow: return 1;
+		case wasmModule.WorkflowType.IdVideoSelfieWorkflow: return 2;
+		case wasmModule.WorkflowType.SelfieWithAggregationMetrics: return 3;
+		case wasmModule.WorkflowType.SelfieWithQualityMetrics: return 4;
+		case wasmModule.WorkflowType.OnDeviceSelfieWorkflow: return 5;
+		case wasmModule.WorkflowType.IdBlurGlareCoreWorkflow: return 6;
+		case wasmModule.WorkflowType.IdBarcodeAndTextQualityCoreWorkflow: return 7;
+		case wasmModule.WorkflowType.IdFaceQualityCoreWorkflow: return 8;
+		default: throw new Error("Unknown pipeline type");
+	}
+}
+function idCaptureModelTypeToWasmEnum(wasmModule, type) {
+	switch (type) {
+		case 0: return wasmModule.IdCaptureModelType.IdCaptureV1x;
+		case 1: return wasmModule.IdCaptureModelType.IdCaptureV2x;
+		case 2: return wasmModule.IdCaptureModelType.IdCaptureV3x;
+		default: throw new Error("Unknown Id Capture model type");
+	}
+}
+function idCaptureModelTypeFromWasmEnum(wasmModule, type) {
+	switch (type) {
+		case wasmModule.IdCaptureModelType.IdCaptureV1x: return 0;
+		case wasmModule.IdCaptureModelType.IdCaptureV2x: return 1;
+		case wasmModule.IdCaptureModelType.IdCaptureV3x: return 2;
+		default: throw new Error("Unknown Id Capture model type");
+	}
+}
+//#endregion
+//#region ../infra/src/wasm/CameraCycleOwnershipDomain.ts
+const CAMERA_CYCLE_OWNERSHIP_DOMAIN = Symbol("cameraCycleOwnershipDomain");
+var CameraCycleOwnershipDomain = class {
+	constructor() {
+		this.generation = 0;
+	}
+	snapshot() {
+		return {
+			generation: this.generation,
+			activeOwner: this.activeOwner
+		};
+	}
+	transfer(owner) {
+		this.generation += 1;
+		this.activeOwner = owner;
+	}
+	releaseController(creationGeneration, createdWithoutOwner) {
+		if (!createdWithoutOwner || this.generation !== creationGeneration || this.activeOwner !== void 0) return false;
+		this.generation += 1;
+		this.activeOwner = void 0;
+		return true;
+	}
+	releaseAttempt(owner) {
+		if (this.activeOwner !== owner) return false;
+		this.generation += 1;
+		this.activeOwner = void 0;
+		return true;
+	}
+};
+function getCameraCycleOwnershipDomain(owner) {
+	const domainOwner = owner;
+	const existing = domainOwner[CAMERA_CYCLE_OWNERSHIP_DOMAIN];
+	if (existing) return existing;
+	const domain = new CameraCycleOwnershipDomain();
+	Object.defineProperty(domainOwner, CAMERA_CYCLE_OWNERSHIP_DOMAIN, {
+		configurable: false,
+		enumerable: false,
+		value: domain,
+		writable: false
+	});
+	return domain;
+}
+//#endregion
+//#region ../infra/src/wasm/WasmRuntime.ts
+function attemptCleanup(firstFailure, cleanup) {
+	try {
+		cleanup();
+	} catch (error) {
+		return firstFailure ?? { error };
+	}
+	return firstFailure;
+}
+function stopStreamTracks(stream) {
+	let firstFailure = null;
+	let tracks = [];
+	try {
+		tracks = stream?.getTracks() ?? [];
+	} catch (error) {
+		firstFailure = { error };
+	}
+	for (const track of tracks) try {
+		track.stop();
+	} catch (error) {
+		firstFailure ??= { error };
+	}
+	return firstFailure;
+}
+function deleteWasmHandle(firstFailure, handle) {
+	const deleteHandle = handle?.delete;
+	if (!deleteHandle) return firstFailure;
+	return attemptCleanup(firstFailure, () => deleteHandle.call(handle));
+}
+function releaseCameraCycleResources(stream, cameraCycleApi) {
+	return attemptCleanup(stopStreamTracks(stream), () => cameraCycleApi?.rcc());
+}
+var WasmRuntime = class WasmRuntime {
+	constructor(loadModule = loadWasmModule) {
+		this.loadModule = loadModule;
+		this[CAMERA_CYCLE_OWNERSHIP_DOMAIN] = new CameraCycleOwnershipDomain();
+		this.loadedModels = /* @__PURE__ */ new Map();
+		this.modelsBuffers = null;
+		this.inputImageBuffer = null;
+		this.wasmModule = null;
+		this.workflowApiUtilities = null;
+		this.utilityApi = null;
+		this.idCaptureWasmApi = null;
+		this.faceProcessingWasmApi = null;
+		this.cameraCycleApi = null;
+		this.webApi = null;
+		this.storageFallbackLease = null;
+		this.unprotectedStream = null;
+		this.imageWidth_ = null;
+		this.imageHeight_ = null;
+		this.pipelines_ = null;
+		this.isInitialized_ = false;
+		this.usedSimd_ = true;
+		this.mlCallSemaphore = new SemaphoreProvider();
+	}
+	async initialize({ module, pipelines }) {
+		await this.freeResources();
+		try {
+			this.pipelines_ = pipelines;
+			this.storageFallbackLease = acquireWasmStorageFallback();
+			const { wasmModule, simdUsed } = await this.loadModule(module);
+			this.wasmModule = wasmModule;
+			this.usedSimd_ = simdUsed;
+			this.workflowApiUtilities = new this.wasmModule.WorkflowApiUtilities();
+			this.utilityApi = new this.wasmModule.UtilityApi();
+			this.idCaptureWasmApi = new this.wasmModule.IdCaptureApi();
+			this.faceProcessingWasmApi = new this.wasmModule.FaceProcessingApi();
+			this.cameraCycleApi = new this.wasmModule.CameraCycleApi();
+			this.webApi = new this.wasmModule.WebApi(createWebApiHostAdapter());
+			this.isInitialized_ = true;
+			return simdUsed;
+		} catch (error) {
+			try {
+				await this.freeResources();
+			} catch {}
+			throw error;
+		}
+	}
+	/**
+	* Returns initialization status
+	* @returns
+	*/
+	isInitialized() {
+		return this.workflowApiUtilities != null && this.utilityApi != null && this.idCaptureWasmApi != null && this.faceProcessingWasmApi != null && this.isInitialized_;
+	}
+	/**
+	* Allocate shared memory for image buffers (RGBA format)
+	* Use it every time when the frame dimentions changes
+	* @param {number} imageWidth - image width
+	* @param {number} imageHeight - image height
+	*/
+	async allocateImageBuffers(imageWidth, imageHeight) {
+		const workflowApiUtilities = this.requireWorkflowApiUtilities("Unable to allocate image buffers, cpp API hasn't been initialized");
+		if (imageWidth && imageHeight && imageWidth == this.imageWidth_ && imageHeight == this.imageHeight_ && this.inputImageBuffer && this.inputImageBuffer.byteLength !== 0 && imageWidth * imageHeight * 4 === this.inputImageBuffer.length) return;
+		this.imageWidth_ = imageWidth;
+		this.imageHeight_ = imageHeight;
+		this.inputImageBuffer = workflowApiUtilities.allocateInputImageBuffer(imageWidth, imageHeight, 4);
+	}
+	/**
+	* Copies one frame into the shared input image buffer.
+	*
+	* The only write path into `inputImageBuffer`, so no caller outside this class
+	* touches the field. It is the guard + `set()` pair that `process`,
+	* `runIdCapture`, `runSelfieCapture` and `analyzeFrame` each performed inline,
+	* including the error message: semantically identical at all four sites, and
+	* byte-identical at three. `analyzeFrame`'s local capture (`const
+	* inputImageBuffer = this.inputImageBuffer`, then `.set()` on the local) is
+	* folded into a double read of the field, which cannot observe two different
+	* values because nothing awaits between the guard and the `set()`.
+	*
+	* Buffers must already be sized by {@link allocateImageBuffers}.
+	*/
+	writeFrame(image) {
+		if (this.inputImageBuffer === null) throw new Error("Unable to process the image, buffers haven't been allocated!");
+		if (image) this.inputImageBuffer.set(image.data);
+	}
+	async handleDetectionCallAndUpdateState(type) {
+		this.requireWorkflowApiUtilities("Unable to update pipeline state, cpp API hasn't been initialized").handleDetectionCallAndUpdateState(this.pipelineTypeToWasmEnum(type));
+	}
+	/**
+	* Free allocated memory
+	*/
+	async freeResources() {
+		this.loadedModels.clear();
+		const stream = this.unprotectedStream;
+		const modelsBuffers = this.modelsBuffers;
+		const workflowApiUtilities = this.workflowApiUtilities;
+		const utilityApi = this.utilityApi;
+		const idCaptureWasmApi = this.idCaptureWasmApi;
+		const faceProcessingWasmApi = this.faceProcessingWasmApi;
+		const cameraCycleApi = this.cameraCycleApi;
+		const webApi = this.webApi;
+		const storageFallbackLease = this.storageFallbackLease;
+		this.unprotectedStream = null;
+		this.workflowApiUtilities = null;
+		this.utilityApi = null;
+		this.idCaptureWasmApi = null;
+		this.faceProcessingWasmApi = null;
+		this.cameraCycleApi = null;
+		this.webApi = null;
+		this.storageFallbackLease = null;
+		this.wasmModule = null;
+		this.modelsBuffers = null;
+		this.inputImageBuffer = null;
+		this.imageWidth_ = null;
+		this.imageHeight_ = null;
+		this.pipelines_ = null;
+		this.isInitialized_ = false;
+		if (typeof window !== "undefined") window.wasmArrayBuffer = null;
+		let firstFailure = releaseCameraCycleResources(stream, cameraCycleApi);
+		firstFailure = deleteWasmHandle(firstFailure, modelsBuffers);
+		firstFailure = deleteWasmHandle(firstFailure, workflowApiUtilities);
+		firstFailure = deleteWasmHandle(firstFailure, utilityApi);
+		firstFailure = deleteWasmHandle(firstFailure, idCaptureWasmApi);
+		firstFailure = deleteWasmHandle(firstFailure, faceProcessingWasmApi);
+		firstFailure = deleteWasmHandle(firstFailure, cameraCycleApi);
+		firstFailure = deleteWasmHandle(firstFailure, webApi);
+		firstFailure = attemptCleanup(firstFailure, () => storageFallbackLease?.release());
+		if (firstFailure) throw firstFailure.error;
+	}
+	/**
+	* Clear pipeline state
+	*/
+	resetPipeline(type) {
+		this.requireWorkflowApiUtilities("Unable to reset pipeline, cpp API hasn't been initialized").resetWorkflow(this.pipelineTypeToWasmEnum(type));
+	}
+	/**
+	* Clear all pipelines states
+	*/
+	resetAllPipelines() {
+		const pipelines = this.pipelines_;
+		if (!this.isInitialized() || pipelines === null) throw new Error("Unable to reset pipelines, cpp API hasn't been initialized");
+		for (const [type] of pipelines) this.resetPipeline(type);
+	}
+	async process(typeOrImage, imageOrType) {
+		const legacyOrder = typeof typeOrImage !== "number";
+		const type = legacyOrder ? typeof imageOrType === "number" ? imageOrType : void 0 : typeOrImage;
+		const image = legacyOrder ? typeOrImage : typeof imageOrType === "number" ? void 0 : imageOrType;
+		const message = "Unable to process the image, cpp API hasn't been initialized";
+		const idCaptureWasmApi = this.requireIdCaptureApi(message);
+		const faceProcessingWasmApi = this.requireFaceProcessingApi(message);
+		if (image) {
+			await this.allocateImageBuffers(image.width, image.height);
+			this.writeFrame(image);
+		}
+		switch (type) {
+			case 0:
+			case 1:
+			case 6:
+			case 7:
+			case 8: return idCaptureWasmApi.runIdCaptureWorkflow(this.pipelineTypeToWasmEnum(type));
+			case 2: return idCaptureWasmApi.runIdVideoSelfieWorkflow();
+			case 3:
+			case 4:
+			case 5: return faceProcessingWasmApi.runSelfieWorkflow(this.pipelineTypeToWasmEnum(type));
+			default: throw new Error("Unknown pipeline type");
+		}
+	}
+	async loadModels(pipelines = this.pipelines_) {
+		const message = "Unable load the models, cpp API hasn't been initialized";
+		const buffSizes = new (this.requireWasmModule(message)).WorkflowTypeToIntMap();
+		const modelData = /* @__PURE__ */ new Map();
+		const sizeVectors = [];
+		let operationFailure = null;
+		let cleanupFailure = null;
+		try {
+			if (pipelines === null) throw new Error(message);
+			for (const [type, modelsPaths] of pipelines) {
+				const wasmType = this.pipelineTypeToWasmEnum(type);
+				const pipelineBuffers = [];
+				const sizes = new (this.requireWasmModule(message)).VectorInt();
+				sizeVectors.push(sizes);
+				for (const path of modelsPaths) {
+					const resolvedSource = this.resolveModelSource(path);
+					let model = this.loadedModels.get(resolvedSource);
+					if (!model) {
+						model = await resolveWasmSource(resolvedSource, "model");
+						this.loadedModels.set(resolvedSource, model);
+					}
+					sizes.push_back(model.byteLength);
+					pipelineBuffers.push(model);
+				}
+				buffSizes.set(wasmType, sizes);
+				modelData.set(wasmType, pipelineBuffers);
+			}
+			const modelsBuffers = this.requireWorkflowApiUtilities(message).allocateModelsBuffers(buffSizes);
+			for (const [type, paths] of pipelines) this.pipelines_?.set(type, paths);
+			this.modelsBuffers = modelsBuffers;
+			for (const [type, data] of modelData) {
+				let buffers = null;
+				try {
+					buffers = modelsBuffers.get(type) ?? null;
+					if (!buffers) throw new Error("Unable to get model buffer from shared memory!");
+					for (let k = 0; k < buffers.size(); k++) {
+						const buffer = buffers.get(k);
+						if (buffer) buffer.set(data[k]);
+						else throw new Error("Unable to get model buffer from shared memory!");
+					}
+				} finally {
+					cleanupFailure = deleteWasmHandle(cleanupFailure, buffers);
+				}
+			}
+		} catch (error) {
+			operationFailure = { error };
+		} finally {
+			for (const sizes of sizeVectors) cleanupFailure = deleteWasmHandle(cleanupFailure, sizes);
+			cleanupFailure = deleteWasmHandle(cleanupFailure, buffSizes);
+		}
+		if (operationFailure) throw operationFailure.error;
+		if (cleanupFailure) throw cleanupFailure.error;
+	}
+	async initializePipelines() {
+		const message = "Unable to initialize pipelines, cpp API hasn't been initialized";
+		this.requireWorkflowApiUtilities(message);
+		if (!this.modelsBuffers) await this.loadModels();
+		this.requireWorkflowApiUtilities(message).initializeWorkflows();
+	}
+	getPipelineState() {
+		return this.requireWorkflowApiUtilities("Unable to get pipeline state, cpp API hasn't been initialized").getWorkflowState();
+	}
+	getCurrentPipeline() {
+		const workflowApiUtilities = this.requireWorkflowApiUtilities("Unable to get current pipeline, cpp API hasn't been initialized");
+		return this.pipelineTypeFromWasmEnum(workflowApiUtilities.getCurrentWorkflow());
+	}
+	setOnDeviceMode(_enabled) {}
+	adoptCameraStream(stream, constraints, options = {}) {
+		return this.requireCameraCycleApi("Unable to adopt stream, cpp API hasn't been initialized").ads(stream, constraints, options);
+	}
+	setWorkflowConsuming(type, consuming) {
+		const accepted = this.requireWorkflowApiUtilities("Unable to set workflow consuming, cpp API hasn't been initialized").setWorkflowConsuming(this.pipelineTypeToWasmEnum(type), consuming);
+		return consuming ? accepted : true;
+	}
+	captureProtectedFrame(target) {
+		return this.requireCameraCycleApi("Unable to capture protected frame, cpp API hasn't been initialized").mcp(target);
+	}
+	paintFrameToCanvas(canvas, options) {
+		return this.requireCameraCycleApi("Unable to paint frame, cpp API hasn't been initialized").pfc(canvas, options);
+	}
+	getCaptureSize() {
+		return this.requireCameraCycleApi("Unable to get capture size, cpp API hasn't been initialized").gcs();
+	}
+	getUnprotectedStream() {
+		const nextStream = this.requireCameraCycleApi("Unable to get unprotected stream, cpp API hasn't been initialized").gus();
+		const previousStream = this.unprotectedStream;
+		this.unprotectedStream = nextStream;
+		if (previousStream && previousStream !== nextStream) {
+			const failure = stopStreamTracks(previousStream);
+			if (failure) throw failure.error;
+		}
+		return nextStream;
+	}
+	postProtectedRequest(request) {
+		const extras = "extras" in request ? request.extras : {};
+		return this.requireWebApi("Unable to post protected request, cpp API hasn't been initialized").pse(request.target, extras, request.config ?? {});
+	}
+	releaseCameraCycle() {
+		const stream = this.unprotectedStream;
+		this.unprotectedStream = null;
+		const firstFailure = releaseCameraCycleResources(stream, this.cameraCycleApi);
+		if (firstFailure) throw firstFailure.error;
+	}
+	resolveModelSource(source) {
+		if (typeof source === "object" && !(source instanceof ArrayBuffer) && !(source instanceof Uint8Array)) return this.usedSimd_ ? source.current : source.legacy;
+		return source;
+	}
+	pipelineTypeToWasmEnum(type) {
+		return pipelineTypeToWasmEnum(this.requireWasmModule(WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE), type);
+	}
+	pipelineTypeFromWasmEnum(type) {
+		return pipelineTypeFromWasmEnum(this.requireWasmModule(WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE), type);
+	}
+	IdCaptureModelTypeToWasmEnum(type) {
+		return idCaptureModelTypeToWasmEnum(this.requireWasmModule(WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE), type);
+	}
+	/**
+	* Kept as an upstream mirror (`src/web/wasmApi.ts` declares the reverse map)
+	* but has no callers, so it stays **private** and off {@link WasmRuntimeApi}:
+	* dead code must not become public surface.
+	*/
+	IdCaptureModelTypeFromWasmEnum(type) {
+		return idCaptureModelTypeFromWasmEnum(this.requireWasmModule(WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE), type);
+	}
+	/**
+	* Handle accessors. Each throws the caller's message when the C++ API is not
+	* initialized and otherwise returns the non-null handle, so every wrapper gets
+	* a narrowed handle without repeating a null check. The message is the
+	* caller's, not this class's, so the wrapper's own pre-init contract is
+	* preserved verbatim.
+	*
+	* `isInitialized()` checks the four ML handles plus `isInitialized_`; it does
+	* not check `wasmModule` or `webApi`. Both are set in `initialize()` and
+	* cleared in `freeResources()`, i.e. they share the exact lifetime of the four
+	* checked handles, so the extra `=== null` clause is unreachable in practice —
+	* it turns a would-be `TypeError` into the same `Error(message)` in a state
+	* that cannot occur. `!this.isInitialized()` is tested first so the observable
+	* message never changes.
+	*/
+	requireWorkflowApiUtilities(message) {
+		if (!this.isInitialized() || this.workflowApiUtilities === null) throw new Error(message);
+		return this.workflowApiUtilities;
+	}
+	requireUtilityApi(message) {
+		if (!this.isInitialized() || this.utilityApi === null) throw new Error(message);
+		return this.utilityApi;
+	}
+	requireIdCaptureApi(message) {
+		if (!this.isInitialized() || this.idCaptureWasmApi === null) throw new Error(message);
+		return this.idCaptureWasmApi;
+	}
+	requireFaceProcessingApi(message) {
+		if (!this.isInitialized() || this.faceProcessingWasmApi === null) throw new Error(message);
+		return this.faceProcessingWasmApi;
+	}
+	requireCameraCycleApi(message) {
+		if (!this.isInitialized() || this.cameraCycleApi === null) throw new Error(message);
+		return this.cameraCycleApi;
+	}
+	requireWasmModule(message) {
+		if (!this.isInitialized() || this.wasmModule === null) throw new Error(message);
+		return this.wasmModule;
+	}
+	requireWebApi(message) {
+		if (!this.isInitialized() || this.webApi === null) throw new Error(message);
+		return this.webApi;
+	}
+};
+WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE = "Unable to map pipeline type, cpp API hasn't been initialized";
+/** Process-wide runtime. One binary, one heap, one owner. */
+const wasmRuntime = new WasmRuntime();
+//#endregion
+//#region ../infra/src/wasm/warmup.ts
+/**
+* Pipelines preloaded when no explicit `pipelines` array is passed to
+* {@link warmupWasm}. The on-device selfie bundle is opt-in (loaded only when
+* a SELFIE/AUTH module has `onDeviceFaceResultsSubmissionEnabled: true`), so
+* it is intentionally excluded here to keep the default warmup small.
+*/
+const WASM_PIPELINES = ["selfie", "idCapture"];
+let state = "idle";
+let loadingPromise = null;
+let wasmError = null;
+let loadedPipelines = [];
+let lastConfig = null;
+let lastModelVariant = null;
+let pipelinesInFlight = [];
+function mapPipelineToWasmType(pipeline) {
+	switch (pipeline) {
+		case "selfie": return 4;
+		case "onDeviceSelfie": return 5;
+		case "idCapture": return 0;
+		case "videoSelfie": return 3;
+		case "videoSelfieId": return 2;
+		default: throw new Error(`Unknown pipeline: ${pipeline}`);
+	}
+}
+/**
+* Derives the models base path from the WASM path.
+* Assumes models are in a 'models' subdirectory relative to the WASM binary location.
+* e.g., '/wasm/v2/binary.wasm' -> '/wasm/v2/models'
+*/
+function deriveModelsBasePath(wasmPath) {
+	const lastSlashIndex = wasmPath.lastIndexOf("/");
+	if (lastSlashIndex === -1) return "models";
+	return `${wasmPath.substring(0, lastSlashIndex)}/models`;
+}
+/**
+* The models base path resolved from the last successful warmup, mirroring the
+* load-time resolution (explicit `modelsBasePath`, else derived from
+* `wasmPath`). `undefined` before any warmup. Used to locate lazily-loaded
+* models such as the PDF417 barcode enhancement model at the correct base so
+* self-hosted / air-gapped deployments resolve it too.
+*/
+function getResolvedModelsBasePath() {
+	if (!lastConfig) return;
+	if (lastConfig.modelsBasePath) return lastConfig.modelsBasePath;
+	return typeof lastConfig.wasmPath === "string" ? deriveModelsBasePath(lastConfig.wasmPath) : void 0;
+}
+function getResolvedModelSource(fileName, pipeline) {
+	if (!lastConfig) return;
+	const explicit = lastModelVariant === "legacy" ? lastConfig.legacyModelUrls?.[fileName] ?? lastConfig.modelUrls?.[fileName] : lastConfig.modelUrls?.[fileName];
+	if (explicit !== void 0) return explicit;
+	if (lastConfig.selfHosted) throw missingWasmModelError(fileName, pipeline);
+	const basePath = getResolvedModelsBasePath();
+	if (!basePath) return;
+	const source = buildModelVariantSources(basePath, fileName);
+	if (typeof source === "string") return source;
+	return lastModelVariant === "legacy" ? source.legacy : source.current;
+}
+function resolveConfiguredModelSource(config, modelFile, pipeline, modelsBasePath) {
+	const current = config.modelUrls?.[modelFile];
+	if (current === void 0) {
+		if (config.selfHosted) throw missingWasmModelError(modelFile, pipeline);
+		if (!modelsBasePath) throw new Error("[Incode SDK] modelsBasePath is required when wasmPath is a byte source.");
+		return buildModelVariantSources(modelsBasePath, modelFile);
+	}
+	const legacy = config.legacyModelUrls?.[modelFile];
+	return legacy === void 0 ? current : {
+		current,
+		legacy
+	};
+}
+/**
+* Warns once per warmup that an optional model listed in
+* {@link WASM_PIPELINE_OPTIONAL_MODEL_NAMES} was not supplied, so the Core
+* profile that needs it is skipped instead of failing the whole warmup.
+*/
+function warnMissingOptionalModel(pipeline, models) {
+	console.warn(`[Incode SDK] The "${pipeline}" self-hosted WASM configuration omits ${models.join(", ")}. The protected ID face-quality workflow stays unavailable; ID capture is unaffected.`);
+}
+/**
+* Builds the pipelines map with model paths for WASM initialization.
+* @param pipelines - Array of pipeline types to initialize
+* @param config - Module and model resolution configuration
+*/
+function buildPipelinesMap(pipelines, config) {
+	const pipelinesMap = /* @__PURE__ */ new Map();
+	const modelsBasePath = config.modelsBasePath ?? (typeof config.wasmPath === "string" ? deriveModelsBasePath(config.wasmPath) : void 0);
+	for (const pipeline of pipelines) {
+		const wasmType = mapPipelineToWasmType(pipeline);
+		if (!pipelinesMap.has(wasmType)) {
+			const modelPaths = (config.pipelineModels?.[pipeline] ?? WASM_PIPELINE_MODELS[pipeline]).map((modelFile) => resolveConfiguredModelSource(config, modelFile, pipeline, modelsBasePath));
+			pipelinesMap.set(wasmType, modelPaths);
+			if (pipeline === "idCapture") {
+				const resolveIdModels = (modelFiles) => modelFiles.map((modelFile) => resolveConfiguredModelSource(config, modelFile, pipeline, modelsBasePath));
+				pipelinesMap.set(6, resolveIdModels([WASM_MODEL_FILES.idCapture]));
+				pipelinesMap.set(7, resolveIdModels([WASM_MODEL_FILES.idCapture]));
+				const missingOptional = WASM_PIPELINE_OPTIONAL_MODEL_NAMES[pipeline].filter((name) => config.selfHosted === true && config.modelUrls?.[WASM_MODEL_FILES[name]] === void 0);
+				if (missingOptional.length === 0) pipelinesMap.set(8, resolveIdModels([
+					WASM_MODEL_FILES.idCapture,
+					WASM_MODEL_FILES.idFiqa,
+					WASM_MODEL_FILES.idFaceDetector
+				]));
+				else warnMissingOptionalModel(pipeline, missingOptional);
+			}
+		}
+	}
+	return pipelinesMap;
+}
+/**
+* Preloads WASM binary and ML models at app startup.
+* Runs asynchronously - app can continue while WASM loads in background.
+*
+* Model files are automatically loaded based on the pipeline type.
+* By default, models are expected in a 'models' subdirectory relative to the WASM binary.
+*
+* @param config - Configuration for WASM warmup
+* @returns Promise that resolves when WASM is ready
+*
+* @example
+* ```ts
+* // Basic usage - models loaded from /wasm/v2/models/
+* warmupWasm({
+*   wasmPath: '/wasm/v2/ml-wasm.wasm',
+*   glueCodePath: '/wasm/v2/ml-wasm.js',
+*   pipelines: ['selfie', 'idCapture'],
+* });
+*
+* // With explicit models path
+* warmupWasm({
+*   wasmPath: '/wasm/v2/ml-wasm.wasm',
+*   glueCodePath: '/wasm/v2/ml-wasm.js',
+*   modelsBasePath: 'https://cdn.example.com/wasm/v2/models',
+*   pipelines: ['selfie'],
+* });
+* ```
+*/
+async function warmupWasm(config) {
+	const pipelines = config.pipelines ?? [...WASM_PIPELINES];
+	if (state === "loading" && loadingPromise) {
+		if (lastConfig && pipelines.every((p) => loadedPipelines.includes(p))) return;
+		const inFlight = loadingPromise;
+		if (pipelines.filter((p) => !pipelinesInFlight.includes(p)).length === 0) return inFlight;
+		return inFlight.then(() => warmupWasm(config));
+	}
+	if (state === "ready") {
+		const missingPipelines = pipelines.filter((p) => !loadedPipelines.includes(p));
+		if (missingPipelines.length === 0) return;
+		if (!lastConfig) throw new Error("Cannot add pipelines: original warmup config not available");
+		if (lastConfig.wasmPath !== config.wasmPath || lastConfig.glueCodePath !== config.glueCodePath || (lastConfig.wasmSimdPath ?? lastConfig.wasmPath) !== (config.wasmSimdPath ?? config.wasmPath) || (lastConfig.glueCodeSimdPath ?? "") !== (config.glueCodeSimdPath ?? "") || lastConfig.loadGlue !== config.loadGlue || lastConfig.loadGlueSimd !== config.loadGlueSimd || (lastConfig.useSimd ?? true) !== (config.useSimd ?? true)) throw new Error("Cannot add pipelines: WASM config mismatch. Use same wasmPath, glueCodePath, and useSimd settings.");
+		const combinedPipelines = [.../* @__PURE__ */ new Set([...loadedPipelines, ...pipelines])];
+		state = "loading";
+		pipelinesInFlight = combinedPipelines;
+		wasmError = null;
+		loadingPromise = (async () => {
+			try {
+				const pipelinesMap = buildPipelinesMap(missingPipelines, lastConfig);
+				await wasmRuntime.loadModels(pipelinesMap);
+				await wasmRuntime.initializePipelines();
+				state = "ready";
+				loadedPipelines = combinedPipelines;
+				lastConfig = {
+					...lastConfig,
+					pipelines: combinedPipelines
+				};
+				loadingPromise = null;
+			} catch (error) {
+				state = "ready";
+				wasmError = error instanceof Error ? error : new Error(String(error));
+				loadingPromise = null;
+				pipelinesInFlight = [];
+				throw wasmError;
+			}
+		})();
+		return loadingPromise;
+	}
+	state = "loading";
+	pipelinesInFlight = [...pipelines];
+	wasmError = null;
+	loadingPromise = (async () => {
+		try {
+			const pipelinesMap = buildPipelinesMap(pipelines, config);
+			if (config.onDeviceMode !== void 0) wasmRuntime.setOnDeviceMode(config.onDeviceMode);
+			const simdUsed = await wasmRuntime.initialize({
+				module: config,
+				pipelines: pipelinesMap
+			});
+			await wasmRuntime.loadModels();
+			await wasmRuntime.initializePipelines();
+			state = "ready";
+			lastModelVariant = simdUsed ? "current" : "legacy";
+			loadedPipelines = [...pipelines];
+			lastConfig = {
+				...config,
+				pipelines
+			};
+			loadingPromise = null;
+		} catch (error) {
+			state = "error";
+			lastModelVariant = null;
+			wasmError = error instanceof Error ? error : new Error(String(error));
+			loadingPromise = null;
+			pipelinesInFlight = [];
+			throw wasmError;
+		}
+	})();
+	return loadingPromise;
+}
+/**
+* Returns the current warmup status.
+* Useful for showing loading indicators.
+*
+* @returns Current warmup status
+*/
+function getWasmStatus() {
+	return {
+		isReady: state === "ready",
+		isLoading: state === "loading",
+		error: wasmError ?? void 0,
+		loadedPipelines: [...loadedPipelines]
+	};
+}
+/**
+* Returns true if WASM is fully initialized and ready.
+*
+* @returns True if WASM is ready
+*/
+function isWasmReady() {
+	return state === "ready";
+}
+/**
+* Returns a promise that resolves when WASM is ready.
+* - If ready: resolves immediately
+* - If loading: waits for completion, then resolves
+* - If not started: rejects with error
+*
+* @returns Promise that resolves when WASM is ready
+* @throws Error if WASM is in error state or was never started
+*/
+function waitForWasm() {
+	if (state === "ready") return Promise.resolve();
+	if (state === "loading" && loadingPromise) return loadingPromise;
+	if (state === "error") return Promise.reject(wasmError ?? /* @__PURE__ */ new Error("WASM initialization failed"));
+	return Promise.reject(/* @__PURE__ */ new Error("WASM warmup was not started. Call warmupWasm() first."));
+}
+/**
+* Retained compatibility surface for callers that used the removed native
+* on-device-mode setter. Both values are native-free no-ops for the pinned
+* runtime and do not alter initialization, capture, or fingerprint lifecycle.
+*/
+function setWasmOnDeviceMode(enabled) {
+	wasmRuntime.setOnDeviceMode(enabled);
+}
+//#endregion
+export { waitForWasm as a, CAMERA_CYCLE_OWNERSHIP_DOMAIN as c, setWasmOnDeviceMode as i, getCameraCycleOwnershipDomain as l, getWasmStatus as n, warmupWasm as o, isWasmReady as r, wasmRuntime as s, getResolvedModelSource as t };