@mostajs/face 1.0.0 → 1.1.0

package/README.md

@@ -1,11 +1,23 @@
 # @mostajs/face
 
-> Reusable face recognition module — detection, descriptor extraction, 1:N matching.
+> Reusable face recognition module — detection, descriptor extraction, 1:N matching, API route factories.
 
 [![npm version](https://img.shields.io/npm/v/@mostajs/face.svg)](https://www.npmjs.com/package/@mostajs/face)
 [![license](https://img.shields.io/npm/l/@mostajs/face.svg)](LICENSE)
 
-Part of the [@mosta suite](https://mostajs.dev).
+Part of the [@mosta suite](https://mostajs.dev). **100% standalone** — zero dependency on `@mostajs/orm` or any other `@mostajs/*` package.
+
+---
+
+## Table des matieres
+
+1. [Installation](#installation)
+2. [Quick Start](#quick-start)
+3. [API Route Factories](#api-route-factories)
+4. [React Hooks](#react-hooks)
+5. [Integration complete dans une nouvelle app](#integration-complete)
+6. [API Reference](#api-reference)
+7. [Architecture](#architecture)
 
 ---
 
@@ -15,59 +27,411 @@ Part of the [@mosta suite](https://mostajs.dev).
 npm install @mostajs/face
 ```
 
+Copier les modeles face-api.js dans votre dossier `public/` :
+
+```bash
+mkdir -p public/models/face-api
+# Copier les fichiers .bin et .json depuis node_modules/@vladmandic/face-api/model/
+cp node_modules/@vladmandic/face-api/model/tiny_face_detector_model-* public/models/face-api/
+cp node_modules/@vladmandic/face-api/model/face_landmark_68_model-* public/models/face-api/
+cp node_modules/@vladmandic/face-api/model/face_recognition_model-* public/models/face-api/
+```
+
+---
+
 ## Quick Start
 
-### 1. Load models and detect faces
+### 1. Charger les modeles et detecter des visages
 
 ```typescript
 import { loadModels, detectFace, extractDescriptor } from '@mostajs/face'
 
-await loadModels('/models')  // path to face-api.js model files
+await loadModels('/models/face-api')
 
 const detection = await detectFace(imageElement)
-const descriptor = await extractDescriptor(imageElement)
+const descriptor = await extractDescriptor(imageElement) // Float32Array(128)
 ```
 
-### 2. Compare faces
+### 2. Comparer des visages
 
 ```typescript
 import { compareFaces, findMatch } from '@mostajs/face'
 
+// Distance euclidienne entre deux descripteurs
 const distance = compareFaces(descriptor1, descriptor2)
+console.log(distance < 0.6 ? 'Meme personne' : 'Personnes differentes')
 
-const match = findMatch(unknownDescriptor, knownFaces, 0.6)
+// Recherche 1:N parmi des candidats
+const candidates = [
+  { id: '1', faceDescriptor: [...], name: 'Alice' },
+  { id: '2', faceDescriptor: [...], name: 'Bob' },
+]
+const match = findMatch(unknownDescriptor, candidates, 0.6)
 if (match) {
-  console.log('Matched:', match.label, 'distance:', match.distance)
+  console.log('Match:', match.match.name, 'distance:', match.distance)
+}
+```
+
+---
+
+## API Route Factories
+
+Depuis la v1.1.0, le package fournit des factories pour creer des routes API (Next.js App Router ou tout framework supportant `Request`/`Response`).
+
+### POST /api/face/recognize
+
+Factory qui recoit un descripteur facial et cherche le meilleur match parmi vos candidats.
+
+```typescript
+// src/app/api/face/recognize/route.ts
+import { createRecognizeHandler } from '@mostajs/face/api/recognize.route'
+import { db } from '@/lib/db'
+
+export const { POST } = createRecognizeHandler({
+  // Fournir les candidats depuis votre base de donnees
+  getCandidates: async () => {
+    return db.query('SELECT id, name, photo, "faceDescriptor" FROM users WHERE "faceDescriptor" IS NOT NULL')
+  },
+
+  // Seuil de matching (defaut: 0.6)
+  getThreshold: async () => 0.55,
+
+  // Champs retournes dans la reponse (defaut: tous sauf faceDescriptor)
+  publicFields: ['name', 'photo', 'email'],
+
+  // Optionnel: verifier l'authentification
+  checkAuth: async (req) => {
+    const token = req.headers.get('Authorization')
+    if (!token) return Response.json({ error: 'Unauthorized' }, { status: 401 })
+    return null // OK
+  },
+
+  // Optionnel: desactiver la feature
+  isEnabled: async () => {
+    const settings = await getAppSettings()
+    return settings.faceRecognitionEnabled
+  },
+})
+```
+
+**Requete :**
+```json
+POST /api/face/recognize
+{ "faceDescriptor": [0.023, -0.114, 0.087, ...] }
+```
+
+**Reponse (match) :**
+```json
+{
+  "data": {
+    "match": true,
+    "distance": 0.312,
+    "candidate": { "id": "abc123", "name": "Alice", "photo": "/photos/alice.jpg" }
+  }
+}
+```
+
+**Reponse (pas de match) :**
+```json
+{
+  "data": { "match": false, "distance": 0.782 }
 }
 ```
 
-### 3. React hooks
+### POST /api/face/detect (placeholder)
+
+```typescript
+// src/app/api/face/detect/route.ts
+import { createDetectHandler } from '@mostajs/face/api/detect.route'
+
+export const { POST } = createDetectHandler({
+  checkAuth: async (req) => { /* ... */ return null },
+  isEnabled: async () => true,
+})
+```
+
+> La detection se fait cote client via face-api.js. Cette route sert de point d'entree pour le controle d'acces et un futur traitement serveur.
+
+---
+
+## React Hooks
+
+### useCamera
 
 ```tsx
 import { useCamera } from '@mostajs/face/hooks/useCamera'
+
+function CameraView() {
+  const { videoRef, streaming, start, stop, capture } = useCamera()
+
+  return (
+    <div>
+      <video ref={videoRef} autoPlay playsInline muted />
+      {!streaming
+        ? <button onClick={start}>Demarrer</button>
+        : <button onClick={() => capture(canvas)}>Capturer</button>
+      }
+    </div>
+  )
+}
+```
+
+### useFaceDetection
+
+```tsx
 import { useFaceDetection } from '@mostajs/face/hooks/useFaceDetection'
 
-function FaceCapture() {
-  const { videoRef, start, stop } = useCamera()
-  const { detection, descriptor } = useFaceDetection(videoRef)
-  // ...
+function LiveDetection({ videoRef }) {
+  const { faceDetected, detection, descriptor } = useFaceDetection(videoRef, {
+    scoreThreshold: 0.5,
+    inputSize: 320,
+  })
+
+  return <span>{faceDetected ? 'Visage detecte' : 'Aucun visage'}</span>
+}
+```
+
+---
+
+## Integration complete
+
+Exemple complet d'integration dans une nouvelle app Next.js.
+
+### Etape 1 — Installer
+
+```bash
+npm install @mostajs/face
+```
+
+### Etape 2 — Copier les modeles
+
+```bash
+mkdir -p public/models/face-api
+cp node_modules/@vladmandic/face-api/model/tiny_face_detector_model-* public/models/face-api/
+cp node_modules/@vladmandic/face-api/model/face_landmark_68_model-* public/models/face-api/
+cp node_modules/@vladmandic/face-api/model/face_recognition_model-* public/models/face-api/
+```
+
+### Etape 3 — Route API recognize
+
+```typescript
+// src/app/api/face/recognize/route.ts
+import { createRecognizeHandler } from '@mostajs/face/api/recognize.route'
+import prisma from '@/lib/prisma' // ou tout ORM
+
+export const { POST } = createRecognizeHandler({
+  getCandidates: async () => {
+    const users = await prisma.user.findMany({
+      where: { faceDescriptor: { not: null } },
+      select: { id: true, name: true, photo: true, faceDescriptor: true },
+    })
+    return users.map(u => ({
+      ...u,
+      faceDescriptor: u.faceDescriptor as number[],
+    }))
+  },
+  getThreshold: async () => 0.6,
+  publicFields: ['name', 'photo'],
+})
+```
+
+### Etape 4 — Composant React
+
+```tsx
+'use client'
+import { useState, useRef, useEffect, useCallback } from 'react'
+import { useCamera } from '@mostajs/face/hooks/useCamera'
+
+export default function FaceSearch() {
+  const { videoRef, streaming, start, stop } = useCamera()
+  const [result, setResult] = useState(null)
+  const faceApiRef = useRef(null)
+
+  useEffect(() => {
+    import('@mostajs/face').then(mod => {
+      mod.loadModels('/models/face-api')
+      faceApiRef.current = mod
+    })
+  }, [])
+
+  const recognize = useCallback(async () => {
+    if (!faceApiRef.current || !videoRef.current) return
+    const descriptor = await faceApiRef.current.extractDescriptor(videoRef.current)
+    if (!descriptor) { alert('Aucun visage'); return }
+
+    const res = await fetch('/api/face/recognize', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ faceDescriptor: Array.from(descriptor) }),
+    })
+    const json = await res.json()
+    setResult(json.data)
+  }, [videoRef])
+
+  return (
+    <div>
+      <video ref={videoRef} autoPlay playsInline muted />
+      {!streaming
+        ? <button onClick={start}>Camera</button>
+        : <button onClick={recognize}>Rechercher</button>
+      }
+      {result?.match && <p>Trouve: {result.candidate.name}</p>}
+    </div>
+  )
 }
 ```
 
+### Etape 5 — Verification locale
+
+```bash
+# Demarrer l'app
+npm run dev
+
+# Tester l'API
+curl -X POST http://localhost:3000/api/face/recognize \
+  -H 'Content-Type: application/json' \
+  -d '{"faceDescriptor": [0.1, 0.2, ...]}'
+```
+
+---
+
 ## API Reference
 
+### Core (client-side)
+
+| Export | Description |
+|--------|-------------|
+| `loadModels(path)` | Charger les modeles face-api.js |
+| `isLoaded()` | Verifier si les modeles sont charges |
+| `detectFace(input)` | Detecter un visage avec landmarks |
+| `detectAllFaces(input)` | Detecter tous les visages |
+| `extractDescriptor(input)` | Extraire un descripteur 128-dim |
+
+### Matching (client ou serveur)
+
+| Export | Description |
+|--------|-------------|
+| `compareFaces(d1, d2)` | Distance euclidienne entre 2 descripteurs |
+| `findMatch(descriptor, candidates, threshold)` | Meilleur match sous le seuil |
+| `findAllMatches(descriptor, candidates, threshold)` | Tous les matchs sous le seuil |
+
+### Utils
+
 | Export | Description |
 |--------|-------------|
-| `loadModels(path)` | Load face-api.js models |
-| `detectFace(input)` | Detect single face with landmarks |
-| `detectAllFaces(input)` | Detect all faces |
-| `extractDescriptor(input)` | Extract 128-dim face descriptor |
-| `compareFaces(d1, d2)` | Euclidean distance between descriptors |
-| `findMatch(descriptor, known, threshold)` | Find best match |
-| `findAllMatches(descriptor, known, threshold)` | Find all matches |
-| `useCamera()` | Camera management hook |
-| `useFaceDetection()` | Continuous detection hook |
+| `descriptorToArray(Float32Array)` | Convertir en `number[]` |
+| `arrayToDescriptor(number[])` | Convertir en `Float32Array` |
+| `isValidDescriptor(value)` | Verifier (128 nombres) |
+| `drawDetection(canvas, detection, w, h)` | Dessiner le cadre de detection |
+
+### Route Factories (serveur)
+
+| Export | Description |
+|--------|-------------|
+| `createRecognizeHandler(config)` | Factory POST recognize avec matching 1:N |
+| `createDetectHandler(config?)` | Factory POST detect (placeholder) |
+
+### React Hooks
+
+| Export | Description |
+|--------|-------------|
+| `useCamera()` | Gestion camera (start/stop/capture) |
+| `useFaceDetection(videoRef, config?)` | Detection continue en temps reel |
+
+### Types
+
+| Type | Description |
+|------|-------------|
+| `MostaFaceConfig` | Configuration (modelsPath, thresholds, inputSize) |
+| `FaceDetectionResult` | Resultat detection (score, box) |
+| `FaceMatchResult<T>` | Resultat matching (match, distance) |
+| `FaceDescriptor` | `Float32Array \| number[]` |
+| `FaceCandidate` | Interface candidat (id, faceDescriptor, ...) |
+| `RecognizeHandlerConfig` | Config de `createRecognizeHandler` |
+| `DetectHandlerConfig` | Config de `createDetectHandler` |
+
+---
+
+## Architecture
+
+```
+@mostajs/face (100% standalone)
+├── lib/
+│   ├── face-api.ts         # Chargement modeles, detection, extraction
+│   ├── face-matcher.ts     # Comparaison, findMatch, findAllMatches
+│   └── face-utils.ts       # Dessin, conversion descripteurs
+├── api/
+│   ├── recognize.route.ts  # Factory POST /api/face/recognize
+│   └── detect.route.ts     # Factory POST /api/face/detect
+├── hooks/
+│   ├── useCamera.ts        # Hook gestion camera
+│   └── useFaceDetection.ts # Hook detection temps reel
+├── types/
+│   └── index.ts            # Types exports
+└── index.ts                # Barrel exports
+
+Dependances:
+  @vladmandic/face-api  (seule dep runtime)
+  react >= 18           (peer dependency)
+
+Zero dependance sur: @mostajs/orm, @mostajs/auth, @mostajs/settings
+```
+
+### Pattern Factory
+
+Le meme pattern que `@mostajs/setup` : le package exporte des factories, l'app injecte ses dependances :
+
+```
+┌─────────────────────┐     inject callbacks      ┌──────────────────────┐
+│   @mostajs/face     │ ◄──────────────────────── │   Votre app          │
+│                     │                            │                      │
+│ createRecognizeHandler({                         │ getCandidates: () => │
+│   getCandidates,    │                            │   db.query(...)      │
+│   checkAuth,        │                            │ checkAuth: () =>     │
+│   getThreshold,     │                            │   verifyToken(...)   │
+│ })                  │                            │                      │
+└─────────────────────┘                            └──────────────────────┘
+```
+
+
+                                                                             
+  Résultat
+                                                                                    
+  Ce qui a été migré dans @mostajs/face v1.1.0
+                                                                                    
+  ┌────────────────────────┬─────────────────────────────────────────────────────┐
+  │        Fichier         │                     Description                     │
+  ├────────────────────────┼─────────────────────────────────────────────────────┤
+  │ api/recognize.route.ts │ Factory createRecognizeHandler() — matching 1:N     │
+  │                        │ avec callbacks injectés                             │
+  ├────────────────────────┼─────────────────────────────────────────────────────┤
+  │ api/detect.route.ts    │ Factory createDetectHandler() — placeholder avec    │
+  │                        │ auth/enable                                         │
+  ├────────────────────────┼─────────────────────────────────────────────────────┤
+  │ index.ts               │ +4 exports (2 factories + 2 types)                  │
+  ├────────────────────────┼─────────────────────────────────────────────────────┤
+  │ package.json           │ v1.1.0, subpath exports ./api/*, ./lib/*, ./types   │
+  ├────────────────────────┼─────────────────────────────────────────────────────┤
+  │ README.md              │ Tutoriel complet avec intégration nouvelle app      │
+  └────────────────────────┴─────────────────────────────────────────────────────┘
+
+  Routes app simplifiées
+
+  - src/app/api/face/recognize/route.ts : 101 lignes → 30 lignes (injection de
+  getCandidates, checkAuth, getThreshold, publicFields)
+  - src/app/api/face/detect/route.ts : 30 lignes → 15 lignes
+
+  Ce qui reste dans l'app (non migré)
+
+  - src/app/api/scan/route.ts — Scanning de tickets (QR, quotas, réentrée). Pas lié
+  à face, relève d'un futur @mostajs/ticketing
+  - src/components/clients/FaceDetector.tsx — Composant UI trop couplé (shadcn,
+  sonner, settings). Les hooks useCamera/useFaceDetection du package couvrent la
+  partie réutilisable
+
+
+---
 
 ## License
 
-MIT — © 2025 Dr Hamid MADANI <drmdh@msn.com>
+MIT — Dr Hamid MADANI <drmdh@msn.com>

package/dist/api/detect.route.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Configuration for the detect handler.
+ */
+export interface DetectHandlerConfig {
+    /** Check auth/permission — return null if OK, or a Response to deny */
+    checkAuth?: (req: Request) => Promise<Response | null>;
+    /** Check if face recognition is enabled (default: always true) */
+    isEnabled?: () => Promise<boolean>;
+}
+/**
+ * Factory for POST /api/face/detect
+ *
+ * Placeholder endpoint — face detection runs client-side via face-api.js.
+ * This route exists for permission gating and future server-side detection.
+ *
+ * @example
+ * ```ts
+ * import { createDetectHandler } from '@mostajs/face/api/detect.route'
+ * export const { POST } = createDetectHandler()
+ * ```
+ */
+export declare function createDetectHandler(config?: DetectHandlerConfig): {
+    POST: (req: Request) => Promise<Response>;
+};

package/dist/api/detect.route.js

@@ -0,0 +1,39 @@
+"use strict";
+// @mosta/face — Detect API route factory (placeholder)
+// Author: Dr Hamid MADANI drmdh@msn.com
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDetectHandler = createDetectHandler;
+/**
+ * Factory for POST /api/face/detect
+ *
+ * Placeholder endpoint — face detection runs client-side via face-api.js.
+ * This route exists for permission gating and future server-side detection.
+ *
+ * @example
+ * ```ts
+ * import { createDetectHandler } from '@mostajs/face/api/detect.route'
+ * export const { POST } = createDetectHandler()
+ * ```
+ */
+function createDetectHandler(config = {}) {
+    async function POST(req) {
+        if (config.isEnabled) {
+            const enabled = await config.isEnabled();
+            if (!enabled) {
+                return Response.json({ error: { code: 'FEATURE_DISABLED', message: 'Face recognition is disabled' } }, { status: 403 });
+            }
+        }
+        if (config.checkAuth) {
+            const denied = await config.checkAuth(req);
+            if (denied)
+                return denied;
+        }
+        return Response.json({
+            data: {
+                message: 'Face detection runs client-side. Use the FaceDetector component or useFaceDetection hook.',
+                hint: 'For recognition, send the descriptor to POST /api/face/recognize',
+            },
+        });
+    }
+    return { POST };
+}

package/dist/api/recognize.route.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Candidate shape: must have an id, faceDescriptor, and any extra fields.
+ */
+export interface FaceCandidate {
+    id: string;
+    faceDescriptor: number[];
+    [key: string]: unknown;
+}
+/**
+ * Configuration for the recognize handler.
+ */
+export interface RecognizeHandlerConfig {
+    /** Fetch all active candidates with a faceDescriptor from the database */
+    getCandidates: () => Promise<FaceCandidate[]>;
+    /** Check auth/permission — return null if OK, or a Response to deny */
+    checkAuth?: (req: Request) => Promise<Response | null>;
+    /** Get the matching distance threshold (default: 0.6) */
+    getThreshold?: () => Promise<number>;
+    /** Check if face recognition is enabled (default: always true) */
+    isEnabled?: () => Promise<boolean>;
+    /** Fields to return from the matched candidate (default: all except faceDescriptor) */
+    publicFields?: string[];
+}
+/**
+ * Factory for POST /api/face/recognize
+ *
+ * Receives a 128-float face descriptor, searches candidates, returns best match.
+ *
+ * @example
+ * ```ts
+ * // app route: src/app/api/face/recognize/route.ts
+ * import { createRecognizeHandler } from '@mostajs/face/api/recognize.route'
+ * import { clientRepo } from '@/dal/service'
+ *
+ * export const { POST } = createRecognizeHandler({
+ *   getCandidates: async () => {
+ *     const repo = await clientRepo()
+ *     return repo.findAll(
+ *       { faceDescriptor: { $exists: true, $not: { $size: 0 } }, status: 'active' },
+ *       { select: ['firstName', 'lastName', 'clientNumber', 'photo', 'faceDescriptor'] },
+ *     )
+ *   },
+ *   getThreshold: async () => 0.6,
+ * })
+ * ```
+ */
+export declare function createRecognizeHandler(config: RecognizeHandlerConfig): {
+    POST: (req: Request) => Promise<Response>;
+};

package/dist/api/recognize.route.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRecognizeHandler = createRecognizeHandler;
+// @mosta/face — Recognize API route factory
+// Author: Dr Hamid MADANI drmdh@msn.com
+const face_matcher_1 = require("../lib/face-matcher");
+/**
+ * Factory for POST /api/face/recognize
+ *
+ * Receives a 128-float face descriptor, searches candidates, returns best match.
+ *
+ * @example
+ * ```ts
+ * // app route: src/app/api/face/recognize/route.ts
+ * import { createRecognizeHandler } from '@mostajs/face/api/recognize.route'
+ * import { clientRepo } from '@/dal/service'
+ *
+ * export const { POST } = createRecognizeHandler({
+ *   getCandidates: async () => {
+ *     const repo = await clientRepo()
+ *     return repo.findAll(
+ *       { faceDescriptor: { $exists: true, $not: { $size: 0 } }, status: 'active' },
+ *       { select: ['firstName', 'lastName', 'clientNumber', 'photo', 'faceDescriptor'] },
+ *     )
+ *   },
+ *   getThreshold: async () => 0.6,
+ * })
+ * ```
+ */
+function createRecognizeHandler(config) {
+    async function POST(req) {
+        // Check if enabled
+        if (config.isEnabled) {
+            const enabled = await config.isEnabled();
+            if (!enabled) {
+                return Response.json({ error: { code: 'FEATURE_DISABLED', message: 'Face recognition is disabled' } }, { status: 403 });
+            }
+        }
+        // Check auth
+        if (config.checkAuth) {
+            const denied = await config.checkAuth(req);
+            if (denied)
+                return denied;
+        }
+        // Parse body
+        let body;
+        try {
+            body = await req.json();
+        }
+        catch {
+            return Response.json({ error: { code: 'VALIDATION_ERROR', message: 'Invalid JSON' } }, { status: 400 });
+        }
+        // Validate descriptor
+        const desc = body.faceDescriptor;
+        if (!Array.isArray(desc) ||
+            desc.length !== 128 ||
+            !desc.every((v) => typeof v === 'number')) {
+            return Response.json({ error: { code: 'VALIDATION_ERROR', message: 'faceDescriptor must be an array of 128 numbers' } }, { status: 400 });
+        }
+        // Get candidates
+        const candidates = await config.getCandidates();
+        if (candidates.length === 0) {
+            return Response.json({
+                data: { match: false, message: 'No candidates with face data' },
+            });
+        }
+        // Find match
+        const threshold = config.getThreshold ? await config.getThreshold() : 0.6;
+        const result = (0, face_matcher_1.findMatch)(desc, candidates, threshold);
+        if (result) {
+            // Strip faceDescriptor from response
+            const { faceDescriptor: _fd, ...publicData } = result.match;
+            const filtered = config.publicFields
+                ? Object.fromEntries(Object.entries(publicData).filter(([k]) => config.publicFields.includes(k) || k === 'id'))
+                : publicData;
+            return Response.json({
+                data: {
+                    match: true,
+                    distance: Math.round(result.distance * 1000) / 1000,
+                    candidate: filtered,
+                },
+            });
+        }
+        // No match — still report best distance for debugging
+        let bestDistance = null;
+        for (const c of candidates) {
+            if (!c.faceDescriptor || c.faceDescriptor.length !== 128)
+                continue;
+            let sum = 0;
+            for (let i = 0; i < 128; i++) {
+                const diff = desc[i] - c.faceDescriptor[i];
+                sum += diff * diff;
+            }
+            const d = Math.sqrt(sum);
+            if (bestDistance === null || d < bestDistance)
+                bestDistance = d;
+        }
+        return Response.json({
+            data: {
+                match: false,
+                distance: bestDistance !== null ? Math.round(bestDistance * 1000) / 1000 : null,
+            },
+        });
+    }
+    return { POST };
+}

package/dist/index.d.ts

@@ -3,4 +3,8 @@ export { compareFaces, findMatch, findAllMatches } from './lib/face-matcher';
 export { descriptorToArray, arrayToDescriptor, isValidDescriptor, drawDetection } from './lib/face-utils';
 export { useCamera } from './hooks/useCamera';
 export { useFaceDetection } from './hooks/useFaceDetection';
+export { createRecognizeHandler } from './api/recognize.route';
+export { createDetectHandler } from './api/detect.route';
 export type { MostaFaceConfig, FaceDetectionResult, FaceMatchResult, FaceDescriptor } from './types';
+export type { FaceCandidate, RecognizeHandlerConfig } from './api/recognize.route';
+export type { DetectHandlerConfig } from './api/detect.route';

package/dist/index.js

@@ -2,7 +2,7 @@
 // @mosta/face — Barrel exports
 // Author: Dr Hamid MADANI drmdh@msn.com
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useFaceDetection = exports.useCamera = exports.drawDetection = exports.isValidDescriptor = exports.arrayToDescriptor = exports.descriptorToArray = exports.findAllMatches = exports.findMatch = exports.compareFaces = exports.extractDescriptor = exports.detectAllFaces = exports.detectFace = exports.isLoaded = exports.loadModels = void 0;
+exports.createDetectHandler = exports.createRecognizeHandler = exports.useFaceDetection = exports.useCamera = exports.drawDetection = exports.isValidDescriptor = exports.arrayToDescriptor = exports.descriptorToArray = exports.findAllMatches = exports.findMatch = exports.compareFaces = exports.extractDescriptor = exports.detectAllFaces = exports.detectFace = exports.isLoaded = exports.loadModels = void 0;
 // Core face-api service
 var face_api_1 = require("./lib/face-api");
 Object.defineProperty(exports, "loadModels", { enumerable: true, get: function () { return face_api_1.loadModels; } });
@@ -26,3 +26,8 @@ var useCamera_1 = require("./hooks/useCamera");
 Object.defineProperty(exports, "useCamera", { enumerable: true, get: function () { return useCamera_1.useCamera; } });
 var useFaceDetection_1 = require("./hooks/useFaceDetection");
 Object.defineProperty(exports, "useFaceDetection", { enumerable: true, get: function () { return useFaceDetection_1.useFaceDetection; } });
+// API route factories
+var recognize_route_1 = require("./api/recognize.route");
+Object.defineProperty(exports, "createRecognizeHandler", { enumerable: true, get: function () { return recognize_route_1.createRecognizeHandler; } });
+var detect_route_1 = require("./api/detect.route");
+Object.defineProperty(exports, "createDetectHandler", { enumerable: true, get: function () { return detect_route_1.createDetectHandler; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mostajs/face",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Reusable face recognition module — detection, descriptor extraction, 1:N matching",
   "author": "Dr Hamid MADANI <drmdh@msn.com>",
   "license": "MIT",
@@ -24,6 +24,21 @@
       "import": "./dist/hooks/useFaceDetection.js",
       "require": "./dist/hooks/useFaceDetection.js",
       "default": "./dist/hooks/useFaceDetection.js"
+    },
+    "./lib/*": {
+      "types": "./dist/lib/*.d.ts",
+      "import": "./dist/lib/*.js",
+      "default": "./dist/lib/*.js"
+    },
+    "./api/*": {
+      "types": "./dist/api/*.d.ts",
+      "import": "./dist/api/*.js",
+      "default": "./dist/api/*.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js",
+      "default": "./dist/types/index.js"
     }
   },
   "files": ["dist", "LICENSE", "README.md"],