@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/{setup-CfNsYAeB.esm.js → setup-CYdVacqv.esm.js}

@@ -1,125 +1,18 @@
-import { i as warmupWasm, p as deriveSiblingJsPath, r as setWasmOnDeviceMode, t as WasmUtilProvider } from "./WasmUtilProvider-BgzcXBdl.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
-import { a as resetApi, i as isApiConfigured, n as getApi, r as getToken, t as api } from "./api-DsbUi7TO.esm.js";
-import { i as upgradeToWasmHttpClient, n as installFreshHttpClient, r as resetHttpClientState, t as getStoredHttpConfig } from "./clientLifecycle-VyzRfALg.esm.js";
-import { _ as getAnalyticsBatcher, h as createAnalyticsBatchingService, v as resetAnalyticsBatcher, y as setAnalyticsBatcher } from "./events-1wxZ97yf.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-BVy52wLy.esm.js";
-import { a as resetSessionInit, i as initializeSession, o as setClientFingerprintEnabled, s as setClientIpLookupEnabled } from "./sessionInitializer-Dj7-aJaP.esm.js";
-import { a as resetTRI, n as initializeTRI, o as resetTRIProviderInstance } from "./tri-CFAPtAUM.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.14.07-post7-post3";
-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 a WarmupConfig from a directory that mirrors the ml-wasm-kit CDN layout. */
-function buildWasmConfigFromBasePath(basePath) {
-	const base = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
-	return {
-		wasmPath: `${base}/webLib.wasm`,
-		wasmSimdPath: `${base}/webLibSimd.wasm`,
-		glueCodePath: `${base}/webLib.js`,
-		glueCodeSimdPath: `${base}/webLibSimd.js`,
-		modelsBasePath: `${base}/models`
-	};
-}
-/** Builds the standard WarmupConfig from the Incode CDN. */
-function buildDefaultWasmConfig() {
-	return buildWasmConfigFromBasePath(`${WASM_CDN_BASE_URL}/${DEFAULT_WASM_VERSION}`);
-}
-/**
-* 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) {
-	if (!overrides) return buildDefaultWasmConfig();
-	const defaults = buildWasmConfigFromBasePath(pickPath("basePath", overrides, `${WASM_CDN_BASE_URL}/${DEFAULT_WASM_VERSION}`));
-	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
+import { a as resolveWasmConfig } from "./wasmDefaults-DTUrftxR.esm.js";
+import { o as setWasmOnDeviceMode, r as WasmUtilProvider, s as warmupWasm } from "./safeStorage-Ep56I-f_.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { C as resetFeatureManagement, D as applyEnvironment, O as getEnvironment, S as optOutFeatureManagement, b as initializeFeatureManagement, c as resetResolvedExperiments, k as resetEnvironment, v as getIsFeatureManagementLocked, w as resetFeatureManagementProviderInstance } from "./feature-management-DS_Nj5Gg.esm.js";
+import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
+import { a as resetApi, i as isApiConfigured, n as getApi, r as getToken, s as setHttpRequestObserver, t as api } from "./api-Bx3gKW_y.esm.js";
+import { C as upgradeToWasmHttpClient$1, S as resetHttpClientState, b as getStoredHttpConfig, g as noteTestingSignals, l as trueSightLog, n as initializeTrueSightDiagnostics, o as resetTrueSight, t as finalizeTrueSight, u as categoryForEndpoint, x as installFreshHttpClient } from "./trueSightService-6dTpiaTh.esm.js";
+import { b as resetAnalyticsBatcher, c as resetExperimentAssignments, x as setAnalyticsBatcher, y as getAnalyticsBatcher } from "./events-CxfNJVZW.esm.js";
+import { a as resetSessionInit, d as resolveStandaloneFlowPolicy, f as setStandaloneFlowPolicy, i as initializeSession, l as registerFlowPreloader, o as setClientFingerprintEnabled, s as setClientIpLookupEnabled, u as resetStandaloneFlowPolicy, v as BrowserEnvironmentProvider } from "./sessionInitializer-CV6Rj_dn.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import "./trueSight-B8G85W4z.esm.js";
+import { r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
+import { a as resetTRI, n as initializeTRI, o as resetTRIProviderInstance } from "./tri-4RsGrIt6.esm.js";
+import { n as preloadDashboardFlow, r as resetDashboardFlowCache } from "./flowServices-unhF9V9F.esm.js";
 //#region ../infra/src/providers/browser/BrowserPageLifecycleProvider.ts
 var BrowserPageLifecycleProvider = class {
 	sendBeacon(url, body, contentType = "application/json") {
@@ -141,7 +34,201 @@ var BrowserPageLifecycleProvider = class {
 		};
 	}
 };
-
+//#endregion
+//#region src/internal/events/AnalyticsBatchingService.ts
+const DEFAULT_MAX_BATCH_SIZE = 50;
+const DEFAULT_MAX_BATCH_AGE_MS = 1e3;
+const DEFAULT_MAX_RETRIES = 2;
+const RETRY_BASE_DELAY_MS = 250;
+function isTransientStatus(status) {
+	return status === 0 || status >= 500 || status === 408 || status === 429;
+}
+function createAnalyticsBatchingService(options) {
+	const { endpoint, authToken, pageLifecycle, timer, apiBaseUrl, apiClient = api, maxBatchSize = DEFAULT_MAX_BATCH_SIZE, maxBatchAgeMs = DEFAULT_MAX_BATCH_AGE_MS, maxRetries = DEFAULT_MAX_RETRIES } = options;
+	let buffer = [];
+	let started = false;
+	let disposed = false;
+	let ageTimerHandle = null;
+	let unsubscribeLifecycle = null;
+	let warnedNullToken = false;
+	function clearAgeTimer() {
+		if (ageTimerHandle !== null) {
+			timer.clearTimeout(ageTimerHandle);
+			ageTimerHandle = null;
+		}
+	}
+	function armAgeTimerIfNeeded() {
+		if (ageTimerHandle === null) ageTimerHandle = timer.setTimeout(() => {
+			ageTimerHandle = null;
+			flush();
+		}, maxBatchAgeMs);
+	}
+	function dropTokenless() {
+		if (!warnedNullToken) {
+			warnedNullToken = true;
+			console.warn("[AnalyticsBatchingService] Dropping batch: no auth token at flush time.");
+		}
+	}
+	function sendBatch(batch, attempt) {
+		let promise;
+		try {
+			promise = apiClient.post(endpoint, batch, { keepalive: true });
+		} catch (error) {
+			handleSendError(batch, error, attempt);
+			return;
+		}
+		promise.catch((error) => handleSendError(batch, error, attempt));
+	}
+	function handleSendError(batch, error, attempt) {
+		if (disposed) return;
+		if (!isTransientStatus(error && typeof error === "object" && "status" in error ? Number(error.status) || 0 : 0)) return;
+		if (attempt >= maxRetries) return;
+		const delay = RETRY_BASE_DELAY_MS * 2 ** attempt;
+		timer.setTimeout(() => {
+			if (disposed) return;
+			sendBatch(batch, attempt + 1);
+		}, delay);
+	}
+	function flush() {
+		if (disposed || buffer.length === 0) return;
+		const batch = buffer;
+		buffer = [];
+		clearAgeTimer();
+		if (!authToken()) {
+			dropTokenless();
+			return;
+		}
+		sendBatch(batch, 0);
+	}
+	function handlePageHide() {
+		if (disposed || buffer.length === 0) return;
+		const batch = buffer;
+		buffer = [];
+		clearAgeTimer();
+		const token = authToken();
+		if (!token) {
+			dropTokenless();
+			return;
+		}
+		const url = `${apiBaseUrl().replace(/\/$/, "")}${endpoint}`;
+		const body = JSON.stringify({
+			token,
+			events: batch
+		});
+		pageLifecycle.sendBeacon(url, body);
+	}
+	function enqueue(entry) {
+		if (disposed) return;
+		buffer.push(entry);
+		if (!started) return;
+		if (buffer.length >= maxBatchSize) {
+			flush();
+			return;
+		}
+		armAgeTimerIfNeeded();
+	}
+	function start() {
+		if (started || disposed) return;
+		started = true;
+		unsubscribeLifecycle = pageLifecycle.onPageHide(handlePageHide);
+		if (buffer.length > 0) flush();
+	}
+	function dispose() {
+		if (disposed) return;
+		disposed = true;
+		clearAgeTimer();
+		unsubscribeLifecycle?.();
+		unsubscribeLifecycle = null;
+		buffer = [];
+	}
+	return {
+		enqueue,
+		start,
+		flush,
+		dispose
+	};
+}
+//#endregion
+//#region src/internal/recordings/videoSelfieUploadService.ts
+/**
+* Origin of the dedicated video-selfie-service (e.g.
+* `https://video-selfie-service.stage.incodetest.com`), set from
+* `setup({ videoSelfie: { apiURL } })`. Testing/special-env override: when
+* unset (production), the upload endpoints resolve against the main `apiURL`
+* and the service mesh (Istio) routes them to the service. The service
+* accepts the same session token; the shared `api` client attaches it either
+* way.
+*/
+let serviceBaseUrl = null;
+function setVideoSelfieServiceUrl(url) {
+	let trimmed = url ?? "";
+	while (trimmed.endsWith("/")) trimmed = trimmed.slice(0, -1);
+	serviceBaseUrl = trimmed || null;
+}
+function uploadUrl(path) {
+	return serviceBaseUrl ? `${serviceBaseUrl}${path}` : path;
+}
+/**
+* Opens a multipart video-selfie upload session. Idempotent server-side: if
+* an upload is already in progress for the session, the same `uploadId`
+* comes back along with the parts already stored (`parts` non-empty) — but
+* always with a fresh `epoch` that locks out whoever held the previous one.
+*/
+async function initiateVideoSelfieUpload() {
+	const response = await api.post(uploadUrl(endpoints.videoSelfieUploadInitiate));
+	return {
+		uploadId: response.data.uploadId,
+		epoch: response.data.epoch,
+		parts: response.data.parts ?? []
+	};
+}
+/**
+* Uploads a single chunk as a multipart part. The body is the raw video bytes
+* (no base64, no client-side encryption — encryption at rest is server-side
+* S3 SSE). Every part except the last must be >= 5 MiB (enforced
+* server-side). Returns the part number + `etag` needed to complete the
+* upload. Rejects with a `409` status when a newer initiate fenced this
+* session out.
+*/
+async function uploadVideoSelfiePart(session, partNumber, chunk) {
+	const response = await api.post(uploadUrl(endpoints.videoSelfieUploadPart), chunk, {
+		query: {
+			uploadId: session.uploadId,
+			epoch: session.epoch,
+			partNumber
+		},
+		headers: { "Content-Type": "application/octet-stream" }
+	});
+	return {
+		partNumber: response.data.partNumber,
+		etag: response.data.etag
+	};
+}
+/**
+* Finalizes the upload. The service assembles from the parts it stored; the
+* optional `parts` list is deliberately NOT sent — chunks staged below the
+* S3 minimum are combined and renumbered server-side, so a client-side list
+* could contradict the authoritative one. Safe to repeat if the response
+* was lost. Returns the server-reported status. Rejects with `400` naming a
+* missing part when the sequence has a hole.
+*/
+async function completeVideoSelfieUpload(session) {
+	return (await api.post(uploadUrl(endpoints.videoSelfieUploadComplete), {
+		uploadId: session.uploadId,
+		epoch: session.epoch
+	})).data.status;
+}
+/**
+* Discards an in-progress upload and everything already sent for it, so the
+* backend fails the upload straight away instead of waiting for its expiry.
+* Call when a recording is abandoned or its upload can no longer complete.
+*/
+async function abortVideoSelfieUpload(session) {
+	return (await api.post(uploadUrl(endpoints.videoSelfieUploadAbort), {
+		uploadId: session.uploadId,
+		epoch: session.epoch
+	})).data.status;
+}
 //#endregion
 //#region ../infra/src/providers/browser/DevtoolsDetectorProvider.ts
 var DevtoolsDetectorProvider = class {
@@ -229,7 +316,6 @@ onmessage = (ev) => { postMessage({isOpenBeat:true});
 		}
 	}
 };
-
 //#endregion
 //#region src/internal/device/devtoolsDetectorBridge.ts
 const devtoolsDetector = new DevtoolsDetectorProvider();
@@ -255,7 +341,6 @@ function startDevtoolsDetector() {
 function stopDevtoolsDetector() {
 	devtoolsDetector.stop();
 }
-
 //#endregion
 //#region src/setup.ts
 let wasmConfig;
@@ -287,6 +372,44 @@ function normalizeEncryption(input) {
 }
 let configured = false;
 /**
+* One-line environment facts for TrueSight's snapshot-on-first-error entry
+* (navigator facts read through the L0 provider — core never touches
+* browser globals directly).
+*/
+function buildEnvironmentSnapshot() {
+	const environment = new BrowserEnvironmentProvider();
+	const read = (property) => {
+		try {
+			return environment.getNavigatorProperty(property);
+		} catch {
+			return;
+		}
+	};
+	const connection = read("connection");
+	return [
+		`connection=${typeof connection?.effectiveType === "string" ? connection.effectiveType : "unknown"}`,
+		`saveData=${connection?.saveData === true}`,
+		`online=${read("onLine") !== false}`,
+		`language=${typeof read("language") === "string" ? String(read("language")) : "unknown"}`
+	].join(" ");
+}
+/**
+* ENG-48677 event map row 23b: every Incode HTTP request, success or
+* failure, becomes a self-health line (Android-dashboard parity). Lives here
+* rather than in `api.ts` — `trueSightService` already imports from that
+* module, so a direct `trueSightLog` import there would cycle; `setup()`
+* wires this adapter in as the decoupled observer instead.
+*/
+function logHttpRequestTiming(entry) {
+	const category = categoryForEndpoint(entry.endpoint);
+	const status = entry.httpStatus ?? "unknown";
+	if (entry.outcome === "success") {
+		trueSightLog("debug", "http", category, `http request completed endpoint=${entry.endpoint} method=${entry.method} httpStatus=${status} durationMs=${entry.durationMs}`);
+		return;
+	}
+	trueSightLog("error", "http", category, `http request failed endpoint=${entry.endpoint} method=${entry.method} httpStatus=${status} durationMs=${entry.durationMs}`);
+}
+/**
 * Initializes the SDK with the provided configuration.
 * Must be called before using any SDK functionality.
 *
@@ -423,11 +546,17 @@ let configured = false;
 * ```
 */
 async function setup(options) {
+	const standaloneFlowPolicy = resolveStandaloneFlowPolicy(options.flow);
+	const flowOptions = typeof options.flow === "object" ? options.flow : {};
+	const shouldPreloadFlow = options.flow !== false && flowOptions.preload === true;
+	setStandaloneFlowPolicy(standaloneFlowPolicy);
+	registerFlowPreloader(preloadDashboardFlow);
 	if (options.ipLookup !== void 0) setClientIpLookupEnabled(options.ipLookup);
 	if (options.fingerprint !== void 0) {
 		setClientFingerprintEnabled(options.fingerprint);
 		setWasmOnDeviceMode(options.fingerprint === false);
 	}
+	if (options.videoSelfie?.apiURL !== void 0) setVideoSelfieServiceUrl(options.videoSelfie.apiURL);
 	if (!getAnalyticsBatcher()) setAnalyticsBatcher(createAnalyticsBatchingService({
 		endpoint: endpoints.events,
 		authToken: () => getToken(),
@@ -436,6 +565,18 @@ async function setup(options) {
 		pageLifecycle: new BrowserPageLifecycleProvider(),
 		timer: BrowserTimerProvider.getInstance()
 	}));
+	initializeTrueSightDiagnostics({
+		enabled: options.trueSight?.enabled !== false,
+		pageLifecycle: new BrowserPageLifecycleProvider(),
+		timer: BrowserTimerProvider.getInstance(),
+		storage: new BrowserStorageProvider(),
+		getEnvironmentSnapshot: buildEnvironmentSnapshot
+	});
+	noteTestingSignals({
+		devMode: options.devMode,
+		apiUrl: options.apiURL
+	});
+	setHttpRequestObserver(logHttpRequestTiming);
 	const requestedEncryption = normalizeEncryption(options.encryption);
 	const stored = getStoredHttpConfig();
 	if (requestedEncryption && stored) {
@@ -447,20 +588,39 @@ async function setup(options) {
 		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);
-	});
+	if (options.apiURL) try {
+		await installFreshHttpClient(options.apiURL, options, effectiveWasm, effectiveEncryption);
+	} catch (error) {
+		trueSightLog("severe", "http", "other", `http client install failed error=${String(error)}`);
+		throw error;
+	}
+	if (options.token && isApiConfigured()) {
+		const sessionOptions = {
+			token: options.token,
+			hostingApp: options.hostingApp
+		};
+		if (shouldPreloadFlow) sessionOptions.preloadFlow = true;
+		const sessionPromise = initializeSession(sessionOptions);
+		if (shouldPreloadFlow) await sessionPromise;
+		else sessionPromise.catch((error) => {
+			console.warn("Session initialization failed:", error);
+		});
+	}
 	configured = true;
+	applyEnvironment(options.environment);
 	if (effectiveWasm) {
 		wasmConfig = {
 			...effectiveWasm,
 			pipelines: effectiveWasm.pipelines ? [...effectiveWasm.pipelines] : void 0
 		};
-		await warmupWasm(effectiveWasm);
+		const warmupStartedAt = getTimestamp();
+		try {
+			await warmupWasm(effectiveWasm);
+		} catch (error) {
+			trueSightLog("severe", "wasm", "other", `wasm warmup failed error=${String(error)} durationMs=${getTimestamp() - warmupStartedAt}`);
+			throw error;
+		}
+		trueSightLog("debug", "wasm", "other", `wasm warmup completed durationMs=${getTimestamp() - warmupStartedAt}`);
 		const provider = await WasmUtilProvider.getInstance();
 		await provider.initialize({
 			...effectiveWasm,
@@ -470,6 +630,19 @@ async function setup(options) {
 		await provider.setProductionMode(!showWasmLogs);
 		if (!options.devMode) startDevtoolsDetector();
 	}
+	if (!getIsFeatureManagementLocked()) if (options.featureManagement === false) optOutFeatureManagement();
+	else {
+		const featureManagementSetupOptions = typeof options.featureManagement === "object" ? options.featureManagement : {};
+		await initializeFeatureManagement({
+			environment: getEnvironment(),
+			clientExperimentId: featureManagementSetupOptions.clientExperimentId,
+			disableStableId: featureManagementSetupOptions.disableStableId,
+			disablePersistence: featureManagementSetupOptions.disablePersistence,
+			custom: featureManagementSetupOptions.custom,
+			redactedUserInfo: featureManagementSetupOptions.redactedUserInfo
+		});
+	}
+	else if (options.featureManagement !== void 0) console.error("[FeatureManagement] Feature management is locked after the first setup() call and cannot be changed (re-enabled, disabled, or reconfigured). Ignoring this change. Call reset() before changing it.");
 	if (options.tri) await initializeTRI(options.tri, { sessionToken: options.token });
 }
 /**
@@ -531,10 +704,10 @@ async function ensureWasmPipelines(pipelines) {
 *
 * @param config - Optional WASM configuration. Defaults to the config stored via `setWasmConfig`.
 */
-async function upgradeToWasmHttpClient$1(config) {
+async function upgradeToWasmHttpClient(config) {
 	const configToUse = config ?? wasmConfig;
 	if (!configToUse) return;
-	await upgradeToWasmHttpClient(resolveWasmConfig(configToUse));
+	await upgradeToWasmHttpClient$1(resolveWasmConfig(configToUse));
 }
 /**
 * Checks if the SDK has been configured.
@@ -548,21 +721,30 @@ function isConfigured() {
 * Resets the SDK configuration. Useful for testing.
 */
 function reset() {
+	finalizeTrueSight("failure", "sdk_reset");
 	stopDevtoolsDetector();
 	resetDeviceStatsQueue();
 	resetApi();
 	resetSessionInit();
+	resetDashboardFlowCache();
+	resetStandaloneFlowPolicy();
 	setClientIpLookupEnabled(true);
 	setClientFingerprintEnabled(true);
 	setWasmOnDeviceMode(false);
+	setVideoSelfieServiceUrl(null);
 	resetAnalyticsBatcher();
+	resetExperimentAssignments();
+	resetResolvedExperiments();
 	resetHttpClientState();
 	resetTRI();
 	configured = false;
 	wasmConfig = void 0;
 	WasmUtilProvider.resetInstance();
 	resetTRIProviderInstance();
+	resetFeatureManagement();
+	resetFeatureManagementProviderInstance();
+	resetEnvironment();
+	resetTrueSight();
 }
-
 //#endregion
-export { setWasmConfig as a, DEFAULT_WASM_VERSION as c, resolveWasmConfig as d, reset as i, buildDefaultWasmConfig as l, initializeWasmUtil as n, setup as o, isConfigured as r, upgradeToWasmHttpClient$1 as s, ensureWasmPipelines as t, buildWasmConfigFromBasePath as u };
+export { setWasmConfig as a, abortVideoSelfieUpload as c, uploadVideoSelfiePart as d, reset as i, completeVideoSelfieUpload as l, initializeWasmUtil as n, setup as o, isConfigured as r, upgradeToWasmHttpClient as s, ensureWasmPipelines as t, initiateVideoSelfieUpload as u };