@incodetech/core 2.3.2 → 2.4.0-rc.1

package/dist/{warmup-ChDwHSel.esm.js → warmup-BElYWRh7.esm.js}

@@ -1,4 +1,5 @@
-import { _ as WASM_PIPELINE_OPTIONAL_MODEL_NAMES, b as resolveWasmSource, d as SemaphoreProvider, h as WASM_PIPELINE_MODELS, l as loadWasmModule, n as createWebApiHostAdapter, p as WASM_MODEL_FILES, u as acquireWasmStorageFallback, v as buildModelVariantSources, y as missingWasmModelError } from "./wasmWebClient-B7baE-Wf.esm.js";
+import { A as buildModelVariantSources, C as isDefaultCdnWasmConfig, D as WASM_PIPELINE_MODELS, M as resolveWasmSource, N as reportWasmIntegritySummary, T as WASM_MODEL_FILES, f as rearmWasmCallDiagnostics, g as emitWasmDiagnostic, h as acquireWasmStorageFallback, j as missingWasmModelError, k as WASM_PIPELINE_OPTIONAL_MODEL_NAMES, l as notePipelineStatePulled, m as loadWasmModule, n as createWebApiHostAdapter, p as resetWasmCallDiagnostics, v as SemaphoreProvider, y as DEFAULT_WASM_VERSION } from "./wasmWebClient-BjZw_7OB.esm.js";
+import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
 //#region ../infra/src/wasm/wasmEnumMaps.ts
 function pipelineTypeToWasmEnum(wasmModule, type) {
 	switch (type) {
@@ -45,6 +46,280 @@ function idCaptureModelTypeFromWasmEnum(wasmModule, type) {
 	}
 }
 //#endregion
+//#region ../infra/src/wasm/diagnosticsSink.ts
+/**
+* Receiver for the in-binary TrueSight diagnostics sensor (ENG-48677 WS2,
+* ml-wasm-kit #569, shipped in v2.14.52).
+*
+* Seam contract v1: the kit calls the sink SYNCHRONOUSLY from C++ call sites
+* with a JSON string
+*   `{"v":1,"tLast":<elapsedMs>,"entries":[{t,l,c,sub,msg,n}]}`
+* where `t`/`tLast` share the kit logger's start-time anchor, `l` is
+* `"E"|"W"|"I"`, and the tag is split into `c`/`sub` on its first dot. The
+* handler is enqueue-only: it never calls back into WASM and never throws
+* into the kit (the SDK registers on the raw embind handle, so the kit's own
+* JS wrapper guard does not apply).
+*
+* The mode is a property of the binary, detected at install:
+* - `sink` — `setDiagnosticsSink` exists (v2.14.52+): batches are pushed,
+*   and finalize drains the unsent tail via `drainDiagnostics`.
+* - `fallback` — only `getAppLogs` exists (the pinned v2.14.50-post1): the
+*   plain-text `ClientLogger::render()` grammar (optional leading
+*   `... <k> dropped`, then `+<elapsedMs> <E|W|I> <tag>: <msg>[ (xN)]`) is
+*   parsed at finalize. Nothing in v2.14.50-post1 writes that logger, so in
+*   practice it is empty until the bump.
+* - `none` — neither binding.
+* No TrueSight change is needed when `DEFAULT_WASM_VERSION` moves past the
+* sensor release: the next install simply detects `sink`.
+*/
+const SUBSYSTEM_MAX_CHARS = 40;
+const LAST_ERROR_CLAMP_CHARS = 300;
+/** Below this parsed/candidate ratio the fallback degrades to count + last error. */
+const FALLBACK_MIN_PARSE_RATIO = .7;
+/** Anchor sanity bound: computed times further out than this use receipt time. */
+const MAX_CLOCK_SKEW_MS = 1440 * 60 * 1e3;
+const APP_LOGS_DROPPED_RE = /^\.\.\. (\d+) dropped$/;
+const APP_LOGS_LINE_RE = /^\+(\d+) ([EWI]) (.+?): (.*)$/;
+const DEDUP_SUFFIX_RE = / \(x(\d+)\)$/;
+/**
+* Kit tag (`c.sub`) → TrueSight category. The kit's tag vocabulary is its
+* own (`camera.cycle`, `pipeline.core`, `bridge`, …), so only the
+* capture-pipeline tags map to a scan category; everything else is `other`.
+*/
+const KIT_TAG_CATEGORIES = {
+	"pipeline.id": "idScan",
+	"pipeline.barcode": "idScan",
+	"pipeline.face": "faceScan",
+	"pipeline.selfie": "faceScan",
+	"pipeline.liveness": "faceScan"
+};
+/** The kit's eviction marker: `{c:"diag",sub:"logger",msg:"dropped",n:k}`. */
+const DROPPED_SUBSYSTEM = "diag.logger";
+let mode = null;
+let boundApi = null;
+let sessionEpochMs = null;
+let lastSeenRelativeMs = 0;
+/** Fallback: `getAppLogs` re-renders the whole ring, so emit only newer lines. */
+let fallbackWatermarkMs = -1;
+let unsupportedVersionNoted = false;
+let batchParseFailureNoted = false;
+/** Drains run at every snapshot rebuild, so the degraded note is per session. */
+let fallbackDegradedNoted = false;
+function toCategory(category, sub) {
+	return KIT_TAG_CATEGORIES[`${category}.${sub}`] ?? "other";
+}
+function toLevel(value) {
+	switch (value) {
+		case "E": return "error";
+		case "W": return "warning";
+		case "I": return "info";
+		default: return "debug";
+	}
+}
+/** The `wasm.` prefix comes from the core handler; this builds the dotted tail. */
+function toSubsystem(category, sub) {
+	const cleaned = `${category}${sub !== "" ? `.${sub}` : ""}`.replace(/[^\w.-]/g, "").slice(0, SUBSYSTEM_MAX_CHARS);
+	return cleaned === "" ? "kit" : cleaned;
+}
+function absoluteTimestampMs(relativeMs, receivedAtMs) {
+	if (sessionEpochMs === null || !Number.isFinite(relativeMs)) return receivedAtMs;
+	const computed = sessionEpochMs + relativeMs;
+	if (computed > receivedAtMs || receivedAtMs - computed > MAX_CLOCK_SKEW_MS) return receivedAtMs;
+	return computed;
+}
+function emitKitEntry(level, category, sub, message, count, timestampMs) {
+	const subsystem = toSubsystem(category, sub);
+	const dropped = subsystem === DROPPED_SUBSYSTEM && message === "dropped";
+	emitWasmDiagnostic({
+		level,
+		subsystem,
+		category: toCategory(category, sub),
+		message: dropped ? `dropped entries=${count}` : count > 1 ? `${message} (x${count})` : message,
+		timestampMs
+	});
+}
+function processBatch(batch, receivedAtMs) {
+	if (typeof batch !== "string" || batch === "") return;
+	let decoded;
+	try {
+		decoded = JSON.parse(batch);
+	} catch {
+		if (!batchParseFailureNoted) {
+			batchParseFailureNoted = true;
+			emitWasmDiagnostic({
+				level: "warning",
+				subsystem: "sink",
+				category: "other",
+				message: `batch parse failed len=${batch.length}`
+			});
+		}
+		return;
+	}
+	if (decoded === null || typeof decoded !== "object") return;
+	const record = decoded;
+	if (record.v !== 1) {
+		if (!unsupportedVersionNoted) {
+			unsupportedVersionNoted = true;
+			emitWasmDiagnostic({
+				level: "warning",
+				subsystem: "sink",
+				category: "other",
+				message: `unsupported batch v=${String(record.v)}`
+			});
+		}
+		return;
+	}
+	const tLast = typeof record.tLast === "number" ? record.tLast : 0;
+	if (sessionEpochMs === null) sessionEpochMs = receivedAtMs - tLast;
+	else if (tLast < lastSeenRelativeMs) {
+		sessionEpochMs = receivedAtMs - tLast;
+		emitWasmDiagnostic({
+			level: "info",
+			subsystem: "sink",
+			category: "other",
+			message: "re-anchored"
+		});
+	}
+	lastSeenRelativeMs = tLast;
+	if (!Array.isArray(record.entries)) return;
+	for (const raw of record.entries) {
+		if (raw === null || typeof raw !== "object") continue;
+		const entry = raw;
+		const message = typeof entry.msg === "string" ? entry.msg : "";
+		if (message === "") continue;
+		emitKitEntry(toLevel(entry.l), typeof entry.c === "string" ? entry.c : "", typeof entry.sub === "string" ? entry.sub : "", message, typeof entry.n === "number" && entry.n > 1 ? entry.n : 1, absoluteTimestampMs(typeof entry.t === "number" ? entry.t : NaN, receivedAtMs));
+	}
+}
+/** The value handed to the kit's `setDiagnosticsSink` — never throws. */
+function receiveBatch(batch) {
+	try {
+		processBatch(batch, getTimestamp());
+	} catch {}
+}
+function parseAppLogsText(text, receivedAtMs) {
+	if (text === "") return;
+	const lines = text.split("\n");
+	const dropped = lines[0]?.match(APP_LOGS_DROPPED_RE);
+	if (dropped) lines.shift();
+	const candidates = lines.filter((line) => line !== "");
+	const parsed = [];
+	for (const line of candidates) {
+		const match = line.match(APP_LOGS_LINE_RE);
+		if (!match) continue;
+		const dedup = match[4].match(DEDUP_SUFFIX_RE);
+		parsed.push({
+			elapsedMs: Number(match[1]),
+			level: toLevel(match[2]),
+			tag: match[3],
+			message: dedup ? match[4].slice(0, -dedup[0].length) : match[4],
+			count: dedup ? Number(dedup[1]) : 1
+		});
+	}
+	const maxElapsedMs = parsed.reduce((max, line) => Math.max(max, line.elapsedMs), 0);
+	if (maxElapsedMs < fallbackWatermarkMs) fallbackWatermarkMs = -1;
+	const fresh = parsed.filter((line) => line.elapsedMs > fallbackWatermarkMs);
+	if (dropped && fresh.length > 0) emitKitEntry("warning", "diag", "logger", "dropped", Number(dropped[1]), receivedAtMs);
+	if (candidates.length > 0 && parsed.length / candidates.length < FALLBACK_MIN_PARSE_RATIO) {
+		if (fallbackDegradedNoted) return;
+		fallbackDegradedNoted = true;
+		emitWasmDiagnostic({
+			level: "warning",
+			subsystem: "sink",
+			category: "other",
+			message: `fallback drain unparsed lines=${candidates.length} parsed=${parsed.length}`
+		});
+		const lastError = candidates.filter((line) => /^\+\d+ E /.test(line)).pop();
+		if (lastError !== void 0) emitWasmDiagnostic({
+			level: "error",
+			subsystem: "sink",
+			category: "other",
+			message: `last error: ${lastError.slice(0, LAST_ERROR_CLAMP_CHARS)}`
+		});
+		return;
+	}
+	const drainT0 = receivedAtMs - maxElapsedMs;
+	for (const line of fresh) {
+		const dotIndex = line.tag.indexOf(".");
+		emitKitEntry(line.level, dotIndex === -1 ? line.tag : line.tag.slice(0, dotIndex), dotIndex === -1 ? "" : line.tag.slice(dotIndex + 1), line.message, line.count, drainT0 + line.elapsedMs);
+	}
+	fallbackWatermarkMs = Math.max(fallbackWatermarkMs, maxElapsedMs);
+}
+function emitModeLine() {
+	emitWasmDiagnostic({
+		level: "info",
+		subsystem: "sink",
+		category: "other",
+		message: `diagnostics mode=${mode ?? "none"} pinnedVersion=${DEFAULT_WASM_VERSION}`
+	});
+}
+/**
+* Feature-detects the binary's diagnostics surface and, in sink mode,
+* registers the push callback. Called from `WasmRuntime.initialize()` right
+* after the UtilityApi exists, so even startup errors are pushed.
+* Re-registering is idempotent on the kit side (a process-wide bridge).
+*/
+function installWasmDiagnosticsSink(utilityApi) {
+	boundApi = utilityApi;
+	if (typeof utilityApi.setDiagnosticsSink === "function") {
+		mode = "sink";
+		try {
+			utilityApi.setDiagnosticsSink(receiveBatch);
+		} catch {}
+	} else if (typeof utilityApi.getAppLogs === "function") mode = "fallback";
+	else mode = "none";
+	emitModeLine();
+	return mode;
+}
+/**
+* Pulls whatever the kit has not delivered yet into the record. Invoked
+* synchronously by TrueSight before it builds any record — the terminal and
+* every interrupted snapshot — so it runs many times per session and stays
+* idempotent: a drain with nothing new emits nothing. The runtime outlives
+* `reset()`, so it keeps running for every later session on the page.
+*
+* Delivery is at most once. The kit marks entries sent as it hands them
+* over, so nothing is ever duplicated, but a batch the kit pushes while no
+* session collects (between `reset()` and the next `setup()`) is lost, and
+* kit lines logged after a session finalized ride the next session's record.
+*/
+function drainWasmDiagnostics() {
+	if (boundApi === null) return;
+	try {
+		if (mode === "sink" && typeof boundApi.drainDiagnostics === "function") processBatch(boundApi.drainDiagnostics(), getTimestamp());
+		else if (mode === "fallback" && typeof boundApi.getAppLogs === "function") parseAppLogsText(boundApi.getAppLogs(), getTimestamp());
+	} catch {}
+}
+/**
+* Starts a new SDK session's view of an already-running runtime: per-session
+* budgets re-arm, and the mode line is repeated so each record states it.
+* Called from `setup()`; a no-op for the mode line before the first install.
+*/
+function rearmWasmDiagnostics() {
+	rearmWasmCallDiagnostics();
+	unsupportedVersionNoted = false;
+	batchParseFailureNoted = false;
+	fallbackDegradedNoted = false;
+	if (mode !== null) emitModeLine();
+}
+/**
+* Runtime teardown (`WasmRuntime.freeResources()`). The kit's sink stays
+* registered in its process-wide bridge; the next install re-registers it.
+*/
+function resetWasmDiagnosticsSink() {
+	mode = null;
+	boundApi = null;
+	sessionEpochMs = null;
+	lastSeenRelativeMs = 0;
+	fallbackWatermarkMs = -1;
+	unsupportedVersionNoted = false;
+	batchParseFailureNoted = false;
+	fallbackDegradedNoted = false;
+}
+/** The detected mode, or `null` before the runtime installed the receiver. */
+function getWasmDiagnosticsMode() {
+	return mode;
+}
+//#endregion
 //#region ../infra/src/wasm/CameraCycleOwnershipDomain.ts
 const CAMERA_CYCLE_OWNERSHIP_DOMAIN = Symbol("cameraCycleOwnershipDomain");
 var CameraCycleOwnershipDomain = class {
@@ -120,6 +395,9 @@ function deleteWasmHandle(firstFailure, handle) {
 function releaseCameraCycleResources(stream, cameraCycleApi) {
 	return attemptCleanup(stopStreamTracks(stream), () => cameraCycleApi?.rcc());
 }
+function isWasmModelEntry(source) {
+	return typeof source === "object" && !(source instanceof ArrayBuffer) && !(source instanceof Uint8Array) && "file" in source;
+}
 var WasmRuntime = class WasmRuntime {
 	constructor(loadModule = loadWasmModule) {
 		this.loadModule = loadModule;
@@ -153,6 +431,8 @@ var WasmRuntime = class WasmRuntime {
 			this.usedSimd_ = simdUsed;
 			this.workflowApiUtilities = new this.wasmModule.WorkflowApiUtilities();
 			this.utilityApi = new this.wasmModule.UtilityApi();
+			this.utilityApi.setProductionMode(module.showLogs !== true);
+			installWasmDiagnosticsSink(this.utilityApi);
 			this.idCaptureWasmApi = new this.wasmModule.IdCaptureApi();
 			this.faceProcessingWasmApi = new this.wasmModule.FaceProcessingApi();
 			this.cameraCycleApi = new this.wasmModule.CameraCycleApi();
@@ -237,6 +517,8 @@ var WasmRuntime = class WasmRuntime {
 		this.pipelines_ = null;
 		this.isInitialized_ = false;
 		if (typeof window !== "undefined") window.wasmArrayBuffer = null;
+		resetWasmCallDiagnostics();
+		resetWasmDiagnosticsSink();
 		let firstFailure = releaseCameraCycleResources(stream, cameraCycleApi);
 		firstFailure = deleteWasmHandle(firstFailure, modelsBuffers);
 		firstFailure = deleteWasmHandle(firstFailure, workflowApiUtilities);
@@ -301,10 +583,14 @@ var WasmRuntime = class WasmRuntime {
 				const sizes = new (this.requireWasmModule(message)).VectorInt();
 				sizeVectors.push(sizes);
 				for (const path of modelsPaths) {
-					const resolvedSource = this.resolveModelSource(path);
+					const file = isWasmModelEntry(path) ? path.file : void 0;
+					const resolvedSource = this.resolveModelSource(isWasmModelEntry(path) ? path.source : path);
 					let model = this.loadedModels.get(resolvedSource);
 					if (!model) {
-						model = await resolveWasmSource(resolvedSource, "model");
+						model = await resolveWasmSource(resolvedSource, {
+							kind: "model",
+							file
+						});
 						this.loadedModels.set(resolvedSource, model);
 					}
 					sizes.push_back(model.byteLength);
@@ -346,7 +632,9 @@ var WasmRuntime = class WasmRuntime {
 		this.requireWorkflowApiUtilities(message).initializeWorkflows();
 	}
 	getPipelineState() {
-		return this.requireWorkflowApiUtilities("Unable to get pipeline state, cpp API hasn't been initialized").getWorkflowState();
+		const state = this.requireWorkflowApiUtilities("Unable to get pipeline state, cpp API hasn't been initialized").getWorkflowState();
+		notePipelineStatePulled();
+		return state;
 	}
 	getCurrentPipeline() {
 		const workflowApiUtilities = this.requireWorkflowApiUtilities("Unable to get current pipeline, cpp API hasn't been initialized");
@@ -477,6 +765,7 @@ let wasmError = null;
 let loadedPipelines = [];
 let lastConfig = null;
 let lastModelVariant = null;
+let warmupFacts = null;
 let pipelinesInFlight = [];
 function mapPipelineToWasmType(pipeline) {
 	switch (pipeline) {
@@ -526,16 +815,22 @@ function resolveConfiguredModelSource(config, modelFile, pipeline, modelsBasePat
 	if (current === void 0) {
 		if (config.selfHosted) throw missingWasmModelError(modelFile, pipeline);
 		if (!modelsBasePath) throw new Error("[Incode SDK] modelsBasePath is required when wasmPath is a byte source.");
-		return buildModelVariantSources(modelsBasePath, modelFile);
+		return {
+			file: modelFile,
+			source: buildModelVariantSources(modelsBasePath, modelFile)
+		};
 	}
 	const legacy = config.legacyModelUrls?.[modelFile];
-	return legacy === void 0 ? current : {
-		current,
-		legacy
+	return {
+		file: modelFile,
+		source: legacy === void 0 ? current : {
+			current,
+			legacy
+		}
 	};
 }
 /**
-* Warns once per warmup that an optional model listed in
+* When logging is enabled, warns once per warmup that an optional model listed in
 * {@link WASM_PIPELINE_OPTIONAL_MODEL_NAMES} was not supplied, so the Core
 * profile that needs it is skipped instead of failing the whole warmup.
 */
@@ -565,13 +860,31 @@ function buildPipelinesMap(pipelines, config) {
 					WASM_MODEL_FILES.idFiqa,
 					WASM_MODEL_FILES.idFaceDetector
 				]));
-				else warnMissingOptionalModel(pipeline, missingOptional);
+				else if (config.showLogs) warnMissingOptionalModel(pipeline, missingOptional);
 			}
 		}
 	}
 	return pipelinesMap;
 }
 /**
+* Row 31 taps (ENG-48677 WS2): every warmup origin — `setup()` pre-warm and
+* the lazy UI init paths — funnels through `warmupWasm`, so start / complete /
+* fail lines here also surface the UI-side `.catch(console.error)` swallows.
+* The pinned version rides in the message: the record has no wire field for
+* it outside `webProfile.wasm`.
+*/
+function describeWarmupTarget(pipelines, config) {
+	return `pipelines=[${pipelines.join(",")}] basePathPinned=${!isDefaultCdnWasmConfig(config)} pinnedVersion=${DEFAULT_WASM_VERSION}`;
+}
+function emitWarmupLine(level, message) {
+	emitWasmDiagnostic({
+		level,
+		subsystem: "warmup",
+		category: "other",
+		message
+	});
+}
+/**
 * Preloads WASM binary and ML models at app startup.
 * Runs asynchronously - app can continue while WASM loads in background.
 *
@@ -616,6 +929,9 @@ async function warmupWasm(config) {
 		state = "loading";
 		pipelinesInFlight = combinedPipelines;
 		wasmError = null;
+		const addTarget = describeWarmupTarget(missingPipelines, lastConfig);
+		const addStartedAtMs = getTimestamp();
+		emitWarmupLine("debug", `warmup started ${addTarget} mode=add`);
 		loadingPromise = (async () => {
 			try {
 				const pipelinesMap = buildPipelinesMap(missingPipelines, lastConfig);
@@ -628,12 +944,16 @@ async function warmupWasm(config) {
 					pipelines: combinedPipelines
 				};
 				loadingPromise = null;
+				emitWarmupLine("debug", `warmup completed ${addTarget} mode=add durationMs=${getTimestamp() - addStartedAtMs}`);
 			} catch (error) {
 				state = "ready";
 				wasmError = error instanceof Error ? error : new Error(String(error));
 				loadingPromise = null;
 				pipelinesInFlight = [];
+				emitWarmupLine("error", `warmup failed ${addTarget} mode=add durationMs=${getTimestamp() - addStartedAtMs} error=${String(error)}`);
 				throw wasmError;
+			} finally {
+				reportWasmIntegritySummary();
 			}
 		})();
 		return loadingPromise;
@@ -641,6 +961,9 @@ async function warmupWasm(config) {
 	state = "loading";
 	pipelinesInFlight = [...pipelines];
 	wasmError = null;
+	const target = describeWarmupTarget(pipelines, config);
+	const startedAtMs = getTimestamp();
+	emitWarmupLine("debug", `warmup started ${target}`);
 	loadingPromise = (async () => {
 		try {
 			const pipelinesMap = buildPipelinesMap(pipelines, config);
@@ -659,17 +982,31 @@ async function warmupWasm(config) {
 				pipelines
 			};
 			loadingPromise = null;
+			const durationMs = getTimestamp() - startedAtMs;
+			warmupFacts = {
+				basePathPinned: !isDefaultCdnWasmConfig(config),
+				simd: simdUsed,
+				durationMs
+			};
+			emitWarmupLine("debug", `warmup completed ${target} simd=${simdUsed} durationMs=${durationMs}`);
 		} catch (error) {
 			state = "error";
 			lastModelVariant = null;
 			wasmError = error instanceof Error ? error : new Error(String(error));
 			loadingPromise = null;
 			pipelinesInFlight = [];
+			emitWarmupLine("severe", `warmup failed ${target} durationMs=${getTimestamp() - startedAtMs} error=${String(error)}`);
 			throw wasmError;
+		} finally {
+			reportWasmIntegritySummary();
 		}
 	})();
 	return loadingPromise;
 }
+/** The last successful fresh warmup, or `null` before one completed. */
+function getWarmupFacts() {
+	return warmupFacts;
+}
 /**
 * Returns the current warmup status.
 * Useful for showing loading indicators.
@@ -716,4 +1053,4 @@ function setWasmOnDeviceMode(enabled) {
 	wasmRuntime.setOnDeviceMode(enabled);
 }
 //#endregion
-export { waitForWasm as a, CAMERA_CYCLE_OWNERSHIP_DOMAIN as c, setWasmOnDeviceMode as i, getCameraCycleOwnershipDomain as l, getWasmStatus as n, warmupWasm as o, isWasmReady as r, wasmRuntime as s, getResolvedModelSource as t };
+export { setWasmOnDeviceMode as a, wasmRuntime as c, drainWasmDiagnostics as d, getWasmDiagnosticsMode as f, isWasmReady as i, CAMERA_CYCLE_OWNERSHIP_DOMAIN as l, getWarmupFacts as n, waitForWasm as o, rearmWasmDiagnostics as p, getWasmStatus as r, warmupWasm as s, getResolvedModelSource as t, getCameraCycleOwnershipDomain as u };

package/dist/{warmup-Cis2p6O0.d.ts → warmup-BO57syF6.d.ts}

@@ -30,6 +30,9 @@ declare global {
 type WasmModule = Record<string, unknown>;
 type WasmGlueFactory = (options?: Readonly<{
   wasmBinary?: Uint8Array;
+  print?: (text: string) => void;
+  printErr?: (text: string) => void;
+  onAbort?: (what: unknown) => void;
 }>) => Promise<WasmModule>;
 /**
  * Binary and glue configuration for one WASM module instance.
@@ -38,6 +41,11 @@ type WasmGlueFactory = (options?: Readonly<{
  * use the same memoized module.
  */
 type WasmModuleConfig = {
+  /**
+   * Enables WASM console output, including native errors. Default: false.
+   * Set before the first load; shared instances retain their output sinks.
+   */
+  showLogs?: boolean;
   /** URL or bytes for the standard WASM binary. */
   wasmPath: WasmSource;
   /**

package/dist/wasm.d.ts

@@ -1,5 +1,5 @@
-import { a as WASM_MODEL_FILES, c as WasmPipeline, l as WasmSource, o as WasmGlueLoader, r as warmupWasm, s as WasmModelName, t as WarmupConfig } from "./warmup-Cis2p6O0.js";
-import { c as setWasmConfig, i as initializeWasmUtil, n as WasmConfig, r as ensureWasmPipelines, s as resolveWasmConfigForPipelines, u as upgradeToWasmHttpClient } from "./setup-Cyko6cAn.js";
+import { a as WASM_MODEL_FILES, c as WasmPipeline, l as WasmSource, o as WasmGlueLoader, r as warmupWasm, s as WasmModelName, t as WarmupConfig } from "./warmup-BO57syF6.js";
+import { c as setWasmConfig, i as initializeWasmUtil, n as WasmConfig, r as ensureWasmPipelines, s as resolveWasmConfigForPipelines, u as upgradeToWasmHttpClient } from "./setup-YPKTUCY5.js";
 //#region ../infra/src/wasm/wasmDefaults.d.ts
 /** The WASM version bundled and tested with this SDK release. */
 declare const DEFAULT_WASM_VERSION = "v2.14.50-post1";

package/dist/wasm.esm.js

@@ -1,7 +1,6 @@
-import { g as WASM_PIPELINE_MODEL_NAMES, m as WASM_PIPELINE_LAZY_MODEL_NAMES, p as WASM_MODEL_FILES } from "./wasmWebClient-B7baE-Wf.esm.js";
-import { C as DEFAULT_WASM_VERSION, D as resolveWasmConfig, T as buildWasmConfigFromBasePath, w as buildDefaultWasmConfig } from "./trueSightService-M5VpCo96.esm.js";
-import { o as warmupWasm } from "./warmup-ChDwHSel.esm.js";
-import { a as resolveWasmConfigForPipelines, c as upgradeToWasmHttpClient, n as initializeWasmUtil, o as setWasmConfig, t as ensureWasmPipelines } from "./setup-BuPbxpwF.esm.js";
+import { E as WASM_PIPELINE_LAZY_MODEL_NAMES, O as WASM_PIPELINE_MODEL_NAMES, T as WASM_MODEL_FILES, b as buildDefaultWasmConfig, w as resolveWasmConfig, x as buildWasmConfigFromBasePath, y as DEFAULT_WASM_VERSION } from "./wasmWebClient-BjZw_7OB.esm.js";
+import { s as warmupWasm } from "./warmup-BElYWRh7.esm.js";
+import { a as resolveWasmConfigForPipelines, c as upgradeToWasmHttpClient, n as initializeWasmUtil, o as setWasmConfig, t as ensureWasmPipelines } from "./setup-B7ehQ-lf.esm.js";
 //#region src/defineWasm.ts
 function requiredModels(pipelines) {
 	const models = /* @__PURE__ */ new Set();

package/dist/{wasmDsFlagSync-DYrLUEII.esm.js → wasmDsFlagSync-CYj5LL9z.esm.js}

@@ -1,4 +1,4 @@
-import { a as utilityWasmApi } from "./safeStorage-BdU9_m2E.esm.js";
+import { i as utilityWasmApi } from "./WasmUtilProvider-DtJuBdt-.esm.js";
 //#region ../infra/src/wasm/wasmDsFlagSync.ts
 /**
 * Sets the Deepsight (ds) flag that the WASM utility API receives on every