@facesmash/sdk 0.1.0

package/dist/react.cjs

@@ -0,0 +1,1068 @@
+'use strict';
+
+var PocketBase = require('pocketbase');
+var faceapi = require('@vladmandic/face-api');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var PocketBase__default = /*#__PURE__*/_interopDefault(PocketBase);
+var faceapi__namespace = /*#__PURE__*/_interopNamespace(faceapi);
+
+// src/core/client.ts
+var modelsLoaded = false;
+async function loadModels(config, onProgress) {
+  if (modelsLoaded) {
+    onProgress?.(100);
+    return true;
+  }
+  try {
+    try {
+      const tf2 = faceapi__namespace.tf;
+      if (tf2) {
+        await tf2.setBackend("webgl");
+        await tf2.ready();
+        if (tf2.env().flagRegistry?.CANVAS2D_WILL_READ_FREQUENTLY) {
+          tf2.env().set("CANVAS2D_WILL_READ_FREQUENTLY", true);
+        }
+        if (tf2.env().flagRegistry?.WEBGL_EXP_CONV) {
+          tf2.env().set("WEBGL_EXP_CONV", true);
+        }
+        if (config.debug) {
+          console.log(`[FaceSmash] TF.js backend: ${tf2.getBackend()}`);
+        }
+      }
+    } catch {
+    }
+    onProgress?.(10);
+    await Promise.all([
+      faceapi__namespace.nets.ssdMobilenetv1.loadFromUri(config.modelUrl),
+      faceapi__namespace.nets.tinyFaceDetector.loadFromUri(config.modelUrl),
+      faceapi__namespace.nets.faceLandmark68Net.loadFromUri(config.modelUrl),
+      faceapi__namespace.nets.faceRecognitionNet.loadFromUri(config.modelUrl),
+      faceapi__namespace.nets.faceExpressionNet.loadFromUri(config.modelUrl)
+    ]);
+    modelsLoaded = true;
+    onProgress?.(100);
+    if (config.debug) {
+      console.log("[FaceSmash] Models loaded successfully");
+    }
+    return true;
+  } catch (error) {
+    if (config.debug) {
+      console.error("[FaceSmash] Failed to load models:", error);
+    }
+    return false;
+  }
+}
+function areModelsLoaded() {
+  return modelsLoaded;
+}
+function getSsdOptions(minConfidence) {
+  return new faceapi__namespace.SsdMobilenetv1Options({ minConfidence });
+}
+function getTinyOptions() {
+  return new faceapi__namespace.TinyFaceDetectorOptions({ inputSize: 224, scoreThreshold: 0.4 });
+}
+async function extractDescriptor(input, config) {
+  try {
+    const media = typeof input === "string" ? await faceapi__namespace.fetchImage(input) : input;
+    let detection = await faceapi__namespace.detectSingleFace(media, getSsdOptions(config.minDetectionConfidence)).withFaceLandmarks().withFaceDescriptor();
+    if (!detection) {
+      detection = await faceapi__namespace.detectSingleFace(media, getTinyOptions()).withFaceLandmarks().withFaceDescriptor();
+    }
+    return detection?.descriptor ?? null;
+  } catch (error) {
+    if (config.debug) {
+      console.error("[FaceSmash] Descriptor extraction failed:", error);
+    }
+    return null;
+  }
+}
+async function analyzeFace(imageData, config) {
+  try {
+    const img = await faceapi__namespace.fetchImage(imageData);
+    let detection = await faceapi__namespace.detectSingleFace(img, getSsdOptions(config.minDetectionConfidence)).withFaceLandmarks().withFaceDescriptor();
+    if (!detection) {
+      detection = await faceapi__namespace.detectSingleFace(img, getTinyOptions()).withFaceLandmarks().withFaceDescriptor();
+    }
+    if (!detection) return null;
+    const headPose = estimateHeadPose(detection.landmarks, detection.detection.box);
+    const imgWidth = img.width || 640;
+    const imgHeight = img.height || 480;
+    const faceSizeCheck = validateFaceSize(detection.detection.box, imgWidth, imgHeight);
+    if (!faceSizeCheck.isValid) {
+      return {
+        descriptor: detection.descriptor,
+        normalizedDescriptor: normalizeDescriptor(detection.descriptor),
+        confidence: detection.detection.score,
+        qualityScore: 0,
+        lightingScore: 0,
+        headPose,
+        faceSizeCheck,
+        eyeAspectRatio: 0,
+        rejectionReason: faceSizeCheck.reason
+      };
+    }
+    const { avgEAR } = getEyeAspectRatios(detection.landmarks);
+    let lightingAnalysis;
+    try {
+      lightingAnalysis = analyzeLighting(detection, img);
+    } catch {
+      lightingAnalysis = {
+        score: 0.5,
+        brightness: 0.5,
+        contrast: 0.5,
+        evenness: 0.5,
+        conditions: { tooDark: false, tooBright: false, uneven: false, optimal: false }
+      };
+    }
+    let qualityScore = Math.min(detection.detection.score, 1);
+    qualityScore *= 0.7 + lightingAnalysis.score * 0.3;
+    const faceArea = detection.detection.box.width * detection.detection.box.height;
+    const imageArea = 640 * 640;
+    const sizeRatio = Math.min(faceArea / imageArea, 0.3) / 0.3;
+    qualityScore *= 0.8 + sizeRatio * 0.2;
+    if (!headPose.isFrontal) {
+      const anglePenalty = Math.max(0.5, 1 - (Math.abs(headPose.yaw) + Math.abs(headPose.pitch)) * 0.3);
+      qualityScore *= anglePenalty;
+    }
+    qualityScore = Math.max(0, Math.min(1, qualityScore));
+    return {
+      descriptor: detection.descriptor,
+      normalizedDescriptor: normalizeDescriptor(detection.descriptor),
+      confidence: detection.detection.score,
+      qualityScore,
+      lightingScore: lightingAnalysis.score,
+      headPose,
+      faceSizeCheck,
+      eyeAspectRatio: avgEAR
+    };
+  } catch (error) {
+    if (config.debug) {
+      console.error("[FaceSmash] Face analysis failed:", error);
+    }
+    return null;
+  }
+}
+async function processImages(images, config) {
+  if (images.length === 1) {
+    return extractDescriptor(images[0], config);
+  }
+  const descriptors = [];
+  for (const image of images) {
+    const d = await extractDescriptor(image, config);
+    if (d) descriptors.push(d);
+  }
+  if (descriptors.length === 0) return null;
+  const avg = new Float32Array(descriptors[0].length);
+  for (let i = 0; i < avg.length; i++) {
+    let sum = 0;
+    for (const d of descriptors) sum += d[i];
+    avg[i] = sum / descriptors.length;
+  }
+  return avg;
+}
+function euclidean(a, b) {
+  return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
+}
+function calculateEAR(eye) {
+  if (eye.length < 6) return 0.3;
+  const v1 = euclidean(eye[1], eye[5]);
+  const v2 = euclidean(eye[2], eye[4]);
+  const h = euclidean(eye[0], eye[3]);
+  return h === 0 ? 0 : (v1 + v2) / (2 * h);
+}
+function getEyeAspectRatios(landmarks) {
+  const leftEAR = calculateEAR(landmarks.getLeftEye());
+  const rightEAR = calculateEAR(landmarks.getRightEye());
+  return { leftEAR, rightEAR, avgEAR: (leftEAR + rightEAR) / 2 };
+}
+function estimateHeadPose(landmarks, box) {
+  const nose = landmarks.getNose();
+  const jaw = landmarks.getJawOutline();
+  const noseTip = nose[3];
+  const faceCenterX = box.x + box.width / 2;
+  const faceCenterY = box.y + box.height / 2;
+  const yaw = (noseTip.x - faceCenterX) / (box.width / 2);
+  const pitch = (noseTip.y - faceCenterY) / (box.height / 2);
+  const jawLeft = jaw[0];
+  const jawRight = jaw[jaw.length - 1];
+  const roll = Math.atan2(jawRight.y - jawLeft.y, jawRight.x - jawLeft.x);
+  const isFrontal = Math.abs(yaw) < 0.35 && Math.abs(pitch) < 0.4 && Math.abs(roll) < 0.25;
+  return { yaw, pitch, roll, isFrontal };
+}
+function validateFaceSize(box, frameWidth = 640, frameHeight = 480) {
+  const ratio = box.width * box.height / (frameWidth * frameHeight);
+  if (ratio < 0.02) return { isValid: false, ratio, reason: "Face too far from camera" };
+  if (ratio > 0.65) return { isValid: false, ratio, reason: "Face too close to camera" };
+  if (box.width < 80 || box.height < 80) return { isValid: false, ratio, reason: "Face too small for reliable recognition" };
+  return { isValid: true, ratio };
+}
+function normalizeDescriptor(descriptor) {
+  let norm = 0;
+  for (let i = 0; i < descriptor.length; i++) norm += descriptor[i] ** 2;
+  norm = Math.sqrt(norm);
+  if (norm === 0) return descriptor;
+  const normalized = new Float32Array(descriptor.length);
+  for (let i = 0; i < descriptor.length; i++) normalized[i] = descriptor[i] / norm;
+  return normalized;
+}
+function analyzeLighting(detection, imageElement) {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("Cannot get canvas context");
+  canvas.width = imageElement.width || 640;
+  canvas.height = imageElement.height || 640;
+  if (imageElement instanceof HTMLImageElement) {
+    ctx.drawImage(imageElement, 0, 0, canvas.width, canvas.height);
+  } else {
+    ctx.drawImage(imageElement, 0, 0);
+  }
+  const faceBox = detection.detection.box;
+  const faceImageData = ctx.getImageData(
+    Math.max(0, faceBox.x - 20),
+    Math.max(0, faceBox.y - 20),
+    Math.min(canvas.width - faceBox.x, faceBox.width + 40),
+    Math.min(canvas.height - faceBox.y, faceBox.height + 40)
+  );
+  const pixels = faceImageData.data;
+  let totalBrightness = 0;
+  const brightnessValues = [];
+  for (let i = 0; i < pixels.length; i += 4) {
+    const brightness = (pixels[i] + pixels[i + 1] + pixels[i + 2]) / 3;
+    totalBrightness += brightness;
+    brightnessValues.push(brightness);
+  }
+  const avgBrightness = totalBrightness / (pixels.length / 4);
+  const variance = brightnessValues.reduce((acc, val) => acc + (val - avgBrightness) ** 2, 0) / brightnessValues.length;
+  const contrast = Math.sqrt(variance);
+  const evenness = Math.max(0, 1 - contrast / 128);
+  const tooDark = avgBrightness < 80;
+  const tooBright = avgBrightness > 200;
+  const uneven = evenness < 0.6;
+  const optimal = !tooDark && !tooBright && !uneven;
+  let score = 0.5;
+  if (optimal) score = 0.9;
+  else if (tooDark) score = Math.max(0.2, avgBrightness / 160);
+  else if (tooBright) score = Math.max(0.2, (255 - avgBrightness) / 110);
+  else if (uneven) score = Math.max(0.3, evenness);
+  return {
+    score,
+    brightness: avgBrightness / 255,
+    contrast: Math.min(contrast / 64, 1),
+    evenness,
+    conditions: { tooDark, tooBright, uneven, optimal }
+  };
+}
+function calculateSimilarity(d1, d2) {
+  return 1 - faceapi__namespace.euclideanDistance(d1, d2);
+}
+function facesMatch(d1, d2, threshold = 0.45) {
+  return calculateSimilarity(d1, d2) >= threshold;
+}
+function enhancedMatch(descriptor1, descriptor2, baseThreshold = 0.45, confidenceBoost = 0, lightingScore = 0.5) {
+  if (descriptor1.length !== descriptor2.length) {
+    return { isMatch: false, similarity: 0, adaptedThreshold: baseThreshold };
+  }
+  const similarity = calculateSimilarity(descriptor1, descriptor2);
+  let adaptedThreshold = baseThreshold;
+  if (lightingScore < 0.4) {
+    adaptedThreshold = Math.max(0.35, adaptedThreshold - 0.05);
+  } else if (lightingScore > 0.8) {
+    adaptedThreshold = Math.min(0.6, adaptedThreshold + 0.02);
+  }
+  adaptedThreshold = Math.max(0.35, adaptedThreshold - confidenceBoost * 0.05);
+  return {
+    isMatch: similarity >= adaptedThreshold,
+    similarity,
+    adaptedThreshold
+  };
+}
+function multiTemplateMatch(newDescriptor, templates, baseThreshold, lightingScore = 0.5) {
+  if (templates.length === 0) {
+    return { isMatch: false, bestSimilarity: 0, avgSimilarity: 0, matchCount: 0 };
+  }
+  let bestSimilarity = 0;
+  let weightedSum = 0;
+  let totalWeight = 0;
+  let matchCount = 0;
+  for (const template of templates) {
+    if (!template.descriptor || template.descriptor.length === 0) continue;
+    const result = enhancedMatch(
+      newDescriptor,
+      template.descriptor,
+      baseThreshold,
+      template.weight,
+      lightingScore
+    );
+    if (result.similarity > bestSimilarity) {
+      bestSimilarity = result.similarity;
+    }
+    const w = template.quality * template.weight;
+    weightedSum += result.similarity * w;
+    totalWeight += w;
+    if (result.isMatch) matchCount++;
+  }
+  const avgSimilarity = totalWeight > 0 ? weightedSum / totalWeight : 0;
+  const isMatch = bestSimilarity >= baseThreshold || matchCount / templates.length >= 0.6;
+  return { isMatch, bestSimilarity, avgSimilarity, matchCount };
+}
+function calculateLearningWeight(qualityScore, lightingScore, confidence) {
+  let weight = 1;
+  if (qualityScore > 0.8) weight *= 1.5;
+  else if (qualityScore > 0.6) weight *= 1.2;
+  else if (qualityScore < 0.4) weight *= 0.5;
+  if (lightingScore > 0.7) weight *= 1.3;
+  else if (lightingScore < 0.4) weight *= 0.7;
+  if (confidence > 0.8) weight *= 1.2;
+  else if (confidence < 0.5) weight *= 0.8;
+  return Math.max(0.1, Math.min(weight, 3));
+}
+
+// src/core/types.ts
+var DEFAULT_CONFIG = {
+  apiUrl: "https://api.facesmash.app",
+  modelUrl: "https://cdn.jsdelivr.net/npm/@vladmandic/face-api/model",
+  minDetectionConfidence: 0.3,
+  matchThreshold: 0.45,
+  minQualityScore: 0.2,
+  maxTemplatesPerUser: 10,
+  debug: false
+};
+function resolveConfig(config) {
+  return { ...DEFAULT_CONFIG, ...config };
+}
+
+// src/core/client.ts
+var FaceSmashClient = class {
+  constructor(config) {
+    this.listeners = [];
+    this._modelsLoaded = false;
+    this.config = resolveConfig(config);
+    this.pb = new PocketBase__default.default(this.config.apiUrl);
+    this.pb.autoCancellation(false);
+  }
+  // ─── Event System ───────────────────────────────────────────
+  on(listener) {
+    this.listeners.push(listener);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== listener);
+    };
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  // ─── Model Loading ──────────────────────────────────────────
+  get isReady() {
+    return this._modelsLoaded;
+  }
+  async init(onProgress) {
+    if (this._modelsLoaded) return true;
+    this.emit({ type: "models-loading", progress: 0 });
+    const success = await loadModels(this.config, (progress) => {
+      onProgress?.(progress);
+      this.emit({ type: "models-loading", progress });
+    });
+    if (success) {
+      this._modelsLoaded = true;
+      this.emit({ type: "models-loaded" });
+    } else {
+      this.emit({ type: "models-error", error: "Failed to load face recognition models" });
+    }
+    return success;
+  }
+  // ─── Face Analysis ──────────────────────────────────────────
+  async analyzeFace(imageData) {
+    this.ensureReady();
+    const result = await analyzeFace(imageData, this.config);
+    if (result) {
+      this.emit({ type: "face-detected", analysis: result });
+    } else {
+      this.emit({ type: "face-lost" });
+    }
+    return result;
+  }
+  // ─── Login ──────────────────────────────────────────────────
+  async login(images) {
+    this.ensureReady();
+    this.emit({ type: "login-start" });
+    try {
+      let bestAnalysis = null;
+      for (const img of images) {
+        const analysis = await analyzeFace(img, this.config);
+        if (analysis && !analysis.rejectionReason) {
+          if (!bestAnalysis || analysis.qualityScore > bestAnalysis.qualityScore) {
+            bestAnalysis = analysis;
+          }
+        }
+      }
+      if (!bestAnalysis) {
+        const error2 = "No face detected in any image";
+        this.emit({ type: "login-failed", error: error2 });
+        return { success: false, error: error2 };
+      }
+      if (bestAnalysis.qualityScore < this.config.minQualityScore) {
+        const error2 = "Face quality too low. Improve lighting and face the camera directly.";
+        this.emit({ type: "login-failed", error: error2 });
+        return { success: false, error: error2 };
+      }
+      const profiles = await this.pb.collection("user_profiles").getFullList();
+      if (profiles.length === 0) {
+        const error2 = "No registered users found";
+        this.emit({ type: "login-failed", error: error2 });
+        return { success: false, error: error2 };
+      }
+      let bestMatch = { user: null, similarity: 0 };
+      for (const profile of profiles) {
+        if (!profile.face_embedding) continue;
+        const storedEmbedding = new Float32Array(profile.face_embedding);
+        let matchResult = enhancedMatch(
+          bestAnalysis.descriptor,
+          storedEmbedding,
+          this.config.matchThreshold,
+          0,
+          bestAnalysis.lightingScore
+        );
+        try {
+          const templates = await this.pb.collection("face_templates").getList(1, 50, {
+            filter: `user_email="${profile.email}"`,
+            sort: "-quality_score"
+          });
+          if (templates.items.length > 0) {
+            const templateData = templates.items.filter((t) => t.descriptor && t.descriptor.length > 0).map((t) => ({
+              descriptor: new Float32Array(t.descriptor),
+              quality: t.quality_score || 0.5,
+              weight: 1
+            }));
+            if (templateData.length > 0) {
+              const multiResult = multiTemplateMatch(
+                bestAnalysis.descriptor,
+                templateData,
+                this.config.matchThreshold,
+                bestAnalysis.lightingScore
+              );
+              if (multiResult.bestSimilarity > matchResult.similarity) {
+                matchResult = {
+                  isMatch: multiResult.isMatch,
+                  similarity: multiResult.bestSimilarity,
+                  adaptedThreshold: this.config.matchThreshold
+                };
+              }
+            }
+          }
+        } catch {
+        }
+        const userProfile = {
+          id: profile.id,
+          name: profile.name,
+          email: profile.email,
+          face_embedding: profile.face_embedding,
+          created: profile.created,
+          updated: profile.updated
+        };
+        if (matchResult.similarity > bestMatch.similarity) {
+          bestMatch = { user: userProfile, similarity: matchResult.similarity };
+        }
+        if (matchResult.isMatch) {
+          try {
+            await this.storeLoginScan(userProfile, bestAnalysis);
+          } catch {
+          }
+          this.emit({
+            type: "login-success",
+            user: userProfile,
+            similarity: matchResult.similarity
+          });
+          return { success: true, user: userProfile, similarity: matchResult.similarity };
+        }
+      }
+      const error = bestMatch.similarity > 0.4 ? "Face partially matched but did not meet security threshold." : "Face not recognized.";
+      this.emit({ type: "login-failed", error, bestSimilarity: bestMatch.similarity });
+      return { success: false, error, similarity: bestMatch.similarity };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : "Unknown error during login";
+      this.emit({ type: "login-failed", error });
+      return { success: false, error };
+    }
+  }
+  // ─── Registration ───────────────────────────────────────────
+  async register(name, images, email) {
+    this.ensureReady();
+    this.emit({ type: "register-start" });
+    try {
+      let bestAnalysis = null;
+      let bestImageIdx = 0;
+      for (let i = 0; i < images.length; i++) {
+        const analysis = await analyzeFace(images[i], this.config);
+        if (analysis && !analysis.rejectionReason) {
+          if (!bestAnalysis || analysis.qualityScore > bestAnalysis.qualityScore) {
+            bestAnalysis = analysis;
+            bestImageIdx = i;
+          }
+        }
+      }
+      if (!bestAnalysis) {
+        const error = "No face detected in any image";
+        this.emit({ type: "register-failed", error });
+        return { success: false, error };
+      }
+      if (bestAnalysis.qualityScore < this.config.minQualityScore) {
+        const error = "Face quality too low for registration.";
+        this.emit({ type: "register-failed", error });
+        return { success: false, error };
+      }
+      const existingProfiles = await this.pb.collection("user_profiles").getFullList();
+      for (const profile of existingProfiles) {
+        if (!profile.face_embedding) continue;
+        const stored = new Float32Array(profile.face_embedding);
+        if (stored.length !== bestAnalysis.descriptor.length) continue;
+        const similarity = 1 - (await import('@vladmandic/face-api')).euclideanDistance(bestAnalysis.descriptor, stored);
+        if (similarity >= 0.75) {
+          const error = `This face is already registered to ${profile.name || profile.email}`;
+          this.emit({ type: "register-failed", error });
+          return { success: false, error };
+        }
+      }
+      const embeddingArray = Array.from(bestAnalysis.descriptor);
+      const record = await this.pb.collection("user_profiles").create({
+        name,
+        email: email || `${name.toLowerCase().replace(/\s+/g, ".")}@facesmash.app`,
+        face_embedding: embeddingArray
+      });
+      await this.pb.collection("face_templates").create({
+        user_email: record.email,
+        descriptor: embeddingArray,
+        quality_score: bestAnalysis.qualityScore,
+        label: "registration"
+      });
+      await this.pb.collection("face_scans").create({
+        user_email: record.email,
+        face_embedding: JSON.stringify(embeddingArray),
+        confidence: String(bestAnalysis.confidence),
+        scan_type: "registration",
+        quality_score: String(bestAnalysis.qualityScore)
+      });
+      const user = {
+        id: record.id,
+        name: record.name,
+        email: record.email,
+        face_embedding: embeddingArray,
+        created: record.created,
+        updated: record.updated
+      };
+      this.emit({ type: "register-success", user });
+      return { success: true, user };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : "Unknown error during registration";
+      this.emit({ type: "register-failed", error });
+      return { success: false, error };
+    }
+  }
+  // ─── Helpers ────────────────────────────────────────────────
+  ensureReady() {
+    if (!areModelsLoaded()) {
+      throw new Error(
+        "FaceSmash models not loaded. Call client.init() first."
+      );
+    }
+  }
+  async storeLoginScan(user, analysis) {
+    const embeddingArray = Array.from(analysis.descriptor);
+    await this.pb.collection("sign_in_logs").create({
+      user_email: user.email,
+      success: true
+    });
+    await this.pb.collection("face_scans").create({
+      user_email: user.email,
+      face_embedding: JSON.stringify(embeddingArray),
+      confidence: String(analysis.confidence),
+      scan_type: "login",
+      quality_score: String(analysis.qualityScore)
+    });
+    if (analysis.qualityScore > 0.5) {
+      const weight = calculateLearningWeight(
+        analysis.qualityScore,
+        analysis.lightingScore,
+        analysis.confidence
+      );
+      const learningRate = Math.min(weight * 0.1, 0.3);
+      const current = new Float32Array(user.face_embedding);
+      const updated = new Float32Array(current.length);
+      for (let i = 0; i < current.length; i++) {
+        updated[i] = current[i] * (1 - learningRate) + analysis.descriptor[i] * learningRate;
+      }
+      await this.pb.collection("user_profiles").update(user.id, {
+        face_embedding: Array.from(updated)
+      });
+    }
+    if (analysis.qualityScore > 0.6) {
+      const existing = await this.pb.collection("face_templates").getList(1, 50, {
+        filter: `user_email="${user.email}"`,
+        sort: "quality_score"
+      });
+      if (existing.items.length >= this.config.maxTemplatesPerUser) {
+        await this.pb.collection("face_templates").delete(existing.items[0].id);
+      }
+      await this.pb.collection("face_templates").create({
+        user_email: user.email,
+        descriptor: embeddingArray,
+        quality_score: analysis.qualityScore,
+        label: "auto"
+      });
+    }
+  }
+};
+
+// src/index.ts
+function createFaceSmash(config) {
+  return new FaceSmashClient(config);
+}
+var FaceSmashContext = react.createContext(null);
+function FaceSmashProvider({
+  children,
+  config,
+  onReady,
+  onError,
+  onEvent
+}) {
+  const clientRef = react.useRef(null);
+  if (!clientRef.current) {
+    clientRef.current = new FaceSmashClient(config);
+  }
+  const client = clientRef.current;
+  const [isReady, setIsReady] = react.useState(false);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [loadProgress, setLoadProgress] = react.useState(0);
+  const [error, setError] = react.useState(null);
+  const initModels = react.useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    setLoadProgress(0);
+    const success = await client.init((progress) => {
+      setLoadProgress(progress);
+    });
+    if (success) {
+      setIsReady(true);
+      setIsLoading(false);
+      onReady?.();
+    } else {
+      const msg = "Failed to load face recognition models";
+      setError(msg);
+      setIsLoading(false);
+      onError?.(msg);
+    }
+  }, [client, onReady, onError]);
+  react.useEffect(() => {
+    initModels();
+  }, [initModels]);
+  react.useEffect(() => {
+    if (!onEvent) return;
+    return client.on(onEvent);
+  }, [client, onEvent]);
+  const retryInit = react.useCallback(() => {
+    initModels();
+  }, [initModels]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    FaceSmashContext.Provider,
+    {
+      value: { client, isReady, isLoading, loadProgress, error, retryInit },
+      children
+    }
+  );
+}
+function useFaceSmash() {
+  const ctx = react.useContext(FaceSmashContext);
+  if (!ctx) {
+    throw new Error("useFaceSmash must be used within a <FaceSmashProvider>");
+  }
+  return ctx;
+}
+function FaceLogin({
+  onResult,
+  captureCount = 3,
+  captureDelay = 500,
+  autoStart = true,
+  className,
+  overlay,
+  loadingContent,
+  errorContent
+}) {
+  const { client, isReady, isLoading, error: initError } = useFaceSmash();
+  const videoRef = react.useRef(null);
+  const canvasRef = react.useRef(null);
+  const streamRef = react.useRef(null);
+  const [cameraError, setCameraError] = react.useState(null);
+  const [isScanning, setIsScanning] = react.useState(false);
+  const [status, setStatus] = react.useState("loading");
+  const startCamera = react.useCallback(async () => {
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({
+        video: { width: 640, height: 480, facingMode: "user" }
+      });
+      streamRef.current = stream;
+      if (videoRef.current) {
+        videoRef.current.srcObject = stream;
+        await videoRef.current.play();
+      }
+      setCameraError(null);
+    } catch {
+      setCameraError("Camera access denied or not available");
+      setStatus("error");
+    }
+  }, []);
+  const stopCamera = react.useCallback(() => {
+    streamRef.current?.getTracks().forEach((t) => t.stop());
+    streamRef.current = null;
+  }, []);
+  const captureFrame = react.useCallback(() => {
+    const video = videoRef.current;
+    const canvas = canvasRef.current;
+    if (!video || !canvas) return null;
+    canvas.width = video.videoWidth || 640;
+    canvas.height = video.videoHeight || 480;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return null;
+    ctx.drawImage(video, 0, 0);
+    return canvas.toDataURL("image/jpeg", 0.9);
+  }, []);
+  const scan = react.useCallback(async () => {
+    if (!isReady || isScanning) return;
+    setIsScanning(true);
+    setStatus("scanning");
+    const images = [];
+    for (let i = 0; i < captureCount; i++) {
+      const frame = captureFrame();
+      if (frame) images.push(frame);
+      if (i < captureCount - 1) {
+        await new Promise((r) => setTimeout(r, captureDelay));
+      }
+    }
+    if (images.length === 0) {
+      const result2 = { success: false, error: "Failed to capture images from camera" };
+      onResult(result2);
+      setIsScanning(false);
+      setStatus("error");
+      return;
+    }
+    const result = await client.login(images);
+    onResult(result);
+    setIsScanning(false);
+    setStatus("done");
+  }, [isReady, isScanning, captureCount, captureDelay, captureFrame, client, onResult]);
+  react.useEffect(() => {
+    if (isReady) {
+      startCamera();
+      setStatus("ready");
+    }
+    return () => stopCamera();
+  }, [isReady, startCamera, stopCamera]);
+  react.useEffect(() => {
+    if (autoStart && status === "ready" && !isScanning) {
+      const timer = setTimeout(scan, 2e3);
+      return () => clearTimeout(timer);
+    }
+  }, [autoStart, status, isScanning, scan]);
+  const retry = react.useCallback(() => {
+    setCameraError(null);
+    setStatus("loading");
+    startCamera().then(() => setStatus("ready"));
+  }, [startCamera]);
+  const displayError = cameraError || initError;
+  if (displayError && errorContent) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: errorContent(displayError, retry) });
+  }
+  if (isLoading && loadingContent) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: loadingContent });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className, style: { position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "video",
+      {
+        ref: videoRef,
+        autoPlay: true,
+        playsInline: true,
+        muted: true,
+        style: {
+          width: "100%",
+          height: "100%",
+          objectFit: "cover",
+          transform: "scaleX(-1)"
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx("canvas", { ref: canvasRef, style: { display: "none" } }),
+    overlay,
+    displayError && /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          inset: 0,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          backgroundColor: "rgba(0,0,0,0.8)",
+          color: "white",
+          padding: "1rem",
+          textAlign: "center"
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { children: displayError }),
+          /* @__PURE__ */ jsxRuntime.jsx("button", { onClick: retry, style: { marginTop: "0.5rem", cursor: "pointer" }, children: "Retry" })
+        ] })
+      }
+    )
+  ] });
+}
+function FaceRegister({
+  name,
+  email,
+  onResult,
+  captureCount = 3,
+  captureDelay = 500,
+  autoStart = true,
+  className,
+  overlay,
+  loadingContent,
+  errorContent
+}) {
+  const { client, isReady, isLoading, error: initError } = useFaceSmash();
+  const videoRef = react.useRef(null);
+  const canvasRef = react.useRef(null);
+  const streamRef = react.useRef(null);
+  const [cameraError, setCameraError] = react.useState(null);
+  const [isCapturing, setIsCapturing] = react.useState(false);
+  const [status, setStatus] = react.useState("loading");
+  const startCamera = react.useCallback(async () => {
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({
+        video: { width: 640, height: 480, facingMode: "user" }
+      });
+      streamRef.current = stream;
+      if (videoRef.current) {
+        videoRef.current.srcObject = stream;
+        await videoRef.current.play();
+      }
+      setCameraError(null);
+    } catch {
+      setCameraError("Camera access denied or not available");
+      setStatus("error");
+    }
+  }, []);
+  const stopCamera = react.useCallback(() => {
+    streamRef.current?.getTracks().forEach((t) => t.stop());
+    streamRef.current = null;
+  }, []);
+  const captureFrame = react.useCallback(() => {
+    const video = videoRef.current;
+    const canvas = canvasRef.current;
+    if (!video || !canvas) return null;
+    canvas.width = video.videoWidth || 640;
+    canvas.height = video.videoHeight || 480;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return null;
+    ctx.drawImage(video, 0, 0);
+    return canvas.toDataURL("image/jpeg", 0.9);
+  }, []);
+  const capture = react.useCallback(async () => {
+    if (!isReady || isCapturing) return;
+    setIsCapturing(true);
+    setStatus("capturing");
+    const images = [];
+    for (let i = 0; i < captureCount; i++) {
+      const frame = captureFrame();
+      if (frame) images.push(frame);
+      if (i < captureCount - 1) {
+        await new Promise((r) => setTimeout(r, captureDelay));
+      }
+    }
+    if (images.length === 0) {
+      const result2 = { success: false, error: "Failed to capture images" };
+      onResult(result2);
+      setIsCapturing(false);
+      setStatus("error");
+      return;
+    }
+    const result = await client.register(name, images, email);
+    onResult(result);
+    setIsCapturing(false);
+    setStatus("done");
+  }, [isReady, isCapturing, captureCount, captureDelay, captureFrame, client, name, email, onResult]);
+  react.useEffect(() => {
+    if (isReady) {
+      startCamera();
+      setStatus("ready");
+    }
+    return () => stopCamera();
+  }, [isReady, startCamera, stopCamera]);
+  react.useEffect(() => {
+    if (autoStart && status === "ready" && !isCapturing) {
+      const timer = setTimeout(capture, 2e3);
+      return () => clearTimeout(timer);
+    }
+  }, [autoStart, status, isCapturing, capture]);
+  const retry = react.useCallback(() => {
+    setCameraError(null);
+    setStatus("loading");
+    startCamera().then(() => setStatus("ready"));
+  }, [startCamera]);
+  const displayError = cameraError || initError;
+  if (displayError && errorContent) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: errorContent(displayError, retry) });
+  }
+  if (isLoading && loadingContent) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: loadingContent });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className, style: { position: "relative" }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "video",
+      {
+        ref: videoRef,
+        autoPlay: true,
+        playsInline: true,
+        muted: true,
+        style: {
+          width: "100%",
+          height: "100%",
+          objectFit: "cover",
+          transform: "scaleX(-1)"
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx("canvas", { ref: canvasRef, style: { display: "none" } }),
+    overlay,
+    displayError && /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          inset: 0,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          backgroundColor: "rgba(0,0,0,0.8)",
+          color: "white",
+          padding: "1rem",
+          textAlign: "center"
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { children: displayError }),
+          /* @__PURE__ */ jsxRuntime.jsx("button", { onClick: retry, style: { marginTop: "0.5rem", cursor: "pointer" }, children: "Retry" })
+        ] })
+      }
+    )
+  ] });
+}
+function useFaceLogin() {
+  const { client, isReady } = useFaceSmash();
+  const [isScanning, setIsScanning] = react.useState(false);
+  const [result, setResult] = react.useState(null);
+  const login = react.useCallback(
+    async (images) => {
+      if (!isReady) {
+        return { success: false, error: "Models not loaded yet" };
+      }
+      setIsScanning(true);
+      setResult(null);
+      const loginResult = await client.login(images);
+      setResult(loginResult);
+      setIsScanning(false);
+      return loginResult;
+    },
+    [client, isReady]
+  );
+  const reset = react.useCallback(() => {
+    setIsScanning(false);
+    setResult(null);
+  }, []);
+  return { login, isScanning, result, reset, isReady };
+}
+function useFaceRegister() {
+  const { client, isReady } = useFaceSmash();
+  const [isRegistering, setIsRegistering] = react.useState(false);
+  const [result, setResult] = react.useState(null);
+  const register = react.useCallback(
+    async (name, images, email) => {
+      if (!isReady) {
+        return { success: false, error: "Models not loaded yet" };
+      }
+      setIsRegistering(true);
+      setResult(null);
+      const regResult = await client.register(name, images, email);
+      setResult(regResult);
+      setIsRegistering(false);
+      return regResult;
+    },
+    [client, isReady]
+  );
+  const reset = react.useCallback(() => {
+    setIsRegistering(false);
+    setResult(null);
+  }, []);
+  return { register, isRegistering, result, reset, isReady };
+}
+function useFaceAnalysis() {
+  const { client, isReady } = useFaceSmash();
+  const [analysis, setAnalysis] = react.useState(null);
+  const [isAnalyzing, setIsAnalyzing] = react.useState(false);
+  const analyze = react.useCallback(
+    async (imageData) => {
+      if (!isReady) return null;
+      setIsAnalyzing(true);
+      const result = await client.analyzeFace(imageData);
+      setAnalysis(result);
+      setIsAnalyzing(false);
+      return result;
+    },
+    [client, isReady]
+  );
+  return { analyze, analysis, isAnalyzing, isReady };
+}
+
+exports.FaceLogin = FaceLogin;
+exports.FaceRegister = FaceRegister;
+exports.FaceSmashClient = FaceSmashClient;
+exports.FaceSmashProvider = FaceSmashProvider;
+exports.analyzeFace = analyzeFace;
+exports.areModelsLoaded = areModelsLoaded;
+exports.calculateLearningWeight = calculateLearningWeight;
+exports.calculateSimilarity = calculateSimilarity;
+exports.createFaceSmash = createFaceSmash;
+exports.enhancedMatch = enhancedMatch;
+exports.extractDescriptor = extractDescriptor;
+exports.facesMatch = facesMatch;
+exports.loadModels = loadModels;
+exports.multiTemplateMatch = multiTemplateMatch;
+exports.normalizeDescriptor = normalizeDescriptor;
+exports.processImages = processImages;
+exports.useFaceAnalysis = useFaceAnalysis;
+exports.useFaceLogin = useFaceLogin;
+exports.useFaceRegister = useFaceRegister;
+exports.useFaceSmash = useFaceSmash;
+//# sourceMappingURL=react.cjs.map
+//# sourceMappingURL=react.cjs.map