@monitordog/detector 1.0.2 → 1.0.3

package/dist/service/container.d.ts

@@ -3,7 +3,6 @@ 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;
@@ -18,17 +17,11 @@ export type DetectorOptions = Required<Pick<MonitorDogDetectorOptions, "apiBaseU
 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>;
@@ -39,7 +32,6 @@ export declare class ServiceContainer {
     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

@@ -5,49 +5,19 @@ export declare class DetectService {
     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

@@ -1,5 +1,3 @@
-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 {
@@ -11,22 +9,16 @@ export declare class DetectionEventService {
     private noFaceStartedAt?;
     private suppressNoFaceUntil;
     constructor(services: ServiceContainer);
-    handleDetectionResult(result: InternalDetectionResult, trackingResult: MainUserTrackingResult, source?: MonitorDogImageSource): Promise<void>;
-    handleWebcamBlockageResult(analysis: WebcamBlockageAnalysis, source?: MonitorDogImageSource): Promise<void>;
+    handleDetectionResult(result: InternalDetectionResult, source?: MonitorDogImageSource): Promise<void>;
     reset(): void;
     resetForWebcamStartup(): void;
-    resetAfterResumePasswordUnlock(): void;
+    clearTransientState(): 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/webcam-service.d.ts

@@ -21,6 +21,4 @@ export declare class WebcamService {
     private handleCameraDisconnect;
     private addVisibilityListener;
     private removeVisibilityListener;
-    private isCameraPermissionError;
-    private isCameraReadError;
 }

package/dist/types.d.ts

@@ -1,6 +1,5 @@
-import type { MainUserTrackingResult } from "./pose/mediapipe-main-user-tracker";
 import type { MonitorDogSdkError } from "./sdk-error";
-export type DetectionReasonEnum = "mobileDevice" | "noFaceDetected" | "twoFacesDetected" | "oneFaceDetected" | "logout" | "login" | "webcamBlocked";
+export type DetectionReasonEnum = "mobileDevice" | "noFaceDetected" | "twoFacesDetected" | "oneFaceDetected" | "logout" | "login";
 export type MonitorDogImageSource = HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap | ImageData;
 export interface MonitorDogDetection {
     classId: number;
@@ -25,23 +24,8 @@ export interface DetectionEvent {
     type: MonitorDogDetectionEventType;
     payload: CreateEventPayload;
 }
-export type MonitorDogDetectionEventType = "noFaceDetected" | "twoFacesDetected" | "mobileDevice" | "webcamBlocked";
+export type MonitorDogDetectionEventType = "noFaceDetected" | "twoFacesDetected" | "mobileDevice";
 export type MonitorDogUserActivityEventType = "login" | "logout";
-export type MonitorDogOverlayType = MonitorDogDetectionEventType | "webcamTooDark" | "webcamTooBright" | "cameraPermissionDenied" | "cameraReadableError";
-export type MonitorDogLanguage = "en" | "ko" | "ja";
-export interface MonitorDogOverlayMessages extends Record<MonitorDogOverlayType, string> {
-    remoteAdminLocked: string;
-    remoteLocked: string;
-    cameraRetryButton: string;
-    cameraRetryingButton: string;
-    remoteUnlockButton: string;
-    remoteUnlockingButton: string;
-    remoteUnlockRequestButton: string;
-    remoteUnlockRequestingButton: string;
-    noFacePasswordInputPlaceholder: string;
-    noFacePasswordSubmitButton: string;
-    noFacePasswordSubmittingButton: string;
-}
 export type DeviceType = "desktop" | "mobile" | "tablet" | "laptop" | "other" | "none";
 export type DeviceOs = "windows" | "macos" | "linux" | "android" | "ios" | "other" | "none";
 export type CreateEventPayload = {
@@ -66,46 +50,10 @@ export type CreateEventPayload = {
     video_urls?: Array<string>;
     program_list?: Array<string>;
 };
-export interface MonitorDogOverlayOptions {
-    enabled?: boolean;
-    locale?: MonitorDogLanguage;
-    watchdog?: boolean;
-    watchdogIntervalMs?: number;
-    rootId?: string;
-    className?: string;
-    messageClassName?: string;
-    cameraRetryButtonClassName?: string;
-    style?: Partial<CSSStyleDeclaration>;
-    messageStyle?: Partial<CSSStyleDeclaration>;
-    cameraRetryButtonStyle?: Partial<CSSStyleDeclaration>;
-    cameraRetryButtonText?: string;
-    cameraRetryingButtonText?: string;
-    remoteUnlockButtonClassName?: string;
-    remoteUnlockButtonStyle?: Partial<CSSStyleDeclaration>;
-    remoteUnlockButtonText?: string;
-    remoteUnlockingButtonText?: string;
-    remoteUnlockRequestButtonText?: string;
-    remoteUnlockRequestingButtonText?: string;
-    noFacePasswordFormClassName?: string;
-    noFacePasswordFormStyle?: Partial<CSSStyleDeclaration>;
-    noFacePasswordInputClassName?: string;
-    noFacePasswordInputStyle?: Partial<CSSStyleDeclaration>;
-    noFacePasswordInputPlaceholder?: string;
-    noFacePasswordToggleButtonClassName?: string;
-    noFacePasswordToggleButtonStyle?: Partial<CSSStyleDeclaration>;
-    noFacePasswordOpenIconSrc?: string;
-    noFacePasswordCloseIconSrc?: string;
-    noFacePasswordSubmitButtonClassName?: string;
-    noFacePasswordSubmitButtonStyle?: Partial<CSSStyleDeclaration>;
-    noFacePasswordSubmitButtonText?: string;
-    noFacePasswordSubmittingButtonText?: string;
-    messages?: Partial<MonitorDogOverlayMessages>;
-}
 export type MonitorDogCaptureImageResult = Blob | File | undefined | null;
 export interface MonitorDogVideoDetectionResult extends MonitorDogDetectionResult {
     video: HTMLVideoElement;
     timestamp: number;
-    mainUserTracking: MainUserTrackingResult;
 }
 export interface MonitorDogVideoDetectionController {
     stop: () => void;
@@ -124,13 +72,9 @@ export interface MonitorDogDetectorOptions {
     video?: HTMLVideoElement;
     onDetect: (result: MonitorDogVideoDetectionResult) => void | Promise<void>;
     onError?: (error: unknown) => void;
-    overlay?: MonitorDogOverlayOptions;
     captureMonitorImage?: () => MonitorDogCaptureImageResult | Promise<MonitorDogCaptureImageResult>;
     constraints?: MediaStreamConstraints;
     runInBackground?: boolean;
-    mainUserTrackingEnabled?: boolean;
-    mainUserTrackingWasmBasePath?: string;
-    mainUserTrackingModelAssetPath?: string;
 }
 export type MonitorDogDetectorSessionStatus = "anonymous" | "authenticated";
 export type MonitorDogDetectorStatus = "idle" | "loading" | "starting" | "running" | "stopped" | "disposed" | "error";
@@ -171,14 +115,27 @@ export interface MonitorDogTokenSet {
     expiresIn?: number;
     expiresAt?: string;
 }
-export type SdkModelAssetName = "detector" | "ort-js" | "ort-wasm" | "mediapipe-vision-wasm-js" | "mediapipe-vision-wasm-wasm" | "mediapipe-pose-landmarker";
-export interface SdkModelResponse {
+export type SdkModelAssetName = "detector";
+export interface SdkAssetKeyResponse {
     encrypted_dek: string;
-    asset_download_url: string;
     asset: SdkModelAssetName;
     input_size: number | null;
     version: string;
 }
+export interface SdkAssetManifestDetectorEntry {
+    file: string;
+    version: string;
+    encryptedSha256: string;
+}
+export interface SdkAssetManifest {
+    environment: string;
+    bundleId: string;
+    assetVersion: string;
+    createdAt: string;
+    assets: {
+        detector: Record<"320" | "416" | "640", SdkAssetManifestDetectorEntry>;
+    };
+}
 export interface LetterboxResult {
     data: ImageData;
     sourceWidth: number;
@@ -319,7 +276,7 @@ export interface UserPreferences {
     mobileDetectionLockDuration: number;
     mobileDetectionEnabled: boolean;
     mobileDetectionMode: LockPolicyValue;
-    language: MonitorDogLanguage;
+    language: "en" | "ko" | "ja";
     faceDetectionThreshold: number;
     noPersonDetectionEnabled: boolean;
     noPersonLockDuration: number;
@@ -327,39 +284,4 @@ export interface UserPreferences {
     multiPersonDetectionEnabled: boolean;
     multiPersonLockDuration: number;
     multiPersonDetectionMode: LockPolicyValue;
-    headTurningThreshold: number;
-    webcamBlockageDetectionEnabled: boolean;
-    webcamBlockageLockDuration: number;
-    webcamBlockageDetectionMode: LockPolicyValue;
 }
-export type LiveStatus = {
-    l?: boolean;
-    k?: string;
-    ku?: string;
-    m?: boolean;
-    d?: DetectionLevel;
-    e?: Array<MinimalEventLockSetting>;
-    s?: boolean;
-    dp?: DlpDetectionPolicy;
-    dls?: number;
-    bl?: Array<string>;
-    require_password_on_resume?: boolean;
-    no_face_lock_delay_seconds?: number;
-    use_face_on_resume?: boolean;
-};
-export type LockLogResponse = {
-    organization_uuid: string;
-    lock_target_type: string;
-    account_uuid: string;
-    lock_level: string;
-    device_uuid: string;
-    uuid: string;
-    locker_uuid: string;
-    reason: string;
-    suspicious_activity_uuid: string;
-    unlocker_uuid: string;
-    unlocked_at: string;
-    created_at: string;
-    updated_at: string;
-    is_active: boolean;
-};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@monitordog/detector",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "type": "module",
-  "description": "Browser SDK for running the bundled MonitorDog ONNX detector.",
+  "description": "Lean browser SDK for MonitorDog local ONNX detection.",
   "license": "SEE LICENSE IN LICENSE",
   "main": "./dist/monitordog-detector.umd.cjs",
   "module": "./dist/monitordog-detector.js",
-  "types": "./dist/monitordog-detector.d.ts",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
@@ -15,7 +15,7 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/monitordog-detector.d.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/monitordog-detector.js",
       "require": "./dist/monitordog-detector.umd.cjs"
     }
@@ -23,25 +23,22 @@
   "sideEffects": false,
   "scripts": {
     "dev": "vite",
-    "build:webcam-frame-analysis-wasm": "powershell -ExecutionPolicy Bypass -File scripts/build-webcam-frame-analysis-wasm.ps1",
-    "build:ort-webassembly-reduced": "powershell -ExecutionPolicy Bypass -File scripts/build-ort-webassembly-reduced.ps1",
-    "build:ort-detector-wasm": "powershell -ExecutionPolicy Bypass -File scripts/build-ort-detector-wasm.ps1",
-    "build:demo": "vite build --config vite.demo.config.ts",
-    "deploy:demo": "npm run build:demo && npx wrangler pages deploy dist-demo --project-name monitordog --branch main --commit-dirty=true",
-    "build": "vite build && tsc -p tsconfig.build.json && node scripts/copy-types.cjs",
+    "build": "vite build && tsc -p tsconfig.build.json",
     "preview": "vite preview",
-    "test": "vitest run"
+    "test": "vitest run",
+    "package:dev": "node scripts/package-sdk.mjs --environment dev",
+    "package:prod": "node scripts/package-sdk.mjs --environment prod",
+    "publish:dry-run": "node scripts/publish-sdk.mjs --skip-package --dry-run",
+    "publish:public": "node scripts/publish-sdk.mjs"
+  },
+  "dependencies": {
+    "html2canvas": "^1.4.1",
+    "onnxruntime-web": "1.24.3"
   },
   "devDependencies": {
-    "@sentry/browser": "^10.53.1",
-    "binaryen": "^129.0.0",
+    "adm-zip": "^0.5.16",
     "typescript": "~6.0.2",
     "vite": "^8.1.2",
-    "vite-plugin-javascript-obfuscator": "^3.1.0",
     "vitest": "^4.1.9"
-  },
-  "dependencies": {
-    "@mediapipe/tasks-vision": "^0.10.35",
-    "html2canvas": "^1.4.1"
   }
 }

package/dist/assets/inference-worker-C-n1YxCo.js

@@ -1,2 +0,0 @@
-(function(){let e=[`phone_back`,`phone_front`,`phone_back_cam`,`cup`,`hand`,`face`];function t(e){let t=new DataView(e.buffer,e.byteOffset,e.byteLength),i=t.getUint32(0,!0),a=t.getUint32(4,!0),o=r(e.byteLength,i+a),s=Uint32Array.BYTES_PER_ELEMENT*2,c=n(t,s,i,{classId:5,label:`face`,recordFloatCount:o});s+=i*o*Float32Array.BYTES_PER_ELEMENT;let l=n(t,s,a,{classId:0,label:`phone`,recordFloatCount:o});return{faceDetected:i>0,phoneDetected:a>0,faceCount:i,phoneCount:a,faceDetections:c,phoneDetections:l}}function n(e,t,n,r){let a=[],o=t;for(let t=0;t<n;t+=1){let t=r.recordFloatCount===7,n=t?e.getFloat32(o,!0):r.classId,s=t?o+Float32Array.BYTES_PER_ELEMENT:o;a.push({classId:n,label:t?i(n):r.label,score:e.getFloat32(s,!0),confidence:e.getFloat32(s+4,!0),x:e.getFloat32(s+8,!0),y:e.getFloat32(s+12,!0),width:e.getFloat32(s+16,!0),height:e.getFloat32(s+20,!0)}),o+=r.recordFloatCount*Float32Array.BYTES_PER_ELEMENT}return a}function r(e,t){return t===0||e-Uint32Array.BYTES_PER_ELEMENT*2==t*7*Float32Array.BYTES_PER_ELEMENT?7:6}function i(t){return e[t]??`unknown`}async function a(e){return c({...e,asset:`detector`,inputSize:e.inputSize,errorContext:`model`})}async function o(e){let t=await c({apiBaseUrl:e.apiBaseUrl,accessToken:e.accessToken,asset:`ort-js`,errorContext:`ORT JS runtime`});try{return new TextDecoder().decode(t)}finally{t.fill(0)}}async function s(e){return c({apiBaseUrl:e.apiBaseUrl,accessToken:e.accessToken,asset:`ort-wasm`,errorContext:`ORT WASM runtime`})}async function c(e){x();let t=await crypto.subtle.generateKey({name:`RSA-OAEP`,modulusLength:2048,publicExponent:new Uint8Array([1,0,1]),hash:`SHA-256`},!0,[`decrypt`]),n=m(await f(t.publicKey)),r=await l({apiBaseUrl:e.apiBaseUrl,accessToken:e.accessToken,asset:e.asset,inputSize:e.inputSize,errorContext:e.errorContext},n),i=await u(r.asset_download_url),a=new Uint8Array(await crypto.subtle.decrypt({name:`RSA-OAEP`},t.privateKey,b(h(r.encrypted_dek)))),o=g(a);try{return await d(i,o)}finally{i.fill(0),a.fill(0),o.fill(0)}}async function l(e,t){let n=new URLSearchParams({asset:e.asset,public_key:t});e.inputSize!==void 0&&n.set(`input_size`,String(e.inputSize));let r=await fetch(`${e.apiBaseUrl}/auth/sdk-assets?${n}`,{method:`GET`,headers:{accept:`application/json`,authorization:`Bearer ${e.accessToken}`,"Device-Access-Token":e.accessToken}});if(!r.ok)throw Error(`MonitorDog SDK ${e.errorContext} request failed: ${r.status}`);let i=await r.json();if(!i.encrypted_dek||!i.asset_download_url)throw Error(`MonitorDog SDK ${e.errorContext} response is incomplete.`);return{encrypted_dek:i.encrypted_dek,asset_download_url:i.asset_download_url,asset:i.asset??e.asset,input_size:i.input_size??null,version:i.version??``}}async function u(e){let t=await fetch(e);if(!t.ok)throw Error(`Failed to download MonitorDog model: ${t.status} ${t.statusText}`);return new Uint8Array(await t.arrayBuffer())}async function d(e,t){if(e.byteLength<=12)throw Error(`MonitorDog encrypted model data is too short.`);let n=await crypto.subtle.importKey(`raw`,b(t),{name:`AES-GCM`},!1,[`decrypt`]),r=e.slice(0,12),i=e.slice(12);return new Uint8Array(await crypto.subtle.decrypt({name:`AES-GCM`,iv:b(r)},n,b(i)))}async function f(e){let t=await crypto.subtle.exportKey(`spki`,e);return[`-----BEGIN PUBLIC KEY-----`,...p(new Uint8Array(t)).match(/.{1,64}/g)??[],`-----END PUBLIC KEY-----`].join(`
-`)}function p(e){let t=``;for(let n of e)t+=String.fromCharCode(n);return btoa(t)}function m(e){return p(new TextEncoder().encode(e))}function h(e){let t=e.replace(/-----BEGIN [^-]+-----/g,``).replace(/-----END [^-]+-----/g,``).replace(/\s/g,``).replace(/-/g,`+`).replace(/_/g,`/`),n=(4-t.length%4)%4,r=t+`=`.repeat(n),i=atob(r),a=new Uint8Array(i.length);for(let e=0;e<i.length;e+=1)a[e]=i.charCodeAt(e);return a}function g(e){if(y(e.byteLength))return new Uint8Array(e);let t=new TextDecoder().decode(e).trim(),n=_(t.startsWith(`"`)&&t.endsWith(`"`)?t.slice(1,-1):t);if(n&&y(n.byteLength))return n;throw Error(`MonitorDog SDK model DEK must decode to a 128-bit or 256-bit AES key. Received ${e.byteLength} bytes.`)}function _(e){if(/^[0-9a-f]+$/i.test(e)&&e.length%2==0)return v(e);try{return h(e)}catch{return}}function v(e){let t=new Uint8Array(e.length/2);for(let n=0;n<t.length;n+=1)t[n]=Number.parseInt(e.slice(n*2,n*2+2),16);return t}function y(e){return e===16||e===32}function b(e){let t=new ArrayBuffer(e.byteLength);return new Uint8Array(t).set(e),t}function x(){if(!globalThis.crypto?.subtle)throw Error(`MonitorDog SDK model decryption requires Web Crypto API.`)}var S=class{loadOptions;module;loadPromise;wasmBlobUrl;detectorInputPointer=0;detectorInputByteLength=0;detectorDimsPointer=0;detectorDimsByteLength=0;detectorOutputDataPointerPointer=0;detectorOutputByteLengthPointer=0;constructor(e){this.loadOptions=e}async load(e){this.loadPromise||=this.loadModel(e),await this.loadPromise}async run(e){let t=await this.getModule();if(e.input.type!==`float32`)throw Error(`ort-detector PoC only supports float32 input tensors.`);if(!(e.input.data instanceof Float32Array))throw Error(`ort-detector PoC expected Float32Array input data.`);let n=e.input.data,r=t._malloc(n.byteLength),i=t._malloc(e.input.dims.length*8),a=t._malloc(4),o=t._malloc(4),s=t._malloc(4),c=t._malloc(4);try{t.HEAPF32.set(n,r/Float32Array.BYTES_PER_ELEMENT),C(t,i,e.input.dims),T(t,t._md_ort_run_float32_nchw(r,n.length,i,e.input.dims.length,a,o,s,c),`ort-detector inference failed`);let l=t.getValue(a,`*`),u=t.getValue(o,`i32`),d=t.getValue(s,`*`),f=t.getValue(c,`i32`);try{let n=new Float32Array(u);return n.set(t.HEAPF32.subarray(l/Float32Array.BYTES_PER_ELEMENT,l/Float32Array.BYTES_PER_ELEMENT+u)),{output:{type:`float32`,data:n,dims:w(t,d,f)},input:e.metadata}}finally{t._md_ort_free(l),t._md_ort_free(d)}}finally{t.HEAPU8.fill(0,r,r+n.byteLength),t._free(r),t._free(i),t._free(a),t._free(o),t._free(s),t._free(c)}}async runDetector(e){let n=await this.getModule();if(e.input.type!==`float32`)throw Error(`ort-detector only supports float32 input tensors.`);if(!(e.input.data instanceof Float32Array))throw Error(`ort-detector expected Float32Array input data.`);let r=e.input.data,i=this.ensureDetectorBuffers(n,r.byteLength,e.input.dims.length*BigInt64Array.BYTES_PER_ELEMENT);n.HEAPF32.set(r,i.inputPointer/Float32Array.BYTES_PER_ELEMENT),C(n,i.dimsPointer,e.input.dims),T(n,n._md_ort_run_detector_float32_nchw(i.inputPointer,r.length,i.dimsPointer,e.input.dims.length,e.metadata.sourceWidth,e.metadata.sourceHeight,e.metadata.ratio,e.metadata.padX,e.metadata.padY,e.confidenceThreshold,e.faceConfidenceThreshold,e.iouThreshold,e.maxDetections,i.outputDataPointerPointer,i.outputByteLengthPointer),`ort-detector run failed`);let a=n.getValue(i.outputDataPointerPointer,`*`),o=n.getValue(i.outputByteLengthPointer,`i32`);try{return t(n.HEAPU8.subarray(a,a+o))}finally{n._md_ort_free(a)}}dispose(){this.releaseDetectorBuffers(),this.module?._md_ort_dispose(),this.module=void 0,this.loadPromise=void 0,this.revokeWasmBlobUrl()}async loadModel(e){let t=await this.getModule();try{let n=t._malloc(e.byteLength);try{t.HEAPU8.set(e,n),T(t,t._md_ort_load_model(n,e.byteLength),`ort-detector model load failed`)}finally{t.HEAPU8.fill(0,n,n+e.byteLength),t._free(n)}}finally{e.fill(0)}}async getModule(){if(!this.module){let[e,t]=await Promise.all([o(this.loadOptions),s(this.loadOptions)]),n=new Blob([e],{type:`text/javascript`}),r=URL.createObjectURL(n),i=URL.createObjectURL(new Blob([E(t)],{type:`application/wasm`})),a;try{a=(await import(r)).default}finally{t.fill(0),URL.revokeObjectURL(r)}this.revokeWasmBlobUrl(),this.wasmBlobUrl=i,this.module=await a({locateFile:e=>e.endsWith(`.wasm`)?i:e});let c=this.module._md_ort_init();T(this.module,c,`ort-detector initialization failed`)}return this.module}ensureDetectorBuffers(e,t,n){return this.detectorInputByteLength<t&&(this.detectorInputPointer&&(e.HEAPU8.fill(0,this.detectorInputPointer,this.detectorInputPointer+this.detectorInputByteLength),e._free(this.detectorInputPointer)),this.detectorInputPointer=e._malloc(t),this.detectorInputByteLength=t),this.detectorDimsByteLength<n&&(this.detectorDimsPointer&&e._free(this.detectorDimsPointer),this.detectorDimsPointer=e._malloc(n),this.detectorDimsByteLength=n),this.detectorOutputDataPointerPointer||=e._malloc(4),this.detectorOutputByteLengthPointer||=e._malloc(4),{inputPointer:this.detectorInputPointer,dimsPointer:this.detectorDimsPointer,outputDataPointerPointer:this.detectorOutputDataPointerPointer,outputByteLengthPointer:this.detectorOutputByteLengthPointer}}releaseDetectorBuffers(){let e=this.module;if(!e){this.resetDetectorBuffers();return}this.detectorInputPointer&&(e.HEAPU8.fill(0,this.detectorInputPointer,this.detectorInputPointer+this.detectorInputByteLength),e._free(this.detectorInputPointer)),this.detectorDimsPointer&&e._free(this.detectorDimsPointer),this.detectorOutputDataPointerPointer&&e._free(this.detectorOutputDataPointerPointer),this.detectorOutputByteLengthPointer&&e._free(this.detectorOutputByteLengthPointer),this.resetDetectorBuffers()}resetDetectorBuffers(){this.detectorInputPointer=0,this.detectorInputByteLength=0,this.detectorDimsPointer=0,this.detectorDimsByteLength=0,this.detectorOutputDataPointerPointer=0,this.detectorOutputByteLengthPointer=0}revokeWasmBlobUrl(){this.wasmBlobUrl&&=(URL.revokeObjectURL(this.wasmBlobUrl),void 0)}};function C(e,t,n){let r=t/BigInt64Array.BYTES_PER_ELEMENT;for(let t=0;t<n.length;t+=1)e.HEAP64[r+t]=BigInt(n[t])}function w(e,t,n){let r=t/BigInt64Array.BYTES_PER_ELEMENT,i=[];for(let t=0;t<n;t+=1)i.push(Number(e.HEAP64[r+t]));return i}function T(e,t,n){if(t===0)return;let r=e._md_ort_get_last_error(),i=r?e.UTF8ToString(r):``;throw Error(i||n)}function E(e){let t=new ArrayBuffer(e.byteLength);return new Uint8Array(t).set(e),t}let D=self,O,k=Promise.resolve();D.addEventListener(`message`,e=>{A(e.data)});async function A(e){try{if(e.type===`load`){O?.dispose(),O=new S(e.model),await O.load(await a(e.model)),z({id:e.id,ok:!0});return}let t=await j(e);z({id:e.id,ok:!0,result:t})}catch(t){z({id:e.id,ok:!1,error:t instanceof Error?t.message:String(t)})}}function j(e){let t=k.then(()=>M(e));return k=t.then(()=>void 0,()=>void 0),t}async function M(e){return N(e)}async function N(e){if(!O)throw Error(`ort-detector runtime is not loaded.`);let t=e.debug?performance.now():0,n=e.debug?performance.now():0,{input:r,metadata:i}=e.source.kind===`bitmap`?P(e.source,e.inputSize,e.inputType):F(e.source,e.inputSize,e.inputType),a=e.debug?performance.now():0,o=await O.runDetector({input:r,metadata:i,confidenceThreshold:e.confidenceThreshold,faceConfidenceThreshold:e.faceConfidenceThreshold,iouThreshold:e.iouThreshold,maxDetections:e.maxDetections});if(e.debug){let r=performance.now();console.info(`[MonitorDog] worker inference`,{source:e.source.kind,inputSize:e.inputSize,preprocessMs:B(a-n),ortMs:B(r-a),totalMs:B(r-t)})}return o}function P(e,t,n){try{if(typeof OffscreenCanvas>`u`)throw Error(`OffscreenCanvas is not available.`);let r=I(e.sourceWidth,e.sourceHeight,t),i=new OffscreenCanvas(t,t).getContext(`2d`);if(!i)throw Error(`2D canvas context is not available.`);return i.fillStyle=`rgb(114, 114, 114)`,i.fillRect(0,0,t,t),i.drawImage(e.bitmap,r.padX,r.padY,Math.round(e.sourceWidth*r.ratio),Math.round(e.sourceHeight*r.ratio)),{input:R(i.getImageData(0,0,t,t).data,n,t),metadata:r}}finally{e.bitmap.close()}}function F(e,t,n){let r=I(e.sourceWidth,e.sourceHeight,t);return{input:L(e.data,e.sourceWidth,e.sourceHeight,r,t,n),metadata:r}}function I(e,t,n){let r=Math.min(n/e,n/t);return{sourceWidth:e,sourceHeight:t,ratio:r,padX:Math.floor((n-Math.round(e*r))/2),padY:Math.floor((n-Math.round(t*r))/2)}}function L(e,t,n,r,i,a){let o=i*i,s=[1,3,i,i],c=a===`uint8`?new Uint8Array(o*3):new Float32Array(o*3);for(let s=0;s<i;s+=1)for(let l=0;l<i;l+=1){let u=s*i+l,d=Math.floor((l-r.padX)/r.ratio),f=Math.floor((s-r.padY)/r.ratio),p=d>=0&&f>=0&&d<t&&f<n,m=(f*t+d)*4,h=p?e[m]:114,g=p?e[m+1]:114,_=p?e[m+2]:114;a===`uint8`?(c[u]=h,c[u+o]=g,c[u+o*2]=_):(c[u]=h/255,c[u+o]=g/255,c[u+o*2]=_/255)}return{type:a,data:c,dims:s}}function R(e,t,n){let r=n*n,i=[1,3,n,n];if(t===`uint8`){let t=new Uint8Array(r*3);for(let n=0;n<r;n+=1){let i=n*4;t[n]=e[i],t[n+r]=e[i+1],t[n+r*2]=e[i+2]}return{type:`uint8`,data:t,dims:i}}let a=new Float32Array(r*3);for(let t=0;t<r;t+=1){let n=t*4;a[t]=e[n]/255,a[t+r]=e[n+1]/255,a[t+r*2]=e[n+2]/255}return{type:`float32`,data:a,dims:i}}function z(e,t){D.postMessage(e,t??[])}function B(e){return Math.round(e*10)/10}})();

package/dist/detect/wasm/webcam-frame-analysis-wasm-bytes.d.ts

@@ -1 +0,0 @@
-export declare const WEBCAM_FRAME_ANALYSIS_WASM_BYTES: Uint8Array<ArrayBuffer>;

package/dist/detect/webcam-blockage-detector.d.ts

@@ -1,32 +0,0 @@
-import { type WebcamFrameAnalysis } from "./webcam-frame-analysis";
-export interface WebcamBlockageAnalysis {
-    blocked: boolean;
-    suspected: boolean;
-    likelyCovered: boolean;
-    changedCoverage: number;
-}
-export declare class WebcamBlockageDetector {
-    private previousFrameData?;
-    private baselineFrameData?;
-    private baselineEdgeDensity?;
-    private baselineEdgeDensityUpdatedAt?;
-    private baselineColorVariance?;
-    private baselineLuminanceHistogram?;
-    private smoothedEdgeDensity?;
-    private smoothedEdgeDensityUpdatedAt?;
-    private blocked;
-    private blockedStartedAt?;
-    private baselineRefreshPending;
-    private clearSampleCount;
-    private startedAt;
-    private calibrated;
-    private calibrationNoiseSamples;
-    private adaptivePixelChangeThreshold;
-    analyze(frame: WebcamFrameAnalysis): WebcamBlockageAnalysis;
-    reset(): void;
-    needsBaselineRefresh(): boolean;
-    refreshBaseline(frame: WebcamFrameAnalysis): void;
-    private finalizeCalibration;
-    private smoothEdgeDensity;
-    private updateBaselineEdgeDensity;
-}

package/dist/detect/webcam-frame-analysis-wasm.d.ts

@@ -1,47 +0,0 @@
-export declare const WEBCAM_ANALYSIS_LIGHTING_NONE = 0;
-export declare const WEBCAM_ANALYSIS_LIGHTING_TOO_DARK = 1;
-export declare const WEBCAM_ANALYSIS_LIGHTING_TOO_BRIGHT = 2;
-export interface WebcamFrameWasmAnalysis {
-    edgeDensity: number;
-    coverage: number;
-    colorVariance: number;
-    averageLuminance: number;
-    luminanceSpread: number;
-    luminanceHistogram: Uint16Array;
-    normalizedLuminanceHistogram: Float32Array;
-    darkRatio: number;
-    brightRatio: number;
-    blackout: boolean;
-    lightingIssueCode: number;
-}
-export interface WebcamBlockageWasmInput {
-    image: ImageData;
-    previousFrameData?: Uint8ClampedArray;
-    baselineFrameData?: Uint8ClampedArray;
-    pixelChangeThreshold: number;
-    edgeDensity: number;
-    baselineEdgeDensity?: number;
-    colorVariance: number;
-    baselineColorVariance?: number;
-    luminanceEntropy: number;
-    luminanceSpread: number;
-    normalizedLuminanceHistogram: Float32Array;
-    baselineLuminanceHistogram?: Float32Array;
-    blackout: boolean;
-    currentlyBlocked: boolean;
-}
-export interface WebcamBlockageWasmAnalysis {
-    changedCoverage: number;
-    previousChangedCoverage: number;
-    frameNoiseAverage: number;
-    hasCoveredArea: boolean;
-    detected: boolean;
-    likelyCovered: boolean;
-}
-export declare class WebcamFrameAnalysisWasm {
-    private readonly exports;
-    constructor();
-    analyze(image: ImageData): WebcamFrameWasmAnalysis;
-    analyzeBlockage(input: WebcamBlockageWasmInput): WebcamBlockageWasmAnalysis;
-}
-export declare const webcamFrameAnalysisWasm: WebcamFrameAnalysisWasm;

package/dist/detect/webcam-frame-analysis.d.ts

@@ -1,34 +0,0 @@
-export interface WebcamFrameAnalysis {
-    image: ImageData;
-    pixelCount: number;
-    edgeDensity: number;
-    coverage: number;
-    colorVariance: number;
-    averageLuminance: number;
-    luminanceSpread: number;
-    luminanceEntropy: number;
-    luminanceHistogram: Uint16Array;
-    normalizedLuminanceHistogram: Float32Array;
-    darkRatio: number;
-    brightRatio: number;
-    blackout: boolean;
-    lightingIssueCode: number;
-}
-export declare const WEBCAM_ANALYSIS_SAMPLE_WIDTH = 40;
-export declare const WEBCAM_ANALYSIS_SAMPLE_HEIGHT = 30;
-export declare const LUMINANCE_HISTOGRAM_BINS = 16;
-export declare class WebcamFrameAnalyzer {
-    private readonly context;
-    constructor();
-    analyze(video: HTMLVideoElement): WebcamFrameAnalysis;
-}
-export declare function analyzeWebcamFrame(image: ImageData): WebcamFrameAnalysis;
-export declare function captureWebcamFrame(context: CanvasRenderingContext2D, video: HTMLVideoElement): ImageData;
-export declare function createWebcamAnalysisCanvas(errorMessage: string): {
-    canvas: HTMLCanvasElement;
-    context: CanvasRenderingContext2D;
-};
-export declare function getPixelLuminance(data: Uint8ClampedArray, index: number): number;
-export declare function normalizeHistogram(histogram: Uint16Array, pixelCount: number): Float32Array;
-export declare function getHistogramDistance(current: Float32Array, baseline: Float32Array): number;
-export declare function isWebcamBlackoutFrame(frame: WebcamFrameAnalysis): boolean;

package/dist/detect/webcam-lighting-detector.d.ts

@@ -1,21 +0,0 @@
-import { type WebcamFrameAnalysis } from "./webcam-frame-analysis";
-export type WebcamLightingIssue = "tooDark" | "tooBright";
-export interface WebcamLightingAnalysis {
-    issue?: WebcamLightingIssue;
-    active: boolean;
-    averageLuminance: number;
-    luminanceSpread: number;
-    luminanceEntropy: number;
-    darkRatio: number;
-    brightRatio: number;
-}
-export declare class WebcamLightingDetector {
-    private startedAt;
-    private issueStartedAt?;
-    private clearStartedAt?;
-    private pendingIssue?;
-    private activeIssue?;
-    analyze(frame: WebcamFrameAnalysis): WebcamLightingAnalysis;
-    reset(): void;
-    private detectIssue;
-}

package/dist/language.d.ts

@@ -1,6 +0,0 @@
-import type { MonitorDogLanguage, MonitorDogOverlayMessages } from "./types";
-export declare const DEFAULT_MONITORDOG_LANGUAGE: MonitorDogLanguage;
-export declare const MONITORDOG_OVERLAY_MESSAGES: Record<MonitorDogLanguage, MonitorDogOverlayMessages>;
-export declare function resolveMonitorDogLanguage(language: string | undefined): MonitorDogLanguage;
-export declare function getMonitorDogOverlayMessages(language: string | undefined): MonitorDogOverlayMessages;
-export declare function getBrowserMonitorDogLanguage(): MonitorDogLanguage;

package/dist/monitordog-detector.d.ts

@@ -1,41 +0,0 @@
-import type { MonitorDogDetectorOptions, MonitorDogDetectorState, MonitorDogLoginRequest, MonitorDogSessionToken, UserPreferences } from "./types";
-export declare class MonitorDogDetector {
-    #private;
-    static init(options: MonitorDogDetectorOptions): Promise<MonitorDogDetector>;
-    constructor(options: MonitorDogDetectorOptions);
-    load(): Promise<void>;
-    login(request: MonitorDogLoginRequest): Promise<MonitorDogSessionToken>;
-    private completeAuthenticatedLogin;
-    logout(): Promise<void>;
-    start(): Promise<void>;
-    stop(): void;
-    setRunInBackground(runInBackground: boolean): void;
-    getUserPreferences(): Readonly<UserPreferences>;
-    isMainUserTrackingEnabled(): boolean;
-    setMainUserTrackingEnabled(enabled: boolean): void;
-    getState(): MonitorDogDetectorState;
-    dispose(): void;
-    private resetLoggedOutState;
-    private rollbackAuthenticatedLogin;
-    private startRuntime;
-    private clearSessionState;
-    private stopLocalRuntime;
-    private assertUsable;
-    private assertAuthenticated;
-    private lifecycleError;
-    private transitionToError;
-    private updateState;
-    private notifyStatusChange;
-    private createSdkError;
-    private isDetectorRunning;
-    private hasRuntimeToStop;
-    private getStartErrorCode;
-    private getStartErrorMessage;
-    private isCameraPermissionError;
-    private isCameraReadError;
-}
-export declare function configureMonitorDogDetector(options: MonitorDogDetectorOptions): MonitorDogDetector;
-export declare function createMonitorDogDetector(options: MonitorDogDetectorOptions): Promise<MonitorDogDetector>;
-export declare function getDetector(): MonitorDogDetector;
-export { MonitorDogSdkError, isMonitorDogSdkError } from "./sdk-error";
-export type { AccountResponse, LockPolicyResponse, MonitorDogDetection, MonitorDogDetectionResult, MonitorDogDetectorCameraStatus, MonitorDogDetectorOptions, MonitorDogDetectorSessionStatus, MonitorDogDetectorState, MonitorDogDetectorStatus, MonitorDogLoginRequest, MonitorDogSdkErrorCode, MonitorDogSdkTokenResponse, MonitorDogSessionToken, MonitorDogSessionTokenProvider, MonitorDogVideoDetectionResult, UserPreferences, } from "./types";

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

@@ -1,16 +0,0 @@
-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>;