@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/{phoneManager-CRblfdcI.esm.js → phoneManager-Cpiai2IM.esm.js}

@@ -1,13 +1,10 @@
-import { n as eventModuleNames, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
-import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
-import { t as OTP_CODE_LENGTH } from "./otp-uaXiKt_R.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-DjFGWMjQ.esm.js";
-
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-E1fUUcNM.esm.js";
 //#region src/modules/phone/phoneActor.ts
 function createPhoneActor(options) {
 	return createActor(phoneMachine, { input: { config: options.config } }).start();
 }
-
 //#endregion
 //#region src/modules/phone/phoneManager.ts
 /**
@@ -165,7 +162,7 @@ function mapState(snapshot) {
 	if (typedSnapshot.matches("resendingOtp")) return {
 		status: "resendingOtp",
 		otpCode: context.otpCode,
-		otpLength: OTP_CODE_LENGTH
+		otpLength: 6
 	};
 	if (typedSnapshot.matches("sendingInitialOtp")) return { status: "sendingInitialOtp" };
 	if (typedSnapshot.matches("awaitingOtp")) return {
@@ -174,7 +171,7 @@ function mapState(snapshot) {
 		canResend: !context.resendTimerActive,
 		attemptsRemaining: context.attemptsRemaining,
 		otpCode: context.otpCode,
-		otpLength: OTP_CODE_LENGTH,
+		otpLength: 6,
 		otpValidationErrors: context.otpValidationErrors,
 		isOtpValid: Object.keys(context.otpValidationErrors ?? {}).length === 0
 	};
@@ -183,7 +180,7 @@ function mapState(snapshot) {
 		resendTimer: context.resendTimer,
 		canResend: !context.resendTimerActive,
 		otpCode: context.otpCode,
-		otpLength: OTP_CODE_LENGTH
+		otpLength: 6
 	};
 	if (typedSnapshot.matches("otpError")) return {
 		status: "otpError",
@@ -192,7 +189,7 @@ function mapState(snapshot) {
 		resendTimer: context.resendTimer,
 		canResend: !context.resendTimerActive,
 		otpCode: context.otpCode,
-		otpLength: OTP_CODE_LENGTH,
+		otpLength: 6,
 		otpValidationErrors: context.otpValidationErrors,
 		isOtpValid: Object.keys(context.otpValidationErrors ?? {}).length === 0
 	};
@@ -205,9 +202,29 @@ function mapState(snapshot) {
 }
 function createApi({ actor, trackElementClicked }) {
 	return {
+		/**
+		* Initializes the phone verification flow.
+		* Transitions from 'idle' to 'loadingPrefill' or 'inputting'.
+		* Must be called before any other method.
+		*/
 		load() {
 			actor.send({ type: "LOAD" });
 		},
+		/**
+		* Sets the phone number for verification.
+		* Should be called when state is 'inputting'.
+		*
+		* @param phone - Full phone number with country code (e.g., '+14155551234')
+		* @param isValid - Whether the phone number passes validation
+		*
+		* @example
+		* ```typescript
+		* // Using libphonenumber-js for validation
+		* import { isValidPhoneNumber } from 'libphonenumber-js';
+		* const phone = '+14155551234';
+		* phoneManager.setPhoneNumber(phone, isValidPhoneNumber(phone));
+		* ```
+		*/
 		setPhoneNumber(phone, isValid) {
 			actor.send({
 				type: "PHONE_CHANGED",
@@ -215,28 +232,67 @@ function createApi({ actor, trackElementClicked }) {
 				isValid
 			});
 		},
+		/**
+		* Validates the current phone number (e.g., on blur).
+		* Populates or clears `validationErrors.phone` on the 'inputting' state.
+		*/
 		validatePhone() {
 			actor.send({ type: "VALIDATE_PHONE" });
 		},
+		/**
+		* Sets the marketing opt-in preference.
+		* Only relevant if `config.optinEnabled` is true.
+		*
+		* @param granted - Whether the user consented to receive marketing messages
+		*/
 		setOptInGranted(granted) {
 			actor.send({
 				type: "OPT_IN_CHANGED",
 				granted
 			});
 		},
+		/**
+		* Submits the phone number for verification.
+		* Runs full validation first: if the phone is empty or invalid, populates
+		* `validationErrors` and stays on 'inputting'; otherwise transitions to
+		* 'submitting', then to 'sendingInitialOtp' or 'finished' (if no OTP).
+		*/
 		submit() {
 			trackElementClicked?.("submit");
 			actor.send({ type: "SUBMIT" });
 		},
+		/**
+		* Sets the OTP code without submitting.
+		* Use this for controlled input components.
+		*
+		* @param code - The OTP code entered by the user
+		*/
 		setOtpCode(code) {
 			actor.send({
 				type: "OTP_CHANGED",
 				code
 			});
 		},
+		/**
+		* Validates the current OTP code (e.g. on blur), without submitting.
+		* Populates or clears `otpValidationErrors.otp` on the 'awaitingOtp' /
+		* 'otpError' states (incomplete code → `isOtpValid` becomes false).
+		*/
 		validateOtp() {
 			actor.send({ type: "VALIDATE_OTP" });
 		},
+		/**
+		* Sets and submits the OTP code in one call.
+		* Should be called when state is 'awaitingOtp' or 'otpError'.
+		*
+		* @param code - The complete OTP code (typically 6 alphanumeric characters)
+		*
+		* @example
+		* ```typescript
+		* // Submit OTP when user completes entry
+		* phoneManager.submitOtp('HH36LP');
+		* ```
+		*/
 		submitOtp(code) {
 			trackElementClicked?.("submitOtp");
 			actor.send({
@@ -245,14 +301,29 @@ function createApi({ actor, trackElementClicked }) {
 			});
 			actor.send({ type: "VERIFY_OTP" });
 		},
+		/**
+		* Requests a new OTP code to be sent.
+		* Only works when state is 'awaitingOtp' and `canResend` is true.
+		* Resets the resend timer.
+		*/
 		resendOtp() {
 			trackElementClicked?.("resendOtp");
 			actor.send({ type: "RESEND_OTP" });
 		},
+		/**
+		* Returns to the phone input screen from OTP entry.
+		* Allows the user to change their phone number.
+		* Transitions from 'awaitingOtp' or 'otpError' back to 'inputting'.
+		*/
 		back() {
 			trackElementClicked?.("back");
 			actor.send({ type: "BACK" });
 		},
+		/**
+		* Resets the manager to initial state.
+		* Can be called from 'success' or 'error' states to start over.
+		* Clears all stored data including phone number and OTP.
+		*/
 		reset() {
 			actor.send({ type: "RESET" });
 		}
@@ -315,6 +386,5 @@ function createPhoneManagerFromActor(actor) {
 		instrumentation: createManagerInstrumentation(eventModuleNames.phone, { getEventScreenName: getPhoneScreenName })
 	});
 }
-
 //#endregion
-export { createPhoneManagerFromActor as n, createPhoneManager as t };
+export { createPhoneManagerFromActor as n, createPhoneManager as t };

package/dist/{phoneStateMachine-DjFGWMjQ.esm.js → phoneStateMachine-E1fUUcNM.esm.js}

@@ -1,9 +1,9 @@
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-import { n as computeOtpValidationErrors, r as isOtpComplete } from "./otp-uaXiKt_R.esm.js";
-
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { 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 { n as isOtpComplete, t as computeOtpValidationErrors } from "./otp-D2k3PeSL.esm.js";
 //#region src/modules/phone/phoneServices.ts
 function getPhoneServerFailureReason(error, invalidStatus) {
 	if (error.status === invalidStatus) return "invalidPhone";
@@ -53,7 +53,6 @@ async function verifyOtp(code, signal) {
 		throw new Error(getPhoneServerFailureReason(error));
 	}
 }
-
 //#endregion
 //#region src/modules/phone/phoneStateMachine.ts
 const RESEND_TIMER_SECONDS = 30;
@@ -381,6 +380,5 @@ const phoneMachine = setup({
 		} } }
 	}
 });
-
 //#endregion
-export { phoneMachine as t };
+export { phoneMachine as t };

package/dist/{platform-0Ot-bF_a.esm.js → platform-BJrm5nzZ.esm.js}

@@ -1,16 +1,10 @@
-//#region ../infra/src/capabilities/platform.ts
-/**
-* Platform detection utilities for camera operations.
-* These are pure functions with no external dependencies and can be used by all layers.
-*/
-let uxType = null;
 function isTouchDevice() {
 	return (typeof navigator !== "undefined" ? navigator.maxTouchPoints > 0 : false) || "ontouchstart" in (typeof document !== "undefined" ? document.documentElement : {});
 }
-function isTabletWithoutAndroid(userAgent) {
+function isTabletWithoutAndroid(userAgent, hasTouch = isTouchDevice()) {
 	const isLinux = /Linux/i.test(userAgent);
 	const isChrome = /Chrome/i.test(userAgent) && !/Edge/i.test(userAgent);
-	return !/Mobile|Android/i.test(userAgent) && isLinux && isChrome && isTouchDevice();
+	return !/Mobile|Android/i.test(userAgent) && isLinux && isChrome && hasTouch;
 }
 function isIOS(userAgent) {
 	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
@@ -21,13 +15,40 @@ function isAndroid(userAgent) {
 	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
 	return /Android/i.test(ua);
 }
+/**
+* True when the page runs inside an Android WebView — web content hosted by a
+* native app — rather than a standalone Android browser.
+*
+* This distinction matters for camera permission. A WebView has no persistent
+* permission store: the host app answers every `getUserMedia` through
+* `WebChromeClient.onPermissionRequest`, so
+* `navigator.permissions.query({ name: 'camera' })` never reports `'granted'`
+* there, no matter how many times access was granted. Standalone Android
+* browsers do not behave that way, which is why callers must gate on this and
+* not on `isAndroid()`.
+*
+* Two signals, because hosts may rewrite the UA:
+* 1. Chromium stamps a `wv` token into the WebView UA (Android 4.4+). Definitive
+*    when present, so it is checked before any browser exclusions.
+* 2. Otherwise the `Version/<n>` + `Chrome/<n>` pair — a WebView emits both,
+*    standalone Chrome for Android emits only `Chrome/<n>`.
+*
+* A host that rewrites the UA past recognition is not detectable here; those
+* integrations keep the pre-existing behaviour and simply see `'prompt'`.
+*/
+function isAndroidWebView(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	if (!isAndroid(ua)) return false;
+	if (/;\s*wv\s*\)/i.test(ua)) return true;
+	if (/SamsungBrowser|Firefox|EdgA|OPR|OPT|YaBrowser|HuaweiBrowser/i.test(ua)) return false;
+	return /\bVersion\/[\d.]+/.test(ua) && /\bChrome\/[\d.]+/.test(ua);
+}
 function isIPad(userAgent) {
 	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
 	const hasTouchPoints = typeof navigator !== "undefined" ? navigator.maxTouchPoints > 0 : false;
 	return /iPad/.test(ua) || /Mac OS/.test(ua) && hasTouchPoints && !/iPhone|iPod/.test(ua);
 }
 function isDesktop(userAgent) {
-	if (uxType) return uxType === "desktop";
 	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
 	return !(/Mobile|Android/i.test(ua) || isTabletWithoutAndroid(ua) || isIOS(ua));
 }
@@ -78,6 +99,5 @@ function isIPhone14OrHigher() {
 	const { outerHeight, outerWidth, innerHeight, innerWidth } = window;
 	return IPHONE_14_PLUS_DIMENSIONS.some((dims) => dims.outerHeight === outerHeight && dims.outerWidth === outerWidth || dims.innerHeight === innerHeight && dims.innerWidth === innerWidth);
 }
-
 //#endregion
-export { isIPhone14OrHigher as a, isIPad as i, isDesktop as n, isSafari as o, isIOS as r, isAndroid as t };
+export { isIPad as a, isTabletWithoutAndroid as c, isIOS as i, isAndroidWebView as n, isIPhone14OrHigher as o, isDesktop as r, isSafari as s, isAndroid as t };

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.d.ts

@@ -1,10 +1,8 @@
-import "./StateMachine-D5WO6lHS.js";
-import { t as Manager } from "./Manager-goNPc_h_.js";
-import "./Actor-BwgmOPkb.js";
-import { c as ConsentKey, f as QE_CONSENT_KEYS, g as getDefaultConsentChecks, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, s as ConsentChecks, u as ElectronicSignatureDocument } from "./index-36QX_21w.js";
-
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import { _ as getDefaultConsentChecks, a as ElectronicSignatureConfig, d as QE_CONSENT_KEYS, h as areAllConsented, i as ConsentKey, r as ConsentChecks, s as ElectronicSignatureDocument } from "./types-DVmXIdzW.js";
+import { n as ElectronicSignatureState, o as electronicSignatureMachine } from "./electronicSignatureManager-CcUXQZS7.js";
+import "./electronic-signature.js";
 //#region src/modules/qe-signature/index.d.ts
-
 type QeSignatureConfig = Omit<ElectronicSignatureConfig, 'variant'>;
 declare function createQeSignatureManager(options: {
   config: QeSignatureConfig;

package/dist/qe-signature.esm.js

@@ -1,11 +1,10 @@
-import "./api-DsbUi7TO.esm.js";
-import "./events-1wxZ97yf.esm.js";
-import "./endpoints-CwrFQfW7.esm.js";
-import "./xstate.esm-nY3M5UYm.esm.js";
-import "./urlUtils-CpiYwn7w.esm.js";
-import "./externalFetch-hvmz_npP.esm.js";
-import "./apiError-DkOXfFBu.esm.js";
-import { a as areAllConsented, i as QE_CONSENT_KEYS, n as electronicSignatureMachine, s as getDefaultConsentChecks } from "./electronicSignatureManager-DESRgObX.esm.js";
-import { t as createQeSignatureManager } from "./qe-signature-BnWIpR-O.esm.js";
-
-export { QE_CONSENT_KEYS, areAllConsented, createQeSignatureManager, getDefaultConsentChecks, electronicSignatureMachine as qeSignatureMachine };
+import { a as QE_CONSENT_KEYS, c as getDefaultConsentChecks, o as areAllConsented, r as electronicSignatureMachine, t as createElectronicSignatureManager } from "./electronicSignatureManager-DRYlHPjT.esm.js";
+//#region src/modules/qe-signature/index.ts
+function createQeSignatureManager(options) {
+	return createElectronicSignatureManager({ config: {
+		...options.config,
+		variant: "qe"
+	} });
+}
+//#endregion
+export { QE_CONSENT_KEYS, areAllConsented, createQeSignatureManager, getDefaultConsentChecks, electronicSignatureMachine as qeSignatureMachine };