@monitordog/detector 1.0.0

package/LICENSE

@@ -0,0 +1,10 @@
+Copyright (c) 2026 Spresto, Inc. All rights reserved.
+
+This package is proprietary MonitorDog software.
+
+You may install and use this package only to integrate with MonitorDog services
+under a written agreement with Spresto or applicable MonitorDog terms.
+
+You may not copy, modify, redistribute, sublicense, reverse engineer, or use this
+package to build a competing product except as expressly permitted by that
+agreement.

package/README.md

@@ -0,0 +1,129 @@
+# @monitordog/detector
+
+Browser SDK for MonitorDog webcam detection. The SDK runs the bundled detector in the browser, uploads evidence images when needed, and sends detection/user-activity events to the MonitorDog API.
+
+## Install
+
+```bash
+npm install @monitordog/detector
+```
+
+## Login Access Token Flow
+
+`login({ email })` calls the `sessionTokenProvider` registered in `MonitorDogDetector.init()`. The provider should call your server endpoint and return a short-lived MonitorDog SDK access token to the browser.
+
+```text
+login({ email }) -> sessionTokenProvider({ email }) -> customer backend -> POST /v1/sdk/sessions -> browser SDK
+```
+
+Do not put a MonitorDog partner API key in browser code, browser environment variables, local storage, or a frontend-only proxy. The customer backend owns the partner API key and returns only a short-lived SDK access token to the browser.
+
+Browser integration:
+
+```ts
+import { MonitorDogDetector } from "@monitordog/detector";
+
+async function getMonitorDogAccessToken({ email }: { email: string }) {
+  const response = await fetch("/api/monitordog/access-token", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    credentials: "include",
+    body: JSON.stringify({ email }),
+  });
+
+  if (!response.ok) {
+    throw new Error("Failed to issue MonitorDog access token.");
+  }
+
+  return response.json();
+}
+
+const detector = await MonitorDogDetector.init({
+  apiBaseUrl: "https://api.monitor.dog/v1",
+  sessionTokenProvider: getMonitorDogAccessToken,
+  overlay: {
+    enabled: true,
+    locale: "en",
+  },
+  onDetect(result) {
+    console.log("MonitorDog detection", result);
+  },
+});
+
+await detector.login({ email: "user@example.com" });
+await detector.start();
+
+// Later, before ending the SDK session:
+detector.stop();
+await detector.logout();
+```
+
+Customer backend `/api/monitordog/access-token` example:
+
+```ts
+export async function POST(request: Request) {
+  const { email } = await request.json();
+
+  const response = await fetch("https://api.monitor.dog/v1/sdk/sessions", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${process.env.MONITORDOG_PARTNER_API_KEY}`,
+    },
+    body: JSON.stringify({ email }),
+  });
+
+  return new Response(await response.text(), {
+    status: response.status,
+    headers: { "content-type": "application/json" },
+  });
+}
+```
+
+## Public Runtime Calls
+
+Across `login({ email })` and `start()`, the SDK runtime is expected to call only these MonitorDog API paths:
+
+- `GET /account/me`
+- `GET /account/{uuid}/lock_policy`
+- `GET /auth/sdk-model`
+- `POST /file/image`
+- `POST /event`
+
+The browser SDK does not call password login, MFA, refresh-token, cookie-refresh, remote stream, remote unlock, or policy update APIs.
+
+## Public API
+
+The package entry is `src/index.ts`; generated declarations are copied to `dist/monitordog-detector.d.ts`.
+
+Official customer entrypoint:
+
+- `MonitorDogDetector.init(options)`
+
+Compatibility exports for older integrations:
+
+- `configureMonitorDogDetector(options)`
+- `createMonitorDogDetector(options)`
+- `getDetector()`
+
+Detector methods:
+
+- `login({ email })`
+- `load()`
+- `start()`
+- `stop()`
+- `logout()`
+- `dispose()`
+- `getState()`
+- `setRunInBackground(runInBackground)`
+- `getUserPreferences()`
+- `isMainUserTrackingEnabled()`
+- `setMainUserTrackingEnabled(enabled)`
+
+Default lifecycle:
+
+```text
+init -> login -> start -> stop -> logout -> dispose
+```
+
+`login({ email })` only prepares the SDK session, login event, account state, and policy state. `start()` loads the model, requests camera access, and starts the detection loop. `stop()` stops local detection while keeping the SDK token/session alive. `logout()` ends the SDK session and must be called after `stop()` if the detector is running. `dispose()` force-cleans local resources and marks the instance unusable.

package/dist/assets/inference-worker-BqvxPw8S.js

@@ -0,0 +1,2 @@
+(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,buildVersion:e.modelBuildVersion,buildNumber:e.modelBuildNumber,errorContext:`model`})}async function o(e){let t=await c({...e,buildVersion:e.modelBuildVersion,buildNumber:`ort-js`,errorContext:`ORT JS runtime`});try{return new TextDecoder().decode(t)}finally{t.fill(0)}}async function s(e){return c({...e,buildVersion:e.modelBuildVersion,buildNumber:`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,buildVersion:e.buildVersion,buildNumber:e.buildNumber,errorContext:e.errorContext},n),i=await u(r.model_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({build_version:e.buildVersion,build_number:String(e.buildNumber),public_key:t}),r=await fetch(`${e.apiBaseUrl}/auth/sdk-model?${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.model_download_url)throw Error(`MonitorDog SDK ${e.errorContext} response is incomplete.`);return{encrypted_dek:i.encrypted_dek,model_download_url:i.model_download_url}}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/auth.d.ts

@@ -0,0 +1,6 @@
+import type { MonitorDogSessionToken, MonitorDogTokenSet } from "./types";
+export declare function getAccessToken(payload: MonitorDogSessionToken): string | undefined;
+export declare function getExpiresIn(payload: MonitorDogSessionToken): number | undefined;
+export declare function getExpiresAt(payload: MonitorDogSessionToken): string | undefined;
+export declare function getTokenExpiresAt(tokens: MonitorDogTokenSet): number | undefined;
+export declare function normalizeBaseUrl(baseUrl: string): string;

package/dist/capture.d.ts

@@ -0,0 +1,2 @@
+export declare function captureVideoFrame(video: HTMLVideoElement): Promise<Blob>;
+export declare function captureDocumentBody(): Promise<Blob | null>;

package/dist/constants.d.ts

@@ -0,0 +1,21 @@
+export declare const DEFAULT_INPUT_SIZE = 640;
+export declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.8;
+export declare const DEFAULT_IOU_THRESHOLD = 0.7;
+export declare const DEFAULT_MAX_DETECTIONS = 100;
+export declare const DEFAULT_DETECTION_INTERVAL_MS = 300;
+export declare const DEFAULT_MOBILE_INPUT_SIZE = 416;
+export declare const DEFAULT_LOW_MEMORY_INPUT_SIZE = 320;
+export declare const DEFAULT_REFRESH_BEFORE_MS = 60000;
+export declare const DEFAULT_PERIODIC_REFRESH_INTERVAL_MS = 30000;
+export declare const DEFAULT_MODEL_BUILD_VERSION = "0.0.2";
+export declare const MAIN_USER_TRACKING_ENABLED_STORAGE_KEY = "monitordog.mainUserTracking.enabled";
+export declare const ORT_JS_BUILD_NUMBER = "ort-js";
+export declare const ORT_WASM_BUILD_NUMBER = "ort-wasm";
+export declare const DEFAULT_MEDIAPIPE_BUILD_VERSION = "0.0.1";
+export declare const MEDIAPIPE_POSE_LANDMARKER_BUILD_NUMBER = "pose_landmarker_lite.task";
+export declare const MEDIAPIPE_VISION_WASM_INTERNAL_JS_BUILD_NUMBER = "vision_wasm_internal.js";
+export declare const MEDIAPIPE_VISION_WASM_INTERNAL_WASM_BUILD_NUMBER = "vision_wasm_internal.wasm";
+export declare const MEDIAPIPE_VISION_WASM_MODULE_INTERNAL_JS_BUILD_NUMBER = "vision_wasm_module_internal.js";
+export declare const MEDIAPIPE_VISION_WASM_MODULE_INTERNAL_WASM_BUILD_NUMBER = "vision_wasm_module_internal.wasm";
+export declare const MEDIAPIPE_VISION_WASM_NOSIMD_INTERNAL_JS_BUILD_NUMBER = "vision_wasm_nosimd_internal.js";
+export declare const MEDIAPIPE_VISION_WASM_NOSIMD_INTERNAL_WASM_BUILD_NUMBER = "vision_wasm_nosimd_internal.wasm";

package/dist/detect/inference-worker-client.d.ts

@@ -0,0 +1,24 @@
+import type { MonitorDogInferenceSource, InternalDetectionResult } from "../types";
+import type { WorkerModelLoadOptions } from "./model-loader";
+export declare class InferenceWorkerClient {
+    private worker?;
+    private nextRequestId;
+    private readonly pendingRequests;
+    load(options: WorkerModelLoadOptions): Promise<void>;
+    run(options: {
+        source: MonitorDogInferenceSource;
+        inputSize: number;
+        inputType: "float32" | "uint8";
+        confidenceThreshold: number;
+        faceConfidenceThreshold: number;
+        iouThreshold: number;
+        maxDetections: number;
+        debug: boolean;
+    }): Promise<InternalDetectionResult>;
+    terminate(): void;
+    private request;
+    private getWorker;
+    private readonly handleMessage;
+    private readonly handleError;
+    private rejectPendingRequests;
+}

package/dist/detect/model-loader.d.ts

@@ -0,0 +1,17 @@
+export type WorkerModelLoadOptions = {
+    apiBaseUrl: string;
+    accessToken: string;
+    modelBuildVersion: string;
+    modelBuildNumber: string | number;
+};
+export type SdkAssetLoadOptions = {
+    apiBaseUrl: string;
+    accessToken: string;
+    buildVersion: string;
+    buildNumber: string | number;
+    errorContext: string;
+};
+export declare function downloadAndDecryptModel(options: WorkerModelLoadOptions): Promise<Uint8Array>;
+export declare function downloadAndDecryptOrtJs(options: WorkerModelLoadOptions): Promise<string>;
+export declare function downloadAndDecryptOrtWasm(options: WorkerModelLoadOptions): Promise<Uint8Array>;
+export declare function downloadAndDecryptSdkAsset(options: SdkAssetLoadOptions): Promise<Uint8Array>;

package/dist/detect/preprocess.d.ts

@@ -0,0 +1,8 @@
+import type { MonitorDogImageSource, LetterboxResult, MonitorDogTensorDataPayload, MonitorDogInferenceSource } from "../types";
+export declare function preprocessImage(source: MonitorDogImageSource, inputSize: number): LetterboxResult;
+export declare function createInputTensor(imageData: ImageData, inputType: "float32" | "uint8", inputSize: number): MonitorDogTensorDataPayload;
+export declare function createInferenceSource(source: MonitorDogImageSource): Promise<MonitorDogInferenceSource>;
+export declare function getSourceSize(source: MonitorDogImageSource): {
+    sourceWidth: number;
+    sourceHeight: number;
+};

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+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/environment.d.ts

@@ -0,0 +1,11 @@
+import type { DeviceOs, DeviceType } from "./types";
+export type MainUserTrackerSupport = {
+    enabled: boolean;
+    reason?: string;
+    deviceType: DeviceType;
+    cpuCores: number;
+    deviceMemoryGb?: number;
+};
+export declare function getDeviceType(): DeviceType;
+export declare function getDeviceOs(): DeviceOs;
+export declare function getMainUserTrackerSupport(): MainUserTrackerSupport;

package/dist/events.d.ts

@@ -0,0 +1,8 @@
+import type { CreateEventPayload, DetectionEvent, DetectionReasonEnum, InternalDetectionResult, MonitorDogUserActivityEventType } from "./types";
+import type { MainUserTrackingResult } from "./pose/mediapipe-main-user-tracker";
+import type { WebcamBlockageAnalysis } from "./detect/webcam-blockage-detector";
+export declare function createDetectionEvent(result: InternalDetectionResult, trackingResult: MainUserTrackingResult): DetectionEvent | undefined;
+export declare function createWebcamBlockedEvent(analysis: WebcamBlockageAnalysis): DetectionEvent;
+export declare function createUserActivityEvent(eventType: MonitorDogUserActivityEventType): CreateEventPayload;
+export declare function isNormalDetectionState(result: InternalDetectionResult, trackingResult: MainUserTrackingResult): boolean;
+export declare function getActivityId(event: DetectionReasonEnum): string;

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+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/language.d.ts

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

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