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

package/dist/{PrivacyLensProvider-DA3rp6sf.esm.js → PrivacyLensProvider-D8PS7AJa.esm.js}

@@ -1,5 +1,6 @@
 import { t as createHiddenVideoElement } from "./video-BtSWtHy1.esm.js";
-import { a as createFramePacer, i as publishAvatarStats, n as createStatsWindow, r as isAvatarStatsEnabled, t as createAvatarStatsReporter } from "./avatarStats-BIB3SREM.esm.js";
+import { a as publishAvatarStats, r as isAvatarStatsEnabled, t as createAvatarStatsReporter } from "./avatarStats-CdUOb3VD.esm.js";
+import { a as createPrivacyLensGl, i as detectWorkerSourceInstrumentation, n as canUsePrivacyLensWorker, o as createFramePacer, r as createTrackProcessor, t as buildPrivacyLensWorkerSource } from "./privacyLensWorker-DI-Rg83h.esm.js";
 //#region ../infra/src/avatar/privacy-lens/privacyLensShaders.ts
 /** Starting point; tuned live via the privacy-lens demo sliders. */
 const PRIVACY_LENS_DEFAULTS = {
@@ -113,329 +114,6 @@ ${Array.from({ length: 12 }, (_, i) => {
   gl_FragColor = vec4(clamp(col, 0.0, 1.0), 1.0);
 }`;
 //#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
 //#region ../infra/src/avatar/privacy-lens/PrivacyLensProvider.ts
 /**
 * Privacy-lens avatar — sandblasted-glass effect over the **real** selfie video.
@@ -724,4 +402,4 @@ function createProvider() {
 	return new PrivacyLensProvider();
 }
 //#endregion
-export { createProvider };
+export { PrivacyLensProvider, createProvider };

package/dist/ae-signature.esm.js

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

package/dist/{apiError-CbwItA4n.esm.js → apiError-C_08gwg2.esm.js}

@@ -1,4 +1,4 @@
-import { l as trueSightLog, u as categoryForEndpoint } from "./trueSightService-D_YtkNAI.esm.js";
+import { l as trueSightLog, u as categoryForEndpoint } from "./trueSightService-PXOP5bS9.esm.js";
 //#region src/internal/http/apiError.ts
 /**
 * Incode API error.

package/dist/authentication.esm.js

@@ -1,3 +1,3 @@
-import { t as authenticationMachine } from "./authenticationStateMachine-C9E6Bi5e.esm.js";
-import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-CJnTBpA5.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-CJILuEbH.esm.js";
+import { r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-D76jxYNX.esm.js";
 export { authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/{authenticationManager-CJnTBpA5.esm.js → authenticationManager-D76jxYNX.esm.js}

@@ -2,8 +2,8 @@ import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
 import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
 import { n as eventModuleNames } from "./events-ethtfu2b.esm.js";
 import { o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
-import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-bQm5Ehbz.esm.js";
-import { t as authenticationMachine } from "./authenticationStateMachine-C9E6Bi5e.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-DqQCDsDY.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-CJILuEbH.esm.js";
 //#region src/modules/authentication/authenticationActor.ts
 function createAuthenticationActor(options) {
 	const dependencies = options.dependencies ?? {

package/dist/{authenticationStateMachine-C9E6Bi5e.esm.js → authenticationStateMachine-CJILuEbH.esm.js}

@@ -3,8 +3,8 @@ import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
 import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
 import { r as assign } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
-import { t as faceCaptureMachine } from "./faceCaptureSetup-DalEA-yE.esm.js";
-import { i as prepareOnDeviceFaceUpload, n as isOnDeviceMode, r as postOnDeviceFaceResults, t as defaultPrepareFaceUpload } from "./onDeviceFaceResults-DhAPaF-B.esm.js";
+import { t as faceCaptureMachine } from "./faceCaptureSetup-5Ye-LXbB.esm.js";
+import { i as prepareOnDeviceFaceUpload, n as isOnDeviceMode, r as postOnDeviceFaceResults, t as defaultPrepareFaceUpload } from "./onDeviceFaceResults-D53Rr_B1.esm.js";
 import { t as getDeviceClass } from "./getDeviceClass-BGmoQmjj.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
 //#region src/modules/authentication/authenticationErrorUtils.ts

package/dist/avatar.esm.js

@@ -1,2 +1,2 @@
-import { t as createFaceAvatar } from "./createFaceAvatar-x5aaJwVM.esm.js";
+import { t as createFaceAvatar } from "./createFaceAvatar-AF92I3xf.esm.js";
 export { createFaceAvatar };