@incodetech/core 0.0.0-dev-20260909-14ef44cf → 0.0.0-dev-20260911-3c28f170

package/dist/safeStorage-Dp9m6aOh.esm.js

@@ -0,0 +1,422 @@
+import { c as wasmCallWrapper, s as ML_CALL_MAX_POLLS } from "./wasmWebClient-BJCaFeBL.esm.js";
+import { a as waitForWasm, n as getWasmStatus, o as warmupWasm, r as isWasmReady, s as wasmRuntime } from "./warmup-BOM-sD-6.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);
+	}
+	isVirtualCamera(label) {
+		const utilityApi = this.runtime.requireUtilityApi("Unable to check if the camera is virtual, cpp API hasn't been initialized");
+		if (label) return utilityApi.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(image, pipelineType);
+	}
+	/**
+	* 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) {
+		this.ensureInitialized();
+		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) {
+		this.ensureInitialized();
+		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-Bc55H50S.esm.js → sdkVersion-DlL6SxXs.esm.js}

@@ -1,4 +1,4 @@
 //#region src/internal/version/sdkVersion.ts
-const SDK_VERSION = "0.0.0-dev-20260909-14ef44cf";
+const SDK_VERSION = "0.0.0-dev-20260911-3c28f170";
 //#endregion
 export { SDK_VERSION as t };

package/dist/selfie.esm.js

@@ -1,13 +1,13 @@
-import { l as BrowserStorageProvider } from "./setup-DLn1eHU9.esm.js";
-import { r as WasmUtilProvider } from "./safeStorage-0bZuUtSP.esm.js";
+import { l as BrowserStorageProvider } from "./setup-CQNSur1c.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-Dp9m6aOh.esm.js";
 import { n as eventModuleNames } from "./events-ijlbX_Wx.esm.js";
 import { i as assign, 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-JxQbmDt_.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-waLeHRj_.esm.js";
+import { t as faceCaptureMachine } from "./faceCaptureSetup-Bhpk__dy.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-BRuA7cbI.esm.js";
 import { r as processFace } from "./selfieErrorUtils-C6gC06J7.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-DJwDxPAT.esm.js";
-import { n as createSelfieManagerFromActor, t as createSelfieManager } from "./selfieManager-I_h3YE2X.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-B7vhKLV7.esm.js";
+import { n as createSelfieManagerFromActor, t as createSelfieManager } from "./selfieManager-C4esDm_H.esm.js";
 import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-BjzPjJ_p.esm.js";
 //#region src/modules/selfie/selfieCaptureOnlyStateMachine.ts
 /**

package/dist/{selfieManager-I_h3YE2X.esm.js → selfieManager-C4esDm_H.esm.js}

@@ -1,9 +1,9 @@
-import { l as BrowserStorageProvider } from "./setup-DLn1eHU9.esm.js";
-import { r as WasmUtilProvider } from "./safeStorage-0bZuUtSP.esm.js";
+import { l as BrowserStorageProvider } from "./setup-CQNSur1c.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-Dp9m6aOh.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-waLeHRj_.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-DJwDxPAT.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-BRuA7cbI.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-B7vhKLV7.esm.js";
 //#region src/modules/selfie/selfieActor.ts
 function createSelfieActor(options) {
 	const dependencies = options.dependencies ?? {

package/dist/{selfieStateMachine-DJwDxPAT.esm.js → selfieStateMachine-B7vhKLV7.esm.js}

@@ -1,7 +1,7 @@
 import { i as assign } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { n as manualFaceUploadMachine, t as faceCaptureMachine } from "./faceCaptureSetup-JxQbmDt_.esm.js";
-import { i as prepareOnDeviceFaceUpload, n as isOnDeviceMode, r as postOnDeviceFaceResults, t as defaultPrepareFaceUpload } from "./onDeviceFaceResults-BgIPrRr2.esm.js";
+import { n as manualFaceUploadMachine, t as faceCaptureMachine } from "./faceCaptureSetup-Bhpk__dy.esm.js";
+import { i as prepareOnDeviceFaceUpload, n as isOnDeviceMode, r as postOnDeviceFaceResults, t as defaultPrepareFaceUpload } from "./onDeviceFaceResults-CU5XlhqG.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
 import { a as uploadSelfie, i as uploadManualSelfie, n as validateUploadResponse, r as processFace } from "./selfieErrorUtils-C6gC06J7.esm.js";
 //#region src/modules/selfie/selfieStateMachine.ts

package/dist/{session-CoY3St8F.esm.js → session-DWnBmR2a.esm.js}

@@ -1,8 +1,8 @@
 import { n as getApi } from "./api-Bx3gKW_y.esm.js";
-import { h as noteSessionCreated, l as trueSightLog } from "./trueSightService-VUN8WK4N.esm.js";
-import "./sessionInitializer-BEjB0UVH.esm.js";
+import { h as noteSessionCreated, l as trueSightLog } from "./trueSightService-CvdDnFul.esm.js";
+import "./sessionInitializer-DUpE6yBR.esm.js";
 import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
-import { i as toIncodeApiError } from "./apiError-CE5YD5T0.esm.js";
+import { i as toIncodeApiError } from "./apiError-CY6lWIaQ.esm.js";
 //#region src/internal/session/sessionService.ts
 /**
 * HTTP status codes the QR validation endpoint emits, keyed by their semantic

package/dist/session.d.ts

@@ -188,6 +188,13 @@ type Features = {
 };
 //#endregion
 //#region src/internal/session/sessionInitializer.d.ts
+/**
+ * Resolves once the device-fingerprint step of the current session
+ * activation has settled (submitted, failed, or skipped) — with the backend's
+ * result when there is one. Resolves immediately when no activation is in
+ * flight. Pairs with `initializeSession({ awaitFingerprint: false })`.
+ */
+declare function whenSessionFingerprintSettled(): Promise<DeviceFingerprintResult | undefined>;
 type SessionInitOptions = {
   /**
    * Session token returned by `createSession`. Persisted on the HTTP client
@@ -205,6 +212,14 @@ type SessionInitOptions = {
   signal?: AbortSignal;
   /** Set to `true` to preload Flow configuration during session activation. */
   preloadFlow?: boolean;
+  /**
+   * `false` resolves as soon as the feature config is in, leaving the device
+   * fingerprint (thumbmark + IP lookup + submit) to finish in the background;
+   * `fingerprintSuccess`/`fingerprintResult` on the result are then not yet
+   * known — read them via `whenSessionFingerprintSettled()`. Default `true`
+   * keeps the historical contract: the promise settles after the fingerprint.
+   */
+  awaitFingerprint?: boolean;
 };
 type SessionInitResult = {
   features: Features;
@@ -243,4 +258,4 @@ type SessionInitResult = {
  */
 declare function initializeSession(options?: SessionInitOptions): Promise<SessionInitResult>;
 //#endregion
-export { type BootstrapSessionOptions, type CreateSessionOptions, type FinishStatus, type GetFinishStatusFn, IncodeApiError, QR_VALIDATION_ERROR_CODES, QrValidationError, type QrValidationErrorCode, type QrValidationResult, type RefreshQrUrlUuidOptions, type Session, type SessionInitOptions, type SessionInitResult, type ValidateQrUuidOptions, bootstrapSession, createSession, getFinishStatus, initializeSession, refreshQrUrlUuid, validateQrUuid };
+export { type BootstrapSessionOptions, type CreateSessionOptions, type DeviceFingerprintResult, type FinishStatus, type GetFinishStatusFn, IncodeApiError, QR_VALIDATION_ERROR_CODES, QrValidationError, type QrValidationErrorCode, type QrValidationResult, type RefreshQrUrlUuidOptions, type Session, type SessionInitOptions, type SessionInitResult, type ValidateQrUuidOptions, bootstrapSession, createSession, getFinishStatus, initializeSession, refreshQrUrlUuid, validateQrUuid, whenSessionFingerprintSettled };

package/dist/session.esm.js

@@ -1,5 +1,5 @@
-import { i as initializeSession } from "./sessionInitializer-BEjB0UVH.esm.js";
-import { t as IncodeApiError } from "./apiError-CE5YD5T0.esm.js";
-import { a as refreshQrUrlUuid, i as createSession, n as QrValidationError, o as validateQrUuid, r as bootstrapSession, t as QR_VALIDATION_ERROR_CODES } from "./session-CoY3St8F.esm.js";
-import { n as getFinishStatus } from "./flowCompletionService-1HFgv9BU.esm.js";
-export { IncodeApiError, QR_VALIDATION_ERROR_CODES, QrValidationError, bootstrapSession, createSession, getFinishStatus, initializeSession, refreshQrUrlUuid, validateQrUuid };
+import { c as whenSessionFingerprintSettled, i as initializeSession } from "./sessionInitializer-DUpE6yBR.esm.js";
+import { t as IncodeApiError } from "./apiError-CY6lWIaQ.esm.js";
+import { a as refreshQrUrlUuid, i as createSession, n as QrValidationError, o as validateQrUuid, r as bootstrapSession, t as QR_VALIDATION_ERROR_CODES } from "./session-DWnBmR2a.esm.js";
+import { n as getFinishStatus } from "./flowCompletionService-cuWgokHI.esm.js";
+export { IncodeApiError, QR_VALIDATION_ERROR_CODES, QrValidationError, bootstrapSession, createSession, getFinishStatus, initializeSession, refreshQrUrlUuid, validateQrUuid, whenSessionFingerprintSettled };