facecog-liveness-showcase 0.0.1

package/projects/facecog-liveness-verification/src/lib/services/verification-api.service.spec.ts

@@ -0,0 +1,159 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+import { VerificationApiService } from './verification-api.service';
+import { LIVENESS_VERIFICATION_CONFIG } from '../models/constants/liveness-verification-config.token';
+
+describe('VerificationApiService', () => {
+  let service: VerificationApiService;
+  let httpMock: HttpTestingController;
+
+  describe('without config', () => {
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        imports: [HttpClientTestingModule],
+        providers: [VerificationApiService]
+      });
+      service = TestBed.inject(VerificationApiService);
+      httpMock = TestBed.inject(HttpTestingController);
+    });
+
+    afterEach(() => httpMock.verify());
+
+    it('should be created', () => {
+      expect(service).toBeTruthy();
+    });
+
+    it('uses default baseUrl', () => {
+      service.startSession({ plan: [{ kind: 'gesture', pose: 'smile' }] } as any).subscribe();
+      const req = httpMock.expectOne('http://localhost:3002/verification/session/start');
+      expect(req.request.method).toBe('POST');
+      req.flush({ sessionId: 's1', plan: [] });
+    });
+
+    it('startSession sends POST', () => {
+      const body = { plan: [{ kind: 'gesture', pose: 'smile' }] } as any;
+      service.startSession(body).subscribe(res => {
+        expect(res.sessionId).toBe('s1');
+      });
+      const req = httpMock.expectOne('http://localhost:3002/verification/session/start');
+      expect(req.request.body).toEqual(body);
+      req.flush({ sessionId: 's1', plan: [] });
+    });
+
+    it('startSession handles error', () => {
+      service.startSession({ plan: [] } as any).subscribe({
+        error: (e) => expect(e.status).toBe(500)
+      });
+      httpMock.expectOne('http://localhost:3002/verification/session/start')
+        .flush('Error', { status: 500, statusText: 'Server Error' });
+    });
+
+    it('verifyGestures sends POST', () => {
+      service.verifyGestures({ sessionId: 's1', frames: ['f1'], poseId: 1 } as any).subscribe(res => {
+        expect(res).toBeDefined();
+      });
+      const req = httpMock.expectOne('http://localhost:3002/verification/gestures');
+      expect(req.request.method).toBe('POST');
+      req.flush({ success: true });
+    });
+
+    it('verifyFaceTec sends POST', () => {
+      service.verifyFaceTec({ sessionId: 's1', faceScan: 'data' } as any).subscribe(res => {
+        expect(res).toBeDefined();
+      });
+      const req = httpMock.expectOne('http://localhost:3002/verification/facetec');
+      expect(req.request.method).toBe('POST');
+      req.flush({ success: true });
+    });
+
+    it('finalize sends POST', () => {
+      service.finalize('s1').subscribe(res => {
+        expect(res).toBeDefined();
+      });
+      const req = httpMock.expectOne('http://localhost:3002/verification/finalize');
+      expect(req.request.body).toEqual({ sessionId: 's1' });
+      req.flush({ success: true });
+    });
+
+    it('getSession sends GET', () => {
+      service.getSession('s1').subscribe(res => {
+        expect(res).toBeDefined();
+      });
+      const req = httpMock.expectOne('http://localhost:3002/verification/session/s1');
+      expect(req.request.method).toBe('GET');
+      req.flush({ sessionId: 's1' });
+    });
+
+    it('deleteSession sends DELETE', () => {
+      service.deleteSession('s1').subscribe(res => {
+        expect(res.success).toBe(true);
+      });
+      const req = httpMock.expectOne('http://localhost:3002/verification/session/s1');
+      expect(req.request.method).toBe('DELETE');
+      req.flush({ success: true });
+    });
+
+    it('verifyGestures handles error', () => {
+      service.verifyGestures({ sessionId: 's1', frames: ['f1'] } as any).subscribe({
+        error: (e) => expect(e.status).toBe(400)
+      });
+      httpMock.expectOne('http://localhost:3002/verification/gestures')
+        .flush('Bad', { status: 400, statusText: 'Bad Request' });
+    });
+
+    it('verifyFaceTec handles error', () => {
+      service.verifyFaceTec({ sessionId: 's1' } as any).subscribe({
+        error: (e) => expect(e.status).toBe(500)
+      });
+      httpMock.expectOne('http://localhost:3002/verification/facetec')
+        .flush('Error', { status: 500, statusText: 'Server Error' });
+    });
+
+    it('finalize handles error', () => {
+      service.finalize('s1').subscribe({
+        error: (e) => expect(e.status).toBe(404)
+      });
+      httpMock.expectOne('http://localhost:3002/verification/finalize')
+        .flush('Not found', { status: 404, statusText: 'Not Found' });
+    });
+
+    it('getSession handles error', () => {
+      service.getSession('s1').subscribe({
+        error: (e) => expect(e.status).toBe(403)
+      });
+      httpMock.expectOne('http://localhost:3002/verification/session/s1')
+        .flush('Forbidden', { status: 403, statusText: 'Forbidden' });
+    });
+
+    it('deleteSession handles error', () => {
+      service.deleteSession('s1').subscribe({
+        error: (e) => expect(e.status).toBe(500)
+      });
+      httpMock.expectOne('http://localhost:3002/verification/session/s1')
+        .flush('Error', { status: 500, statusText: 'Server Error' });
+    });
+  });
+
+  describe('with config', () => {
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        imports: [HttpClientTestingModule],
+        providers: [
+          VerificationApiService,
+          { provide: LIVENESS_VERIFICATION_CONFIG, useValue: { apiUrl: 'https://api.example.com' } }
+        ]
+      });
+      service = TestBed.inject(VerificationApiService);
+      httpMock = TestBed.inject(HttpTestingController);
+    });
+
+    afterEach(() => httpMock.verify());
+
+    it('uses configured baseUrl', () => {
+      service.startSession({ plan: [] } as any).subscribe();
+      const req = httpMock.expectOne('https://api.example.com/verification/session/start');
+      expect(req.request.method).toBe('POST');
+      req.flush({ sessionId: 's1', plan: [] });
+    });
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/verification-api.service.ts

@@ -0,0 +1,151 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable, throwError } from 'rxjs';
+import { catchError, tap } from 'rxjs/operators';
+import { LIVENESS_VERIFICATION_CONFIG } from '../models/constants/liveness-verification-config.token';
+import type { LivenessVerificationConfig } from '../interfaces/liveness-verification-config.interface';
+import type {
+  VerificationSessionStartRequest,
+  VerificationSessionStartResponse,
+  VerifyGesturesRequest,
+  VerifyGesturesResponse,
+  VerifyFaceTecRequest,
+  VerifyFaceTecResponse,
+  VerifyFinalizeResponse
+} from '../interfaces/verification-session.interface';
+
+const API_VERBOSE = true;
+
+function apiLog(method: string, message: string, data?: unknown): void {
+  if (!API_VERBOSE) return;
+  if (data !== undefined) {
+    console.log(`%c[VerificationAPI:${method}] ${message}`, 'color: #ff9800; font-weight: bold', data);
+  } else {
+    console.log(`%c[VerificationAPI:${method}] ${message}`, 'color: #ff9800; font-weight: bold');
+  }
+}
+
+function apiError(method: string, message: string, data?: unknown): void {
+  console.error(`[VerificationAPI:${method}] ${message}`, data ?? '');
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class VerificationApiService {
+  private baseUrl: string;
+  private apiPath = '/verification';
+
+  constructor(
+    private http: HttpClient,
+    @Optional() @Inject(LIVENESS_VERIFICATION_CONFIG) config?: LivenessVerificationConfig | null
+  ) {
+    this.baseUrl = config?.apiUrl || 'http://localhost:3002';
+    apiLog('constructor', `Initialized with baseUrl: ${this.baseUrl}`);
+    apiLog('constructor', `Full config:`, {
+      apiUrl: config?.apiUrl,
+      backends: config?.backends,
+      hasConfig: !!config,
+    });
+  }
+
+  startSession(request: VerificationSessionStartRequest): Observable<VerificationSessionStartResponse> {
+    const url = `${this.baseUrl}${this.apiPath}/session/start`;
+    apiLog('startSession', `POST ${url}`, request);
+    return this.http.post<VerificationSessionStartResponse>(url, request).pipe(
+      tap(response => apiLog('startSession', 'Success response:', response)),
+      catchError(e => {
+        apiError('startSession', `FAILED: ${e?.status} ${e?.statusText}`, {
+          url,
+          status: e?.status,
+          statusText: e?.statusText,
+          message: e?.message,
+          error: e?.error,
+          fullError: e,
+        });
+        return throwError(() => e);
+      })
+    );
+  }
+
+  verifyGestures(request: VerifyGesturesRequest): Observable<VerifyGesturesResponse> {
+    const url = `${this.baseUrl}${this.apiPath}/gestures`;
+    apiLog('verifyGestures', `POST ${url}`, { sessionId: request.sessionId, stepIndex: request.stepIndex, pose: request.pose, frameCount: request.frames?.length });
+    return this.http.post<VerifyGesturesResponse>(url, request).pipe(
+      tap(response => apiLog('verifyGestures', 'Success response:', response)),
+      catchError(e => {
+        apiError('verifyGestures', `FAILED: ${e?.status} ${e?.statusText}`, {
+          url,
+          status: e?.status,
+          statusText: e?.statusText,
+          message: e?.message,
+          error: e?.error,
+          fullError: e,
+        });
+        return throwError(() => e);
+      })
+    );
+  }
+
+  verifyFaceTec(request: VerifyFaceTecRequest): Observable<VerifyFaceTecResponse> {
+    const url = `${this.baseUrl}${this.apiPath}/facetec`;
+    apiLog('verifyFaceTec', `POST ${url}`, { sessionId: request.sessionId, stepIndex: request.stepIndex });
+    return this.http.post<VerifyFaceTecResponse>(url, request).pipe(
+      tap(response => apiLog('verifyFaceTec', 'Success response:', response)),
+      catchError(e => {
+        apiError('verifyFaceTec', `FAILED: ${e?.status} ${e?.statusText}`, {
+          url,
+          status: e?.status,
+          statusText: e?.statusText,
+          message: e?.message,
+          error: e?.error,
+          fullError: e,
+        });
+        return throwError(() => e);
+      })
+    );
+  }
+
+  finalize(sessionId: string): Observable<VerifyFinalizeResponse> {
+    const url = `${this.baseUrl}${this.apiPath}/finalize`;
+    apiLog('finalize', `POST ${url}`, { sessionId });
+    return this.http.post<VerifyFinalizeResponse>(url, { sessionId }).pipe(
+      tap(response => apiLog('finalize', 'Success response:', response)),
+      catchError(e => {
+        apiError('finalize', `FAILED: ${e?.status} ${e?.statusText}`, {
+          url,
+          status: e?.status,
+          statusText: e?.statusText,
+          message: e?.message,
+          error: e?.error,
+          fullError: e,
+        });
+        return throwError(() => e);
+      })
+    );
+  }
+
+  getSession(sessionId: string): Observable<unknown> {
+    const url = `${this.baseUrl}${this.apiPath}/session/${sessionId}`;
+    apiLog('getSession', `GET ${url}`);
+    return this.http.get<unknown>(url).pipe(
+      tap(response => apiLog('getSession', 'Success response:', response)),
+      catchError(e => {
+        apiError('getSession', `FAILED: ${e?.status} ${e?.statusText}`, e);
+        return throwError(() => e);
+      })
+    );
+  }
+
+  deleteSession(sessionId: string): Observable<{ success: boolean }> {
+    const url = `${this.baseUrl}${this.apiPath}/session/${sessionId}`;
+    apiLog('deleteSession', `DELETE ${url}`);
+    return this.http.delete<{ success: boolean }>(url).pipe(
+      tap(response => apiLog('deleteSession', 'Success response:', response)),
+      catchError(e => {
+        apiError('deleteSession', `FAILED: ${e?.status} ${e?.statusText}`, e);
+        return throwError(() => e);
+      })
+    );
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/verification-plan.service.spec.ts

@@ -0,0 +1,184 @@
+import { TestBed } from '@angular/core/testing';
+import { VerificationPlanService } from './verification-plan.service';
+
+describe('VerificationPlanService', () => {
+  let service: VerificationPlanService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({ providers: [VerificationPlanService] });
+    service = TestBed.inject(VerificationPlanService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('initial state is empty', () => {
+    expect(service.getPlanValue()).toEqual([]);
+    expect(service.getCurrentStepIndexValue()).toBe(0);
+    expect(service.getSessionIdValue()).toBeNull();
+    expect(service.getFrameHashValue()).toBeNull();
+    expect(service.getTotalSteps()).toBe(0);
+    expect(service.getProgress()).toBe(0);
+    expect(service.isComplete()).toBe(true);
+  });
+
+  it('initializePlan sets plan and resets state', () => {
+    const plan = [
+      { kind: 'gesture' as const, pose: 'smile' },
+      { kind: 'gesture' as const, pose: 'nod' },
+    ];
+    service.initializePlan(plan, false);
+    expect(service.getPlanValue().length).toBe(2);
+    expect(service.getCurrentStepIndexValue()).toBe(0);
+    expect(service.getTotalSteps()).toBe(2);
+  });
+
+  it('initializePlan randomizes gesture order', () => {
+    const plan = Array.from({ length: 20 }, (_, i) => ({ kind: 'gesture' as const, pose: `pose${i}` }));
+    service.initializePlan(plan, true);
+    expect(service.getPlanValue().length).toBe(20);
+  });
+
+  it('getCurrentStep returns first step', () => {
+    service.initializePlan([{ kind: 'gesture', pose: 'smile' }], false);
+    const step = service.getCurrentStep();
+    expect(step).toBeDefined();
+    expect(step!.kind).toBe('gesture');
+  });
+
+  it('getCurrentStep returns null for empty plan', () => {
+    expect(service.getCurrentStep()).toBeNull();
+  });
+
+  it('nextStep advances index', () => {
+    service.initializePlan([
+      { kind: 'gesture', pose: 'smile' },
+      { kind: 'gesture', pose: 'nod' },
+    ], false);
+    expect(service.nextStep()).toBe(true);
+    expect(service.getCurrentStepIndexValue()).toBe(1);
+  });
+
+  it('nextStep returns false at end', () => {
+    service.initializePlan([{ kind: 'gesture', pose: 'smile' }], false);
+    expect(service.nextStep()).toBe(false);
+    expect(service.getCurrentStepIndexValue()).toBe(0);
+  });
+
+  it('completeCurrentStep marks step as completed', () => {
+    service.initializePlan([{ kind: 'gesture', pose: 'smile' }], false);
+    service.completeCurrentStep({ success: true });
+    const plan = service.getPlanValue();
+    expect(plan[0].completed).toBe(true);
+    expect(plan[0].result).toEqual({ success: true });
+  });
+
+  it('isComplete returns true when all steps completed', () => {
+    service.initializePlan([{ kind: 'gesture', pose: 'smile' }], false);
+    service.completeCurrentStep({ success: true });
+    expect(service.isComplete()).toBe(true);
+  });
+
+  it('isComplete returns false when steps remain', () => {
+    service.initializePlan([
+      { kind: 'gesture', pose: 'smile' },
+      { kind: 'gesture', pose: 'nod' },
+    ], false);
+    service.completeCurrentStep({ success: true });
+    expect(service.isComplete()).toBe(false);
+  });
+
+  it('getProgress returns correct percentage', () => {
+    service.initializePlan([
+      { kind: 'gesture', pose: 'smile' },
+      { kind: 'gesture', pose: 'nod' },
+    ], false);
+    service.completeCurrentStep({});
+    expect(service.getProgress()).toBe(50);
+  });
+
+  it('setSessionId and getSessionIdValue work', () => {
+    service.setSessionId('s123');
+    expect(service.getSessionIdValue()).toBe('s123');
+  });
+
+  it('setFrameHash and getFrameHashValue work', () => {
+    service.setFrameHash('abc123');
+    expect(service.getFrameHashValue()).toBe('abc123');
+  });
+
+  it('reset clears all state', () => {
+    service.initializePlan([{ kind: 'gesture', pose: 'smile' }], false);
+    service.setSessionId('s1');
+    service.setFrameHash('h1');
+    service.reset();
+    expect(service.getPlanValue()).toEqual([]);
+    expect(service.getSessionIdValue()).toBeNull();
+    expect(service.getFrameHashValue()).toBeNull();
+  });
+
+  it('getGestureStepCount returns gesture count', () => {
+    service.initializePlan([
+      { kind: 'gesture', pose: 'smile' },
+      { kind: 'facetec' },
+      { kind: 'gesture', pose: 'nod' },
+    ], false);
+    expect(service.getGestureStepCount()).toBe(2);
+  });
+
+  it('getFaceTecStepCount returns facetec count', () => {
+    service.initializePlan([
+      { kind: 'gesture', pose: 'smile' },
+      { kind: 'facetec' },
+    ], false);
+    expect(service.getFaceTecStepCount()).toBe(1);
+  });
+
+  it('generateDefaultPlan creates plan with gestures', () => {
+    const plan = service.generateDefaultPlan(['smile', 'nod'], false);
+    expect(plan.length).toBe(2);
+    expect(plan.every(s => s.kind === 'gesture')).toBe(true);
+  });
+
+  it('generateDefaultPlan includes facetec when requested', () => {
+    const plan = service.generateDefaultPlan(['smile', 'nod'], true);
+    expect(plan.length).toBe(3);
+    expect(plan.some(s => s.kind === 'facetec')).toBe(true);
+  });
+
+  it('generateDefaultPlan appends facetec for single pose', () => {
+    const plan = service.generateDefaultPlan(['smile'], true);
+    expect(plan.length).toBe(2);
+    expect(plan[1].kind).toBe('facetec');
+  });
+
+  it('getPlan returns observable', (done) => {
+    service.initializePlan([{ kind: 'gesture', pose: 'smile' }], false);
+    service.getPlan().subscribe(plan => {
+      expect(plan.length).toBe(1);
+      done();
+    });
+  });
+
+  it('getCurrentStepIndex returns observable', (done) => {
+    service.getCurrentStepIndex().subscribe(idx => {
+      expect(idx).toBe(0);
+      done();
+    });
+  });
+
+  it('getSessionId returns observable', (done) => {
+    service.getSessionId().subscribe(id => {
+      expect(id).toBeNull();
+      done();
+    });
+  });
+
+  it('getFrameHash returns observable', (done) => {
+    service.getFrameHash().subscribe(h => {
+      expect(h).toBeNull();
+      done();
+    });
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/verification-plan.service.ts

@@ -0,0 +1,94 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import type { VerificationPlan, VerificationStep } from '../interfaces/verification-plan.interface';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class VerificationPlanService {
+  private plan$ = new BehaviorSubject<VerificationPlan>([]);
+  private currentStepIndex$ = new BehaviorSubject<number>(0);
+  private sessionId$ = new BehaviorSubject<string | null>(null);
+  private frameHash$ = new BehaviorSubject<string | null>(null);
+
+  initializePlan(plan: VerificationPlan, randomizeGestures = true): void {
+    let processedPlan = [...plan];
+    if (randomizeGestures) processedPlan = this.randomizeGestureOrder(processedPlan);
+    this.plan$.next(processedPlan);
+    this.currentStepIndex$.next(0);
+    this.sessionId$.next(null);
+    this.frameHash$.next(null);
+  }
+
+  private randomizeGestureOrder(plan: VerificationPlan): VerificationPlan {
+    const gestureSteps = plan.filter(s => s.kind === 'gesture');
+    for (let i = gestureSteps.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [gestureSteps[i], gestureSteps[j]] = [gestureSteps[j], gestureSteps[i]];
+    }
+    const result: VerificationPlan = [];
+    let gi = 0;
+    for (const s of plan) {
+      result.push(s.kind === 'gesture' ? gestureSteps[gi++] : s);
+    }
+    return result;
+  }
+
+  getPlan(): Observable<VerificationPlan> { return this.plan$.asObservable(); }
+  getPlanValue(): VerificationPlan { return this.plan$.value; }
+  getCurrentStepIndex(): Observable<number> { return this.currentStepIndex$.asObservable(); }
+  getCurrentStepIndexValue(): number { return this.currentStepIndex$.value; }
+  getCurrentStep(): VerificationStep | null {
+    const plan = this.plan$.value;
+    const i = this.currentStepIndex$.value;
+    return plan[i] || null;
+  }
+  nextStep(): boolean {
+    const i = this.currentStepIndex$.value;
+    const plan = this.plan$.value;
+    if (i < plan.length - 1) {
+      this.currentStepIndex$.next(i + 1);
+      return true;
+    }
+    return false;
+  }
+  completeCurrentStep(result: unknown): void {
+    const plan = this.plan$.value;
+    const i = this.currentStepIndex$.value;
+    if (plan[i]) {
+      plan[i].completed = true;
+      plan[i].result = result;
+      this.plan$.next([...plan]);
+    }
+  }
+  isComplete(): boolean { return this.plan$.value.every(s => s.completed === true); }
+  getProgress(): number {
+    const plan = this.plan$.value;
+    if (plan.length === 0) return 0;
+    return Math.round((plan.filter(s => s.completed).length / plan.length) * 100);
+  }
+  getSessionId(): Observable<string | null> { return this.sessionId$.asObservable(); }
+  getSessionIdValue(): string | null { return this.sessionId$.value; }
+  setSessionId(id: string): void { this.sessionId$.next(id); }
+  getFrameHash(): Observable<string | null> { return this.frameHash$.asObservable(); }
+  getFrameHashValue(): string | null { return this.frameHash$.value; }
+  setFrameHash(h: string): void { this.frameHash$.next(h); }
+  reset(): void {
+    this.plan$.next([]);
+    this.currentStepIndex$.next(0);
+    this.sessionId$.next(null);
+    this.frameHash$.next(null);
+  }
+  getTotalSteps(): number { return this.plan$.value.length; }
+  getGestureStepCount(): number { return this.plan$.value.filter(s => s.kind === 'gesture').length; }
+  getFaceTecStepCount(): number { return this.plan$.value.filter(s => s.kind === 'facetec').length; }
+
+  generateDefaultPlan(poses: string[], includeFaceTec = true): VerificationPlan {
+    const plan: VerificationPlan = poses.map(pose => ({ kind: 'gesture', pose }));
+    if (includeFaceTec) {
+      if (poses.length > 1) plan.splice(Math.floor(poses.length / 2), 0, { kind: 'facetec' });
+      else plan.push({ kind: 'facetec' });
+    }
+    return plan;
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/video-recorder.service.spec.ts

@@ -0,0 +1,52 @@
+import { TestBed } from '@angular/core/testing';
+import { VideoRecorderService } from './video-recorder.service';
+
+describe('VideoRecorderService', () => {
+  let service: VideoRecorderService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [VideoRecorderService]
+    });
+    service = TestBed.inject(VideoRecorderService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('isRecording returns false when no recorder', () => {
+    expect(service.isRecording()).toBe(false);
+  });
+
+  it('startRecording initializes MediaRecorder', async () => {
+    const mockStream = new MediaStream();
+    await service.startRecording(mockStream);
+    expect(service.isRecording()).toBe(true);
+  });
+
+  it('stopRecording rejects when no active recording', async () => {
+    await expect(service.stopRecording()).rejects.toThrow('No active recording');
+  });
+
+  it('startRecording and stopRecording returns video recording', async () => {
+    const mockStream = new MediaStream();
+    await service.startRecording(mockStream);
+    const recording = await service.stopRecording();
+    expect(recording).toBeDefined();
+    expect(recording.blob).toBeInstanceOf(Blob);
+    expect(typeof recording.duration).toBe('number');
+    expect(typeof recording.sizeMB).toBe('number');
+  });
+
+  it('cleanup stops recording and clears state', async () => {
+    const mockStream = new MediaStream();
+    await service.startRecording(mockStream);
+    service.cleanup();
+    expect(service.isRecording()).toBe(false);
+  });
+
+  it('cleanup is safe when no recorder', () => {
+    expect(() => service.cleanup()).not.toThrow();
+  });
+});