@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/avatar2dWarm-DqucNFX4.esm.js

@@ -0,0 +1,1330 @@
+import { i as detectWorkerSourceInstrumentation, o as createFramePacer } from "./privacyLensWorker-DI-Rg83h.esm.js";
+//#region ../infra/src/avatar/2d-default-avatar/assets.ts
+/**
+* 2D avatar MediaPipe asset resolution — **self-contained** (no shared
+* `avatarDefaults`; owns its asset config). No VRM here — 2D satin face.
+* See docs/features/FACE_AVATAR.md → Isolation and ownership.
+*
+* Prebuilt tasks-vision ESM + wasm + the face-landmarker model. Public CDNs for
+* development; production should self-host.
+*/
+const DEFAULT_MEDIAPIPE_MODULE_URL = "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.35";
+const DEFAULT_FACE_LANDMARKER_MODEL_URL = "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task";
+function valid(value) {
+	return typeof value === "string" && value.trim() !== "";
+}
+function resolveAvatar2DAssets(overrides) {
+	const moduleUrl = valid(overrides?.mediapipeModulePath) ? overrides.mediapipeModulePath : DEFAULT_MEDIAPIPE_MODULE_URL;
+	return {
+		mediapipeModulePath: moduleUrl,
+		mediapipeWasmPath: valid(overrides?.mediapipeWasmPath) ? overrides.mediapipeWasmPath : `${moduleUrl}/wasm`,
+		faceLandmarkerModelPath: valid(overrides?.faceLandmarkerModelPath) ? overrides.faceLandmarkerModelPath : DEFAULT_FACE_LANDMARKER_MODEL_URL
+	};
+}
+//#endregion
+//#region ../infra/src/avatar/renderers/SatinSmileyRenderer.ts
+/**
+* The satin-smiley drawing core. SELF-CONTAINED (serialized via toString into
+* the avatar-2d worker blob): no module-level references — all constants,
+* palettes and helpers are inside; keep it free of spread/async helpers.
+*/
+function createSatinSmileyCore(canvas) {
+	const SPRITE = 512;
+	const HEAD_CX = 256;
+	const HEAD_CY = 256;
+	const HEAD_R = 150;
+	const HALO_R = 178;
+	const EYE_Y = 218;
+	const EYE_DX = 56;
+	const EYE_RX = 12;
+	const NOSE_Y0 = 258;
+	const NOSE_Y1 = 292;
+	const MOUTH_Y = 330;
+	const MOUTH_HALF = 44;
+	const YAW_PARALLAX = 90;
+	const PITCH_PARALLAX = 72;
+	const REST_SMILE = .35;
+	const PALETTE_ALPHA_30 = .08;
+	const PRESENCE_ALPHA_30 = .12;
+	const REF_FRAME_MS = 1e3 / 30;
+	const MAX_RENDER_DT_MS = 500;
+	const RENDER_DT_SEED_MS = REF_FRAME_MS;
+	const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+	const hexToRgb = (hex) => {
+		const h = hex.replace("#", "");
+		return [
+			parseInt(h.slice(0, 2), 16),
+			parseInt(h.slice(2, 4), 16),
+			parseInt(h.slice(4, 6), 16)
+		];
+	};
+	const rgb = (c) => `rgb(${c[0] | 0}, ${c[1] | 0}, ${c[2] | 0})`;
+	const rgba = (c, a) => `rgba(${c[0] | 0}, ${c[1] | 0}, ${c[2] | 0}, ${a})`;
+	const buildPalette = (stops, occlusion, contact, feature, halo) => ({
+		stops: [
+			hexToRgb(stops[0]),
+			hexToRgb(stops[1]),
+			hexToRgb(stops[2]),
+			hexToRgb(stops[3])
+		],
+		occlusion: hexToRgb(occlusion),
+		contact: hexToRgb(contact),
+		feature: hexToRgb(feature),
+		halo: hexToRgb(halo)
+	});
+	const PALETTES = {
+		detecting: buildPalette([
+			"#f4f9ff",
+			"#dbeafe",
+			"#cbe0fb",
+			"#aacdf3"
+		], "#6f9fd8", "#3a5f8f", "#007aff", "#2f86f0"),
+		success: buildPalette([
+			"#f0fdf4",
+			"#dcfce7",
+			"#bbf7d0",
+			"#86c79a"
+		], "#3f7a52", "#1f5132", "#15803d", "#22c55e"),
+		error: buildPalette([
+			"#fff1f1",
+			"#fee2e2",
+			"#fecaca",
+			"#e89a9a"
+		], "#8c4a4a", "#5f1e1e", "#b91c1c", "#dc2626")
+	};
+	const clonePalette = (p) => ({
+		stops: [
+			p.stops[0].slice(),
+			p.stops[1].slice(),
+			p.stops[2].slice(),
+			p.stops[3].slice()
+		],
+		occlusion: p.occlusion.slice(),
+		contact: p.contact.slice(),
+		feature: p.feature.slice(),
+		halo: p.halo.slice()
+	});
+	const easeRgb = (cur, target, t) => {
+		cur[0] += (target[0] - cur[0]) * t;
+		cur[1] += (target[1] - cur[1]) * t;
+		cur[2] += (target[2] - cur[2]) * t;
+	};
+	/** Ease every channel of `cur` toward `target` in place (state crossfade). */
+	const easePaletteToward = (cur, target, t) => {
+		for (let i = 0; i < 4; i += 1) easeRgb(cur.stops[i], target.stops[i], t);
+		easeRgb(cur.occlusion, target.occlusion, t);
+		easeRgb(cur.contact, target.contact, t);
+		easeRgb(cur.feature, target.feature, t);
+		easeRgb(cur.halo, target.halo, t);
+	};
+	/** Frame-rate-independent EMA factor for a 30fps-authored alpha. */
+	const dtAlpha = (refAlpha, dtMs) => {
+		if (refAlpha <= 0) return 0;
+		if (refAlpha >= 1) return 1;
+		const tau = -33.333333333333336 / Math.log(1 - refAlpha);
+		return 1 - Math.exp(-dtMs / tau);
+	};
+	/** Dev override: read directly on main; bridged via setOverrideState in workers. */
+	const resolveGlobalOverride = () => {
+		const v = globalThis.__incodeAvatarState;
+		return v === "detecting" || v === "success" || v === "error" ? v : null;
+	};
+	let ctx = canvas.getContext("2d");
+	const size = canvas.width;
+	let presence = 0;
+	let faceState = "detecting";
+	let overrideState = null;
+	const eased = clonePalette(PALETTES.detecting);
+	let lastRenderAt = 0;
+	let ballGradients = null;
+	let specGradient = null;
+	const resolveBallGradients = (c2d) => {
+		const p = eased;
+		const parts = [];
+		parts.push(p.contact[0], p.contact[1], p.contact[2]);
+		for (let i = 0; i < 4; i += 1) parts.push(p.stops[i][0], p.stops[i][1], p.stops[i][2]);
+		parts.push(p.occlusion[0], p.occlusion[1], p.occlusion[2]);
+		const key = parts.map((v) => v | 0).join(",");
+		if (ballGradients && ballGradients.key === key) return ballGradients;
+		const contact = c2d.createRadialGradient(256, 424, 0, 256, 424, 122);
+		contact.addColorStop(0, rgba(p.contact, .28));
+		contact.addColorStop(1, rgba(p.contact, 0));
+		const body = c2d.createRadialGradient(HEAD_CX - HEAD_R * .28, HEAD_CY - HEAD_R * .34, HEAD_R * .08, HEAD_CX, HEAD_CY, HEAD_R * 1.05);
+		body.addColorStop(0, rgb(p.stops[0]));
+		body.addColorStop(.45, rgb(p.stops[1]));
+		body.addColorStop(.8, rgb(p.stops[2]));
+		body.addColorStop(1, rgb(p.stops[3]));
+		const occlusion = c2d.createRadialGradient(HEAD_CX, HEAD_CY, HEAD_R * .68, HEAD_CX, HEAD_CY, HEAD_R);
+		occlusion.addColorStop(0, rgba(p.occlusion, 0));
+		occlusion.addColorStop(1, rgba(p.occlusion, .22));
+		ballGradients = {
+			key,
+			contact,
+			body,
+			occlusion
+		};
+		return ballGradients;
+	};
+	/** Soft 3D-shaded ball via cached runtime gradients (state colours ease). */
+	const drawBall = (c2d) => {
+		const g = resolveBallGradients(c2d);
+		c2d.fillStyle = g.contact;
+		c2d.beginPath();
+		c2d.ellipse(256, 424, 122, 26, 0, 0, Math.PI * 2);
+		c2d.fill();
+		c2d.fillStyle = g.body;
+		c2d.beginPath();
+		c2d.arc(HEAD_CX, HEAD_CY, HEAD_R, 0, Math.PI * 2);
+		c2d.fill();
+		c2d.fillStyle = g.occlusion;
+		c2d.beginPath();
+		c2d.arc(HEAD_CX, HEAD_CY, HEAD_R, 0, Math.PI * 2);
+		c2d.fill();
+		if (!specGradient) {
+			const spec = c2d.createRadialGradient(200, 190, 0, 200, 190, 64);
+			spec.addColorStop(0, "rgba(255, 255, 255, 0.85)");
+			spec.addColorStop(1, "rgba(255, 255, 255, 0)");
+			specGradient = spec;
+		}
+		c2d.fillStyle = specGradient;
+		c2d.beginPath();
+		c2d.ellipse(200, 190, 64, 48, 0, 0, Math.PI * 2);
+		c2d.fill();
+	};
+	/**
+	* Dashed halo ring — a STATIC face-placement guide, the avatar-mode
+	* counterpart of the white silhouette outline in the normal video view:
+	* it marks where the user should put their face, so it must NOT move or
+	* scale with the tracked pose (the smiley moves within it; a too-close
+	* ball outgrowing the static ring reads as the same "back up" cue the
+	* video outline gives). Fixed centre, fixed radius, always on.
+	*/
+	const drawHalo = (c2d, s, k) => {
+		c2d.save();
+		c2d.translate(s / 2, s / 2);
+		c2d.globalAlpha = .9;
+		c2d.strokeStyle = rgb(eased.halo);
+		c2d.lineWidth = 4 * k;
+		c2d.lineCap = "round";
+		c2d.setLineDash([15 * k, 12 * k]);
+		c2d.beginPath();
+		c2d.arc(0, 0, HALO_R * k, 0, Math.PI * 2);
+		c2d.stroke();
+		c2d.setLineDash([]);
+		c2d.restore();
+	};
+	/** One eye: a near-round dot (open) that flattens to a line as blink → 1. */
+	const drawEye = (c2d, cx, cy, blink, color) => {
+		const ry = 2.5 + (1 - blink) * 14;
+		c2d.fillStyle = color;
+		c2d.beginPath();
+		c2d.ellipse(cx, cy, EYE_RX, ry, 0, 0, Math.PI * 2);
+		c2d.fill();
+	};
+	/** Nose: a short, rounded vertical line under the eyes (personhood cue). */
+	const drawNose = (c2d, color) => {
+		c2d.strokeStyle = color;
+		c2d.lineWidth = 8;
+		c2d.lineCap = "round";
+		c2d.beginPath();
+		c2d.moveTo(HEAD_CX, NOSE_Y0);
+		c2d.lineTo(HEAD_CX, NOSE_Y1);
+		c2d.stroke();
+	};
+	/** Mouth: a rounded line — flat at rest, bowing up with smile, down on frown. */
+	const drawMouth = (c2d, smile, color) => {
+		const cy = MOUTH_Y;
+		const curve = 2 + smile * 32;
+		const lift = smile * 10;
+		c2d.strokeStyle = color;
+		c2d.lineWidth = 11;
+		c2d.lineCap = "round";
+		c2d.beginPath();
+		c2d.moveTo(HEAD_CX - MOUTH_HALF, cy - lift);
+		c2d.quadraticCurveTo(HEAD_CX, cy + curve, 300, cy - lift);
+		c2d.stroke();
+	};
+	return {
+		setState(state) {
+			faceState = state;
+		},
+		setOverrideState(state) {
+			overrideState = state;
+		},
+		dispose() {
+			ctx = null;
+			ballGradients = null;
+			specGradient = null;
+		},
+		render(frame) {
+			const c2d = ctx;
+			if (!c2d) return;
+			const s = size;
+			c2d.clearRect(0, 0, s, s);
+			const nowMs = performance.now();
+			const dtMs = clamp(lastRenderAt > 0 ? nowMs - lastRenderAt : RENDER_DT_SEED_MS, 1, MAX_RENDER_DT_MS);
+			lastRenderAt = nowMs;
+			const state = overrideState ?? resolveGlobalOverride() ?? faceState;
+			easePaletteToward(eased, PALETTES[state], dtAlpha(PALETTE_ALPHA_30, dtMs));
+			const target = frame.tracked ? 1 : 0;
+			presence += (target - presence) * dtAlpha(PRESENCE_ALPHA_30, dtMs);
+			const faceAlpha = presence;
+			const k = s / SPRITE;
+			const slideX = frame.rootOffset.x * s * .03;
+			const slideY = frame.rootOffset.y * s * .03;
+			const scale = 1 + clamp(frame.depth, -.6, .8) * .35;
+			const yaw = clamp(frame.headEuler.y, -.9, .9);
+			const pitch = clamp(frame.headEuler.x, -.9, .9);
+			drawHalo(c2d, s, k);
+			c2d.save();
+			c2d.translate(s / 2 + slideX, s / 2 + slideY);
+			c2d.rotate(frame.headEuler.z);
+			c2d.scale(scale * k, scale * k);
+			c2d.translate(-512 / 2, -512 / 2);
+			if (faceAlpha > .02) {
+				c2d.globalAlpha = faceAlpha;
+				drawBall(c2d);
+				const featX = yaw * YAW_PARALLAX;
+				const featY = pitch * PITCH_PARALLAX;
+				c2d.save();
+				c2d.translate(HEAD_CX, HEAD_CY);
+				c2d.scale(1 - Math.abs(yaw) * .24, 1 - Math.abs(pitch) * .12);
+				c2d.translate(-256, -256);
+				c2d.translate(featX, featY);
+				const feat = rgb(eased.feature);
+				let blinkL = clamp(frame.blink.left, 0, 1);
+				let blinkR = clamp(frame.blink.right, 0, 1);
+				if (state === "success") {
+					blinkL = 0;
+					blinkR = .85;
+				}
+				drawEye(c2d, HEAD_CX - EYE_DX, EYE_Y, blinkL, feat);
+				drawEye(c2d, 312, EYE_Y, blinkR, feat);
+				drawNose(c2d, feat);
+				let mouth = Math.max(REST_SMILE, clamp(frame.smile ?? 0, 0, 1));
+				if (state === "success") mouth = 1;
+				else if (state === "error") mouth = -.55;
+				drawMouth(c2d, mouth, feat);
+				c2d.restore();
+				c2d.globalAlpha = 1;
+			}
+			c2d.restore();
+		}
+	};
+}
+/**
+* Main-thread wrapper: owns a DOM `<canvas>` and delegates to the shared
+* drawing core. Public shape unchanged for existing consumers (`incode-2d`,
+* `avatar-2d` main path).
+*/
+var SatinSmileyRenderer = class {
+	constructor(size = 512) {
+		this.core = null;
+		this.pendingState = "detecting";
+		this.canvas = document.createElement("canvas");
+		this.canvas.width = size;
+		this.canvas.height = size;
+	}
+	getCanvas() {
+		return this.canvas;
+	}
+	/** Set the verdict state (detecting/success/error); colours ease toward it. */
+	setState(state) {
+		this.pendingState = state;
+		this.core?.setState(state);
+	}
+	init() {
+		this.core = createSatinSmileyCore(this.canvas);
+		this.core.setState(this.pendingState);
+	}
+	dispose() {
+		this.core?.dispose();
+		this.core = null;
+	}
+	render(frame) {
+		this.core?.render(frame);
+	}
+};
+//#endregion
+//#region ../infra/src/avatar/2d-default-avatar/pose.ts
+const AVATAR2D_POSE_CONFIG = {
+	yawGain: 2.2,
+	pitchUpGain: 3.4,
+	pitchDownGain: 2.6,
+	rollGain: 1,
+	rotMax: .9,
+	lateralGain: 1.6,
+	lateralMax: 1,
+	depthGain: 2,
+	depthMax: .8,
+	signYaw: 1,
+	signPitch: 1,
+	signRoll: 1,
+	signX: 1,
+	signY: 1
+};
+const AVATAR2D_DEADZONE = {
+	rot: .005,
+	roll: .006,
+	pos: .03,
+	depth: .1
+};
+/**
+* Below this face-size ratio the detector emits sporadic single-frame outlier
+* spikes ("the avatar jumps") that the deadzone (idle-only) and the EMA (delays,
+* doesn't reject) both miss; run the {@link Median} first in that regime. At/above
+* it, the face is near and exp smoothing alone is enough. (FACE_AVATAR.md → Pose pipeline.)
+*/
+const MEDIAN_FACE_RATIO = .35;
+/**
+* Single-axis rolling-window median for outlier rejection. Returns the latest
+* sample until the window fills (no start-up lag spike), then the middle of the
+* sorted window. The buffer stays in insertion order so `shift()` evicts the
+* OLDEST sample, not the smallest. Ported from the incode-personhood-widget
+* `MedianFilter` — **copied, not shared** (POC isolation; renderer is the only
+* shared surface). Use three independent instances (one per axis).
+*
+* SELF-CONTAINED (window size is a ctor arg, `slice()` not spread) — it is
+* `toString()`-serialized into the avatar-2d worker.
+*/
+var Median = class {
+	constructor(windowSize = 7) {
+		this.buf = [];
+		this.windowSize = windowSize;
+	}
+	reset() {
+		this.buf = [];
+	}
+	filter(x) {
+		this.buf.push(x);
+		if (this.buf.length > this.windowSize) this.buf.shift();
+		if (this.buf.length < this.windowSize) return x;
+		const sorted = this.buf.slice().sort((a, b) => a - b);
+		return sorted[Math.floor(sorted.length / 2)];
+	}
+};
+/**
+* Caps on the auto-calibrated neutral so calibration cancels small device/framing
+* bias but NOT the user's real starting orientation. Yaw/roll only (straight ≈ 0
+* for both); pitch + position are left unbounded (pitch has a person-specific
+* baseline; position is genuine framing) — bounding those risks an "always looks
+* down/off-centre" artifact. Tune on device.
+*/
+const AVATAR2D_NEUTRAL_BIAS = {
+	yaw: .06,
+	roll: .05
+};
+/**
+* Extract the compact payload from a FaceLandmarker result. Returns null when
+* no usable face. **SELF-CONTAINED** — no module refs (the mesh indices are
+* inlined: nose tip 4, left eye outer 33 / inner 133, right eye outer 263 /
+* inner 362, forehead 10, chin 152 — see the LM_* docs above) — because it is
+* `toString()`-serialized into the avatar-2d worker; it is also the first half
+* of the main-thread {@link computeRawPose}. Keep it free of spread/helpers.
+*/
+function extractCompactFace(result) {
+	const lm = result.faceLandmarks && result.faceLandmarks[0];
+	if (!lm) return null;
+	const nose = lm[4];
+	const eyeLo = lm[33];
+	const eyeLi = lm[133];
+	const eyeRo = lm[263];
+	const eyeRi = lm[362];
+	const forehead = lm[10];
+	const chin = lm[152];
+	if (!nose || !eyeLo || !eyeLi || !eyeRo || !eyeRi || !forehead || !chin) return null;
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	for (let i = 0; i < lm.length; i += 1) {
+		const p = lm[i];
+		if (p.x < minX) minX = p.x;
+		if (p.x > maxX) maxX = p.x;
+		if (p.y < minY) minY = p.y;
+		if (p.y > maxY) maxY = p.y;
+	}
+	let blinkL = 0;
+	let blinkR = 0;
+	let jawOpen = 0;
+	let smileL = 0;
+	let smileR = 0;
+	const shapes = result.faceBlendshapes && result.faceBlendshapes[0];
+	const categories = shapes && shapes.categories || [];
+	for (const c of categories) if (c.categoryName === "eyeBlinkLeft") blinkL = c.score;
+	else if (c.categoryName === "eyeBlinkRight") blinkR = c.score;
+	else if (c.categoryName === "jawOpen") jawOpen = c.score;
+	else if (c.categoryName === "mouthSmileLeft") smileL = c.score;
+	else if (c.categoryName === "mouthSmileRight") smileR = c.score;
+	return {
+		nx: nose.x,
+		ny: nose.y,
+		lox: eyeLo.x,
+		loy: eyeLo.y,
+		lix: eyeLi.x,
+		liy: eyeLi.y,
+		rox: eyeRo.x,
+		roy: eyeRo.y,
+		rix: eyeRi.x,
+		riy: eyeRi.y,
+		foreheadY: forehead.y,
+		chinY: chin.y,
+		bboxW: maxX - minX,
+		bboxH: maxY - minY,
+		blinkL,
+		blinkR,
+		jawOpen,
+		smile: (smileL + smileR) / 2
+	};
+}
+/**
+* Raw pose from a compact face, in **pixel space** (multiply normalized coords
+* by the DETECT input width/height — worker and main must use the same dims as
+* calibration) so distances/angles aren't skewed on non-square frames.
+* Returns null on a non-finite frame (NaN guard).
+*/
+function rawPoseFromCompact(c, width, height) {
+	const nx = c.nx * width;
+	const ny = c.ny * height;
+	const lx = (c.lox + c.lix) / 2 * width;
+	const ly = (c.loy + c.liy) / 2 * height;
+	const rx = (c.rox + c.rix) / 2 * width;
+	const ry = (c.roy + c.riy) / 2 * height;
+	const fy = c.foreheadY * height;
+	const cy = c.chinY * height;
+	const eyeMidX = (lx + rx) / 2;
+	const eyeMidY = (ly + ry) / 2;
+	const faceMidY = (fy + cy) / 2;
+	const eyeDist = Math.hypot(rx - lx, ry - ly) || 1e-4;
+	const faceH = Math.abs(cy - fy) || 1e-4;
+	const yaw = (nx - eyeMidX) / eyeDist;
+	const pitch = (ny - faceMidY) / faceH;
+	const roll = Math.atan2(ry - ly, rx - lx);
+	if (!Number.isFinite(yaw) || !Number.isFinite(pitch) || !Number.isFinite(roll) || !Number.isFinite(eyeMidX) || !Number.isFinite(eyeDist)) return null;
+	let faceSizeRatio;
+	if (width > 0 && height > 0) {
+		const bw = c.bboxW * width;
+		const bh = c.bboxH * height;
+		if (bw > 0 && bh > 0) faceSizeRatio = Math.sqrt(bw * bh) / Math.min(width, height);
+	}
+	return {
+		yaw,
+		pitch,
+		roll,
+		eyeMidX,
+		eyeMidY,
+		eyeDist,
+		faceH,
+		faceSizeRatio
+	};
+}
+/**
+* Map a raw pose (relative to neutral) into head euler + offset + depth.
+* SELF-CONTAINED (deadzones arrive as a param; clamp/deadzone inlined) — it is
+* `toString()`-serialized into the avatar-2d worker.
+*/
+function mapToPose(raw, neutral, cfg, dz) {
+	const deadzone = (v, d) => Math.abs(v) <= d ? 0 : v - Math.sign(v) * d;
+	const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+	let dRoll = raw.roll - neutral.roll;
+	dRoll = Math.atan2(Math.sin(dRoll), Math.cos(dRoll));
+	const dist = neutral.dist || 1e-4;
+	const dPitch = deadzone(raw.pitch - neutral.pitch, dz.rot);
+	const pitchGain = dPitch < 0 ? cfg.pitchUpGain : cfg.pitchDownGain;
+	const dYaw = deadzone(raw.yaw - neutral.yaw, dz.rot);
+	const dRollDz = deadzone(dRoll, dz.roll);
+	const relX = deadzone((raw.eyeMidX - neutral.cx) / dist, dz.pos);
+	const relY = deadzone((raw.eyeMidY - neutral.cy) / dist, dz.pos);
+	const faceHN = neutral.faceH || 1e-4;
+	const relZ = deadzone((raw.faceH - neutral.faceH) / faceHN, dz.depth);
+	return {
+		headEuler: {
+			x: clamp(dPitch * pitchGain * cfg.signPitch, -cfg.rotMax, cfg.rotMax),
+			y: clamp(dYaw * cfg.yawGain * cfg.signYaw, -cfg.rotMax, cfg.rotMax),
+			z: clamp(dRollDz * cfg.rollGain * cfg.signRoll, -cfg.rotMax, cfg.rotMax)
+		},
+		rootOffset: {
+			x: clamp(relX * cfg.lateralGain * cfg.signX, -cfg.lateralMax, cfg.lateralMax),
+			y: clamp(relY * cfg.lateralGain * cfg.signY, -cfg.lateralMax, cfg.lateralMax)
+		},
+		depth: clamp(relZ * cfg.depthGain, -cfg.depthMax, cfg.depthMax)
+	};
+}
+//#endregion
+//#region ../infra/src/avatar/2d-default-avatar/avatar2dCore.ts
+/**
+* Avatar-2d shared cores (ENG-49806 render-in-worker refactor).
+*
+* The lens's `privacyLensGlCore.ts` pattern applied to the 2D avatar: the
+* pieces of the pipeline that must run in BOTH transports (main thread and the
+* worker) live here as **self-contained, `toString()`-serializable factories**
+* with a single source of truth:
+*
+*  - {@link createAvatar2DPoseCore} — compact-face ingestion → median outlier
+*    rejection → averaged-neutral calibration (velocity-gated, time-boxed) →
+*    face-lost gate → dt-corrected EMA smoothing → the pose to render.
+*
+* Serialization rules (same as the lens): factory bodies must not reference
+* ANY module-level binding — tuning constants arrive via the JSON-injectable
+* {@link AVATAR2D_POSE_CORE_DEFAULTS} config, and cross-function calls go
+* through the `deps` object (minifier-safe). Types are fine (they vanish).
+*/
+/**
+* The pose-pipeline tuning, single home (both transports; the worker builder
+* JSON-injects it). `dtSeedMs` is derived from the effective maxFps at start.
+*/
+const AVATAR2D_POSE_CORE_DEFAULTS = {
+	pose: AVATAR2D_POSE_CONFIG,
+	deadzone: AVATAR2D_DEADZONE,
+	neutralBias: AVATAR2D_NEUTRAL_BIAS,
+	medianWindow: 7,
+	medianFaceRatio: MEDIAN_FACE_RATIO,
+	medianMaxGapMs: 120,
+	neutralFrames: 20,
+	calMotionYawPitch: .012,
+	calMotionRoll: .02,
+	calFallbackMult: 3,
+	calMinFrames: 1,
+	calMaxMs: 300,
+	faceLostMs: 600,
+	faceLostMinMisses: 2,
+	faceLostHardMs: 3e3,
+	headAlpha: .4,
+	posAlpha: .35,
+	depthAlpha: .2,
+	exprAlpha: .5,
+	refFrameMs: 1e3 / 30,
+	maxEmaDtMs: 100,
+	dtSeedMs: 1e3 / 30
+};
+/** Main-thread deps instance (the worker builder assembles its own). */
+function createAvatar2DPoseCoreDeps() {
+	return {
+		rawPoseFromCompact,
+		mapToPose,
+		createMedian: (windowSize) => new Median(windowSize)
+	};
+}
+/**
+* The pose pipeline, transport-agnostic. SELF-CONTAINED (serialized via
+* toString into the worker blob): everything arrives via `cfg` / `deps`.
+*/
+function createAvatar2DPoseCore(cfg, deps) {
+	const neutralPose = () => ({
+		tracked: false,
+		headEuler: {
+			x: 0,
+			y: 0,
+			z: 0
+		},
+		rootOffset: {
+			x: 0,
+			y: 0
+		},
+		depth: 0,
+		blink: {
+			left: 0,
+			right: 0
+		},
+		mouthOpen: 0,
+		smile: 0
+	});
+	const copyPoseInto = (dst, src) => {
+		dst.tracked = src.tracked;
+		dst.headEuler.x = src.headEuler.x;
+		dst.headEuler.y = src.headEuler.y;
+		dst.headEuler.z = src.headEuler.z;
+		dst.rootOffset.x = src.rootOffset.x;
+		dst.rootOffset.y = src.rootOffset.y;
+		dst.depth = src.depth;
+		dst.blink.left = src.blink.left;
+		dst.blink.right = src.blink.right;
+		dst.mouthOpen = src.mouthOpen;
+		dst.smile = src.smile;
+	};
+	const clampValue = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+	const dtAlpha = (refAlpha, dtMs) => {
+		if (refAlpha <= 0) return 0;
+		if (refAlpha >= 1) return 1;
+		const tau = -cfg.refFrameMs / Math.log(1 - refAlpha);
+		return 1 - Math.exp(-dtMs / tau);
+	};
+	const current = neutralPose();
+	let target = neutralPose();
+	let lastFaceAt = 0;
+	let missedDetects = 0;
+	let lastTickAt = 0;
+	let calibrated = false;
+	let nFrames = 0;
+	let calAttempts = 0;
+	let calStartAt = 0;
+	let prevCalYaw = NaN;
+	let prevCalPitch = NaN;
+	let prevCalRoll = NaN;
+	let seeded = false;
+	const sum = {
+		yaw: 0,
+		pitch: 0,
+		roll: 0,
+		cx: 0,
+		cy: 0,
+		dist: 0,
+		faceH: 0
+	};
+	let neutral = {
+		yaw: 0,
+		pitch: 0,
+		roll: 0,
+		cx: 0,
+		cy: 0,
+		dist: 1,
+		faceH: 1
+	};
+	const medYaw = deps.createMedian(cfg.medianWindow);
+	const medPitch = deps.createMedian(cfg.medianWindow);
+	const medRoll = deps.createMedian(cfg.medianWindow);
+	return {
+		ingest(face, width, height, now) {
+			let landed = false;
+			const raw0 = face ? deps.rawPoseFromCompact(face, width, height) : null;
+			if (face && raw0) {
+				landed = true;
+				const small = !(now - lastFaceAt > cfg.medianMaxGapMs) && raw0.faceSizeRatio !== void 0 && raw0.faceSizeRatio < cfg.medianFaceRatio;
+				let raw = raw0;
+				if (small) raw = {
+					yaw: medYaw.filter(raw0.yaw),
+					pitch: medPitch.filter(raw0.pitch),
+					roll: medRoll.filter(raw0.roll),
+					eyeMidX: raw0.eyeMidX,
+					eyeMidY: raw0.eyeMidY,
+					eyeDist: raw0.eyeDist,
+					faceH: raw0.faceH,
+					faceSizeRatio: raw0.faceSizeRatio
+				};
+				else {
+					medYaw.reset();
+					medPitch.reset();
+					medRoll.reset();
+				}
+				lastFaceAt = now;
+				if (!calibrated) {
+					calAttempts += 1;
+					if (calStartAt === 0) calStartAt = now;
+					const dRollMotion = Math.atan2(Math.sin(raw.roll - prevCalRoll), Math.cos(raw.roll - prevCalRoll));
+					const moved = Number.isFinite(prevCalYaw) && (Math.abs(raw.yaw - prevCalYaw) > cfg.calMotionYawPitch || Math.abs(raw.pitch - prevCalPitch) > cfg.calMotionYawPitch || Math.abs(dRollMotion) > cfg.calMotionRoll);
+					prevCalYaw = raw.yaw;
+					prevCalPitch = raw.pitch;
+					prevCalRoll = raw.roll;
+					const fallback = calAttempts >= cfg.neutralFrames * cfg.calFallbackMult || now - calStartAt > cfg.calMaxMs;
+					if (!moved || fallback) {
+						nFrames += 1;
+						sum.yaw += raw.yaw;
+						sum.pitch += raw.pitch;
+						sum.roll += raw.roll;
+						sum.cx += raw.eyeMidX;
+						sum.cy += raw.eyeMidY;
+						sum.dist += raw.eyeDist;
+						sum.faceH += raw.faceH;
+					}
+					const timeBoxed = nFrames >= cfg.calMinFrames && now - calStartAt > cfg.calMaxMs;
+					if (nFrames >= cfg.neutralFrames || timeBoxed) {
+						const n = nFrames;
+						neutral = {
+							yaw: clampValue(sum.yaw / n, -cfg.neutralBias.yaw, cfg.neutralBias.yaw),
+							pitch: sum.pitch / n,
+							roll: clampValue(sum.roll / n, -cfg.neutralBias.roll, cfg.neutralBias.roll),
+							cx: sum.cx / n,
+							cy: sum.cy / n,
+							dist: sum.dist / n || 1,
+							faceH: sum.faceH / n || 1
+						};
+						calibrated = true;
+					}
+				}
+				if (calibrated) {
+					const mapped = deps.mapToPose(raw, neutral, cfg.pose, cfg.deadzone);
+					target = {
+						tracked: true,
+						headEuler: {
+							x: mapped.headEuler.x,
+							y: mapped.headEuler.y,
+							z: mapped.headEuler.z
+						},
+						rootOffset: {
+							x: mapped.rootOffset.x,
+							y: mapped.rootOffset.y
+						},
+						depth: mapped.depth,
+						blink: {
+							left: face.blinkL,
+							right: face.blinkR
+						},
+						mouthOpen: face.jawOpen,
+						smile: face.smile
+					};
+					if (!seeded) {
+						copyPoseInto(current, target);
+						seeded = true;
+					}
+				}
+			}
+			missedDetects = landed ? 0 : missedDetects + 1;
+		},
+		tick(now) {
+			const dtMs = clampValue(lastTickAt > 0 ? now - lastTickAt : cfg.dtSeedMs, 1, cfg.maxEmaDtMs);
+			lastTickAt = now;
+			if (now - lastFaceAt > cfg.faceLostMs && missedDetects >= cfg.faceLostMinMisses || now - lastFaceAt > cfg.faceLostHardMs) target = neutralPose();
+			const ha = dtAlpha(cfg.headAlpha, dtMs);
+			const pa = dtAlpha(cfg.posAlpha, dtMs);
+			const da = dtAlpha(cfg.depthAlpha, dtMs);
+			const ea = dtAlpha(cfg.exprAlpha, dtMs);
+			const c = current;
+			const t = target;
+			c.tracked = t.tracked;
+			c.headEuler.x += (t.headEuler.x - c.headEuler.x) * ha;
+			c.headEuler.y += (t.headEuler.y - c.headEuler.y) * ha;
+			c.headEuler.z += (t.headEuler.z - c.headEuler.z) * ha;
+			c.rootOffset.x += (t.rootOffset.x - c.rootOffset.x) * pa;
+			c.rootOffset.y += (t.rootOffset.y - c.rootOffset.y) * pa;
+			c.depth += (t.depth - c.depth) * da;
+			c.blink.left += (t.blink.left - c.blink.left) * ea;
+			c.blink.right += (t.blink.right - c.blink.right) * ea;
+			c.mouthOpen += (t.mouthOpen - c.mouthOpen) * ea;
+			c.smile += (t.smile - c.smile) * ea;
+			return current;
+		}
+	};
+}
+//#endregion
+//#region ../infra/src/avatar/2d-default-avatar/avatar2dWorker.ts
+/**
+* Worker mode for the 2D avatar (ENG-49806) — TWO workers, full pipeline
+* off-main.
+*
+* Under a saturated main thread (the synchronous WASM capture pipeline runs
+* back-to-back on throttled/low-tier devices) ANY main-thread loop is starved
+* to single-digit fps no matter how cheap its frame is. And on low-tier
+* silicon a SINGLE worker is not enough either: one MediaPipe inference costs
+* ~200-250ms on a Cortex-A53 under capture contention, blocking that worker's
+* own render loop to ~8fps (measured on a Galaxy A04e; adaptive cadence alone
+* capped inference duty at 50% but every inference still froze the ball
+* mid-drift). So the pipeline is SPLIT:
+*
+*  - RENDER worker — pose core + SatinSmiley on the transferred
+*    `OffscreenCanvas`, worker-rAF loop + tolerance pacer. Its frame costs
+*    ~0.3ms and NOTHING in it ever blocks → ~25-30fps even on the A04e.
+*  - TRACK worker — camera track (cloned) → `MediaStreamTrackProcessor` →
+*    `VideoFrame` downscale → FaceLandmarker, at an adaptive cadence (EMA'd
+*    cost × 2 — never more than ~50% of its own thread). Each detect posts a
+*    tiny compact-face message over a `MessageChannel` DIRECTLY to the render
+*    worker (never through the contended main thread).
+*
+* The main thread only bridges dev flags and verdict-state cues, and
+* re-publishes the render worker's stats snapshots.
+*
+* Boot keeps the instant-mount contract (sub-second halo): the render
+* worker's `'started'` handshake covers only its core init (ms). The track
+* worker's MediaPipe bring-up (module + ~3.7MB model + WASM compile) runs in
+* the background — or, better, ALREADY RAN during the tutorial via the warm
+* registry (`avatar2dWarm.ts` warms a track worker; the provider adopts it).
+* Tracking failure leaves the avatar in the searching state ('trackingFatal'
+* logged) — the face stays concealed either way.
+*
+* Support: Chromium 94+ (Chrome/Edge/Android WebView/Samsung Internet) — the
+* low-tier Android target segment. Safari/Firefox and strict-CSP hosts fall
+* back to the main-thread path automatically (`Face2DProvider`).
+*
+* Packaging: like the lens, both worker scripts are assembled AT RUNTIME from
+* `Function.prototype.toString()` of the self-contained factories and loaded
+* via Blob URLs — no separate worker chunks, bundler-agnostic. They are
+* CLASSIC workers (NOT `{ type: 'module' }`): MediaPipe's wasm glue loads
+* itself via `importScripts()`, which module workers lack — booting
+* tasks-vision in a module worker dies with "ModuleFactory not set". The
+* tasks-vision ESM is instead dynamic-imported via a Function-constructed
+* `import()` (see `avatar2dTrackWorkerMain`) — supported in Chromium classic
+* dedicated workers, the only environment these workers run in (probe-gated).
+* No `window.Module` shield is needed in-worker — ml-wasm-kit never runs
+* there.
+*/
+/**
+* Whether the worker path is available in this environment. Anything missing
+* (Safari's worker-only MSTP shape, Firefox, old WebView) routes to the
+* main-thread fallback.
+*/
+function canUseAvatar2DWorker() {
+	const g = globalThis;
+	if (typeof g.MediaStreamTrackProcessor !== "function" || typeof g.Worker !== "function" || typeof g.MessageChannel !== "function" || typeof g.HTMLCanvasElement !== "function") return false;
+	return "transferControlToOffscreen" in g.HTMLCanvasElement.prototype;
+}
+/**
+* RENDER worker logic. SELF-CONTAINED (serialized via toString into the
+* blob): everything arrives via `deps` / messages; no module refs. The loop
+* is worker-rAF when available (Chromium exposes it in dedicated workers),
+* else setTimeout ~60Hz; the tolerance-based pacer enforces maxFps. Pose
+* updates arrive on the channel port and are ingested on receipt — nothing
+* in this worker ever blocks longer than a canvas-2D draw (~0.3ms).
+*/
+function avatar2dRenderWorkerMain(scope, deps) {
+	let stopped = false;
+	let poseCore = null;
+	let smiley = null;
+	let pacer = null;
+	let port = null;
+	let statsEnabled = false;
+	let rafId = null;
+	let timerId = null;
+	const PUBLISH_MS = 500;
+	const GAP_WINDOW = 128;
+	let renderedTotal = 0;
+	let dropped = 0;
+	let winStart = NaN;
+	let winFrames = 0;
+	let drawSum = 0;
+	let detectSum = 0;
+	let detectCount = 0;
+	const gaps = [];
+	let lastFrameAt = NaN;
+	let trackingStatus = "loading";
+	let detectsRun = 0;
+	let facesFound = 0;
+	let lastDims = "";
+	let debugIntervalMs = 0;
+	const publishStats = (nowMs) => {
+		const elapsed = nowMs - winStart;
+		if (!(elapsed > 0)) return;
+		const fps = Math.round(winFrames / elapsed * 1e3 * 10) / 10;
+		const snapshot = {
+			variant: "avatar-2d",
+			mode: "worker",
+			avatarFps: fps,
+			renderedFps: fps,
+			renderedTotal,
+			droppedByThrottle: dropped,
+			tsMs: nowMs
+		};
+		if (winFrames > 0) snapshot.drawMsAvg = Math.round(drawSum / winFrames * 100) / 100;
+		if (detectCount > 0) snapshot.uploadMsAvg = Math.round(detectSum / detectCount * 100) / 100;
+		if (gaps.length > 0) {
+			const sorted = gaps.slice().sort((a, b) => a - b);
+			const idx = Math.min(sorted.length - 1, Math.floor(sorted.length * .95));
+			snapshot.frameGapP95Ms = Math.round(sorted[idx] * 10) / 10;
+		}
+		snapshot.debug = "landmarker=" + trackingStatus + " dims=" + (lastDims || "?") + " faces=" + facesFound + "/" + detectsRun + " detInt=" + Math.round(debugIntervalMs) + "ms";
+		scope.postMessage({
+			type: "stats",
+			snapshot
+		});
+		winStart = nowMs;
+		winFrames = 0;
+		drawSum = 0;
+		detectSum = 0;
+		detectCount = 0;
+	};
+	const renderTick = () => {
+		if (stopped || !poseCore || !smiley || !pacer) return;
+		if (typeof requestAnimationFrame === "function") rafId = requestAnimationFrame(renderTick);
+		else timerId = setTimeout(renderTick, 16);
+		const now = performance.now();
+		if (!pacer.shouldRender(now)) {
+			if (statsEnabled) dropped += 1;
+			return;
+		}
+		const frameStart = statsEnabled ? performance.now() : 0;
+		smiley.render(poseCore.tick(now));
+		if (statsEnabled) {
+			renderedTotal += 1;
+			if (Number.isNaN(winStart)) winStart = now;
+			else {
+				winFrames += 1;
+				drawSum += performance.now() - frameStart;
+			}
+			if (!Number.isNaN(lastFrameAt)) {
+				gaps.push(now - lastFrameAt);
+				if (gaps.length > GAP_WINDOW) gaps.shift();
+			}
+			lastFrameAt = now;
+			if (now - winStart >= PUBLISH_MS) publishStats(now);
+		}
+	};
+	const onPortMessage = (event) => {
+		const msg = event.data;
+		if (msg.kind === "face") {
+			if (poseCore) poseCore.ingest(msg.face, msg.width, msg.height, performance.now());
+			detectsRun += 1;
+			if (msg.face) facesFound += 1;
+			lastDims = msg.width + "x" + msg.height;
+			debugIntervalMs = msg.detIntervalMs;
+			if (statsEnabled) {
+				detectSum += msg.detectMs;
+				detectCount += 1;
+			}
+		} else if (msg.kind === "tracking") trackingStatus = msg.status === "up" ? "up" : "FAILED";
+	};
+	scope.onmessage = (event) => {
+		const msg = event.data;
+		if (msg.type === "start") {
+			try {
+				smiley = deps.createSmileyCore(msg.canvas);
+				poseCore = deps.createPoseCore(msg.poseConfig);
+				pacer = deps.createPacer(msg.maxFps, 8);
+				port = msg.port;
+				port.onmessage = onPortMessage;
+			} catch (error) {
+				scope.postMessage({
+					type: "fatal",
+					message: String(error)
+				});
+				return;
+			}
+			statsEnabled = msg.statsEnabled;
+			scope.postMessage({ type: "started" });
+			renderTick();
+		} else if (msg.type === "state") smiley?.setState(msg.state);
+		else if (msg.type === "override") smiley?.setOverrideState(msg.state);
+		else if (msg.type === "statsEnabled") {
+			if (msg.value && !statsEnabled) {
+				winStart = NaN;
+				lastFrameAt = NaN;
+			}
+			statsEnabled = msg.value;
+		} else if (msg.type === "stop") {
+			stopped = true;
+			if (rafId != null && typeof cancelAnimationFrame === "function") cancelAnimationFrame(rafId);
+			if (timerId != null) clearTimeout(timerId);
+			try {
+				port?.close();
+			} catch {}
+			port = null;
+			smiley?.dispose();
+			smiley = null;
+			scope.postMessage({ type: "stopped" });
+		}
+	};
+}
+/**
+* TRACK worker logic. SELF-CONTAINED (serialized via toString into the
+* blob). Detect pump: sequential read → adaptive cadence gate → downscale →
+* detect → post compact face to the render worker's port → 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
+* avatar must never do (cosmetic-only invariant).
+*/
+function avatar2dTrackWorkerMain(scope, deps) {
+	let stopped = false;
+	let reader = null;
+	let landmarker = null;
+	let port = null;
+	let inputCanvas = null;
+	let inputCtx = null;
+	let landmarkerPromise = null;
+	let lastPaths = null;
+	const initLandmarker = (paths) => (async () => {
+		lastPaths = {
+			mediapipeModulePath: paths.mediapipeModulePath,
+			mediapipeWasmPath: paths.mediapipeWasmPath,
+			faceLandmarkerModelPath: paths.faceLandmarkerModelPath
+		};
+		try {
+			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 tasksVision = await new Function("u", "return import(u)")(paths.mediapipeModulePath);
+			const fileset = await tasksVision.FilesetResolver.forVisionTasks(paths.mediapipeWasmPath);
+			const modelBytes = await modelBytesPromise;
+			landmarker = await tasksVision.FaceLandmarker.createFromOptions(fileset, {
+				baseOptions: {
+					...modelBytes ? { modelAssetBuffer: modelBytes } : { modelAssetPath: paths.faceLandmarkerModelPath },
+					delegate: "CPU"
+				},
+				runningMode: "VIDEO",
+				numFaces: 1,
+				outputFaceBlendshapes: true,
+				outputFacialTransformationMatrixes: false
+			});
+		} catch (error) {
+			scope.postMessage({
+				type: "trackingFatal",
+				message: String(error)
+			});
+			return false;
+		}
+		if (stopped) {
+			try {
+				landmarker.close();
+			} catch {}
+			landmarker = null;
+			return false;
+		}
+		try {
+			const warmupCanvas = new OffscreenCanvas(320, 240);
+			const warmupCtx = warmupCanvas.getContext("2d");
+			if (warmupCtx) {
+				warmupCtx.fillRect(0, 0, 320, 240);
+				landmarker.detectForVideo(warmupCanvas, performance.now());
+			}
+		} catch {}
+		return true;
+	})();
+	const detectPump = async (cfg) => {
+		let lastDetectAt = -Infinity;
+		let detectCostEma = 0;
+		let minIntervalMs = cfg.detectMinIntervalMs;
+		const SEARCH_MISSES = 3;
+		const SEARCH_MIN_INTERVAL_MS = 330;
+		const SEARCH_DUTY_FACTOR = 4;
+		let noFaceStreak = 0;
+		const MAX_DETECT_THROWS = 30;
+		let detectThrows = 0;
+		while (!stopped && reader && landmarker && port) {
+			let result;
+			try {
+				result = await reader.read();
+			} catch {
+				break;
+			}
+			if (result.done) break;
+			const frame = result.value;
+			try {
+				const now = performance.now();
+				if (now - lastDetectAt < minIntervalMs - cfg.detectIntervalToleranceMs) continue;
+				const fw = frame.displayWidth;
+				const fh = frame.displayHeight;
+				if (!(fw > 0 && fh > 0)) continue;
+				lastDetectAt = now;
+				const scale = Math.min(1, cfg.detectMaxEdge / Math.max(fw, fh));
+				const dw = Math.max(1, Math.round(fw * scale));
+				const dh = Math.max(1, Math.round(fh * scale));
+				if (!inputCanvas || inputCanvas.width !== dw || inputCanvas.height !== dh) {
+					inputCanvas = new OffscreenCanvas(dw, dh);
+					inputCtx = inputCanvas.getContext("2d");
+				}
+				if (!inputCtx) continue;
+				inputCtx.drawImage(frame, 0, 0, dw, dh);
+				let detected = null;
+				try {
+					detected = landmarker.detectForVideo(inputCanvas, now);
+					detectThrows = 0;
+				} catch {
+					detected = null;
+					detectThrows += 1;
+				}
+				const face = detected ? deps.extractCompact(detected) : null;
+				const detectCost = performance.now() - now;
+				const reacquired = face !== null && noFaceStreak >= SEARCH_MISSES;
+				noFaceStreak = face ? 0 : noFaceStreak + 1;
+				detectCostEma = detectCostEma === 0 || reacquired ? detectCost : detectCostEma + (detectCost - detectCostEma) * .3;
+				minIntervalMs = noFaceStreak >= SEARCH_MISSES ? Math.max(SEARCH_MIN_INTERVAL_MS, detectCostEma * SEARCH_DUTY_FACTOR) : Math.max(cfg.detectMinIntervalMs, detectCostEma * 1.5);
+				port.postMessage({
+					kind: "face",
+					face,
+					width: dw,
+					height: dh,
+					detectMs: detectCost,
+					detIntervalMs: minIntervalMs
+				});
+			} catch {} finally {
+				frame.close();
+			}
+			if (detectThrows >= MAX_DETECT_THROWS && !stopped && lastPaths) {
+				detectThrows = 0;
+				try {
+					landmarker?.close();
+				} catch {}
+				landmarker = null;
+				landmarkerPromise = initLandmarker(lastPaths);
+				if (!await landmarkerPromise) break;
+			}
+		}
+	};
+	scope.onmessage = (event) => {
+		const msg = event.data;
+		if (msg.type === "warm") {
+			if (!landmarkerPromise) {
+				landmarkerPromise = initLandmarker(msg);
+				landmarkerPromise.then((ok) => {
+					if (ok) scope.postMessage({ type: "warmed" });
+				});
+			}
+		} else if (msg.type === "start") {
+			port = msg.port;
+			(async () => {
+				let ok = landmarkerPromise ? await landmarkerPromise : false;
+				if (!ok && !stopped) {
+					landmarkerPromise = initLandmarker(msg);
+					ok = await landmarkerPromise;
+				}
+				if (!ok || stopped || !landmarker || !port) {
+					try {
+						port?.postMessage({
+							kind: "tracking",
+							status: "failed"
+						});
+					} catch {}
+					return;
+				}
+				port.postMessage({
+					kind: "tracking",
+					status: "up"
+				});
+				reader = msg.readable.getReader();
+				detectPump({
+					detectMaxEdge: msg.detectMaxEdge,
+					detectMinIntervalMs: msg.detectMinIntervalMs,
+					detectIntervalToleranceMs: msg.detectIntervalToleranceMs
+				});
+			})();
+		} else if (msg.type === "stop") {
+			stopped = true;
+			try {
+				reader?.cancel();
+			} catch {}
+			try {
+				landmarker?.close();
+			} catch {}
+			landmarker = null;
+			try {
+				port?.close();
+			} catch {}
+			port = null;
+			scope.postMessage({ type: "stopped" });
+		}
+	};
+}
+/**
+* Assemble the RENDER worker script (pose core + smiley core + pacer + main).
+* Everything referenced must be self-contained (see module doc); the deps
+* wiring re-creates the same composition `createAvatar2DPoseCoreDeps`
+* provides on the main thread. Runtime config travels in the 'start' message.
+*/
+function buildAvatar2DRenderWorkerSource() {
+	return [
+		"\"use strict\";",
+		`const rawPoseFromCompact = ${rawPoseFromCompact.toString()};`,
+		`const mapToPose = ${mapToPose.toString()};`,
+		`const Median = ${Median.toString()};`,
+		`const createPoseCoreImpl = ${createAvatar2DPoseCore.toString()};`,
+		`const createSmileyCore = ${createSatinSmileyCore.toString()};`,
+		`const createPacer = ${createFramePacer.toString()};`,
+		`const workerMain = ${avatar2dRenderWorkerMain.toString()};`,
+		`workerMain(self, {
+  createPoseCore: (cfg) =>
+    createPoseCoreImpl(cfg, {
+      rawPoseFromCompact,
+      mapToPose,
+      createMedian: (windowSize) => new Median(windowSize),
+    }),
+  createSmileyCore,
+  createPacer,
+});`
+	].join("\n");
+}
+/** Assemble the TRACK worker script (compact-face extraction + main). */
+function buildAvatar2DTrackWorkerSource() {
+	return [
+		"\"use strict\";",
+		`const extractCompact = ${extractCompactFace.toString()};`,
+		`const workerMain = ${avatar2dTrackWorkerMain.toString()};`,
+		"workerMain(self, { extractCompact });"
+	].join("\n");
+}
+//#endregion
+//#region ../infra/src/avatar/2d-default-avatar/avatar2dWarm.ts
+/**
+* Pre-capture warm-up registry for the avatar-2d worker (ENG-49806 AC#1).
+*
+* The heavy part of avatar start is the MediaPipe bring-up (module + ~3.7MB
+* model download + WASM compile) — seconds on a low-tier device, which made
+* the smiley LOSE THE RACE against a fast capture on the Galaxy-A04e-class
+* target. `warmAvatar2D()` boots the real avatar worker during the tutorial
+* phase and runs that bring-up WITHOUT camera or canvas (cosmetic-only by
+* construction — no media is touched); the provider then ADOPTS the warm
+* worker at capture start via `takeWarmAvatar2DWorker()` and tracking engages
+* near-instantly.
+*
+* Lifecycle: one warm entry at a time (keyed by the resolved asset URLs —
+* idempotent re-warms are no-ops; different assets replace the entry). The
+* entry is consumed on adoption, released explicitly by the capture machine's
+* terminal states, and self-disposes after WARM_TTL_MS as the backstop for
+* teardown paths that never reach either (e.g. the host unmounting the module
+* mid-tutorial).
+*/
+/** Idle warm workers self-dispose after this long without adoption. */
+const WARM_TTL_MS = 5 * 6e4;
+let entry = null;
+function assetsKey(assets) {
+	return assets.mediapipeModulePath + "\n" + assets.mediapipeWasmPath + "\n" + assets.faceLandmarkerModelPath;
+}
+/**
+* Boot the avatar-2d worker and start its MediaPipe bring-up in the
+* background. Fire-and-forget and never throws; environments without the
+* worker path (probe fail, CSP, instrumented source) silently no-op — the
+* capture-time fallback chain is unchanged.
+*/
+function warmAvatar2D(overrides) {
+	try {
+		if (!canUseAvatar2DWorker()) return;
+		const assets = resolveAvatar2DAssets(overrides ?? {});
+		const key = assetsKey(assets);
+		if (entry?.key === key) return;
+		releaseAvatar2DWarmup();
+		const source = buildAvatar2DTrackWorkerSource();
+		if (detectWorkerSourceInstrumentation(source)) return;
+		let blobUrl = null;
+		let worker;
+		try {
+			blobUrl = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
+			worker = new Worker(blobUrl);
+		} catch {
+			if (blobUrl) URL.revokeObjectURL(blobUrl);
+			return;
+		}
+		if (blobUrl) URL.revokeObjectURL(blobUrl);
+		const ttlId = setTimeout(() => {
+			if (entry?.worker === worker) releaseAvatar2DWarmup();
+		}, WARM_TTL_MS);
+		entry = {
+			worker,
+			key,
+			blobUrl: null,
+			ttlId
+		};
+		worker.onerror = () => {
+			if (entry?.worker === worker) releaseAvatar2DWarmup();
+		};
+		const warmMsg = {
+			type: "warm",
+			mediapipeModulePath: assets.mediapipeModulePath,
+			mediapipeWasmPath: assets.mediapipeWasmPath,
+			faceLandmarkerModelPath: assets.faceLandmarkerModelPath
+		};
+		worker.postMessage(warmMsg);
+	} catch {}
+}
+/**
+* Hand the warm worker (if any, and only for the SAME resolved assets) to the
+* provider. The caller owns it from here — the registry forgets the entry and
+* detaches its listeners.
+*/
+function takeWarmAvatar2DWorker(assets) {
+	if (!entry || entry.key !== assetsKey(assets)) return null;
+	const { worker, blobUrl, ttlId } = entry;
+	entry = null;
+	clearTimeout(ttlId);
+	if (blobUrl) URL.revokeObjectURL(blobUrl);
+	worker.onmessage = null;
+	worker.onerror = null;
+	return worker;
+}
+/** Dispose an un-adopted warm worker (terminal machine states; re-warm). */
+function releaseAvatar2DWarmup() {
+	if (!entry) return;
+	const { worker, blobUrl, ttlId } = entry;
+	entry = null;
+	clearTimeout(ttlId);
+	if (blobUrl) URL.revokeObjectURL(blobUrl);
+	worker.terminate();
+}
+//#endregion
+export { createAvatar2DPoseCore as a, SatinSmileyRenderer as c, AVATAR2D_POSE_CORE_DEFAULTS as i, resolveAvatar2DAssets as l, buildAvatar2DTrackWorkerSource as n, createAvatar2DPoseCoreDeps as o, canUseAvatar2DWorker as r, releaseAvatar2DWarmup, extractCompactFace as s, buildAvatar2DRenderWorkerSource as t, takeWarmAvatar2DWorker, warmAvatar2D };