@authme/engine 2.2.0-rc.9 → 2.2.1-rc.1

package/assets/engine-worker.js

@@ -3,8 +3,6 @@
   let wasm_loaded = false;
   let wasm_loading = false;
 
-  let modelSession = {};
-
   function importScriptsViaJsContent(jsContent) {
     const objectUrl = URL.createObjectURL(
       new Blob([jsContent], { type: 'text/javascript' })
@@ -13,40 +11,8 @@
     URL.revokeObjectURL(objectUrl);
   }
 
-  function base64toBlob(data) {
-    const byteChars = self.atob(data);
-    const byteNumbers = new Array(byteChars.length);
-    for (let i = 0; i < byteChars.length; i++) {
-      byteNumbers[i] = byteChars.charCodeAt(i);
-    }
-    const byteArray = new Uint8Array(byteNumbers);
-    return new Blob([byteArray], { type: 'application/octet-stream' });
-  }
-
-  async function fetchModel(code) {
-    const method = self.config.dataTransferMethod || 'binary';
-
-    const resp = await fetch(
-      `${self.config.apiBaseUrl}/api/model-management/v1/model/${code}${
-        method === 'binary' ? '/file' : ''
-      }`,
-      {
-        headers: {
-          Authorization: 'Bearer ' + self.config.token,
-        },
-      }
-    );
-
-    if (method === 'binary') {
-      return resp.blob();
-    } else {
-      const data = await resp.json();
-      return base64toBlob(data.data);
-    }
-  }
-
   async function loadWasm({ engineJsContent, engineWasmContent }) {
-    return new Promise((res, rej) => {
+    return new Promise(function loadWasmExecutor(res, rej) {
       // console.log('load wasm');
       if (wasm_loaded || wasm_loading) {
         res(true);
@@ -65,7 +31,7 @@
           },
         };
         importScriptsViaJsContent(engineJsContent);
-        let tryInitEngineLib = async () => {
+        async function tryInitEngineLib() {
           try {
             const module = await AuthmeMLEngineLib({
               wasmBinary: engineWasmContent,
@@ -89,64 +55,231 @@
             console.warn(
               'init Authme EngineLib error:',
               error,
-              ' Try after 1 second.'
+              ' Try after 3 second.'
             );
-            await waitTime(500);
+            await waitTime(3000);
             await tryInitEngineLib();
           }
-        };
+        }
         tryInitEngineLib();
       }
     });
   }
 
-  // PassportService
-  self.PassportService = {
-    instance: null,
-    init: async function () {
-      return await self.Base.init(self.PassportService, 'PassportService');
+  // Base
+  const baseFunctions = {
+    // 由於不同 service 間的 _loadedSessions instance 是隔離開來的，
+    // 所以不能將 _loadedSessions: {} 直接放到這裡，
+    // 否則會造成 destroy 異常。
+    // 更好的做法會是用 class 替代現在的做法，只是改的幅度偏大，
+    // 所以暫時保留現有的做法。
+    _getLoadedModelKey({ modelVersion: { name, version } }) {
+      return `${name}#${version}`;
+    },
+    _getModelVersions(constructorName) {
+      const versionVector =
+        self.EngineLib[constructorName]['getModelVersion']();
+      const models = [];
+      for (let i = 0; i < versionVector.size(); i++) {
+        let item = versionVector.get(i);
+        models.push({
+          name: `${item.szName}`,
+          version: `${item.szVersion}`,
+        });
+      }
+      return models;
     },
-    start: function () {
-      return self.Base.start(self.PassportService);
+    _getNoLoadedModelVersions(constructorName) {
+      const modelVersions = this._getModelVersions(constructorName);
+      return modelVersions.filter(
+        (modelVersion) =>
+          !this._loadedSessions[this._getLoadedModelKey({ modelVersion })]
+      );
     },
-    stop: function () {
-      return self.Base.stop(self.PassportService);
+
+    // worker 專心處理 cpu 密集 (model 載入) 的工作，
+    // 至於純 IO 下載的任務就交給 main thread 處理就好。
+    loadSession({ modelVersion: { name, version }, modelArrayBuffer }) {
+      let fileMounted = false;
+      try {
+        const FS = self.EngineLib.FS;
+        FS.mkdir(`/${name}-${version}/`);
+        FS.mount(
+          FS.filesystems.WORKERFS,
+          {
+            blobs: [
+              {
+                name: `${name}-${version}`,
+                data: new Blob([modelArrayBuffer], {
+                  type: 'application/octet-stream',
+                }),
+              },
+            ],
+          },
+          `/${name}-${version}/`
+        );
+        fileMounted = true;
+      } catch (error) {
+        if (error?.errno === 20) {
+          // File Exist
+          fileMounted = true;
+        } else {
+          throw error;
+        }
+      }
+
+      if (fileMounted) {
+        const sessionKey = this._getLoadedModelKey({
+          modelVersion: { name, version },
+        });
+        if (this._loadedSessions[sessionKey]) {
+          throw new Error('should be undefined here.');
+        }
+        this._loadedSessions[sessionKey] =
+          self.EngineLib.createInferenceSession(
+            name,
+            `/${name}-${version}/${name}-${version}`
+          );
+      }
     },
-    getJsonReport: function () {
-      return self.Base.getJsonReport(self.PassportService);
+    async _init(constructorName) {
+      // 暫時將縮排透過遺留下來，減少 review 無變動的資訊。
+      {
+        {
+          {
+            const instance = new self.EngineLib[constructorName]();
+            instance.initial(
+              ...this._getModelVersions(constructorName).map(
+                (modelVersion) =>
+                  this._loadedSessions[
+                    this._getLoadedModelKey({ modelVersion })
+                  ]
+              )
+            );
+            const engine = instance;
+            const uiParams = engine.getUIParams();
+            uiParams.previewPosition.fLeft = 0;
+            uiParams.previewPosition.fTop = 0;
+            uiParams.previewPosition.fRight = 1;
+            uiParams.previewPosition.fBottom = 1;
+            engine.setUIParams(uiParams);
+            this.instance = instance;
+            return true;
+          }
+        }
+      }
     },
-    setFrameSize: function (params) {
-      return self.Base.setFrameSize(self.PassportService, params);
+    start() {
+      return this.instance?.start();
     },
-    getFinalResult: function (params) {
-      return self.PassportService.instance.getFinalResult();
+    stop() {
+      return this.instance?.stop();
     },
-    toJson: function (params) {
-      return Object.getPrototypeOf(
-        self.PassportService.instance
-      ).constructor.toJson(params);
+    _setFrameSize(params) {
+      config.frame.width = Math.floor(params.width);
+      config.frame.height = Math.floor(params.height);
+      if (this.instance) {
+        const engine = this.instance;
+        const uiParams = engine.getUIParams();
+        uiParams.analyzeSize.iHeight = config.frame.height;
+        uiParams.analyzeSize.iWidth = config.frame.width;
+        engine.setUIParams(uiParams);
+        return true;
+      }
     },
-    recognition: function (params) {
-      const result = self.Base.recognition(self.PassportService, params);
-      if (result) {
-        result.eStatus = result.eStatus.constructor.name;
-        result.tField = JSON.parse(self.PassportService.toJson(result.tField));
+    setFrameSize(params) {
+      return this._setFrameSize(params);
+    },
+    _recognition(params) {
+      const engine = this.instance;
+      if (engine) {
+        try {
+          const data = params.data;
+          const heapInfo = putOnHeap(data);
+          const result = engine.run(
+            heapInfo.byteOffset,
+            heapInfo.length,
+            config.frame.width,
+            config.frame.height
+          );
+          self.EngineLib._free(heapInfo.dataPtr);
+          return result;
+        } catch (error) {
+          // console.warn(error);
+          // console.warn('[Recognition Error]: ' + error?.message);
+          return null;
+        }
       }
-      return result;
+      console.warn('engine not initialized');
     },
-    getParams: function () {
-      return self.Base.getParams(self.PassportService);
+    recognition(params) {
+      return this._recognition(params);
     },
-    setParams: function (params) {
-      return self.Base.setParams(self.PassportService, params);
+    getParams() {
+      return this.instance.getParams();
     },
-    getDebugImage: function (params) {
-      return self.Base.getDebugImage(self.PassportService, params);
+    setParams(params) {
+      return this.instance.setParams(params.params);
     },
-    destroy: function () {
-      return self.Base.destroy(self.PassportService);
+    getDebugImage(params) {
+      const data = params.data;
+      const heapInfo = putOnHeap(data);
+      let imageData;
+      const pointer = this.instance.getDebugImage(
+        heapInfo.byteOffset,
+        heapInfo.length,
+        config.frame.width,
+        config.frame.height
+      );
+      self.EngineLib._free(heapInfo.dataPtr);
+      if (pointer) {
+        imageData = self.EngineLib.HEAPU8.slice(
+          pointer,
+          pointer + config.frame.width * config.frame.height * 4
+        );
+        self.EngineLib._free(pointer);
+      }
+      return imageData;
+    },
+    destroy() {
+      if (this.instance) {
+        this.instance.delete();
+        this.instance = null;
+      }
+      for (const session of Object.values(this._loadedSessions)) {
+        self.EngineLib.deleteSession(session);
+      }
+      this._loadedSessions = {};
+    },
+    getJsonReport() {
+      return this.instance?.getJsonReport();
+    },
+  };
+
+  // PassportService
+  self.PassportService = {
+    instance: null,
+    _loadedSessions: {},
+    ...baseFunctions,
+
+    getNoLoadedModelVersions() {
+      return this._getNoLoadedModelVersions('PassportService');
+    },
+    init() {
+      return this._init('PassportService');
     },
-    setMaskPosition: function (params) {
+    toJson(params) {
+      return Object.getPrototypeOf(this.instance).constructor.toJson(params);
+    },
+    recognition(params) {
+      const result = this._recognition(params);
+      if (result) {
+        result.eStatus = result.eStatus.constructor.name;
+        result.tField = JSON.parse(self.PassportService.toJson(result.tField));
+      }
+      return result;
+    },
+    setMaskPosition(params) {
       const positions = params.positions;
       return self.PassportService.instance?.setMatchROI(
         positions[0][0],
@@ -164,24 +297,17 @@
   // Card OCR
   self.CardOCR = {
     instance: null,
-    init: async function () {
-      let result = await self.Base.init(self.CardOCR, 'CardOCR');
-      return result;
-    },
-    start: function () {
-      return self.Base.start(self.CardOCR);
-    },
-    stop: function () {
-      return self.Base.stop(self.CardOCR);
-    },
-    getJsonReport: function () {
-      return self.Base.getJsonReport(self.CardOCR);
+    _loadedSessions: {},
+    ...baseFunctions,
+
+    getNoLoadedModelVersions() {
+      return this._getNoLoadedModelVersions('CardOCR');
     },
-    setFrameSize: function (params) {
-      return self.Base.setFrameSize(self.CardOCR, params);
+    init() {
+      return this._init('CardOCR');
     },
-    recognition: function (params) {
-      const result = self.Base.recognition(self.CardOCR, params);
+    recognition(params) {
+      const result = this._recognition(params);
       if (result) {
         if (result.pointer > 0) {
           result.imageData = self.EngineLib.HEAPU8.slice(
@@ -196,24 +322,23 @@
       }
       return result;
     },
-    getDebugImage: function (params) {
-      return self.Base.getDebugImage(self.CardOCR, params);
-    },
-    setType: function (params) {
-      const engine = self.CardOCR.instance;
+    setType({ type }) {
+      const engine = this.instance;
       if (engine) {
         const engineParams = engine.getParams();
         engineParams.eTargetCardType =
-          self.EngineLib.EAuthMeCardClass.values[params.type];
+          self.EngineLib.EAuthMeCardClass[
+            type.replace(/^EAuthMeCardClass_/, '')
+          ];
         engineParams.fImageBlurTh = 750;
         engine.setParams(engineParams);
         return true;
       }
       return false;
     },
-    setMaskPosition: function (params) {
+    setMaskPosition(params) {
       const positions = params.positions;
-      return self.CardOCR.instance?.setCardMatchROI(
+      return this.instance?.setCardMatchROI(
         positions[0][0],
         positions[0][1],
         positions[1][0],
@@ -224,44 +349,29 @@
         positions[3][1]
       );
     },
-    getParams: function () {
-      return self.Base.getParams(self.CardOCR);
-    },
-    setParams: function (params) {
-      return self.Base.setParams(self.CardOCR, params);
-    },
-    destroy: function () {
-      return self.Base.destroy(self.CardOCR);
-    },
   };
 
   // Id Card Anti Fraud
   self.IdCardAntiFraud = {
     instance: null,
-    init: async function () {
-      await self.Base.init(self.IdCardAntiFraud, 'IdCardAntiFraudService');
-      if (self.IdCardAntiFraud.instance) {
-        const engine = self.IdCardAntiFraud.instance;
+    _loadedSessions: {},
+    ...baseFunctions,
+
+    getNoLoadedModelVersions() {
+      return this._getNoLoadedModelVersions('IdCardAntiFraudService');
+    },
+    async init() {
+      await this._init('IdCardAntiFraudService');
+      if (this.instance) {
+        const engine = this.instance;
         const engineParams = engine.getParams();
         engineParams.timeoutSec = 52;
         engine.setParams(engineParams);
         return true;
       }
     },
-    start: function () {
-      return self.Base.start(self.IdCardAntiFraud);
-    },
-    stop: function () {
-      return self.Base.stop(self.IdCardAntiFraud);
-    },
-    getJsonReport: function () {
-      return self.Base.getJsonReport(self.IdCardAntiFraud);
-    },
-    setFrameSize: function (params) {
-      return self.Base.setFrameSize(self.IdCardAntiFraud, params);
-    },
-    recognition: function (params) {
-      const result = self.Base.recognition(self.IdCardAntiFraud, params);
+    recognition(params) {
+      const result = this._recognition(params);
       if (result) {
         result.eStatus = result.eStatus.constructor.name;
         result.eStage = result.eStage.constructor.name;
@@ -275,9 +385,9 @@
       }
       return result;
     },
-    setMaskPosition: function (params) {
+    setMaskPosition(params) {
       const positions = params.positions;
-      return self.IdCardAntiFraud.instance?.setFrontalCardVertices(
+      return this.instance?.setFrontalCardVertices(
         positions[0][0],
         positions[0][1],
         positions[1][0],
@@ -288,68 +398,55 @@
         positions[3][1]
       );
     },
-    setStage: function (params) {
-      if (self.IdCardAntiFraud.instance) {
+    setStage(params) {
+      if (this.instance) {
         const stageList = new self.EngineLib.FraudStageList();
-        params.forEach((x) => {
-          stageList.push_back(self.EngineLib.EAuthMeIDCardAntiFraudStage[x]);
-        });
-        self.IdCardAntiFraud.instance.setStage(stageList);
+        for (const stage of params) {
+          stageList.push_back(
+            self.EngineLib.EAuthMeIDCardAntiFraudStage[stage]
+          );
+        }
+        this.instance.setStage(stageList);
       }
     },
-    getParams: function () {
-      return self.Base.getParams(self.IdCardAntiFraud);
-    },
-    setParams: function (params) {
-      return self.Base.setParams(self.IdCardAntiFraud, params);
-    },
-    getDebugImage: function (params) {
-      return self.Base.getDebugImage(self.IdCardAntiFraud, params);
-    },
-    destroy: function () {
-      return self.Base.destroy(self.IdCardAntiFraud);
-    },
   };
 
   self.Fas = {
     instance: null,
-    init: async function () {
-      await self.Base.init(self.Fas, 'CFASService');
-    },
-    start: function () {
-      return self.Base.start(self.Fas);
-    },
-    stop: function () {
-      return self.Base.stop(self.Fas);
+    _loadedSessions: {},
+    ...baseFunctions,
+
+    getNoLoadedModelVersions() {
+      return this._getNoLoadedModelVersions('CFASService');
     },
-    getJsonReport: function () {
-      return self.Base.getJsonReport(self.Fas);
+    init() {
+      return this._init('CFASService');
     },
-    setFrameSize: function (params) {
-      self.Base.setFrameSize(self.Fas, params);
+    setFrameSize(params) {
+      this._setFrameSize(params);
       if (config.frame.width / config.frame.height >= 1) {
-        const params = self.Fas.instance.getParams();
+        const params = this.instance.getParams();
         params.fFaceRoiPreviewRatioW = 0.3;
-        self.Fas.instance.setParams(params);
+        this.instance.setParams(params);
       }
     },
-    setStage: function (params) {
-      if (self.Fas.instance) {
+    setStage(params) {
+      if (this.instance) {
         const stageList = new self.EngineLib.FASStageList();
-        params.stageList.forEach((x) => {
-          stageList.push_back(self.EngineLib.EAuthMeFASServiceStage[x]);
-        });
-        self.Fas.instance.setStage(stageList);
+        for (const stage of params.stageList) {
+          stageList.push_back(self.EngineLib.EAuthMeFASServiceStage[stage]);
+        }
+        this.instance.setStage(stageList);
       }
     },
     getStageParams({ stageIndex }) {
-      return self.Fas.instance.getStageParams(stageIndex);
+      return this.instance.getStageParams(stageIndex);
     },
     setStageParams({ stageIndex, value }) {
-      self.Fas.instance.setStageParams(value, stageIndex);
+      this.instance.setStageParams(value, stageIndex);
     },
-    recognition: function (params) {
-      const result = self.Base.recognition(self.Fas, params);
+    recognition(params) {
+      const result = this._recognition(params);
       if (result) {
         result.eStatus = result.eStatus.constructor.name;
         result.eStage = result.eStage.constructor.name;
@@ -361,188 +458,59 @@
       }
       return result;
     },
-    getParams: function () {
-      return self.Base.getParams(self.Fas);
-    },
-    setParams: function (params) {
-      return self.Base.setParams(self.Fas, params);
-    },
-    getDebugImage: function (params) {
-      return self.Base.getDebugImage(self.Fas, params);
-    },
-    destroy: function () {
-      return self.Base.destroy(self.Fas);
-    },
-  };
-
-  // Base
-  self.Base = {
-    init: async function (target, constructorName) {
-      return new Promise((res, rej) => {
-        try {
-          setTimeout(async () => {
-            const models = [];
-            const versionVector =
-              self.EngineLib[constructorName]['getModelVersion']();
-            target.sessionUsed = [];
-            for (let i = 0; i < versionVector.size(); i++) {
-              let item = versionVector.get(i);
-              target.sessionUsed.push(item.szName);
-              models.push({
-                name: item.szName,
-                version: item.szVersion,
-              });
-            }
-
-            let queryModelString = models
-              .map((x) => 'models=' + x.name + '[' + x.version + ']')
-              .join('&');
-            let modelPath = await loadModels(queryModelString);
-            let modelPointer = models.map(({ name }, index) => {
-              if (modelSession[name]) {
-                return modelSession[name];
-              } else {
-                modelSession[name] = self.EngineLib.createInferenceSession(
-                  name,
-                  modelPath[index]
-                );
-                return modelSession[name];
-              }
-            });
-            const instance = new self.EngineLib[constructorName]();
-            instance.initial(...modelPointer);
-            const engine = instance;
-            const uiParams = engine.getUIParams();
-            uiParams.previewPosition.fLeft = 0;
-            uiParams.previewPosition.fTop = 0;
-            uiParams.previewPosition.fRight = 1;
-            uiParams.previewPosition.fBottom = 1;
-            engine.setUIParams(uiParams);
-            target.instance = instance;
-            res(true);
-          }, 10);
-        } catch (error) {
-          rej(error.message);
-        }
-      });
-    },
-    start: function (target) {
-      return target?.instance?.start();
-    },
-    stop: function (target) {
-      return target?.instance?.stop();
-    },
-    setFrameSize: function (target, params) {
-      config.frame.width = Math.floor(params.width);
-      config.frame.height = Math.floor(params.height);
-      if (target.instance) {
-        const engine = target.instance;
-        const uiParams = engine.getUIParams();
-        uiParams.analyzeSize.iHeight = config.frame.height;
-        uiParams.analyzeSize.iWidth = config.frame.width;
-        engine.setUIParams(uiParams);
-        return true;
-      }
-    },
-    recognition: function (target, params) {
-      const engine = target.instance;
-      if (engine) {
-        try {
-          const data = params.data;
-          const heapInfo = putOnHeap(data);
-          const result = engine.run(
-            heapInfo.byteOffset,
-            heapInfo.length,
-            config.frame.width,
-            config.frame.height
-          );
-          self.EngineLib._free(heapInfo.dataPtr);
-          return result;
-        } catch (error) {
-          // console.warn(error);
-          // console.warn('[Recognition Error]: ' + error?.message);
-          return null;
-        }
-      }
-      console.warn('engine not initialized');
-    },
-    getParams: function (target) {
-      return target.instance.getParams();
-    },
-    setParams: function (target, params) {
-      return target.instance.setParams(params.params);
-    },
-    getDebugImage: function (target, params) {
-      const data = params.data;
-      const heapInfo = putOnHeap(data);
-      let imageData;
-      const pointer = target.instance.getDebugImage(
-        heapInfo.byteOffset,
-        heapInfo.length,
-        config.frame.width,
-        config.frame.height
-      );
-      self.EngineLib._free(heapInfo.dataPtr);
-      if (pointer) {
-        imageData = self.EngineLib.HEAPU8.slice(
-          pointer,
-          pointer + config.frame.width * config.frame.height * 4
-        );
-        self.EngineLib._free(pointer);
-      }
-      return imageData;
-    },
-    destroy: function (target) {
-      if (target.instance) {
-        target.instance.delete();
-        target.instance = null;
-      }
-      if (target.sessionUsed) {
-        target.sessionUsed.forEach((name) => {
-          if (modelSession[name]) {
-            self.EngineLib.deleteSession(modelSession[name]);
-            modelSession[name] = null;
-          }
-        });
-        target.sessionUsed = [];
-      }
-    },
-    getJsonReport: function (target) {
-      return target?.instance?.getJsonReport();
-    },
   };
 
   self.Core = {
-    setConfig: async function (config) {
+    async setConfig(config) {
       self.config = {
         ...self.config,
         ...config,
       };
       return true;
     },
-    loadEngine: async function ({ engineJsContent, engineWasmContent }) {
+    async loadEngine({ engineJsContent, engineWasmContent }) {
       return await loadWasm({ engineJsContent, engineWasmContent });
     },
-    verify: async function (params) {
+    async verify(params) {
       for (let index = 0; index < 20; index++) {
         if (self.EngineLib) {
           let result = self.EngineLib.verifySDK(params.cert, params.authToken);
           return result.constructor.name;
         }
-        await waitTime(500);
       }
       return false;
     },
+    checkEnumConsistency(enums) {
+      const problem = [];
+      for (const [enumName, enumDef] of Object.entries(enums)) {
+        const actualEnumDef = self.EngineLib[enumName];
+        const actualEnumValues = actualEnumDef?.values ?? {};
+        const actualEnumMap = Object.fromEntries(
+          Object.values(actualEnumValues).map((enumValue) => [
+            enumValue.constructor.name,
+            enumValue.value,
+          ])
+        );
+
+        for (const [key, engineKey] of Object.entries(enumDef)) {
+          const actualValue = actualEnumMap[engineKey];
+          if (typeof actualValue === 'undefined') {
+            problem.push({ enumName, key, engineKey, actualEnumMap });
+          }
+        }
+      }
+      return problem;
+    },
   };
 
   addEventListener(
     'message',
-    async function ({ data }) {
+    async function onWorkerMessage({ data }) {
       const { module, command, id, value } = data;
       const fn = self[module][command];
       if (fn) {
         // console.log(`call ${module}.${command} :`, value);
-        const result = await fn(value);
+        const result = await fn.call(self[module], value);
         // console.log(`worker return value for ${command}:`, result);
         postMessage({
           module,
@@ -563,60 +531,6 @@
     },
   };
 
-  async function loadModel(modelInfo) {
-    const { name, code } = modelInfo;
-    const modelData = await fetchModel(code);
-    console.log(modelData);
-    try {
-      const FS = self.EngineLib.FS;
-      FS.mkdir(name);
-      FS.mount(
-        FS.filesystems.WORKERFS,
-        {
-          blobs: [
-            {
-              name,
-              data: modelData,
-            },
-          ],
-        },
-        '/' + name
-      );
-    } catch (error) {
-      if (error?.errno === 20) {
-        // File Exist
-        return `/${name}/${name}`;
-      } else {
-        throw error;
-      }
-    }
-
-    return `/${name}/${name}`;
-  }
-
-  async function loadModels(modelString) {
-    const start = performance.now();
-    const resp = await fetch(
-      self.config.apiBaseUrl + '/api/model-management/v1/model?' + modelString,
-      {
-        headers: {
-          Authorization: 'Bearer ' + self.config.token,
-        },
-      }
-    );
-    if (!resp.ok) {
-      throw new Error('[HTTP Error] Status: ' + resp.status);
-    }
-    const result = await resp.json();
-    const modelPath = [];
-    for (let i = 0; i < result.models.length; i++) {
-      modelPath.push(await loadModel(result.models[i]));
-    }
-    const end = performance.now();
-    // console.log('Load Model Time: ', +end - start + ' ms');
-    return modelPath;
-  }
-
   function putOnHeap(data) {
     const Module = self.EngineLib;
     const uint8ArrData = new Uint8Array(data);
@@ -633,7 +547,7 @@
     };
   }
 
-  async function waitTime(ms) {
+  function waitTime(ms) {
     return new Promise((res) => {
       setTimeout(() => {
         res(true);