@coherentglobal/wasm-runner 0.0.103 → 0.1.19

package/dist/node.js

@@ -51,10 +51,14 @@ const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const util_1 = require("util");
 const got_1 = __importDefault(require("got"));
-const node_worker_threads_pool_1 = require("node-worker-threads-pool");
+const semver_1 = __importDefault(require("semver"));
+const workerPool_1 = __importDefault(require("./node/threads/workerPool"));
 const utils = __importStar(require("./utils"));
+const types_1 = require("./types");
 const error_1 = __importDefault(require("./error"));
 const node_os_1 = require("node:os");
+const constants_1 = require("./constants");
+const responseTimeMetric_1 = __importDefault(require("./responseTimeMetric"));
 /* istanbul ignore next  */
 var columnarSerializer_1 = require("./serializer/columnarSerializer");
 Object.defineProperty(exports, "ColumnarSerializer", { enumerable: true, get: function () { return columnarSerializer_1.ColumnarSerializer; } });
@@ -92,6 +96,7 @@ const unzipFiles = (id, url, workerFolder) => {
     let data;
     let metadata;
     let formspec;
+    let compilerLog;
     // @ts-ignore
     const stream = fs_1.default.createReadStream(url).pipe((0, unzipper_1.Parse)());
     return new Promise((resolve, reject) => {
@@ -115,6 +120,9 @@ const unzipFiles = (id, url, workerFolder) => {
                 if (entry.path.toLowerCase().indexOf("_jsonformspec.json") > -1) {
                     formspec = fileName;
                 }
+                if (entry.path.toLowerCase().indexOf("_compilerlog.json") > -1) {
+                    compilerLog = fileName;
+                }
                 return entry.pipe(writeStream);
             }
             return entry.autodrain();
@@ -131,6 +139,7 @@ const unzipFiles = (id, url, workerFolder) => {
                     data,
                     metadata,
                     formspec,
+                    compilerLog,
                 });
         });
         stream.on("error", (error) => reject(error));
@@ -140,18 +149,11 @@ const template = ejs_1.default.compile(fs_1.default.readFileSync(path_1.default.
     encoding: "utf8",
     flag: "r",
 }), { async: false });
-/**
- * WASM runner config
- * @typedef {Object} RunnerConfig
- * @property {string} id - Model id or version_uuid
- * @property {string} url - Model url
- */
-/**
- * Input object
- * @typedef {Object} InputObject
- * @property {Object} request_data - Request input date
- * @property {Object} request_meta - Request input meta
- */
+const delay = (time) => {
+    return new Promise((res) => {
+        setTimeout(res, time);
+    });
+};
 /**
  * WasmRunner class, responsible for managing model and it's lifecycle
  *
@@ -165,21 +167,30 @@ class WasmRunner {
      *
      * @param {RunnerConfig} wasmRunnerConfig
      */
-    constructor(wasmRunnerConfig, externalResolverModule = "", license = "") {
+    constructor(wasmRunnerConfig, externalResolverModule = "", options = {}, license = "") {
+        let baseTmpDir = null;
+        if (process.env.DEV_DEBUG_TMP_PATH) {
+            baseTmpDir = path_1.default.join(process.cwd(), process.env.DEV_DEBUG_TMP_PATH);
+        }
         this._tempWorkerFolder = tmp_1.default.dirSync({
             prefix: "wasmserver_worker",
             // @ts-ignore
             mode: 0o750,
+            tmpdir: baseTmpDir,
         });
         this._tempModelFolder = tmp_1.default.dirSync({
             prefix: "wasmserver_model",
             // @ts-ignore
             mode: 0o750,
+            tmpdir: baseTmpDir,
         });
         this.license = license;
-        this.externalResolverModule =
-            externalResolverModule || require.resolve("./defaultExternalResolver");
+        this.initializingModels = [];
+        this.externalResolverModule = externalResolverModule
+            ? require(useCorrectPath(require.resolve(externalResolverModule)))
+            : require(require.resolve("./defaultExternalResolver"));
         this.models = [];
+        this.options = options;
         if (!utils.isEmpty(wasmRunnerConfig)) {
             if (Array.isArray(wasmRunnerConfig)) {
                 this.models = wasmRunnerConfig.map((wsconfig) => ({
@@ -204,20 +215,24 @@ class WasmRunner {
      * @function initialize
      */
     /* istanbul ignore next  */
-    initialize(license = "") {
-        return __awaiter(this, void 0, void 0, function* () {
+    initialize() {
+        return __awaiter(this, arguments, void 0, function* (license = "") {
+            if (this.options.compatibilityCheckEnabled) {
+                this.safeCompiler = yield this.getSafeCompilerVersion(this.options.runnerVersion);
+            }
             yield Promise.all(this.models.map((m) => __awaiter(this, void 0, void 0, function* () {
                 return this._initializeModelInstance(m);
             })));
         });
     }
     /* istanbul ignore next  */
-    _createModelInstance(id, url, workerFolder, size) {
-        return __awaiter(this, void 0, void 0, function* () {
+    _createModelInstance(id_1, url_1, workerFolder_1) {
+        return __awaiter(this, arguments, void 0, function* (id, url, workerFolder, size = 1) {
+            const workerSize = size || 1;
             logger_1.default.debug({
                 TimeStamp: Date.now(),
                 EventType: "Runner._createModelInstance",
-                size: size,
+                size: workerSize,
                 ModelId: id,
             });
             const tempFolder = path_1.default.join(workerFolder, `${id}-${Date.now()}`);
@@ -235,6 +250,11 @@ class WasmRunner {
             });
             const modelName = id;
             yield replaceRegexInFile(modelPack.js, `wasmBinaryFile="${path_1.default.basename(modelPack.wasm)}"`, `scriptDirectory="";wasmBinaryFile="${modelPack.wasm}"`);
+            const replaceIsFileURLFunc = "function isFileURI(filename) { if(typeof process !== undefined && process.versions && process.versions.node) { return true; }";
+            yield replaceRegexInFile(modelPack.js, "function isFileURI(filename) {", replaceIsFileURLFunc);
+            yield replaceRegexInFile(modelPack.js, "function isFileURI(filename){", replaceIsFileURLFunc);
+            // Remove `new URL()` since `isFileURI` will always be true for Node
+            yield replaceRegexInFile(modelPack.js, /\s*isFileURI\s*\(\s*filename\s*\)\s*\?\s*new\s*URL\s*\(\s*filename\s*\)\s*:\s*/g, "");
             if (modelPack.data) {
                 yield replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
                 yield replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
@@ -242,10 +262,13 @@ class WasmRunner {
                 yield replaceRegexInFile(modelPack.js, `"${path_1.default.basename(modelPack.data)}"`, `"${modelPack.data}"`);
             }
             // Prepare File Paths
-            const externalResolverPath = useCorrectPath(this.externalResolverModule);
+            // const externalResolverPath = useCorrectPath(this.externalResolverModule);
             const loggerPath = useCorrectPath(process.env.NODE_ENV === "test"
                 ? require.resolve("./node/mockLogger.js")
                 : require.resolve("./node/logger"));
+            const workerThread = useCorrectPath(process.env.NODE_ENV === "test"
+                ? require.resolve("./node/threads/mockWorkerThread.js")
+                : require.resolve("./node/threads/workerThread"));
             let metadata = "undefined";
             if (!utils.isEmpty(modelPack.metadata)) {
                 const metadataPath = useCorrectPath(require.resolve(modelPack.metadata));
@@ -256,6 +279,14 @@ class WasmRunner {
                 const formSpecPath = useCorrectPath(require.resolve(modelPack.formspec));
                 formspec = `require("${formSpecPath}")`;
             }
+            let compilerVersion = "undefined";
+            let compatibilityStatus = "undefined";
+            compilerVersion = !utils.isEmpty(modelPack.compilerLog)
+                ? yield this.getNeuronCompilerVersion(`"${modelPack.compilerLog}"`)
+                : undefined;
+            if (this.options.compatibilityCheckEnabled) {
+                compatibilityStatus = yield this.checkCompilerVersionCompatibility(compilerVersion);
+            }
             const fileContent = template({
                 runtime: modelPack.js.replace(".js", ""),
                 model: modelPack.wasm,
@@ -263,8 +294,8 @@ class WasmRunner {
                 formspec,
                 modelName,
                 modules: {
-                    externalResolver: externalResolverPath,
                     logger: loggerPath,
+                    workerThread: workerThread,
                 },
             });
             const workerPath = path_1.default.join(tempFolder, `worker-${id}.js`);
@@ -274,26 +305,88 @@ class WasmRunner {
                 EventType: "Runner.CreateTemplates",
                 ModelId: id,
             });
-            const instancePool = new node_worker_threads_pool_1.StaticPool({
-                size: size || 1,
-                task: workerPath,
+            let workerPool;
+            /**
+             * Processes the requests from Worker thread. Interprets the request
+             * `type` and implement necessary logic and returns the result.
+             *
+             * @param {Object} requestData
+             * Event details from Worker thread.
+             */
+            const processWorkerThreadRequest = (requestData) => __awaiter(this, void 0, void 0, function* () {
+                const { type, payload, context, threadId } = requestData;
+                // Worker request of model execution on main thread.
+                if (type === constants_1.THREAD_EVENT_TYPES.REQUEST_EXECUTE) {
+                    try {
+                        // Callback the resolver function
+                        const result = yield this.externalResolverModule.sparkService(payload, context);
+                        // Send back the response to worker thread
+                        workerPool.postMessage({
+                            payload: result,
+                            type: constants_1.THREAD_EVENT_TYPES.RESPONSE,
+                            threadId,
+                        });
+                    }
+                    catch (e) {
+                        // Send back the error to worker thread
+                        workerPool.postMessage({
+                            payload: e,
+                            type: constants_1.THREAD_EVENT_TYPES.ERROR,
+                            threadId,
+                        });
+                    }
+                }
+            });
+            const workerName = path_1.default.basename(modelPack.js, path_1.default.extname(modelPack.js)) || "";
+            workerPool = new workerPool_1.default(workerSize, workerPath, {
+                errorHandler: (e) => logger_1.default.error("Worker Error: ", e),
+                onlineHandler: () => logger_1.default.info(`Worker ${id} online`),
+                // Receive messages from worker here
+                messageHandler: processWorkerThreadRequest,
+                workerOptions: {
+                    name: workerName,
+                },
+                enableTasksQueue: true
             });
             logger_1.default.debug({
                 TimeStamp: Date.now(),
                 EventType: "Runner.ModelInitialize",
                 ModelId: id,
             });
+            workerPool.start();
             return new Promise((resolve, reject) => {
                 let limit = 0;
+                let readyCount = workerSize;
+                const stats = {};
                 const checkModelStatus = () => __awaiter(this, void 0, void 0, function* () {
-                    const isReady = yield instancePool.exec("isReady");
-                    if (isReady) {
+                    var _a;
+                    const readyRes = yield workerPool.execute("isReady");
+                    if (readyRes && !stats[readyRes.threadId]) {
+                        stats[readyRes.threadId] = {
+                            init_memory: readyRes.memoryUsage,
+                            init_time_ms: readyRes.time,
+                            ready_ts: ((_a = readyRes.payload) === null || _a === void 0 ? void 0 : _a.readyTs) || readyRes.readyTs,
+                            peak_memory: readyRes.memoryUsage,
+                            last_execute_consume_memory: readyRes.memoryUsage
+                        };
+                        readyCount = readyCount - 1;
                         logger_1.default.debug({
                             TimeStamp: Date.now(),
                             EventType: "Runner.ModelInitialize.Completed",
                             ModelId: id,
                         });
-                        resolve(instancePool);
+                        if (readyCount === 0) {
+                            resolve({
+                                instance: workerPool,
+                                compilerVersion,
+                                compatibilityStatus,
+                                size: workerSize,
+                                stats: stats
+                            });
+                        }
+                        else {
+                            setTimeout(checkModelStatus, 1);
+                        }
                     }
                     else if (limit >= 2000) {
                         // 1 second
@@ -313,15 +406,23 @@ class WasmRunner {
     _initializeModelInstance(m) {
         return __awaiter(this, void 0, void 0, function* () {
             if (utils.isHttpURL(m.url)) {
-                const instance = yield this._createModelInstanceFromURL(m.id, m.url, this._tempWorkerFolder.name, this._tempModelFolder.name, m.size);
+                const { instance, compilerVersion, compatibilityStatus, stats } = yield this._createModelInstanceFromURL(m.id, m.url, this._tempWorkerFolder.name, this._tempModelFolder.name, m.size);
                 m.ready = true;
                 m.worker = instance;
+                m.compatibility_status = compatibilityStatus;
+                m.compilerVersion = compilerVersion;
+                m.stats = stats;
+                m.responseTimeMetrics = new responseTimeMetric_1.default();
                 return Promise.resolve();
             }
             if (yield utils.isPath(m.url)) {
-                const instance = yield this._createModelInstance(m.id, m.url, this._tempWorkerFolder.name, m.size);
+                const { instance, compilerVersion, compatibilityStatus, stats } = yield this._createModelInstance(m.id, m.url, this._tempWorkerFolder.name, m.size);
                 m.ready = true;
                 m.worker = instance;
+                m.compatibility_status = compatibilityStatus;
+                m.compilerVersion = compilerVersion;
+                m.stats = stats;
+                m.responseTimeMetrics = new responseTimeMetric_1.default();
                 return Promise.resolve();
             }
             if (Buffer.isBuffer(m.url)) {
@@ -329,9 +430,13 @@ class WasmRunner {
                 const modelPath = path_1.default.join(this._tempWorkerFolder.name, `${m.id}.zip`);
                 const fileWriterStream = (0, fs_1.createWriteStream)(modelPath);
                 yield pipeline(model, fileWriterStream);
-                const instance = yield this._createModelInstance(m.id, modelPath, this._tempWorkerFolder.name, m.size);
+                const { instance, compilerVersion, compatibilityStatus, stats } = yield this._createModelInstance(m.id, modelPath, this._tempWorkerFolder.name, m.size);
                 m.ready = true;
                 m.worker = instance;
+                m.compatibility_status = compatibilityStatus;
+                m.compilerVersion = compilerVersion;
+                m.stats = stats;
+                m.responseTimeMetrics = new responseTimeMetric_1.default();
                 return Promise.resolve();
             }
         });
@@ -353,35 +458,70 @@ class WasmRunner {
         });
     }
     /**
-     * Append and initialized new model to runner
+     * Append and initialize model in preparation for the `execute()`.
+     *
      * @param {ModelConfig} modelConfig
-     * @returns Promise
+     * Model details like version_id as `id` and zip path as `url`.
+     *
+     * @returns {Promise<void>}
      */
     append(modelConfig) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isExist(modelConfig.id)) {
-                return;
+            if (this.options.compatibilityCheckEnabled) {
+                this.safeCompiler = yield this.getSafeCompilerVersion(this.options.runnerVersion);
+            }
+            if (!this.isExist(modelConfig.id)) {
+                const model = {
+                    id: modelConfig.id,
+                    url: modelConfig.url,
+                    size: modelConfig.size,
+                    busy: 0,
+                };
+                if (!this.isExist(modelConfig.id)) {
+                    if (this.initializingModels.findIndex((im) => im === modelConfig.id) ===
+                        -1) {
+                        try {
+                            this.initializingModels.push(modelConfig.id);
+                            yield this._initializeModelInstance(model);
+                            this.models.push(model);
+                        }
+                        catch (e) {
+                            throw e;
+                        }
+                        finally {
+                            this.initializingModels = this.initializingModels.filter((im) => im !== modelConfig.id);
+                        }
+                    }
+                    else {
+                        const maxRetry = 600;
+                        let retry = 0;
+                        while (this.initializingModels.findIndex((im) => im === modelConfig.id) >
+                            -1 &&
+                            retry < maxRetry) {
+                            yield delay(100);
+                            retry++;
+                        }
+                        if (retry >= maxRetry || !this.isExist(modelConfig.id)) {
+                            throw new error_1.default.ModelInitializationError(modelConfig.id);
+                        }
+                    }
+                }
             }
-            const model = {
-                id: modelConfig.id,
-                url: modelConfig.url,
-                size: modelConfig.size,
-                busy: 0,
-            };
-            yield this._initializeModelInstance(model);
-            this.models.push(model);
         });
     }
     /**
-     * Remove model from runner
-     * @param {string} id Model id
-     * @returns Promise
+     * Remove model from the list of initialized model useful for GC.
+     *
+     * @param {String} id
+     * ID of the model that needs to be removed.
+     *
+     * @returns {Promise<void>}
      */
     remove(id) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isExist(id)) {
                 const model = this.models.find((m) => m.id === id);
-                yield model.worker.exec("destroy");
+                yield model.worker.execute("destroy");
                 model.worker.destroy();
                 delete model.worker;
                 this.models = this.models.filter((m) => m.id !== id);
@@ -442,10 +582,21 @@ class WasmRunner {
             throw new error_1.default.ModelInitializationError(id);
         return model;
     }
+    getModelSize(id) {
+        const model = this._getModel(id);
+        return model.size || 1;
+    }
+    getModelCompilerVersion(id) {
+        const model = this._getModel(id);
+        if (model.compilerVersion && model.compilerVersion !== 'undefined') {
+            return model.compilerVersion;
+        }
+        return undefined;
+    }
     /**
      * Check if model existed
      * @param {string} id Model id
-     * @returns boolean
+     * @returns {boolean}
      */
     isExist(id) {
         try {
@@ -455,15 +606,65 @@ class WasmRunner {
             return false;
         }
     }
+    isModelCompatible(model, input) {
+        if (!this.options.compatibilityCheckEnabled) {
+            return true;
+        }
+        switch (model.compatibility_status) {
+            case types_1.Compatibility.INCOMPATIBLE:
+                throw new error_1.default.ModelExecuteError(this.getIncompatibleMessage(model), model.id, input);
+            case types_1.Compatibility.PARTIAL:
+                logger_1.default.warn({
+                    TimeStamp: Date.now(),
+                    EventType: "Runner.Execute.Compatibility.Warning",
+                    TextMessage: this.getPartiallyCompatibleMessage(model),
+                    ModelId: model.id,
+                });
+                return true;
+            case types_1.Compatibility.COMPATIBLE:
+                return true;
+        }
+        return true;
+    }
+    getModelsStats() {
+        return this.models.map(model => {
+            const stats = Object.assign({}, model.stats);
+            Object.keys(stats).forEach(threadId => {
+                stats[threadId] = Object.assign({}, stats[threadId]);
+                Object.keys(stats[threadId]).forEach(k => {
+                    if (k.indexOf('_memory') > -1) {
+                        stats[threadId][`${k}_mb`] = utils.formatMemory(stats[threadId][k]);
+                        delete stats[threadId][k];
+                    }
+                    if (k.indexOf('ready_ts') > -1) {
+                        stats[threadId].uptime_ms = Date.now() - stats[threadId]['ready_ts'];
+                        delete stats[threadId][k];
+                    }
+                });
+            });
+            return {
+                stats: Object.assign(Object.assign({}, stats), { uptime_ms: Math.min(...Object.keys(stats).map((k) => stats[k].uptime_ms)), min_time_ms: model.responseTimeMetrics.min, mean_time_ms: model.responseTimeMetrics.mean, p95_time_ms: model.responseTimeMetrics.p95, p99_time_ms: model.responseTimeMetrics.p99, max_time_ms: model.responseTimeMetrics.max }),
+                busy: model.busy,
+                size: model.size,
+                id: model.id
+            };
+        });
+    }
+    getPartiallyCompatibleMessage(model) {
+        return `The Wasm was compiled using ${model.compilerVersion} which is not fully supported by this runner version ${this.safeCompiler}. The service should be able to run but could encounter errors`;
+    }
+    getIncompatibleMessage(model) {
+        return `The Wasm was compiled using ${model.compilerVersion} which is not supported by this runner version ${this.safeCompiler}.`;
+    }
     /**
      * Perform calculation. The runner will use request_meta.version_uuid of input argument to locate model
      * @async
      * @param {InputObject} input - Input data for calculation
      * @returns {Promise<ResponseObject>} - Response model data
      */
-    execute(input, id = undefined, raw = false, cancelToken) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
+    execute(input_1) {
+        return __awaiter(this, arguments, void 0, function* (input, id = undefined, raw = false, cancelToken) {
+            var _a, _b, _c;
             let logInput;
             const token = cancelToken ? cancelToken.getToken() : undefined;
             if (utils.isV3Input(input)) {
@@ -486,7 +687,10 @@ class WasmRunner {
                 runnerCallId: callid,
                 ModelId: id,
             });
-            const version_uuid = id || ((_b = input.request_meta) === null || _b === void 0 ? void 0 : _b.version_uuid) || (input === null || input === void 0 ? void 0 : input.version_id);
+            const version_uuid = id ||
+                ((_b = input === null || input === void 0 ? void 0 : input.request_meta) === null || _b === void 0 ? void 0 : _b.version_uuid) ||
+                ((_c = input === null || input === void 0 ? void 0 : input.request_meta) === null || _c === void 0 ? void 0 : _c.version_id) ||
+                (input === null || input === void 0 ? void 0 : input.version_id);
             if (input) {
                 if (raw) {
                     if (!input.request_data) {
@@ -518,15 +722,31 @@ class WasmRunner {
                         model.busy = model.busy + 1;
                     }
                     let parsedResult;
-                    parsedResult = yield model.worker.exec(input);
-                    logger_1.default.debug({
-                        TimeStamp: Date.now(),
-                        EventType: "Runner.Execute.Completed",
-                        executeDuration: Date.now() - start,
-                        runnerCallId: callid,
-                        ModelId: id,
-                    });
-                    return parsedResult;
+                    if (this.isModelCompatible(model, input)) {
+                        const start = Date.now();
+                        const res = yield model.worker.execute(input);
+                        const execTime = Date.now() - start;
+                        if (res.memoryUsage > model.stats[res.threadId].peak_memory) {
+                            model.stats[res.threadId].peak_memory = res.memoryUsage;
+                        }
+                        model.stats[res.threadId].last_execute_consume_memory = res.memoryUsage;
+                        model.responseTimeMetrics.record(execTime);
+                        if (res.error) {
+                            throw res.error;
+                        }
+                        parsedResult = res.payload;
+                        logger_1.default.debug({
+                            TimeStamp: Date.now(),
+                            EventType: "Runner.Execute.Completed",
+                            executeDuration: Date.now() - start,
+                            runnerCallId: callid,
+                            ModelId: id,
+                        });
+                        return parsedResult;
+                    }
+                    else {
+                        throw new error_1.default.ModelExecuteError(this.getIncompatibleMessage(model), version_uuid, input);
+                    }
                 }
                 catch (err) {
                     logger_1.default.error(err);
@@ -547,6 +767,58 @@ class WasmRunner {
             }
         });
     }
+    getNeuronCompilerVersion(logFile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let compilerVersion = undefined;
+            const data = fs_1.default.readFileSync(logFile.replace(/"/g, ""), "utf8");
+            const modelJsonInfo = JSON.parse(data);
+            if (!semver_1.default.valid(modelJsonInfo.CompilerVersion)) {
+                throw new error_1.default.CompatibilityJsonError(`The Wasm was compiled using ${modelJsonInfo.CompilerVersion} which is not supported by the compatibility check.`);
+            }
+            compilerVersion = semver_1.default.coerce(modelJsonInfo.CompilerVersion).version;
+            return compilerVersion;
+        });
+    }
+    checkCompilerVersionCompatibility(modelCompilerVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const safeCompilerVersion = this.safeCompiler;
+                if (modelCompilerVersion) {
+                    if (semver_1.default.lte(modelCompilerVersion, safeCompilerVersion)) {
+                        return types_1.Compatibility.COMPATIBLE;
+                    }
+                    else {
+                        return types_1.Compatibility.PARTIAL;
+                    }
+                }
+                else {
+                    return types_1.Compatibility.COMPATIBLE;
+                }
+            }
+            catch (err) {
+                if (err.code === "ENOENT" || err.message === "File not found") {
+                    return types_1.Compatibility.COMPATIBLE;
+                }
+                else if (err instanceof SyntaxError) {
+                    return types_1.Compatibility.INCOMPATIBLE;
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+    getSafeCompilerVersion(runnerVersion) {
+        var _a;
+        const runnerVersions = (_a = this.options.compatibilityList) === null || _a === void 0 ? void 0 : _a.runner_versions;
+        if (!this.options.compatibilityList) {
+            throw new error_1.default.CompatibilityJsonError("No runner compiler compatibility list provided");
+        }
+        if (!runnerVersions.hasOwnProperty(runnerVersion)) {
+            throw new error_1.default.CompatibilityJsonError(`No compiler compatibility found for the runner version ${runnerVersion}`);
+        }
+        return runnerVersions[runnerVersion].safe_compiler;
+    }
 }
 exports.WasmRunner = WasmRunner;
 //# sourceMappingURL=node.js.map