@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/setup-Buy-hyj4.esm.js

@@ -1,887 +0,0 @@
-import { a as executeWasmRequest, c as setupWasmConnection, i as WasmWebClientError, n as warmupWasm, o as initializeWasmWebClient, s as setWebApiHttpTransport } from "./BaseWasmProvider-C_DLEI40.esm.js";
-import { t as WasmUtilProvider } from "./WasmUtilProvider-j98OJf-S.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
-import { a as resetApi, i as isApiConfigured, n as getApi, o as setClient, r as getToken, t as api } from "./api-CESGtpbH.esm.js";
-import { _ as resetAnalyticsBatcher, g as getAnalyticsBatcher, m as createAnalyticsBatchingService, v as setAnalyticsBatcher } from "./events-D6-e4vok.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { i as resetSessionInit, r as initializeSession } from "./session-BS-d_vuE.esm.js";
-
-//#region ../infra/src/wasm/wasmDefaults.ts
-const WASM_CDN_BASE_URL = "https://cdn.incodesmile.com/ml-wasm-kit-release";
-/** The WASM version bundled and tested with this SDK release. */
-const DEFAULT_WASM_VERSION = "v2.13.21";
-const PATH_KEYS = [
-	"wasmPath",
-	"wasmSimdPath",
-	"glueCodePath",
-	"glueCodeSimdPath",
-	"modelsBasePath"
-];
-function isBlank(value) {
-	return value.trim() === "";
-}
-function hasDisallowedControlChars(value) {
-	for (let i = 0; i < value.length; i += 1) {
-		const code = value.charCodeAt(i);
-		if (code < 32 || code === 127) return true;
-	}
-	return false;
-}
-function isMalformedPath(value) {
-	const trimmed = value.trim();
-	if (trimmed === "") return false;
-	if (hasDisallowedControlChars(trimmed)) return true;
-	if (/^https?:\/\//i.test(trimmed)) try {
-		new URL(trimmed);
-		return false;
-	} catch {
-		return true;
-	}
-	return false;
-}
-function warnInvalidWasmPath(field, reason) {
-	if (reason === "empty") {
-		console.warn(`[Incode SDK] wasm.${field} is empty. Falling back to CDN default.`);
-		return;
-	}
-	console.warn(`[Incode SDK] wasm.${field} appears malformed. Falling back to CDN default.`);
-}
-function warnMalformedWasmPath(field) {
-	console.warn(`[Incode SDK] wasm.${field} appears malformed. Check the URL or path.`);
-}
-/**
-* Validates merged WASM path strings. When overrides contained blank path
-* values, callers should have already fallen back to defaults before this runs.
-*/
-function validateWasmPaths(config) {
-	for (const key of PATH_KEYS) {
-		const value = config[key];
-		if (typeof value === "string" && isMalformedPath(value)) warnMalformedWasmPath(key);
-	}
-}
-function pickPath(key, overrides, defaultValue) {
-	if (!overrides || !(key in overrides)) return defaultValue;
-	const raw = overrides[key];
-	if (raw === void 0) return defaultValue;
-	if (typeof raw !== "string") return defaultValue;
-	if (isBlank(raw)) {
-		warnInvalidWasmPath(key, "empty");
-		return defaultValue;
-	}
-	if (isMalformedPath(raw)) {
-		warnInvalidWasmPath(key, "malformed");
-		return defaultValue;
-	}
-	return raw.trim();
-}
-/** Builds the standard WarmupConfig from the Incode CDN. */
-function buildDefaultWasmConfig() {
-	const base = `${WASM_CDN_BASE_URL}/${DEFAULT_WASM_VERSION}`;
-	return {
-		wasmPath: `${base}/webLib.wasm`,
-		wasmSimdPath: `${base}/webLibSimd.wasm`,
-		glueCodePath: `${base}/webLib.js`,
-		glueCodeSimdPath: `${base}/webLibSimd.js`,
-		modelsBasePath: `${base}/models`
-	};
-}
-/**
-* Derives a sibling `.js` glue path from a `.wasm` binary path. Used when the
-* caller supplies `wasmSimdPath` but no explicit `glueCodeSimdPath`, mirroring
-* the legacy CDN naming convention (`webLibSimd.wasm` <-> `webLibSimd.js`).
-*/
-function deriveSiblingJsPath(wasmPath) {
-	return wasmPath.replace(/\.wasm($|\?)/, ".js$1");
-}
-/**
-* Merges optional WASM path overrides with CDN defaults. Explicit non-blank
-* paths take precedence. Blank override strings log a warning and fall back to defaults.
-*/
-function resolveWasmConfig(overrides) {
-	const defaults = buildDefaultWasmConfig();
-	if (!overrides) return defaults;
-	const simdDefault = defaults.wasmSimdPath ?? defaults.wasmPath;
-	const modelsDefault = defaults.modelsBasePath ?? (() => {
-		const lastSlash = defaults.wasmPath.lastIndexOf("/");
-		return lastSlash === -1 ? "models" : `${defaults.wasmPath.substring(0, lastSlash)}/models`;
-	})();
-	const resolvedWasmSimdPath = pickPath("wasmSimdPath", overrides, simdDefault);
-	const glueCodeSimdDefault = deriveSiblingJsPath(resolvedWasmSimdPath);
-	const merged = {
-		wasmPath: pickPath("wasmPath", overrides, defaults.wasmPath),
-		wasmSimdPath: resolvedWasmSimdPath,
-		glueCodePath: pickPath("glueCodePath", overrides, defaults.glueCodePath),
-		glueCodeSimdPath: pickPath("glueCodeSimdPath", overrides, glueCodeSimdDefault),
-		modelsBasePath: pickPath("modelsBasePath", overrides, modelsDefault),
-		useSimd: overrides.useSimd,
-		pipelines: overrides.pipelines,
-		pipelineModels: overrides.pipelineModels
-	};
-	validateWasmPaths(merged);
-	return merged;
-}
-
-//#endregion
-//#region ../infra/src/providers/browser/BrowserPageLifecycleProvider.ts
-var BrowserPageLifecycleProvider = class {
-	sendBeacon(url, body, contentType = "application/json") {
-		if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function") return false;
-		const blob = new Blob([body], { type: contentType });
-		return navigator.sendBeacon(url, blob);
-	}
-	onPageHide(listener) {
-		const onVisibilityChange = () => {
-			if (document.visibilityState === "hidden") listener();
-		};
-		document.addEventListener("visibilitychange", onVisibilityChange);
-		window.addEventListener("pagehide", listener);
-		window.addEventListener("beforeunload", listener);
-		return () => {
-			document.removeEventListener("visibilitychange", onVisibilityChange);
-			window.removeEventListener("pagehide", listener);
-			window.removeEventListener("beforeunload", listener);
-		};
-	}
-};
-
-//#endregion
-//#region ../infra/src/http/createApi.ts
-var FetchHttpError = class extends Error {
-	constructor(status, statusText, url, method, headers, data) {
-		super(`HTTP ${status} ${statusText}`);
-		this.ok = false;
-		this.status = status;
-		this.statusText = statusText;
-		this.url = url;
-		this.method = method;
-		this.headers = headers;
-		this.data = data;
-		this.name = "FetchHttpError";
-	}
-};
-const buildQueryString$1 = (query) => {
-	if (!query) return "";
-	const params = new URLSearchParams();
-	Object.entries(query).forEach(([key, value]) => {
-		if (value !== void 0 && value !== null) params.append(key, String(value));
-	});
-	const str = params.toString();
-	return str ? `?${str}` : "";
-};
-const buildUrl$1 = (baseURL, url, query) => {
-	const queryString = buildQueryString$1(query);
-	if (url.startsWith("http://") || url.startsWith("https://")) return `${url}${queryString}`;
-	return `${baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL}${url.startsWith("/") ? url : `/${url}`}${queryString}`;
-};
-const prepareBody$1 = (body) => {
-	if (body === null || body === void 0) return null;
-	if (body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer) return body;
-	if (typeof body === "object") return JSON.stringify(body);
-	return String(body);
-};
-const parseResponse = async (response, parseType) => {
-	if (parseType === "response") return response;
-	if (parseType === "blob") return await response.blob();
-	if (parseType === "arrayBuffer") return await response.arrayBuffer();
-	if (parseType === "text") return await response.text();
-	const contentType = response.headers.get("content-type") ?? "";
-	if (parseType === "json" || contentType.includes("application/json")) try {
-		return await response.json();
-	} catch {
-		return await response.text();
-	}
-	return await response.text();
-};
-const DEFAULT_TIMEOUT$1 = 3e4;
-const requestWithXHR = (fullUrl, method, mergedHeaders, requestBody, timeout, signal, onUploadProgress) => {
-	return new Promise((resolve, reject) => {
-		const xhr = new XMLHttpRequest();
-		xhr.open(method, fullUrl, true);
-		Object.entries(mergedHeaders).forEach(([key, value]) => {
-			xhr.setRequestHeader(key, value);
-		});
-		xhr.timeout = timeout;
-		xhr.upload.onprogress = (event) => {
-			if (event.lengthComputable) {
-				const percentComplete = event.loaded / event.total * 100;
-				onUploadProgress(Math.round(percentComplete));
-			}
-		};
-		xhr.onload = () => {
-			const responseHeaders = {};
-			xhr.getAllResponseHeaders().split("\r\n").forEach((line) => {
-				const parts = line.split(": ");
-				if (parts.length === 2) responseHeaders[parts[0].toLowerCase()] = parts[1];
-			});
-			let data;
-			try {
-				if ((xhr.getResponseHeader("content-type") ?? "").includes("application/json")) data = JSON.parse(xhr.responseText);
-				else data = xhr.responseText;
-			} catch {
-				data = xhr.responseText;
-			}
-			if (xhr.status >= 200 && xhr.status < 300) resolve({
-				ok: true,
-				status: xhr.status,
-				statusText: xhr.statusText,
-				url: fullUrl,
-				headers: responseHeaders,
-				data
-			});
-			else reject(new FetchHttpError(xhr.status, xhr.statusText, fullUrl, method, responseHeaders, data));
-		};
-		xhr.onerror = () => {
-			reject(new FetchHttpError(0, "Network Error", fullUrl, method, {}, null));
-		};
-		xhr.ontimeout = () => {
-			reject(new FetchHttpError(0, "Request timeout", fullUrl, method, {}, null));
-		};
-		if (signal) signal.addEventListener("abort", () => {
-			xhr.abort();
-			reject(new FetchHttpError(0, "Request aborted", fullUrl, method, {}, null));
-		});
-		xhr.send(requestBody);
-	});
-};
-const createApi = (config) => {
-	const headers = {
-		"Content-Type": "application/json",
-		Accept: "application/json",
-		"api-version": "1.0",
-		...config.customHeaders ?? {}
-	};
-	const defaults = {
-		baseURL: config.apiURL,
-		headers
-	};
-	const client = {
-		defaults,
-		async request(requestConfig) {
-			const { method = "GET", url, headers: headers$1 = {}, query, params, body, signal, timeout = config.timeout ?? DEFAULT_TIMEOUT$1, parse, onUploadProgress, keepalive } = requestConfig;
-			const fullUrl = buildUrl$1(defaults.baseURL, url, params ?? query);
-			const mergedHeaders = {
-				...defaults.headers,
-				...headers$1
-			};
-			const requestBody = prepareBody$1(body);
-			let finalHeaders = mergedHeaders;
-			if (requestBody === null && (method === "POST" || method === "PUT" || method === "PATCH")) {
-				const { "Content-Type": _, ...headersWithoutContentType } = mergedHeaders;
-				finalHeaders = headersWithoutContentType;
-			}
-			if (onUploadProgress) {
-				if (requestBody !== null && typeof ReadableStream !== "undefined" && requestBody instanceof ReadableStream) throw new Error("Upload progress tracking is not supported for ReadableStream bodies");
-				return requestWithXHR(fullUrl, method, finalHeaders, requestBody, timeout, signal, onUploadProgress);
-			}
-			const controller = new AbortController();
-			const abortSignal = signal ?? controller.signal;
-			const timeoutId = setTimeout(() => controller.abort(), timeout);
-			try {
-				const response = await fetch(fullUrl, {
-					method,
-					headers: finalHeaders,
-					body: requestBody,
-					signal: abortSignal,
-					keepalive
-				});
-				if (timeoutId) clearTimeout(timeoutId);
-				const responseHeaders = {};
-				response.headers.forEach((value, key) => {
-					responseHeaders[key] = value;
-				});
-				const data = await parseResponse(response, parse);
-				if (!response.ok) throw new FetchHttpError(response.status, response.statusText, fullUrl, method, responseHeaders, data);
-				return {
-					ok: true,
-					status: response.status,
-					statusText: response.statusText,
-					url: fullUrl,
-					headers: responseHeaders,
-					data
-				};
-			} catch (error) {
-				if (timeoutId) clearTimeout(timeoutId);
-				if (error instanceof FetchHttpError) throw error;
-				if (error instanceof Error && error.name === "AbortError") throw new FetchHttpError(0, "Request timeout", fullUrl, method, {}, null);
-				throw error;
-			}
-		},
-		get(url, config$1) {
-			return client.request({
-				...config$1,
-				url,
-				method: "GET"
-			});
-		},
-		post(url, body, config$1) {
-			return client.request({
-				...config$1,
-				url,
-				body,
-				method: "POST"
-			});
-		},
-		put(url, body, config$1) {
-			return client.request({
-				...config$1,
-				url,
-				body,
-				method: "PUT"
-			});
-		},
-		patch(url, body, config$1) {
-			return client.request({
-				...config$1,
-				url,
-				body,
-				method: "PATCH"
-			});
-		},
-		delete(url, config$1) {
-			return client.request({
-				...config$1,
-				url,
-				method: "DELETE"
-			});
-		},
-		head(url, config$1) {
-			return client.request({
-				...config$1,
-				url,
-				method: "HEAD"
-			});
-		},
-		options(url, config$1) {
-			return client.request({
-				...config$1,
-				url,
-				method: "OPTIONS"
-			});
-		},
-		setHeader(name, value) {
-			defaults.headers[name] = value;
-		}
-	};
-	return client;
-};
-var createApi_default = createApi;
-
-//#endregion
-//#region ../infra/src/http/createWasmApi.ts
-const RSA_OAEP_SHA256_SCHEME = "RSA/NONE/OAEPWITHSHA-256ANDMGF1PADDING";
-/**
-* Builds the base set of HTTP headers that the WASM WebClient sends on every
-* request (including the internal `/e2ee/key/v2` and `/e2ee/key` handshake
-* calls).
-*/
-function buildWasmDefaultHeaders(customHeaders) {
-	return {
-		"Content-Type": "application/json",
-		Accept: "application/json",
-		"api-version": "1.0",
-		...customHeaders ?? {}
-	};
-}
-var WasmHttpError = class extends Error {
-	constructor(status, statusText, url, method, headers, data) {
-		super(`HTTP ${status} ${statusText}`);
-		this.ok = false;
-		this.status = status;
-		this.statusText = statusText;
-		this.url = url;
-		this.method = method;
-		this.headers = headers;
-		this.data = data;
-		this.name = "WasmHttpError";
-	}
-};
-const DEFAULT_TIMEOUT = 3e4;
-const HTTP_METHODS = new Set([
-	"GET",
-	"POST",
-	"PUT",
-	"PATCH",
-	"DELETE"
-]);
-const buildQueryString = (query) => {
-	if (!query) return "";
-	const params = new URLSearchParams();
-	Object.entries(query).forEach(([key, value]) => {
-		if (value !== void 0 && value !== null) params.append(key, String(value));
-	});
-	const str = params.toString();
-	return str ? `?${str}` : "";
-};
-const buildUrl = (baseURL, url, query) => {
-	const queryString = buildQueryString(query);
-	if (url.startsWith("http://") || url.startsWith("https://")) return `${url}${queryString}`;
-	return `${baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL}${url.startsWith("/") ? url : `/${url}`}${queryString}`;
-};
-const prepareBody = (body) => {
-	if (body === null || body === void 0) return void 0;
-	if (body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer || body instanceof Uint8Array || typeof body === "string") return body;
-	if (typeof body === "object") return body;
-	return String(body);
-};
-const normalizeMethod = (method) => {
-	const upper = method.toUpperCase();
-	if (!HTTP_METHODS.has(upper)) throw new Error(`Unsupported HTTP method for WASM client: ${method}`);
-	return upper;
-};
-const getErrorStatus = (error) => {
-	if (error instanceof WasmWebClientError) return error.statusCode;
-	if (typeof error === "object" && error !== null) {
-		const record = error;
-		if (typeof record.statusCode === "number") return record.statusCode;
-		if (typeof record.status === "number") return record.status;
-	}
-	return 0;
-};
-const getErrorData = (error) => {
-	if (error instanceof WasmWebClientError) return error.response?.data ?? null;
-	return null;
-};
-const getErrorMessage = (error) => {
-	if (error instanceof Error) return error.message;
-	return "WasmWebClient request failed";
-};
-const withAbortSignal = async (promise, signal, error) => {
-	if (!signal) return await promise;
-	if (signal.aborted) throw error;
-	return await new Promise((resolve, reject) => {
-		const onAbort = () => reject(error);
-		signal.addEventListener("abort", onAbort, { once: true });
-		promise.then(resolve, reject).finally(() => {
-			signal.removeEventListener("abort", onAbort);
-		});
-	});
-};
-const createWasmApi = async (config) => {
-	const headers = buildWasmDefaultHeaders(config.customHeaders);
-	const isEncryptionEnabled = config.isEncryptionEnabled ?? (() => false);
-	const useSha256 = config.mgf1 === "sha256";
-	await initializeWasmWebClient(config.wasm.wasmPath, config.wasm.wasmSimdPath ?? config.wasm.wasmPath, config.wasm.glueCodePath, config.wasm.glueCodeSimdPath ?? "", config.wasm.useSimd ?? true);
-	await setupWasmConnection(config.apiURL, "", config.encryptionEnabled ?? false, headers, useSha256);
-	const defaults = {
-		baseURL: config.apiURL,
-		headers
-	};
-	const client = {
-		defaults,
-		async request(requestConfig) {
-			const { method = "GET", url, headers: requestHeaders = {}, query, params, body, signal, timeout = config.timeout ?? DEFAULT_TIMEOUT, onUploadProgress, ie = false } = requestConfig;
-			const upperMethod = normalizeMethod(method);
-			const requestParams = params ?? query;
-			const fullUrl = buildUrl(defaults.baseURL, url, requestParams);
-			const needsSchemeHeader = ie || useSha256 && isEncryptionEnabled();
-			const mergedHeaders = {
-				...defaults.headers,
-				...needsSchemeHeader ? { "X-RSA-Encryption-Scheme": RSA_OAEP_SHA256_SCHEME } : {},
-				...requestHeaders
-			};
-			const requestBody = prepareBody(body);
-			const wasmProgress = onUploadProgress ? (progress) => {
-				if (progress.total > 0) onUploadProgress(Math.round(progress.loaded / progress.total * 100));
-			} : void 0;
-			const abortError = new WasmHttpError(0, "Request aborted", fullUrl, upperMethod, {}, null);
-			if (signal?.aborted) throw abortError;
-			try {
-				const response = await withAbortSignal(executeWasmRequest(upperMethod, url, requestBody, mergedHeaders, requestParams, timeout, wasmProgress, ie), signal, abortError);
-				if (response.status < 200 || response.status >= 300) throw new WasmHttpError(response.status, "", fullUrl, upperMethod, {}, response.data);
-				return {
-					ok: true,
-					status: response.status,
-					statusText: "",
-					url: fullUrl,
-					headers: {},
-					data: response.data
-				};
-			} catch (error) {
-				if (error instanceof WasmHttpError) throw error;
-				throw new WasmHttpError(getErrorStatus(error), getErrorMessage(error), fullUrl, upperMethod, {}, getErrorData(error));
-			}
-		},
-		get(url, requestConfig) {
-			return client.request({
-				...requestConfig,
-				url,
-				method: "GET"
-			});
-		},
-		post(url, body, requestConfig) {
-			return client.request({
-				...requestConfig,
-				url,
-				body,
-				method: "POST"
-			});
-		},
-		put(url, body, requestConfig) {
-			return client.request({
-				...requestConfig,
-				url,
-				body,
-				method: "PUT"
-			});
-		},
-		patch(url, body, requestConfig) {
-			return client.request({
-				...requestConfig,
-				url,
-				body,
-				method: "PATCH"
-			});
-		},
-		delete(url, requestConfig) {
-			return client.request({
-				...requestConfig,
-				url,
-				method: "DELETE"
-			});
-		},
-		head() {
-			return Promise.reject(/* @__PURE__ */ new Error("HEAD is not supported by the WASM HTTP client"));
-		},
-		options() {
-			return Promise.reject(/* @__PURE__ */ new Error("OPTIONS is not supported by the WASM HTTP client"));
-		},
-		setHeader(name, value) {
-			defaults.headers[name] = value;
-		}
-	};
-	return client;
-};
-var createWasmApi_default = createWasmApi;
-
-//#endregion
-//#region src/internal/http/clientLifecycle.ts
-/**
-* Wraps the active HttpClient as a transport for the C++ `WebApi` host
-* adapter. Lets the on-device face-results POST flow through the same
-* `httpClient.request()` pipeline as every other endpoint — header
-* injection, encryption-state handling, default headers, timeout — instead
-* of bypassing it via `executeWasmRequest` directly.
-*/
-function bindWebApiTransport(client) {
-	return async (url, body, config) => {
-		const response = await client.request({
-			method: "POST",
-			url,
-			body,
-			headers: config.headers,
-			params: config.params,
-			timeout: config.timeout,
-			ie: config.ie
-		});
-		return {
-			data: response.data,
-			status: response.status
-		};
-	};
-}
-function installClient(client) {
-	setClient(client);
-	setWebApiHttpTransport(bindWebApiTransport(client));
-}
-let storedHttpConfig;
-/** Reads the current HTTP-client config (or `undefined` if none installed). */
-function getStoredHttpConfig() {
-	return storedHttpConfig;
-}
-/** Whether encryption is currently active on the installed HTTP client. */
-function isHttpEncrypted() {
-	return storedHttpConfig?.encryption.enabled ?? false;
-}
-/** Clears all HTTP-client state. Called by `reset()`. */
-function resetHttpClientState() {
-	storedHttpConfig = void 0;
-	setWebApiHttpTransport(null);
-}
-/**
-* Builds (or replaces) the HTTP client when `setup()` receives an `apiURL`.
-* Picks `createWasmApi` when `effectiveWasm` is set, otherwise plain
-* `createApi`. Wraps the call in handshake-failure context when encryption
-* is requested.
-*/
-async function installFreshHttpClient(apiURL, options, effectiveWasm, encryption) {
-	installClient(effectiveWasm ? await withHandshakeFailureContext(encryption.enabled, () => createWasmApi_default({
-		apiURL,
-		customHeaders: options.customHeaders,
-		timeout: options.timeout,
-		wasm: effectiveWasm,
-		encryptionEnabled: encryption.enabled,
-		mgf1: encryption.mgf1,
-		isEncryptionEnabled: isHttpEncrypted
-	})) : createApi_default({
-		apiURL,
-		customHeaders: options.customHeaders,
-		timeout: options.timeout
-	}));
-	storedHttpConfig = {
-		apiURL,
-		customHeaders: options.customHeaders,
-		timeout: options.timeout,
-		isWasm: Boolean(effectiveWasm),
-		encryption
-	};
-}
-/**
-* Replaces the active HTTP client with the WASM-backed one. Used internally
-* by lazy-loading UI components (`<incode-flow>`, `<incode-workflow>`) when
-* WASM finishes warming up.
-*
-* No-op when no apiURL was previously configured, or when the active client
-* is already WASM-backed. The encryption state (enabled + MGF1 scheme) is
-* preserved across the swap — this is *not* a user-facing encryption change.
-*
-* @internal NOT a public API. Application code should use
-*   `setup({ wasm: {...} })` instead.
-*/
-async function upgradeToWasmHttpClient(resolved) {
-	const stored = storedHttpConfig;
-	if (!stored || stored.isWasm) return;
-	installClient(await createWasmApi_default({
-		apiURL: stored.apiURL,
-		customHeaders: stored.customHeaders,
-		timeout: stored.timeout,
-		wasm: resolved,
-		encryptionEnabled: stored.encryption.enabled,
-		mgf1: stored.encryption.mgf1,
-		isEncryptionEnabled: isHttpEncrypted
-	}));
-	storedHttpConfig = {
-		...stored,
-		isWasm: true
-	};
-}
-/**
-* When `wantsEncryption` is true, wraps a call that triggers the in-binary
-* RSA/AES handshake so its rejection surfaces as a single, descriptive error
-* with the original error preserved as `cause`. Pass-through otherwise.
-*/
-async function withHandshakeFailureContext(wantsEncryption, fn) {
-	if (!wantsEncryption) return fn();
-	try {
-		return await fn();
-	} catch (cause) {
-		const error = /* @__PURE__ */ new Error("Failed to establish encrypted transport. The /e2ee/key handshake did not complete. Verify the apiURL is reachable and that the environment supports E2EE.");
-		error.cause = cause;
-		throw error;
-	}
-}
-
-//#endregion
-//#region src/setup.ts
-let wasmConfig;
-const DEFAULT_MGF1 = "sha1";
-/**
-* Normalizes the public `encryption` option into the internal shape used by
-* the HTTP client lifecycle. Returns `undefined` when the caller did not
-* specify `encryption` at all (so callers can distinguish "preserve stored
-* value" from "explicitly off").
-*/
-function normalizeEncryption(input) {
-	if (input === void 0) return void 0;
-	if (input === false) return {
-		enabled: false,
-		mgf1: DEFAULT_MGF1
-	};
-	if (input === true) return {
-		enabled: true,
-		mgf1: DEFAULT_MGF1
-	};
-	return {
-		enabled: true,
-		mgf1: input.mgf1 ?? DEFAULT_MGF1
-	};
-}
-let configured = false;
-/**
-* Initializes the SDK with the provided configuration.
-* Must be called before using any SDK functionality.
-*
-* WASM loads only when `options.wasm` is provided as an object.
-*
-* `setup` is boot — it provisions the HTTP client, the optional E2EE
-* handshake, WASM warmup, and the analytics batcher. The session token is a
-* separate concern: hand it off via `initializeSession({ token })` from
-* `@incodetech/core/session`, or pass it inline as `setup({ apiURL, token })`
-* (a convenience that delegates to `initializeSession` for you).
-*
-* @param options - Configuration options for the SDK
-*
-* @example Boot first, activate the session later (preferred)
-* ```ts
-* import { setup } from '@incodetech/core';
-* import { createSession, initializeSession } from '@incodetech/core/session';
-*
-* await setup({ apiURL: 'https://api.incode.com' });
-* const session = await createSession(apiKey, { configurationId });
-* await initializeSession({ token: session.token });
-* ```
-*
-* @example One-shot convenience
-* ```ts
-* await setup({ apiURL: 'https://api.incode.com', token: 'session-token' });
-* ```
-*
-* @example Explicitly disable WASM
-* ```ts
-* await setup({ apiURL: 'https://api.incode.com', wasm: false });
-* ```
-*
-* @example Use CDN defaults for paths and preload only one pipeline
-* ```ts
-* await setup({
-*   apiURL: 'https://api.incode.com',
-*   wasm: { pipelines: ['selfie'] },
-* });
-* ```
-*
-* @example Self-hosted / custom version (full or partial path overrides)
-* ```ts
-* await setup({
-*   apiURL: 'https://api.incode.com',
-*   wasm: {
-*     wasmPath: '/my-cdn/webLib.wasm',
-*     glueCodePath: '/my-cdn/webLib.js',
-*   },
-* });
-* ```
-*
-* @example Partial override: only models path, rest from CDN
-* ```ts
-* await setup({
-*   apiURL: 'https://api.incode.com',
-*   wasm: { modelsBasePath: 'https://my-cdn/models' },
-* });
-* ```
-*
-* @example Sessionless setup (all API actors overridden via .provide())
-* ```ts
-* await setup({
-*   wasm: {
-*     wasmPath: '/wasm/ml-wasm.wasm',
-*     glueCodePath: '/wasm/ml-wasm.js',
-*     pipelines: ['selfie'],
-*   },
-* });
-* ```
-*
-* @example Enable end-to-end encryption at boot (defaults to MGF1 = SHA-1)
-* ```ts
-* await setup({ apiURL: 'https://api.incode.com', encryption: true });
-* ```
-*
-* @example Enable encryption with the SHA-256 MGF1 padding
-* ```ts
-* await setup({
-*   apiURL: 'https://api.incode.com',
-*   encryption: { mgf1: 'sha256' },
-* });
-* ```
-*/
-async function setup(options) {
-	if (!getAnalyticsBatcher()) setAnalyticsBatcher(createAnalyticsBatchingService({
-		endpoint: endpoints.events,
-		authToken: () => getToken(),
-		apiBaseUrl: () => getApi().defaults.baseURL,
-		apiClient: api,
-		pageLifecycle: new BrowserPageLifecycleProvider(),
-		timer: BrowserTimerProvider.getInstance()
-	}));
-	const requestedEncryption = normalizeEncryption(options.encryption);
-	const stored = getStoredHttpConfig();
-	if (requestedEncryption && stored) {
-		if (requestedEncryption.enabled !== stored.encryption.enabled || requestedEncryption.enabled && requestedEncryption.mgf1 !== stored.encryption.mgf1) throw new Error("Encryption is locked at the first setup() call and cannot be changed at runtime. Call reset() to fully reinitialize the SDK if you need a different encryption configuration.");
-	}
-	if (requestedEncryption?.enabled && options.wasm === false) throw new Error("Encryption is incompatible with `wasm: false`. Either remove `wasm: false` or omit `encryption`.");
-	const effectiveEncryption = requestedEncryption ?? stored?.encryption ?? {
-		enabled: false,
-		mgf1: "sha1"
-	};
-	const effectiveWasm = options.wasm || requestedEncryption?.enabled ? resolveWasmConfig(options.wasm || {}) : void 0;
-	if (options.apiURL) await installFreshHttpClient(options.apiURL, options, effectiveWasm, effectiveEncryption);
-	if (options.token && isApiConfigured()) initializeSession({
-		token: options.token,
-		hostingApp: options.hostingApp
-	}).catch((error) => {
-		console.warn("Session initialization failed:", error);
-	});
-	configured = true;
-	if (effectiveWasm) {
-		await warmupWasm(effectiveWasm);
-		await (await WasmUtilProvider.getInstance()).initialize({
-			...effectiveWasm,
-			pipelines: effectiveWasm.pipelines ? [...effectiveWasm.pipelines] : void 0
-		});
-	}
-}
-/**
-* Sets the WASM configuration without performing warmup.
-* Useful when WASM warmup is handled separately (e.g., conditionally based on flow).
-*
-* @param config - WASM configuration to store
-*/
-function setWasmConfig(config) {
-	wasmConfig = config;
-}
-/**
-* Initializes WasmUtilProvider with the stored WASM configuration.
-* Should be called after warmupWasm() completes when using conditional warmup.
-* This ensures image encryption works properly.
-*
-* @param config - Optional WASM configuration. If not provided, uses the stored config from setWasmConfig().
-* @throws Error if no config is provided and none is stored
-*/
-async function initializeWasmUtil(config) {
-	const wasmConfigToUse = config ?? wasmConfig;
-	if (!wasmConfigToUse) throw new Error("WASM config is required. Provide config parameter or call setWasmConfig() first.");
-	const resolved = resolveWasmConfig(wasmConfigToUse);
-	await (await WasmUtilProvider.getInstance()).initialize({
-		...resolved,
-		pipelines: resolved.pipelines ? [...resolved.pipelines] : void 0
-	});
-}
-/**
-* Replaces the active HTTP client with the WASM-backed one. Used internally
-* by lazy-loading UI components (`<incode-flow>`, `<incode-workflow>`) when
-* WASM finishes warming up.
-*
-* No-op when no apiURL was originally configured, or when the active client is
-* already the WASM one.
-*
-* @internal NOT a public API. Application code should use
-*   `setup({ wasm: {...} })` instead — that path is the supported way to opt
-*   into the WASM HTTP client.
-*
-* @param config - Optional WASM configuration. Defaults to the config stored via `setWasmConfig`.
-*/
-async function upgradeToWasmHttpClient$1(config) {
-	const configToUse = config ?? wasmConfig;
-	if (!configToUse) return;
-	await upgradeToWasmHttpClient(resolveWasmConfig(configToUse));
-}
-/**
-* Checks if the SDK has been configured.
-*
-* @returns true if setup() has been called, false otherwise
-*/
-function isConfigured() {
-	return configured;
-}
-/**
-* Resets the SDK configuration. Useful for testing.
-*/
-function reset() {
-	resetApi();
-	resetSessionInit();
-	resetAnalyticsBatcher();
-	resetHttpClientState();
-	configured = false;
-	wasmConfig = void 0;
-	WasmUtilProvider.resetInstance();
-}
-
-//#endregion
-export { setup as a, buildDefaultWasmConfig as c, setWasmConfig as i, resolveWasmConfig as l, isConfigured as n, upgradeToWasmHttpClient$1 as o, reset as r, DEFAULT_WASM_VERSION as s, initializeWasmUtil as t };