@incodetech/core 0.0.0-dev-20260803-ebbd53d1 → 0.0.0-dev-20260803-e2b5d35d

package/dist/{3dAvatarProvider-D9H4rR6_.esm.js → 3dAvatarProvider-1zpeX-h8.esm.js}

@@ -1,5 +1,5 @@
 import { t as createHiddenVideoElement } from "./video-BtSWtHy1.esm.js";
-import { n as createFaceLandmarker, r as dtAlpha, t as asRvfc } from "./mediapipeShared-B0iQQ5k7.esm.js";
+import { n as createFaceLandmarker, r as dtAlpha, t as asRvfc } from "./mediapipeShared-D0syL_Gp.esm.js";
 /**
 * @license
 * Copyright 2010-2024 Three.js Authors
@@ -28142,4 +28142,4 @@ function createProvider() {
 	return new Avatar3DProvider();
 }
 //#endregion
-export { createProvider };
+export { Avatar3DProvider, createProvider };

package/dist/Face2DProvider-TLwFIRn4.esm.js

@@ -0,0 +1,437 @@
+import { t as createHiddenVideoElement } from "./video-BtSWtHy1.esm.js";
+import { a as publishAvatarStats, r as isAvatarStatsEnabled, t as createAvatarStatsReporter } from "./avatarStats-CdUOb3VD.esm.js";
+import { n as createFaceLandmarker, t as asRvfc } from "./mediapipeShared-D0syL_Gp.esm.js";
+import { i as detectWorkerSourceInstrumentation, o as createFramePacer, r as createTrackProcessor } from "./privacyLensWorker-DI-Rg83h.esm.js";
+import { a as createAvatar2DPoseCore, c as SatinSmileyRenderer, i as AVATAR2D_POSE_CORE_DEFAULTS, l as resolveAvatar2DAssets, n as buildAvatar2DTrackWorkerSource, o as createAvatar2DPoseCoreDeps, r as canUseAvatar2DWorker, s as extractCompactFace, t as buildAvatar2DRenderWorkerSource, takeWarmAvatar2DWorker } from "./avatar2dWarm-DqucNFX4.esm.js";
+//#region ../infra/src/avatar/2d-default-avatar/Face2DProvider.ts
+/**
+* 2D satin-face avatar — MediaPipe-tracked, 2D sprite renderer.
+* **Self-contained** (its own MediaPipe loop; see FACE_AVATAR.md → Isolation and ownership).
+* Carries mobile robustness patterns (FACE_AVATAR.md → Mobile hardening): `window.Module` shield,
+* CPU delegate, transformation matrix OFF, landmark-derived pose, NaN guards.
+*/
+const DEFAULT_MAX_FPS = 30;
+const DETECT_MAX_EDGE = 320;
+const DETECT_MIN_INTERVAL_MS = 66;
+const DETECT_INTERVAL_TOLERANCE_MS = 8;
+const MAX_DETECT_FAILURES = 30;
+const WORKER_START_TIMEOUT_MS = 5e3;
+/** Grace period for the worker to ack 'stop' before hard termination. */
+const WORKER_STOP_GRACE_MS = 500;
+/** Cadence of the main→worker dev statsEnabled/state-override bridge. */
+const BRIDGE_INTERVAL_MS = 250;
+/** Dev override global (poc demos): workers can't see it, so it is bridged. */
+function readAvatarStateOverride() {
+	const v = globalThis.__incodeAvatarState;
+	return v === "detecting" || v === "success" || v === "error" ? v : null;
+}
+var Avatar2DProvider = class {
+	constructor() {
+		this.renderer = new SatinSmileyRenderer(512);
+		this.videoHandle = null;
+		this.landmarker = null;
+		this.inputCanvas = document.createElement("canvas");
+		this.inputCtx = null;
+		this.rafId = null;
+		this.pacer = createFramePacer(DEFAULT_MAX_FPS);
+		this.stats = createAvatarStatsReporter("avatar-2d");
+		this.stopped = false;
+		this.renderWorker = null;
+		this.trackWorker = null;
+		this.clonedTrack = null;
+		this.bridgeId = null;
+		this.lastBridgedStatsEnabled = false;
+		this.lastBridgedOverride = null;
+		this.mediapipeModulePath = "";
+		this.mediapipeWasmPath = "";
+		this.faceLandmarkerModelPath = "";
+		this.detectFailures = 0;
+		this.poseCore = createAvatar2DPoseCore(AVATAR2D_POSE_CORE_DEFAULTS, createAvatar2DPoseCoreDeps());
+		this.lastDetectAt = 0;
+		this.usingRvfc = false;
+		this.rvfcHandle = null;
+		this.lastSetState = null;
+		this.loop = (now) => {
+			if (this.stopped) return;
+			this.scheduleNextFrame();
+			if (!this.pacer.shouldRender(now)) {
+				this.stats.frameDropped();
+				return;
+			}
+			const measure = isAvatarStatsEnabled();
+			const frameStart = measure ? performance.now() : 0;
+			let detectMs;
+			const video = this.videoHandle?.element;
+			if (video && video.readyState >= 2 && this.landmarker) this.detectOnMainThread(video, now, measure, (ms) => {
+				detectMs = ms;
+			});
+			this.renderer.render(this.poseCore.tick(now));
+			if (measure) this.stats.frameRendered(now, detectMs, performance.now() - frameStart);
+		};
+	}
+	getCanvas() {
+		return this.renderer.getCanvas();
+	}
+	setState(state) {
+		this.renderer.setState(state);
+		this.lastSetState = state;
+		try {
+			this.renderWorker?.postMessage({
+				type: "state",
+				state
+			});
+		} catch {}
+	}
+	async start(stream, options = {}) {
+		const assets = resolveAvatar2DAssets({
+			mediapipeModulePath: options.assets?.mediapipeModulePath,
+			mediapipeWasmPath: options.assets?.mediapipeWasmPath,
+			faceLandmarkerModelPath: options.assets?.faceLandmarkerModelPath
+		});
+		this.mediapipeModulePath = assets.mediapipeModulePath;
+		this.mediapipeWasmPath = assets.mediapipeWasmPath;
+		this.faceLandmarkerModelPath = assets.faceLandmarkerModelPath;
+		const maxFps = options.maxFps ?? DEFAULT_MAX_FPS;
+		this.pacer = createFramePacer(maxFps);
+		this.poseCore = createAvatar2DPoseCore({
+			...AVATAR2D_POSE_CORE_DEFAULTS,
+			dtSeedMs: 1e3 / maxFps
+		}, createAvatar2DPoseCoreDeps());
+		if (await this.tryStartWorker(stream, maxFps)) return;
+		if (this.stopped) return;
+		this.videoHandle = createHiddenVideoElement(stream, { keepStreamAlive: true });
+		try {
+			this.renderer.init();
+			const video = this.videoHandle.element;
+			this.usingRvfc = !!asRvfc(video);
+			this.scheduleNextFrame();
+			this.startMainTracking();
+		} catch (error) {
+			this.stop();
+			throw error;
+		}
+	}
+	/**
+	* Background landmarker bring-up for the MAIN-THREAD path. On failure the
+	* avatar stays in its neutral searching state (the face remains concealed)
+	* rather than tearing down the already-mounted canvas.
+	*/
+	async startMainTracking() {
+		try {
+			this.landmarker = await this.createLandmarker();
+			if (this.stopped) {
+				this.landmarker?.close();
+				this.landmarker = null;
+				return;
+			}
+			this.stats.dispose();
+			this.stats = createAvatarStatsReporter("avatar-2d", "main");
+		} catch (error) {
+			console.warn("[face-avatar] avatar-2d tracking failed to start — avatar stays in searching state (capture unaffected)", error);
+		}
+	}
+	/** rVFC (one callback per camera frame) when available, else capped rAF. (§1.) */
+	scheduleNextFrame() {
+		if (this.stopped) return;
+		const video = this.videoHandle?.element;
+		const rvfc = this.usingRvfc && video ? asRvfc(video) : null;
+		if (rvfc) this.rvfcHandle = rvfc.requestVideoFrameCallback(this.loop);
+		else this.rafId = requestAnimationFrame(this.loop);
+	}
+	stop() {
+		this.stopped = true;
+		this.stats.dispose();
+		if (this.bridgeId != null) {
+			clearInterval(this.bridgeId);
+			this.bridgeId = null;
+		}
+		if (this.renderWorker || this.trackWorker) {
+			try {
+				this.renderWorker?.postMessage({ type: "stop" });
+				this.trackWorker?.postMessage({ type: "stop" });
+			} catch {}
+			const pendingRender = this.renderWorker;
+			const pendingTrack = this.trackWorker;
+			setTimeout(() => {
+				if (this.renderWorker === pendingRender || this.trackWorker === pendingTrack) this.finalizeWorkers();
+			}, WORKER_STOP_GRACE_MS);
+		}
+		if (this.rafId != null) {
+			cancelAnimationFrame(this.rafId);
+			this.rafId = null;
+		}
+		const stoppingVideo = this.videoHandle?.element;
+		if (stoppingVideo && this.rvfcHandle != null) {
+			asRvfc(stoppingVideo)?.cancelVideoFrameCallback(this.rvfcHandle);
+			this.rvfcHandle = null;
+		}
+		this.landmarker?.close();
+		this.landmarker = null;
+		this.renderer.dispose();
+		this.videoHandle?.dispose();
+		this.videoHandle = null;
+	}
+	/**
+	* Worker transport, TWO workers: clone the track, feed it to a
+	* MediaStreamTrackProcessor, adopt (or boot) the TRACK worker, boot the
+	* RENDER worker, wire them with a MessageChannel, transfer the renderer's
+	* canvas + the readable, and wait for the render worker's ms-fast 'started'
+	* handshake (the track worker's MediaPipe bring-up runs in the background —
+	* or already ran via the tutorial warm-up). Any failure tears down —
+	* recreating the renderer if its canvas was already transferred — and
+	* returns false so the main-thread path takes over. Never throws.
+	*/
+	async tryStartWorker(stream, maxFps) {
+		if (!canUseAvatar2DWorker()) return false;
+		const sourceTrack = stream.getVideoTracks()[0];
+		if (!sourceTrack) return false;
+		let track = null;
+		let processor;
+		try {
+			track = sourceTrack.clone();
+			processor = createTrackProcessor(track);
+		} catch {
+			track?.stop();
+			return false;
+		}
+		let trackWorker = takeWarmAvatar2DWorker({
+			mediapipeModulePath: this.mediapipeModulePath,
+			mediapipeWasmPath: this.mediapipeWasmPath,
+			faceLandmarkerModelPath: this.faceLandmarkerModelPath
+		});
+		let trackBlobUrl = null;
+		if (!trackWorker) {
+			const trackSource = buildAvatar2DTrackWorkerSource();
+			const trackInstrumenter = detectWorkerSourceInstrumentation(trackSource);
+			if (trackInstrumenter) {
+				console.error(`[face-avatar] avatar-2d worker source was instrumented by "${trackInstrumenter}" and cannot run in a worker; using the slower main-thread avatar. Exclude packages/infra from that transform (see docs/features/FACE_AVATAR.md → Worker transport).`);
+				track.stop();
+				return false;
+			}
+			try {
+				trackBlobUrl = URL.createObjectURL(new Blob([trackSource], { type: "text/javascript" }));
+				trackWorker = new Worker(trackBlobUrl);
+			} catch {
+				if (trackBlobUrl) URL.revokeObjectURL(trackBlobUrl);
+				track.stop();
+				return false;
+			}
+		}
+		const renderSource = buildAvatar2DRenderWorkerSource();
+		const renderInstrumenter = detectWorkerSourceInstrumentation(renderSource);
+		let renderWorker = null;
+		let renderBlobUrl = null;
+		if (!renderInstrumenter) try {
+			renderBlobUrl = URL.createObjectURL(new Blob([renderSource], { type: "text/javascript" }));
+			renderWorker = new Worker(renderBlobUrl);
+		} catch {
+			if (renderBlobUrl) URL.revokeObjectURL(renderBlobUrl);
+			renderBlobUrl = null;
+			renderWorker = null;
+		}
+		if (!renderWorker) {
+			if (renderInstrumenter) console.error(`[face-avatar] avatar-2d worker source was instrumented by "${renderInstrumenter}" and cannot run in a worker; using the slower main-thread avatar. Exclude packages/infra from that transform (see docs/features/FACE_AVATAR.md → Worker transport).`);
+			trackWorker.terminate();
+			if (trackBlobUrl) URL.revokeObjectURL(trackBlobUrl);
+			track.stop();
+			return false;
+		}
+		trackWorker.onmessage = (event) => {
+			const message = event.data;
+			if (message?.type === "trackingFatal") {
+				console.warn("[face-avatar] avatar-2d worker tracking failed to start — avatar stays in searching state (capture unaffected):", message.message);
+				trackWorker.terminate();
+				if (this.trackWorker === trackWorker) this.trackWorker = null;
+				track.stop();
+				if (this.clonedTrack === track) this.clonedTrack = null;
+			} else if (message?.type === "stopped") {
+				trackWorker.terminate();
+				if (this.trackWorker === trackWorker) this.trackWorker = null;
+				track.stop();
+				if (this.clonedTrack === track) this.clonedTrack = null;
+			}
+		};
+		trackWorker.onerror = () => {
+			console.warn("[face-avatar] avatar-2d track worker error — pose frozen (capture unaffected)");
+			trackWorker.terminate();
+			if (this.trackWorker === trackWorker) this.trackWorker = null;
+			track.stop();
+			if (this.clonedTrack === track) this.clonedTrack = null;
+		};
+		let started;
+		try {
+			const channel = new MessageChannel();
+			const offscreen = this.renderer.getCanvas().transferControlToOffscreen();
+			const handshakeWorker = renderWorker;
+			const startedTrackWorker = trackWorker;
+			started = await new Promise((resolve) => {
+				const timer = setTimeout(() => resolve(false), WORKER_START_TIMEOUT_MS);
+				handshakeWorker.onmessage = (event) => {
+					if (event.data?.type === "started") {
+						clearTimeout(timer);
+						resolve(true);
+					} else if (event.data?.type === "fatal") {
+						clearTimeout(timer);
+						resolve(false);
+					}
+				};
+				handshakeWorker.onerror = () => {
+					clearTimeout(timer);
+					resolve(false);
+				};
+				handshakeWorker.postMessage({
+					type: "start",
+					canvas: offscreen,
+					port: channel.port1,
+					maxFps,
+					poseConfig: {
+						...AVATAR2D_POSE_CORE_DEFAULTS,
+						dtSeedMs: 1e3 / maxFps
+					},
+					statsEnabled: isAvatarStatsEnabled()
+				}, [offscreen, channel.port1]);
+				startedTrackWorker.postMessage({
+					type: "start",
+					readable: processor.readable,
+					port: channel.port2,
+					mediapipeModulePath: this.mediapipeModulePath,
+					mediapipeWasmPath: this.mediapipeWasmPath,
+					faceLandmarkerModelPath: this.faceLandmarkerModelPath,
+					detectMaxEdge: DETECT_MAX_EDGE,
+					detectMinIntervalMs: DETECT_MIN_INTERVAL_MS,
+					detectIntervalToleranceMs: DETECT_INTERVAL_TOLERANCE_MS
+				}, [processor.readable, channel.port2]);
+			});
+		} catch {
+			renderWorker.terminate();
+			trackWorker.terminate();
+			if (renderBlobUrl) URL.revokeObjectURL(renderBlobUrl);
+			if (trackBlobUrl) URL.revokeObjectURL(trackBlobUrl);
+			track.stop();
+			if (!this.stopped) this.renderer = new SatinSmileyRenderer(512);
+			return false;
+		}
+		if (renderBlobUrl) URL.revokeObjectURL(renderBlobUrl);
+		if (trackBlobUrl) URL.revokeObjectURL(trackBlobUrl);
+		if (!started || this.stopped) {
+			renderWorker.terminate();
+			trackWorker.terminate();
+			track.stop();
+			if (!this.stopped) this.renderer = new SatinSmileyRenderer(512);
+			return this.stopped;
+		}
+		this.renderWorker = renderWorker;
+		this.trackWorker = trackWorker;
+		this.clonedTrack = track;
+		this.lastBridgedStatsEnabled = isAvatarStatsEnabled();
+		this.lastBridgedOverride = null;
+		renderWorker.onmessage = (event) => {
+			const message = event.data;
+			if (message?.type === "stats") {
+				if (!this.stopped) publishAvatarStats(message.snapshot);
+			} else if (message?.type === "stopped") {
+				this.renderWorker?.terminate();
+				this.renderWorker = null;
+			}
+		};
+		renderWorker.onerror = () => {
+			console.warn("[face-avatar] avatar-2d render worker error — avatar frozen (capture unaffected)");
+			if (this.bridgeId != null) {
+				clearInterval(this.bridgeId);
+				this.bridgeId = null;
+			}
+			this.finalizeWorkers();
+		};
+		if (this.lastSetState) renderWorker.postMessage({
+			type: "state",
+			state: this.lastSetState
+		});
+		this.bridgeId = setInterval(() => {
+			if (!this.renderWorker) return;
+			const enabled = isAvatarStatsEnabled();
+			if (enabled !== this.lastBridgedStatsEnabled) {
+				this.lastBridgedStatsEnabled = enabled;
+				this.renderWorker.postMessage({
+					type: "statsEnabled",
+					value: enabled
+				});
+			}
+			const override = readAvatarStateOverride();
+			if (override !== this.lastBridgedOverride) {
+				this.lastBridgedOverride = override;
+				this.renderWorker.postMessage({
+					type: "override",
+					state: override
+				});
+			}
+		}, BRIDGE_INTERVAL_MS);
+		return true;
+	}
+	finalizeWorkers() {
+		this.renderWorker?.terminate();
+		this.renderWorker = null;
+		this.trackWorker?.terminate();
+		this.trackWorker = null;
+		this.clonedTrack?.stop();
+		this.clonedTrack = null;
+	}
+	/** Loads the FaceLandmarker via the shared shielded init (see mediapipeShared). */
+	createLandmarker() {
+		return createFaceLandmarker({
+			mediapipeModulePath: this.mediapipeModulePath,
+			mediapipeWasmPath: this.mediapipeWasmPath,
+			faceLandmarkerModelPath: this.faceLandmarkerModelPath
+		});
+	}
+	/** Main-thread detect fallback: downscale → detectForVideo → ingest. */
+	detectOnMainThread(video, now, measure, onDetectMs) {
+		if (!this.landmarker) return;
+		const vw = video.videoWidth;
+		const vh = video.videoHeight;
+		const detectDue = now - this.lastDetectAt >= DETECT_MIN_INTERVAL_MS - DETECT_INTERVAL_TOLERANCE_MS;
+		if (vw > 0 && vh > 0 && detectDue) {
+			if (!this.inputCtx) this.inputCtx = this.inputCanvas.getContext("2d");
+			if (this.inputCtx) {
+				this.lastDetectAt = now;
+				const dscale = Math.min(1, DETECT_MAX_EDGE / Math.max(vw, vh));
+				const dw = Math.max(1, Math.round(vw * dscale));
+				const dh = Math.max(1, Math.round(vh * dscale));
+				if (this.inputCanvas.width !== dw || this.inputCanvas.height !== dh) {
+					this.inputCanvas.width = dw;
+					this.inputCanvas.height = dh;
+				}
+				this.inputCtx.drawImage(video, 0, 0, dw, dh);
+				let result = null;
+				const detectStart = measure ? performance.now() : 0;
+				try {
+					result = this.landmarker.detectForVideo(this.inputCanvas, now);
+					this.detectFailures = 0;
+				} catch {
+					result = null;
+					this.detectFailures += 1;
+					if (this.detectFailures >= MAX_DETECT_FAILURES) this.recreateLandmarker();
+				}
+				if (measure) onDetectMs(performance.now() - detectStart);
+				this.poseCore.ingest(result ? extractCompactFace(result) : null, dw, dh, now);
+			}
+		}
+	}
+	recreateLandmarker() {
+		this.detectFailures = 0;
+		this.landmarker?.close();
+		this.landmarker = null;
+		this.createLandmarker().then((lm) => {
+			if (this.stopped) {
+				lm.close();
+				return;
+			}
+			this.landmarker = lm;
+		}).catch(() => {});
+	}
+};
+/** Factory used by the avatar actor's provider selection (2D satin-face avatar). */
+function createProvider() {
+	return new Avatar2DProvider();
+}
+//#endregion
+export { Avatar2DProvider, createProvider };