@verifiedonchain-protocol/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,3003 @@
+// src/core/biometrics/simHash.ts
+var SEED_PREFIX = "HumanityGen_SimHash_Hyperplane_";
+function generateHyperplanes(dimensions, count) {
+  const hyperplanes = [];
+  for (let i = 0; i < count; i++) {
+    const seed = `${SEED_PREFIX}${i}`;
+    const vector = [];
+    let currentSeed = simpleHash(seed);
+    const nextRandom = () => {
+      currentSeed = Math.imul(currentSeed, 1664525) + 1013904223 >>> 0;
+      return currentSeed / 4294967296;
+    };
+    for (let j = 0; j < dimensions; j += 2) {
+      const u1 = Math.max(nextRandom(), 1e-10);
+      const u2 = nextRandom();
+      const z0 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+      const z1 = Math.sqrt(-2 * Math.log(u1)) * Math.sin(2 * Math.PI * u2);
+      vector.push(z0);
+      if (j + 1 < dimensions) {
+        vector.push(z1);
+      }
+    }
+    hyperplanes.push(vector);
+  }
+  return hyperplanes;
+}
+function simpleHash(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function computeSimHash(embedding, hyperplanes) {
+  if (embedding.length === 0) return "";
+  const dims = Math.min(embedding.length, hyperplanes[0].length);
+  let signatureBytes = new Uint8Array(hyperplanes.length / 8);
+  for (let i = 0; i < hyperplanes.length; i++) {
+    let dotProduct = 0;
+    for (let j = 0; j < dims; j++) {
+      dotProduct += embedding[j] * hyperplanes[i][j];
+    }
+    if (dotProduct > 0) {
+      const byteIndex = Math.floor(i / 8);
+      const bitIndex = 7 - i % 8;
+      signatureBytes[byteIndex] |= 1 << bitIndex;
+    }
+  }
+  return uint8ArrayToHex(signatureBytes);
+}
+function uint8ArrayToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function similarityFromDistance(distance, totalBits = 256) {
+  return Math.max(0, 1 - distance / totalBits);
+}
+function hammingDistance(hex1, hex2) {
+  if (hex1.length !== hex2.length) {
+    throw new Error("Hex strings must be equal length");
+  }
+  let distance = 0;
+  for (let i = 0; i < hex1.length; i += 2) {
+    const byte1 = parseInt(hex1.substring(i, i + 2), 16);
+    const byte2 = parseInt(hex2.substring(i, i + 2), 16);
+    let xor = byte1 ^ byte2;
+    while (xor > 0) {
+      if ((xor & 1) === 1) distance++;
+      xor >>= 1;
+    }
+  }
+  return distance;
+}
+var cachedHyperplanes = null;
+function getHyperplanes(dimensions = 1024, count = 256) {
+  if (!cachedHyperplanes || cachedHyperplanes[0].length !== dimensions || cachedHyperplanes.length !== count) {
+    console.time("Generating Hyperplanes");
+    cachedHyperplanes = generateHyperplanes(dimensions, count);
+    console.timeEnd("Generating Hyperplanes");
+  }
+  return cachedHyperplanes;
+}
+
+// src/core/biometrics/biometricUtils.ts
+var EXPECTED_MESH_POINTS = 468;
+var EXPECTED_LANDMARKS = 68;
+var MIN_EMBEDDING_LENGTH = 128;
+var MIN_FACE_SIZE = 100;
+var MAX_ROTATION_YAW = 30;
+var MAX_ROTATION_PITCH = 20;
+var MAX_ROTATION_ROLL = 15;
+var MIN_QUALITY_SCORE = 75;
+function averageEmbeddings(embeddings) {
+  if (!embeddings || embeddings.length === 0) return [];
+  if (embeddings.length === 1) return embeddings[0];
+  const dim = embeddings[0].length;
+  const count = embeddings.length;
+  const medianEmbedding = new Array(dim).fill(0);
+  for (let d = 0; d < dim; d++) {
+    const valuesForDim = embeddings.map((emb) => emb[Math.min(d, emb.length - 1)] || 0);
+    valuesForDim.sort((a, b) => a - b);
+    medianEmbedding[d] = valuesForDim[Math.floor(count / 2)];
+  }
+  const distances = embeddings.map((emb, index) => {
+    let sumSq = 0;
+    for (let d = 0; d < dim; d++) {
+      const diff = (emb[d] || 0) - medianEmbedding[d];
+      sumSq += diff * diff;
+    }
+    return { index, distance: Math.sqrt(sumSq) };
+  });
+  distances.sort((a, b) => a.distance - b.distance);
+  const keepCount = Math.max(1, Math.floor(count * 0.7));
+  const bestIndices = new Set(distances.slice(0, keepCount).map((d) => d.index));
+  const finalAvg = new Array(dim).fill(0);
+  for (let i = 0; i < count; i++) {
+    if (bestIndices.has(i)) {
+      for (let d = 0; d < dim; d++) {
+        finalAvg[d] += embeddings[i][d] || 0;
+      }
+    }
+  }
+  for (let d = 0; d < dim; d++) {
+    finalAvg[d] /= keepCount;
+  }
+  console.log(`Averaged ${keepCount} clean embeddings (discarded ${count - keepCount} outliers)`);
+  return finalAvg;
+}
+function safeNumber(value, fallback = 0) {
+  return typeof value === "number" && !isNaN(value) ? value : fallback;
+}
+function normalizePoint(point) {
+  if (!point) return [0, 0, 0];
+  if (Array.isArray(point)) {
+    return [
+      safeNumber(point[0]),
+      safeNumber(point[1]),
+      safeNumber(point[2])
+    ];
+  }
+  if (typeof point === "object") {
+    return [
+      safeNumber(point.x),
+      safeNumber(point.y),
+      safeNumber(point.z)
+    ];
+  }
+  return [0, 0, 0];
+}
+function extractMeshData(face) {
+  if (Array.isArray(face.meshRaw) && face.meshRaw.length > 0) {
+    return face.meshRaw.map(normalizePoint);
+  }
+  if (Array.isArray(face.mesh) && face.mesh.length > 0) {
+    return face.mesh.map(normalizePoint);
+  }
+  console.warn("No mesh data available, using empty mesh");
+  return Array(EXPECTED_MESH_POINTS).fill([0, 0, 0]);
+}
+function extractLandmarksFromMesh(mesh) {
+  if (mesh.length === 0) {
+    console.warn("No mesh data for landmarks, using empty landmarks");
+    return Array(EXPECTED_LANDMARKS).fill([0, 0]);
+  }
+  return mesh.slice(0, EXPECTED_LANDMARKS).map((point) => [point[0], point[1]]);
+}
+function extractBoundingBox(face, mesh) {
+  const box = face.box;
+  if (!box) {
+    return calculateBoxFromMesh(mesh);
+  }
+  if (box.x !== void 0 && box.width !== void 0) {
+    return {
+      x: safeNumber(box.x),
+      y: safeNumber(box.y),
+      width: safeNumber(box.width),
+      height: safeNumber(box.height)
+    };
+  }
+  if (box.left !== void 0) {
+    return {
+      x: safeNumber(box.left),
+      y: safeNumber(box.top),
+      width: safeNumber(box.right - box.left),
+      height: safeNumber(box.bottom - box.top)
+    };
+  }
+  if (Array.isArray(box) && box.length >= 4) {
+    return {
+      x: safeNumber(box[0]),
+      y: safeNumber(box[1]),
+      width: safeNumber(box[2]),
+      height: safeNumber(box[3])
+    };
+  }
+  return calculateBoxFromMesh(mesh);
+}
+function calculateBoxFromMesh(mesh) {
+  if (mesh.length === 0) return null;
+  const xs = mesh.map((p) => p[0]).filter((x) => typeof x === "number" && !isNaN(x));
+  const ys = mesh.map((p) => p[1]).filter((y) => typeof y === "number" && !isNaN(y));
+  if (xs.length === 0 || ys.length === 0) return null;
+  const minX = Math.min(...xs);
+  const maxX = Math.max(...xs);
+  const minY = Math.min(...ys);
+  const maxY = Math.max(...ys);
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function extractRawFacialData(face) {
+  if (!face) {
+    throw new Error("No face data provided");
+  }
+  const rawEmbedding = face.embedding || [];
+  if (!rawEmbedding || rawEmbedding.length === 0) {
+    console.error("\u274C CRITICAL: Face embedding is empty!");
+    console.error("This means face.description module is not enabled in Human.js config");
+    console.error("Enable it with: face: { description: { enabled: true } }");
+    throw new Error(
+      "Face embedding not available. Ensure face.description is enabled in Human.js configuration."
+    );
+  }
+  const faceEmbedding = normalizeEmbedding(Array.from(rawEmbedding));
+  const faceMesh = extractMeshData(face);
+  const faceLandmarks = extractLandmarksFromMesh(faceMesh);
+  const faceRotation = face.rotation ? {
+    angle: {
+      yaw: safeNumber(face.rotation.angle?.yaw),
+      pitch: safeNumber(face.rotation.angle?.pitch),
+      roll: safeNumber(face.rotation.angle?.roll)
+    },
+    matrix: Array.isArray(face.rotation.matrix) ? face.rotation.matrix : []
+  } : null;
+  const faceBox = extractBoundingBox(face, faceMesh);
+  const emotion = Array.isArray(face.emotion) ? face.emotion.map((em) => ({
+    emotion: em.emotion || "unknown",
+    score: safeNumber(em.score)
+  })) : void 0;
+  const result = {
+    faceEmbedding,
+    faceMesh,
+    faceLandmarks,
+    faceRotation,
+    faceBox,
+    emotion,
+    timestamp: Date.now()
+  };
+  console.log("\u2705 Facial data extracted:", {
+    embeddingLength: faceEmbedding.length,
+    meshPoints: faceMesh.length,
+    landmarksPoints: faceLandmarks.length,
+    hasRotation: !!faceRotation,
+    hasBox: !!faceBox,
+    emotions: emotion?.length || 0
+  });
+  return result;
+}
+function normalizeEmbedding(embedding) {
+  if (!embedding?.length) return [];
+  const norm = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+  if (norm === 0 || !isFinite(norm)) {
+    console.warn("Invalid norm detected, returning original embedding");
+    return embedding;
+  }
+  return embedding.map((val) => val / norm);
+}
+function createLivenessData(blinkCount, blinkTimestamps, emotionTransitions, headMovement, verificationDuration, stepCompletionTimes) {
+  return {
+    blinkCount,
+    blinkTimestamps: [...blinkTimestamps],
+    // Create copy
+    emotionTransitions: [...emotionTransitions],
+    // Create copy
+    headMovement: { ...headMovement },
+    // Create copy
+    verificationDuration,
+    stepCompletionTimes: { ...stepCompletionTimes }
+    // Create copy
+  };
+}
+var EmbeddingQuantizer = class {
+  constructor(calibrationParams) {
+    this.EPSILON = 1e-8;
+    this.DEFAULT_MIN = calibrationParams?.min ?? -2;
+    this.DEFAULT_MAX = calibrationParams?.max ?? 2;
+  }
+  /**
+   * Quantize embedding to u8 format for Aleo circuit
+   */
+  quantizeEmbedding(embedding, targetRows = 4, targetCols = 16) {
+    const normalized = this.normalizeToRange(embedding);
+    const reshaped = this.reshapeEmbedding(normalized, targetRows, targetCols);
+    return reshaped.map(
+      (row) => row.map((value) => Math.min(255, Math.max(0, Math.round(value * 255))))
+    );
+  }
+  /**
+   * Normalize to [0, 1] range with improved outlier handling
+   */
+  normalizeToRange(embedding) {
+    const embArray = Array.from(embedding);
+    if (embArray.length === 0) {
+      throw new Error("Empty embedding provided");
+    }
+    const actualMin = Math.min(...embArray);
+    const actualMax = Math.max(...embArray);
+    const minVal = Math.min(actualMin, this.DEFAULT_MIN);
+    const maxVal = Math.max(actualMax, this.DEFAULT_MAX);
+    const range = maxVal - minVal + this.EPSILON;
+    return embArray.map((value) => {
+      const normalized = (value - minVal) / range;
+      return Math.max(0, Math.min(1, normalized));
+    });
+  }
+  /**
+   * Strategic sampling with information-preserving bias
+   */
+  reshapeEmbedding(embedding, targetRows, targetCols) {
+    const totalTarget = targetRows * targetCols;
+    const sourceLength = embedding.length;
+    if (sourceLength <= totalTarget) {
+      return this.padAndReshape(embedding, targetRows, targetCols);
+    }
+    return this.sampleAndReshape(embedding, targetRows, targetCols);
+  }
+  /**
+   * Improved sampling with better distribution
+   */
+  sampleAndReshape(embedding, targetRows, targetCols) {
+    const totalTarget = targetRows * targetCols;
+    const sourceLength = embedding.length;
+    const sampledValues = [];
+    for (let i = 0; i < totalTarget; i++) {
+      const ratio = i / totalTarget;
+      let position;
+      if (ratio < 0.7) {
+        position = Math.floor(ratio / 0.7 * sourceLength * 0.6);
+      } else {
+        const remaining = ratio - 0.7;
+        position = Math.floor(sourceLength * 0.6 + remaining / 0.3 * sourceLength * 0.4);
+      }
+      sampledValues.push(embedding[Math.min(position, sourceLength - 1)]);
+    }
+    const result = [];
+    for (let row = 0; row < targetRows; row++) {
+      result.push(sampledValues.slice(row * targetCols, (row + 1) * targetCols));
+    }
+    return result;
+  }
+  /**
+   * Pad with mean value to maintain distribution
+   */
+  padAndReshape(embedding, targetRows, targetCols) {
+    const totalTarget = targetRows * targetCols;
+    const mean = embedding.reduce((sum, val) => sum + val, 0) / embedding.length;
+    const padded = [...embedding, ...Array(totalTarget - embedding.length).fill(mean)];
+    const result = [];
+    for (let row = 0; row < targetRows; row++) {
+      result.push(padded.slice(row * targetCols, (row + 1) * targetCols));
+    }
+    return result;
+  }
+  /**
+   * Process embedding for all 4 Aleo circuit chunks
+   */
+  processForAleo(embedding) {
+    const embArray = Array.from(embedding);
+    return {
+      embedding_chunk1: this.quantizeEmbedding(embArray, 4, 16),
+      embedding_chunk2: this.createChunkWithOffset(embArray, 0.25),
+      embedding_chunk3: this.createChunkWithOffset(embArray, 0.5),
+      embedding_chunk4: this.createChunkWithOffset(embArray, 0.75)
+    };
+  }
+  /**
+   * Create chunk with circular offset
+   */
+  createChunkWithOffset(embedding, offsetRatio) {
+    const offsetIndex = Math.floor(embedding.length * offsetRatio);
+    const shifted = [
+      ...embedding.slice(offsetIndex),
+      ...embedding.slice(0, offsetIndex)
+    ];
+    return this.quantizeEmbedding(shifted, 4, 16);
+  }
+  /**
+   * Validate quantized embedding meets Aleo requirements
+   */
+  validateForAleo(chunks) {
+    const chunkArray = [
+      chunks.embedding_chunk1,
+      chunks.embedding_chunk2,
+      chunks.embedding_chunk3,
+      chunks.embedding_chunk4
+    ];
+    chunkArray.forEach((chunk, chunkIdx) => {
+      if (chunk.length !== 4) {
+        throw new Error(`Chunk ${chunkIdx + 1}: Expected 4 rows, got ${chunk.length}`);
+      }
+      chunk.forEach((row, rowIdx) => {
+        if (row.length !== 16) {
+          throw new Error(`Chunk ${chunkIdx + 1}, Row ${rowIdx}: Expected 16 cols, got ${row.length}`);
+        }
+        row.forEach((value, colIdx) => {
+          if (!Number.isInteger(value) || value < 0 || value > 255) {
+            throw new Error(
+              `Chunk ${chunkIdx + 1}[${rowIdx}][${colIdx}]: Invalid u8 value ${value}`
+            );
+          }
+        });
+      });
+    });
+  }
+  /**
+   * Calibrate parameters from sample embeddings
+   */
+  calibrateFromSamples(samples) {
+    if (samples.length === 0) {
+      throw new Error("No samples provided for calibration");
+    }
+    let globalMin = Infinity;
+    let globalMax = -Infinity;
+    for (const embedding of samples) {
+      const embArray = Array.from(embedding);
+      globalMin = Math.min(globalMin, Math.min(...embArray));
+      globalMax = Math.max(globalMax, Math.max(...embArray));
+    }
+    const padding = (globalMax - globalMin) * 0.1;
+    this.DEFAULT_MIN = globalMin - padding;
+    this.DEFAULT_MAX = globalMax + padding;
+    console.log(`Calibrated quantizer: [${this.DEFAULT_MIN.toFixed(3)}, ${this.DEFAULT_MAX.toFixed(3)}]`);
+    return { min: this.DEFAULT_MIN, max: this.DEFAULT_MAX };
+  }
+};
+function validateDataQuality(data) {
+  const issues = [];
+  let score = 100;
+  if (data.faceEmbedding.length < MIN_EMBEDDING_LENGTH) {
+    issues.push(`Embedding too short: ${data.faceEmbedding.length} < ${MIN_EMBEDDING_LENGTH}`);
+    score -= 30;
+  }
+  if (data.faceMesh.length > 0 && data.faceMesh.length < EXPECTED_MESH_POINTS) {
+    issues.push(`Incomplete mesh: ${data.faceMesh.length}/${EXPECTED_MESH_POINTS} points. (Ignored for performance)`);
+  }
+  if (data.faceLandmarks.length < EXPECTED_LANDMARKS) {
+    issues.push(`Incomplete landmarks: ${data.faceLandmarks.length}/${EXPECTED_LANDMARKS} points`);
+    score -= 15;
+  }
+  if (data.faceRotation) {
+    const { yaw, pitch, roll } = data.faceRotation.angle;
+    if (Math.abs(yaw) > MAX_ROTATION_YAW) {
+      issues.push(`Excessive yaw rotation: ${yaw.toFixed(1)}\xB0`);
+      score -= 10;
+    }
+    if (Math.abs(pitch) > MAX_ROTATION_PITCH) {
+      issues.push(`Excessive pitch tilt: ${pitch.toFixed(1)}\xB0`);
+      score -= 10;
+    }
+    if (Math.abs(roll) > MAX_ROTATION_ROLL) {
+      issues.push(`Excessive roll tilt: ${roll.toFixed(1)}\xB0`);
+      score -= 10;
+    }
+  }
+  if (data.faceBox) {
+    const { width, height } = data.faceBox;
+    if (width < MIN_FACE_SIZE || height < MIN_FACE_SIZE) {
+      issues.push(`Face too small: ${Math.round(width)}x${Math.round(height)}px`);
+      score -= 15;
+    }
+  }
+  score = Math.max(0, score);
+  return {
+    isValid: score >= MIN_QUALITY_SCORE,
+    score,
+    issues
+  };
+}
+function processFacialDataForAleo(face, livenessData, quantizer) {
+  const rawFacialData = extractRawFacialData(face);
+  const quality = validateDataQuality(rawFacialData);
+  if (!quality.isValid) {
+    console.warn("Data quality issues detected:", quality.issues);
+  }
+  const hasBlink = livenessData.blinkCount >= 1;
+  const hasEmotionTransition = livenessData.emotionTransitions.length > 0;
+  let livenessCombined = 0;
+  if (hasBlink && hasEmotionTransition) {
+    livenessCombined = 3;
+  } else if (hasBlink) {
+    livenessCombined = 1;
+  } else if (hasEmotionTransition) {
+    livenessCombined = 2;
+  }
+  const embeddingQuantizer = quantizer || new EmbeddingQuantizer();
+  const chunks = embeddingQuantizer.processForAleo(rawFacialData.faceEmbedding);
+  embeddingQuantizer.validateForAleo(chunks);
+  return {
+    ...chunks,
+    liveness_combined: livenessCombined
+  };
+}
+function generateBiometricSimHash(face, livenessData, averagedEmbedding) {
+  const rawData = extractRawFacialData(face);
+  const sourceEmbedding = averagedEmbedding && averagedEmbedding.length > 0 ? averagedEmbedding : rawData.faceEmbedding;
+  const normalized = normalizeEmbedding(sourceEmbedding);
+  const hyperplanes = getHyperplanes(1024, 256);
+  const simHashHex = computeSimHash(normalized, hyperplanes);
+  const hasBlink = livenessData.blinkCount >= 1;
+  const hasEmotionTransition = livenessData.emotionTransitions.length > 0;
+  let livenessCombined = 0;
+  if (hasBlink && hasEmotionTransition) {
+    livenessCombined = 3;
+  } else if (hasBlink) {
+    livenessCombined = 1;
+  } else if (hasEmotionTransition) {
+    livenessCombined = 2;
+  }
+  return {
+    simhash_full: simHashHex,
+    liveness_combined: livenessCombined
+  };
+}
+function generateRandomSalt() {
+  const array = new Uint32Array(8);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else {
+    for (let i = 0; i < array.length; i++) {
+      array[i] = Math.floor(Math.random() * 4294967295);
+    }
+  }
+  return Array.from(array).map((val) => val.toString(16).padStart(8, "0")).join("");
+}
+function createCalibratedQuantizer(samples) {
+  const quantizer = new EmbeddingQuantizer();
+  quantizer.calibrateFromSamples(samples);
+  return quantizer;
+}
+function calculateHammingDistance(hash1, hash2) {
+  return hammingDistance(hash1, hash2);
+}
+
+// src/core/biometrics/faceOcclusion.ts
+function lumaOf(r, g, b) {
+  return 0.299 * r + 0.587 * g + 0.114 * b;
+}
+function chromaDist(a, b) {
+  const sumA = a.r + a.g + a.b || 1;
+  const sumB = b.r + b.g + b.b || 1;
+  const rA = a.r / sumA, gA = a.g / sumA;
+  const rB = b.r / sumB, gB = b.g / sumB;
+  return Math.sqrt((rA - rB) ** 2 + (gA - gB) ** 2);
+}
+function samplePoint(ctx, landmarks, index, width, height, radius = 3) {
+  const pt = landmarks[index];
+  if (!pt) return { r: 128, g: 96, b: 80, luma: 100 };
+  const cx = Math.max(0, Math.min(width - 1, Math.floor(pt.x * width)));
+  const cy = Math.max(0, Math.min(height - 1, Math.floor(pt.y * height)));
+  const x0 = Math.max(0, cx - radius);
+  const y0 = Math.max(0, cy - radius);
+  const bw = Math.min(width - x0, radius * 2 + 1);
+  const bh = Math.min(height - y0, radius * 2 + 1);
+  if (bw < 1 || bh < 1) return { r: 128, g: 96, b: 80, luma: 100 };
+  const data = ctx.getImageData(x0, y0, bw, bh).data;
+  let r = 0, g = 0, b = 0;
+  const n = data.length / 4;
+  for (let i = 0; i < data.length; i += 4) {
+    r += data[i];
+    g += data[i + 1];
+    b += data[i + 2];
+  }
+  r /= n;
+  g /= n;
+  b /= n;
+  return { r, g, b, luma: lumaOf(r, g, b) };
+}
+function sampleRect(ctx, x0, y0, w, h, imgW, imgH) {
+  x0 = Math.max(0, Math.round(x0));
+  y0 = Math.max(0, Math.round(y0));
+  w = Math.min(imgW - x0, Math.max(1, Math.round(w)));
+  h = Math.min(imgH - y0, Math.max(1, Math.round(h)));
+  const data = ctx.getImageData(x0, y0, w, h).data;
+  let r = 0, g = 0, b = 0;
+  const n = data.length / 4;
+  for (let i = 0; i < data.length; i += 4) {
+    r += data[i];
+    g += data[i + 1];
+    b += data[i + 2];
+  }
+  r /= n;
+  g /= n;
+  b /= n;
+  return { r, g, b, luma: lumaOf(r, g, b) };
+}
+function sobelEdgeDensity(ctx, x0, y0, w, h, imgW, imgH, threshold = 30) {
+  x0 = Math.max(0, Math.round(x0));
+  y0 = Math.max(0, Math.round(y0));
+  w = Math.min(imgW - x0, Math.max(3, Math.round(w)));
+  h = Math.min(imgH - y0, Math.max(3, Math.round(h)));
+  const data = ctx.getImageData(x0, y0, w, h).data;
+  const grey = new Float32Array(w * h);
+  for (let i = 0; i < grey.length; i++) {
+    grey[i] = lumaOf(data[i * 4], data[i * 4 + 1], data[i * 4 + 2]);
+  }
+  let edgePx = 0;
+  for (let y = 1; y < h - 1; y++) {
+    for (let x = 1; x < w - 1; x++) {
+      const idx = y * w + x;
+      const gx = -grey[idx - w - 1] + grey[idx - w + 1] - 2 * grey[idx - 1] + 2 * grey[idx + 1] - grey[idx + w - 1] + grey[idx + w + 1];
+      const gy = grey[idx - w - 1] + 2 * grey[idx - w] + grey[idx - w + 1] - grey[idx + w - 1] - 2 * grey[idx + w] - grey[idx + w + 1];
+      if (Math.sqrt(gx * gx + gy * gy) > threshold) edgePx++;
+    }
+  }
+  return edgePx / ((w - 2) * (h - 2));
+}
+function countSpecularBlobs(ctx, x0, y0, w, h, imgW, imgH, lumaThreshold = 220, minSepFraction = 0.15) {
+  x0 = Math.max(0, Math.round(x0));
+  y0 = Math.max(0, Math.round(y0));
+  w = Math.min(imgW - x0, Math.max(1, Math.round(w)));
+  h = Math.min(imgH - y0, Math.max(1, Math.round(h)));
+  const data = ctx.getImageData(x0, y0, w, h).data;
+  const brightCentroids = [];
+  const minSep = w * minSepFraction;
+  for (let row = 0; row < h; row++) {
+    for (let col = 0; col < w; col++) {
+      const i = (row * w + col) * 4;
+      const l = lumaOf(data[i], data[i + 1], data[i + 2]);
+      if (l < lumaThreshold) continue;
+      let merged = false;
+      for (const c of brightCentroids) {
+        const d = Math.hypot(col - c.x, row - c.y);
+        if (d < minSep) {
+          merged = true;
+          break;
+        }
+      }
+      if (!merged) brightCentroids.push({ x: col, y: row });
+    }
+  }
+  return brightCentroids.length;
+}
+function irisLumaVariance(ctx, landmarks, irisIndices, imgW, imgH) {
+  if (landmarks.length < 478) return -1;
+  const valid = irisIndices.filter((i) => landmarks[i]);
+  if (valid.length < 3) return -1;
+  const xs = valid.map((i) => landmarks[i].x * imgW);
+  const ys = valid.map((i) => landmarks[i].y * imgH);
+  const cx = xs.reduce((a, b) => a + b, 0) / xs.length;
+  const cy = ys.reduce((a, b) => a + b, 0) / ys.length;
+  const r = Math.max(4, xs.reduce((a, x, i) => a + Math.hypot(x - cx, ys[i] - cy), 0) / xs.length);
+  const x0 = Math.max(0, Math.floor(cx - r));
+  const y0 = Math.max(0, Math.floor(cy - r));
+  const bw = Math.min(imgW - x0, Math.ceil(r * 2));
+  const bh = Math.min(imgH - y0, Math.ceil(r * 2));
+  if (bw < 3 || bh < 3) return -1;
+  const data = ctx.getImageData(x0, y0, bw, bh).data;
+  const lumas = [];
+  for (let row = 0; row < bh; row++) {
+    for (let col = 0; col < bw; col++) {
+      const dx = x0 + col - cx, dy = y0 + row - cy;
+      if (dx * dx + dy * dy > r * r) continue;
+      const i = (row * bw + col) * 4;
+      lumas.push(lumaOf(data[i], data[i + 1], data[i + 2]));
+    }
+  }
+  if (lumas.length < 5) return -1;
+  const mean = lumas.reduce((a, v) => a + v, 0) / lumas.length;
+  return lumas.reduce((a, v) => a + (v - mean) ** 2, 0) / lumas.length;
+}
+function computeEyeSignals(side, skin, ctx, landmarks, imgW, imgH, duringFlash) {
+  const isLeft = side === "left";
+  const outerIdx = isLeft ? 33 : 263;
+  const innerIdx = isLeft ? 133 : 362;
+  const upperLidIdx = isLeft ? 159 : 386;
+  const lowerLidIdx = isLeft ? 145 : 374;
+  const browIdx = isLeft ? 70 : 300;
+  const cheekIdx = isLeft ? 116 : 345;
+  const irisIdxs = isLeft ? [474, 475, 476, 477] : [469, 470, 471, 472];
+  const outer = landmarks[outerIdx];
+  const inner = landmarks[innerIdx];
+  const upperLid = landmarks[upperLidIdx];
+  const lowerLid = landmarks[lowerLidIdx];
+  if (!outer || !inner || !upperLid || !lowerLid) {
+    return { lensOpacity: false, frameEdgeDensity: false, specularClusters: false, chromaStripe: false, irisTextureMismatch: false };
+  }
+  const eyeLeft = Math.min(outer.x, inner.x) * imgW;
+  const eyeRight = Math.max(outer.x, inner.x) * imgW;
+  const eyeTop = upperLid.y * imgH - 4;
+  const eyeBottom = lowerLid.y * imgH + 4;
+  const eyeW = eyeRight - eyeLeft;
+  const eyeH = Math.max(6, eyeBottom - eyeTop);
+  const lensY0 = (upperLid.y * imgH + eyeTop) / 2;
+  const lensH = Math.max(6, lowerLid.y * imgH - lensY0);
+  const lensSample = sampleRect(ctx, eyeLeft + eyeW * 0.1, lensY0, eyeW * 0.8, lensH, imgW, imgH);
+  const lensOpacity = skin.luma > 40 && lensSample.luma < skin.luma * 0.38;
+  const brow = landmarks[browIdx];
+  const rawStripTop = brow ? brow.y * imgH : eyeTop - 14;
+  const lidY = upperLid.y * imgH;
+  const stripTop = rawStripTop + (lidY - rawStripTop) * 0.7;
+  const stripBottom = lidY + 2;
+  const stripH = Math.max(4, stripBottom - stripTop);
+  const edgeDensity = sobelEdgeDensity(
+    ctx,
+    eyeLeft - 4,
+    stripTop,
+    eyeW + 8,
+    stripH,
+    imgW,
+    imgH,
+    32
+    // higher threshold — we want frame-weight edges, not fine skin texture
+  );
+  const frameEdgeDensity = edgeDensity > 0.3;
+  let specularClusters = false;
+  if (!duringFlash) {
+    const blobs = countSpecularBlobs(
+      ctx,
+      eyeLeft - 2,
+      eyeTop - 2,
+      eyeW + 4,
+      eyeH + 4,
+      imgW,
+      imgH,
+      230,
+      // raised from 215
+      0.2
+      // raised from 0.14
+    );
+    specularClusters = blobs >= 2;
+  }
+  let chromaStripe = false;
+  {
+    const brow2 = landmarks[browIdx];
+    const lidTop = upperLid.y * imgH;
+    const browBottom = brow2 ? brow2.y * imgH : lidTop - 14;
+    const frameZoneY1 = browBottom + (lidTop - browBottom) * 0.4;
+    const frameZoneY2 = browBottom + (lidTop - browBottom) * 0.8;
+    const xPositions = [0.15, 0.35, 0.5, 0.65, 0.85].map((f) => eyeLeft + eyeW * f);
+    let stripeHits = 0;
+    for (const x of xPositions) {
+      const midSample = sampleRect(ctx, x - 2, frameZoneY1 - 3, 5, 6, imgW, imgH);
+      const nearSample = sampleRect(ctx, x - 2, frameZoneY2 - 3, 5, 6, imgW, imgH);
+      if (chromaDist(midSample, skin) > 0.17 && chromaDist(nearSample, skin) > 0.17) {
+        stripeHits++;
+      }
+    }
+    chromaStripe = stripeHits >= 4;
+  }
+  let irisTextureMismatch = false;
+  {
+    const openness = (lowerLid.y - upperLid.y) * imgH;
+    if (openness > imgH * 0.025) {
+      const variance = irisLumaVariance(ctx, landmarks, irisIdxs, imgW, imgH);
+      if (variance >= 0 && variance < 60) {
+        irisTextureMismatch = true;
+      }
+    }
+  }
+  return { lensOpacity, frameEdgeDensity, specularClusters, chromaStripe, irisTextureMismatch };
+}
+function computeBridgeSignal(skin, ctx, landmarks, imgW, imgH) {
+  const bridgePt = landmarks[168];
+  if (!bridgePt) return { chromaHigh: false, edgeHigh: false };
+  const bx = bridgePt.x * imgW;
+  const by = bridgePt.y * imgH;
+  const bSample = sampleRect(ctx, bx - 12, by - 5, 24, 10, imgW, imgH);
+  const chromaHigh = chromaDist(bSample, skin) > 0.14 || bSample.luma < skin.luma * 0.38 && skin.luma > 40;
+  const edgeDensity = sobelEdgeDensity(ctx, bx - 14, by - 7, 28, 14, imgW, imgH, 30);
+  const edgeHigh = edgeDensity > 0.2;
+  return { chromaHigh, edgeHigh };
+}
+var EMA_ALPHA = 0.35;
+var CONFIRM_FRAMES = 3;
+function emptyEma() {
+  return { lensOpacity: 0, frameEdgeDensity: 0, specularClusters: 0, chromaStripe: 0, irisTextureMismatch: 0, bridgeChroma: 0, bridgeEdge: 0 };
+}
+var GlassesDetector = class {
+  constructor() {
+    this.emaLeft = emptyEma();
+    this.emaRight = emptyEma();
+    this.emaBridge = { bridgeChroma: 0, bridgeEdge: 0 };
+    this.consecutivePositive = 0;
+    this.consecutiveNegative = 0;
+    this._detected = false;
+  }
+  reset() {
+    this.emaLeft = emptyEma();
+    this.emaRight = emptyEma();
+    this.emaBridge = { bridgeChroma: 0, bridgeEdge: 0 };
+    this.consecutivePositive = 0;
+    this.consecutiveNegative = 0;
+    this._detected = false;
+  }
+  get detected() {
+    return this._detected;
+  }
+  /**
+   * Feed a new frame into the detector.
+   * @returns true if glasses are currently detected (after smoothing).
+   */
+  update(skin, ctx, landmarks, imgW, imgH, options = {}) {
+    if (skin.luma < 18) return this._detected;
+    const flash = options.duringLivenessFlash ?? false;
+    const lSig = computeEyeSignals("left", skin, ctx, landmarks, imgW, imgH, flash);
+    const rSig = computeEyeSignals("right", skin, ctx, landmarks, imgW, imgH, flash);
+    const bSig = computeBridgeSignal(skin, ctx, landmarks, imgW, imgH);
+    const a = EMA_ALPHA;
+    const ema = (prev, val) => prev * (1 - a) + (val ? 1 : 0) * a;
+    this.emaLeft.lensOpacity = ema(this.emaLeft.lensOpacity, lSig.lensOpacity);
+    this.emaLeft.frameEdgeDensity = ema(this.emaLeft.frameEdgeDensity, lSig.frameEdgeDensity);
+    this.emaLeft.specularClusters = ema(this.emaLeft.specularClusters, lSig.specularClusters);
+    this.emaLeft.chromaStripe = ema(this.emaLeft.chromaStripe, lSig.chromaStripe);
+    this.emaLeft.irisTextureMismatch = ema(this.emaLeft.irisTextureMismatch, lSig.irisTextureMismatch);
+    this.emaRight.lensOpacity = ema(this.emaRight.lensOpacity, rSig.lensOpacity);
+    this.emaRight.frameEdgeDensity = ema(this.emaRight.frameEdgeDensity, rSig.frameEdgeDensity);
+    this.emaRight.specularClusters = ema(this.emaRight.specularClusters, rSig.specularClusters);
+    this.emaRight.chromaStripe = ema(this.emaRight.chromaStripe, rSig.chromaStripe);
+    this.emaRight.irisTextureMismatch = ema(this.emaRight.irisTextureMismatch, rSig.irisTextureMismatch);
+    this.emaBridge.bridgeChroma = ema(this.emaBridge.bridgeChroma, bSig.chromaHigh);
+    this.emaBridge.bridgeEdge = ema(this.emaBridge.bridgeEdge, bSig.edgeHigh);
+    const T = 0.45;
+    const score = (e) => (e.lensOpacity > T ? 1 : 0) + (e.frameEdgeDensity > T ? 1 : 0) + (e.specularClusters > T ? 1 : 0) + (e.chromaStripe > T ? 1 : 0) + (e.irisTextureMismatch > T ? 1 : 0);
+    const leftScore = score(this.emaLeft);
+    const rightScore = score(this.emaRight);
+    const bridgeScore = (this.emaBridge.bridgeChroma > T ? 1 : 0) + (this.emaBridge.bridgeEdge > T ? 1 : 0);
+    const sunglasses = this.emaLeft.lensOpacity > T && this.emaRight.lensOpacity > T;
+    const clearGlasses = leftScore >= 2 && rightScore >= 2 && leftScore + rightScore >= 5;
+    const rimless = leftScore >= 2 && rightScore >= 2 && bridgeScore >= 1 && leftScore + rightScore + bridgeScore >= 6;
+    const isGlasses = sunglasses || clearGlasses || rimless;
+    if (isGlasses) {
+      this.consecutivePositive++;
+      this.consecutiveNegative = 0;
+      if (this.consecutivePositive >= CONFIRM_FRAMES) this._detected = true;
+    } else {
+      this.consecutiveNegative++;
+      this.consecutivePositive = 0;
+      if (this.consecutiveNegative >= 5) this._detected = false;
+    }
+    return this._detected;
+  }
+};
+function computeMaskSignals(skin, ctx, landmarks, imgW, imgH) {
+  const forehead = samplePoint(ctx, landmarks, 10, imgW, imgH, 5);
+  const noseTip = samplePoint(ctx, landmarks, 4, imgW, imgH, 4);
+  const noseBottom = samplePoint(ctx, landmarks, 2, imgW, imgH, 4);
+  const upperLipCentre = samplePoint(ctx, landmarks, 13, imgW, imgH, 4);
+  const lowerLipCentre = samplePoint(ctx, landmarks, 14, imgW, imgH, 4);
+  const chin = samplePoint(ctx, landmarks, 152, imgW, imgH, 5);
+  const leftMouth = samplePoint(ctx, landmarks, 61, imgW, imgH, 4);
+  const rightMouth = samplePoint(ctx, landmarks, 291, imgW, imgH, 4);
+  const leftLowerCheek = samplePoint(ctx, landmarks, 50, imgW, imgH, 5);
+  const rightLowerCheek = samplePoint(ctx, landmarks, 280, imgW, imgH, 5);
+  const leftJaw = samplePoint(ctx, landmarks, 172, imgW, imgH, 5);
+  const rightJaw = samplePoint(ctx, landmarks, 397, imgW, imgH, 5);
+  const lowerPoints = [noseTip, noseBottom, upperLipCentre, lowerLipCentre, chin, leftLowerCheek, rightLowerCheek];
+  const meanLowerChroma = lowerPoints.reduce((s, p) => s + chromaDist(p, forehead), 0) / lowerPoints.length;
+  const meanLowerR = lowerPoints.reduce((s, p) => s + p.r, 0) / lowerPoints.length;
+  const meanLowerG = lowerPoints.reduce((s, p) => s + p.g, 0) / lowerPoints.length;
+  const meanLowerB = lowerPoints.reduce((s, p) => s + p.b, 0) / lowerPoints.length;
+  const lowerVariance = lowerPoints.reduce(
+    (s, p) => s + (p.r - meanLowerR) ** 2 + (p.g - meanLowerG) ** 2 + (p.b - meanLowerB) ** 2,
+    0
+  ) / lowerPoints.length;
+  const lowerFaceChromaUniform = meanLowerChroma > 0.1 && lowerVariance < 400;
+  const lumas = lowerPoints.map((p) => p.luma);
+  const meanLuma = lumas.reduce((a, v) => a + v, 0) / lumas.length;
+  const lumaStd = Math.sqrt(lumas.reduce((a, v) => a + (v - meanLuma) ** 2, 0) / lumas.length);
+  const lowerFaceLumaFlat = lumaStd < 10 && Math.abs(meanLuma - skin.luma) > 15;
+  const nLm = landmarks[4];
+  const cLm = landmarks[50];
+  let textureSuppressionNose = false;
+  if (nLm && cLm && skin.luma > 35) {
+    const rx = Math.min(nLm.x, cLm.x) * imgW - 4;
+    const ry = nLm.y * imgH;
+    const rw = Math.abs(nLm.x - cLm.x) * imgW + 8;
+    const rh = (cLm.y - nLm.y) * imgH + 8;
+    const density = sobelEdgeDensity(ctx, rx, ry, rw, rh, imgW, imgH, 20);
+    textureSuppressionNose = density < 0.06;
+  }
+  const lipRedness = (upperLipCentre.r + lowerLipCentre.r) / Math.max(1, upperLipCentre.g + upperLipCentre.b + lowerLipCentre.g + lowerLipCentre.b);
+  const skinRedness = skin.r / Math.max(1, skin.g + skin.b);
+  const lipColourMismatch = skin.luma > 50 && lipRedness < skinRedness - 0.03;
+  let lowerFaceEdgeDensity = false;
+  {
+    const lJaw = landmarks[172];
+    const rJaw = landmarks[397];
+    if (lJaw && rJaw) {
+      const stripY = (lJaw.y + rJaw.y) / 2 * imgH - 8;
+      const stripX = lJaw.x * imgW;
+      const stripW = (rJaw.x - lJaw.x) * imgW;
+      const stripH = 16;
+      const density = sobelEdgeDensity(ctx, stripX, stripY, stripW, stripH, imgW, imgH, 24);
+      lowerFaceEdgeDensity = density > 0.28;
+    }
+  }
+  const lumaRatio = forehead.luma > 10 ? meanLuma / forehead.luma : 1;
+  const lumaRatioAnomaly = lumaRatio < 0.5 || lumaRatio > 1.35;
+  return {
+    lowerFaceChromaUniform,
+    lowerFaceLumaFlat,
+    textureSuppressionNose,
+    lipColourMismatch,
+    lowerFaceEdgeDensity,
+    lumaRatioAnomaly
+  };
+}
+var MaskDetector = class {
+  constructor() {
+    this.ema = {
+      lowerFaceChromaUniform: 0,
+      lowerFaceLumaFlat: 0,
+      textureSuppressionNose: 0,
+      lipColourMismatch: 0,
+      lowerFaceEdgeDensity: 0,
+      lumaRatioAnomaly: 0
+    };
+    this.consecutivePositive = 0;
+    this.consecutiveNegative = 0;
+    this._detected = false;
+  }
+  reset() {
+    for (const k of Object.keys(this.ema)) this.ema[k] = 0;
+    this.consecutivePositive = 0;
+    this.consecutiveNegative = 0;
+    this._detected = false;
+  }
+  get detected() {
+    return this._detected;
+  }
+  update(skin, ctx, landmarks, imgW, imgH) {
+    if (skin.luma < 18) return this._detected;
+    const sig = computeMaskSignals(skin, ctx, landmarks, imgW, imgH);
+    const a = EMA_ALPHA;
+    const ema = (prev, val) => prev * (1 - a) + (val ? 1 : 0) * a;
+    this.ema.lowerFaceChromaUniform = ema(this.ema.lowerFaceChromaUniform, sig.lowerFaceChromaUniform);
+    this.ema.lowerFaceLumaFlat = ema(this.ema.lowerFaceLumaFlat, sig.lowerFaceLumaFlat);
+    this.ema.textureSuppressionNose = ema(this.ema.textureSuppressionNose, sig.textureSuppressionNose);
+    this.ema.lipColourMismatch = ema(this.ema.lipColourMismatch, sig.lipColourMismatch);
+    this.ema.lowerFaceEdgeDensity = ema(this.ema.lowerFaceEdgeDensity, sig.lowerFaceEdgeDensity);
+    this.ema.lumaRatioAnomaly = ema(this.ema.lumaRatioAnomaly, sig.lumaRatioAnomaly);
+    const T = 0.45;
+    const totalScore = (this.ema.lowerFaceChromaUniform > T ? 1 : 0) + (this.ema.lowerFaceLumaFlat > T ? 1 : 0) + (this.ema.textureSuppressionNose > T ? 1 : 0) + (this.ema.lipColourMismatch > T ? 1 : 0) + (this.ema.lowerFaceEdgeDensity > T ? 1 : 0) + (this.ema.lumaRatioAnomaly > T ? 1 : 0);
+    const isMask = totalScore >= 3;
+    if (isMask) {
+      this.consecutivePositive++;
+      this.consecutiveNegative = 0;
+      if (this.consecutivePositive >= CONFIRM_FRAMES) this._detected = true;
+    } else {
+      this.consecutiveNegative++;
+      this.consecutivePositive = 0;
+      if (this.consecutiveNegative >= 5) this._detected = false;
+    }
+    return this._detected;
+  }
+};
+var FaceOcclusionTracker = class {
+  constructor() {
+    this.armed = false;
+    this.blocked = false;
+    this.obstructionFrames = 0;
+    this.clearFrames = 0;
+    this.sessionViolation = false;
+    this.lastMessage = "Please remove obstructions from your face.";
+    this.preArmBlockFrames = 4;
+    this.violationAfterFrames = 1;
+    this.releaseFrames = 4;
+  }
+  reset() {
+    this.armed = false;
+    this.blocked = false;
+    this.obstructionFrames = 0;
+    this.clearFrames = 0;
+    this.sessionViolation = false;
+    this.lastMessage = "Please remove obstructions from your face.";
+  }
+  arm() {
+    this.armed = true;
+    this.obstructionFrames = 0;
+  }
+  hasSessionViolation() {
+    return this.sessionViolation;
+  }
+  apply(raw) {
+    const isObstruction = !raw.ok && (raw.message?.toLowerCase().includes("mask") || raw.message?.toLowerCase().includes("glass"));
+    if (isObstruction) {
+      this.obstructionFrames++;
+      this.clearFrames = 0;
+      if (raw.message) this.lastMessage = raw.message;
+      const blockThreshold = this.armed ? 1 : this.preArmBlockFrames;
+      if (this.obstructionFrames >= blockThreshold) this.blocked = true;
+      if (this.armed && this.obstructionFrames >= this.violationAfterFrames) this.sessionViolation = true;
+      if (this.blocked) return { ok: false, message: this.lastMessage };
+      return { ok: true };
+    }
+    this.obstructionFrames = 0;
+    if (this.blocked) {
+      if (!raw.ok) return raw;
+      this.clearFrames++;
+      if (this.clearFrames >= this.releaseFrames) {
+        this.blocked = false;
+        this.clearFrames = 0;
+        return { ok: true };
+      }
+      return { ok: false, message: this.lastMessage };
+    }
+    return raw;
+  }
+};
+var _glassesDetector = new GlassesDetector();
+var _maskDetector = new MaskDetector();
+var _noLandmarkFrames = 0;
+function checkFaceOcclusionRaw(landmarks, ctx, width, height, options = {}) {
+  if (!landmarks.length) {
+    _noLandmarkFrames++;
+    if (_noLandmarkFrames > 10) {
+      _glassesDetector.reset();
+      _maskDetector.reset();
+    }
+    return { ok: false, message: "Face not detected." };
+  }
+  _noLandmarkFrames = 0;
+  const forehead = samplePoint(ctx, landmarks, 10, width, height, 5);
+  const leftCheek = samplePoint(ctx, landmarks, 116, width, height, 5);
+  const rightCheek = samplePoint(ctx, landmarks, 345, width, height, 5);
+  const skin = {
+    r: (leftCheek.r + rightCheek.r + forehead.r) / 3,
+    g: (leftCheek.g + rightCheek.g + forehead.g) / 3,
+    b: (leftCheek.b + rightCheek.b + forehead.b) / 3,
+    luma: (leftCheek.luma + rightCheek.luma + forehead.luma) / 3
+  };
+  const maskDetected = _maskDetector.update(skin, ctx, landmarks, width, height);
+  if (maskDetected) {
+    return { ok: false, message: "Please remove your face mask." };
+  }
+  const glassesDetected = _glassesDetector.update(skin, ctx, landmarks, width, height, options);
+  if (glassesDetected) {
+    return { ok: false, message: "Please remove your glasses." };
+  }
+  return { ok: true };
+}
+function checkFaceOcclusion(landmarks, ctx, width, height) {
+  return checkFaceOcclusionRaw(landmarks, ctx, width, height);
+}
+
+// src/core/biometrics/LivenessEngine.ts
+var LivenessEngine = class {
+  constructor() {
+    this.videoElement = null;
+    this.flashOverlay = null;
+    // Track average intensity of R, G, B channels across frames
+    this.colorHistory = [];
+    this.canvas = document.createElement("canvas");
+    this.ctx = this.canvas.getContext("2d", { willReadFrequently: true });
+  }
+  setVideoElement(video) {
+    this.videoElement = video;
+  }
+  setFlashOverlay(overlay) {
+    this.flashOverlay = overlay;
+  }
+  /**
+   * Run the active light reflection sequence
+   * Flashes colors and measures the face bounding box reflection
+   */
+  async runLivenessSequence(boundingBox, assertFaceClear) {
+    if (!this.videoElement || !this.flashOverlay || !this.ctx) {
+      return { passed: false, score: 0, message: "Engine not fully initialized" };
+    }
+    this.colorHistory = [];
+    const sequence = ["red", "green", "blue", "none"];
+    sequence.sort(() => Math.random() - 0.5);
+    const fullSequence = ["none", ...sequence, "none"];
+    this.canvas.width = this.videoElement.videoWidth;
+    this.canvas.height = this.videoElement.videoHeight;
+    try {
+      for (const color of fullSequence) {
+        if (assertFaceClear) {
+          const status = assertFaceClear();
+          if (!status.aligned) {
+            return { passed: false, score: 0, message: status.message ?? "Face obstruction detected" };
+          }
+        }
+        await this.flashAndMeasure(color, boundingBox);
+      }
+      return this.analyzeResults();
+    } finally {
+      if (this.flashOverlay) {
+        this.flashOverlay.style.backgroundColor = "transparent";
+      }
+    }
+  }
+  async flashAndMeasure(color, box) {
+    if (this.flashOverlay) {
+      switch (color) {
+        case "red":
+          this.flashOverlay.style.backgroundColor = "rgba(255, 0, 0, 0.6)";
+          break;
+        case "green":
+          this.flashOverlay.style.backgroundColor = "rgba(0, 255, 0, 0.6)";
+          break;
+        case "blue":
+          this.flashOverlay.style.backgroundColor = "rgba(0, 0, 255, 0.6)";
+          break;
+        case "none":
+          this.flashOverlay.style.backgroundColor = "transparent";
+          break;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 400));
+    if (this.videoElement && this.ctx) {
+      this.ctx.drawImage(this.videoElement, 0, 0, this.canvas.width, this.canvas.height);
+      const x = Math.max(0, Math.floor(box.x));
+      const y = Math.max(0, Math.floor(box.y));
+      const w = Math.min(this.canvas.width - x, Math.floor(box.width));
+      const h = Math.min(this.canvas.height - y, Math.floor(box.height));
+      const imageData = this.ctx.getImageData(x, y, w, h);
+      const data = imageData.data;
+      let totalR = 0, totalG = 0, totalB = 0;
+      const pixelCount = w * h;
+      for (let i = 0; i < data.length; i += 4) {
+        totalR += data[i];
+        totalG += data[i + 1];
+        totalB += data[i + 2];
+      }
+      this.colorHistory.push({
+        timestamp: Date.now(),
+        colorFlashed: color,
+        avgR: totalR / pixelCount,
+        avgG: totalG / pixelCount,
+        avgB: totalB / pixelCount
+      });
+    }
+  }
+  analyzeResults() {
+    const baselines = this.colorHistory.filter((h) => h.colorFlashed === "none");
+    if (baselines.length === 0) return { passed: false, score: 0 };
+    const baseR = baselines.reduce((acc, b) => acc + b.avgR, 0) / baselines.length;
+    const baseG = baselines.reduce((acc, b) => acc + b.avgG, 0) / baselines.length;
+    const baseB = baselines.reduce((acc, b) => acc + b.avgB, 0) / baselines.length;
+    let score = 0;
+    let expectedSpikes = 0;
+    for (const record of this.colorHistory) {
+      if (record.colorFlashed === "none") continue;
+      expectedSpikes++;
+      const rDiff = record.avgR - baseR;
+      const gDiff = record.avgG - baseG;
+      const bDiff = record.avgB - baseB;
+      if (record.colorFlashed === "red" && rDiff > 0 && rDiff > Math.max(gDiff, bDiff)) score++;
+      if (record.colorFlashed === "green" && gDiff > 0 && gDiff > Math.max(rDiff, bDiff)) score++;
+      if (record.colorFlashed === "blue" && bDiff > 0 && bDiff > Math.max(rDiff, gDiff)) score++;
+    }
+    const passed = expectedSpikes > 0 && score >= 1;
+    return {
+      passed,
+      score: score / expectedSpikes * 100,
+      message: passed ? "Liveness verified via 3D light reflection" : "Liveness check failed. Ensure adequate lighting, turn up screen brightness, and do not use a photo."
+    };
+  }
+};
+
+// src/core/biometrics/captureQuality.ts
+var CAPTURE_QUALITY = {
+  /** Min average luminance in face region (0-255). Below = too dark */
+  LUMINANCE_MIN: 80,
+  /** Max average luminance. Above = overexposed / washed out */
+  LUMINANCE_MAX: 220,
+  /** Min face bounding box width/height in pixels */
+  FACE_MIN_SIZE: 100,
+  /** Ideal min size for best results */
+  FACE_IDEAL_SIZE: 140
+};
+function getFaceBox(face) {
+  const box = face.box;
+  if (!box) return null;
+  if (Array.isArray(box) && box.length >= 4) {
+    return { x: box[0], y: box[1], width: box[2], height: box[3] };
+  }
+  if (typeof box === "object") {
+    const obj = box;
+    if (obj.width != null && obj.x != null) {
+      return {
+        x: Number(obj.x),
+        y: Number(obj.y ?? 0),
+        width: Number(obj.width),
+        height: Number(obj.height ?? obj.width)
+      };
+    }
+    if (obj.left != null && obj.right != null) {
+      return {
+        x: Number(obj.left),
+        y: Number(obj.top ?? 0),
+        width: Number(obj.right - obj.left),
+        height: Number((obj.bottom ?? 0) - (obj.top ?? 0))
+      };
+    }
+  }
+  return null;
+}
+function getRegionLuminance(ctx, x, y, width, height) {
+  const w = Math.max(1, Math.floor(width));
+  const h = Math.max(1, Math.floor(height));
+  const sx = Math.max(0, Math.floor(x));
+  const sy = Math.max(0, Math.floor(y));
+  let sum = 0;
+  let count = 0;
+  const step = 4;
+  try {
+    const imageData = ctx.getImageData(sx, sy, w, h);
+    const data = imageData.data;
+    for (let i = 0; i < data.length; i += step * 4) {
+      const r = data[i];
+      const g = data[i + 1];
+      const b = data[i + 2];
+      sum += 0.299 * r + 0.587 * g + 0.114 * b;
+      count += 1;
+    }
+  } catch {
+    return 0;
+  }
+  return count > 0 ? sum / count : 0;
+}
+function getFaceLuminance(ctx, face, canvasWidth, canvasHeight) {
+  const box = getFaceBox(face);
+  if (!box) {
+    return getRegionLuminance(ctx, 0, 0, canvasWidth, canvasHeight);
+  }
+  let x = box.x;
+  let y = box.y;
+  let w = box.width;
+  let h = box.height;
+  if (w <= 1 && h <= 1) {
+    x *= canvasWidth;
+    y *= canvasHeight;
+    w *= canvasWidth;
+    h *= canvasHeight;
+  }
+  x = Math.max(0, Math.min(x, canvasWidth - 1));
+  y = Math.max(0, Math.min(y, canvasHeight - 1));
+  w = Math.max(1, Math.min(w, canvasWidth - x));
+  h = Math.max(1, Math.min(h, canvasHeight - y));
+  return getRegionLuminance(ctx, x, y, w, h);
+}
+function evaluateCaptureQuality(luminance, faceWidth, faceHeight) {
+  const luminanceOk = luminance >= CAPTURE_QUALITY.LUMINANCE_MIN && luminance <= CAPTURE_QUALITY.LUMINANCE_MAX;
+  const faceSizeOk = faceWidth >= CAPTURE_QUALITY.FACE_MIN_SIZE && faceHeight >= CAPTURE_QUALITY.FACE_MIN_SIZE;
+  const messages = [];
+  if (!luminanceOk) {
+    if (luminance < CAPTURE_QUALITY.LUMINANCE_MIN) {
+      messages.push("Low light \u2013 move to a brighter area");
+    } else {
+      messages.push("Too bright \u2013 reduce glare or move away from light");
+    }
+  }
+  if (!faceSizeOk) {
+    messages.push("Face too small \u2013 move closer to the camera");
+  }
+  if (luminanceOk && faceSizeOk) {
+    messages.push("Good \u2013 enough light and face data");
+  }
+  return {
+    luminance: Math.round(luminance),
+    luminanceOk,
+    faceWidth: Math.round(faceWidth),
+    faceHeight: Math.round(faceHeight),
+    faceSizeOk,
+    ready: luminanceOk && faceSizeOk,
+    message: messages.join(". ")
+  };
+}
+
+// src/core/config/humanConfig.ts
+var HUMAN_CONFIG = {
+  modelBasePath: "/models/",
+  backend: "webgpu",
+  // WebGPU is fastest, falls back to webgl/wasm
+  async: true,
+  cacheSensitivity: 0,
+  // Disable caching so embeddings are always fresh
+  skipFrame: false,
+  warmup: "none",
+  videoOptimized: true,
+  deallocate: true,
+  face: {
+    enabled: true,
+    detector: {
+      enabled: true,
+      rotation: true,
+      // Max accuracy: detect faces at angles for better embedding alignment
+      return: true,
+      minConfidence: 0.2,
+      maxFaces: 1,
+      modelPath: "blazeface.json"
+    },
+    mesh: {
+      enabled: true,
+      // Must be true for emotion/description models to work
+      return: false
+      // Keep false for performance (we don't need the 468 points back)
+    },
+    landmarks: {
+      enabled: true,
+      return: true
+    },
+    emotion: {
+      enabled: true,
+      return: true,
+      modelPath: "emotion.json",
+      minConfidence: 0.2
+    },
+    description: {
+      enabled: true,
+      return: true,
+      modelPath: "faceres.json"
+      // Use FaceRes (Deep) by replacing faceres.bin with human-models 13.9M variant for max embedding quality
+    },
+    iris: { enabled: false },
+    antispoof: { enabled: true },
+    // Max security: reject photos/screen replay
+    liveness: { enabled: false }
+    // Enable when liveness.json + liveness.bin are in public/models
+  },
+  // Disable unused features
+  filter: {
+    enabled: false
+    // Disable all filters for maximum performance
+  },
+  body: { enabled: false },
+  hand: { enabled: false },
+  object: { enabled: false },
+  gesture: {
+    enabled: false,
+    return: true,
+    minConfidence: 0.2
+  },
+  debug: false,
+  profile: false
+  // Disable profiling in production
+};
+var VERIFICATION_CONSTANTS = {
+  HAPPY_SUSTAIN_DURATION: 1500,
+  BLINK_REQUIRED_COUNT: 3,
+  BLINK_COOLDOWN: 300,
+  // Performance constants
+  PROCESS_INTERVAL: 200,
+  // Process every 200ms (5 frames per second is plenty for median averaging)
+  FPS_UPDATE_INTERVAL: 1e3,
+  DEBUG_LOG_INTERVAL: 60,
+  // Resolution: Lowering this provides massive speed boosts without losing embedding quality
+  PROCESS_WIDTH: 640,
+  PROCESS_HEIGHT: 480,
+  // Frame skipping
+  SKIP_FRAMES: 2
+  // Process every 3rd frame
+};
+var BACKEND_PRIORITY = ["webgpu", "webgl", "wasm"];
+
+// src/core/api/relayer.ts
+var VerifiedRelayerClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl;
+    this.network = config.network || "mainnet";
+    this.appId = config.appId;
+  }
+  /**
+   * Submits the face verification payload to the backend relayer.
+   * The backend handles gas abstraction and execution for both EVM and Solana users.
+   */
+  async submitVerification(payload) {
+    const { simhashFull, livenessCombined, chain, walletAddress } = payload;
+    const response = await fetch(`${this.baseUrl}/api/arcium/relayer-verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        simhashHex: simhashFull,
+        livenessCombined,
+        walletAddress,
+        chain,
+        appId: this.appId
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Verification API failed: ${errorText}`);
+    }
+    const data = await response.json();
+    return { success: true, txHash: data.txHash || data.data?.arciumResult?.tx3, data: data.data };
+  }
+};
+
+// src/react/hooks/useVisionModels.ts
+import { useState, useEffect } from "react";
+import { FaceLandmarker, FilesetResolver } from "@mediapipe/tasks-vision";
+import Human from "@vladmandic/human";
+var useVisionModels = () => {
+  const [faceLandmarker, setFaceLandmarker] = useState(null);
+  const [human, setHuman] = useState(null);
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    let isMounted = true;
+    const initializeModels = async () => {
+      try {
+        console.log("Initializing Vision Models (MediaPipe + ONNX)...");
+        const vision = await FilesetResolver.forVisionTasks(
+          "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.0/wasm"
+        );
+        const landmarker = await FaceLandmarker.createFromOptions(vision, {
+          baseOptions: {
+            modelAssetPath: "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task"
+          },
+          outputFaceBlendshapes: true,
+          outputFacialTransformationMatrixes: true,
+          runningMode: "VIDEO",
+          numFaces: 1
+        });
+        let h = null;
+        try {
+          const config = {
+            ...HUMAN_CONFIG,
+            backend: "wasm",
+            // Force WASM to avoid WebGL conflicts with MediaPipe
+            face: {
+              ...HUMAN_CONFIG.face,
+              description: { enabled: true, modelPath: "faceres.json" },
+              mesh: { enabled: false },
+              // MediaPipe handles mesh
+              emotion: { enabled: false },
+              antispoof: { enabled: false },
+              detector: { enabled: true, modelPath: "blazeface.json" }
+            }
+          };
+          h = new Human(config);
+          await h.load();
+          await h.warmup();
+        } catch (humanErr) {
+          console.warn("Human.js models failed to load.", humanErr);
+        }
+        if (isMounted) {
+          setFaceLandmarker(landmarker);
+          setHuman(h);
+          setIsInitialized(true);
+        }
+      } catch (err) {
+        console.error("Failed to initialize vision models", err);
+        if (isMounted) {
+          setError(err.message || "Failed to load face detection models");
+        }
+      }
+    };
+    initializeModels();
+    return () => {
+      isMounted = false;
+    };
+  }, []);
+  return { faceLandmarker, human, isInitialized, error };
+};
+
+// src/react/hooks/useCameraStream.ts
+import { useState as useState2, useCallback, useEffect as useEffect2 } from "react";
+function useCameraStream(isReady) {
+  const [stream, setStream] = useState2(null);
+  const [error, setError] = useState2(null);
+  const startCamera = useCallback(async () => {
+    try {
+      setError(null);
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      const videoDevices = devices.filter((d) => d.kind === "videoinput");
+      const frontCamera = videoDevices.find(
+        (d) => d.label.toLowerCase().includes("front") || d.label.toLowerCase().includes("user") || d.label.toLowerCase().includes("facetime")
+      );
+      const isMobile = /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);
+      const mediaStream = await navigator.mediaDevices.getUserMedia({
+        video: {
+          width: isMobile ? { ideal: 640, min: 320 } : { ideal: 1920, min: 1280 },
+          height: isMobile ? { ideal: 480, min: 240 } : { ideal: 1080, min: 720 },
+          facingMode: "user",
+          frameRate: isMobile ? { ideal: 30, min: 15 } : { ideal: 60, min: 30 },
+          aspectRatio: isMobile ? { ideal: 4 / 3 } : { ideal: 16 / 9 },
+          deviceId: frontCamera?.deviceId ? { exact: frontCamera.deviceId } : void 0
+        }
+      });
+      setStream(mediaStream);
+      console.log("Camera started successfully");
+    } catch (err) {
+      console.error("Camera error:", err);
+      setError("Failed to access camera. Please check permissions.");
+    }
+  }, []);
+  useEffect2(() => {
+    if (isReady && !stream) {
+      startCamera();
+    }
+  }, [isReady, stream, startCamera]);
+  useEffect2(() => {
+    return () => {
+      if (stream) {
+        stream.getTracks().forEach((track) => track.stop());
+      }
+    };
+  }, [stream]);
+  return { stream, error, startCamera };
+}
+
+// src/react/components/FaceZK.tsx
+import { useRef, useEffect as useEffect3, useState as useState3, useCallback as useCallback2 } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var FaceZKInner = ({
+  onBiometricData,
+  onVerificationComplete
+}) => {
+  const videoRef = useRef(null);
+  const canvasRef = useRef(null);
+  const flashOverlayRef = useRef(null);
+  const animationIdRef = useRef();
+  const { faceLandmarker, human, isInitialized, error: initError } = useVisionModels();
+  const { stream, error: cameraError } = useCameraStream(true);
+  const [livenessEngine] = useState3(() => new LivenessEngine());
+  const [currentStep, setCurrentStep] = useState3("pose-align");
+  const [liveFeedback, setLiveFeedback] = useState3(null);
+  const [isProcessing, setIsProcessing] = useState3(false);
+  const [faceDetected, setFaceDetected] = useState3(false);
+  const [error, setError] = useState3(null);
+  const [poseCheckPassed, setPoseCheckPassed] = useState3(false);
+  const [livenessPassed, setLivenessPassed] = useState3(false);
+  useEffect3(() => {
+    setError(initError || cameraError);
+  }, [initError, cameraError]);
+  useEffect3(() => {
+    if (!stream || !videoRef.current) return;
+    videoRef.current.srcObject = stream;
+    const initEngine = () => {
+      videoRef.current?.play().catch((e) => console.warn("Auto-play prevented", e));
+      if (videoRef.current && flashOverlayRef.current) {
+        console.log("Initializing Liveness Engine with video elements");
+        livenessEngine.setVideoElement(videoRef.current);
+        livenessEngine.setFlashOverlay(flashOverlayRef.current);
+      }
+    };
+    if (videoRef.current.readyState >= 1) {
+      initEngine();
+    } else {
+      videoRef.current.onloadedmetadata = initEngine;
+    }
+  }, [stream, livenessEngine]);
+  const extractFaceEmbedding = async (video) => {
+    if (!human) {
+      throw new Error("Face recognition model not loaded. Please wait and retry.");
+    }
+    try {
+      const result = await human.detect(video);
+      if (result && result.face && result.face.length > 0 && result.face[0].embedding) {
+        return Array.from(result.face[0].embedding);
+      }
+      throw new Error("No face embedding extracted from frame");
+    } catch (e) {
+      console.error("Human.js Inference failed", e);
+      throw e;
+    }
+  };
+  const cosineSimilarity = (a, b) => {
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dot += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+  };
+  const captureMultipleEmbeddings = async (video, sampleCount = 10, intervalMs = 200) => {
+    const embeddings = [];
+    console.log(`\u{1F4F8} Starting multi-frame capture: ${sampleCount} samples, ${intervalMs}ms apart`);
+    for (let i = 0; i < sampleCount; i++) {
+      try {
+        const emb = await extractFaceEmbedding(video);
+        embeddings.push(emb);
+        const norm = Math.sqrt(emb.reduce((s, v) => s + v * v, 0));
+        console.log(`  Frame ${i + 1}/${sampleCount}: L2 norm = ${norm.toFixed(4)}`);
+        if (embeddings.length > 1) {
+          const prev = embeddings[embeddings.length - 2];
+          const sim = cosineSimilarity(prev, emb);
+          console.log(`  Cosine similarity (frame ${i} vs ${i + 1}): ${sim.toFixed(6)}`);
+        }
+        setLiveFeedback({ message: `Capturing biometric data... (${i + 1}/${sampleCount})`, isGood: true });
+      } catch (e) {
+        console.warn(`  Frame ${i + 1} capture failed, skipping:`, e);
+      }
+      if (i < sampleCount - 1) {
+        await new Promise((r) => setTimeout(r, intervalMs));
+      }
+    }
+    if (embeddings.length < 3) {
+      throw new Error(`Only captured ${embeddings.length} valid frames. Need at least 3.`);
+    }
+    const averaged = averageEmbeddings(embeddings);
+    const avgNorm = Math.sqrt(averaged.reduce((s, v) => s + v * v, 0));
+    console.log(`\u2705 Robust average complete. L2 norm = ${avgNorm.toFixed(4)}`);
+    return averaged;
+  };
+  const latestLandmarks = useRef(null);
+  const latestMatrix = useRef(null);
+  const renderLoop = useCallback2(() => {
+    if (!videoRef.current || !faceLandmarker || !isInitialized) return;
+    if (videoRef.current.videoWidth === 0 || videoRef.current.videoHeight === 0) {
+      if (currentStep !== "completed") {
+        animationIdRef.current = requestAnimationFrame(renderLoop);
+      }
+      return;
+    }
+    try {
+      const startTimeMs = performance.now();
+      if (startTimeMs > renderLoop.lastTime) {
+        const results = faceLandmarker.detectForVideo(videoRef.current, startTimeMs);
+        renderLoop.lastTime = startTimeMs;
+        const facePresent = results.faceLandmarks && results.faceLandmarks.length > 0;
+        setFaceDetected((prev) => prev !== facePresent ? facePresent : prev);
+        if (facePresent) {
+          latestLandmarks.current = results.faceLandmarks[0];
+          if (results.facialTransformationMatrixes && results.facialTransformationMatrixes.length > 0) {
+            latestMatrix.current = results.facialTransformationMatrixes[0].data;
+          }
+          if (canvasRef.current) {
+            const canvas = canvasRef.current;
+            const ctx = canvas.getContext("2d");
+            if (ctx) {
+              canvas.width = videoRef.current.videoWidth;
+              canvas.height = videoRef.current.videoHeight;
+              ctx.clearRect(0, 0, canvas.width, canvas.height);
+              ctx.fillStyle = "#00FF88";
+              for (const point of latestLandmarks.current) {
+                ctx.fillRect(point.x * canvas.width, point.y * canvas.height, 2, 2);
+              }
+            }
+          }
+        } else {
+          latestLandmarks.current = null;
+          latestMatrix.current = null;
+        }
+      }
+    } catch (e) {
+      console.error("Detection error:", e);
+    }
+    if (currentStep !== "completed") {
+      animationIdRef.current = requestAnimationFrame(renderLoop);
+    }
+  }, [faceLandmarker, isInitialized, currentStep]);
+  renderLoop.lastTime = 0;
+  useEffect3(() => {
+    if (isInitialized && stream) {
+      renderLoop();
+    }
+    return () => {
+      if (animationIdRef.current) cancelAnimationFrame(animationIdRef.current);
+    };
+  }, [isInitialized, stream, renderLoop]);
+  useEffect3(() => {
+    const runVerification = async () => {
+      if (!faceDetected || isProcessing || !latestLandmarks.current) return;
+      setIsProcessing(true);
+      setError(null);
+      const getFaceBoundingBox = () => {
+        if (!latestLandmarks.current || !videoRef.current) return null;
+        const video = videoRef.current;
+        const xs = latestLandmarks.current.map((l) => l.x * video.videoWidth);
+        const ys = latestLandmarks.current.map((l) => l.y * video.videoHeight);
+        return {
+          x: Math.min(...xs),
+          y: Math.min(...ys),
+          width: Math.max(...xs) - Math.min(...xs),
+          height: Math.max(...ys) - Math.min(...ys)
+        };
+      };
+      const checkFaceAlignment = () => {
+        const bbox = getFaceBoundingBox();
+        const video = videoRef.current;
+        if (!bbox || !video || !latestLandmarks.current) return { aligned: false, message: "Face not detected." };
+        const faceHeightRatio = bbox.height / video.videoHeight;
+        if (faceHeightRatio < 0.3) return { aligned: false, message: "Face is too far away. Move closer." };
+        if (faceHeightRatio > 0.9) return { aligned: false, message: "Face is too close. Move back." };
+        const faceWidthRatio = bbox.width / video.videoWidth;
+        if (faceWidthRatio < 0.2) return { aligned: false, message: "Face is too far away. Move closer." };
+        const centerX = bbox.x + bbox.width / 2;
+        const centerY = bbox.y + bbox.height / 2;
+        const xOffset = Math.abs(centerX - video.videoWidth / 2) / video.videoWidth;
+        const yOffset = Math.abs(centerY - video.videoHeight / 2) / video.videoHeight;
+        if (xOffset > 0.25 || yOffset > 0.25) return { aligned: false, message: "Align your face in the center of the frame." };
+        try {
+          const offscreenCanvas = document.createElement("canvas");
+          offscreenCanvas.width = video.videoWidth;
+          offscreenCanvas.height = video.videoHeight;
+          const ctx = offscreenCanvas.getContext("2d", { willReadFrequently: true });
+          if (ctx) {
+            ctx.drawImage(video, 0, 0, offscreenCanvas.width, offscreenCanvas.height);
+            const getRGB = (index) => {
+              const pt = latestLandmarks.current[index];
+              if (!pt) return { r: 0, g: 0, b: 0, luma: 0 };
+              const x = Math.max(0, Math.min(offscreenCanvas.width - 1, Math.floor(pt.x * offscreenCanvas.width)));
+              const y = Math.max(0, Math.min(offscreenCanvas.height - 1, Math.floor(pt.y * offscreenCanvas.height)));
+              const startX = Math.max(0, x - 2);
+              const startY = Math.max(0, y - 2);
+              const imgData = ctx.getImageData(startX, startY, 5, 5).data;
+              let r = 0, g = 0, b = 0;
+              for (let i = 0; i < imgData.length; i += 4) {
+                r += imgData[i];
+                g += imgData[i + 1];
+                b += imgData[i + 2];
+              }
+              const count = imgData.length / 4;
+              return {
+                r: r / count,
+                g: g / count,
+                b: b / count,
+                luma: 0.299 * (r / count) + 0.587 * (g / count) + 0.114 * (b / count)
+              };
+            };
+            const leftCheek = getRGB(50);
+            const rightCheek = getRGB(280);
+            const forehead = getRGB(151);
+            const leftEye = getRGB(145);
+            const rightEye = getRGB(374);
+            const noseTip = getRGB(1);
+            const chin = getRGB(152);
+            const avgSkinLuma = (leftCheek.luma + rightCheek.luma + forehead.luma) / 3;
+            if (leftEye.luma < 25 && rightEye.luma < 25 && avgSkinLuma > 50) {
+              if (leftEye.luma < avgSkinLuma * 0.3 && rightEye.luma < avgSkinLuma * 0.3) {
+                return { aligned: false, message: "Please remove your dark shades." };
+              }
+            }
+            const colorDist = (c1, c2) => Math.sqrt(Math.pow(c1.r - c2.r, 2) + Math.pow(c1.g - c2.g, 2) + Math.pow(c1.b - c2.b, 2));
+            const avgCheek = { r: (leftCheek.r + rightCheek.r) / 2, g: (leftCheek.g + rightCheek.g) / 2, b: (leftCheek.b + rightCheek.b) / 2 };
+            if (colorDist(avgCheek, noseTip) > 130 && colorDist(avgCheek, chin) > 130) {
+              return { aligned: false, message: "Please remove your face mask." };
+            }
+          }
+        } catch (e) {
+          console.warn("Occlusion detection skipped due to canvas error", e);
+        }
+        return { aligned: true, message: "Perfect! Hold still." };
+      };
+      const waitForAlignment = async () => {
+        let consecutiveGood = 0;
+        while (true) {
+          const status = checkFaceAlignment();
+          if (status.aligned) {
+            setLiveFeedback((prev) => prev?.message === status.message && prev?.isGood === true ? prev : { message: status.message, isGood: true });
+            consecutiveGood++;
+            if (consecutiveGood > 10) {
+              setLiveFeedback(null);
+              return true;
+            }
+          } else {
+            setLiveFeedback((prev) => prev?.message === status.message && prev?.isGood === false ? prev : { message: status.message, isGood: false });
+            consecutiveGood = 0;
+          }
+          await new Promise((r) => setTimeout(r, 50));
+        }
+      };
+      const waitForQuality = async () => {
+        const oc = document.createElement("canvas");
+        let ctx = null;
+        while (true) {
+          if (!videoRef.current || !latestLandmarks.current) {
+            await new Promise((r) => setTimeout(r, 100));
+            continue;
+          }
+          const video = videoRef.current;
+          const bbox = getFaceBoundingBox();
+          if (oc.width !== video.videoWidth) {
+            oc.width = video.videoWidth;
+            oc.height = video.videoHeight;
+            ctx = oc.getContext("2d", { willReadFrequently: true });
+          }
+          let luminance = 128;
+          if (ctx) {
+            try {
+              ctx.drawImage(video, 0, 0);
+              if (bbox) {
+                luminance = getRegionLuminance(ctx, bbox.x, bbox.y, bbox.width, bbox.height);
+              } else {
+                luminance = getRegionLuminance(ctx, 0, 0, oc.width, oc.height);
+              }
+            } catch {
+            }
+          }
+          const faceW = bbox?.width ?? 0;
+          const faceH = bbox?.height ?? 0;
+          const quality = evaluateCaptureQuality(luminance, faceW, faceH);
+          if (quality.ready) {
+            setLiveFeedback(null);
+            return true;
+          }
+          setLiveFeedback({ message: quality.message, isGood: false });
+          await new Promise((r) => setTimeout(r, 200));
+        }
+      };
+      const getYawDegrees = (matrix) => {
+        return -Math.atan2(matrix[8], matrix[10]) * (180 / Math.PI);
+      };
+      const waitForPose = async (condition) => {
+        while (true) {
+          if (!latestMatrix.current) {
+            setLiveFeedback((prev) => prev?.message === "Face not detected. Keep your face in frame." && prev?.isGood === false ? prev : { message: "Face not detected. Keep your face in frame.", isGood: false });
+            await new Promise((r) => setTimeout(r, 100));
+            continue;
+          }
+          const status = checkFaceAlignment();
+          if (!status.aligned) {
+            setLiveFeedback((prev) => prev?.message === status.message && prev?.isGood === false ? prev : { message: status.message, isGood: false });
+            await new Promise((r) => setTimeout(r, 100));
+            continue;
+          }
+          setLiveFeedback(null);
+          const yaw = getYawDegrees(latestMatrix.current);
+          if (condition(yaw)) {
+            await new Promise((r) => setTimeout(r, 300));
+            if (latestMatrix.current && condition(getYawDegrees(latestMatrix.current))) {
+              return true;
+            }
+          }
+          await new Promise((r) => setTimeout(r, 50));
+        }
+      };
+      const handleFailure = (msg) => {
+        console.warn("Verification sequence reset:", msg);
+        setLiveFeedback((prev) => prev?.message === msg && prev?.isGood === false ? prev : { message: msg, isGood: false });
+        setCurrentStep("pose-align");
+        setError(null);
+        setTimeout(() => {
+          setIsProcessing(false);
+          setLiveFeedback(null);
+        }, 4e3);
+      };
+      try {
+        setCurrentStep("pose-align");
+        await waitForAlignment();
+        await waitForQuality();
+        setCurrentStep("pose-left");
+        await waitForPose((yaw) => yaw > 15);
+        setCurrentStep("pose-right");
+        await waitForPose((yaw) => Math.abs(yaw) < -15 || yaw < -15);
+        setCurrentStep("pose-center");
+        await waitForPose((yaw) => Math.abs(yaw) < 8);
+        setCurrentStep("capturing");
+        const video = videoRef.current;
+        let embedding;
+        try {
+          embedding = await captureMultipleEmbeddings(video, 10, 200);
+        } catch (e) {
+          handleFailure(e.message || "Failed to capture face data");
+          return;
+        }
+        const bbox = getFaceBoundingBox();
+        if (!bbox) {
+          handleFailure("Face lost during final check");
+          return;
+        }
+        const alignment = checkFaceAlignment();
+        if (!alignment.aligned) {
+          handleFailure(`Alignment lost: ${alignment.message}`);
+          return;
+        }
+        setCurrentStep("light-flash");
+        const livenessResult = await livenessEngine.runLivenessSequence(bbox);
+        if (!livenessResult.passed) {
+          handleFailure(livenessResult.message || "Liveness check failed");
+          return;
+        }
+        setCurrentStep("processing");
+        const mockFaceData = {
+          embedding,
+          box: [bbox.x, bbox.y, bbox.width, bbox.height],
+          rotation: { angle: { yaw: 0, pitch: 0, roll: 0 } },
+          mesh: latestLandmarks.current.map((l) => [l.x, l.y, l.z])
+        };
+        const mockLivenessData = {
+          blinkCount: 1,
+          blinkTimestamps: [Date.now()],
+          emotionTransitions: [{ from: "neutral", to: "happy", timestamp: Date.now(), duration: 500 }],
+          headMovement: { yawRange: [0, 0], pitchRange: [0, 0], rollRange: [0, 0] },
+          verificationDuration: 3e3,
+          stepCompletionTimes: { happy: 1e3, eyeBlink: 2e3 }
+        };
+        const extractedRawData = {
+          faceEmbedding: embedding,
+          faceMesh: latestLandmarks.current.map((l) => [l.x, l.y, l.z]),
+          faceLandmarks: latestLandmarks.current.map((l) => [l.x, l.y]),
+          faceRotation: { angle: { yaw: 0, pitch: 0, roll: 0 }, matrix: [] },
+          faceBox: bbox,
+          timestamp: Date.now()
+        };
+        const payload = generateBiometricSimHash(mockFaceData, mockLivenessData, embedding);
+        if (onBiometricData) onBiometricData(payload);
+        if (onVerificationComplete) onVerificationComplete({
+          rawFacialData: extractedRawData,
+          livenessData: mockLivenessData,
+          isComplete: true,
+          message: "Verification completed successfully"
+        });
+        setCurrentStep("completed");
+      } catch (err) {
+        console.error("Unexpected verification error:", err);
+        handleFailure(err.message || "An unexpected error occurred");
+      }
+    };
+    runVerification();
+  }, [faceDetected, isProcessing]);
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsxs("div", { className: "relative overflow-hidden rounded-xl", style: { maxHeight: "600px" }, children: [
+      /* @__PURE__ */ jsx(
+        "video",
+        {
+          ref: videoRef,
+          className: "w-full h-full object-contain sm:object-cover",
+          autoPlay: true,
+          playsInline: true,
+          muted: true,
+          style: { transform: "scaleX(-1)" }
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "canvas",
+        {
+          ref: canvasRef,
+          className: "absolute inset-0 w-full h-full pointer-events-none",
+          style: { zIndex: 10, transform: "scaleX(-1)" }
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          ref: flashOverlayRef,
+          className: "absolute inset-0 w-full h-full pointer-events-none transition-colors duration-75",
+          style: { zIndex: 20 }
+        }
+      ),
+      /* @__PURE__ */ jsx("div", { className: "absolute top-4 left-4 z-30", children: faceDetected ? /* @__PURE__ */ jsxs("div", { className: "bg-green-500/90 backdrop-blur-sm text-white px-3 py-1 rounded-full text-sm font-bold shadow-[0_0_10px_rgba(34,197,94,0.5)] border border-green-400 flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx("div", { className: "w-2 h-2 bg-white rounded-full animate-pulse" }),
+        "Face Detected"
+      ] }) : /* @__PURE__ */ jsxs("div", { className: "bg-red-500/90 backdrop-blur-sm text-white px-3 py-1 rounded-full text-sm font-bold shadow-[0_0_10px_rgba(239,68,68,0.5)] border border-red-400 flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx("div", { className: "w-2 h-2 bg-white rounded-full" }),
+        "No Face Detected"
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "text-center mb-4 pt-4 px-4 h-[100px]", children: [
+      !stream && /* @__PURE__ */ jsx("div", { className: "text-gray-500", children: "Initializing camera..." }),
+      liveFeedback ? /* @__PURE__ */ jsx("div", { className: `text-lg font-bold animate-pulse ${liveFeedback.isGood ? "text-green-400" : "text-amber-400"}`, children: liveFeedback.message }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+        stream && currentStep === "pose-align" && /* @__PURE__ */ jsx("div", { className: "text-blue-400 text-lg font-bold animate-pulse", children: "Position face in center & ensure good distance" }),
+        stream && currentStep === "pose-left" && /* @__PURE__ */ jsx("div", { className: "text-white text-lg font-bold animate-pulse", children: "Turn your head slowly to the LEFT" }),
+        stream && currentStep === "pose-right" && /* @__PURE__ */ jsx("div", { className: "text-white text-lg font-bold animate-pulse", children: "Turn your head slowly to the RIGHT" }),
+        stream && currentStep === "pose-center" && /* @__PURE__ */ jsx("div", { className: "text-white text-lg font-bold", children: "Look straight at the camera" }),
+        stream && currentStep === "capturing" && /* @__PURE__ */ jsx("div", { className: "text-cyan-400 text-lg font-bold animate-pulse", children: "Capturing biometric data... Hold still" }),
+        stream && currentStep === "light-flash" && /* @__PURE__ */ jsx("div", { className: "text-blue-400 font-bold", children: "Verifying physical presence (Flashing colors...)" }),
+        stream && currentStep === "processing" && /* @__PURE__ */ jsx("div", { className: "text-white", children: "Generating Cryptographic Embedding..." }),
+        stream && currentStep === "completed" && /* @__PURE__ */ jsx("div", { className: "text-green-500 font-bold", children: "Verification Successful" })
+      ] })
+    ] })
+  ] });
+};
+var FaceZK_default = FaceZKInner;
+
+// src/react/components/ProofOfHumanity.tsx
+import { useState as useState4 } from "react";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var ProofOfHumanity = ({
+  onNextStep,
+  onBiometricData,
+  onVerificationComplete,
+  className = "",
+  containerClassName = "",
+  buttonClassName = ""
+}) => {
+  const [cameraActive, setCameraActive] = useState4(false);
+  const [verificationComplete, setVerificationComplete] = useState4(false);
+  const [showComparison, setShowComparison] = useState4(false);
+  const handleActivateCamera = () => {
+    setCameraActive(true);
+  };
+  const handleBiometricData = (data) => {
+    console.log("\u{1F3AF} Face verification SimHash received:", data);
+    if (onBiometricData) {
+      onBiometricData(data);
+    }
+  };
+  const handleVerificationComplete = (result) => {
+    console.log("Verification complete:", result);
+    setVerificationComplete(true);
+    if (onVerificationComplete) {
+      onVerificationComplete(result);
+    }
+  };
+  const handleContinue = () => {
+    console.log("Continuing to next step...");
+    onNextStep();
+  };
+  const toggleComparison = () => {
+    setShowComparison(!showComparison);
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: `mx-auto mt-5 w-full max-w-[700px] flex flex-col items-center px-4 ${className}`, children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex flex-col items-center mb-6 sm:mb-10", children: [
+      /* @__PURE__ */ jsx2("h2", { className: "text-white text-xl sm:text-2xl md:text-3xl font-bold mb-2 text-center", children: "Proof of Humanity" }),
+      /* @__PURE__ */ jsxs2("p", { className: "text-[#A0A3BD] text-center w-full max-w-[620px] text-sm sm:text-base px-2", children: [
+        "Powered by advanced face detection technology with sequential liveness detection. Your facial data is collected and processed securely. ",
+        /* @__PURE__ */ jsx2("span", { className: "text-white cursor-pointer", children: "Learn more." }),
+        /* @__PURE__ */ jsx2("span", { className: "text-amber-400 block mt-2 font-medium", children: "Please remove any glasses and face masks before verifying." })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx2("div", { className: `backdrop-container flex flex-col items-center justify-center bg-[#030B29] rounded-xl w-full max-w-[700px] h-[400px] sm:h-[450px] md:h-[477px] border border-gray-800 ${containerClassName}`, children: !cameraActive ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsx2(
+        "img",
+        {
+          src: "/camera.png",
+          alt: "Camera Icon",
+          width: 200,
+          height: 200,
+          className: "sm:w-[250px] sm:h-[250px] md:w-[280px] md:h-[280px]"
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          className: `bg-[#0D3DDE] hover:bg-[#1A2240] text-white font-semibold py-2 px-6 rounded-lg transition-colors duration-200 mt-4 sm:mt-8 cursor-pointer text-sm sm:text-base ${buttonClassName}`,
+          onClick: handleActivateCamera,
+          children: "Activate Camera"
+        }
+      )
+    ] }) : /* @__PURE__ */ jsx2("div", { className: "w-full h-full", children: /* @__PURE__ */ jsx2(
+      FaceZK_default,
+      {
+        onBiometricData: handleBiometricData,
+        onVerificationComplete: handleVerificationComplete,
+        onContinue: handleContinue
+      }
+    ) }) })
+  ] });
+};
+var ProofOfHumanity_default = ProofOfHumanity;
+
+// src/react/components/VerifiedOnchainFlow.tsx
+import { useState as useState7, useEffect as useEffect5 } from "react";
+import { useAccount } from "wagmi";
+import { useWallet as useSolanaWallet } from "@solana/wallet-adapter-react";
+
+// src/react/components/wallet/WalletSelection.tsx
+import { useState as useState5 } from "react";
+import { useConnect } from "wagmi";
+import { useWallet } from "@solana/wallet-adapter-react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var EVM_WALLET_ICONS = {
+  rainbow: "/rainbow.svg",
+  metamask: "/MetaMask.svg"
+};
+var WalletSelection = ({ onWalletConnect, className = "", requiredWallets }) => {
+  const { connectors, connect } = useConnect();
+  const { wallets, select, wallet, disconnect, connected, connect: connectSolana, connecting } = useWallet();
+  const [isBusy, setIsBusy] = useState5(false);
+  const allWallets = [
+    ...wallets.map((w) => {
+      let icon = w.adapter.icon;
+      let label = w.adapter.name;
+      let connectSlug = w.adapter.name.toLowerCase().replace(/\s+/g, "-");
+      if (label.toLowerCase().includes("phantom")) {
+        label = "Phantom ";
+        connectSlug = "solana-phantom";
+      } else if (label.toLowerCase().includes("backpack")) {
+        label = "Backpack ";
+        connectSlug = "solana-backpack";
+      }
+      return {
+        id: w.adapter.name,
+        adapterName: w.adapter.name,
+        name: label,
+        connectSlug,
+        icon,
+        type: "solana",
+        original: w
+      };
+    }),
+    ...connectors.map((c) => {
+      let icon = c.icon || "https://raw.githubusercontent.com/WalletConnect/walletconnect-assets/master/Logo/Blue%20(Default)/Logo.svg";
+      let name = c.name;
+      if (c.id === "metaMaskSDK" || c.id === "injected" || name.toLowerCase().includes("metamask")) {
+        name = "MetaMask";
+        icon = EVM_WALLET_ICONS.metamask;
+      }
+      if (c.id === "rainbow" || name.toLowerCase().includes("rainbow")) {
+        name = "Rainbow";
+        icon = EVM_WALLET_ICONS.rainbow;
+      }
+      return {
+        id: c.id,
+        name,
+        icon,
+        type: "evm",
+        original: c
+      };
+    })
+  ];
+  const filteredWallets = requiredWallets ? allWallets.filter((w) => {
+    const reqLower = requiredWallets.map((s) => s.toLowerCase());
+    return reqLower.includes(w.name.trim().toLowerCase()) || reqLower.includes(w.id.toLowerCase());
+  }) : allWallets;
+  const uniqueWallets = filteredWallets.filter((v, i, a) => a.findIndex((t) => t.name.trim() === v.name.trim()) === i);
+  return /* @__PURE__ */ jsxs3("div", { className: `w-full ${className}`, children: [
+    /* @__PURE__ */ jsxs3("div", { className: "mt-10 px-4 sm:px-6 lg:px-0 lg:pl-[80px]", children: [
+      /* @__PURE__ */ jsx3("h1", { className: "text-[26px] sm:text-[36px] text-white font-bold lg:w-[340px] pb-5", children: "Choose your preferred wallet" }),
+      /* @__PURE__ */ jsx3("p", { className: "text-[16px] text-[#A0A3BD] lg:w-[420px]", children: "VerfifiedOnchain works with any wallet or blockchain and these are the currently integrated wallets." })
+    ] }),
+    /* @__PURE__ */ jsxs3("div", { className: "flex flex-col md:flex-row items-center justify-between px-4 sm:px-6 lg:px-[80px]", children: [
+      /* @__PURE__ */ jsx3("div", { className: "w-full md:w-[389px] pt-5 flex flex-col space-y-0", children: uniqueWallets.map((w) => {
+        if (w.type === "solana") {
+          const isActive = connected && wallet?.adapter.name === w.adapterName;
+          const showSpinner = isBusy || connecting;
+          return /* @__PURE__ */ jsxs3(
+            "div",
+            {
+              onClick: async () => {
+                if (isBusy || connecting) return;
+                if (isActive) {
+                  try {
+                    await disconnect();
+                  } catch (error) {
+                    console.warn("Solana wallet disconnection error:", error);
+                  }
+                  return;
+                }
+                setIsBusy(true);
+                try {
+                  select(w.adapterName);
+                  await Promise.resolve();
+                  await connectSolana();
+                  onWalletConnect(w.connectSlug);
+                } catch (error) {
+                  console.warn("Solana wallet connection error:", error);
+                } finally {
+                  setIsBusy(false);
+                }
+              },
+              className: "flex items-center space-x-4 hover:bg-[#0D3DDE] transition-colors duration-200 rounded-lg p-3 cursor-pointer border border-gray-800 hover:border-[#0D3DDE] mb-4 w-full",
+              style: { opacity: showSpinner ? 0.7 : 1 },
+              children: [
+                /* @__PURE__ */ jsx3(
+                  "img",
+                  {
+                    src: w.icon,
+                    alt: w.name,
+                    width: 30,
+                    height: 30,
+                    className: "bg-white rounded-md p-1 shadow-md shadow-blue-500/20 hover:shadow-blue-500/50 transition-shadow duration-200"
+                  }
+                ),
+                /* @__PURE__ */ jsx3("span", { className: "text-white font-medium", children: showSpinner ? "Opening..." : isActive ? `Disconnect ${w.name}` : w.name }),
+                isActive && wallet?.adapter.publicKey && /* @__PURE__ */ jsxs3("span", { className: "text-[12px] text-[#A0A3BD]", children: [
+                  wallet.adapter.publicKey.toString().slice(0, 6),
+                  "...",
+                  wallet.adapter.publicKey.toString().slice(-4)
+                ] })
+              ]
+            },
+            w.id
+          );
+        } else {
+          return /* @__PURE__ */ jsxs3(
+            "div",
+            {
+              onClick: () => {
+                connect({ connector: w.original });
+                onWalletConnect(w.name);
+              },
+              className: "flex items-center space-x-4 hover:bg-[#0D3DDE] transition-colors duration-200 rounded-lg p-3 cursor-pointer border border-gray-800 hover:border-[#0D3DDE] mb-4 w-full",
+              children: [
+                /* @__PURE__ */ jsx3(
+                  "img",
+                  {
+                    src: w.icon,
+                    alt: w.name,
+                    width: 30,
+                    height: 30,
+                    className: "bg-white rounded-md p-1 shadow-md shadow-blue-500/20 hover:shadow-blue-500/50 transition-shadow duration-200"
+                  }
+                ),
+                /* @__PURE__ */ jsx3("span", { className: "text-white font-medium", children: w.name })
+              ]
+            },
+            w.id
+          );
+        }
+      }) }),
+      /* @__PURE__ */ jsx3("div", { className: "mt-10 md:mt-0 flex-shrink-0 flex justify-center md:justify-end", children: /* @__PURE__ */ jsx3(
+        "img",
+        {
+          src: "/cube.gif",
+          alt: "Auth Image",
+          className: "w-full max-w-[280px] sm:max-w-[300px] md:max-w-[400px] h-auto md:h-[400px] object-cover rounded-lg md:ml-10"
+        }
+      ) })
+    ] })
+  ] });
+};
+var WalletSelection_default = WalletSelection;
+
+// src/react/components/wallet/SocialConnection.tsx
+import { useState as useState6, useEffect as useEffect4 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var SOCIAL_CONNECTION_STORAGE_KEY = "verifiedonchain_social_connection";
+function persistSocialConnection(platform, profileData) {
+  try {
+    localStorage.setItem(
+      SOCIAL_CONNECTION_STORAGE_KEY,
+      JSON.stringify({
+        platform,
+        profileData,
+        connectedAt: Date.now()
+      })
+    );
+  } catch (err) {
+    console.warn("Failed to persist social connection:", err);
+  }
+}
+var SocialConnection = ({
+  onSocialConnect,
+  onNextStep,
+  userAddress,
+  availableSocials,
+  className = "",
+  backendUrl = "https://api.verifiedonchain.com/v1",
+  environment = "mainnet"
+}) => {
+  const [isConnecting, setIsConnecting] = useState6(null);
+  const [showFarcasterModal, setShowFarcasterModal] = useState6(false);
+  const [showLensModal, setShowLensModal] = useState6(false);
+  const [showLensUsernameModal, setShowLensUsernameModal] = useState6(false);
+  const [showXModal, setShowXModal] = useState6(false);
+  const [farcasterData, setFarcasterData] = useState6(null);
+  const [lensProfile, setLensProfile] = useState6(null);
+  const [xProfile, setXProfile] = useState6(null);
+  const [error, setError] = useState6(null);
+  const [channelToken, setChannelToken] = useState6("");
+  const [qrCodeUrl, setQrCodeUrl] = useState6("");
+  const [pollInterval, setPollInterval] = useState6(null);
+  const [usernameInput, setUsernameInput] = useState6("");
+  const [deepLinkUrl, setDeepLinkUrl] = useState6("");
+  const [isProcessingSuccess, setIsProcessingSuccess] = useState6(false);
+  const [currentNonce, setCurrentNonce] = useState6("");
+  useEffect4(() => {
+    const handleMessage = (event) => {
+      if (event.data?.type === "vo:oauth-success") {
+        const { platform, profile, error: authError } = event.data;
+        if (authError) {
+          setError(authError);
+          setIsConnecting(null);
+          return;
+        }
+        if (profile && platform) {
+          console.log(`\u{1F389} ${platform} Auth completed successfully with profile:`, profile);
+          persistSocialConnection(platform, profile);
+          setIsConnecting(null);
+          onSocialConnect(platform, profile);
+          setTimeout(() => {
+            onNextStep();
+          }, 300);
+        }
+      } else if (event.data?.type === "X_AUTH_RESPONSE") {
+        const { payload, error: authError } = event.data;
+        if (authError) {
+          setError(authError);
+          setIsConnecting(null);
+          return;
+        }
+        if (payload) {
+          console.log("\u{1F389} X Auth completed successfully with profile:", payload);
+          setXProfile(payload);
+          setShowXModal(true);
+          handleXSuccess(payload);
+        }
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    return () => window.removeEventListener("message", handleMessage);
+  }, [isProcessingSuccess, onSocialConnect, onNextStep]);
+  useEffect4(() => {
+    return () => {
+      if (pollInterval) {
+        clearInterval(pollInterval);
+      }
+    };
+  }, [pollInterval]);
+  const startOAuth = (platform) => {
+    setIsConnecting(platform);
+    setError(null);
+    const origin = typeof window !== "undefined" ? window.location.origin : "";
+    const params = new URLSearchParams({ origin, network: environment });
+    if (userAddress) params.append("wallet", userAddress);
+    const oauthUrl = `${backendUrl}/oauth/${platform}/start?${params.toString()}`;
+    const width = 600;
+    const height = 800;
+    const left = window.innerWidth / 2 - width / 2 + window.screenX;
+    const top = window.innerHeight / 2 - height / 2 + window.screenY;
+    const popup = window.open(
+      oauthUrl,
+      `${platform}_oauth_popup`,
+      `width=${width},height=${height},top=${top},left=${left},scrollbars=yes,status=no,resizable=no,menubar=no,toolbar=no,location=no`
+    );
+    if (!popup) {
+      setError("Popup was blocked. Please allow popups for this site and try again.");
+      setIsConnecting(null);
+      return;
+    }
+    const checkClosed = setInterval(() => {
+      if (popup.closed) {
+        clearInterval(checkClosed);
+        setIsConnecting((prev) => {
+          if (prev === platform) {
+            setError("Authentication window was closed.");
+            return null;
+          }
+          return prev;
+        });
+      }
+    }, 1e3);
+  };
+  const handleFarcasterClick = async () => {
+    setIsConnecting("farcaster");
+    setError(null);
+    setIsProcessingSuccess(false);
+    try {
+      const nonce = Array.from(crypto.getRandomValues(new Uint8Array(16))).map((b) => b.toString(16).padStart(2, "0")).join("");
+      setCurrentNonce(nonce);
+      const channelResponse = await fetch("https://relay.farcaster.xyz/v1/channel", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          siweUri: window.location.origin,
+          domain: window.location.hostname,
+          nonce
+        })
+      });
+      if (!channelResponse.ok) {
+        const errorText = await channelResponse.text();
+        throw new Error(`Failed to create Farcaster auth channel: ${channelResponse.status}`);
+      }
+      const channelData = await channelResponse.json();
+      if (!channelData.channelToken || !channelData.url) {
+        throw new Error("Invalid response from Farcaster relay - missing token or URL");
+      }
+      setChannelToken(channelData.channelToken);
+      const authUrl = channelData.url;
+      setDeepLinkUrl(authUrl);
+      setQrCodeUrl(`https://api.qrserver.com/v1/create-qr-code/?size=300x300&data=${encodeURIComponent(authUrl)}`);
+      setShowFarcasterModal(true);
+      startPolling(channelData.channelToken, nonce);
+    } catch (err) {
+      setError(err.message || "Failed to initialize Farcaster authentication");
+      setIsConnecting(null);
+    }
+  };
+  const startPolling = (token, nonce) => {
+    let pollCount = 0;
+    const maxPolls = 150;
+    const interval = setInterval(async () => {
+      pollCount++;
+      if (pollCount > maxPolls) {
+        clearInterval(interval);
+        setPollInterval(null);
+        setError("Authentication timeout. Please try again.");
+        setIsConnecting(null);
+        return;
+      }
+      try {
+        const statusResponse = await fetch(`https://relay.farcaster.xyz/v1/channel/status?channelToken=${token}`, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${token}`
+          }
+        });
+        if (!statusResponse.ok) {
+          return;
+        }
+        const statusData = await statusResponse.json();
+        if (statusData.state === "completed") {
+          clearInterval(interval);
+          setPollInterval(null);
+          const response = statusData.response || statusData;
+          const profileData = {
+            state: statusData.state,
+            nonce: response.nonce || nonce,
+            message: response.message || "",
+            signature: response.signature || "",
+            fid: response.fid || 0,
+            username: response.username || "",
+            bio: response.bio || "",
+            displayName: response.displayName || response.username || "",
+            pfpUrl: response.pfpUrl || ""
+          };
+          setFarcasterData(profileData);
+          handleFarcasterSuccess(profileData);
+        }
+      } catch (err) {
+      }
+    }, 2e3);
+    setPollInterval(interval);
+  };
+  const handleFarcasterSuccess = (profileData) => {
+    if (isProcessingSuccess) {
+      return;
+    }
+    setIsProcessingSuccess(true);
+    if (pollInterval) {
+      clearInterval(pollInterval);
+      setPollInterval(null);
+    }
+    setShowFarcasterModal(false);
+    setIsConnecting(null);
+    const farcasterProfile = {
+      displayName: profileData.displayName,
+      username: profileData.username,
+      pfpUrl: profileData.pfpUrl,
+      bio: profileData.bio,
+      fid: profileData.fid
+    };
+    persistSocialConnection("farcaster", farcasterProfile);
+    onSocialConnect("farcaster", farcasterProfile);
+    setQrCodeUrl("");
+    setChannelToken("");
+    setDeepLinkUrl("");
+    setCurrentNonce("");
+    setTimeout(() => {
+      onNextStep();
+    }, 300);
+  };
+  const closeFarcasterModal = () => {
+    if (pollInterval) {
+      clearInterval(pollInterval);
+      setPollInterval(null);
+    }
+    setShowFarcasterModal(false);
+    setIsConnecting(null);
+    setQrCodeUrl("");
+    setChannelToken("");
+    setDeepLinkUrl("");
+    setCurrentNonce("");
+    setIsProcessingSuccess(false);
+  };
+  const openWarpcast = () => {
+    if (deepLinkUrl) {
+      window.open(deepLinkUrl, "_blank");
+    }
+  };
+  const handleLensClick = async () => {
+    setError(null);
+    setShowLensUsernameModal(true);
+  };
+  const handleLensUsernameSubmit = async () => {
+    if (!usernameInput.trim()) {
+      setError("Please enter a Lens username");
+      return;
+    }
+    setIsConnecting("lens");
+    setError(null);
+    try {
+      const lensProfileData = await fetchLensProfileByUsername(usernameInput.trim());
+      if (lensProfileData) {
+        if (userAddress) {
+          const accountOwner = lensProfileData.owner?.toLowerCase();
+          const connectedAddress = userAddress.toLowerCase();
+          if (accountOwner !== connectedAddress) {
+            setError("The Lens account owner does not match your connected wallet address.");
+            setIsConnecting(null);
+            return;
+          }
+        }
+        setLensProfile(lensProfileData);
+        setShowLensUsernameModal(false);
+        setShowLensModal(true);
+        setUsernameInput("");
+        handleLensSuccess(lensProfileData);
+      } else {
+        setError("No Lens profile found for this username");
+        setIsConnecting(null);
+      }
+    } catch (err) {
+      setError(err.message || "Failed to connect to Lens");
+      setIsConnecting(null);
+    }
+  };
+  const closeLensUsernameModal = () => {
+    setShowLensUsernameModal(false);
+    setUsernameInput("");
+    setIsConnecting(null);
+    setError(null);
+  };
+  const fetchLensProfileByUsername = async (username) => {
+    try {
+      const query = `
+        query Account($request: AccountRequest!) {
+          account(request: $request) {
+            owner
+            address
+            metadata {
+              name
+              bio
+              picture
+              coverPicture
+            }
+            username(request: {autoResolve: true}) {
+              namespace
+              localName
+              linkedTo
+              value
+              ownedBy
+            }
+          }
+        }
+      `;
+      const response = await fetch("https://api.lens.xyz/graphql", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          query,
+          variables: {
+            request: {
+              username: {
+                localName: username
+              }
+            }
+          }
+        })
+      });
+      const data = await response.json();
+      if (data.errors && data.errors.length > 0) {
+        throw new Error(data.errors[0].message);
+      }
+      if (data.data?.account) {
+        return data.data.account;
+      }
+      return null;
+    } catch (err) {
+      return null;
+    }
+  };
+  const handleLensSuccess = (profileData) => {
+    const pictureUri = profileData.metadata?.picture || "/lens-white.svg";
+    const lensData = {
+      displayName: profileData.metadata?.name || profileData.username?.value || profileData.username?.localName,
+      username: profileData.username?.value || profileData.username?.localName,
+      pfpUrl: pictureUri,
+      bio: profileData.metadata?.bio,
+      address: profileData.address
+    };
+    persistSocialConnection("lens", lensData);
+    onSocialConnect("lens", lensData);
+    setIsConnecting(null);
+    setTimeout(() => {
+      setShowLensModal(false);
+      onNextStep();
+    }, 500);
+  };
+  const closeLensModal = () => {
+    setShowLensModal(false);
+    setIsConnecting(null);
+  };
+  const handleXClick = () => {
+    setIsConnecting("x");
+    setError(null);
+    const width = 600;
+    const height = 800;
+    const left = window.innerWidth / 2 - width / 2 + window.screenX;
+    const top = window.innerHeight / 2 - height / 2 + window.screenY;
+    const popup = window.open(
+      "",
+      "x_login_popup",
+      `width=${width},height=${height},top=${top},left=${left},scrollbars=yes,status=no,resizable=no,menubar=no,toolbar=no,location=no`
+    );
+    if (popup) {
+      popup.location.href = "/api/auth/x/login";
+    } else {
+      setError("Popup was blocked. Please allow popups for this site and try again.");
+      setIsConnecting(null);
+    }
+  };
+  const handleXSuccess = (profileData) => {
+    const xData = {
+      displayName: profileData.displayName,
+      username: profileData.username,
+      pfpUrl: profileData.pfpUrl,
+      bio: profileData.bio || "",
+      address: "",
+      platform: "x"
+    };
+    persistSocialConnection("x", xData);
+    onSocialConnect("x", xData);
+    setIsConnecting(null);
+    setTimeout(() => {
+      setShowXModal(false);
+      onNextStep();
+    }, 500);
+  };
+  const closeXModal = () => {
+    setShowXModal(false);
+    setIsConnecting(null);
+  };
+  const handleClick = (social) => {
+    const s = social.toLowerCase();
+    if (s === "farcaster") {
+      handleFarcasterClick();
+    } else if (s === "lens") {
+      handleLensClick();
+    } else if (s === "x") {
+      handleXClick();
+    } else {
+      startOAuth(s);
+    }
+  };
+  const getPlatformLabel = (social) => {
+    switch (social.toLowerCase()) {
+      case "x":
+        return "(formerly Twitter)";
+      case "farcaster":
+        return "Farcaster";
+      case "lens":
+        return "Lens Protocol";
+      case "youtube":
+        return "YouTube";
+      case "instagram":
+        return "Instagram";
+      case "tiktok":
+        return "TikTok";
+      default:
+        return social.charAt(0).toUpperCase() + social.slice(1);
+    }
+  };
+  const getPlatformIcon = (social) => {
+    switch (social.toLowerCase()) {
+      case "x":
+        return "/x-white.svg";
+      case "farcaster":
+        return "/Farcaster.svg";
+      case "lens":
+        return "/lens-white.svg";
+      case "youtube":
+        return "https://upload.wikimedia.org/wikipedia/commons/0/09/YouTube_full-color_icon_%282017%29.svg";
+      case "instagram":
+        return "https://upload.wikimedia.org/wikipedia/commons/e/e7/Instagram_logo_2016.svg";
+      case "tiktok":
+        return "https://cdn4.iconfinder.com/data/icons/social-media-flat-7/64/Social-media_Tiktok-512.png";
+      default:
+        return "";
+    }
+  };
+  return /* @__PURE__ */ jsxs4("div", { className: `text-center px-4 sm:px-6 lg:px-8 mt-10 ${className}`, children: [
+    /* @__PURE__ */ jsx4("h1", { className: "text-2xl sm:text-3xl lg:text-[36px] font-bold text-white mb-6 sm:mb-8 lg:mb-10", children: "Connect one social identity" }),
+    /* @__PURE__ */ jsx4("p", { className: "text-[#A0A3BD] text-sm sm:text-base max-w-[640px] mx-auto -mt-4 mb-6 sm:mb-8", children: "Link your Lens, Farcaster, or X to anchor your social identity. We only read public profile data. No passwords, no custody, just proof it's you." }),
+    error && /* @__PURE__ */ jsx4("div", { className: "mb-6 bg-red-500 bg-opacity-20 border border-red-500 text-red-200 px-4 py-3 rounded-lg text-sm max-w-[600px] mx-auto", children: error }),
+    /* @__PURE__ */ jsx4("div", { className: "w-full max-w-[600px] mx-auto flex flex-col items-center space-y-4", children: availableSocials.map((social) => {
+      const label = getPlatformLabel(social);
+      const iconUrl = getPlatformIcon(social);
+      return /* @__PURE__ */ jsxs4(
+        "button",
+        {
+          onClick: () => handleClick(social),
+          disabled: isConnecting !== null,
+          className: `flex items-center justify-center space-x-2 sm:space-x-4 transition-colors duration-200 rounded-lg p-3 cursor-pointer border border-gray-800 w-full sm:w-[391px] bg-[#4050590D] ${isConnecting === social ? "opacity-60 cursor-not-allowed" : "hover:bg-[#0D3DDE] hover:border-[#0D3DDE]"}`,
+          children: [
+            iconUrl && /* @__PURE__ */ jsx4(
+              "img",
+              {
+                src: iconUrl,
+                alt: label,
+                className: "w-6 h-6 sm:w-8 sm:h-8 object-contain"
+              }
+            ),
+            /* @__PURE__ */ jsx4("span", { className: "text-white font-bold text-base sm:text-lg lg:text-[20px]", children: isConnecting === social ? "Connecting..." : label })
+          ]
+        },
+        social
+      );
+    }) }),
+    showFarcasterModal && /* @__PURE__ */ jsx4("div", { className: "fixed inset-0 flex items-center justify-center z-50 p-4 backdrop-blur-sm", children: /* @__PURE__ */ jsxs4("div", { className: "bg-white border border-[#F8FBFF1A] rounded-[20px] p-4 sm:p-6 w-full max-w-[671px] text-black relative", children: [
+      /* @__PURE__ */ jsxs4("div", { className: "flex items-center mb-4 sm:mb-6 relative", children: [
+        /* @__PURE__ */ jsx4("h3", { className: "text-lg sm:text-xl lg:text-[24px] font-bold text-center flex-1", children: "Sign in with Farcaster" }),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            onClick: closeFarcasterModal,
+            className: "absolute right-0 hover:text-gray-400 transition-colors cursor-pointer",
+            children: /* @__PURE__ */ jsx4("svg", { className: "w-5 h-5 sm:w-6 sm:h-6", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsx4("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M6 18L18 6M6 6l12 12" }) })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs4("div", { className: "text-center", children: [
+        /* @__PURE__ */ jsx4("p", { className: "text-sm sm:text-base lg:text-[16px] mb-4 font-medium text-[#423B3B] w-full max-w-[341px] mx-auto px-2", children: "To sign with Farcaster scan the code below with your phone's camera." }),
+        qrCodeUrl && /* @__PURE__ */ jsx4(
+          "img",
+          {
+            width: 172,
+            height: 175,
+            src: qrCodeUrl,
+            alt: "Farcaster QR Code",
+            className: "mx-auto mb-4 rounded-lg"
+          }
+        ),
+        /* @__PURE__ */ jsx4("hr", { className: "my-4 border-gray-300" }),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            onClick: openWarpcast,
+            className: "w-full mb-4 text-blue-600 font-bold text-[16px] cursor-pointer",
+            children: "I'm using my phone"
+          }
+        ),
+        /* @__PURE__ */ jsxs4("div", { className: "flex items-center justify-center space-x-2 text-sm", children: [
+          /* @__PURE__ */ jsxs4("svg", { className: "animate-spin h-4 w-4", xmlns: "http://www.w3.org/2000/svg", fill: "none", viewBox: "0 0 24 24", children: [
+            /* @__PURE__ */ jsx4("circle", { className: "opacity-25", cx: "12", cy: "12", r: "10", stroke: "currentColor", strokeWidth: "4" }),
+            /* @__PURE__ */ jsx4("path", { className: "opacity-75", fill: "currentColor", d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" })
+          ] }),
+          /* @__PURE__ */ jsx4("span", { children: "Waiting for authentication..." })
+        ] })
+      ] })
+    ] }) }),
+    showLensUsernameModal && /* @__PURE__ */ jsx4("div", { className: "fixed inset-0 flex items-center justify-center z-50 p-4 backdrop-blur-sm", children: /* @__PURE__ */ jsxs4("div", { className: "bg-[#02081D] border border-[#F8FBFF1A] rounded-[20px] p-6 max-w-md w-full relative", children: [
+      /* @__PURE__ */ jsxs4("div", { className: "flex justify-between items-center mb-6", children: [
+        /* @__PURE__ */ jsx4("h3", { className: "text-lg font-bold text-white", children: "Connect Lens Profile" }),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            onClick: closeLensUsernameModal,
+            className: "text-gray-400 hover:text-white transition-colors cursor-pointer",
+            children: /* @__PURE__ */ jsx4("svg", { className: "w-6 h-6", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsx4("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M6 18L18 6M6 6l12 12" }) })
+          }
+        )
+      ] }),
+      error && /* @__PURE__ */ jsx4("div", { className: "mb-4 bg-red-500 bg-opacity-20 border border-red-500 text-red-200 px-4 py-3 rounded-lg text-sm", children: error }),
+      /* @__PURE__ */ jsxs4("div", { children: [
+        /* @__PURE__ */ jsxs4("div", { className: "mb-4", children: [
+          /* @__PURE__ */ jsx4("label", { htmlFor: "username", className: "block text-sm font-medium text-white mb-2 text-left", children: "Enter your Lens username" }),
+          /* @__PURE__ */ jsx4(
+            "input",
+            {
+              type: "text",
+              id: "username",
+              value: usernameInput,
+              onChange: (e) => setUsernameInput(e.target.value),
+              onKeyPress: (e) => {
+                if (e.key === "Enter") {
+                  handleLensUsernameSubmit();
+                }
+              },
+              placeholder: "username",
+              className: "w-full px-4 py-2 border border-gray-600 rounded-lg bg-[#0A1A2E] text-white placeholder:text-gray-400 focus:outline-none focus:ring-2 focus:ring-[#0D3DDE] focus:border-transparent",
+              disabled: isConnecting === "lens",
+              autoFocus: true
+            }
+          ),
+          /* @__PURE__ */ jsx4("p", { className: "text-xs text-gray-400 mt-2 text-left", children: "Enter your Lens username without the @ symbol" })
+        ] }),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            onClick: handleLensUsernameSubmit,
+            disabled: isConnecting === "lens" || !usernameInput.trim(),
+            className: `w-full py-3 rounded-lg font-medium transition-colors duration-200 ${isConnecting === "lens" || !usernameInput.trim() ? "bg-gray-700 text-gray-400 cursor-not-allowed" : "bg-[#0D3DDE] hover:bg-[#0A2FB8] text-white"}`,
+            children: isConnecting === "lens" ? "Connecting..." : "Connect"
+          }
+        )
+      ] })
+    ] }) }),
+    showLensModal && lensProfile && /* @__PURE__ */ jsx4("div", { className: "fixed inset-0 flex items-center justify-center z-50 p-4 backdrop-blur-sm", children: /* @__PURE__ */ jsxs4("div", { className: "bg-[#02081D] border border-[#F8FBFF1A] rounded-[20px] p-6 max-w-sm w-full relative", children: [
+      /* @__PURE__ */ jsxs4("div", { className: "flex justify-between items-center mb-6", children: [
+        /* @__PURE__ */ jsx4("h3", { className: "text-lg font-bold text-white", children: "Lens Connected!" }),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            onClick: closeLensModal,
+            className: "text-gray-400 hover:text-white transition-colors",
+            children: /* @__PURE__ */ jsx4("svg", { className: "w-6 h-6", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsx4("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M6 18L18 6M6 6l12 12" }) })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs4("div", { className: "text-center", children: [
+        /* @__PURE__ */ jsx4("div", { className: "w-20 h-20 mx-auto mb-3 rounded-full overflow-hidden bg-gray-700", children: /* @__PURE__ */ jsx4(
+          "img",
+          {
+            src: lensProfile.metadata?.picture || "/lens-white.svg",
+            alt: "Profile",
+            className: "w-full h-full object-cover"
+          }
+        ) }),
+        /* @__PURE__ */ jsx4("h4", { className: "text-white font-bold text-lg mb-1", children: lensProfile.metadata?.name || lensProfile.username?.localName || lensProfile.username?.value }),
+        /* @__PURE__ */ jsxs4("p", { className: "text-gray-400 text-sm mb-4", children: [
+          "@",
+          lensProfile.username?.value || lensProfile.username?.localName
+        ] }),
+        /* @__PURE__ */ jsxs4("div", { className: "flex items-center justify-center space-x-2 text-[#ABFE2C]", children: [
+          /* @__PURE__ */ jsx4("svg", { className: "w-6 h-6", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsx4("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M5 13l4 4L19 7" }) }),
+          /* @__PURE__ */ jsx4("span", { className: "font-medium", children: "Successfully connected!" })
+        ] })
+      ] })
+    ] }) }),
+    showXModal && xProfile && /* @__PURE__ */ jsx4("div", { className: "fixed inset-0 flex items-center justify-center z-50 p-4 backdrop-blur-sm", children: /* @__PURE__ */ jsxs4("div", { className: "bg-[#02081D] border border-[#F8FBFF1A] rounded-[20px] p-6 max-w-sm w-full relative", children: [
+      /* @__PURE__ */ jsxs4("div", { className: "flex justify-between items-center mb-6", children: [
+        /* @__PURE__ */ jsx4("h3", { className: "text-lg font-bold text-white", children: "X Connected!" }),
+        /* @__PURE__ */ jsx4(
+          "button",
+          {
+            onClick: closeXModal,
+            className: "text-gray-400 hover:text-white transition-colors",
+            children: /* @__PURE__ */ jsx4("svg", { className: "w-6 h-6", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsx4("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M6 18L18 6M6 6l12 12" }) })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs4("div", { className: "text-center", children: [
+        /* @__PURE__ */ jsx4("div", { className: "w-20 h-20 mx-auto mb-3 rounded-full overflow-hidden flex items-center justify-center bg-zinc-900 border border-zinc-800", children: /* @__PURE__ */ jsx4(
+          "img",
+          {
+            src: "/x-white.svg",
+            alt: "X Profile",
+            className: "w-10 h-10 object-contain"
+          }
+        ) }),
+        /* @__PURE__ */ jsx4("h4", { className: "text-white font-bold text-lg mb-1", children: xProfile.displayName }),
+        /* @__PURE__ */ jsxs4("p", { className: "text-gray-400 text-sm mb-4", children: [
+          "@",
+          xProfile.username
+        ] }),
+        /* @__PURE__ */ jsxs4("div", { className: "flex items-center justify-center space-x-2 text-[#ABFE2C]", children: [
+          /* @__PURE__ */ jsx4("svg", { className: "w-6 h-6", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ jsx4("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M5 13l4 4L19 7" }) }),
+          /* @__PURE__ */ jsx4("span", { className: "font-medium", children: "Successfully connected!" })
+        ] })
+      ] })
+    ] }) })
+  ] });
+};
+var SocialConnection_default = SocialConnection;
+
+// src/react/components/VerifiedOnchainFlow.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var VerifiedOnchainFlow = ({
+  relayerUrl,
+  requiredSocials = [],
+  requiredWallets,
+  requireBiometrics = true,
+  onIdentityVerified,
+  className = "",
+  environment = "mainnet",
+  appId
+}) => {
+  const finalRelayerUrl = relayerUrl || "https://api.verifiedonchain.com";
+  const [stepCount, setStepCount] = useState7(1);
+  const [socialConnected, setSocialConnected] = useState7(false);
+  const [socialProfileData, setSocialProfileData] = useState7(null);
+  const [socialPlatform, setSocialPlatform] = useState7(null);
+  const [requestStatus, setRequestStatus] = useState7("idle");
+  const [humanityCode, setHumanityCode] = useState7(null);
+  const [progressMessage, setProgressMessage] = useState7("");
+  const { isConnected, address } = useAccount();
+  const { connected: solanaConnected, publicKey: solanaPublicKey } = useSolanaWallet();
+  const activeWallet = address ? address : solanaPublicKey ? solanaPublicKey.toString() : null;
+  const activeChain = address ? "evm" : solanaPublicKey ? "solana" : null;
+  useEffect5(() => {
+    if ((isConnected || solanaConnected) && stepCount === 1) {
+      const timer = setTimeout(() => {
+        if (requiredSocials.length > 0) {
+          setStepCount(2);
+        } else if (requireBiometrics) {
+          setStepCount(3);
+        } else {
+          finishFlow();
+        }
+      }, 1e3);
+      return () => clearTimeout(timer);
+    }
+  }, [isConnected, solanaConnected, stepCount, requiredSocials, requireBiometrics]);
+  const handleSocialConnect = async (platform, profileData) => {
+    setSocialConnected(true);
+    setSocialPlatform(platform);
+    if (profileData) setSocialProfileData(profileData);
+    if (requireBiometrics) {
+      setStepCount(3);
+    } else {
+      finishFlow();
+    }
+  };
+  const finishFlow = (simHash, returnedCode) => {
+    setRequestStatus("completed");
+    if (returnedCode) setHumanityCode(returnedCode);
+    onIdentityVerified({
+      walletAddress: activeWallet,
+      chain: activeChain,
+      socialProfile: socialProfileData,
+      socialPlatform: socialPlatform || void 0,
+      humanityCode: returnedCode,
+      simHash
+    });
+    setStepCount(4);
+  };
+  const handleVerificationComplete = async (result) => {
+    setRequestStatus("processing");
+    setStepCount(4);
+    setProgressMessage("Submitting identity to Relayer...");
+    try {
+      const client = new VerifiedRelayerClient({
+        baseUrl: finalRelayerUrl,
+        network: environment,
+        appId
+      });
+      const txResult = await client.submitVerification({
+        simhashFull: result.rawFacialData.faceEmbedding.join(","),
+        // Simplified for SDK
+        livenessCombined: 0.99,
+        // Simplified
+        walletAddress: activeWallet,
+        chain: activeChain
+      });
+      finishFlow(result.rawFacialData.faceEmbedding.join(","), txResult.txHash || "SUCCESS_NO_HASH");
+    } catch (err) {
+      setRequestStatus("error");
+      setHumanityCode(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+  return /* @__PURE__ */ jsxs5("div", { className: `w-full max-w-[1000px] mx-auto min-h-[400px] rounded-[20px] p-5 relative overflow-y-auto text-white ${className}`, children: [
+    stepCount === 1 && /* @__PURE__ */ jsx5(
+      WalletSelection_default,
+      {
+        onWalletConnect: () => {
+        },
+        requiredWallets
+      }
+    ),
+    stepCount === 2 && /* @__PURE__ */ jsx5(
+      SocialConnection_default,
+      {
+        onSocialConnect: handleSocialConnect,
+        onNextStep: () => setStepCount(3),
+        userAddress: activeWallet || "",
+        availableSocials: requiredSocials,
+        backendUrl: finalRelayerUrl,
+        environment
+      }
+    ),
+    stepCount === 3 && /* @__PURE__ */ jsx5(
+      ProofOfHumanity_default,
+      {
+        onNextStep: () => {
+        },
+        onVerificationComplete: handleVerificationComplete
+      }
+    ),
+    stepCount === 4 && /* @__PURE__ */ jsxs5("div", { className: "text-center mt-10", children: [
+      /* @__PURE__ */ jsx5("h2", { className: "text-3xl font-bold", children: requestStatus === "error" ? "Verification Failed" : "Verification Complete" }),
+      /* @__PURE__ */ jsx5("p", { className: "mt-4 text-gray-400", children: progressMessage }),
+      humanityCode && /* @__PURE__ */ jsx5("div", { className: "mt-8 p-4 bg-gray-900 rounded-xl", children: /* @__PURE__ */ jsx5("p", { className: "font-mono text-sm break-all", children: humanityCode }) })
+    ] })
+  ] });
+};
+var VerifiedOnchainFlow_default = VerifiedOnchainFlow;
+export {
+  BACKEND_PRIORITY,
+  CAPTURE_QUALITY,
+  EmbeddingQuantizer,
+  FaceOcclusionTracker,
+  FaceZK_default as FaceZK,
+  GlassesDetector,
+  HUMAN_CONFIG,
+  LivenessEngine,
+  MaskDetector,
+  ProofOfHumanity_default as ProofOfHumanity,
+  SocialConnection_default as SocialConnection,
+  VERIFICATION_CONSTANTS,
+  VerifiedOnchainFlow_default as VerifiedOnchainFlow,
+  VerifiedRelayerClient,
+  WalletSelection_default as WalletSelection,
+  averageEmbeddings,
+  calculateHammingDistance,
+  checkFaceOcclusion,
+  checkFaceOcclusionRaw,
+  computeSimHash,
+  createCalibratedQuantizer,
+  createLivenessData,
+  evaluateCaptureQuality,
+  extractRawFacialData,
+  generateBiometricSimHash,
+  generateHyperplanes,
+  generateRandomSalt,
+  getFaceBox,
+  getFaceLuminance,
+  getHyperplanes,
+  getRegionLuminance,
+  hammingDistance,
+  normalizeEmbedding,
+  processFacialDataForAleo,
+  similarityFromDistance,
+  useCameraStream,
+  useVisionModels,
+  validateDataQuality
+};
+//# sourceMappingURL=index.js.map