@incodetech/core 0.0.0-dev-20260727-4e22043f → 0.0.0-dev-20260727-6d540cf0

package/dist/PrivacyLensProvider-BrYSd1dr.esm.js

@@ -1,336 +0,0 @@
-import { t as createHiddenVideoElement } from "./video-BtSWtHy1.esm.js";
-//#region ../infra/src/avatar/privacy-lens/privacyLensShaders.ts
-/** Starting point; tuned live via the privacy-lens demo sliders. */
-const PRIVACY_LENS_DEFAULTS = {
-	frost: .55,
-	sandblast: .28,
-	grainSize: .5,
-	brightness: 1.12,
-	shadowLift: .12,
-	warmth: .5,
-	sun: .71,
-	sunSpeed: .26
-};
-const PRIVACY_LENS_VERT = `
-attribute vec2 aPos;
-varying vec2 vUv;
-void main() {
-  vUv = aPos * 0.5 + 0.5;
-  gl_Position = vec4(aPos, 0.0, 1.0);
-}`;
-const PRIVACY_LENS_FRAG = `
-// The grain hash (h21 below) feeds large gl_FragCoord-derived values through
-// sin()*43758.5 — that overflows mediump's range on many mobile GPUs and
-// collapses the grain to a flat artifact. Use highp where available (all WebGL2
-// and most WebGL1 devices); fall back to mediump on the rare device without it.
-#ifdef GL_FRAGMENT_PRECISION_HIGH
-precision highp float;
-#else
-precision mediump float;
-#endif
-varying vec2 vUv;
-uniform sampler2D uVideo;
-uniform vec2 uRes;        // canvas pixel size (square)
-uniform vec2 uVideoRes;   // decoded video pixel size
-uniform float uTime;      // seconds (sun drift only)
-uniform float uFrost;
-uniform float uSandblast;
-uniform float uGrainSize;
-uniform float uWarmth;
-uniform float uBright;
-uniform float uShadow;
-uniform float uSun;
-uniform float uSunSpeed;
-
-// Static per-cell hash — NO time term, so the grain is a fixed matte surface.
-float h21(vec2 p) {
-  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
-}
-
-// Cover-fit the (non-square) video into the square output, centre-cropped, so
-// faces are never stretched.
-vec2 coverUv(vec2 uv) {
-  float va = uVideoRes.x / max(uVideoRes.y, 1.0);
-  vec2 o = uv;
-  if (va > 1.0) o.x = (uv.x - 0.5) / va + 0.5;   // landscape: crop sides
-  else          o.y = (uv.y - 0.5) * va + 0.5;    // portrait: crop top/bottom
-  return o;
-}
-
-const int N = 12;
-
-void main() {
-  vec2 uv = vUv;
-  vec2 base = coverUv(uv);
-  float aspect = uRes.y / max(uRes.x, 1.0);
-
-  // Per-fragment static seed, clustered into grain cells. Small cells = ultra
-  // fine sandblast (effectively invisible pattern); larger = coarser frosting.
-  vec2 cell = floor(gl_FragCoord.xy / max(uGrainSize, 0.5));
-  float rnd = h21(cell);
-  float baseAngle = rnd * 6.2831853;
-
-  // Stochastic sandblasted scatter: an even golden-angle disk, but each pixel
-  // cell rotates + jitters the kernel differently → a fine matte grain rather
-  // than a smooth blur. The video moves UNDER this fixed glass grain.
-  vec3 col = vec3(0.0);
-  for (int i = 0; i < N; i++) {
-    float fi = float(i) + 0.5;
-    float ang = baseAngle + fi * 2.399963; // golden angle
-    float rad = sqrt(fi / float(N));        // even area coverage 0..1
-    float j = h21(cell + vec2(fi * 7.13, fi * 3.71));
-    float r = uFrost * 0.06 * rad + (j - 0.5) * uSandblast * 0.03;
-    vec2 off = vec2(cos(ang), sin(ang)) * r;
-    off.x *= aspect;
-    col += texture2D(uVideo, base + off).rgb;
-  }
-  col /= float(N);
-
-  // Airy + warm grade (luminous frosted glass, not murky).
-  col = col + uShadow * (1.0 - col);
-  col *= uBright;
-  vec3 warm = vec3(1.0, 0.92, 0.80);
-  col = mix(col, col * warm + vec3(0.03, 0.015, 0.0), uWarmth);
-
-  // Drifting sun: a broad soft glow + a fine STATIC sparkle (per-cell) that
-  // catches the ground-glass grain only where the light falls — not all-over.
-  vec2 sun = vec2(0.34 + 0.16 * sin(uTime * uSunSpeed),
-                  0.26 + 0.10 * cos(uTime * uSunSpeed * 0.8));
-  float glow = smoothstep(0.7, 0.0, distance(uv, sun));
-  vec3 sunCol = vec3(1.0, 0.96, 0.88);
-  col += sunCol * glow * (0.20 + (rnd - 0.5) * 0.18 * uSandblast) * uSun;
-
-  gl_FragColor = vec4(clamp(col, 0.0, 1.0), 1.0);
-}`;
-//#endregion
-//#region ../infra/src/avatar/privacy-lens/PrivacyLensProvider.ts
-/**
-* Privacy-lens avatar — sandblasted-glass effect over the **real** selfie video.
-* **Self-contained** (see FACE_AVATAR.md → Isolation and ownership). No MediaPipe, no landmarks, no
-* three/VRM, no npm deps, no textures but the live video — just a raw-WebGL
-* fragment shader run on the video each frame (see `privacyLensShaders.ts`).
-*
-* Implements `IFaceAvatarCapability` (the generic `start/getCanvas/stop`
-* contract) so it rides the existing concealment seam
-* (`selfieConcealmentOption: 'OPTION_SILHOUETTE'`). The UI swaps the live `<Video>` for this
-* canvas exactly as it does for the other avatars. Cosmetic-only: the authoritative
-* pipeline still runs on the real frames; this only changes what is *displayed*.
-*
-* Mirroring is the UI's job (CSS), like every other provider — the shader
-* renders forward.
-*/
-const DEFAULT_MAX_FPS = 30;
-const RENDER_SIZE = 512;
-const asRvfc = (video) => {
-	const v = video;
-	return typeof v.requestVideoFrameCallback === "function" && typeof v.cancelVideoFrameCallback === "function" ? v : null;
-};
-const readParams = () => {
-	if (typeof window === "undefined") return PRIVACY_LENS_DEFAULTS;
-	const override = window.__incodePrivacyLensParams;
-	return override ? {
-		...PRIVACY_LENS_DEFAULTS,
-		...override
-	} : PRIVACY_LENS_DEFAULTS;
-};
-var PrivacyLensProvider = class {
-	constructor() {
-		this.gl = null;
-		this.program = null;
-		this.quad = null;
-		this.videoTex = null;
-		this.uniforms = /* @__PURE__ */ new Map();
-		this.videoHandle = null;
-		this.rafId = null;
-		this.rvfcHandle = null;
-		this.usingRvfc = false;
-		this.stopped = false;
-		this.lastFrameAt = 0;
-		this.minFrameIntervalMs = 1e3 / DEFAULT_MAX_FPS;
-		this.startTime = 0;
-		this.loop = (now) => {
-			if (this.stopped) return;
-			this.scheduleNextFrame();
-			if (now - this.lastFrameAt < this.minFrameIntervalMs) return;
-			this.lastFrameAt = now;
-			const gl = this.gl;
-			const video = this.videoHandle?.element;
-			if (!gl || !this.program) return;
-			if (!video || video.readyState < 2 || !video.videoWidth) {
-				gl.clear(gl.COLOR_BUFFER_BIT);
-				return;
-			}
-			gl.activeTexture(gl.TEXTURE0);
-			gl.bindTexture(gl.TEXTURE_2D, this.videoTex);
-			gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, video);
-			const p = readParams();
-			const setF = (name, value) => {
-				const loc = this.uniforms.get(name);
-				if (loc) gl.uniform1f(loc, value);
-			};
-			const set2 = (name, x, y) => {
-				const loc = this.uniforms.get(name);
-				if (loc) gl.uniform2f(loc, x, y);
-			};
-			set2("uRes", RENDER_SIZE, RENDER_SIZE);
-			set2("uVideoRes", video.videoWidth, video.videoHeight);
-			setF("uTime", (now - this.startTime) / 1e3);
-			setF("uFrost", p.frost);
-			setF("uSandblast", p.sandblast);
-			setF("uGrainSize", p.grainSize);
-			setF("uWarmth", p.warmth);
-			setF("uBright", p.brightness);
-			setF("uShadow", p.shadowLift);
-			setF("uSun", p.sun);
-			setF("uSunSpeed", p.sunSpeed);
-			gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-		};
-		this.canvas = document.createElement("canvas");
-		this.canvas.width = RENDER_SIZE;
-		this.canvas.height = RENDER_SIZE;
-	}
-	getCanvas() {
-		return this.canvas;
-	}
-	async start(stream, options = {}) {
-		this.minFrameIntervalMs = 1e3 / (options.maxFps ?? DEFAULT_MAX_FPS);
-		this.videoHandle = createHiddenVideoElement(stream, { keepStreamAlive: true });
-		try {
-			this.initGl();
-			if (this.stopped) return;
-			this.startTime = performance.now();
-			const video = this.videoHandle.element;
-			this.usingRvfc = !!asRvfc(video);
-			this.scheduleNextFrame();
-		} catch (error) {
-			this.stop();
-			throw error;
-		}
-		return Promise.resolve();
-	}
-	stop() {
-		this.stopped = true;
-		if (this.rafId != null) {
-			cancelAnimationFrame(this.rafId);
-			this.rafId = null;
-		}
-		const video = this.videoHandle?.element;
-		if (video && this.rvfcHandle != null) {
-			asRvfc(video)?.cancelVideoFrameCallback(this.rvfcHandle);
-			this.rvfcHandle = null;
-		}
-		const gl = this.gl;
-		if (gl) {
-			if (this.program) gl.deleteProgram(this.program);
-			if (this.quad) gl.deleteBuffer(this.quad);
-			if (this.videoTex) gl.deleteTexture(this.videoTex);
-			gl.getExtension("WEBGL_lose_context")?.loseContext();
-		}
-		this.program = null;
-		this.quad = null;
-		this.videoTex = null;
-		this.gl = null;
-		this.videoHandle?.dispose();
-		this.videoHandle = null;
-	}
-	initGl() {
-		const gl = this.canvas.getContext("webgl", {
-			alpha: false,
-			antialias: false,
-			premultipliedAlpha: false,
-			preserveDrawingBuffer: false
-		}) ?? this.canvas.getContext("experimental-webgl");
-		if (!gl) throw new Error("PrivacyLensProvider: WebGL is not available");
-		this.gl = gl;
-		const program = this.buildProgram(gl, PRIVACY_LENS_VERT, PRIVACY_LENS_FRAG);
-		this.program = program;
-		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);
-		this.quad = quad;
-		this.videoTex = this.makeTexture(gl, gl.CLAMP_TO_EDGE);
-		gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
-		for (const name of [
-			"uVideo",
-			"uRes",
-			"uVideoRes",
-			"uTime",
-			"uFrost",
-			"uSandblast",
-			"uGrainSize",
-			"uWarmth",
-			"uBright",
-			"uShadow",
-			"uSun",
-			"uSunSpeed"
-		]) this.uniforms.set(name, gl.getUniformLocation(program, name));
-		gl.uniform1i(this.uniforms.get("uVideo") ?? null, 0);
-		gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE);
-		gl.clearColor(.88, .86, .83, 1);
-	}
-	buildProgram(gl, vertSrc, fragSrc) {
-		const compile = (type, src) => {
-			const shader = gl.createShader(type);
-			if (!shader) throw new Error("PrivacyLensProvider: 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(`PrivacyLensProvider: 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("PrivacyLensProvider: 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(`PrivacyLensProvider: program link failed: ${log}`);
-		}
-		return program;
-	}
-	makeTexture(gl, wrap) {
-		const tex = gl.createTexture();
-		if (!tex) throw new Error("PrivacyLensProvider: createTexture failed");
-		gl.bindTexture(gl.TEXTURE_2D, tex);
-		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrap);
-		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrap);
-		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
-		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-		return tex;
-	}
-	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);
-	}
-};
-/** Factory used by the avatar actor's provider selection (privacy-lens avatar). */
-function createProvider() {
-	return new PrivacyLensProvider();
-}
-//#endregion
-export { createProvider };

package/dist/session-DTuRfMtr.esm.js

@@ -1 +0,0 @@
-import "./sessionInitializer-B_GKYIAU.esm.js";