@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/avatarStats-CdUOb3VD.esm.js

@@ -0,0 +1,136 @@
+//#region ../infra/src/avatar/avatarStats.ts
+/**
+* Whether stats collection is on. Providers use this to skip the
+* `performance.now()` bracketing entirely when off (zero production cost).
+*/
+function isAvatarStatsEnabled() {
+	return globalThis.__incodeAvatarStatsEnabled === true;
+}
+/**
+* Publishes a snapshot to the dev-global (no-op unless stats are enabled). The
+* single owner of the `__incodeAvatarStats` key — used both by the in-process
+* reporter below and by the privacy-lens provider when it relays a snapshot
+* computed in its render worker, so the key/type live in exactly one place.
+*/
+function publishAvatarStats(snapshot) {
+	if (!isAvatarStatsEnabled()) return;
+	globalThis.__incodeAvatarStats = snapshot;
+}
+/**
+* Pure, self-contained windowing accumulator shared by the in-process reporter
+* and the privacy-lens render worker. It MUST NOT reference any module-level
+* value (constant, helper, or import): it is serialized via
+* `Function.prototype.toString()` into the worker blob, where module scope does
+* not exist, so everything it needs — the publish sink, the window sizes, the
+* variant/mode — arrives through `config`. For the same reason p95 is inlined
+* and `gaps.slice()` is used instead of spread. Gating (the reporter's
+* {@link isAvatarStatsEnabled} check / the worker's `statsEnabled` flag) stays
+* with the caller: every method here assumes stats are on when it is called.
+*/
+function createStatsWindow(config) {
+	let droppedTotal = 0;
+	let renderedTotal = 0;
+	let windowStartMs = NaN;
+	let windowFrames = 0;
+	let windowUploadMs = 0;
+	let windowUploadCount = 0;
+	let windowDrawMs = 0;
+	let windowDrawCount = 0;
+	const gaps = [];
+	let lastFrameAt = NaN;
+	function publish(nowMs) {
+		const elapsed = nowMs - windowStartMs;
+		if (!(elapsed > 0)) return;
+		const renderedFps = Math.round(windowFrames / elapsed * 1e3 * 10) / 10;
+		const snapshot = {
+			variant: config.variant,
+			avatarFps: renderedFps,
+			renderedFps,
+			renderedTotal,
+			droppedByThrottle: droppedTotal,
+			tsMs: nowMs
+		};
+		if (config.mode !== void 0) snapshot.mode = config.mode;
+		if (windowUploadCount > 0) snapshot.uploadMsAvg = Math.round(windowUploadMs / windowUploadCount * 100) / 100;
+		if (windowDrawCount > 0) snapshot.drawMsAvg = Math.round(windowDrawMs / windowDrawCount * 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;
+		}
+		config.publish(snapshot);
+		windowStartMs = nowMs;
+		windowFrames = 0;
+		windowUploadMs = 0;
+		windowUploadCount = 0;
+		windowDrawMs = 0;
+		windowDrawCount = 0;
+	}
+	return {
+		noteRendered(nowMs, uploadMs, drawMs) {
+			renderedTotal += 1;
+			if (Number.isNaN(windowStartMs)) windowStartMs = nowMs;
+			else windowFrames += 1;
+			if (uploadMs !== void 0) {
+				windowUploadMs += uploadMs;
+				windowUploadCount += 1;
+			}
+			if (drawMs !== void 0) {
+				windowDrawMs += drawMs;
+				windowDrawCount += 1;
+			}
+			if (!Number.isNaN(lastFrameAt)) {
+				gaps.push(nowMs - lastFrameAt);
+				if (gaps.length > config.gapWindow) gaps.shift();
+			}
+			lastFrameAt = nowMs;
+			if (nowMs - windowStartMs >= config.publishIntervalMs) publish(nowMs);
+		},
+		noteDropped() {
+			droppedTotal += 1;
+		}
+	};
+}
+/**
+* Creates a per-provider reporter. Publishing is driven lazily from the frame
+* callbacks (no timers to leak); when {@link isAvatarStatsEnabled} is false
+* every method is a cheap no-op. The windowing is the shared
+* {@link createStatsWindow}; this wrapper adds the enabled-gate and the
+* dev-global ownership cleanup on {@link AvatarStatsReporter.dispose}.
+*/
+function createAvatarStatsReporter(variant, mode) {
+	const statsWindow = createStatsWindow({
+		variant,
+		mode,
+		publishIntervalMs: 500,
+		gapWindow: 128,
+		publish: publishAvatarStats
+	});
+	return {
+		frameRendered(nowMs, uploadMs, drawMs) {
+			if (!isAvatarStatsEnabled()) return;
+			statsWindow.noteRendered(nowMs, uploadMs, drawMs);
+		},
+		frameDropped() {
+			if (!isAvatarStatsEnabled()) return;
+			statsWindow.noteDropped();
+		},
+		dispose() {
+			const globals = globalThis;
+			if (globals.__incodeAvatarStats?.variant === variant) delete globals.__incodeAvatarStats;
+		}
+	};
+}
+/**
+* Timeline marks for diagnosing time-to-avatar on real devices (ENG-49806):
+* `performance.getEntriesByName('incode:avatar:<point>')` decomposes page
+* boot → tutorial warm → capture-entry create → canvas ready. Marks are
+* near-free and namespaced; never throws on exotic hosts.
+*/
+function markAvatarTimeline(point) {
+	try {
+		performance.mark(`incode:avatar:${point}`);
+	} catch {}
+}
+//#endregion
+export { publishAvatarStats as a, markAvatarTimeline as i, createStatsWindow as n, isAvatarStatsEnabled as r, createAvatarStatsReporter as t };

package/dist/{backCameraStream-ChrMTJv-.esm.js → backCameraStream-CUeYm5eu.esm.js}

@@ -1,7 +1,7 @@
-import { a as isIPhone14OrHigher, o as isSafari, r as isIOS, t as isAndroid } from "./platform-0Ot-bF_a.esm.js";
-import { a as stopCameraStream, n as enumerateVideoDevices, r as requestCameraAccess, t as applyTrackConstraints } from "./camera-CxxXV0VN.esm.js";
-import { t as sleep } from "./ITimerCapability-DJ73P4RK.esm.js";
-
+import { i as isIOS, o as isIPhone14OrHigher, r as isDesktop, s as isSafari, t as isAndroid } from "./platform-BJrm5nzZ.esm.js";
+import { a as stopCameraStream, n as enumerateVideoDevices, r as requestCameraAccess, t as applyTrackConstraints } from "./camera-_2sXMXiF.esm.js";
+import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
+import { t as getBrowser } from "./getBrowser-DNrQeL4T.esm.js";
 //#region src/internal/camera/backCameraStream.ts
 const BACK_CAMERA_KEYWORDS = [
 	"rear",
@@ -70,6 +70,11 @@ async function getCameras() {
 	}
 	return cameras;
 }
+async function hasBackCamera() {
+	const devices = await enumerateVideoDevices();
+	if (devices.some((d) => isBackCameraLabel(d.label))) return true;
+	return devices.length > 1 && !isDesktop();
+}
 function selectBestBackCamera(backCameras) {
 	if (backCameras.length === 0) return void 0;
 	if (backCameras.length === 1) return backCameras[0];
@@ -222,6 +227,12 @@ async function getAndroidBackCameraStream(fallbackLevel = 0) {
 		return getAndroidBackCameraStream(nextLevel);
 	}
 }
+async function getFirefoxAndroidBackCameraStream() {
+	return {
+		stream: await requestCameraAccess(getDesktopConstraints({ facingMode: "environment" })),
+		fallbackLevel: 0
+	};
+}
 async function applyFocusHint(stream) {
 	const videoTrack = stream.getVideoTracks()[0];
 	try {
@@ -305,7 +316,6 @@ function getDesktopVideoConstraints(level) {
 				max: 600
 			}
 		};
-		case 5:
 		default: return {};
 	}
 }
@@ -422,9 +432,11 @@ async function ensureFrontCameraStream(open) {
 }
 async function getBackCameraStream(deviceId) {
 	if (isIOS()) return { stream: await getIOSCameraStream() };
-	if (isAndroid()) return getAndroidBackCameraStream(0);
+	if (isAndroid()) {
+		if (getBrowser() === "firefox") return getFirefoxAndroidBackCameraStream();
+		return getAndroidBackCameraStream(0);
+	}
 	return { stream: await getDesktopBackCameraStream(deviceId) };
 }
-
 //#endregion
-export { getBackCameraStream as n, getDesktopCameraStream as r, ensureFrontCameraStream as t };
+export { hasBackCamera as i, getBackCameraStream as n, getDesktopCameraStream as r, ensureFrontCameraStream as t };