@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.3

package/dist/FaceDetectionProvider-B78455D4.d.ts

@@ -0,0 +1,119 @@
+import { n as WasmPipeline } from "./warmup-BJZPQIiX.js";
+import { c as FaceAttributesThresholds, d as FaceDetectionCallbacks, f as FaceDetectionConfig, h as IFaceDetectionCapability, l as FaceChecksConfig, m as FacePositionConstraints, p as FaceDetectionThresholds, v as WebApiHostRequestConfig } from "./createFaceAvatar-B8pFpy6o.js";
+
+//#region ../infra/src/wasm/WasmPipelineType.d.ts
+declare enum WasmPipelineType {
+  IdBlurGlarePipeline = 0,
+  IdBarcodeAndTextQualityPipeline = 1,
+  IdVideoSelfiePipeline = 2,
+  SelfieWithAggregationMetrics = 3,
+  SelfieWithQualityMetrics = 4,
+  OnDeviceSelfieWorkflow = 5,
+}
+//#endregion
+//#region ../infra/src/providers/wasm/BaseWasmProvider.d.ts
+/**
+ * Base configuration for WASM providers
+ */
+interface BaseWasmConfig {
+  /** Path to the WASM binary */
+  wasmPath?: string;
+  /** Path to the SIMD-optimized WASM binary (optional) */
+  wasmSimdPath?: string;
+  /** Path to the WASM glue code (paired with `wasmPath`) */
+  glueCodePath?: string;
+  /**
+   * Path to the SIMD-optimized WASM glue code (paired with `wasmSimdPath`).
+   * If omitted, defaults to a sibling `.js` derived from `wasmSimdPath`.
+   */
+  glueCodeSimdPath?: string;
+  /** Whether to use SIMD optimizations (default: true) */
+  useSimd?: boolean;
+  /**
+   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
+   * If not provided, models are expected in a 'models' subdirectory relative to the WASM binary.
+   */
+  modelsBasePath?: string;
+}
+/**
+ * Base provider class that abstracts common WASM functionality.
+ * This serves as a foundation for specific ML capability providers
+ * like FaceDetectionProvider and IdCaptureProvider.
+ */
+declare abstract class BaseWasmProvider {
+  private _isInitialized;
+  protected pipelineType: WasmPipelineType | undefined;
+  /**
+   * Creates a new BaseWasmProvider
+   * @param pipelineType - The WASM pipeline type this provider uses
+   */
+  constructor(pipelineType?: WasmPipelineType);
+  /**
+   * Returns whether this provider has been initialized.
+   */
+  get initialized(): boolean;
+  protected getPipelineType(): WasmPipelineType;
+  /**
+   * Initializes the provider by ensuring WASM is loaded
+   * @param config - Provider configuration
+   * @param pipeline - The pipeline type to warm up ('selfie', 'idCapture', etc.)
+   */
+  protected initializeBase(config: BaseWasmConfig, pipeline: WasmPipeline): Promise<void>;
+  /**
+   * Ensures the provider is initialized before performing operations.
+   * @throws Error if not initialized
+   */
+  protected ensureInitialized(): void;
+  /**
+   * Processes a frame through the WASM pipeline
+   * @param image - Image data to process
+   * @returns The pipeline result (type depends on pipeline - WASM returns any)
+   */
+  protected processFrameWasm(image: ImageData): Promise<any>;
+  abstract processFrame(image: ImageData): Promise<void>;
+  /**
+   * Resets the pipeline to its initial state.
+   * Safe to call even if not initialized (no-op in that case).
+   */
+  reset(): void;
+  /**
+   * Disposes of resources and resets initialization state.
+   * Safe to call even if not initialized.
+   */
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region ../infra/src/providers/wasm/FaceDetectionProvider.d.ts
+declare class FaceDetectionProvider extends BaseWasmProvider implements IFaceDetectionCapability {
+  private defaultThresholds;
+  private currentThresholds;
+  private currentFrame;
+  private onFaceDataCallback;
+  constructor();
+  processFrame(image: ImageData): Promise<void>;
+  initialize(config: FaceDetectionConfig): Promise<void>;
+  /**
+   * Last-registered onCapture callback — captured into a private
+   * field so `forceCapture()` (called from outside the WASM-callback
+   * lifecycle) can re-fire the same wrapper. `setCallbacks` rebinds
+   * this on each invocation, so the field always reflects the
+   * current consumer.
+   */
+  private currentOnCaptureWrapper;
+  processPhoto(canvas: HTMLCanvasElement): void;
+  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
+  setCallbacks(callbacks: FaceDetectionCallbacks): void;
+  setPositionConstraints(constraints: FacePositionConstraints): void;
+  applyDefaults(autocaptureInterval?: number): void;
+  setAutocaptureInterval(interval: number): void;
+  setThresholds(thresholds: FaceDetectionThresholds): void;
+  setAttributesThresholds(thresholds: FaceAttributesThresholds): void;
+  setChecksEnabled(config: FaceChecksConfig): void;
+  setVideoSelfieMode(enabled: boolean): void;
+  forceCapture(): void;
+  reset(): void;
+  private createDefaultFaceCoordinates;
+  private formatFaceCoordinates;
+}
+//#endregion
+export { BaseWasmProvider as n, FaceDetectionProvider as t };

package/dist/IVisibilityObserverCapability-BbWjgpiF.d.ts

@@ -0,0 +1,12 @@
+//#region ../infra/src/capabilities/IVisibilityObserverCapability.d.ts
+type IVisibilityObserverCapability = {
+  /**
+   * Whether the document is currently visible. Lets the orchestrator seed its
+   * dedupe state and emit an initial `background` when a session starts while
+   * the tab is already hidden (e.g. the SDK is opened in a background tab).
+   */
+  isVisible(): boolean;
+  onVisibilityChange(listener: (visible: boolean) => void): () => void;
+};
+//#endregion
+export { IVisibilityObserverCapability as t };

package/dist/IWasmUtilCapability-d2XvzaCk.d.ts

@@ -0,0 +1,145 @@
+import { n as WasmPipeline } from "./warmup-BJZPQIiX.js";
+import { _ as MLProviderConfig } from "./createFaceAvatar-B8pFpy6o.js";
+
+//#region ../infra/src/capabilities/IRecordingCapability.d.ts
+type RecordingPublisher = {
+  getStreamId: () => string | undefined;
+  replaceVideoTrack: (track: MediaStreamTrack) => Promise<void>;
+  destroy: () => void;
+};
+type RecordingConnection = {
+  sessionId: string | undefined;
+  publisher: RecordingPublisher;
+  disconnect: () => Promise<void>;
+};
+type RecordingConnectionEvents = {
+  onSessionConnected?: (sessionId: string | undefined) => void;
+  onSessionDisconnected?: (sessionId: string | undefined) => void;
+  onSessionException?: (params: {
+    name?: string;
+    message?: string;
+    sessionId?: string;
+  }) => void;
+  onPublisherCreated?: (params: {
+    streamId?: string;
+    sessionId?: string;
+  }) => void;
+  onPublisherError?: (params: {
+    message?: string;
+    sessionId?: string;
+    streamId?: string;
+  }) => void;
+};
+type ConnectRecordingParams = {
+  sessionToken: string;
+  stream: MediaStream;
+  events?: RecordingConnectionEvents;
+};
+type IRecordingCapability = {
+  /**
+   * Connects to a recording session and publishes the provided media stream.
+   * Returns a connection handle that can be disconnected and used to manage the publisher.
+   */
+  connect: (params: ConnectRecordingParams) => Promise<RecordingConnection>;
+};
+//#endregion
+//#region ../infra/src/capabilities/IStorageCapability.d.ts
+/**
+ * Storage capability interface for abstracting storage operations.
+ * Enables swapping between browser localStorage and future WASM-based storage.
+ */
+interface IStorageCapability {
+  /**
+   * Retrieves a value from storage.
+   * @param key - The storage key
+   * @returns The stored value or null if not found
+   */
+  get<T>(key: string): Promise<T | null>;
+  /**
+   * Stores a value in storage.
+   * @param key - The storage key
+   * @param value - The value to store (will be serialized)
+   */
+  set<T>(key: string, value: T): Promise<void>;
+  /**
+   * Removes a value from storage.
+   * @param key - The storage key to remove
+   */
+  remove(key: string): Promise<void>;
+  /**
+   * Clears all values from storage.
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+//#region ../infra/src/capabilities/IWasmUtilCapability.d.ts
+type WasmUtilConfig = MLProviderConfig & {
+  pipelines?: WasmPipeline[];
+};
+type VirtualCameraCheckOutput = {
+  canvas: HTMLCanvasElement | null;
+  itr: boolean | null;
+  skipped: boolean | null;
+};
+type IWasmUtilCapability = {
+  /**
+   * Whether the provider has been initialized and is ready to be used.
+   */
+  readonly initialized: boolean;
+  /**
+   * Initializes the provider with the given configuration.
+   * If WASM was already warmed up via `warmupWasm()`, this returns almost instantly.
+   * @param config - Provider configuration including WASM paths
+   */
+  initialize(config: WasmUtilConfig): Promise<void>;
+  /**
+   * Encrypts a base64 image using the WASM utility API.
+   * @param image - Base64 image string (no data URL prefix)
+   * @returns Encrypted string
+   */
+  encryptImage(image: string): string;
+  setSdkVersion(version: string): void;
+  setSdkPlatform(platform: string): void;
+  setDeviceInfo(deviceInfo: object, overrideExisting?: boolean): void;
+  setBrowserInfo(browserInfo: object, overrideExisting?: boolean): void;
+  setCameraInfo(cameraInfo: object, overrideExisting?: boolean): void;
+  setMotionStatus(status: string): void;
+  setBackgroundMode(backgroundMode: boolean): void;
+  setZc(zc: string): void;
+  setInspectorOpened(opened: boolean): void;
+  /**
+   * Returns whether the DevTools inspector has been detected as open.
+   * Safe to call before WASM initialization (returns the in-memory flag).
+   */
+  getInspectorOpened(): boolean;
+  /**
+   * Toggles the WASM module's production mode. When `true`, the native module
+   * suppresses its verbose debug logging/console output.
+   */
+  setProductionMode(productionMode: boolean): Promise<void>;
+  getMetadata(): string;
+  analyzeFrame(image: ImageData): Promise<void>;
+  getCheck(): string;
+  /**
+   * Gets the current pipeline state. Must be called before setMotionStatus(),
+   * getCheck(), setBackgroundMode(), and getMetadata() for proper metadata generation.
+   */
+  getPipelineState(): string;
+  estimatePerformance(): string;
+  isVirtualCamera(label: string | null): boolean;
+  prc(): Promise<void>;
+  poc(output: VirtualCameraCheckOutput): Promise<void>;
+  rsp(): Promise<void>;
+  ssl(): void;
+  stl(): void;
+  osv(): void;
+  oev(): void;
+  ckvcks(data: ArrayBuffer): void;
+  getVersions(): Promise<unknown>;
+  /**
+   * Disposes of resources and resets initialization state.
+   */
+  dispose(): Promise<void>;
+};
+//#endregion
+export { IRecordingCapability as a, IStorageCapability as i, VirtualCameraCheckOutput as n, RecordingConnection as o, WasmUtilConfig as r, IWasmUtilCapability as t };

package/dist/IpifyProvider-BRW14_uo.esm.js

@@ -0,0 +1,51 @@
+//#region ../infra/src/providers/browser/IpifyProvider.ts
+let cachedIp;
+let inFlightLookup;
+/**
+* Resets the module-level IP cache. Intended for tests and full session resets.
+*/
+function resetIpifyCache() {
+	cachedIp = void 0;
+	inFlightLookup = void 0;
+}
+async function fetchIpFromIpify() {
+	if (typeof fetch === "undefined") return "";
+	let timeoutId = 0;
+	const controller = new AbortController();
+	if (AbortSignal.timeout) {
+		const signal = AbortSignal.timeout(3e3);
+		return (await (await fetch("https://api.ipify.org?format=json", { signal })).json()).ip;
+	}
+	const timeoutPromise = new Promise((_, reject) => {
+		timeoutId = setTimeout(() => {
+			controller.abort();
+			reject(/* @__PURE__ */ new Error("Request timeout"));
+		}, 3e3);
+	});
+	const fetchPromise = fetch("https://api.ipify.org?format=json", { signal: controller.signal }).then((res) => res.json()).then((data) => data.ip);
+	const result = await Promise.race([fetchPromise, timeoutPromise]);
+	clearTimeout(timeoutId);
+	return result;
+}
+var IpifyProvider = class {
+	async getIp() {
+		if (cachedIp !== void 0) return cachedIp;
+		if (inFlightLookup) return inFlightLookup;
+		inFlightLookup = (async () => {
+			try {
+				const ip = await fetchIpFromIpify();
+				cachedIp = ip;
+				return ip;
+			} catch {
+				cachedIp = "";
+				return "";
+			} finally {
+				inFlightLookup = void 0;
+			}
+		})();
+		return inFlightLookup;
+	}
+};
+
+//#endregion
+export { resetIpifyCache as n, IpifyProvider as t };

package/dist/{OpenViduRecordingProvider-O4GjBseO.esm.js → OpenViduRecordingProvider-B_0GKkzc.esm.js}

@@ -1,4 +1,4 @@
-import { t as loadOpenVidu } from "./openviduLazy-Dh14JNJc.esm.js";
+import { t as loadOpenVidu } from "./openviduLazy-BTOIauGP.esm.js";
 
 //#region ../infra/src/providers/browser/OpenViduRecordingProvider.ts
 function createHiddenContainer() {

package/dist/PrivacyLensProvider-hDzaDzZ6.esm.js

@@ -0,0 +1,339 @@
+import { t as createHiddenVideoElement } from "./video-C2WIj6TS.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/{StreamCanvasCapture-ImiDQdVA.esm.js → StreamCanvasCapture-Bz17q4FP.esm.js}

@@ -1,4 +1,4 @@
-import { t as IncodeCanvas } from "./canvas-SKcRBxsk.esm.js";
+import { t as IncodeCanvas } from "./canvas-_I95hkPg.esm.js";
 
 //#region ../infra/src/media/StreamCanvasCapture.ts
 var StreamCanvasCapture = class {