@monitordog/detector 1.0.0

package/dist/pose/mediapipe-asset-loader.d.ts

@@ -0,0 +1,16 @@
+export type MediaPipeWasmFileset = {
+    wasmLoaderPath: string;
+    wasmBinaryPath: string;
+    assetLoaderPath?: string;
+    assetBinaryPath?: string;
+};
+export type MediaPipeAssetBundle = {
+    wasmFileset: MediaPipeWasmFileset;
+    poseModelAssetBuffer: Uint8Array;
+    dispose: () => void;
+};
+export type MediaPipeAssetLoadOptions = {
+    apiBaseUrl: string;
+    accessToken: string;
+};
+export declare function loadMediaPipeAssetBundle(options: MediaPipeAssetLoadOptions): Promise<MediaPipeAssetBundle>;

package/dist/pose/mediapipe-main-user-tracker.d.ts

@@ -0,0 +1,90 @@
+export declare const CHECK_INTERVAL_MS = 300;
+export declare const MAX_MISSING_TIME_MS = 650;
+export declare const MAX_MISSING_SAMPLE_COUNT = 2;
+export declare const ACQUIRE_MIN_SHOULDER_WIDTH = 0.2;
+export declare const TRACK_MIN_SHOULDER_WIDTH = 0.08;
+export declare const DISTANCE_THRESHOLD = 0.25;
+export declare const ACQUIRE_MIN_VISIBILITY = 0.5;
+export declare const TRACK_MIN_VISIBILITY = 0.75;
+export declare const TRACK_DISTANCE_THRESHOLD = 0.45;
+export declare const TORSO_OVERLAP_THRESHOLD = 0.15;
+export declare const SHOULDER_SCALE_MIN_RATIO = 0.45;
+export declare const SHOULDER_SCALE_MAX_RATIO = 2.2;
+export declare const landmarkIndexes: {
+    readonly leftShoulder: 11;
+    readonly rightShoulder: 12;
+    readonly leftHip: 23;
+    readonly rightHip: 24;
+};
+export type MainUserTrackingState = "INIT" | "TRACKING" | "MISSING" | "AWAY";
+export type NormalizedPoint = {
+    x: number;
+    y: number;
+};
+export type NormalizedBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type MainUserTrackingDebugPose = {
+    landmarks: NormalizedPoint[][];
+    candidateBoxes: NormalizedBox[];
+    lastTrackBox?: NormalizedBox;
+};
+export type MainUserTrackingResult = {
+    enabled: boolean;
+    disabledReason?: string;
+    state: MainUserTrackingState;
+    hasTrackedUser: boolean;
+    lastCentroid?: NormalizedPoint;
+    missingElapsedMs: number;
+    poseCount: number;
+    candidateCount: number;
+    debugPose?: MainUserTrackingDebugPose;
+};
+export type MediaPipeMainUserTrackerOptions = {
+    apiBaseUrl?: string;
+    accessToken?: string;
+    wasmBasePath?: string;
+    modelAssetPath?: string;
+    numPoses?: number;
+};
+export type CandidateMode = "acquire" | "track";
+export declare class MediaPipeMainUserTracker {
+    private readonly wasmBasePath;
+    private readonly poseModelAssetPath;
+    private readonly numPoses;
+    private readonly apiBaseUrl?;
+    private readonly accessToken?;
+    private assetBundle?;
+    private poseLandmarker?;
+    private state;
+    private lastCentroid?;
+    private lastTrack?;
+    private hasTrackedUser;
+    private missingStartedAt?;
+    private missingSampleCount;
+    constructor(options?: MediaPipeMainUserTrackerOptions);
+    load(): Promise<void>;
+    detectForVideo(video: HTMLVideoElement, timestampMs: number): MainUserTrackingResult;
+    getSnapshot(nowMs: number): MainUserTrackingResult;
+    reset(): void;
+    private resetTrackingState;
+    dispose(): void;
+    private createPoseLandmarkerWithFallback;
+    private createPoseLandmarker;
+    private loadAssetBundle;
+    private hasSelfHostedAssetPath;
+    private getSelfHostedWasmBasePath;
+    private getSelfHostedModelAssetPath;
+    private toPoseCandidates;
+    private toPoseCandidate;
+    private getPoseCentroid;
+    private findMainUser;
+    private matchCandidate;
+    private setTracking;
+    private markMissing;
+    private setAway;
+    private createResult;
+}

package/dist/pose.d.ts

@@ -0,0 +1,15 @@
+import type { NormalizedLandmark } from "@mediapipe/tasks-vision";
+import { type NormalizedPoint, type NormalizedBox, type CandidateMode } from "./pose/mediapipe-main-user-tracker";
+export declare function isVisible(landmark: NormalizedLandmark | undefined, minVisibility: number): landmark is NormalizedLandmark;
+export declare function getVisibleTorsoLandmarks(landmarks: NormalizedLandmark[], minVisibility: number): NormalizedLandmark[];
+export declare function getCandidateThresholds(mode: CandidateMode): {
+    minShoulderWidth: number;
+    minVisibility: number;
+};
+export declare function averageLandmarks(landmarks: NormalizedLandmark[]): NormalizedPoint;
+export declare function getTorsoBox(landmarks: NormalizedLandmark[]): NormalizedBox;
+export declare function getBoxOverlapRatio(first: NormalizedBox, second: NormalizedBox): number;
+export declare function doesShoulderScaleMatch(previousShoulderWidth: number | undefined, nextShoulderWidth: number | undefined): boolean;
+export declare function getDistance(a: NormalizedPoint, b: NormalizedPoint): number;
+export declare function clampRatio(value: number): number;
+export declare function clampInteger(value: number, min: number, max: number): number;

package/dist/sdk-error.d.ts

@@ -0,0 +1,7 @@
+import type { MonitorDogSdkErrorCode } from "./types";
+export declare class MonitorDogSdkError extends Error {
+    readonly code: MonitorDogSdkErrorCode;
+    readonly cause?: unknown;
+    constructor(code: MonitorDogSdkErrorCode, message: string, cause?: unknown);
+}
+export declare function isMonitorDogSdkError(error: unknown): error is MonitorDogSdkError;

package/dist/service/auth-service.d.ts

@@ -0,0 +1,42 @@
+import type { MonitorDogLoginRequest, MonitorDogSessionToken } from "../types";
+import type { ServiceContainer } from "./container";
+export declare class AuthService {
+    private readonly services;
+    private readonly refreshBeforeMs;
+    private readonly periodicRefreshIntervalMs;
+    private token?;
+    private tokenExpiresAt?;
+    private refreshPromise?;
+    private refreshIntervalId?;
+    private authSessionId;
+    private sessionEmail?;
+    constructor(services: ServiceContainer);
+    login(request: MonitorDogLoginRequest): Promise<MonitorDogSessionToken>;
+    logout(): Promise<void>;
+    getToken(): string | undefined;
+    getTokenExpiresAt(): number | undefined;
+    getSessionEmail(): string | undefined;
+    isAuthenticated(): boolean;
+    dispose(): void;
+    assertAuthenticated(): void;
+    getValidAccessToken(): Promise<string | undefined>;
+    authorizedFetch(path: string, init?: RequestInit, retry?: boolean): Promise<Response>;
+    private setSessionTokenPayload;
+    private setTokens;
+    private clearTokens;
+    private refreshToken;
+    private handleAuthRefresh;
+    private refreshAccessToken;
+    private startPeriodicRefresh;
+    private stopPeriodicRefresh;
+    private refreshPeriodically;
+    private shouldRefreshCurrentToken;
+    private isCurrentTokenExpired;
+    private isRefreshSupersededError;
+    private fetchSessionToken;
+    private getApiErrorCode;
+    private shouldRefreshAfterAuthError;
+    private handleLoginRequired;
+    private sendUserActivityEvent;
+    private createSdkError;
+}

package/dist/service/camera-service.d.ts

@@ -0,0 +1,19 @@
+export declare class CameraService {
+    createWebcamStream(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+    stopStream(stream: MediaStream): void;
+    watchStreamDeviceDisconnect(stream: MediaStream, onDisconnect: () => void | Promise<void>, debounceMs?: number): () => void;
+    isCameraInUse(video?: HTMLVideoElement): boolean;
+    getVideoInputDevices(): Promise<MediaDeviceInfo[]>;
+    getRealVideoInputDevices(): Promise<MediaDeviceInfo[]>;
+    private createFallbackWebcamStream;
+    private handleDeviceChange;
+    private getBaseWebcamConstraints;
+    private createFirstCameraConstraints;
+    private getWebcamNaturalAspectRatio;
+    private generateResolutionList;
+    private createDeviceConstraints;
+    private isVirtualCamera;
+    private isPermissionError;
+    private getUserMedia;
+    private isCameraRequestTimeoutError;
+}

package/dist/service/container.d.ts

@@ -0,0 +1,47 @@
+import type { AccountResponse, LockPolicyResponse, MonitorDogDetectorOptions, UserPreferences } from "../types";
+import { AuthService } from "./auth-service";
+import { CameraService } from "./camera-service";
+import { DetectionEventService } from "./detection-event-service";
+import { DetectService } from "./detect-service";
+import { OverlayService } from "./overlay-service";
+import { WebcamService } from "./webcam-service";
+export type DetectorOptions = Required<Pick<MonitorDogDetectorOptions, "apiBaseUrl">> & MonitorDogDetectorOptions & {
+    confidenceThreshold: number;
+    faceConfidenceThreshold: number;
+    requiredPassword: boolean;
+    iouThreshold: number;
+    maxDetections: number;
+    inputSize: number;
+    inputType: "float32" | "uint8";
+    detectionIntervalMs: number;
+    modelBuildVersion: string;
+    modelBuildNumber: string | number;
+};
+export declare class ServiceContainer {
+    #private;
+    readonly auth: AuthService;
+    readonly overlay: OverlayService;
+    readonly camera: CameraService;
+    readonly detectionEvents: DetectionEventService;
+    readonly detect: DetectService;
+    readonly webcam: WebcamService;
+    onCameraRetry?: () => void | Promise<void>;
+    onCameraDisconnect?: () => void | Promise<void>;
+    onRemoteUnlock?: () => void | Promise<void>;
+    onRemoteUnlockRequest?: () => void | Promise<void>;
+    getRemoteUnlockRequestCooldownMs?: () => number;
+    onShutdownRequest?: () => void;
+    onLoginRequired?: () => void;
+    constructor(getOptions: () => DetectorOptions);
+    get options(): Readonly<DetectorOptions>;
+    get noFaceEventDelayMs(): number;
+    get userPreferences(): Readonly<UserPreferences>;
+    updateNoFaceEventDelayFromServer(delayMs: number): void;
+    updateRequiredPasswordFromServer(requiredPassword: boolean): void;
+    degradeInferenceModelForMemoryPressure(): void;
+    get shouldPauseForHiddenPage(): boolean;
+    get shouldPauseDetection(): boolean;
+    get shouldPauseForResumePassword(): boolean;
+    applyPolicyItems(items: LockPolicyResponse[], _account: AccountResponse): void;
+    resetAuthenticatedState(): void;
+}

package/dist/service/detect-service.d.ts

@@ -0,0 +1,53 @@
+import type { InternalDetectionResult, MonitorDogDetectionResult, MonitorDogImageSource, MonitorDogVideoDetectionController, MonitorDogWebcamDetectionController } from "../types";
+import type { ServiceContainer } from "./container";
+export declare class DetectService {
+    private readonly services;
+    private inferenceWorker?;
+    private loadPromise?;
+    private lastInferenceMemoryErrorAt;
+    private mainUserTracker?;
+    private mainUserTrackerLoadPromise?;
+    private mainUserTrackerLoadTimeoutId?;
+    private mainUserTrackerLoadToken;
+    private mainUserTrackerDisabledReason;
+    private mainUserTrackingEnabled;
+    private webcamFrameAnalyzer?;
+    private webcamBlockageDetector?;
+    private webcamLightingDetector?;
+    private activeLightingOverlayState?;
+    private poseDebugCanvas?;
+    private baselineRefreshPendingAfterNoFace;
+    constructor(services: ServiceContainer);
+    load(): Promise<void>;
+    detect(source: MonitorDogImageSource): Promise<InternalDetectionResult>;
+    toPublicResult(result: InternalDetectionResult): MonitorDogDetectionResult;
+    detectVideo(video: HTMLVideoElement): MonitorDogVideoDetectionController;
+    startWebcamDetection(): Promise<MonitorDogWebcamDetectionController>;
+    isMainUserTrackingEnabled(): boolean;
+    setMainUserTrackingEnabled(enabled: boolean): void;
+    dispose(): void;
+    private ensureMainUserTrackerLoading;
+    private scheduleMainUserTrackerLoading;
+    private clearMainUserTrackerLoadTimeout;
+    private loadMainUserTracker;
+    private detectMainUser;
+    private isNoUserTrackingState;
+    private shouldRefreshBaselineForNormalState;
+    private handleWebcamLightingResult;
+    private clearWebcamLightingOverlay;
+    private renderPoseDebugOverlay;
+    private getPoseDebugCanvas;
+    private clearPoseDebugOverlay;
+    private drawPoseDebug;
+    private handleDetectionLoopError;
+    private recoverFromInferenceMemoryError;
+    private resetInferenceWorker;
+    private degradeModelForMemoryPressure;
+    private isInferenceMemoryError;
+    private getInferenceWorker;
+    private getWebcamFrameAnalyzer;
+    private getWebcamBlockageDetector;
+    private getWebcamLightingDetector;
+    private loadInferenceWorker;
+    private loadInferenceWorkerWithOptions;
+}

package/dist/service/detection-event-service.d.ts

@@ -0,0 +1,32 @@
+import type { WebcamBlockageAnalysis } from "../detect/webcam-blockage-detector";
+import type { MainUserTrackingResult } from "../pose/mediapipe-main-user-tracker";
+import type { InternalDetectionResult, MonitorDogImageSource } from "../types";
+import type { ServiceContainer } from "./container";
+export declare class DetectionEventService {
+    private static readonly NO_FACE_STARTUP_GRACE_MS;
+    private readonly services;
+    private detectionEventLocked;
+    private detectionEventInFlight;
+    private detectionEventLockTimeoutId?;
+    private noFaceStartedAt?;
+    private suppressNoFaceUntil;
+    constructor(services: ServiceContainer);
+    handleDetectionResult(result: InternalDetectionResult, trackingResult: MainUserTrackingResult, source?: MonitorDogImageSource): Promise<void>;
+    handleWebcamBlockageResult(analysis: WebcamBlockageAnalysis, source?: MonitorDogImageSource): Promise<void>;
+    reset(): void;
+    resetForWebcamStartup(): void;
+    resetAfterResumePasswordUnlock(): void;
+    private uploadWebcamImage;
+    private uploadMonitorImage;
+    private uploadImage;
+    private shouldSendEvent;
+    private shouldSendWebcamBlockedEvent;
+    private shouldShowOverlay;
+    private lock;
+    private clearLock;
+    private hasNoFaceDelayElapsed;
+    private getLockDuration;
+    private getOverlayDuration;
+    private shouldPauseDetectionAfterCapture;
+    private getMode;
+}

package/dist/service/overlay-renderer.d.ts

@@ -0,0 +1,71 @@
+import type { MonitorDogOverlayMessages, MonitorDogOverlayOptions } from "../types";
+import type { ActiveOverlayJob, OverlayState } from "./overlay-service";
+type OverlayRendererOptions = {
+    getOverlayOptions: () => MonitorDogOverlayOptions | undefined;
+    getCurrentJob: () => ActiveOverlayJob | undefined;
+    getOverlayMessage: (job: ActiveOverlayJob) => string;
+    getLanguageMessages: () => MonitorDogOverlayMessages;
+    hasInteractiveAction: (state: OverlayState | undefined) => boolean;
+    isCameraOverlay: (state: OverlayState | undefined) => boolean;
+    isRemoteLockOverlay: (state: OverlayState | undefined) => state is "remoteAdminLocked" | "remoteLocked";
+    shouldShowNoFacePasswordInput: (job: ActiveOverlayJob) => boolean;
+    getOnCameraRetry: () => (() => void | Promise<void>) | undefined;
+    getOnRemoteUnlock: () => (() => void | Promise<void>) | undefined;
+    getOnRemoteUnlockRequest: () => (() => void | Promise<void>) | undefined;
+    getRemoteUnlockRequestCooldownMs: () => number;
+    onNoFacePasswordSubmit: (password: string) => Promise<boolean>;
+    getOnError: () => ((error: unknown) => void) | undefined;
+};
+export declare class OverlayRenderer {
+    private readonly options;
+    private previousBodyOverflow?;
+    private remoteUnlockRequestCooldownIntervalId?;
+    constructor(options: OverlayRendererOptions);
+    ensureIntegrity(job: ActiveOverlayJob): void;
+    render(job: ActiveOverlayJob): void;
+    hide(): void;
+    stop(): void;
+    private get overlayOptions();
+    private get languageMessages();
+    private get rootId();
+    private syncActions;
+    private lockPageScroll;
+    private unlockPageScroll;
+    private getOverlayElement;
+    private applyOverlayStyle;
+    private applyOverlayMessageStyle;
+    private getOverlayMessageElement;
+    private syncCameraRetryButton;
+    private handleCameraRetry;
+    private syncRemoteLockButton;
+    private handleRemoteLockAction;
+    private resetCameraRetryButton;
+    private resetRemoteLockButton;
+    private syncNoFacePasswordInput;
+    private resetNoFacePasswordInput;
+    private toggleNoFacePasswordVisibility;
+    private updateNoFacePasswordToggleButton;
+    private handleNoFacePasswordSubmit;
+    private applyCameraRetryButtonStyle;
+    private applyRemoteLockButtonStyle;
+    private applyNoFacePasswordInputStyle;
+    private applyNoFacePasswordInputWrapperStyle;
+    private applyNoFacePasswordFormStyle;
+    private applyNoFacePasswordSubmitButtonStyle;
+    private applyNoFacePasswordToggleButtonStyle;
+    private updateRemoteUnlockRequestCooldownButton;
+    private startRemoteUnlockRequestCooldownTimer;
+    private clearRemoteUnlockRequestCooldownTimer;
+    private applyRemoteLockButtonEnabledState;
+    private applyRemoteLockButtonDisabledState;
+    private applyPointerEvents;
+    private getCameraRetryButtonText;
+    private getCameraRetryingButtonText;
+    private getRemoteLockButtonText;
+    private getRemoteLockBusyButtonText;
+    private getNoFacePasswordSubmitButtonText;
+    private getNoFacePasswordSubmittingButtonText;
+    private getNoFacePasswordOpenIconSrc;
+    private getNoFacePasswordCloseIconSrc;
+}
+export {};

package/dist/service/overlay-service.d.ts

@@ -0,0 +1,75 @@
+import type { MonitorDogOverlayType } from "../types";
+import type { ServiceContainer } from "./container";
+export type OverlayState = MonitorDogOverlayType | "inferenceMemoryError" | "remoteAdminLocked" | "remoteLocked";
+export type OverlaySource = "camera" | "detection" | "remote" | "system";
+type OverlayJob = {
+    action: "show";
+    id: string;
+    state: OverlayState;
+    source: OverlaySource;
+    text?: string;
+    durationMs?: number;
+    priority?: number;
+} | {
+    action: "clear";
+    id?: string;
+    source?: OverlaySource;
+};
+export interface ActiveOverlayJob {
+    id: string;
+    state: OverlayState;
+    source: OverlaySource;
+    text?: string;
+    priority: number;
+    requiresPasswordInput: boolean;
+}
+export declare class OverlayService {
+    private readonly services;
+    private readonly queue;
+    private readonly activeJobs;
+    private readonly jobTimeoutIds;
+    private readonly renderer;
+    private readonly watchdog;
+    private currentJob?;
+    constructor(services: ServiceContainer);
+    private get isDebug();
+    private get overlayOptions();
+    show(eventType: MonitorDogOverlayType): void;
+    hide(): void;
+    lock(durationMs: number): void;
+    clearLock(): void;
+    isLocked(): boolean;
+    isShowing(): boolean;
+    isShowingDetectionBlocker(): boolean;
+    hasActiveSource(source: OverlaySource): boolean;
+    hasActiveState(state: OverlayState): boolean;
+    hasActiveResumePasswordLock(): boolean;
+    enqueue(job: OverlayJob): void;
+    showJob(job: Omit<Extract<OverlayJob, {
+        action: "show";
+    }>, "action">): void;
+    clearJob(id: string): void;
+    clearSource(source: OverlaySource): void;
+    stopWatchdog(): void;
+    private startWatchdog;
+    private ensureIntegrity;
+    private processQueue;
+    private clearJobs;
+    private syncActiveOverlay;
+    private renderHidden;
+    private getNextActiveJob;
+    private setJobDuration;
+    private clearJobDuration;
+    private getOverlayMessage;
+    private getLanguageMessages;
+    private getDefaultSource;
+    private getDefaultPriority;
+    private handleNoFacePasswordSubmit;
+    private isCameraOverlay;
+    private isRemoteLockOverlay;
+    private shouldRequirePasswordInput;
+    private shouldShowNoFacePasswordInput;
+    private hasInteractiveAction;
+    private isMonitorDogOverlayType;
+}
+export {};

package/dist/service/overlay-watchdog-service.d.ts

@@ -0,0 +1,13 @@
+import type { MonitorDogOverlayOptions } from "../types";
+interface OverlayWatchdogOptions {
+    getOverlayOptions: () => MonitorDogOverlayOptions | undefined;
+    ensureIntegrity: () => void;
+}
+export declare class OverlayWatchdogService {
+    private readonly options;
+    private intervalId?;
+    constructor(options: OverlayWatchdogOptions);
+    start(): void;
+    stop(): void;
+}
+export {};

package/dist/service/webcam-service.d.ts

@@ -0,0 +1,26 @@
+import type { ServiceContainer } from "./container";
+export declare class WebcamService {
+    private readonly services;
+    private isWebcamRunning;
+    private stopCurrentWebcam?;
+    private startPromise?;
+    private shouldRun;
+    private resumeWhenUnpaused;
+    private readonly handleVisibilityChange;
+    constructor(services: ServiceContainer);
+    get isRunning(): boolean;
+    get isStarting(): boolean;
+    start(): Promise<void>;
+    stop(): void;
+    retryConnection(): Promise<void>;
+    syncPauseState(): Promise<void>;
+    syncBackgroundPreference(): void;
+    private ensureStarted;
+    private startWebcam;
+    private stopWebcam;
+    private handleCameraDisconnect;
+    private addVisibilityListener;
+    private removeVisibilityListener;
+    private isCameraPermissionError;
+    private isCameraReadError;
+}