@moveris/shared 0.0.1

package/README.md

@@ -0,0 +1,25 @@
+# @moveris/shared
+
+Core business logic for Moveris Live SDK. This package contains:
+
+- WebSocket client with reconnection logic
+- Frame buffer management
+- Authentication manager
+- Type definitions
+- Utility functions
+
+## Installation
+
+```bash
+pnpm add @moveris/shared
+```
+
+## Usage
+
+```typescript
+import { WebSocketClient, FrameBuffer, AuthManager } from '@moveris/shared';
+```
+
+## API
+
+See [API Documentation](../../docs/api-reference.md#shared-package) for complete API reference.

package/dist/index.d.mts

@@ -0,0 +1,193 @@
+type MessageType = 'auth_required' | 'auth' | 'auth_success' | 'auth_error' | 'frame' | 'frame_received' | 'processing_complete' | 'error' | 'session_resume';
+interface BaseMessage {
+    type: MessageType;
+    timestamp?: number;
+}
+interface AuthRequiredMessage extends BaseMessage {
+    type: 'auth_required';
+}
+interface AuthMessage extends BaseMessage {
+    type: 'auth';
+    token: string;
+    model_file_name: string;
+}
+interface AuthSuccessMessage extends BaseMessage {
+    type: 'auth_success';
+    request_id: string;
+    last_acked_frame?: number;
+}
+interface AuthErrorMessage extends BaseMessage {
+    type: 'auth_error';
+    error: string;
+    code?: string;
+}
+interface FrameMessage extends BaseMessage {
+    type: 'frame';
+    frame_data: string;
+    frame_number: number;
+}
+interface FrameReceivedMessage extends BaseMessage {
+    type: 'frame_received';
+    frame_number: number;
+}
+interface ProcessingCompleteMessage extends BaseMessage {
+    type: 'processing_complete';
+    request_id: string;
+    prediction: 'real' | 'spoof';
+    confidence: number;
+}
+interface ErrorMessage extends BaseMessage {
+    type: 'error';
+    error: string;
+    code: string;
+}
+interface SessionResumeMessage extends BaseMessage {
+    type: 'session_resume';
+    last_acked_frame: number;
+}
+type WebSocketMessage = AuthRequiredMessage | AuthMessage | AuthSuccessMessage | AuthErrorMessage | FrameMessage | FrameReceivedMessage | ProcessingCompleteMessage | ErrorMessage | SessionResumeMessage;
+
+interface Frame {
+    number: number;
+    data: string;
+    timestamp: number;
+    size: number;
+}
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+interface LivenessResult {
+    prediction: 'real' | 'spoof';
+    confidence: number;
+    requestId: string;
+}
+type OnResultCallback = (result: LivenessResult) => void;
+type OnErrorCallback = (error: Error) => void;
+type OnFrameAckCallback = (frameNumber: number) => void;
+type OnConnectionStateChangeCallback = (state: ConnectionState) => void;
+type OnProgressCallback = (current: number, total: number) => void;
+interface LivenessCallbacks {
+    onResult?: OnResultCallback;
+    onError?: OnErrorCallback;
+    onFrameAck?: OnFrameAckCallback;
+    onConnectionStateChange?: OnConnectionStateChangeCallback;
+    onProgress?: OnProgressCallback;
+}
+
+interface WebSocketClientConfig {
+    url: string;
+    apiKey: string;
+    model: string;
+    onMessage?: (message: WebSocketMessage) => void;
+    onConnectionStateChange?: OnConnectionStateChangeCallback;
+    onError?: (error: Error) => void;
+}
+declare class WebSocketClient {
+    private ws;
+    private connectionManager;
+    private authManager;
+    private config;
+    private state;
+    constructor(config: WebSocketClientConfig);
+    connect(): Promise<void>;
+    disconnect(): void;
+    sendFrame(frameData: string, frameNumber: number): void;
+    getState(): ConnectionState;
+    private setState;
+    private handleMessage;
+    private handleError;
+}
+
+declare class AuthManager {
+    authenticate(ws: WebSocket, apiKey: string, model: string): Promise<string>;
+}
+
+interface ConnectionManagerConfig {
+    onReconnect: () => Promise<void>;
+    maxAttempts?: number;
+}
+declare class ConnectionManager {
+    private config;
+    private reconnectAttempts;
+    constructor(config: ConnectionManagerConfig);
+    handleDisconnect(): Promise<void>;
+    reset(): void;
+}
+
+declare class FrameBuffer {
+    private buffer;
+    private lastAcknowledged;
+    private currentMemoryUsage;
+    private readonly maxSize;
+    private readonly maxMemory;
+    constructor(maxSize?: number, maxMemory?: number);
+    add(frame: Frame): void;
+    acknowledge(frameNumber: number): void;
+    getUnacknowledged(): Frame[];
+    getLastAcknowledged(): number;
+    size(): number;
+    getMemoryUsage(): number;
+    clear(): void;
+    private remove;
+    private flushOldest;
+}
+
+declare class FrameQueue {
+    private queue;
+    enqueue(frame: Frame): void;
+    dequeue(): Frame | undefined;
+    peek(): Frame | undefined;
+    isEmpty(): boolean;
+    size(): number;
+    clear(): void;
+    toArray(): Frame[];
+}
+
+type ModelType = '50-frame' | '250-frame';
+interface ModelConfig {
+    type: ModelType;
+    fileName: string;
+    frameCount: number;
+}
+declare const MODEL_CONFIGS: Record<ModelType, ModelConfig>;
+
+declare const API_ENDPOINTS: {
+    readonly production: "wss://api.moveris.com/v1/liveness";
+    readonly staging: "wss://staging-api.moveris.com/v1/liveness";
+    readonly development: "ws://localhost:8080/v1/liveness";
+};
+declare const DEFAULT_ENDPOINT: "wss://api.moveris.com/v1/liveness";
+declare const RECONNECTION_CONFIG: {
+    readonly maxAttempts: 10;
+    readonly initialDelay: 1000;
+    readonly maxDelay: 30000;
+    readonly backoffMultiplier: 2;
+};
+declare const FRAME_BUFFER_CONFIG: {
+    readonly maxSize: 10;
+    readonly maxMemory: number;
+};
+declare const AUTH_CONFIG: {
+    readonly timeout: 10000;
+    readonly apiKeyPattern: RegExp;
+};
+declare const FRAME_CONFIG: {
+    readonly targetFPS: 30;
+    readonly frameInterval: 33;
+    readonly jpegQuality: 0.8;
+};
+
+declare function validateApiKey(apiKey: string): boolean;
+declare function validateFrameData(data: string): boolean;
+declare function validateFrameNumber(frameNumber: number): boolean;
+
+declare function encodeBase64(buffer: ArrayBuffer | Uint8Array): string;
+declare function decodeBase64(base64: string): Uint8Array;
+
+interface RetryOptions {
+    maxAttempts?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+}
+declare function retryWithBackoff<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+
+export { API_ENDPOINTS, AUTH_CONFIG, type AuthErrorMessage, AuthManager, type AuthMessage, type AuthRequiredMessage, type AuthSuccessMessage, type BaseMessage, ConnectionManager, type ConnectionState, DEFAULT_ENDPOINT, type ErrorMessage, FRAME_BUFFER_CONFIG, FRAME_CONFIG, type Frame, FrameBuffer, type FrameMessage, FrameQueue, type FrameReceivedMessage, type LivenessCallbacks, type LivenessResult, MODEL_CONFIGS, type MessageType, type ModelConfig, type ModelType, type OnConnectionStateChangeCallback, type OnErrorCallback, type OnFrameAckCallback, type OnProgressCallback, type OnResultCallback, type ProcessingCompleteMessage, RECONNECTION_CONFIG, type RetryOptions, type SessionResumeMessage, WebSocketClient, type WebSocketMessage, decodeBase64, encodeBase64, retryWithBackoff, validateApiKey, validateFrameData, validateFrameNumber };

package/dist/index.d.ts

@@ -0,0 +1,193 @@
+type MessageType = 'auth_required' | 'auth' | 'auth_success' | 'auth_error' | 'frame' | 'frame_received' | 'processing_complete' | 'error' | 'session_resume';
+interface BaseMessage {
+    type: MessageType;
+    timestamp?: number;
+}
+interface AuthRequiredMessage extends BaseMessage {
+    type: 'auth_required';
+}
+interface AuthMessage extends BaseMessage {
+    type: 'auth';
+    token: string;
+    model_file_name: string;
+}
+interface AuthSuccessMessage extends BaseMessage {
+    type: 'auth_success';
+    request_id: string;
+    last_acked_frame?: number;
+}
+interface AuthErrorMessage extends BaseMessage {
+    type: 'auth_error';
+    error: string;
+    code?: string;
+}
+interface FrameMessage extends BaseMessage {
+    type: 'frame';
+    frame_data: string;
+    frame_number: number;
+}
+interface FrameReceivedMessage extends BaseMessage {
+    type: 'frame_received';
+    frame_number: number;
+}
+interface ProcessingCompleteMessage extends BaseMessage {
+    type: 'processing_complete';
+    request_id: string;
+    prediction: 'real' | 'spoof';
+    confidence: number;
+}
+interface ErrorMessage extends BaseMessage {
+    type: 'error';
+    error: string;
+    code: string;
+}
+interface SessionResumeMessage extends BaseMessage {
+    type: 'session_resume';
+    last_acked_frame: number;
+}
+type WebSocketMessage = AuthRequiredMessage | AuthMessage | AuthSuccessMessage | AuthErrorMessage | FrameMessage | FrameReceivedMessage | ProcessingCompleteMessage | ErrorMessage | SessionResumeMessage;
+
+interface Frame {
+    number: number;
+    data: string;
+    timestamp: number;
+    size: number;
+}
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+interface LivenessResult {
+    prediction: 'real' | 'spoof';
+    confidence: number;
+    requestId: string;
+}
+type OnResultCallback = (result: LivenessResult) => void;
+type OnErrorCallback = (error: Error) => void;
+type OnFrameAckCallback = (frameNumber: number) => void;
+type OnConnectionStateChangeCallback = (state: ConnectionState) => void;
+type OnProgressCallback = (current: number, total: number) => void;
+interface LivenessCallbacks {
+    onResult?: OnResultCallback;
+    onError?: OnErrorCallback;
+    onFrameAck?: OnFrameAckCallback;
+    onConnectionStateChange?: OnConnectionStateChangeCallback;
+    onProgress?: OnProgressCallback;
+}
+
+interface WebSocketClientConfig {
+    url: string;
+    apiKey: string;
+    model: string;
+    onMessage?: (message: WebSocketMessage) => void;
+    onConnectionStateChange?: OnConnectionStateChangeCallback;
+    onError?: (error: Error) => void;
+}
+declare class WebSocketClient {
+    private ws;
+    private connectionManager;
+    private authManager;
+    private config;
+    private state;
+    constructor(config: WebSocketClientConfig);
+    connect(): Promise<void>;
+    disconnect(): void;
+    sendFrame(frameData: string, frameNumber: number): void;
+    getState(): ConnectionState;
+    private setState;
+    private handleMessage;
+    private handleError;
+}
+
+declare class AuthManager {
+    authenticate(ws: WebSocket, apiKey: string, model: string): Promise<string>;
+}
+
+interface ConnectionManagerConfig {
+    onReconnect: () => Promise<void>;
+    maxAttempts?: number;
+}
+declare class ConnectionManager {
+    private config;
+    private reconnectAttempts;
+    constructor(config: ConnectionManagerConfig);
+    handleDisconnect(): Promise<void>;
+    reset(): void;
+}
+
+declare class FrameBuffer {
+    private buffer;
+    private lastAcknowledged;
+    private currentMemoryUsage;
+    private readonly maxSize;
+    private readonly maxMemory;
+    constructor(maxSize?: number, maxMemory?: number);
+    add(frame: Frame): void;
+    acknowledge(frameNumber: number): void;
+    getUnacknowledged(): Frame[];
+    getLastAcknowledged(): number;
+    size(): number;
+    getMemoryUsage(): number;
+    clear(): void;
+    private remove;
+    private flushOldest;
+}
+
+declare class FrameQueue {
+    private queue;
+    enqueue(frame: Frame): void;
+    dequeue(): Frame | undefined;
+    peek(): Frame | undefined;
+    isEmpty(): boolean;
+    size(): number;
+    clear(): void;
+    toArray(): Frame[];
+}
+
+type ModelType = '50-frame' | '250-frame';
+interface ModelConfig {
+    type: ModelType;
+    fileName: string;
+    frameCount: number;
+}
+declare const MODEL_CONFIGS: Record<ModelType, ModelConfig>;
+
+declare const API_ENDPOINTS: {
+    readonly production: "wss://api.moveris.com/v1/liveness";
+    readonly staging: "wss://staging-api.moveris.com/v1/liveness";
+    readonly development: "ws://localhost:8080/v1/liveness";
+};
+declare const DEFAULT_ENDPOINT: "wss://api.moveris.com/v1/liveness";
+declare const RECONNECTION_CONFIG: {
+    readonly maxAttempts: 10;
+    readonly initialDelay: 1000;
+    readonly maxDelay: 30000;
+    readonly backoffMultiplier: 2;
+};
+declare const FRAME_BUFFER_CONFIG: {
+    readonly maxSize: 10;
+    readonly maxMemory: number;
+};
+declare const AUTH_CONFIG: {
+    readonly timeout: 10000;
+    readonly apiKeyPattern: RegExp;
+};
+declare const FRAME_CONFIG: {
+    readonly targetFPS: 30;
+    readonly frameInterval: 33;
+    readonly jpegQuality: 0.8;
+};
+
+declare function validateApiKey(apiKey: string): boolean;
+declare function validateFrameData(data: string): boolean;
+declare function validateFrameNumber(frameNumber: number): boolean;
+
+declare function encodeBase64(buffer: ArrayBuffer | Uint8Array): string;
+declare function decodeBase64(base64: string): Uint8Array;
+
+interface RetryOptions {
+    maxAttempts?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+}
+declare function retryWithBackoff<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+
+export { API_ENDPOINTS, AUTH_CONFIG, type AuthErrorMessage, AuthManager, type AuthMessage, type AuthRequiredMessage, type AuthSuccessMessage, type BaseMessage, ConnectionManager, type ConnectionState, DEFAULT_ENDPOINT, type ErrorMessage, FRAME_BUFFER_CONFIG, FRAME_CONFIG, type Frame, FrameBuffer, type FrameMessage, FrameQueue, type FrameReceivedMessage, type LivenessCallbacks, type LivenessResult, MODEL_CONFIGS, type MessageType, type ModelConfig, type ModelType, type OnConnectionStateChangeCallback, type OnErrorCallback, type OnFrameAckCallback, type OnProgressCallback, type OnResultCallback, type ProcessingCompleteMessage, RECONNECTION_CONFIG, type RetryOptions, type SessionResumeMessage, WebSocketClient, type WebSocketMessage, decodeBase64, encodeBase64, retryWithBackoff, validateApiKey, validateFrameData, validateFrameNumber };

package/dist/index.js

@@ -0,0 +1,410 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  API_ENDPOINTS: () => API_ENDPOINTS,
+  AUTH_CONFIG: () => AUTH_CONFIG,
+  AuthManager: () => AuthManager,
+  ConnectionManager: () => ConnectionManager,
+  DEFAULT_ENDPOINT: () => DEFAULT_ENDPOINT,
+  FRAME_BUFFER_CONFIG: () => FRAME_BUFFER_CONFIG,
+  FRAME_CONFIG: () => FRAME_CONFIG,
+  FrameBuffer: () => FrameBuffer,
+  FrameQueue: () => FrameQueue,
+  RECONNECTION_CONFIG: () => RECONNECTION_CONFIG,
+  WebSocketClient: () => WebSocketClient,
+  decodeBase64: () => decodeBase64,
+  encodeBase64: () => encodeBase64,
+  retryWithBackoff: () => retryWithBackoff,
+  validateApiKey: () => validateApiKey,
+  validateFrameData: () => validateFrameData,
+  validateFrameNumber: () => validateFrameNumber
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants/config.ts
+var API_ENDPOINTS = {
+  production: "wss://api.moveris.com/v1/liveness",
+  staging: "wss://staging-api.moveris.com/v1/liveness",
+  development: "ws://localhost:8080/v1/liveness"
+};
+var DEFAULT_ENDPOINT = API_ENDPOINTS.production;
+var RECONNECTION_CONFIG = {
+  maxAttempts: 10,
+  initialDelay: 1e3,
+  // 1 second
+  maxDelay: 3e4,
+  // 30 seconds
+  backoffMultiplier: 2
+};
+var FRAME_BUFFER_CONFIG = {
+  maxSize: 10,
+  // Maximum un-acked frames
+  maxMemory: 4 * 1024 * 1024
+  // 4 MB
+};
+var AUTH_CONFIG = {
+  timeout: 1e4,
+  // 10 seconds
+  apiKeyPattern: /^mv_[a-zA-Z0-9]{32}$/
+};
+var FRAME_CONFIG = {
+  targetFPS: 30,
+  frameInterval: 33,
+  // milliseconds (1000 / 30)
+  jpegQuality: 0.8
+  // 80%
+};
+
+// src/utils/retry.ts
+async function retryWithBackoff(fn, options = {}) {
+  const {
+    maxAttempts = RECONNECTION_CONFIG.maxAttempts,
+    initialDelay = RECONNECTION_CONFIG.initialDelay,
+    maxDelay = RECONNECTION_CONFIG.maxDelay,
+    backoffMultiplier = RECONNECTION_CONFIG.backoffMultiplier
+  } = options;
+  let lastError;
+  let delay = initialDelay;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * backoffMultiplier, maxDelay);
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/client/ConnectionManager.ts
+var ConnectionManager = class {
+  constructor(config) {
+    this.reconnectAttempts = 0;
+    this.config = config;
+  }
+  async handleDisconnect() {
+    if (this.reconnectAttempts >= (this.config.maxAttempts ?? 10)) {
+      throw new Error("Max reconnection attempts reached");
+    }
+    try {
+      await retryWithBackoff(
+        async () => {
+          await this.config.onReconnect();
+          this.reconnectAttempts = 0;
+        },
+        {
+          maxAttempts: this.config.maxAttempts ?? 10
+        }
+      );
+    } catch (error) {
+      this.reconnectAttempts++;
+      throw error;
+    }
+  }
+  reset() {
+    this.reconnectAttempts = 0;
+  }
+};
+
+// src/utils/validators.ts
+function validateApiKey(apiKey) {
+  if (!apiKey || typeof apiKey !== "string") {
+    return false;
+  }
+  return AUTH_CONFIG.apiKeyPattern.test(apiKey);
+}
+function validateFrameData(data) {
+  if (!data || typeof data !== "string") {
+    return false;
+  }
+  const base64Pattern = /^[A-Za-z0-9+/=]+$/;
+  return base64Pattern.test(data) && data.length > 0;
+}
+function validateFrameNumber(frameNumber) {
+  return Number.isInteger(frameNumber) && frameNumber > 0;
+}
+
+// src/types/models.ts
+var MODEL_CONFIGS = {
+  "50-frame": {
+    type: "50-frame",
+    fileName: "model_50.h5",
+    frameCount: 50
+  },
+  "250-frame": {
+    type: "250-frame",
+    fileName: "model_250.h5",
+    frameCount: 250
+  }
+};
+
+// src/client/AuthManager.ts
+var AuthManager = class {
+  async authenticate(ws, apiKey, model) {
+    if (!validateApiKey(apiKey)) {
+      throw new Error("Invalid API key format");
+    }
+    const modelType = model;
+    if (!MODEL_CONFIGS[modelType]) {
+      throw new Error(`Invalid model type: ${model}`);
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Authentication timeout"));
+      }, AUTH_CONFIG.timeout);
+      const messageHandler = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          if (message.type === "auth_success") {
+            clearTimeout(timeout);
+            ws.removeEventListener("message", messageHandler);
+            resolve(message.request_id);
+          } else if (message.type === "auth_error") {
+            clearTimeout(timeout);
+            ws.removeEventListener("message", messageHandler);
+            reject(new Error(message.error));
+          }
+        } catch (error) {
+        }
+      };
+      ws.addEventListener("message", messageHandler);
+      ws.send(
+        JSON.stringify({
+          type: "auth",
+          token: apiKey,
+          model_file_name: MODEL_CONFIGS[modelType].fileName
+        })
+      );
+    });
+  }
+};
+
+// src/client/WebSocketClient.ts
+var WebSocketClient = class {
+  constructor(config) {
+    this.ws = null;
+    this.state = "disconnected";
+    this.config = config;
+    this.connectionManager = new ConnectionManager({
+      onReconnect: () => this.connect()
+    });
+    this.authManager = new AuthManager();
+  }
+  async connect() {
+    if (this.state === "connected" || this.state === "connecting") {
+      return;
+    }
+    this.setState("connecting");
+    try {
+      this.ws = new WebSocket(this.config.url);
+      this.ws.onopen = async () => {
+        try {
+          await this.authManager.authenticate(this.ws, this.config.apiKey, this.config.model);
+          this.setState("connected");
+        } catch (error) {
+          this.handleError(error instanceof Error ? error : new Error("Authentication failed"));
+        }
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          this.handleMessage(message);
+        } catch (error) {
+          this.handleError(error instanceof Error ? error : new Error("Failed to parse message"));
+        }
+      };
+      this.ws.onerror = () => {
+        this.handleError(new Error("WebSocket error"));
+      };
+      this.ws.onclose = () => {
+        this.setState("disconnected");
+        this.connectionManager.handleDisconnect();
+      };
+    } catch (error) {
+      this.handleError(error instanceof Error ? error : new Error("Connection failed"));
+    }
+  }
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setState("disconnected");
+  }
+  sendFrame(frameData, frameNumber) {
+    if (this.state !== "connected" || !this.ws) {
+      throw new Error("WebSocket not connected");
+    }
+    const message = {
+      type: "frame",
+      frame_data: frameData,
+      frame_number: frameNumber,
+      timestamp: Date.now()
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  getState() {
+    return this.state;
+  }
+  setState(newState) {
+    if (this.state !== newState) {
+      this.state = newState;
+      this.config.onConnectionStateChange?.(newState);
+    }
+  }
+  handleMessage(message) {
+    this.config.onMessage?.(message);
+  }
+  handleError(error) {
+    this.setState("error");
+    this.config.onError?.(error);
+  }
+};
+
+// src/buffer/FrameBuffer.ts
+var FrameBuffer = class {
+  constructor(maxSize = FRAME_BUFFER_CONFIG.maxSize, maxMemory = FRAME_BUFFER_CONFIG.maxMemory) {
+    this.buffer = /* @__PURE__ */ new Map();
+    this.lastAcknowledged = 0;
+    this.currentMemoryUsage = 0;
+    this.maxSize = maxSize;
+    this.maxMemory = maxMemory;
+  }
+  add(frame) {
+    if (this.currentMemoryUsage + frame.size > this.maxMemory) {
+      this.flushOldest();
+    }
+    this.buffer.set(frame.number, frame);
+    this.currentMemoryUsage += frame.size;
+    if (this.buffer.size > this.maxSize) {
+      const oldest = Math.min(...this.buffer.keys());
+      this.remove(oldest);
+    }
+  }
+  acknowledge(frameNumber) {
+    this.lastAcknowledged = Math.max(this.lastAcknowledged, frameNumber);
+    for (const [num] of this.buffer) {
+      if (num <= frameNumber) {
+        this.remove(num);
+      }
+    }
+  }
+  getUnacknowledged() {
+    return Array.from(this.buffer.values()).filter((f) => f.number > this.lastAcknowledged).sort((a, b) => a.number - b.number);
+  }
+  getLastAcknowledged() {
+    return this.lastAcknowledged;
+  }
+  size() {
+    return this.buffer.size;
+  }
+  getMemoryUsage() {
+    return this.currentMemoryUsage;
+  }
+  clear() {
+    this.buffer.clear();
+    this.currentMemoryUsage = 0;
+    this.lastAcknowledged = 0;
+  }
+  remove(frameNumber) {
+    const frame = this.buffer.get(frameNumber);
+    if (frame) {
+      this.currentMemoryUsage -= frame.size;
+      this.buffer.delete(frameNumber);
+    }
+  }
+  flushOldest() {
+    if (this.buffer.size === 0) {
+      return;
+    }
+    const oldest = Math.min(...this.buffer.keys());
+    this.remove(oldest);
+  }
+};
+
+// src/buffer/FrameQueue.ts
+var FrameQueue = class {
+  constructor() {
+    this.queue = [];
+  }
+  enqueue(frame) {
+    this.queue.push(frame);
+  }
+  dequeue() {
+    return this.queue.shift();
+  }
+  peek() {
+    return this.queue[0];
+  }
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+  size() {
+    return this.queue.length;
+  }
+  clear() {
+    this.queue = [];
+  }
+  toArray() {
+    return [...this.queue];
+  }
+};
+
+// src/utils/encoders.ts
+function encodeBase64(buffer) {
+  if (buffer instanceof ArrayBuffer) {
+    const bytes = new Uint8Array(buffer);
+    return btoa(String.fromCharCode(...bytes));
+  }
+  return btoa(String.fromCharCode(...buffer));
+}
+function decodeBase64(base64) {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API_ENDPOINTS,
+  AUTH_CONFIG,
+  AuthManager,
+  ConnectionManager,
+  DEFAULT_ENDPOINT,
+  FRAME_BUFFER_CONFIG,
+  FRAME_CONFIG,
+  FrameBuffer,
+  FrameQueue,
+  RECONNECTION_CONFIG,
+  WebSocketClient,
+  decodeBase64,
+  encodeBase64,
+  retryWithBackoff,
+  validateApiKey,
+  validateFrameData,
+  validateFrameNumber
+});

package/dist/index.mjs

@@ -0,0 +1,367 @@
+// src/constants/config.ts
+var API_ENDPOINTS = {
+  production: "wss://api.moveris.com/v1/liveness",
+  staging: "wss://staging-api.moveris.com/v1/liveness",
+  development: "ws://localhost:8080/v1/liveness"
+};
+var DEFAULT_ENDPOINT = API_ENDPOINTS.production;
+var RECONNECTION_CONFIG = {
+  maxAttempts: 10,
+  initialDelay: 1e3,
+  // 1 second
+  maxDelay: 3e4,
+  // 30 seconds
+  backoffMultiplier: 2
+};
+var FRAME_BUFFER_CONFIG = {
+  maxSize: 10,
+  // Maximum un-acked frames
+  maxMemory: 4 * 1024 * 1024
+  // 4 MB
+};
+var AUTH_CONFIG = {
+  timeout: 1e4,
+  // 10 seconds
+  apiKeyPattern: /^mv_[a-zA-Z0-9]{32}$/
+};
+var FRAME_CONFIG = {
+  targetFPS: 30,
+  frameInterval: 33,
+  // milliseconds (1000 / 30)
+  jpegQuality: 0.8
+  // 80%
+};
+
+// src/utils/retry.ts
+async function retryWithBackoff(fn, options = {}) {
+  const {
+    maxAttempts = RECONNECTION_CONFIG.maxAttempts,
+    initialDelay = RECONNECTION_CONFIG.initialDelay,
+    maxDelay = RECONNECTION_CONFIG.maxDelay,
+    backoffMultiplier = RECONNECTION_CONFIG.backoffMultiplier
+  } = options;
+  let lastError;
+  let delay = initialDelay;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * backoffMultiplier, maxDelay);
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/client/ConnectionManager.ts
+var ConnectionManager = class {
+  constructor(config) {
+    this.reconnectAttempts = 0;
+    this.config = config;
+  }
+  async handleDisconnect() {
+    if (this.reconnectAttempts >= (this.config.maxAttempts ?? 10)) {
+      throw new Error("Max reconnection attempts reached");
+    }
+    try {
+      await retryWithBackoff(
+        async () => {
+          await this.config.onReconnect();
+          this.reconnectAttempts = 0;
+        },
+        {
+          maxAttempts: this.config.maxAttempts ?? 10
+        }
+      );
+    } catch (error) {
+      this.reconnectAttempts++;
+      throw error;
+    }
+  }
+  reset() {
+    this.reconnectAttempts = 0;
+  }
+};
+
+// src/utils/validators.ts
+function validateApiKey(apiKey) {
+  if (!apiKey || typeof apiKey !== "string") {
+    return false;
+  }
+  return AUTH_CONFIG.apiKeyPattern.test(apiKey);
+}
+function validateFrameData(data) {
+  if (!data || typeof data !== "string") {
+    return false;
+  }
+  const base64Pattern = /^[A-Za-z0-9+/=]+$/;
+  return base64Pattern.test(data) && data.length > 0;
+}
+function validateFrameNumber(frameNumber) {
+  return Number.isInteger(frameNumber) && frameNumber > 0;
+}
+
+// src/types/models.ts
+var MODEL_CONFIGS = {
+  "50-frame": {
+    type: "50-frame",
+    fileName: "model_50.h5",
+    frameCount: 50
+  },
+  "250-frame": {
+    type: "250-frame",
+    fileName: "model_250.h5",
+    frameCount: 250
+  }
+};
+
+// src/client/AuthManager.ts
+var AuthManager = class {
+  async authenticate(ws, apiKey, model) {
+    if (!validateApiKey(apiKey)) {
+      throw new Error("Invalid API key format");
+    }
+    const modelType = model;
+    if (!MODEL_CONFIGS[modelType]) {
+      throw new Error(`Invalid model type: ${model}`);
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Authentication timeout"));
+      }, AUTH_CONFIG.timeout);
+      const messageHandler = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          if (message.type === "auth_success") {
+            clearTimeout(timeout);
+            ws.removeEventListener("message", messageHandler);
+            resolve(message.request_id);
+          } else if (message.type === "auth_error") {
+            clearTimeout(timeout);
+            ws.removeEventListener("message", messageHandler);
+            reject(new Error(message.error));
+          }
+        } catch (error) {
+        }
+      };
+      ws.addEventListener("message", messageHandler);
+      ws.send(
+        JSON.stringify({
+          type: "auth",
+          token: apiKey,
+          model_file_name: MODEL_CONFIGS[modelType].fileName
+        })
+      );
+    });
+  }
+};
+
+// src/client/WebSocketClient.ts
+var WebSocketClient = class {
+  constructor(config) {
+    this.ws = null;
+    this.state = "disconnected";
+    this.config = config;
+    this.connectionManager = new ConnectionManager({
+      onReconnect: () => this.connect()
+    });
+    this.authManager = new AuthManager();
+  }
+  async connect() {
+    if (this.state === "connected" || this.state === "connecting") {
+      return;
+    }
+    this.setState("connecting");
+    try {
+      this.ws = new WebSocket(this.config.url);
+      this.ws.onopen = async () => {
+        try {
+          await this.authManager.authenticate(this.ws, this.config.apiKey, this.config.model);
+          this.setState("connected");
+        } catch (error) {
+          this.handleError(error instanceof Error ? error : new Error("Authentication failed"));
+        }
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          this.handleMessage(message);
+        } catch (error) {
+          this.handleError(error instanceof Error ? error : new Error("Failed to parse message"));
+        }
+      };
+      this.ws.onerror = () => {
+        this.handleError(new Error("WebSocket error"));
+      };
+      this.ws.onclose = () => {
+        this.setState("disconnected");
+        this.connectionManager.handleDisconnect();
+      };
+    } catch (error) {
+      this.handleError(error instanceof Error ? error : new Error("Connection failed"));
+    }
+  }
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setState("disconnected");
+  }
+  sendFrame(frameData, frameNumber) {
+    if (this.state !== "connected" || !this.ws) {
+      throw new Error("WebSocket not connected");
+    }
+    const message = {
+      type: "frame",
+      frame_data: frameData,
+      frame_number: frameNumber,
+      timestamp: Date.now()
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  getState() {
+    return this.state;
+  }
+  setState(newState) {
+    if (this.state !== newState) {
+      this.state = newState;
+      this.config.onConnectionStateChange?.(newState);
+    }
+  }
+  handleMessage(message) {
+    this.config.onMessage?.(message);
+  }
+  handleError(error) {
+    this.setState("error");
+    this.config.onError?.(error);
+  }
+};
+
+// src/buffer/FrameBuffer.ts
+var FrameBuffer = class {
+  constructor(maxSize = FRAME_BUFFER_CONFIG.maxSize, maxMemory = FRAME_BUFFER_CONFIG.maxMemory) {
+    this.buffer = /* @__PURE__ */ new Map();
+    this.lastAcknowledged = 0;
+    this.currentMemoryUsage = 0;
+    this.maxSize = maxSize;
+    this.maxMemory = maxMemory;
+  }
+  add(frame) {
+    if (this.currentMemoryUsage + frame.size > this.maxMemory) {
+      this.flushOldest();
+    }
+    this.buffer.set(frame.number, frame);
+    this.currentMemoryUsage += frame.size;
+    if (this.buffer.size > this.maxSize) {
+      const oldest = Math.min(...this.buffer.keys());
+      this.remove(oldest);
+    }
+  }
+  acknowledge(frameNumber) {
+    this.lastAcknowledged = Math.max(this.lastAcknowledged, frameNumber);
+    for (const [num] of this.buffer) {
+      if (num <= frameNumber) {
+        this.remove(num);
+      }
+    }
+  }
+  getUnacknowledged() {
+    return Array.from(this.buffer.values()).filter((f) => f.number > this.lastAcknowledged).sort((a, b) => a.number - b.number);
+  }
+  getLastAcknowledged() {
+    return this.lastAcknowledged;
+  }
+  size() {
+    return this.buffer.size;
+  }
+  getMemoryUsage() {
+    return this.currentMemoryUsage;
+  }
+  clear() {
+    this.buffer.clear();
+    this.currentMemoryUsage = 0;
+    this.lastAcknowledged = 0;
+  }
+  remove(frameNumber) {
+    const frame = this.buffer.get(frameNumber);
+    if (frame) {
+      this.currentMemoryUsage -= frame.size;
+      this.buffer.delete(frameNumber);
+    }
+  }
+  flushOldest() {
+    if (this.buffer.size === 0) {
+      return;
+    }
+    const oldest = Math.min(...this.buffer.keys());
+    this.remove(oldest);
+  }
+};
+
+// src/buffer/FrameQueue.ts
+var FrameQueue = class {
+  constructor() {
+    this.queue = [];
+  }
+  enqueue(frame) {
+    this.queue.push(frame);
+  }
+  dequeue() {
+    return this.queue.shift();
+  }
+  peek() {
+    return this.queue[0];
+  }
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+  size() {
+    return this.queue.length;
+  }
+  clear() {
+    this.queue = [];
+  }
+  toArray() {
+    return [...this.queue];
+  }
+};
+
+// src/utils/encoders.ts
+function encodeBase64(buffer) {
+  if (buffer instanceof ArrayBuffer) {
+    const bytes = new Uint8Array(buffer);
+    return btoa(String.fromCharCode(...bytes));
+  }
+  return btoa(String.fromCharCode(...buffer));
+}
+function decodeBase64(base64) {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+export {
+  API_ENDPOINTS,
+  AUTH_CONFIG,
+  AuthManager,
+  ConnectionManager,
+  DEFAULT_ENDPOINT,
+  FRAME_BUFFER_CONFIG,
+  FRAME_CONFIG,
+  FrameBuffer,
+  FrameQueue,
+  RECONNECTION_CONFIG,
+  WebSocketClient,
+  decodeBase64,
+  encodeBase64,
+  retryWithBackoff,
+  validateApiKey,
+  validateFrameData,
+  validateFrameNumber
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@moveris/shared",
+  "version": "0.0.1",
+  "description": "Core business logic for Moveris Live SDK",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "moveris",
+    "liveness",
+    "websocket",
+    "sdk"
+  ],
+  "author": "Jeyson Palacio",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.11",
+    "@types/node": "^20.11.5",
+    "@types/ws": "^8.5.10",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "ws": "^8.16.0"
+  },
+  "dependencies": {},
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --tsconfig tsconfig.json",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "jest --passWithNoTests",
+    "test:coverage": "jest --coverage --passWithNoTests",
+    "test:watch": "jest --watch",
+    "lint": "eslint src --ext .ts",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "publish:local": "npm run build && yalc publish --push",
+    "yalc:publish": "yalc publish",
+    "yalc:push": "yalc push",
+    "yalc:remove": "yalc remove"
+  }
+}