@incodetech/core 0.0.0-dev-20260507-85da360 → 0.0.0-dev-20260507-a2cd155

package/dist/{setup-DGSuf74f.esm.js → setup-B72ayX57.esm.js}

@@ -1,10 +1,10 @@
-import { n as warmupWasm } from "./BaseWasmProvider-QTXpU_qs.esm.js";
-import { t as WasmUtilProvider } from "./WasmUtilProvider-Cj17GAox.esm.js";
+import { c as SemaphoreProvider, n as warmupWasm, o as wasmCallWrapper, s as loadWasmModule } from "./BaseWasmProvider-C2cw9STp.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-B8VtGgvF.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BZGH3sYJ.esm.js";
 import { a as resetApi, i as isApiConfigured, n as getApi, o as setClient, r as getToken, s as setToken, t as api } from "./api-eqRXuVG-.esm.js";
 import { _ as resetAnalyticsBatcher, g as getAnalyticsBatcher, m as createAnalyticsBatchingService, v as setAnalyticsBatcher } from "./events-Bt1azl2B.esm.js";
 import { t as endpoints } from "./endpoints-B3V1U9Dg.esm.js";
-import { i as resetSessionInit, r as initializeSession } from "./session-CsUswFcx.esm.js";
+import { i as resetSessionInit, r as initializeSession } from "./session-DPd529SS.esm.js";
 
 //#region ../infra/src/http/createApi.ts
 var FetchHttpError = class extends Error {
@@ -20,7 +20,7 @@ var FetchHttpError = class extends Error {
 		this.name = "FetchHttpError";
 	}
 };
-const buildQueryString = (query) => {
+const buildQueryString$1 = (query) => {
 	if (!query) return "";
 	const params = new URLSearchParams();
 	Object.entries(query).forEach(([key, value]) => {
@@ -29,12 +29,12 @@ const buildQueryString = (query) => {
 	const str = params.toString();
 	return str ? `?${str}` : "";
 };
-const buildUrl = (baseURL, url, query) => {
-	const queryString = buildQueryString(query);
+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 = (body) => {
+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);
@@ -53,7 +53,7 @@ const parseResponse = async (response, parseType) => {
 	}
 	return await response.text();
 };
-const DEFAULT_TIMEOUT = 3e4;
+const DEFAULT_TIMEOUT$1 = 3e4;
 const requestWithXHR = (fullUrl, method, mergedHeaders, requestBody, timeout, signal, onUploadProgress) => {
 	return new Promise((resolve, reject) => {
 		const xhr = new XMLHttpRequest();
@@ -118,13 +118,13 @@ const createApi = (config) => {
 	const client = {
 		defaults,
 		async request(requestConfig) {
-			const { method = "GET", url, headers: headers$1 = {}, query, params, body, signal, timeout = config.timeout ?? DEFAULT_TIMEOUT, parse, onUploadProgress, keepalive } = requestConfig;
-			const fullUrl = buildUrl(defaults.baseURL, url, params ?? query);
+			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(body);
+			const requestBody = prepareBody$1(body);
 			let finalHeaders = mergedHeaders;
 			if (requestBody === null && (method === "POST" || method === "PUT" || method === "PATCH")) {
 				const { "Content-Type": _, ...headersWithoutContentType } = mergedHeaders;
@@ -227,6 +227,315 @@ const createApi = (config) => {
 };
 var createApi_default = createApi;
 
+//#endregion
+//#region ../infra/src/wasm/wasmWebClient.ts
+/**
+* JavaScript bridge for the C++ `WebClient` exposed by `webLib.wasm`.
+*
+* The pinned WASM bundle ships a `WebClient` class alongside the ML pipeline
+* APIs. This module instantiates it once (sharing the singleton `wasmModule`
+* with `mlWasmJSApi`) and exposes a small TypeScript-friendly surface that
+* `createWasmApi` can drive.
+*
+* Concurrency model mirrors the legacy implementation:
+* - 4-slot semaphore keyed by per-request `threadId` so multiple HTTP calls
+*   can run in parallel without trampling shared C++ state.
+* - Each WASM-side request method returns `false` while in flight; we
+*   busy-poll via {@link wasmCallWrapper}.
+* - Result extraction (`getRequestResult`) is per-thread.
+*
+* Encryption is wired through the `encryptionEnabled` flag but defaults to
+* `false`. End-to-end encryption (Phase 2) will re-call `setupConnection` with
+* a real token + `encryptionEnabled = true`; that helper is a follow-up.
+*/
+const HTTP_CONCURRENCY = 4;
+var WasmWebClientError = class extends Error {
+	constructor(message, statusCode, data) {
+		super(message);
+		this.name = "WasmWebClientError";
+		this.status = statusCode;
+		this.statusCode = statusCode;
+		if (statusCode > 0 || data !== void 0) this.response = {
+			status: statusCode,
+			data
+		};
+	}
+};
+let webClientApi = null;
+let initPromise = null;
+let semaphore = new SemaphoreProvider(HTTP_CONCURRENCY);
+const isWebClientWasm = (mod) => {
+	return typeof mod.WebClient === "function";
+};
+const toStringRecord = (obj) => {
+	if (!obj) return void 0;
+	const result = {};
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		if (value === void 0 || value === null) continue;
+		result[key] = String(value);
+	}
+	return result;
+};
+/**
+* Loads the shared WASM module (if not already loaded) and instantiates the
+* C++ `WebClient`. Idempotent — repeated calls reuse the existing instance.
+*/
+async function initializeWasmWebClient(wasmPath, wasmSimdPath, glueCodePath, useSimd) {
+	if (webClientApi) return;
+	if (initPromise) return initPromise;
+	initPromise = (async () => {
+		try {
+			const { wasmModule } = await loadWasmModule({
+				wasmPath,
+				wasmSimdPath,
+				glueCodePath,
+				useSimd
+			});
+			if (!isWebClientWasm(wasmModule)) throw new Error("WASM module does not expose a WebClient class. Update webLib.wasm to a build that includes WebClient.");
+			webClientApi = new wasmModule.WebClient();
+		} catch (error) {
+			initPromise = null;
+			throw error;
+		}
+	})();
+	return initPromise;
+}
+/**
+* Configures the C++ WebClient connection. Safe to call multiple times — each
+* call resets the underlying session and re-applies default headers.
+*/
+async function setupWasmConnection(apiURL, token, useSha256, encryptionEnabled, defaultHeaders) {
+	const api$1 = ensureReady();
+	api$1.resetSessionState?.();
+	api$1.createApi(apiURL, token, useSha256, encryptionEnabled);
+	api$1.setDefaultHeaders?.(defaultHeaders);
+}
+/**
+* Executes a single HTTP request through the WASM WebClient.
+*
+* Acquires a semaphore slot for `threadId`, registers progress callbacks, runs
+* the request via {@link wasmCallWrapper} (busy-polls until the WASM method
+* returns `true`), then extracts the per-thread result. Throws
+* {@link WasmWebClientError} on non-2xx or transport errors.
+*/
+async function executeWasmRequest(method, url, body, headers, params, timeout, onUploadProgress) {
+	const api$1 = ensureReady();
+	const stringParams = toStringRecord(params);
+	return semaphore.withLock(async (threadId) => {
+		if (onUploadProgress && api$1.setOnUploadProgress) api$1.setOnUploadProgress((event) => {
+			try {
+				onUploadProgress(event);
+			} catch (error) {
+				console.error("WasmWebClient: error in onUploadProgress callback", error);
+			}
+		});
+		try {
+			await wasmCallWrapper(semaphore, () => callWasmMethod(api$1, method, threadId, url, body, headers, stringParams, timeout), false);
+			return readResult(api$1, threadId);
+		} finally {
+			api$1.clearOnUploadProgress?.(threadId);
+			api$1.clearOnDownloadProgress?.(threadId);
+		}
+	});
+}
+function callWasmMethod(api$1, method, threadId, url, body, headers, params, timeout) {
+	switch (method) {
+		case "GET": return api$1.get(threadId, url, params, headers, timeout);
+		case "POST": return api$1.post(threadId, url, body ?? {}, headers, params, timeout);
+		case "PUT": return api$1.put(threadId, url, body ?? {}, headers, params, timeout);
+		case "PATCH": return api$1.patch(threadId, url, body ?? {}, headers, params, timeout);
+		case "DELETE": return api$1.del(threadId, url, body ?? {}, headers, params, timeout);
+		default: throw new Error(`Unsupported WASM HTTP method: ${method}`);
+	}
+}
+function readResult(api$1, threadId) {
+	const response = api$1.getRequestResult(threadId);
+	if (response.hasError) throw new WasmWebClientError(response.errorMessage || "WasmWebClient request failed", response.statusCode, response.result);
+	return {
+		data: response.result,
+		status: response.statusCode
+	};
+}
+function ensureReady() {
+	if (!webClientApi) throw new Error("WasmWebClient not initialized. Call initializeWasmWebClient() first.");
+	return webClientApi;
+}
+
+//#endregion
+//#region ../infra/src/http/createWasmApi.ts
+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 = {
+		"Content-Type": "application/json",
+		Accept: "application/json",
+		"api-version": "1.0",
+		...config.customHeaders ?? {}
+	};
+	await initializeWasmWebClient(config.wasm.wasmPath, config.wasm.wasmSimdPath ?? config.wasm.wasmPath, config.wasm.glueCodePath, config.wasm.useSimd ?? true);
+	await setupWasmConnection(config.apiURL, "", config.useSha256 ?? false, config.encryptionEnabled ?? false, headers);
+	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 } = requestConfig;
+			const upperMethod = normalizeMethod(method);
+			const requestParams = params ?? query;
+			const fullUrl = buildUrl(defaults.baseURL, url, requestParams);
+			const mergedHeaders = {
+				...defaults.headers,
+				...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), 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 ../infra/src/wasm/wasmDefaults.ts
 const WASM_CDN_BASE_URL = "https://cdn.incodesmile.com/ml-wasm-kit-release";
@@ -356,6 +665,7 @@ var BrowserPageLifecycleProvider = class {
 //#endregion
 //#region src/setup.ts
 let wasmConfig;
+let storedHttpConfig;
 let configured = false;
 /**
 * Initializes the SDK with the provided configuration.
@@ -418,11 +728,26 @@ async function setup(options) {
 		pageLifecycle: new BrowserPageLifecycleProvider(),
 		timer: BrowserTimerProvider.getInstance()
 	}));
-	if (options.apiURL) setClient(createApi_default({
-		apiURL: options.apiURL,
-		customHeaders: options.customHeaders,
-		timeout: options.timeout
-	}));
+	const effectiveWasm = options.wasm ? resolveWasmConfig(options.wasm) : void 0;
+	if (options.apiURL) {
+		const client = effectiveWasm ? await createWasmApi_default({
+			apiURL: options.apiURL,
+			customHeaders: options.customHeaders,
+			timeout: options.timeout,
+			wasm: effectiveWasm
+		}) : createApi_default({
+			apiURL: options.apiURL,
+			customHeaders: options.customHeaders,
+			timeout: options.timeout
+		});
+		storedHttpConfig = {
+			apiURL: options.apiURL,
+			customHeaders: options.customHeaders,
+			timeout: options.timeout,
+			isWasm: Boolean(effectiveWasm)
+		};
+		setClient(client);
+	}
 	if (options.token && isApiConfigured()) {
 		setToken(options.token);
 		resetSessionInit();
@@ -433,7 +758,6 @@ async function setup(options) {
 		});
 	}
 	configured = true;
-	const effectiveWasm = options.wasm ? resolveWasmConfig(options.wasm) : void 0;
 	if (effectiveWasm) {
 		await warmupWasm(effectiveWasm);
 		await (await WasmUtilProvider.getInstance()).initialize({
@@ -469,6 +793,34 @@ async function initializeWasmUtil(config) {
 	});
 }
 /**
+* Replaces the active HTTP client with the WASM-backed one. Used when WASM is
+* loaded lazily (e.g. by the flow component) — `setup()` originally wired the
+* fetch/XHR client because no `wasm` was provided, and this swap upgrades to
+* `createWasmApi` once the WASM module is ready.
+*
+* No-op when no apiURL was originally configured, or when the active client is
+* already the WASM one.
+*
+* @param config - Optional WASM configuration. Defaults to the config stored via `setWasmConfig`.
+*/
+async function upgradeToWasmHttpClient(config) {
+	if (!storedHttpConfig) return;
+	if (storedHttpConfig.isWasm) return;
+	const wasmConfigToUse = config ?? wasmConfig;
+	if (!wasmConfigToUse) return;
+	const resolved = resolveWasmConfig(wasmConfigToUse);
+	setClient(await createWasmApi_default({
+		apiURL: storedHttpConfig.apiURL,
+		customHeaders: storedHttpConfig.customHeaders,
+		timeout: storedHttpConfig.timeout,
+		wasm: resolved
+	}));
+	storedHttpConfig = {
+		...storedHttpConfig,
+		isWasm: true
+	};
+}
+/**
 * Checks if the SDK has been configured.
 *
 * @returns true if setup() has been called, false otherwise
@@ -485,8 +837,9 @@ function reset() {
 	resetAnalyticsBatcher();
 	configured = false;
 	wasmConfig = void 0;
+	storedHttpConfig = 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 };
+export { setup as a, buildDefaultWasmConfig as c, setWasmConfig as i, resolveWasmConfig as l, isConfigured as n, upgradeToWasmHttpClient as o, reset as r, DEFAULT_WASM_VERSION as s, initializeWasmUtil as t };

package/dist/{setup-DKabjTK6.d.ts → setup-D3rE3N3K.d.ts}

@@ -113,6 +113,18 @@ declare function setWasmConfig(config: WasmConfig): void;
  * @throws Error if no config is provided and none is stored
  */
 declare function initializeWasmUtil(config?: WasmConfig): Promise<void>;
+/**
+ * Replaces the active HTTP client with the WASM-backed one. Used when WASM is
+ * loaded lazily (e.g. by the flow component) — `setup()` originally wired the
+ * fetch/XHR client because no `wasm` was provided, and this swap upgrades to
+ * `createWasmApi` once the WASM module is ready.
+ *
+ * No-op when no apiURL was originally configured, or when the active client is
+ * already the WASM one.
+ *
+ * @param config - Optional WASM configuration. Defaults to the config stored via `setWasmConfig`.
+ */
+declare function upgradeToWasmHttpClient(config?: WasmConfig): Promise<void>;
 /**
  * Checks if the SDK has been configured.
  *
@@ -124,4 +136,4 @@ declare function isConfigured(): boolean;
  */
 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 };
+export { reset as a, upgradeToWasmHttpClient as c, isConfigured as i, WasmConfig as n, setWasmConfig as o, initializeWasmUtil as r, setup as s, SetupOptions as t };

package/dist/wasm.d.ts

@@ -1,5 +1,5 @@
 import { n as WasmPipeline, r as warmupWasm, t as WarmupConfig } from "./warmup-DHGg8wQZ.js";
-import { n as WasmConfig, o as setWasmConfig, r as initializeWasmUtil } from "./setup-DKabjTK6.js";
+import { c as upgradeToWasmHttpClient, n as WasmConfig, o as setWasmConfig, r as initializeWasmUtil } from "./setup-D3rE3N3K.js";
 
 //#region ../infra/src/wasm/wasmDefaults.d.ts
 /** The WASM version bundled and tested with this SDK release. */
@@ -12,4 +12,4 @@ declare function buildDefaultWasmConfig(): WarmupConfig;
  */
 declare function resolveWasmConfig(overrides?: Partial<WarmupConfig>): WarmupConfig;
 //#endregion
-export { DEFAULT_WASM_VERSION, type WasmConfig, type WasmPipeline, buildDefaultWasmConfig, initializeWasmUtil, resolveWasmConfig, setWasmConfig, warmupWasm };
+export { DEFAULT_WASM_VERSION, type WasmConfig, type WasmPipeline, buildDefaultWasmConfig, initializeWasmUtil, resolveWasmConfig, setWasmConfig, upgradeToWasmHttpClient, warmupWasm };

package/dist/wasm.esm.js

@@ -1,12 +1,12 @@
-import { c as resolveWasmConfig, i as setWasmConfig, o as DEFAULT_WASM_VERSION, s as buildDefaultWasmConfig, t as initializeWasmUtil } from "./setup-DGSuf74f.esm.js";
-import { n as warmupWasm } from "./BaseWasmProvider-QTXpU_qs.esm.js";
-import "./WasmUtilProvider-Cj17GAox.esm.js";
+import { c as buildDefaultWasmConfig, i as setWasmConfig, l as resolveWasmConfig, o as upgradeToWasmHttpClient, s as DEFAULT_WASM_VERSION, t as initializeWasmUtil } from "./setup-B72ayX57.esm.js";
+import { n as warmupWasm } from "./BaseWasmProvider-C2cw9STp.esm.js";
+import "./WasmUtilProvider-B8VtGgvF.esm.js";
 import "./BrowserTimerProvider-BZGH3sYJ.esm.js";
 import "./api-eqRXuVG-.esm.js";
 import "./events-Bt1azl2B.esm.js";
 import "./endpoints-B3V1U9Dg.esm.js";
-import "./session-CsUswFcx.esm.js";
+import "./session-DPd529SS.esm.js";
 import "./IpifyProvider-ByL6JYxg.esm.js";
 import "./browserSimulation-CAH-V_iE.esm.js";
 
-export { DEFAULT_WASM_VERSION, buildDefaultWasmConfig, initializeWasmUtil, resolveWasmConfig, setWasmConfig, warmupWasm };
+export { DEFAULT_WASM_VERSION, buildDefaultWasmConfig, initializeWasmUtil, resolveWasmConfig, setWasmConfig, upgradeToWasmHttpClient, warmupWasm };