@incodetech/core 0.0.0-dev-20260403-eccc51c → 0.0.0-dev-20260407-4677d7f

package/dist/setup-DJ3dFl5k.d.ts

@@ -0,0 +1,120 @@
+import { n as WasmPipeline } from "./warmup-CEOVQKby.js";
+
+//#region src/setup.d.ts
+
+/**
+ * WASM warmup configuration. Path fields are optional; omitted values resolve to the Incode CDN defaults.
+ */
+type WasmConfig = {
+  /** Path to the WASM binary */
+  wasmPath?: string;
+  /** Path to the SIMD-optimized WASM binary (optional) */
+  wasmSimdPath?: string;
+  /** Path to the WASM glue code */
+  glueCodePath?: string;
+  /** Whether to use SIMD optimizations (default: true) */
+  useSimd?: boolean;
+  /** Which pipelines to preload models for */
+  pipelines?: WasmPipeline[];
+  /**
+   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
+   * If not provided, models are expected in a 'models' subdirectory relative to the WASM binary.
+   */
+  modelsBasePath?: string;
+};
+/**
+ * Configuration options for the SDK setup.
+ */
+type SetupOptions = {
+  /** The base URL for the API. When omitted, no HTTP client is created — useful when all API actors are overridden via .provide(). */
+  apiURL?: string;
+  /** The session token for API requests (optional - can be set later or omitted for createSession calls) */
+  token?: string;
+  /** Custom headers to include in all requests */
+  customHeaders?: Record<string, string>;
+  /** Request timeout in milliseconds */
+  timeout?: number;
+  /**
+   * WASM warmup config.
+   * - Omit (default): loads automatically from the Incode CDN using the SDK's built-in version.
+   * - `false`: opt out of WASM entirely.
+   * - Object: override paths for self-hosting or a specific version.
+   */
+  wasm?: WasmConfig | false;
+  /** Optional hosting app identifier for fingerprint tracking */
+  hostingApp?: string;
+};
+/**
+ * Initializes the SDK with the provided configuration.
+ * Must be called before using any SDK functionality.
+ *
+ * WASM loads automatically from the Incode CDN unless explicitly disabled or overridden.
+ *
+ * @param options - Configuration options for the SDK
+ *
+ * @example
+ * ```ts
+ * import { setup } from '@incodetech/core';
+ *
+ * // Zero-config: WASM loads automatically from CDN
+ * await setup({ apiURL: 'https://api.incode.com', token: 'session-token' });
+ *
+ * // Opt out of WASM
+ * await setup({ apiURL: 'https://api.incode.com', token: 'session-token', wasm: false });
+ *
+ * // Self-hosted / custom version (full or partial path overrides)
+ * await setup({
+ *   apiURL: 'https://api.incode.com',
+ *   token: 'session-token',
+ *   wasm: {
+ *     wasmPath: '/my-cdn/webLib.wasm',
+ *     glueCodePath: '/my-cdn/webLib.js',
+ *   },
+ * });
+ *
+ * // Partial override: only models path, rest from CDN
+ * await setup({
+ *   apiURL: 'https://api.incode.com',
+ *   token: 'session-token',
+ *   wasm: { modelsBasePath: 'https://my-cdn/models' },
+ * });
+ *
+ * // Sessionless setup (all API actors overridden via .provide())
+ * await setup({
+ *   wasm: {
+ *     wasmPath: '/wasm/ml-wasm.wasm',
+ *     glueCodePath: '/wasm/ml-wasm.js',
+ *     pipelines: ['selfie'],
+ *   },
+ * });
+ * ```
+ */
+declare function setup(options: SetupOptions): Promise<void>;
+/**
+ * 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
+ */
+declare function setWasmConfig(config: WasmConfig): void;
+/**
+ * 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
+ */
+declare function initializeWasmUtil(config?: WasmConfig): Promise<void>;
+/**
+ * Checks if the SDK has been configured.
+ *
+ * @returns true if setup() has been called, false otherwise
+ */
+declare function isConfigured(): boolean;
+/**
+ * Resets the SDK configuration. Useful for testing.
+ */
+declare function reset(): void;
+//#endregion
+export { reset as a, isConfigured as i, WasmConfig as n, setWasmConfig as o, initializeWasmUtil as r, setup as s, SetupOptions as t };

package/dist/setup-fvDWE7f8.esm.js

@@ -0,0 +1,450 @@
+import { n as warmupWasm } from "./BaseWasmProvider-CQgeReKV.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-C45HStLj.esm.js";
+import { a as resetApi, o as setClient, s as setToken } from "./api-CyI8qTie.esm.js";
+import { h as flushEventQueue } from "./events-BlVGS-8F.esm.js";
+import { i as resetSessionInit, r as initializeSession } from "./session-PLjFj_T3.esm.js";
+
+//#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 = (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 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 = 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, parse, onUploadProgress } = requestConfig;
+			const fullUrl = buildUrl(defaults.baseURL, url, params ?? query);
+			const mergedHeaders = {
+				...defaults.headers,
+				...headers$1
+			};
+			const requestBody = prepareBody(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
+				});
+				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/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.12.84";
+const PATH_KEYS = [
+	"wasmPath",
+	"wasmSimdPath",
+	"glueCodePath",
+	"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`,
+		modelsBasePath: `${base}/models`
+	};
+}
+/**
+* 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 merged = {
+		wasmPath: pickPath("wasmPath", overrides, defaults.wasmPath),
+		wasmSimdPath: pickPath("wasmSimdPath", overrides, simdDefault),
+		glueCodePath: pickPath("glueCodePath", overrides, defaults.glueCodePath),
+		modelsBasePath: pickPath("modelsBasePath", overrides, modelsDefault),
+		useSimd: overrides.useSimd,
+		pipelines: overrides.pipelines,
+		pipelineModels: overrides.pipelineModels
+	};
+	validateWasmPaths(merged);
+	return merged;
+}
+
+//#endregion
+//#region src/setup.ts
+let wasmConfig;
+let configured = false;
+/**
+* Initializes the SDK with the provided configuration.
+* Must be called before using any SDK functionality.
+*
+* WASM loads automatically from the Incode CDN unless explicitly disabled or overridden.
+*
+* @param options - Configuration options for the SDK
+*
+* @example
+* ```ts
+* import { setup } from '@incodetech/core';
+*
+* // Zero-config: WASM loads automatically from CDN
+* await setup({ apiURL: 'https://api.incode.com', token: 'session-token' });
+*
+* // Opt out of WASM
+* await setup({ apiURL: 'https://api.incode.com', token: 'session-token', wasm: false });
+*
+* // Self-hosted / custom version (full or partial path overrides)
+* await setup({
+*   apiURL: 'https://api.incode.com',
+*   token: 'session-token',
+*   wasm: {
+*     wasmPath: '/my-cdn/webLib.wasm',
+*     glueCodePath: '/my-cdn/webLib.js',
+*   },
+* });
+*
+* // Partial override: only models path, rest from CDN
+* await setup({
+*   apiURL: 'https://api.incode.com',
+*   token: 'session-token',
+*   wasm: { modelsBasePath: 'https://my-cdn/models' },
+* });
+*
+* // Sessionless setup (all API actors overridden via .provide())
+* await setup({
+*   wasm: {
+*     wasmPath: '/wasm/ml-wasm.wasm',
+*     glueCodePath: '/wasm/ml-wasm.js',
+*     pipelines: ['selfie'],
+*   },
+* });
+* ```
+*/
+async function setup(options) {
+	if (options.apiURL) {
+		setClient(createApi_default({
+			apiURL: options.apiURL,
+			customHeaders: options.customHeaders,
+			timeout: options.timeout
+		}));
+		if (options.token) {
+			setToken(options.token);
+			flushEventQueue();
+			initializeSession({ hostingApp: options.hostingApp }).catch((error) => {
+				console.warn("Session initialization failed:", error);
+			});
+		}
+	}
+	configured = true;
+	const effectiveWasm = options.wasm === false ? void 0 : resolveWasmConfig(options.wasm);
+	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
+	});
+}
+/**
+* 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();
+	configured = false;
+	wasmConfig = void 0;
+	WasmUtilProvider.resetInstance();
+}
+
+//#endregion
+export { setup as a, resolveWasmConfig as c, setWasmConfig as i, isConfigured as n, DEFAULT_WASM_VERSION as o, reset as r, buildDefaultWasmConfig as s, initializeWasmUtil as t };

package/dist/signature.d.ts

@@ -1,5 +1,5 @@
-import "./Actor-By8WNHi-.js";
-import { t as Manager } from "./Manager-CCT_-HuZ.js";
+import { t as Manager } from "./Manager-BqFybBV-.js";
+import "./Actor-C-jivmFF.js";
 
 //#region src/modules/signature/types.d.ts
 /**

package/dist/signature.esm.js

@@ -1,6 +1,6 @@
-import { t as api } from "./api-C2uzxrpN.esm.js";
-import { C as createActor, S as fromPromise, b as assign, h as addEvent, i as eventScreenNames, r as eventModuleNames, s as createManagerInstrumentation, t as createManager, y as setup } from "./Manager-C6AGXEq_.esm.js";
-import { t as endpoints } from "./endpoints-CI5-28jT.esm.js";
+import { t as api } from "./api-CyI8qTie.esm.js";
+import { _ as endpoints, m as addEvent, n as eventModuleNames, o as createManagerInstrumentation, r as eventScreenNames } from "./events-BlVGS-8F.esm.js";
+import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-BXrcOcSC.esm.js";
 
 //#region src/modules/signature/signatureServices.ts
 /**

package/dist/{stats-BVigf5Rn.esm.js → stats-BZ1kFW4p.esm.js}

@@ -1,4 +1,4 @@
-import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as api } from "./api-CyI8qTie.esm.js";
 
 //#region src/modules/stats/statsServices.ts
 /**

package/dist/stats.esm.js

@@ -1,4 +1,4 @@
-import "./api-C2uzxrpN.esm.js";
-import { t as addDeviceStats } from "./stats-BVigf5Rn.esm.js";
+import "./api-CyI8qTie.esm.js";
+import { t as addDeviceStats } from "./stats-BZ1kFW4p.esm.js";
 
 export { addDeviceStats };

package/dist/{types-CiLyvJGb.d.ts → types-T0VjZW3T.d.ts}

@@ -1,4 +1,4 @@
-import { t as CameraStream } from "./camera-6XJdOeBF.js";
+import { t as CameraStream } from "./camera-CKsQVNlH.js";
 
 //#region src/modules/document-upload/types.d.ts
 

package/dist/types-qhLxpptI.d.ts

@@ -0,0 +1,5 @@
+//#region src/internal/permissions/types.d.ts
+type PermissionResult = 'granted' | 'denied' | 'prompt';
+type PermissionStatus = 'idle' | 'requesting' | 'denied' | 'learnMore';
+//#endregion
+export { PermissionStatus as n, PermissionResult as t };

package/dist/{types-D8Y1faI5.d.ts → types-zH5PDmSe.d.ts}

@@ -1,4 +1,4 @@
-import { t as DocumentUploadConfig } from "./types-CiLyvJGb.js";
+import { t as DocumentUploadConfig } from "./types-T0VjZW3T.js";
 
 //#region src/modules/flow/types.d.ts
 type EmptyConfig = Record<string, never>;

package/dist/{StateMachine-CM_aOfNL.d.ts → warmup-CEOVQKby.d.ts}

@@ -1,7 +1,4 @@
-import { AnyStateMachine, StateMachine, fromPromise } from "xstate";
-
 //#region ../infra/src/wasm/warmup.d.ts
-
 /**
  * All available ML pipelines in the SDK.
  * - 'selfie' - Face detection for selfie capture
@@ -55,4 +52,4 @@ interface WarmupConfig {
  */
 declare function warmupWasm(config: WarmupConfig): Promise<void>;
 //#endregion
-export { WasmPipeline as a, WarmupConfig as i, StateMachine as n, warmupWasm as o, fromPromise as r, AnyStateMachine as t };
+export { WasmPipeline as n, warmupWasm as r, WarmupConfig as t };

package/dist/wasm.d.ts

@@ -0,0 +1,15 @@
+import { n as WasmPipeline, r as warmupWasm, t as WarmupConfig } from "./warmup-CEOVQKby.js";
+import { n as WasmConfig, o as setWasmConfig, r as initializeWasmUtil } from "./setup-DJ3dFl5k.js";
+
+//#region ../infra/src/wasm/wasmDefaults.d.ts
+/** The WASM version bundled and tested with this SDK release. */
+declare const DEFAULT_WASM_VERSION = "v2.12.84";
+/** Builds the standard WarmupConfig from the Incode CDN. */
+declare function buildDefaultWasmConfig(): WarmupConfig;
+/**
+ * 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.
+ */
+declare function resolveWasmConfig(overrides?: Partial<WarmupConfig>): WarmupConfig;
+//#endregion
+export { DEFAULT_WASM_VERSION, type WasmConfig, type WasmPipeline, buildDefaultWasmConfig, initializeWasmUtil, resolveWasmConfig, setWasmConfig, warmupWasm };

package/dist/wasm.esm.js

@@ -0,0 +1,10 @@
+import { c as resolveWasmConfig, i as setWasmConfig, o as DEFAULT_WASM_VERSION, s as buildDefaultWasmConfig, t as initializeWasmUtil } from "./setup-fvDWE7f8.esm.js";
+import { n as warmupWasm } from "./BaseWasmProvider-CQgeReKV.esm.js";
+import "./WasmUtilProvider-C45HStLj.esm.js";
+import "./api-CyI8qTie.esm.js";
+import "./events-BlVGS-8F.esm.js";
+import "./session-PLjFj_T3.esm.js";
+import "./BrowserEnvironmentProvider--xQUs3sg.esm.js";
+import "./browserSimulation-yzDdWSBf.esm.js";
+
+export { DEFAULT_WASM_VERSION, buildDefaultWasmConfig, initializeWasmUtil, resolveWasmConfig, setWasmConfig, warmupWasm };