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

package/dist/safeStorage-B-trhxg6.esm.js

@@ -0,0 +1,423 @@
+import { c as wasmCallWrapper, s as ML_CALL_MAX_POLLS } from "./wasmWebClient-B7baE-Wf.esm.js";
+import { a as waitForWasm, n as getWasmStatus, o as warmupWasm, r as isWasmReady, s as wasmRuntime } from "./warmup-CUUnwYxe.esm.js";
+//#region ../infra/src/wasm/utilityWasmApi.ts
+/**
+* Utility / metadata domain facade over {@link WasmRuntime}.
+*
+* Holds no WASM state — the runtime owns every handle and buffer. The one
+* qualification: it owns exactly two JS-side flags that the C++ side does not
+* persist and that must be replayed into it at call time —
+*
+* - `dsEnabled_` (deepsight) is passed as an argument on every
+*   `prc`/`poc`/`rsp`/`ssl` call;
+* - `inspectorOpened_` is pushed into C++ inside {@link getMetadata}, right
+*   before reading the metadata, because `setInspectorOpened` may legitimately be
+*   called before WASM is initialized.
+*
+* Both are deliberately **unguarded** setters: they never throw, so the SDK can
+* record them during setup and have them honored once WASM comes up.
+*
+* `prc`/`poc`/`rsp` are the only methods here that hold the ML semaphore.
+* `ssl`/`stl`/`osv`/`oev`/`ckvcks` and everything else are unlocked **by design**
+* (decision D6) — never add locking.
+*
+* Method names, argument order and the pre-initialization error strings are
+* copied verbatim from the mirrored upstream `wasmApi.ts` so a WASM version bump
+* stays a diff against upstream (`docs/processes/WASM_VERSION_MIGRATION.md`).
+* `setSdkPlatform`'s message says "device type" on purpose — do not "fix" it.
+*/
+var UtilityWasmApi = class {
+	constructor(runtime = wasmRuntime) {
+		this.runtime = runtime;
+		this.inspectorOpened_ = false;
+		this.dsEnabled_ = false;
+	}
+	ens(image) {
+		return this.runtime.requireUtilityApi("Unable to encrypt the image, cpp API hasn't been initialized").ens(image);
+	}
+	/**
+	* @deprecated Native label inspection has been unavailable since
+	* v2.14.49-post1; scheduled for removal in 3.0.0. Protected PRC/POC owns
+	* the authoritative decision: use `prc()` followed by `poc()` instead.
+	*/
+	isVirtualCamera(_label) {
+		return false;
+	}
+	estimatePerformance() {
+		return this.runtime.requireUtilityApi("Unable to estimate performance, cpp API hasn't been initialized").estimatePerformance();
+	}
+	async analyzeFrame(image) {
+		const message = "Unable to analyze the frame, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await this.runtime.allocateImageBuffers(image.width, image.height);
+		this.runtime.writeFrame(image);
+		this.runtime.requireUtilityApi(message).analyzeFrame();
+	}
+	/**
+	* Sets the native (C++) utility API's production mode. When `true`, the WASM
+	* module suppresses its verbose debug logging; when `false`, it emits it.
+	*
+	* @param productionMode - `true` to silence WASM logs, `false` to emit them.
+	* @throws If the WASM C++ API has not been initialized yet.
+	*/
+	async setProductionMode(productionMode) {
+		this.runtime.requireUtilityApi("Unable to set production mode, cpp API hasn't been initialized").setProductionMode(productionMode);
+	}
+	setSdkVersion(sdkVersion) {
+		this.runtime.requireUtilityApi("Unable to set sdk version, cpp API hasn't been initialized").setSdkVersion(sdkVersion);
+	}
+	setSdkPlatform(sdkPlatform) {
+		this.runtime.requireUtilityApi("Unable to set device type, cpp API hasn't been initialized").setSdkPlatform(sdkPlatform);
+	}
+	setDeviceInfo(deviceInfo, overrideExisting = true) {
+		this.runtime.requireUtilityApi("Unable to set device info, cpp API hasn't been initialized").setDeviceInfo(deviceInfo, overrideExisting);
+	}
+	setBrowserInfo(browserInfo, overrideExisting = true) {
+		this.runtime.requireUtilityApi("Unable to set browser info, cpp API hasn't been initialized").setBrowserInfo(browserInfo, overrideExisting);
+	}
+	setCameraInfo(cameraInfo, overrideExisting = true) {
+		this.runtime.requireUtilityApi("Unable to set camera info, cpp API hasn't been initialized").setCameraInfo(cameraInfo, overrideExisting);
+	}
+	setZc(zc) {
+		this.runtime.requireUtilityApi("Unable to set zc, cpp API hasn't been initialized").setZc(zc);
+	}
+	setMotionStatus(motionStatus) {
+		this.runtime.requireUtilityApi("Unable to set motion status, cpp API hasn't been initialized").setMotionStatus(motionStatus);
+	}
+	setInspectorOpened(inspectorOpened) {
+		this.inspectorOpened_ = inspectorOpened;
+	}
+	getInspectorOpened() {
+		return this.inspectorOpened_;
+	}
+	setBackgroundMode(backgroundMode) {
+		this.runtime.requireUtilityApi("Unable to set background mode, cpp API hasn't been initialized").setBackgroundMode(backgroundMode);
+	}
+	setDsEnabled(enabled) {
+		this.dsEnabled_ = enabled;
+	}
+	getCheck() {
+		return this.runtime.requireUtilityApi("Unable to get check, cpp API hasn't been initialized").getCheck();
+	}
+	getMetadata() {
+		const utilityApi = this.runtime.requireUtilityApi("Unable to get metadata, cpp API hasn't been initialized");
+		utilityApi.setInspectorOpened(this.inspectorOpened_);
+		return utilityApi.getMetadata();
+	}
+	async prc() {
+		const message = "Unable to prc, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await wasmCallWrapper(this.runtime.mlCallSemaphore, () => this.runtime.requireUtilityApi(message).prc(this.dsEnabled_, false), true, {
+			maxPolls: ML_CALL_MAX_POLLS,
+			label: "prc"
+		});
+	}
+	async poc(output) {
+		const message = "Unable to poc, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await wasmCallWrapper(this.runtime.mlCallSemaphore, () => this.runtime.requireUtilityApi(message).poc(this.dsEnabled_, output), true, {
+			maxPolls: ML_CALL_MAX_POLLS,
+			label: "poc"
+		});
+	}
+	async rsp() {
+		const message = "Unable to rsp, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await wasmCallWrapper(this.runtime.mlCallSemaphore, () => this.runtime.requireUtilityApi(message).rsp(this.dsEnabled_), true, {
+			maxPolls: ML_CALL_MAX_POLLS,
+			label: "rsp"
+		});
+	}
+	ssl() {
+		this.runtime.requireUtilityApi("Unable to ssl, cpp API hasn't been initialized").ssl(this.dsEnabled_);
+	}
+	stl() {
+		this.runtime.requireUtilityApi("Unable to stl, cpp API hasn't been initialized").stl();
+	}
+	osv() {
+		this.runtime.requireUtilityApi("Unable to set sensor beginning timestamp, cpp API hasn't been initialized").osv();
+	}
+	oev() {
+		this.runtime.requireUtilityApi("Unable to set sensor ending timestamp, cpp API hasn't been initialized").oev();
+	}
+	ckvcks(data) {
+		this.runtime.requireUtilityApi("Unable to ckvcks, cpp API hasn't been initialized").ckvcks(data);
+	}
+	/**
+	* Clear all states, not related to ml pipelines
+	*/
+	resetOther() {
+		this.runtime.requireUtilityApi("Unable to reset other states, cpp API hasn't been initialized").resetOther();
+	}
+	/**
+	* Full reset. Pipelines first, then the non-pipeline state — the order the
+	* mirrored upstream wrapper uses.
+	*/
+	reset() {
+		this.runtime.resetAllPipelines();
+		this.resetOther();
+	}
+};
+const utilityWasmApi = new UtilityWasmApi();
+//#endregion
+//#region ../infra/src/providers/wasm/BaseWasmProvider.ts
+/**
+* Base provider class that abstracts common WASM functionality.
+* This serves as a foundation for specific ML capability providers
+* like FaceDetectionProvider and IdCaptureProvider.
+*/
+var BaseWasmProvider = class {
+	/**
+	* Creates a new BaseWasmProvider
+	* @param pipelineType - The WASM pipeline type this provider uses
+	*/
+	constructor(pipelineType) {
+		this._isInitialized = false;
+		this.pipelineType = pipelineType;
+	}
+	/**
+	* Returns whether this provider has been initialized.
+	*/
+	get initialized() {
+		return this._isInitialized;
+	}
+	getPipelineType() {
+		if (this.pipelineType === void 0) throw new Error(`${this.constructor.name} has no pipeline type configured.`);
+		return this.pipelineType;
+	}
+	/**
+	* Initializes the provider by ensuring WASM is loaded
+	* @param config - Provider configuration
+	* @param pipeline - The pipeline type to warm up ('selfie', 'idCapture', etc.)
+	*/
+	async initializeBase(config, pipeline) {
+		if (this._isInitialized) return;
+		const status = getWasmStatus();
+		if (status.isLoading || isWasmReady() || status.error) {
+			if (!(status.isLoading && status.loadedPipelines.includes(pipeline))) await waitForWasm();
+			if (this.pipelineType !== void 0 && !getWasmStatus().loadedPipelines.includes(pipeline)) throw new Error(`WASM pipeline "${pipeline}" is not loaded.`);
+		} else {
+			if (!config.wasmPath || !config.glueCodePath && !config.loadGlue) throw new Error("WASM path and glue code path are required. Call warmupWasm() first.");
+			await warmupWasm({
+				...config,
+				wasmPath: config.wasmPath,
+				glueCodePath: config.glueCodePath ?? "",
+				pipelines: [pipeline]
+			});
+		}
+		this._isInitialized = true;
+	}
+	/**
+	* Ensures the provider is initialized before performing operations.
+	* @throws Error if not initialized
+	*/
+	ensureInitialized() {
+		if (!this._isInitialized) throw new Error(`${this.constructor.name} not initialized. Call initialize() first.`);
+	}
+	/**
+	* Processes a frame through the WASM pipeline
+	* @param image - Image data to process
+	* @returns The pipeline result (type depends on pipeline - WASM returns any)
+	*/
+	async processFrameWasm(image) {
+		this.ensureInitialized();
+		const pipelineType = this.getPipelineType();
+		await wasmRuntime.allocateImageBuffers(image.width, image.height);
+		await wasmRuntime.handleDetectionCallAndUpdateState(pipelineType);
+		return await wasmRuntime.process(pipelineType, image);
+	}
+	/**
+	* Resets the pipeline to its initial state.
+	* Safe to call even if not initialized (no-op in that case).
+	*/
+	reset() {
+		if (this._isInitialized && this.pipelineType !== void 0) wasmRuntime.resetPipeline(this.pipelineType);
+	}
+	/**
+	* Disposes of resources and resets initialization state.
+	* Safe to call even if not initialized.
+	*/
+	async dispose() {
+		this.reset();
+		this._isInitialized = false;
+	}
+};
+//#endregion
+//#region ../infra/src/providers/wasm/WasmUtilProvider.ts
+var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
+	static async getInstance() {
+		if (WasmUtilProvider.instance) return WasmUtilProvider.instance;
+		if (WasmUtilProvider.initPromise) return WasmUtilProvider.initPromise;
+		WasmUtilProvider.initPromise = (async () => {
+			const instance = new WasmUtilProvider();
+			await instance.initializeBase({}, "selfie");
+			WasmUtilProvider.instance = instance;
+			return instance;
+		})();
+		return WasmUtilProvider.initPromise;
+	}
+	static resetInstance() {
+		WasmUtilProvider.instance = void 0;
+		WasmUtilProvider.initPromise = void 0;
+	}
+	constructor() {
+		super(void 0);
+	}
+	async initialize(config) {
+		if (this.initialized) return;
+		const pipeline = config.pipelines?.[0] ?? "selfie";
+		await this.initializeBase(config, pipeline);
+	}
+	async processFrame(_image) {
+		throw new Error("WasmUtilProvider does not support frame processing. Use encryptImage() instead.");
+	}
+	encryptImage(image) {
+		this.ensureInitialized();
+		return utilityWasmApi.ens(image);
+	}
+	setSdkVersion(version) {
+		this.ensureInitialized();
+		utilityWasmApi.setSdkVersion(version);
+	}
+	setSdkPlatform(platform) {
+		this.ensureInitialized();
+		utilityWasmApi.setSdkPlatform(platform);
+	}
+	setDeviceInfo(deviceInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		utilityWasmApi.setDeviceInfo(deviceInfo, overrideExisting);
+	}
+	setBrowserInfo(browserInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		utilityWasmApi.setBrowserInfo(browserInfo, overrideExisting);
+	}
+	setCameraInfo(cameraInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		utilityWasmApi.setCameraInfo(cameraInfo, overrideExisting);
+	}
+	setMotionStatus(status) {
+		this.ensureInitialized();
+		utilityWasmApi.setMotionStatus(status);
+	}
+	setBackgroundMode(backgroundMode) {
+		this.ensureInitialized();
+		utilityWasmApi.setBackgroundMode(backgroundMode);
+	}
+	setOnDeviceMode(enabled) {
+		wasmRuntime.setOnDeviceMode(enabled);
+	}
+	setZc(zc) {
+		this.ensureInitialized();
+		utilityWasmApi.setZc(zc);
+	}
+	setInspectorOpened(opened) {
+		this.ensureInitialized();
+		utilityWasmApi.setInspectorOpened(opened);
+	}
+	getInspectorOpened() {
+		return utilityWasmApi.getInspectorOpened();
+	}
+	/**
+	* Toggles the WASM module's production mode. When `true`, the native module
+	* suppresses its verbose debug logging/console output; when `false`, those
+	* logs are emitted. The SDK forces this to `true` by default and only flips
+	* it off when the caller opts in via `setup({ wasm: { showLogs: true } })`.
+	*
+	* @param productionMode - `true` to silence WASM logs, `false` to emit them.
+	*/
+	async setProductionMode(productionMode) {
+		this.ensureInitialized();
+		await utilityWasmApi.setProductionMode(productionMode);
+	}
+	getMetadata() {
+		this.ensureInitialized();
+		return utilityWasmApi.getMetadata();
+	}
+	async analyzeFrame(image) {
+		this.ensureInitialized();
+		await utilityWasmApi.analyzeFrame(image);
+	}
+	getCheck() {
+		this.ensureInitialized();
+		return utilityWasmApi.getCheck();
+	}
+	getPipelineState() {
+		this.ensureInitialized();
+		return wasmRuntime.getPipelineState();
+	}
+	estimatePerformance() {
+		this.ensureInitialized();
+		return utilityWasmApi.estimatePerformance();
+	}
+	isVirtualCamera(label) {
+		return utilityWasmApi.isVirtualCamera(label);
+	}
+	async prc() {
+		this.ensureInitialized();
+		await utilityWasmApi.prc();
+	}
+	async poc(output) {
+		this.ensureInitialized();
+		await utilityWasmApi.poc(output);
+	}
+	async rsp() {
+		this.ensureInitialized();
+		await utilityWasmApi.rsp();
+	}
+	ssl() {
+		this.ensureInitialized();
+		utilityWasmApi.ssl();
+	}
+	stl() {
+		this.ensureInitialized();
+		utilityWasmApi.stl();
+	}
+	osv() {
+		this.ensureInitialized();
+		utilityWasmApi.osv();
+	}
+	oev() {
+		this.ensureInitialized();
+		utilityWasmApi.oev();
+	}
+	ckvcks(data) {
+		this.ensureInitialized();
+		utilityWasmApi.ckvcks(data);
+	}
+};
+//#endregion
+//#region ../infra/src/storage/safeStorage.ts
+/**
+* Storage resolvers that tolerate hosts which make Web Storage unreachable.
+*
+* Two hostile shapes occur in the field, and they fail differently:
+*
+* 1. **Deleted bare global** — a page mitigates self-XSS with
+*    `delete window.localStorage` and keeps a module-private reference. Since
+*    `window` *is* the global object, the identifier stops resolving: a bare
+*    read throws `ReferenceError`. `typeof` is the only safe probe, because it
+*    is the one operator that tolerates an unresolvable identifier.
+* 2. **Blocked storage** — a webview or a cross-origin/partitioned context
+*    makes the accessor itself throw (`SecurityError`). Here `typeof` is *not*
+*    enough: it invokes the getter, so the throw escapes the guard.
+*
+* Handling only one shape leaves the other live, so always go through these
+* resolvers instead of touching the globals directly. A `null` return means
+* "no storage in this host" — callers degrade, they do not throw.
+*/
+function resolveLocalStorage() {
+	try {
+		return typeof localStorage === "undefined" ? null : localStorage;
+	} catch {
+		return null;
+	}
+}
+function resolveSessionStorage() {
+	try {
+		return typeof sessionStorage === "undefined" ? null : sessionStorage;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { utilityWasmApi as a, BaseWasmProvider as i, resolveSessionStorage as n, WasmUtilProvider as r, resolveLocalStorage as t };

package/dist/{sdkVersion-BWOdgLZ1.esm.js → sdkVersion-CLxKvdyz.esm.js}

@@ -1,4 +1,4 @@
 //#region src/internal/version/sdkVersion.ts
-const SDK_VERSION = "2.2.0-rc.8";
+const SDK_VERSION = "2.3.0-rc.0+656e675";
 //#endregion
 export { SDK_VERSION as t };

package/dist/selfie.d.ts

@@ -1,10 +1,10 @@
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
-import { a as SelfieCaptureOnlyMachine, c as SelfieActor, g as SelfieConfig, h as SelfieCaptureOnlyConfig, i as SelfieCaptureOnlyActor, l as SelfieMachine, n as FaceCaptureManagerState, o as selfieCaptureOnlyMachine, r as CreateSelfieCaptureOnlyActorOptions, t as FaceCaptureManager, u as selfieMachine } from "./faceCaptureManagerFactory-BxWPpxyd.js";
-import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { a as FaceCapturedImageData, i as FaceCaptureOnlyResponse, n as DetectionStatus, o as FaceErrorCode } from "./types-Hmd7U0JA.js";
+import { _ as SelfieCaptureOnlyConfig, a as SelfieCaptureOnlyMachine, c as SelfieActor, g as processFace, h as ProcessFaceResponse, i as SelfieCaptureOnlyActor, l as SelfieMachine, n as FaceCaptureManagerState, o as selfieCaptureOnlyMachine, r as CreateSelfieCaptureOnlyActorOptions, t as FaceCaptureManager, u as selfieMachine, v as SelfieConfig } from "./faceCaptureManagerFactory-CvtqcLxs.js";
 import { n as PermissionStatus, t as PermissionResult } from "./types-BEwVKkLJ.js";
-import { t as DeepsightService } from "./deepsightService-DLVQS_RH.js";
-import { a as ProcessFaceResponse, i as createSelfieManagerFromActor, n as SelfieState, o as processFace, r as createSelfieManager, t as SelfieManager } from "./selfieManager-DwlCppg0.js";
+import { a as FaceCapturedImageData, i as FaceCaptureOnlyResponse, n as DetectionStatus, o as FaceErrorCode } from "./types-CM-jtjJ2.js";
+import { n as DeepsightService } from "./StreamCanvasCapture-B3YT2Bt6.js";
+import { t as CameraStream } from "./camera-9wWD-pwg.js";
+import { i as createSelfieManagerFromActor, n as SelfieState, r as createSelfieManager, t as SelfieManager } from "./selfieManager-D1KRJ39M.js";
 //#region src/modules/selfie/selfieCaptureOnlyManager.d.ts
 type SelfieCaptureOnlyState = FaceCaptureManagerState;
 type SelfieCaptureOnlyManager = FaceCaptureManager;

package/dist/selfie.esm.js

@@ -1,53 +1,15 @@
-import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
-import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
-import { n as eventModuleNames } from "./events-DYiyoSlx.esm.js";
-import { i as assign, s as createActor } from "./xstate.esm-BuFLFuzz.esm.js";
+import { l as BrowserStorageProvider } from "./setup-msLybMbC.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
+import { n as eventModuleNames } from "./events-ijlbX_Wx.esm.js";
+import { s as createActor } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { t as faceCaptureMachine } from "./faceCaptureSetup-BECAis8R.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-Bkueb8mk.esm.js";
-import { r as processFace } from "./selfieErrorUtils-C2PYBVsp.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-CPXEC4wV.esm.js";
-import { n as createSelfieManagerFromActor, t as createSelfieManager } from "./selfieManager-BlImAV-k.esm.js";
-import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-GpvMuz9o.esm.js";
-//#region src/modules/selfie/selfieCaptureOnlyStateMachine.ts
-/**
-* Performs local finalization of a captured face frame: stops local video
-* recording (if any), runs deepsight metadata extraction, and assembles the
-* rich payload delivered to the integrator's `onCapture` callback.
-*/
-async function finalizeFaceCaptureOnly(ctx, signal) {
-	const canvas = ctx.capturedImage;
-	if (!canvas) throw new Error("selfieCaptureOnly: no captured image");
-	let videoBase64;
-	try {
-		videoBase64 = (await ctx.recordingService?.stopAndGetVideo())?.videoBase64;
-	} catch {
-		videoBase64 = void 0;
-	}
-	if (signal.aborted) throw new DOMException("Aborted", "AbortError");
-	let metadata = "";
-	try {
-		if (ctx.deepsightService) {
-			const imageData = canvas.getImageData();
-			if (imageData) await ctx.deepsightService.analyzeFrame(imageData);
-			if (signal.aborted) throw new DOMException("Aborted", "AbortError");
-			metadata = ctx.deepsightService.getMetadata();
-		}
-	} catch (error) {
-		if (error?.name === "AbortError") throw error;
-		metadata = "";
-	}
-	const imageBase64 = canvas.getBase64Image() ?? "";
-	const blobData = canvas.getBlobData();
-	if (!blobData) throw new Error("selfieCaptureOnly: failed to build image blob");
-	return {
-		imageBase64,
-		blob: blobData.blob,
-		url: blobData.url,
-		metadata,
-		videoBase64
-	};
-}
+import { n as createDefaultProtectedFaceControllerActor, t as faceCaptureMachine } from "./faceCaptureSetup-BSextack.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-pCmG4MeF.esm.js";
+import { s as PROTECTED_CAPTURE_TARGET } from "./createCameraCycleOwnership-DQ5-F2oW.esm.js";
+import { r as processFace } from "./selfieErrorUtils-C77GXJH6.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-fwMmNtOi.esm.js";
+import { n as createSelfieManagerFromActor, t as createSelfieManager } from "./selfieManager-CihVnODO.esm.js";
+import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-BjzPjJ_p.esm.js";
 /**
 * Selfie state machine variant for the captureOnly flow. Shares the full base
 * face-capture state tree; only the upload/process step is local instead of
@@ -55,37 +17,13 @@ async function finalizeFaceCaptureOnly(ctx, signal) {
 */
 const selfieCaptureOnlyMachine = faceCaptureMachine.provide({
 	actors: {
-		/**
-		* Pre-upload encryption + virtual-camera check are skipped: captureOnly is
-		* offline (no backend calls) and hands the canvas to the integrator
-		* unencrypted. The downstream `encryptedBase64Image`/`recordingId` fields
-		* are inert because `uploadFace` no longer reads them.
-		*/
-		prepareFaceUpload: fromPromise(async () => ({
-			encryptedBase64Image: "",
-			recordingId: null
-		})),
-		/**
-		* "Upload" becomes local finalize. The rich payload is routed to the
-		* typed `captureOnlyResult` context slot by the body-overridden
-		* `setUploadResponseFromEvent` action below, rather than the loose
-		* `uploadResponse: Record<string, unknown>` channel the base flow uses.
-		*/
-		uploadFace: fromPromise(async ({ input, signal }) => {
-			return await finalizeFaceCaptureOnly(input, signal);
+		protectedFaceController: createDefaultProtectedFaceControllerActor({
+			target: PROTECTED_CAPTURE_TARGET.selfie,
+			delivery: "local"
 		}),
 		/** No backend processing in captureOnly. */
 		processFace: fromPromise(async () => ({}))
 	},
-	actions: { 
-	/**
-	* Override the regular upload-response handler to populate the typed
-	* `captureOnlyResult` slot the captureOnly manager reads on `finished`.
-	* The regular `uploadResponse` channel is left undefined — the variant's
-	* guards (`hasUploadValidationError`, `isTerminalUploadError`) both
-	* return false, so nothing downstream needs it.
-	*/
-setUploadResponseFromEvent: assign({ captureOnlyResult: ({ event }) => event.output }) },
 	guards: {
 		hasUploadValidationError: () => false,
 		isTerminalUploadError: () => false

package/dist/{selfieErrorUtils-C2PYBVsp.esm.js → selfieErrorUtils-C77GXJH6.esm.js}

@@ -1,8 +1,8 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-9y-kbVDw.esm.js";
+import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
+import { t as addDeviceStats } from "./stats-DkK-f8JT.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-5NYZg9s6.esm.js";
 //#region src/modules/selfie/selfieUploadService.ts
 /**
 * Uploads a selfie image to the backend.
@@ -36,6 +36,32 @@ async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal, met
 	}
 }
 /**
+* Uploads a selfie the user picked from device storage. Same endpoint and
+* encryption as {@link uploadSelfie}, plus `captureType=UPLOAD`; there is no
+* camera, so no face coordinates, deepsight metadata or recording id.
+*/
+async function uploadManualSelfie({ base64Image, dependencies, imageType = "selfie", signal }) {
+	try {
+		const payload = {
+			base64Image: (await dependencies.getWasmUtil()).encryptImage(base64Image),
+			encrypted: true,
+			clientInfo: { deviceClass: getDeviceClass() }
+		};
+		const res = await api.post(endpoints.selfie, payload, {
+			signal,
+			query: {
+				imageType,
+				captureType: "UPLOAD"
+			}
+		});
+		if (!res.ok) throw new Error(`POST ${endpoints.selfie} failed: ${res.status} ${res.statusText}`);
+		return res.data;
+	} catch (error) {
+		const errorCode = getFaceErrorCodeFromHttpError(error);
+		throw withTransportStatus(new Error(errorCode ?? FACE_ERROR_CODES.SERVER), error);
+	}
+}
+/**
 * Copies the HTTP status of `source` onto `target`. The code alone cannot say
 * whether the request got a verdict or never reached the backend — a network
 * failure and a 5xx both map to `SERVER_ERROR` — so a caller that retries
@@ -87,4 +113,4 @@ const validateUploadResponse = ({ config, response }) => {
 	if (config.validateHeadCover && response.hasHeadCover) return FACE_ERROR_CODES.HEAD_COVER;
 };
 //#endregion
-export { uploadSelfie as i, validateUploadResponse as n, processFace as r, getFaceErrorCodeFromUnknown as t };
+export { uploadSelfie as a, uploadManualSelfie as i, validateUploadResponse as n, processFace as r, getFaceErrorCodeFromUnknown as t };

package/dist/{selfieManager-BlImAV-k.esm.js → selfieManager-CihVnODO.esm.js}

@@ -1,9 +1,9 @@
-import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
-import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
-import { n as eventModuleNames } from "./events-DYiyoSlx.esm.js";
+import { l as BrowserStorageProvider } from "./setup-msLybMbC.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
+import { n as eventModuleNames } from "./events-ijlbX_Wx.esm.js";
 import { s as createActor } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-Bkueb8mk.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-CPXEC4wV.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-pCmG4MeF.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-fwMmNtOi.esm.js";
 //#region src/modules/selfie/selfieActor.ts
 function createSelfieActor(options) {
 	const dependencies = options.dependencies ?? {

package/dist/{selfieManager-DwlCppg0.d.ts → selfieManager-D1KRJ39M.d.ts}

@@ -1,15 +1,6 @@
 import { t as Manager } from "./Manager-CQQ99QOI.js";
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
-import { c as SelfieActor, n as FaceCaptureManagerState, s as CreateSelfieActorOptions, t as FaceCaptureManager } from "./faceCaptureManagerFactory-BxWPpxyd.js";
-//#region src/modules/selfie/selfieUploadService.d.ts
-type ProcessFaceImageType = 'selfie' | 'videoSelfie';
-type ProcessFaceResponse = {
-  faceMatch: boolean;
-  confidence: number;
-  existingUser: boolean;
-};
-declare function processFace(imageType?: ProcessFaceImageType, signal?: AbortSignal): Promise<ProcessFaceResponse>;
-//#endregion
+import { c as SelfieActor, n as FaceCaptureManagerState, s as CreateSelfieActorOptions, t as FaceCaptureManager } from "./faceCaptureManagerFactory-CvtqcLxs.js";
 //#region src/modules/selfie/selfieManager.d.ts
 type SelfieState = FaceCaptureManagerState;
 /**
@@ -31,6 +22,9 @@ declare function createSelfieManagerFromActor(actor: SelfieActor, visibilityObse
   reset(): void;
   retryCapture(): void;
   capture(): void;
+  goToManualUpload(): void;
+  manualUploadSelectFile(file: File): void;
+  manualUploadContinue(): void;
 };
 /**
  * Creates a selfie manager instance for handling selfie capture flow.
@@ -71,7 +65,10 @@ declare function createSelfieManager(options: CreateSelfieActorOptions): Manager
   reset(): void;
   retryCapture(): void;
   capture(): void;
+  goToManualUpload(): void;
+  manualUploadSelectFile(file: File): void;
+  manualUploadContinue(): void;
 };
 type SelfieManager = FaceCaptureManager;
 //#endregion
-export { ProcessFaceResponse as a, createSelfieManagerFromActor as i, SelfieState as n, processFace as o, createSelfieManager as r, SelfieManager as t };
+export { createSelfieManagerFromActor as i, SelfieState as n, createSelfieManager as r, SelfieManager as t };