@incodetech/core 0.0.0-dev-20260803-2bd16802 → 0.0.0-dev-20260803-e2b5d35d

package/dist/{idCaptureStateMachine-cWGQatgx.esm.js → idCaptureStateMachine-CKJ_aV6s.esm.js}

@@ -1,16 +1,16 @@
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { n as revokeObjectURL } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
 import { r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
-import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService-mUItB6iL.esm.js";
-import { t as getDisableIpify } from "./sessionInitializer-q_Sx6L7L.esm.js";
-import "./trueSight-CxKqRMOO.esm.js";
+import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService-PXOP5bS9.esm.js";
+import { t as getDisableIpify } from "./sessionInitializer-DR77TDcE.esm.js";
+import "./trueSight-CGZ_9YL1.esm.js";
 import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
 import { t as isAndroid } from "./platform-Cd_yWGNG.esm.js";
-import "./session-DY1mtqPs.esm.js";
+import "./session-DvCKSn2k.esm.js";
 import { a as and, n as sendTo, r as assign, s as not, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-3UAjhmjw.esm.js";
-import { _ as StreamCanvasProcessingSession } from "./onDeviceFaceResults-BuTjLnON.esm.js";
+import { _ as StreamCanvasProcessingSession } from "./onDeviceFaceResults-D53Rr_B1.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
 import { t as IncodeCanvas } from "./canvas-E1zGkel4.esm.js";
 import { t as getBrowser } from "./getBrowser-DNrQeL4T.esm.js";
@@ -19,7 +19,7 @@ import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js"
 import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-KNkc71eN.esm.js";
 import { n as flagIdManualReview } from "./manualReviewService-D4IkipnN.esm.js";
 import { n as DEFAULT_ID_CAPTURE_THRESHOLDS } from "./idCaptureDefaults-DrQe0hWr.esm.js";
-import { a as processId, c as stopStream, d as validateUploadResponse, f as ID_ERROR_CODES, i as preloadIdRecordingProvider, l as uploadIdImage, o as startRecordingSession, p as getIdCameraStream, r as initializeIdCapture, s as stopRecording, t as addBarcode, u as uploadManualIdFile } from "./idCaptureServices-DcGxxfYS.esm.js";
+import { a as processId, c as stopStream, d as validateUploadResponse, f as ID_ERROR_CODES, i as preloadIdRecordingProvider, l as uploadIdImage, o as startRecordingSession, p as getIdCameraStream, r as initializeIdCapture, s as stopRecording, t as addBarcode, u as uploadManualIdFile } from "./idCaptureServices-DlnEwYJJ.esm.js";
 //#region src/modules/id/digitalUpload/digitalUploadErrors.ts
 const TERMINAL_FAIL_REASONS = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
 function isKnownFailReason(reason) {
@@ -1316,7 +1316,7 @@ const startRecordingActor = fromPromise(async ({ input }) => {
 });
 const initializeDeepsightSessionActor = fromPromise(async ({ input }) => {
 	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-DYVd_8gR.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-DqEfPplN.esm.js");
 	return loadDeepsightSession({
 		ds: input.ds,
 		storage: input.dependencies.storage,

package/dist/index.esm.js

@@ -1,2 +1,2 @@
-import { i as reset, o as setup, r as isConfigured } from "./setup-DZLzxBYo.esm.js";
+import { i as reset, o as setup, r as isConfigured } from "./setup-DSLbrjHG.esm.js";
 export { isConfigured, reset, setup };

package/dist/mandatory-consent.d.ts

@@ -1,3 +1,3 @@
 import { r as MandatoryConsentConfig } from "./types-BX_XkMsQ2.js";
-import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, t as MandatoryConsentManager } from "./mandatoryConsentManager-DyPzUmsZ.js";
+import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, t as MandatoryConsentManager } from "./mandatoryConsentManager-B29kR0XA.js";
 export { type MandatoryConsentActor, type MandatoryConsentConfig, type MandatoryConsentManager, type MandatoryConsentState, createMandatoryConsentManager, createMandatoryConsentManagerFromActor, mandatoryConsentMachine };

package/dist/{mandatoryConsentManager-DyPzUmsZ.d.ts → mandatoryConsentManager-B29kR0XA.d.ts}

@@ -61,14 +61,14 @@ declare const mandatoryConsentMachine: StateMachine<MandatoryConsentContext, {
     type: "clearError";
     params: NonReducibleUnknown;
   };
-  resetContext: {
-    type: "resetContext";
-    params: NonReducibleUnknown;
-  };
   toggleSigned: {
     type: "toggleSigned";
     params: NonReducibleUnknown;
   };
+  resetContext: {
+    type: "resetContext";
+    params: NonReducibleUnknown;
+  };
 }>, {
   type: "canSubmit";
   params: unknown;

package/dist/{mediapipeShared-B0iQQ5k7.esm.js → mediapipeShared-D0syL_Gp.esm.js}

@@ -24,6 +24,10 @@
 *  - `outputFaceBlendshapes: true` — drives blink / mouth / smile.
 */
 async function createFaceLandmarker(paths) {
+	const modelBytesPromise = fetch(paths.faceLandmarkerModelPath).then((res) => {
+		if (!res.ok) throw new Error(`model fetch HTTP ${res.status}`);
+		return res.arrayBuffer();
+	}).then((buf) => new Uint8Array(buf)).catch(() => null);
 	const globalScope = window;
 	const savedModule = globalScope.Module;
 	globalScope.Module = void 0;
@@ -33,9 +37,10 @@ async function createFaceLandmarker(paths) {
 			paths.mediapipeModulePath
 );
 		const fileset = await tasksVision.FilesetResolver.forVisionTasks(paths.mediapipeWasmPath);
+		const modelBytes = await modelBytesPromise;
 		return await tasksVision.FaceLandmarker.createFromOptions(fileset, {
 			baseOptions: {
-				modelAssetPath: paths.faceLandmarkerModelPath,
+				...modelBytes ? { modelAssetBuffer: modelBytes } : { modelAssetPath: paths.faceLandmarkerModelPath },
 				delegate: "CPU"
 			},
 			runningMode: "VIDEO",

package/dist/{onDeviceFaceResults-BuTjLnON.esm.js → onDeviceFaceResults-D53Rr_B1.esm.js}

@@ -1,8 +1,8 @@
 import { c as mlWasmJSApi_default, i as BaseWasmProvider } from "./safeStorage-Ep56I-f_.esm.js";
 import { r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
-import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService-mUItB6iL.esm.js";
+import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService-PXOP5bS9.esm.js";
 import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import "./trueSight-CxKqRMOO.esm.js";
+import "./trueSight-CGZ_9YL1.esm.js";
 import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
 import { a as isIPhone14OrHigher, n as isDesktop } from "./platform-Cd_yWGNG.esm.js";
 import { a as stopCameraStream, r as requestCameraAccess } from "./camera-BmFEyPP_.esm.js";
@@ -521,7 +521,7 @@ async function stopRecording(session) {
 	}
 }
 async function initializeDeepsightSession(options) {
-	const { loadDeepsightSession } = await import("./deepsightLoader-DYVd_8gR.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-DqEfPplN.esm.js");
 	return loadDeepsightSession({
 		ds: options.ds,
 		storage: options.storage

package/dist/personhood.esm.js

@@ -2,15 +2,15 @@ import { r as WasmUtilProvider } 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 { t as api } from "./api-Bx3gKW_y.esm.js";
-import { b as getStoredHttpConfig, w as createApi$1, y as randomUUID } from "./trueSightService-mUItB6iL.esm.js";
+import { b as getStoredHttpConfig, w as createApi$1, y as randomUUID } from "./trueSightService-PXOP5bS9.esm.js";
 import { n as eventModuleNames } from "./events-ethtfu2b.esm.js";
-import { _ as getDeviceFingerprintInfo, g as getThumbmarkId, n as getFingerprintEnabled, p as isBrowserSimulation, v as BrowserEnvironmentProvider } from "./sessionInitializer-q_Sx6L7L.esm.js";
+import { _ as getDeviceFingerprintInfo, g as getThumbmarkId, n as getFingerprintEnabled, p as isBrowserSimulation, v as BrowserEnvironmentProvider } from "./sessionInitializer-DR77TDcE.esm.js";
 import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
 import { c as createManager, o as createActor, r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 import { i as requestPermission, t as checkPermission } from "./permissionServices-3UAjhmjw.esm.js";
 import { a as stopCameraStream, r as requestCameraAccess } from "./camera-BmFEyPP_.esm.js";
-import { f as stopStream, l as startDetection, s as initializeDeepsightSession, v as FaceDetectionProvider } from "./onDeviceFaceResults-BuTjLnON.esm.js";
+import { f as stopStream, l as startDetection, s as initializeDeepsightSession, v as FaceDetectionProvider } from "./onDeviceFaceResults-D53Rr_B1.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
 import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
 //#region src/modules/personhood/personhoodServices.ts

package/dist/privacyLensWorker-DI-Rg83h.esm.js

@@ -0,0 +1,355 @@
+import { n as createStatsWindow } from "./avatarStats-CdUOb3VD.esm.js";
+//#region ../infra/src/avatar/framePacing.ts
+/**
+* Creates a tolerance-based fps cap. The first frame is always accepted.
+*
+* The default is the literal `8` (= FRAME_PACER_TOLERANCE_MS), NOT the
+* constant: this function is serialized into worker blobs via `toString()`,
+* where a module-scope reference in a default parameter would ReferenceError
+* at runtime on the first one-arg call — and no serialization test evaluates
+* defaults, so it would ship silently.
+*/
+function createFramePacer(maxFps, toleranceMs = 8) {
+	const intervalMs = 1e3 / Math.max(maxFps, 1);
+	const minGapMs = Math.max(intervalMs - toleranceMs, 0);
+	let lastAcceptedAt = Number.NEGATIVE_INFINITY;
+	let dropped = 0;
+	return {
+		shouldRender(nowMs) {
+			if (nowMs - lastAcceptedAt >= minGapMs) {
+				lastAcceptedAt = nowMs;
+				return true;
+			}
+			dropped += 1;
+			return false;
+		},
+		get droppedCount() {
+			return dropped;
+		}
+	};
+}
+//#endregion
+//#region ../infra/src/avatar/privacy-lens/privacyLensGlCore.ts
+/**
+* Builds the lens GL pipeline on `canvas`. Throws if WebGL is unavailable or
+* the program fails to compile/link (callers fall back / surface the error).
+* SELF-CONTAINED — see the module doc before editing.
+*/
+function createPrivacyLensGl(canvas, vertSrc, fragSrc, renderSize) {
+	canvas.width = renderSize;
+	canvas.height = renderSize;
+	const gl = canvas.getContext("webgl", {
+		alpha: false,
+		antialias: false,
+		premultipliedAlpha: false,
+		preserveDrawingBuffer: false
+	}) ?? canvas.getContext("experimental-webgl");
+	if (!gl) throw new Error("privacy-lens: WebGL is not available");
+	const compile = (type, src) => {
+		const shader = gl.createShader(type);
+		if (!shader) throw new Error("privacy-lens: createShader failed");
+		gl.shaderSource(shader, src);
+		gl.compileShader(shader);
+		if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+			const log = gl.getShaderInfoLog(shader);
+			gl.deleteShader(shader);
+			throw new Error(`privacy-lens: shader compile failed: ${log}`);
+		}
+		return shader;
+	};
+	const vs = compile(gl.VERTEX_SHADER, vertSrc);
+	const fs = compile(gl.FRAGMENT_SHADER, fragSrc);
+	const program = gl.createProgram();
+	if (!program) throw new Error("privacy-lens: createProgram failed");
+	gl.attachShader(program, vs);
+	gl.attachShader(program, fs);
+	gl.linkProgram(program);
+	gl.deleteShader(vs);
+	gl.deleteShader(fs);
+	if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+		const log = gl.getProgramInfoLog(program);
+		gl.deleteProgram(program);
+		throw new Error(`privacy-lens: program link failed: ${log}`);
+	}
+	gl.useProgram(program);
+	const quad = gl.createBuffer();
+	gl.bindBuffer(gl.ARRAY_BUFFER, quad);
+	gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+		-1,
+		-1,
+		1,
+		-1,
+		-1,
+		1,
+		1,
+		1
+	]), gl.STATIC_DRAW);
+	const aPos = gl.getAttribLocation(program, "aPos");
+	gl.enableVertexAttribArray(aPos);
+	gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 0, 0);
+	const videoTex = gl.createTexture();
+	if (!videoTex) throw new Error("privacy-lens: createTexture failed");
+	gl.bindTexture(gl.TEXTURE_2D, videoTex);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+	const uniformNames = [
+		"uVideo",
+		"uRes",
+		"uVideoRes",
+		"uTime",
+		"uFrost",
+		"uSandblast",
+		"uGrainSize",
+		"uWarmth",
+		"uBright",
+		"uShadow",
+		"uSun",
+		"uSunSpeed"
+	];
+	const uniforms = {};
+	for (let i = 0; i < uniformNames.length; i += 1) uniforms[uniformNames[i]] = gl.getUniformLocation(program, uniformNames[i]);
+	gl.uniform1i(uniforms.uVideo, 0);
+	if (uniforms.uRes) gl.uniform2f(uniforms.uRes, renderSize, renderSize);
+	gl.viewport(0, 0, renderSize, renderSize);
+	gl.clearColor(.88, .86, .83, 1);
+	let texWidth = 0;
+	let texHeight = 0;
+	let disposed = false;
+	const setF = (name, value) => {
+		const loc = uniforms[name];
+		if (loc) gl.uniform1f(loc, value);
+	};
+	return {
+		clear() {
+			if (disposed) return;
+			gl.clear(gl.COLOR_BUFFER_BIT);
+		},
+		render(source, srcWidth, srcHeight, timeSec, params, measure) {
+			if (disposed) return null;
+			const t0 = measure ? performance.now() : 0;
+			gl.activeTexture(gl.TEXTURE0);
+			gl.bindTexture(gl.TEXTURE_2D, videoTex);
+			if (srcWidth !== texWidth || srcHeight !== texHeight) {
+				texWidth = srcWidth;
+				texHeight = srcHeight;
+				gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, texWidth, texHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+				if (uniforms.uVideoRes) gl.uniform2f(uniforms.uVideoRes, texWidth, texHeight);
+			}
+			gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gl.RGBA, gl.UNSIGNED_BYTE, source);
+			const t1 = measure ? performance.now() : 0;
+			setF("uTime", timeSec);
+			setF("uFrost", params.frost);
+			setF("uSandblast", params.sandblast);
+			setF("uGrainSize", params.grainSize);
+			setF("uWarmth", params.warmth);
+			setF("uBright", params.brightness);
+			setF("uShadow", params.shadowLift);
+			setF("uSun", params.sun);
+			setF("uSunSpeed", params.sunSpeed);
+			gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+			if (!measure) return null;
+			const t2 = performance.now();
+			return {
+				uploadMs: t1 - t0,
+				drawMs: t2 - t1
+			};
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			gl.deleteProgram(program);
+			gl.deleteBuffer(quad);
+			gl.deleteTexture(videoTex);
+			gl.getExtension("WEBGL_lose_context")?.loseContext();
+		}
+	};
+}
+//#endregion
+//#region ../infra/src/avatar/privacy-lens/privacyLensWorker.ts
+/**
+* Worker mode for the privacy lens (ENG-49806 Plan B).
+*
+* Under a saturated main thread (the synchronous WASM detection pipeline can
+* occupy it back-to-back on throttled/low-tier devices) a main-thread lens is
+* starved to single-digit fps regardless of how cheap its frame is — measured
+* at 1.6-3 fps with 0ms upload/draw. The fix is to take the main thread out of
+* the frame path entirely: camera track → `MediaStreamTrackProcessor` →
+* `VideoFrame` stream → worker → OffscreenCanvas WebGL. The main thread only
+* bridges dev-tuning params and stats at 4 Hz.
+*
+* Support: Chromium 94+ (Chrome/Edge/Android WebView/Samsung Internet) — the
+* low-tier Android target segment. Safari/Firefox and strict-CSP hosts that
+* block blob workers fail the probe or the Worker constructor and fall back to
+* the main-thread path automatically (`PrivacyLensProvider`).
+*
+* Packaging: the worker script is assembled AT RUNTIME from
+* `Function.prototype.toString()` of the shared, self-contained functions
+* (`createPrivacyLensGl`, `createFramePacer`, `createStatsWindow`,
+* `privacyLensWorkerMain`) plus JSON-injected shader sources and stats/pacer
+* constants, and loaded via a Blob URL. No separate worker chunk to ship —
+* bundler-agnostic for npm and CDN consumers alike. The serialized functions
+* must therefore never close over module-level values.
+*/
+/**
+* Whether the worker path is available in this environment. All three probes
+* must hold; anything missing (Safari's worker-only MSTP shape, Firefox, old
+* WebView) routes to the main-thread fallback.
+*/
+function canUsePrivacyLensWorker() {
+	const g = globalThis;
+	if (typeof g.MediaStreamTrackProcessor !== "function" || typeof g.Worker !== "function" || typeof g.HTMLCanvasElement !== "function") return false;
+	return "transferControlToOffscreen" in g.HTMLCanvasElement.prototype;
+}
+/** Constructs a MediaStreamTrackProcessor (Chromium main-thread shape). */
+function createTrackProcessor(track) {
+	const Ctor = globalThis.MediaStreamTrackProcessor;
+	if (!Ctor) throw new Error("MediaStreamTrackProcessor unavailable");
+	return new Ctor({ track });
+}
+/**
+* The worker's entire logic. SELF-CONTAINED (serialized via toString into the
+* blob): everything it needs arrives via `deps` / messages; no module refs.
+* Frame loop: sequential read → pace → render → close. MSTP buffers at most
+* one frame internally, so reads always yield the freshest frame and closing
+* every frame promptly keeps the camera's frame pool healthy — an unclosed
+* VideoFrame can stall the CAPTURE pipeline, which the lens must never do.
+*/
+function privacyLensWorkerMain(scope, deps) {
+	let gl = null;
+	let pacer = null;
+	let reader = null;
+	let params = null;
+	let statsEnabled = false;
+	let stopped = false;
+	let stats = null;
+	const pump = async () => {
+		const startTime = performance.now();
+		while (!stopped && reader && gl && pacer && params) {
+			let result;
+			try {
+				result = await reader.read();
+			} catch {
+				break;
+			}
+			if (result.done) break;
+			const frame = result.value;
+			try {
+				const now = performance.now();
+				if (!pacer.shouldRender(now)) {
+					if (statsEnabled) stats?.noteDropped();
+					continue;
+				}
+				const timing = gl.render(frame, frame.displayWidth, frame.displayHeight, (now - startTime) / 1e3, params, statsEnabled);
+				if (statsEnabled) stats?.noteRendered(now, timing?.uploadMs, timing?.drawMs);
+			} catch {} finally {
+				frame.close();
+			}
+		}
+	};
+	scope.onmessage = (event) => {
+		const msg = event.data;
+		if (msg.type === "start") {
+			try {
+				gl = deps.createGl(msg.canvas, deps.vertSrc, deps.fragSrc, deps.renderSize);
+				gl.clear();
+			} catch (error) {
+				scope.postMessage({
+					type: "fatal",
+					message: String(error)
+				});
+				return;
+			}
+			params = msg.params;
+			statsEnabled = msg.statsEnabled;
+			stats = deps.createStats({
+				variant: "privacy-lens",
+				mode: "worker",
+				publishIntervalMs: deps.publishIntervalMs,
+				gapWindow: deps.gapWindow,
+				publish: (snapshot) => scope.postMessage({
+					type: "stats",
+					snapshot
+				})
+			});
+			pacer = deps.createPacer(msg.maxFps, deps.frameToleranceMs);
+			reader = msg.readable.getReader();
+			scope.postMessage({ type: "started" });
+			pump();
+		} else if (msg.type === "params") params = msg.params;
+		else if (msg.type === "statsEnabled") statsEnabled = msg.value;
+		else if (msg.type === "stop") {
+			stopped = true;
+			try {
+				reader?.cancel();
+			} catch {}
+			gl?.dispose();
+			gl = null;
+			scope.postMessage({ type: "stopped" });
+		}
+	};
+}
+/**
+* Dev/build transforms that inject module-level references into function bodies.
+* These pass `new Function(src)` (syntactically valid) but throw a
+* `ReferenceError` at worker boot because the injected identifier
+* (`$RefreshSig$`, `cov_xxx()`, …) doesn't exist in the worker scope — silently
+* downgrading everyone to the slow main-thread path via the fatal→fallback net.
+* The vite config excludes `packages/infra` from prefresh for this reason; this
+* list is the runtime backstop for any other instrumenter (coverage, SSR, a
+* consumer's bundler) that the config can't reach.
+*/
+const WORKER_SOURCE_SENTINELS = [
+	{
+		name: "prefresh / react-refresh",
+		pattern: /\$Refresh(Sig|Reg)\$/
+	},
+	{
+		name: "istanbul coverage",
+		pattern: /\bcov_[0-9a-zA-Z]+\(/
+	},
+	{
+		name: "vite SSR transform",
+		pattern: /__vite_ssr_/
+	}
+];
+/**
+* Returns the name of the instrumenter that corrupted the serialized worker
+* source, or null if the source is clean. Callers log loudly and fall back to
+* the main-thread lens rather than booting a worker that will `ReferenceError`.
+*/
+function detectWorkerSourceInstrumentation(source) {
+	for (const sentinel of WORKER_SOURCE_SENTINELS) if (sentinel.pattern.test(source)) return sentinel.name;
+	return null;
+}
+/**
+* Assembles the worker script from the serialized shared functions + injected
+* shader sources and stats/pacer constants. Everything referenced must be
+* self-contained (see module doc); the shaders and the numeric constants
+* (`PUBLISH_INTERVAL_MS`, `GAP_WINDOW`, `FRAME_PACER_TOLERANCE_MS`) are injected
+* as literals so the worker never depends on this module's scope.
+*/
+function buildPrivacyLensWorkerSource(options) {
+	if (!Number.isFinite(options.renderSize)) throw new Error(`privacy-lens: renderSize must be finite, got ${String(options.renderSize)}`);
+	return [
+		"\"use strict\";",
+		`const createGl = ${createPrivacyLensGl.toString()};`,
+		`const createPacer = ${createFramePacer.toString()};`,
+		`const createStats = ${createStatsWindow.toString()};`,
+		`const workerMain = ${privacyLensWorkerMain.toString()};`,
+		`workerMain(self, {
+  createGl,
+  createPacer,
+  createStats,
+  vertSrc: ${JSON.stringify(options.vertSrc)},
+  fragSrc: ${JSON.stringify(options.fragSrc)},
+  renderSize: ${JSON.stringify(options.renderSize)},
+  publishIntervalMs: ${JSON.stringify(500)},
+  gapWindow: ${JSON.stringify(128)},
+  frameToleranceMs: ${JSON.stringify(8)},
+});`
+	].join("\n");
+}
+//#endregion
+export { createPrivacyLensGl as a, detectWorkerSourceInstrumentation as i, canUsePrivacyLensWorker as n, createFramePacer as o, createTrackProcessor as r, buildPrivacyLensWorkerSource as t };

package/dist/qe-signature.esm.js

@@ -1,4 +1,4 @@
-import { a as areAllConsented, i as QE_CONSENT_KEYS, n as electronicSignatureMachine, s as getDefaultConsentChecks, t as createElectronicSignatureManager } from "./electronicSignatureManager-CPWJcuFy.esm.js";
+import { a as areAllConsented, i as QE_CONSENT_KEYS, n as electronicSignatureMachine, s as getDefaultConsentChecks, t as createElectronicSignatureManager } from "./electronicSignatureManager-DHC0bqr9.esm.js";
 //#region src/modules/qe-signature/index.ts
 function createQeSignatureManager(options) {
 	return createElectronicSignatureManager({ config: {

package/dist/{recordingService-DdljWMN1.esm.js → recordingService-Dv5Ztm5Y.esm.js}

@@ -1,5 +1,5 @@
 import { t as isAndroid } from "./platform-Cd_yWGNG.esm.js";
-import { d as stopRecording, g as uploadDeepsightVideo, u as startRecordingSession } from "./onDeviceFaceResults-BuTjLnON.esm.js";
+import { d as stopRecording, g as uploadDeepsightVideo, u as startRecordingSession } from "./onDeviceFaceResults-D53Rr_B1.esm.js";
 import { t as getAdaptiveMediaRecorderOptions } from "./mediaRecorderOptions-CUsftWlH.esm.js";
 //#region ../infra/src/media/VideoTrimmer.ts
 async function getDurationBySeek(videoBlob) {

package/dist/{runChildModule-BSTzbivl.esm.js → runChildModule-Dh9HjxbH.esm.js}

@@ -1,5 +1,5 @@
 import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
-import { a as notifyTrueSightManagerStopped, i as notifyTrueSightFlowEvent } from "./trueSightService-mUItB6iL.esm.js";
+import { a as notifyTrueSightManagerStopped, i as notifyTrueSightFlowEvent } from "./trueSightService-PXOP5bS9.esm.js";
 import { C as createEventBus } from "./events-ethtfu2b.esm.js";
 import { o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";

package/dist/selfie.esm.js

@@ -3,11 +3,11 @@ import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.e
 import { n as eventModuleNames } from "./events-ethtfu2b.esm.js";
 import { o as createActor, r as assign } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
-import { t as faceCaptureMachine } from "./faceCaptureSetup-a7dsfqui.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-C58fhn5l.esm.js";
+import { t as faceCaptureMachine } from "./faceCaptureSetup-5Ye-LXbB.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-DqQCDsDY.esm.js";
 import { r as processFace } from "./selfieErrorUtils-DggLa9pg.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-TC6ctOex.esm.js";
-import { n as createSelfieManagerFromActor, t as createSelfieManager } from "./selfieManager-BzCnteUg.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-C1ErWDmF.esm.js";
+import { n as createSelfieManagerFromActor, t as createSelfieManager } from "./selfieManager-CwLK0icS.esm.js";
 import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-DVtdZdpI.esm.js";
 //#region src/modules/selfie/selfieCaptureOnlyStateMachine.ts
 /**

package/dist/{selfieManager-BzCnteUg.esm.js → selfieManager-CwLK0icS.esm.js}

@@ -2,8 +2,8 @@ import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
 import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
 import { n as eventModuleNames } from "./events-ethtfu2b.esm.js";
 import { o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-C58fhn5l.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-TC6ctOex.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-DqQCDsDY.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-C1ErWDmF.esm.js";
 //#region src/modules/selfie/selfieActor.ts
 function createSelfieActor(options) {
 	const dependencies = options.dependencies ?? {

package/dist/{selfieStateMachine-TC6ctOex.esm.js → selfieStateMachine-C1ErWDmF.esm.js}

@@ -1,7 +1,7 @@
 import { r as assign } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
-import { t as faceCaptureMachine } from "./faceCaptureSetup-a7dsfqui.esm.js";
-import { i as prepareOnDeviceFaceUpload, n as isOnDeviceMode, r as postOnDeviceFaceResults, t as defaultPrepareFaceUpload } from "./onDeviceFaceResults-BuTjLnON.esm.js";
+import { t as faceCaptureMachine } from "./faceCaptureSetup-5Ye-LXbB.esm.js";
+import { i as prepareOnDeviceFaceUpload, n as isOnDeviceMode, r as postOnDeviceFaceResults, t as defaultPrepareFaceUpload } from "./onDeviceFaceResults-D53Rr_B1.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
 import { i as uploadSelfie, n as validateUploadResponse, r as processFace } from "./selfieErrorUtils-DggLa9pg.esm.js";
 /**

package/dist/{session-DY1mtqPs.esm.js → session-DvCKSn2k.esm.js}

@@ -1,9 +1,9 @@
 import { n as getApi } from "./api-Bx3gKW_y.esm.js";
-import { h as noteSessionCreated, l as trueSightLog } from "./trueSightService-mUItB6iL.esm.js";
-import "./sessionInitializer-q_Sx6L7L.esm.js";
+import { h as noteSessionCreated, l as trueSightLog } from "./trueSightService-PXOP5bS9.esm.js";
+import "./sessionInitializer-DR77TDcE.esm.js";
 import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import "./trueSight-CxKqRMOO.esm.js";
-import { r as toIncodeApiError } from "./apiError-0e7XVmLE.esm.js";
+import "./trueSight-CGZ_9YL1.esm.js";
+import { r as toIncodeApiError } from "./apiError-C_08gwg2.esm.js";
 //#region src/internal/session/sessionService.ts
 /**
 * HTTP status codes the QR validation endpoint emits, keyed by their semantic

package/dist/session.esm.js

@@ -1,5 +1,5 @@
-import { i as initializeSession } from "./sessionInitializer-q_Sx6L7L.esm.js";
-import { t as IncodeApiError } from "./apiError-0e7XVmLE.esm.js";
-import { a as refreshQrUrlUuid, i as createSession, n as QrValidationError, o as validateQrUuid, r as bootstrapSession, t as QR_VALIDATION_ERROR_CODES } from "./session-DY1mtqPs.esm.js";
-import { n as getFinishStatus } from "./flowCompletionService-BZWoO8E3.esm.js";
+import { i as initializeSession } from "./sessionInitializer-DR77TDcE.esm.js";
+import { t as IncodeApiError } from "./apiError-C_08gwg2.esm.js";
+import { a as refreshQrUrlUuid, i as createSession, n as QrValidationError, o as validateQrUuid, r as bootstrapSession, t as QR_VALIDATION_ERROR_CODES } from "./session-DvCKSn2k.esm.js";
+import { n as getFinishStatus } from "./flowCompletionService-DEO2OqAI.esm.js";
 export { IncodeApiError, QR_VALIDATION_ERROR_CODES, QrValidationError, bootstrapSession, createSession, getFinishStatus, initializeSession, refreshQrUrlUuid, validateQrUuid };

package/dist/{sessionInitializer-q_Sx6L7L.esm.js → sessionInitializer-DR77TDcE.esm.js}

@@ -1,9 +1,9 @@
 import { _ as updateFeatureManagementUser } from "./feature-management-CFRmD8Nr.esm.js";
 import { c as setToken, r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
-import { _ as noteTokenActivated, d as fetchFeatureConfig, f as isFeatureEnabled, l as trueSightLog, m as noteEnvironment, p as resetFeatureConfigCache, s as startTrueSightCollection, v as SDK_VERSION } from "./trueSightService-mUItB6iL.esm.js";
+import { _ as noteTokenActivated, d as fetchFeatureConfig, f as isFeatureEnabled, l as trueSightLog, m as noteEnvironment, p as resetFeatureConfigCache, s as startTrueSightCollection, v as SDK_VERSION } from "./trueSightService-PXOP5bS9.esm.js";
 import { v as addEvent, y as getAnalyticsBatcher } from "./events-ethtfu2b.esm.js";
 import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import "./trueSight-CxKqRMOO.esm.js";
+import "./trueSight-CGZ_9YL1.esm.js";
 import { n as flushDeviceStatsQueue, r as resetDeviceStatsQueue } from "./stats-B0nFKawG.esm.js";
 import { n as UAParser, t as getParsedUserAgent } from "./getParsedUserAgent-pJjATANs.esm.js";
 import { r as isIOS } from "./platform-Cd_yWGNG.esm.js";

package/dist/{setup-DZLzxBYo.esm.js → setup-DSLbrjHG.esm.js}

@@ -5,14 +5,14 @@ import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.j
 import { b as resetEnvironment, d as initializeFeatureManagement, h as resetFeatureManagementProviderInstance, l as getIsFeatureManagementLocked, m as resetFeatureManagement, p as optOutFeatureManagement, v as applyEnvironment, y as getEnvironment } from "./feature-management-CFRmD8Nr.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-mUItB6iL.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-PXOP5bS9.esm.js";
 import { b as resetAnalyticsBatcher, c as resetExperimentAssignments, x as setAnalyticsBatcher, y as getAnalyticsBatcher } from "./events-ethtfu2b.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-q_Sx6L7L.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-DR77TDcE.esm.js";
 import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import "./trueSight-CxKqRMOO.esm.js";
+import "./trueSight-CGZ_9YL1.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-DlsSs-nq.esm.js";
+import { n as preloadDashboardFlow, r as resetDashboardFlowCache } from "./flowServices-D6T8fwIf.esm.js";
 //#region ../infra/src/providers/browser/BrowserPageLifecycleProvider.ts
 var BrowserPageLifecycleProvider = class {
 	sendBeacon(url, body, contentType = "application/json") {

package/dist/trueSight-CGZ_9YL1.esm.js

@@ -0,0 +1 @@
+import "./trueSightService-PXOP5bS9.esm.js";

package/dist/{trueSightService-mUItB6iL.esm.js → trueSightService-PXOP5bS9.esm.js}

@@ -724,7 +724,7 @@ function epochMsToIsoString(epochMs) {
 }
 //#endregion
 //#region src/internal/version/sdkVersion.ts
-const SDK_VERSION = "0.0.0-dev-20260803-2bd16802";
+const SDK_VERSION = "0.0.0-dev-20260803-e2b5d35d";
 //#endregion
 //#region src/internal/trueSight/recordBuilder.ts
 /**