@sdeverywhere/check-core 0.1.5 → 0.1.6

package/dist/index.js

@@ -38,33 +38,178 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
+// src/bundle/impl-vars-codec.ts
+function encodeImplVars(input) {
+  const subscripts = [];
+  const variables = [];
+  const varTypes = [];
+  const varInstances = {};
+  const subscriptMap = /* @__PURE__ */ new Map();
+  const variableMap = /* @__PURE__ */ new Map();
+  const varTypeMap = /* @__PURE__ */ new Map();
+  for (const [groupKey, implVars] of Object.entries(input)) {
+    const instances = [];
+    for (const implVar of implVars) {
+      const varIdInfo = parseSubscripts(implVar.varId);
+      const varNameInfo = parseSubscripts(implVar.varName);
+      let varTypeIndex = varTypeMap.get(implVar.varType);
+      if (varTypeIndex === void 0) {
+        varTypeIndex = varTypes.length;
+        varTypes.push(implVar.varType);
+        varTypeMap.set(implVar.varType, varTypeIndex);
+      }
+      let variableIndex = variableMap.get(implVar.varIndex);
+      if (variableIndex === void 0) {
+        variableIndex = variables.length;
+        variables.push({
+          n: varNameInfo.base,
+          i: varIdInfo.base,
+          x: implVar.varIndex
+        });
+        variableMap.set(implVar.varIndex, variableIndex);
+      }
+      let subscriptIndices;
+      let subscriptValues;
+      if (varIdInfo.subscripts.length > 0) {
+        subscriptIndices = [];
+        subscriptValues = implVar.subscriptIndices || [];
+        for (let i = 0; i < varIdInfo.subscripts.length; i++) {
+          const subscriptId = varIdInfo.subscripts[i];
+          const subscriptName = varNameInfo.subscripts[i];
+          let subscriptIndex = subscriptMap.get(subscriptId);
+          if (subscriptIndex === void 0) {
+            subscriptIndex = subscripts.length;
+            subscripts.push({
+              n: subscriptName,
+              i: subscriptId
+            });
+            subscriptMap.set(subscriptId, subscriptIndex);
+          }
+          subscriptIndices.push(subscriptIndex);
+        }
+      }
+      const instance = [varTypeIndex, variableIndex];
+      if (subscriptIndices) {
+        instance.push(...subscriptIndices, ...subscriptValues);
+      }
+      instances.push(instance);
+    }
+    varInstances[groupKey] = instances;
+  }
+  return {
+    subscripts,
+    variables,
+    varTypes,
+    varInstances
+  };
+}
+function decodeImplVars(encoded) {
+  const result = {};
+  for (const [groupKey, instances] of Object.entries(encoded.varInstances)) {
+    const implVars = [];
+    for (const instance of instances) {
+      const varType = encoded.varTypes[instance[0]];
+      const variable = encoded.variables[instance[1]];
+      let varId = variable.i;
+      let varName = variable.n;
+      if (instance.length > 2) {
+        const subscriptIds = [];
+        const subscriptNames = [];
+        const subscriptCount = (instance.length - 2) / 2;
+        const subscriptIndices = instance.slice(2, 2 + subscriptCount);
+        for (const subscriptIndex of subscriptIndices) {
+          const subscript = encoded.subscripts[subscriptIndex];
+          subscriptIds.push(subscript.i);
+          subscriptNames.push(subscript.n);
+        }
+        varId += `[${subscriptIds.join(",")}]`;
+        varName += `[${subscriptNames.join(",")}]`;
+      }
+      const implVar = {
+        varId,
+        varName,
+        varType,
+        varIndex: variable.x,
+        subscriptIndices: instance.length > 2 ? instance.slice(2 + (instance.length - 2) / 2) : void 0
+      };
+      implVars.push(implVar);
+    }
+    result[groupKey] = implVars;
+  }
+  return result;
+}
+function parseSubscripts(text) {
+  const bracketIndex = text.indexOf("[");
+  if (bracketIndex === -1) {
+    return { base: text, subscripts: [] };
+  }
+  const base = text.substring(0, bracketIndex);
+  const subscriptText = text.substring(bracketIndex + 1, text.lastIndexOf("]"));
+  const subscripts = subscriptText.split(",").map((s) => s.trim());
+  return { base, subscripts };
+}
+
 // src/_shared/task-queue.ts
-var TaskQueue = class {
-  constructor(processor) {
-    this.processor = processor;
+var TaskQueue = class _TaskQueue {
+  /**
+   * @param executors The map of available task executors.
+   */
+  constructor(executors) {
+    this.executors = executors;
     /** The queue of task keys, most recent at front. */
     this.taskKeyQueue = [];
     /** The map of tasks. */
     this.taskMap = /* @__PURE__ */ new Map();
+    // /** The set of keys for the executors that are currently processing tasks. */
+    // private readonly activeExecutorKeys: Set<TaskExecutorKey> = new Set()
+    /** The idle event listeners. */
+    this.idleListeners = [];
     /** Whether tasks are being processed. */
     this.processing = false;
     /** Whether `shutdown` has been called. */
     this.stopped = false;
   }
-  addTask(key, input, onComplete) {
+  /**
+   * Initialize the shared `TaskQueue` instance.
+   *
+   * @param executors The map of available task executors.
+   */
+  static initialize(executors) {
+    if (executors.size === 0) {
+      throw new Error("Must provide at least one executor");
+    }
+    this.instance = new _TaskQueue(executors);
+  }
+  /**
+   * Get the shared `TaskQueue` instance.
+   */
+  static getInstance() {
+    if (!this.instance) {
+      throw new Error("TaskQueue not initialized; must call `initialize` first");
+    }
+    return this.instance;
+  }
+  /**
+   * Add a task to the queue.
+   *
+   * @param task The task to add.
+   */
+  addTask(task) {
     if (this.stopped) {
       return;
     }
-    if (this.taskMap.has(key)) {
-      throw new Error(`Task already added for key ${key}`);
+    if (this.taskMap.has(task.key)) {
+      throw new Error(`Task already added for key ${task.key}`);
     }
-    this.taskKeyQueue.push(key);
-    this.taskMap.set(key, {
-      input,
-      onComplete
-    });
+    this.taskKeyQueue.push(task.key);
+    this.taskMap.set(task.key, task);
     this.processTasksIfNeeded();
   }
+  /**
+   * Cancel a task.
+   *
+   * @param taskKey The key of the task to cancel.
+   */
   cancelTask(taskKey) {
     const index = this.taskKeyQueue.indexOf(taskKey);
     if (index >= 0) {
@@ -72,9 +217,37 @@ var TaskQueue = class {
     }
     this.taskMap.delete(taskKey);
   }
+  /**
+   * Add an idle listener.
+   *
+   * @param listener The listener to add.
+   */
+  onIdle(listener) {
+    this.idleListeners.push(listener);
+  }
+  /**
+   * Remove an idle listener.
+   *
+   * @param listener The listener to remove.
+   */
+  removeIdleListener(listener) {
+    this.idleListeners.splice(this.idleListeners.indexOf(listener), 1);
+  }
+  /**
+   * Notify the idle listeners.
+   *
+   * @param error The error to notify the listeners with.
+   */
+  notifyIdle(error) {
+    for (const listener of this.idleListeners) {
+      listener(error);
+    }
+  }
+  /**
+   * Shutdown the task queue, cancelling all pending tasks.
+   */
   shutdown() {
     this.stopped = true;
-    this.processing = false;
     this.taskKeyQueue.length = 0;
     this.taskMap.clear();
   }
@@ -82,75 +255,98 @@ var TaskQueue = class {
     if (!this.stopped && !this.processing) {
       this.processing = true;
       setTimeout(() => {
-        this.processNextTask();
+        this.processNextTasks();
       });
     }
   }
-  processNextTask() {
+  processNextTasks() {
     return __async(this, null, function* () {
-      var _a, _b;
-      const taskKey = this.taskKeyQueue.shift();
-      if (!taskKey) {
+      const taskKeys = this.taskKeyQueue.splice(0, this.executors.size);
+      if (taskKeys.length === 0) {
+        this.processing = false;
+        if (!this.stopped) {
+          this.notifyIdle();
+        }
         return;
       }
-      const task = this.taskMap.get(taskKey);
-      if (task) {
+      const executeCalls = [];
+      const availableExecutorKeys = Array.from(this.executors.keys());
+      for (const taskKey of taskKeys) {
+        const task = this.taskMap.get(taskKey);
+        if (!task) {
+          continue;
+        }
         this.taskMap.delete(taskKey);
-      } else {
-        return;
+        const executorKey = availableExecutorKeys.shift();
+        const executor = this.executors.get(executorKey);
+        if (!executor) {
+          throw new Error(`No executor found for key ${executorKey}`);
+        }
+        executeCalls.push(executor.execute(task));
       }
-      let output;
       try {
-        output = yield this.processor.process(task.input);
+        yield Promise.all(executeCalls);
       } catch (e) {
         if (!this.stopped) {
           this.shutdown();
-          (_a = this.onIdle) == null ? void 0 : _a.call(this, e);
+          this.notifyIdle(e);
         }
         return;
       }
-      task.onComplete(output);
       if (this.taskKeyQueue.length > 0) {
         setTimeout(() => {
-          this.processNextTask();
+          this.processNextTasks();
         });
       } else {
         this.processing = false;
         if (!this.stopped) {
-          (_b = this.onIdle) == null ? void 0 : _b.call(this);
+          this.notifyIdle();
         }
       }
     });
   }
 };
+function createExecutor(bundleModelL, bundleModelR) {
+  return {
+    execute: (task) => __async(this, null, function* () {
+      return task.process({
+        L: bundleModelL,
+        R: bundleModelR
+      });
+    })
+  };
+}
 
 // src/check/check-data-coordinator.ts
 var CheckDataCoordinator = class {
-  constructor(bundleModel) {
-    this.bundleModel = bundleModel;
-    this.taskQueue = new TaskQueue({
-      process: (request) => __async(this, null, function* () {
-        const result = yield this.bundleModel.getDatasetsForScenario(request.scenarioSpec, [request.datasetKey]);
-        const dataset = result.datasetMap.get(request.datasetKey);
-        return {
-          dataset
-        };
-      })
-    });
+  constructor(taskQueue) {
+    this.taskQueue = taskQueue;
   }
   requestDataset(requestKey, scenarioSpec, datasetKey, onResponse) {
-    const request = {
-      scenarioSpec,
-      datasetKey
+    const task = {
+      key: requestKey,
+      kind: "check-data-coordinator",
+      process: (bundleModels) => __async(this, null, function* () {
+        const bundleModelR = bundleModels.R;
+        const result = yield bundleModelR.getDatasetsForScenario(scenarioSpec, [datasetKey]);
+        const dataset = result.datasetMap.get(datasetKey);
+        onResponse(dataset);
+      })
     };
-    this.taskQueue.addTask(requestKey, request, (response) => {
-      onResponse(response.dataset);
-    });
+    this.taskQueue.addTask(task);
   }
   cancelRequest(key) {
     this.taskQueue.cancelTask(key);
   }
 };
+function createCheckDataCoordinator() {
+  return new CheckDataCoordinator(TaskQueue.getInstance());
+}
+function createCheckDataCoordinatorForTests(bundleModel) {
+  const executor = createExecutor(void 0, bundleModel);
+  const taskQueue = new TaskQueue(/* @__PURE__ */ new Map([["test-executor-0", executor]]));
+  return new CheckDataCoordinator(taskQueue);
+}
 
 // src/check/check-report.ts
 import assertNever2 from "assert-never";
@@ -212,6 +408,10 @@ function buildCheckReport(checkPlan, checkResults) {
                   testStatus = "failed";
                   scenarioStatus = "failed";
                   datasetStatus = "failed";
+                } else if (checkResult.status === "skipped" && testStatus === "passed") {
+                  testStatus = "skipped";
+                  scenarioStatus = "skipped";
+                  datasetStatus = "skipped";
                 }
               }
               predicateReports.push(predicateReport(predicatePlan, checkKey, checkResult));
@@ -1147,16 +1347,6 @@ function actionForPredicate(predicateSpec) {
   };
 }
 
-// src/_shared/combo.ts
-function cartesianProductOf(arr) {
-  return arr.reduce(
-    (a, b) => {
-      return a.map((x) => b.map((y) => x.concat([y]))).reduce((v, w) => v.concat(w), []);
-    },
-    [[]]
-  );
-}
-
 // src/check/check-dataset.ts
 function expandDatasets(modelSpec, datasetSpec) {
   var _a;
@@ -1185,25 +1375,10 @@ function expandDatasets(modelSpec, datasetSpec) {
         name: match.outputVar.varName
       });
     } else if (match.implVar) {
-      const implVar = match.implVar;
-      if (implVar.dimensions.length > 0) {
-        const baseDatasetKey = match.datasetKey;
-        const subscripts = [...implVar.dimensions.map((dim) => dim.subscripts)];
-        const subscriptCombos = cartesianProductOf(subscripts);
-        for (const subscriptCombo of subscriptCombos) {
-          const subIdParts = subscriptCombo.map((sub) => `[${sub.id}]`).join("");
-          const subNameParts = subscriptCombo.map((sub) => sub.name).join(",");
-          checkDatasets.push({
-            datasetKey: `${baseDatasetKey}${subIdParts}`,
-            name: `${implVar.varName}[${subNameParts}]`
-          });
-        }
-      } else {
-        checkDatasets.push({
-          datasetKey: match.datasetKey,
-          name: implVar.varName
-        });
-      }
+      checkDatasets.push({
+        datasetKey: match.datasetKey,
+        name: match.implVar.varName
+      });
     }
   }
   return checkDatasets;
@@ -1611,12 +1786,18 @@ var CheckPlanner = class {
     this.dataRefs = /* @__PURE__ */ new Map();
     this.checkKey = 1;
   }
-  addAllChecks(checkSpec, simplifyScenarios) {
+  addAllChecks(checkSpec, skipChecks) {
+    function skipCheckKey(groupName, testName) {
+      return `${groupName.toLowerCase()} :: ${testName.toLowerCase()}`;
+    }
+    const skipChecksSet = new Set(skipChecks.map((check) => skipCheckKey(check.groupName, check.testName)));
     for (const groupSpec of checkSpec.groups) {
       const groupName = groupSpec.describe;
       const planTests = [];
       for (const testSpec of groupSpec.tests) {
         const testName = testSpec.it;
+        const shouldSkip = skipChecksSet.has(skipCheckKey(groupName, testName));
+        const simplifyScenarios = false;
         const checkScenarios = expandScenarios(this.modelSpec, testSpec.scenarios || [], simplifyScenarios);
         const checkDatasets = [];
         for (const datasetSpec of testSpec.datasets) {
@@ -1657,7 +1838,8 @@ var CheckPlanner = class {
                 scenario: checkScenario,
                 dataset: checkDataset,
                 action: checkAction,
-                dataRefs
+                dataRefs,
+                skip: shouldSkip
               });
             }
             planDatasets.push({
@@ -1794,6 +1976,7 @@ function checkSummaryFromReport(checkReport) {
                 break;
               case "failed":
               case "error":
+              case "skipped":
                 predicateSummaries.push({
                   checkKey: predicate.checkKey,
                   result: predicate.result
@@ -1811,14 +1994,14 @@ function checkSummaryFromReport(checkReport) {
     predicateSummaries
   };
 }
-function checkReportFromSummary(checkConfig, checkSummary) {
+function checkReportFromSummary(checkConfig, checkSummary, skipChecks = []) {
   const checkSpecResult = parseTestYaml(checkConfig.tests);
   if (checkSpecResult.isErr()) {
     return void 0;
   }
   const checkSpec = checkSpecResult.value;
-  const checkPlanner = new CheckPlanner(checkConfig.bundle.model.modelSpec);
-  checkPlanner.addAllChecks(checkSpec, false);
+  const checkPlanner = new CheckPlanner(checkConfig.bundle.modelSpec);
+  checkPlanner.addAllChecks(checkSpec, skipChecks);
   const checkPlan = checkPlanner.buildPlan();
   const checkResults = /* @__PURE__ */ new Map();
   for (const predicateSummary of checkSummary.predicateSummaries) {
@@ -1828,98 +2011,115 @@ function checkReportFromSummary(checkConfig, checkSummary) {
 }
 
 // src/comparison/run/comparison-data-coordinator.ts
-import { assertNever as assertNever7 } from "assert-never";
 var ComparisonDataCoordinator = class {
-  constructor(bundleModelL, bundleModelR) {
-    this.bundleModelL = bundleModelL;
-    this.bundleModelR = bundleModelR;
-    this.taskQueue = new TaskQueue({
-      process: (request) => __async(this, null, function* () {
-        switch (request.kind) {
-          case "dataset":
-            return this.processDatasetRequest(request);
-          case "graph-data":
-            return this.processGraphDataRequest(request);
-          default:
-            assertNever7(request);
+  constructor(taskQueue) {
+    this.taskQueue = taskQueue;
+  }
+  /**
+   * Request datasets from the two models.
+   *
+   * @param requestKey The unique key for the request.
+   * @param sourceL The source of the first ("left") dataset.  If "left", the datasets will
+   * be fetched from the "left" bundle's model, otherwise they will be fetched from the
+   * "right" bundle's model.
+   * @param scenarioSpecL The scenario used for the first ("left") model of the comparison.
+   * @param sourceR The source of the second ("right") dataset.  If "left", the datasets
+   * will be fetched from the "left" bundle's model, otherwise they will be fetched from
+   * the "right" bundle's model.
+   * @param scenarioSpecR The scenario used for the second ("right") model of the comparison.
+   * @param graphId The keys of the datasets to be fetched.
+   * @param onResponse The callback that will be called with the dataset maps.
+   */
+  requestDatasetMaps(requestKey, sourceL, scenarioSpecL, sourceR, scenarioSpecR, datasetKeys, onResponse) {
+    function fetchDatasets(bundleModel, scenarioSpec) {
+      return __async(this, null, function* () {
+        if (scenarioSpec) {
+          return bundleModel.getDatasetsForScenario(scenarioSpec, datasetKeys);
+        } else {
+          return void 0;
+        }
+      });
+    }
+    const task = {
+      key: requestKey,
+      kind: "comparison-data-coordinator",
+      process: (bundleModels) => __async(this, null, function* () {
+        const modelL = sourceL === "left" ? bundleModels.L : bundleModels.R;
+        const modelR = sourceR === "left" ? bundleModels.L : bundleModels.R;
+        let resultL;
+        let resultR;
+        if (modelL === modelR) {
+          resultL = yield fetchDatasets(modelL, scenarioSpecL);
+          resultR = yield fetchDatasets(modelR, scenarioSpecR);
+        } else {
+          const results = yield Promise.all([
+            fetchDatasets(modelL, scenarioSpecL),
+            fetchDatasets(modelR, scenarioSpecR)
+          ]);
+          resultL = results[0];
+          resultR = results[1];
         }
+        onResponse(resultL == null ? void 0 : resultL.datasetMap, resultR == null ? void 0 : resultR.datasetMap);
       })
-    });
-  }
-  processDatasetRequest(request) {
-    return __async(this, null, function* () {
-      function fetchDatasets(bundleModel, scenarioSpec) {
-        return __async(this, null, function* () {
-          if (scenarioSpec) {
-            return bundleModel.getDatasetsForScenario(scenarioSpec, request.datasetKeys);
-          } else {
-            return void 0;
-          }
-        });
-      }
-      const [resultL, resultR] = yield Promise.all([
-        fetchDatasets(this.bundleModelL, request.scenarioSpecL),
-        fetchDatasets(this.bundleModelR, request.scenarioSpecR)
-      ]);
-      return {
-        kind: "dataset",
-        datasetMapL: resultL == null ? void 0 : resultL.datasetMap,
-        datasetMapR: resultR == null ? void 0 : resultR.datasetMap
-      };
-    });
-  }
-  processGraphDataRequest(request) {
-    return __async(this, null, function* () {
-      function fetchGraphData(bundleModel, scenarioSpec) {
-        return __async(this, null, function* () {
-          if (scenarioSpec) {
-            return bundleModel.getGraphDataForScenario(scenarioSpec, request.graphId);
-          } else {
-            return void 0;
-          }
-        });
-      }
-      const [graphDataL, graphDataR] = yield Promise.all([
-        fetchGraphData(this.bundleModelL, request.scenarioSpecL),
-        fetchGraphData(this.bundleModelR, request.scenarioSpecR)
-      ]);
-      return {
-        kind: "graph-data",
-        graphDataL,
-        graphDataR
-      };
-    });
-  }
-  requestDatasetMaps(requestKey, scenarioSpecL, scenarioSpecR, datasetKeys, onResponse) {
-    const request = {
-      kind: "dataset",
-      scenarioSpecL,
-      scenarioSpecR,
-      datasetKeys
     };
-    this.taskQueue.addTask(requestKey, request, (response) => {
-      if (response.kind === "dataset") {
-        onResponse(response.datasetMapL, response.datasetMapR);
-      }
-    });
+    this.taskQueue.addTask(task);
   }
-  requestGraphData(requestKey, scenarioSpecL, scenarioSpecR, graphId, onResponse) {
-    const request = {
-      kind: "graph-data",
-      scenarioSpecL,
-      scenarioSpecR,
-      graphId
+  /**
+   * Request graph data from the two models.
+   *
+   * @param requestKey The unique key for the request.
+   * @param sourceL The source of the first ("left") dataset.  If "left", the datasets will
+   * be fetched from the "left" bundle's model, otherwise they will be fetched from the
+   * "right" bundle's model.
+   * @param scenarioSpecL The scenario used for the first ("left") model of the comparison.
+   * @param sourceR The source of the second ("right") dataset.  If "left", the datasets
+   * will be fetched from the "left" bundle's model, otherwise they will be fetched from
+   * the "right" bundle's model.
+   * @param scenarioSpecR The scenario used for the second ("right") model of the comparison.
+   * @param graphId The ID of the graph for which data will be fetched.
+   * @param onResponse The callback that will be called with the graph data.
+   */
+  requestGraphData(requestKey, sourceL, scenarioSpecL, sourceR, scenarioSpecR, graphId, onResponse) {
+    function fetchGraphData(bundleModel, scenarioSpec) {
+      return __async(this, null, function* () {
+        if (scenarioSpec) {
+          return bundleModel.getGraphDataForScenario(scenarioSpec, graphId);
+        } else {
+          return void 0;
+        }
+      });
+    }
+    const task = {
+      key: requestKey,
+      kind: "comparison-data-coordinator",
+      process: (bundleModels) => __async(this, null, function* () {
+        const modelL = sourceL === "left" ? bundleModels.L : bundleModels.R;
+        const modelR = sourceR === "left" ? bundleModels.L : bundleModels.R;
+        let graphDataL;
+        let graphDataR;
+        if (modelL === modelR) {
+          graphDataL = yield fetchGraphData(modelL, scenarioSpecL);
+          graphDataR = yield fetchGraphData(modelR, scenarioSpecR);
+        } else {
+          const results = yield Promise.all([
+            fetchGraphData(modelL, scenarioSpecL),
+            fetchGraphData(modelR, scenarioSpecR)
+          ]);
+          graphDataL = results[0];
+          graphDataR = results[1];
+        }
+        onResponse(graphDataL, graphDataR);
+      })
     };
-    this.taskQueue.addTask(requestKey, request, (response) => {
-      if (response.kind === "graph-data") {
-        onResponse(response.graphDataL, response.graphDataR);
-      }
-    });
+    this.taskQueue.addTask(task);
   }
   cancelRequest(key) {
     this.taskQueue.cancelTask(key);
   }
 };
+function createComparisonDataCoordinator() {
+  return new ComparisonDataCoordinator(TaskQueue.getInstance());
+}
 
 // src/comparison/diff-datasets/diff-datasets.ts
 function diffDatasets(datasetL, datasetR) {
@@ -2069,14 +2269,14 @@ function diffGraphs(graphL, graphR, scenarioKey, testSummaries) {
 
 // src/comparison/report/comparison-reporting.ts
 function comparisonSummaryFromReport(comparisonReport) {
+  var _a, _b;
   const terseSummaries = [];
   for (const r of comparisonReport.testReports) {
-    if (r.diffReport.validity === "both" && r.diffReport.maxDiff > 0) {
-      terseSummaries.push({
-        s: r.scenarioKey,
-        d: r.datasetKey,
-        md: r.diffReport.maxDiff
-      });
+    const baselineMaxDiff = (_a = r.baselineDiffReport) == null ? void 0 : _a.maxDiff;
+    const baselineAvgDiff = (_b = r.baselineDiffReport) == null ? void 0 : _b.avgDiff;
+    const summary = testSummaryFromReport(r, baselineMaxDiff, baselineAvgDiff);
+    if (summary) {
+      terseSummaries.push(summary);
     }
   }
   return {
@@ -2085,6 +2285,43 @@ function comparisonSummaryFromReport(comparisonReport) {
     perfReportR: comparisonReport.perfReportR
   };
 }
+function testSummaryFromReport(r, baselineMaxDiff, baselineAvgDiff) {
+  var _a;
+  function baselineRelativeDiff(diffValue, baselineDiffValue) {
+    if (baselineDiffValue !== void 0) {
+      const epsilon = 1e-6;
+      if (baselineDiffValue === 0) {
+        baselineDiffValue = epsilon;
+      }
+      return diffValue / baselineDiffValue;
+    } else {
+      if (diffValue === 0) {
+        return 0;
+      } else {
+        return 1;
+      }
+    }
+  }
+  if (r.diffReport === void 0) {
+    return {
+      s: r.scenarioKey,
+      d: r.datasetKey
+    };
+  } else if (((_a = r.diffReport) == null ? void 0 : _a.validity) === "both" && r.diffReport.maxDiff > 0) {
+    const maxDiffRelativeToBaseline = baselineRelativeDiff(r.diffReport.maxDiff, baselineMaxDiff);
+    const avgDiffRelativeToBaseline = baselineRelativeDiff(r.diffReport.avgDiff, baselineAvgDiff);
+    return {
+      s: r.scenarioKey,
+      d: r.datasetKey,
+      md: r.diffReport.maxDiff,
+      ad: r.diffReport.avgDiff,
+      mdb: maxDiffRelativeToBaseline,
+      adb: avgDiffRelativeToBaseline
+    };
+  } else {
+    return void 0;
+  }
+}
 function restoreFromTerseSummaries(comparisonConfig, terseSummaries) {
   const existingSummaries = /* @__PURE__ */ new Map();
   for (const summary of terseSummaries) {
@@ -2097,24 +2334,33 @@ function restoreFromTerseSummaries(comparisonConfig, terseSummaries) {
     for (const datasetKey of datasetKeys) {
       const key = `${scenario.key}::${datasetKey}`;
       const existingSummary = existingSummaries.get(key);
-      const maxDiff = (existingSummary == null ? void 0 : existingSummary.md) || 0;
-      allTestSummaries.push({
-        s: scenario.key,
-        d: datasetKey,
-        md: maxDiff
-      });
+      if (existingSummary) {
+        allTestSummaries.push(existingSummary);
+      } else {
+        allTestSummaries.push({
+          s: scenario.key,
+          d: datasetKey,
+          md: 0,
+          ad: 0,
+          mdb: 0,
+          adb: 0
+        });
+      }
     }
   }
   return allTestSummaries;
 }
 
 // src/comparison/report/buckets.ts
-function getBucketIndex(diffPct, thresholds) {
-  if (diffPct === 0) {
+function getBucketIndex(diff, thresholds) {
+  if (diff === void 0) {
+    return thresholds.length + 2;
+  }
+  if (diff === 0) {
     return 0;
   }
   for (let i = 0; i < thresholds.length; i++) {
-    if (diffPct < thresholds[i]) {
+    if (diff < thresholds[i]) {
       return i + 1;
     }
   }
@@ -2122,14 +2368,32 @@ function getBucketIndex(diffPct, thresholds) {
 }
 
 // src/comparison/report/comparison-group-scores.ts
-function getScoresForTestSummaries(testSummaries, thresholds) {
-  const diffCountByBucket = Array(thresholds.length + 2).fill(0);
-  const totalMaxDiffByBucket = Array(thresholds.length + 2).fill(0);
+function getScoresForTestSummaries(testSummaries, thresholds, sortMode) {
+  const diffCountByBucket = Array(thresholds.length + 3).fill(0);
+  const totalDiffByBucket = Array(thresholds.length + 3).fill(0);
   let totalDiffCount = 0;
+  let valueKey;
+  switch (sortMode) {
+    case "max-diff":
+      valueKey = "md";
+      break;
+    case "avg-diff":
+      valueKey = "ad";
+      break;
+    case "max-diff-relative":
+      valueKey = "mdb";
+      break;
+    case "avg-diff-relative":
+      valueKey = "adb";
+      break;
+  }
   for (const testSummary of testSummaries) {
-    const bucketIndex = getBucketIndex(testSummary.md, thresholds);
+    const value = testSummary[valueKey];
+    const bucketIndex = getBucketIndex(value, thresholds);
     diffCountByBucket[bucketIndex]++;
-    totalMaxDiffByBucket[bucketIndex] += testSummary.md;
+    if (value !== void 0) {
+      totalDiffByBucket[bucketIndex] += value;
+    }
     totalDiffCount++;
   }
   let diffPercentByBucket;
@@ -2140,20 +2404,20 @@ function getScoresForTestSummaries(testSummaries, thresholds) {
   }
   return {
     totalDiffCount,
-    totalMaxDiffByBucket,
+    totalDiffByBucket,
     diffCountByBucket,
     diffPercentByBucket
   };
 }
 
 // src/comparison/report/comparison-grouping.ts
-import { assertNever as assertNever8 } from "assert-never";
-function categorizeComparisonTestSummaries(comparisonConfig, terseSummaries) {
+import { assertNever as assertNever7 } from "assert-never";
+function categorizeComparisonTestSummaries(comparisonConfig, terseSummaries, sortMode) {
   const allTestSummaries = restoreFromTerseSummaries(comparisonConfig, terseSummaries);
   const groupsByScenario = groupComparisonTestSummaries(allTestSummaries, "by-scenario");
-  const byScenario = categorizeComparisonGroups(comparisonConfig, [...groupsByScenario.values()]);
+  const byScenario = categorizeComparisonGroups(comparisonConfig, [...groupsByScenario.values()], sortMode);
   const groupsByDataset = groupComparisonTestSummaries(allTestSummaries, "by-dataset");
-  const byDataset = categorizeComparisonGroups(comparisonConfig, [...groupsByDataset.values()]);
+  const byDataset = categorizeComparisonGroups(comparisonConfig, [...groupsByDataset.values()], sortMode);
   return {
     allTestSummaries,
     byScenario,
@@ -2172,7 +2436,7 @@ function groupComparisonTestSummaries(testSummaries, groupKind) {
         groupKey = testSummary.s;
         break;
       default:
-        assertNever8(groupKind);
+        assertNever7(groupKind);
     }
     const group = groups.get(groupKey);
     if (group) {
@@ -2187,7 +2451,7 @@ function groupComparisonTestSummaries(testSummaries, groupKind) {
   }
   return groups;
 }
-function categorizeComparisonGroups(comparisonConfig, allGroups) {
+function categorizeComparisonGroups(comparisonConfig, allGroups, sortMode) {
   const allGroupSummaries = /* @__PURE__ */ new Map();
   const withErrors = [];
   const onlyInLeft = [];
@@ -2197,7 +2461,9 @@ function categorizeComparisonGroups(comparisonConfig, allGroups) {
   function addSummaryForGroup(group, root, validInL, validInR) {
     let scores;
     if (validInL && validInR) {
-      scores = getScoresForTestSummaries(group.testSummaries, comparisonConfig.thresholds);
+      const isRelativeMode = sortMode === "max-diff-relative" || sortMode === "avg-diff-relative";
+      const thresholds = isRelativeMode ? comparisonConfig.ratioThresholds : comparisonConfig.thresholds;
+      scores = getScoresForTestSummaries(group.testSummaries, thresholds, sortMode);
     }
     const groupSummary = {
       root,
@@ -2206,7 +2472,9 @@ function categorizeComparisonGroups(comparisonConfig, allGroups) {
     };
     allGroupSummaries.set(group.key, groupSummary);
     if (validInL && validInR) {
-      if (scores.totalDiffCount !== scores.diffCountByBucket[0]) {
+      const noDiffCount = scores.diffCountByBucket[0];
+      const skippedCount = scores.diffCountByBucket[5];
+      if (scores.totalDiffCount !== noDiffCount + skippedCount) {
         withDiffs.push(groupSummary);
       } else {
         withoutDiffs.push(groupSummary);
@@ -2236,7 +2504,7 @@ function categorizeComparisonGroups(comparisonConfig, allGroups) {
         break;
       }
       default:
-        assertNever8(group.kind);
+        assertNever7(group.kind);
     }
   }
   if (withDiffs.length > 1) {
@@ -2298,13 +2566,13 @@ function sortScenarioGroupSummaries(summaries) {
   });
 }
 function compareScores(a, b) {
-  if (a.totalMaxDiffByBucket.length !== b.totalMaxDiffByBucket.length) {
+  if (a.totalDiffByBucket.length !== b.totalDiffByBucket.length) {
     return 0;
   }
-  const len = a.totalMaxDiffByBucket.length;
+  const len = a.totalDiffByBucket.length;
   for (let i = len - 1; i >= 0; i--) {
-    const aTotal = a.totalMaxDiffByBucket[i];
-    const bTotal = b.totalMaxDiffByBucket[i];
+    const aTotal = a.totalDiffByBucket[i];
+    const bTotal = b.totalDiffByBucket[i];
     if (aTotal > bTotal) {
       return 1;
     } else if (aTotal < bTotal) {
@@ -2316,7 +2584,7 @@ function compareScores(a, b) {
 
 // src/comparison/config/parse/comparison-parser.ts
 import Ajv2 from "ajv";
-import assertNever9 from "assert-never";
+import assertNever8 from "assert-never";
 import { err as err2, ok as ok2 } from "neverthrow";
 import yaml2 from "yaml";
 
@@ -2852,7 +3120,7 @@ function parseComparisonSpecs(specSource) {
       parsed = yaml2.parse(specSource.content);
       break;
     default:
-      assertNever9(specSource.kind);
+      assertNever8(specSource.kind);
   }
   if (validate(parsed)) {
     for (const specItem of parsed) {
@@ -3079,7 +3347,7 @@ function viewGroupSpecFromParsed(parsedViewGroup) {
 }
 
 // src/comparison/config/resolve/comparison-resolver.ts
-import { assertNever as assertNever11 } from "assert-never";
+import { assertNever as assertNever10 } from "assert-never";
 
 // src/bundle/model-inputs.ts
 var ModelInputs = class {
@@ -3142,7 +3410,7 @@ var ModelInputs = class {
 };
 
 // src/comparison/config/resolve/comparison-scenario-specs.ts
-import { assertNever as assertNever10 } from "assert-never";
+import { assertNever as assertNever9 } from "assert-never";
 function scenarioSpecsFromSettings(settings) {
   switch (settings.kind) {
     case "all-inputs-settings": {
@@ -3155,7 +3423,7 @@ function scenarioSpecsFromSettings(settings) {
       return [specL, specR];
     }
     default:
-      assertNever10(settings);
+      assertNever9(settings);
   }
 }
 function scenarioSpecFromInputs(inputs, side) {
@@ -3374,7 +3642,7 @@ function resolveScenariosFromSpec(modelInputsL, modelInputsR, scenarioSpec, genK
       ];
     }
     default:
-      assertNever11(scenarioSpec);
+      assertNever10(scenarioSpec);
   }
 }
 function resolveScenarioMatrix(modelInputsL, modelInputsR, genKey) {
@@ -3430,7 +3698,7 @@ function resolveScenarioForInputSpecs(modelInputsL, modelInputsR, key, id, title
       case "input-at-value":
         return resolveInputForName(modelInputsL, modelInputsR, inputSpec.inputName, inputSpec.value);
       default:
-        assertNever11(inputSpec);
+        assertNever10(inputSpec);
     }
   });
   const settings = {
@@ -3463,7 +3731,7 @@ function resolveScenarioForDistinctInputSpecs(modelInputsL, modelInputsR, key, i
         inputState = resolveInputForNameInModel(modelInputs, inputSpec.inputName, inputSpec.value);
         break;
       default:
-        assertNever11(inputSpec);
+        assertNever10(inputSpec);
     }
     if (inputState.error !== void 0) {
       inputsWithErrors.push({
@@ -3679,7 +3947,7 @@ function inputValueAtPosition2(inputVar, position) {
     case "at-maximum":
       return inputVar.maxValue;
     default:
-      assertNever11(position);
+      assertNever10(position);
   }
 }
 var ResolvedScenarioGroups = class {
@@ -3738,7 +4006,7 @@ function resolveGraphsFromSpec(modelSpecL, modelSpecR, resolvedGraphGroups, grap
           return [...graphIds];
         }
         default:
-          assertNever11(graphsSpec.preset);
+          assertNever10(graphsSpec.preset);
       }
     }
     // eslint-disable-next-line no-fallthrough
@@ -3752,7 +4020,7 @@ function resolveGraphsFromSpec(modelSpecL, modelSpecR, resolvedGraphGroups, grap
       return groupSpec.graphIds;
     }
     default:
-      assertNever11(graphsSpec);
+      assertNever10(graphsSpec);
   }
 }
 function resolveViewForScenarioId(resolvedScenarios, viewTitle, viewSubtitle, scenarioId, graphIds, graphOrder) {
@@ -3926,7 +4194,7 @@ function resolveViewGroupFromSpec(modelSpecL, modelSpecR, modelOutputs, resolved
                     views.push(resolveViewForScenario(void 0, void 0, scenario, graphIds, graphOrder));
                     break;
                   default:
-                    assertNever11(scenario);
+                    assertNever10(scenario);
                 }
               }
             } else {
@@ -3935,13 +4203,13 @@ function resolveViewGroupFromSpec(modelSpecL, modelSpecR, modelOutputs, resolved
             break;
           }
           default:
-            assertNever11(refSpec);
+            assertNever10(refSpec);
         }
       }
       break;
     }
     default:
-      assertNever11(viewGroupSpec);
+      assertNever10(viewGroupSpec);
   }
   return {
     kind: "view-group",
@@ -4004,9 +4272,9 @@ var ComparisonDatasetsImpl = class {
     }
     const allOutputVarKeysSet = /* @__PURE__ */ new Set();
     const modelOutputVarKeysSet = /* @__PURE__ */ new Set();
-    function addOutputVars(outputVars, handleRenames) {
+    function addOutputVars(outputVars, handleRenames2) {
       outputVars.forEach((outputVar, key) => {
-        const remappedKey = handleRenames ? leftKeyForRightKey(key) : key;
+        const remappedKey = handleRenames2 ? leftKeyForRightKey(key) : key;
         allOutputVarKeysSet.add(remappedKey);
         if (outputVar.sourceName === void 0) {
           modelOutputVarKeysSet.add(remappedKey);
@@ -4120,109 +4388,41 @@ var ComparisonScenariosImpl = class {
   }
 };
 
-// src/config/synchronized-model.ts
-function synchronizedBundleModel(sourceModel) {
-  const promiseQueue = new PromiseQueue();
-  return {
-    modelSpec: sourceModel.modelSpec,
-    getDatasetsForScenario: (scenarioSpec, datasetKeys) => {
-      return promiseQueue.add(() => sourceModel.getDatasetsForScenario(scenarioSpec, datasetKeys));
-    },
-    getGraphDataForScenario: (scenarioSpec, graphId) => {
-      return promiseQueue.add(() => sourceModel.getGraphDataForScenario(scenarioSpec, graphId));
-    },
-    getGraphLinksForScenario: sourceModel.getGraphLinksForScenario.bind(sourceModel)
-  };
-}
-var PromiseQueue = class {
-  constructor() {
-    this.tasks = [];
-    this.runningCount = 0;
-  }
-  add(f) {
-    return new Promise((resolve, reject) => {
-      const run = () => __async(this, null, function* () {
-        this.runningCount++;
-        const promise = f();
-        try {
-          const result = yield promise;
-          resolve(result);
-        } catch (e) {
-          reject(e);
-        } finally {
-          this.runningCount--;
-          this.runNext();
-        }
-      });
-      if (this.runningCount < 1) {
-        run();
-      } else {
-        this.tasks.push(run);
-      }
-    });
-  }
-  runNext() {
-    if (this.tasks.length > 0) {
-      const task = this.tasks.shift();
-      if (task) {
-        task();
-      }
-    }
-  }
-};
-
 // src/config/config.ts
 function createConfig(options) {
   return __async(this, null, function* () {
-    var _a;
-    const origCurrentBundle = yield loadSynchronized(options.current);
+    var _a, _b, _c, _d, _e;
+    let concurrentModels;
+    if (options.concurrency === void 0) {
+      concurrentModels = 1;
+    } else if (options.concurrency === 0) {
+      let coreCount;
+      if (typeof navigator !== "undefined") {
+        coreCount = navigator.hardwareConcurrency;
+      }
+      if (coreCount === void 0 || coreCount < 1) {
+        coreCount = 1;
+      }
+      concurrentModels = Math.max(1, Math.floor(coreCount / 2));
+    } else {
+      concurrentModels = Math.max(1, options.concurrency);
+    }
+    const origCurrentBundle = yield loadBundle(options.current, concurrentModels);
     let currentBundle;
     let comparisonConfig;
     if (options.comparison === void 0) {
       currentBundle = origCurrentBundle;
     } else {
-      const baselineBundle = yield loadSynchronized(options.comparison.baseline);
-      const renamedDatasetKeys = (_a = options.comparison.datasets) == null ? void 0 : _a.renamedDatasetKeys;
-      const invertedRenamedKeys = /* @__PURE__ */ new Map();
-      renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.forEach((newKey, oldKey) => {
-        invertedRenamedKeys.set(newKey, oldKey);
-      });
-      const rightKeyForLeftKey = (leftKey) => {
-        return (renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.get(leftKey)) || leftKey;
-      };
-      const leftKeyForRightKey = (rightKey) => {
-        return invertedRenamedKeys.get(rightKey) || rightKey;
-      };
-      const origBundleModelR = origCurrentBundle.model;
-      const adjBundleModelR = {
-        modelSpec: origBundleModelR.modelSpec,
-        getDatasetsForScenario: (scenarioSpec, datasetKeys) => __async(this, null, function* () {
-          const rightKeys = datasetKeys.map(rightKeyForLeftKey);
-          const result = yield origBundleModelR.getDatasetsForScenario(scenarioSpec, rightKeys);
-          const mapWithRightKeys = result.datasetMap;
-          const mapWithLeftKeys = /* @__PURE__ */ new Map();
-          for (const [rightKey, dataset] of mapWithRightKeys.entries()) {
-            const leftKey = leftKeyForRightKey(rightKey);
-            mapWithLeftKeys.set(leftKey, dataset);
-          }
-          return {
-            datasetMap: mapWithLeftKeys,
-            modelRunTime: result.modelRunTime
-          };
-        }),
-        getGraphDataForScenario: origBundleModelR.getGraphDataForScenario.bind(origBundleModelR),
-        getGraphLinksForScenario: origBundleModelR.getGraphLinksForScenario.bind(origBundleModelR)
-      };
-      currentBundle = __spreadProps(__spreadValues({}, origCurrentBundle), {
-        model: adjBundleModelR
-      });
-      const modelSpecL = baselineBundle.model.modelSpec;
-      const modelSpecR = currentBundle.model.modelSpec;
+      const baselineBundle = yield loadBundle(options.comparison.baseline, concurrentModels);
+      currentBundle = handleRenames(origCurrentBundle, (_a = options.comparison.datasets) == null ? void 0 : _a.renamedDatasetKeys);
+      const modelSpecL = baselineBundle.modelSpec;
+      const modelSpecR = currentBundle.modelSpec;
       const comparisonDefs = resolveComparisonSpecsFromSources(modelSpecL, modelSpecR, options.comparison.specs);
       comparisonConfig = {
         bundleL: baselineBundle,
         bundleR: currentBundle,
-        thresholds: options.comparison.thresholds,
+        thresholds: (_b = options.comparison.thresholds) != null ? _b : [1, 5, 10],
+        ratioThresholds: (_c = options.comparison.ratioThresholds) != null ? _c : [1, 2, 3],
         scenarios: getComparisonScenarios(comparisonDefs.scenarios),
         datasets: getComparisonDatasets(modelSpecL, modelSpecR, options.comparison.datasets),
         viewGroups: comparisonDefs.viewGroups,
@@ -4233,26 +4433,75 @@ function createConfig(options) {
       bundle: currentBundle,
       tests: options.check.tests
     };
+    const executors = /* @__PURE__ */ new Map();
+    for (let i = 0; i < checkConfig.bundle.models.length; i++) {
+      const bundleModelL = (_d = comparisonConfig == null ? void 0 : comparisonConfig.bundleL.models) == null ? void 0 : _d[i];
+      const bundleModelR = ((_e = comparisonConfig == null ? void 0 : comparisonConfig.bundleR.models) == null ? void 0 : _e[i]) || checkConfig.bundle.models[i];
+      const executor = createExecutor(bundleModelL, bundleModelR);
+      executors.set(`executor-${i}`, executor);
+    }
+    TaskQueue.initialize(executors);
     return {
       check: checkConfig,
       comparison: comparisonConfig
     };
   });
 }
-function loadSynchronized(sourceBundle) {
+function loadBundle(bundle, concurrentModels) {
   return __async(this, null, function* () {
-    const sourceModel = yield sourceBundle.bundle.initModel();
-    const synchronizedModel = synchronizedBundleModel(sourceModel);
+    const initCalls = Array.from({ length: concurrentModels }, () => bundle.bundle.initModel());
+    const models = yield Promise.all(initCalls);
     return {
-      name: sourceBundle.name,
-      version: sourceBundle.bundle.version,
-      model: synchronizedModel
+      name: bundle.name,
+      version: bundle.bundle.version,
+      modelSpec: bundle.bundle.modelSpec,
+      models
+    };
+  });
+}
+function handleRenames(origCurrentBundle, renamedDatasetKeys) {
+  if (renamedDatasetKeys === void 0 || renamedDatasetKeys.size === 0) {
+    return origCurrentBundle;
+  }
+  const invertedRenamedKeys = /* @__PURE__ */ new Map();
+  renamedDatasetKeys.forEach((newKey, oldKey) => {
+    invertedRenamedKeys.set(newKey, oldKey);
+  });
+  const rightKeyForLeftKey = (leftKey) => {
+    return (renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.get(leftKey)) || leftKey;
+  };
+  const leftKeyForRightKey = (rightKey) => {
+    return invertedRenamedKeys.get(rightKey) || rightKey;
+  };
+  function wrapModel(origBundleModelR) {
+    return {
+      modelSpec: origBundleModelR.modelSpec,
+      getDatasetsForScenario: (scenarioSpec, datasetKeys) => __async(this, null, function* () {
+        const rightKeys = datasetKeys.map(rightKeyForLeftKey);
+        const result = yield origBundleModelR.getDatasetsForScenario(scenarioSpec, rightKeys);
+        const mapWithRightKeys = result.datasetMap;
+        const mapWithLeftKeys = /* @__PURE__ */ new Map();
+        for (const [rightKey, dataset] of mapWithRightKeys.entries()) {
+          const leftKey = leftKeyForRightKey(rightKey);
+          mapWithLeftKeys.set(leftKey, dataset);
+        }
+        return {
+          datasetMap: mapWithLeftKeys,
+          modelRunTime: result.modelRunTime
+        };
+      }),
+      getGraphDataForScenario: origBundleModelR.getGraphDataForScenario.bind(origBundleModelR),
+      getGraphLinksForScenario: origBundleModelR.getGraphLinksForScenario.bind(origBundleModelR)
     };
+  }
+  const wrappedModels = origCurrentBundle.models.map(wrapModel);
+  return __spreadProps(__spreadValues({}, origCurrentBundle), {
+    models: wrappedModels
   });
 }
 
 // src/perf/perf-runner.ts
-import { assertNever as assertNever12 } from "assert-never";
+import { assertNever as assertNever11 } from "assert-never";
 
 // src/perf/perf-stats.ts
 var PerfStats = class {
@@ -4289,80 +4538,110 @@ var PerfStats = class {
 };
 
 // src/perf/perf-runner.ts
-var warmupCount = 5;
-var runCount = 100;
+function runPerfWithTaskQueue(taskQueue, callbacks, options) {
+  const perfRunner = new PerfRunner(taskQueue, callbacks, options);
+  perfRunner.start();
+  return () => {
+    perfRunner.cancel();
+  };
+}
+function runPerf(callbacks, options) {
+  const taskQueue = TaskQueue.getInstance();
+  return runPerfWithTaskQueue(taskQueue, callbacks, options);
+}
 var PerfRunner = class {
-  constructor(bundleModelL, bundleModelR, mode = "serial") {
-    this.bundleModelL = bundleModelL;
-    this.bundleModelR = bundleModelR;
-    this.mode = mode;
-    const scenarioSpec = allInputsAtPositionSpec("at-default");
-    this.taskQueue = new TaskQueue({
-      process: (request) => __async(this, null, function* () {
-        switch (request.kind) {
-          case "left": {
-            const result = yield bundleModelL.getDatasetsForScenario(scenarioSpec, []);
-            return {
-              runTimeL: result.modelRunTime
-            };
-          }
-          case "right": {
-            const result = yield bundleModelR.getDatasetsForScenario(scenarioSpec, []);
-            return {
-              runTimeR: result.modelRunTime
-            };
-          }
-          case "both": {
-            const [resultL, resultR] = yield Promise.all([
-              bundleModelL.getDatasetsForScenario(scenarioSpec, []),
-              bundleModelR.getDatasetsForScenario(scenarioSpec, [])
-            ]);
-            return {
-              runTimeL: resultL.modelRunTime,
-              runTimeR: resultR.modelRunTime
-            };
-          }
-          default:
-            assertNever12(request.kind);
-        }
-      })
-    });
+  constructor(taskQueue, callbacks, options) {
+    this.taskQueue = taskQueue;
+    this.callbacks = callbacks;
+    this.options = options;
+    this.pendingTaskKeys = /* @__PURE__ */ new Set();
+    this.stopped = false;
+  }
+  cancel() {
+    if (!this.stopped) {
+      for (const taskKey of this.pendingTaskKeys) {
+        this.taskQueue.cancelTask(taskKey);
+      }
+      this.stopped = true;
+    }
   }
   start() {
+    var _a, _b, _c, _d, _e, _f;
     const statsL = new PerfStats();
     const statsR = new PerfStats();
-    this.taskQueue.onIdle = (error) => {
-      var _a;
-      if (error) {
-        this.onError(error);
-      } else {
-        (_a = this.onComplete) == null ? void 0 : _a.call(this, statsL.toReport(), statsR.toReport());
-      }
-    };
-    const taskQueue = this.taskQueue;
-    function addTask(index, warmup, kind) {
-      const key = `${warmup ? "warmup-" : ""}${kind}-${index}`;
-      const request = {
-        kind
-      };
-      taskQueue.addTask(key, request, (response) => {
-        if (!warmup && response.runTimeL !== void 0) {
-          statsL.addRun(response.runTimeL);
-        }
-        if (!warmup && response.runTimeR !== void 0) {
-          statsR.addRun(response.runTimeR);
-        }
-      });
+    const scenarioSpec = allInputsAtPositionSpec("at-default");
+    const warmupCount = (_b = (_a = this.options) == null ? void 0 : _a.warmupCount) != null ? _b : 5;
+    const runCount = (_d = (_c = this.options) == null ? void 0 : _c.runCount) != null ? _d : 100;
+    let totalTasks = 0;
+    if (((_e = this.options) == null ? void 0 : _e.mode) === "parallel") {
+      totalTasks = warmupCount + runCount;
+    } else {
+      totalTasks = (warmupCount + runCount) * 2;
     }
+    let tasksCompleted = 0;
+    let perfTaskId = 1;
+    const addTask = (warmup, kind) => {
+      const task = {
+        key: `perf-runner-${perfTaskId++}`,
+        kind: "perf-runner",
+        process: (bundleModels) => __async(this, null, function* () {
+          var _a2, _b2, _c2, _d2;
+          this.pendingTaskKeys.delete(task.key);
+          try {
+            let runTimeL;
+            let runTimeR;
+            switch (kind) {
+              case "left": {
+                const result = yield bundleModels.L.getDatasetsForScenario(scenarioSpec, []);
+                runTimeL = result.modelRunTime;
+                break;
+              }
+              case "right": {
+                const result = yield bundleModels.R.getDatasetsForScenario(scenarioSpec, []);
+                runTimeR = result.modelRunTime;
+                break;
+              }
+              case "both": {
+                const [resultL, resultR] = yield Promise.all([
+                  bundleModels.L.getDatasetsForScenario(scenarioSpec, []),
+                  bundleModels.R.getDatasetsForScenario(scenarioSpec, [])
+                ]);
+                runTimeL = resultL.modelRunTime;
+                runTimeR = resultR.modelRunTime;
+                break;
+              }
+              default:
+                assertNever11(kind);
+            }
+            if (!warmup) {
+              if (runTimeL !== void 0) {
+                statsL.addRun(runTimeL);
+              }
+              if (runTimeR !== void 0) {
+                statsR.addRun(runTimeR);
+              }
+            }
+            tasksCompleted++;
+            if (tasksCompleted === totalTasks) {
+              (_b2 = (_a2 = this.callbacks).onComplete) == null ? void 0 : _b2.call(_a2, statsL.toReport(), statsR.toReport());
+            }
+          } catch (error) {
+            (_d2 = (_c2 = this.callbacks).onError) == null ? void 0 : _d2.call(_c2, error);
+          }
+        })
+      };
+      this.taskQueue.addTask(task);
+      this.pendingTaskKeys.add(task.key);
+    };
     function addTasks(kind) {
       for (let i = 0; i < warmupCount; i++) {
-        addTask(i, true, kind);
+        addTask(true, kind);
       }
       for (let i = 0; i < runCount; i++) {
-        addTask(i, false, kind);
+        addTask(false, kind);
       }
     }
-    if (this.mode === "parallel") {
+    if (((_f = this.options) == null ? void 0 : _f.mode) === "parallel") {
       addTasks("both");
     } else {
       addTasks("left");
@@ -4371,6 +4650,303 @@ var PerfRunner = class {
   }
 };
 
+// src/trace/trace-runner.ts
+import { assertNever as assertNever12 } from "assert-never";
+function runTraceWithTaskQueue(modelSpec, taskQueue, callbacks, options) {
+  const traceRunner = new TraceRunner(taskQueue, callbacks);
+  traceRunner.start(modelSpec, options);
+  return () => {
+    traceRunner.cancel();
+  };
+}
+function runTrace(modelSpec, callbacks, options) {
+  const taskQueue = TaskQueue.getInstance();
+  return runTraceWithTaskQueue(modelSpec, taskQueue, callbacks, options);
+}
+var TraceRunner = class {
+  constructor(taskQueue, callbacks) {
+    this.taskQueue = taskQueue;
+    this.callbacks = callbacks;
+    this.pendingTaskKeys = /* @__PURE__ */ new Set();
+    this.stopped = false;
+  }
+  cancel() {
+    if (!this.stopped) {
+      for (const taskKey of this.pendingTaskKeys) {
+        this.taskQueue.cancelTask(taskKey);
+      }
+      this.stopped = true;
+    }
+  }
+  start(modelSpec, options) {
+    const allDatasetKeys = [...modelSpec.implVars.keys()];
+    const traceRequests = [];
+    const batchSize = 2e3;
+    for (let i = 0; i < allDatasetKeys.length; i += batchSize) {
+      const datasetKeysForBatch = allDatasetKeys.slice(i, i + batchSize);
+      switch (options.kind) {
+        case "compare-to-bundle":
+          traceRequests.push({
+            kind: "compare-to-bundle",
+            datasetKeys: datasetKeysForBatch,
+            bundleSide0: options.bundleSide0,
+            scenarioSpec0: options.scenarioSpec0,
+            bundleSide1: options.bundleSide1,
+            scenarioSpec1: options.scenarioSpec1
+          });
+          break;
+        case "compare-to-ext-data":
+          traceRequests.push({
+            kind: "compare-to-ext-data",
+            datasetKeys: datasetKeysForBatch,
+            extData: options.extData,
+            bundleSide: options.bundleSide,
+            scenarioSpec: options.scenarioSpec
+          });
+          break;
+        default:
+          assertNever12(options);
+      }
+    }
+    const allDatasetReports = /* @__PURE__ */ new Map();
+    const taskCount = traceRequests.length;
+    let tasksCompleted = 0;
+    let traceTaskId = 1;
+    for (const traceRequest of traceRequests) {
+      const task = {
+        key: `trace-runner-${traceTaskId++}`,
+        kind: "trace-runner",
+        process: (bundleModels) => __async(this, null, function* () {
+          var _a, _b;
+          this.pendingTaskKeys.delete(task.key);
+          let datasetReports;
+          switch (traceRequest.kind) {
+            case "compare-to-bundle":
+              datasetReports = yield processCompareToBundleRequest(traceRequest, bundleModels);
+              break;
+            case "compare-to-ext-data":
+              datasetReports = yield processCompareToExtDataRequest(traceRequest, bundleModels);
+              break;
+            default:
+              assertNever12(traceRequest);
+          }
+          for (const datasetReport of datasetReports) {
+            allDatasetReports.set(datasetReport.datasetKey, datasetReport);
+          }
+          tasksCompleted++;
+          if (tasksCompleted === taskCount) {
+            const traceReport = {
+              datasetReports: allDatasetReports
+            };
+            (_b = (_a = this.callbacks).onComplete) == null ? void 0 : _b.call(_a, traceReport);
+          }
+        })
+      };
+      this.taskQueue.addTask(task);
+      this.pendingTaskKeys.add(task.key);
+    }
+  }
+};
+function processCompareToBundleRequest(request, bundleModels) {
+  return __async(this, null, function* () {
+    const bundleModel0 = request.bundleSide0 === "left" ? bundleModels.L : bundleModels.R;
+    const bundleModel1 = request.bundleSide1 === "left" ? bundleModels.L : bundleModels.R;
+    let result0;
+    let result1;
+    if (bundleModel1 === bundleModel0) {
+      result0 = yield bundleModel0.getDatasetsForScenario(request.scenarioSpec0, request.datasetKeys);
+      result1 = yield bundleModel1.getDatasetsForScenario(request.scenarioSpec1, request.datasetKeys);
+    } else {
+      ;
+      [result0, result1] = yield Promise.all([
+        bundleModel0.getDatasetsForScenario(request.scenarioSpec0, request.datasetKeys),
+        bundleModel1.getDatasetsForScenario(request.scenarioSpec1, request.datasetKeys)
+      ]);
+    }
+    const datasetReports = [];
+    for (const datasetKey of request.datasetKeys) {
+      const dataset0 = result0.datasetMap.get(datasetKey);
+      const dataset1 = result1.datasetMap.get(datasetKey);
+      const datasetReport = diffDatasets2(
+        datasetKey,
+        dataset0,
+        dataset1,
+        /*matchPrecisionOfLeft=*/
+        false
+      );
+      datasetReports.push(datasetReport);
+    }
+    return datasetReports;
+  });
+}
+function processCompareToExtDataRequest(request, bundleModels) {
+  return __async(this, null, function* () {
+    const bundleModel = request.bundleSide === "left" ? bundleModels.L : bundleModels.R;
+    const resultR = yield bundleModel.getDatasetsForScenario(request.scenarioSpec, request.datasetKeys);
+    const datasetReports = [];
+    for (const datasetKey of request.datasetKeys) {
+      let datasetL = request.extData.get(datasetKey);
+      if (datasetL === void 0) {
+        const datasetKeyParts = datasetKey.split("[");
+        if (datasetKeyParts.length === 2) {
+          const baseKey = datasetKeyParts[0];
+          const keySubParts = datasetKeyParts[1].replace("]", "");
+          const keySubIds = keySubParts.split(",");
+          const subIdPermutations = permutationsOf(keySubIds);
+          for (const subIds of subIdPermutations) {
+            const datDatasetKey = `${baseKey}[${subIds.join(",")}]`;
+            datasetL = request.extData.get(datDatasetKey);
+            if (datasetL !== void 0) {
+              break;
+            }
+          }
+        }
+        if (datasetL === void 0) {
+          console.warn(`WARNING: Failed to find data in dat file for key=${datasetKey}`);
+        }
+      }
+      const datasetR = resultR.datasetMap.get(datasetKey);
+      const datasetReport = diffDatasets2(
+        datasetKey,
+        datasetL,
+        datasetR,
+        /*matchPrecisionOfLeft=*/
+        true
+      );
+      datasetReports.push(datasetReport);
+    }
+    return datasetReports;
+  });
+}
+function diffDatasets2(datasetKey, datasetL, datasetR, matchPrecisionOfLeft) {
+  const points = /* @__PURE__ */ new Map();
+  let minValueL = Number.MAX_VALUE;
+  let maxValueL = Number.MIN_VALUE;
+  let minValueR = Number.MAX_VALUE;
+  let maxValueR = Number.MIN_VALUE;
+  let minValue = Number.MAX_VALUE;
+  let maxValue = Number.MIN_VALUE;
+  let minRawDiff = Number.MAX_VALUE;
+  let maxRawDiff = -1;
+  let maxDiffPoint;
+  let diffCount = 0;
+  let totalRawDiff = 0;
+  if (datasetL && datasetR) {
+    const times = /* @__PURE__ */ new Set([...datasetL.keys(), ...datasetR.keys()]);
+    for (const t of times) {
+      const valueL = datasetL.get(t);
+      if (valueL !== void 0) {
+        if (valueL < minValueL) minValueL = valueL;
+        if (valueL > maxValueL) maxValueL = valueL;
+        if (valueL < minValue) minValue = valueL;
+        if (valueL > maxValue) maxValue = valueL;
+      }
+      let valueR;
+      const rawValueR = datasetR.get(t);
+      if (rawValueR !== void 0) {
+        if (matchPrecisionOfLeft && valueL !== void 0) {
+          valueR = matchPrecision(rawValueR, valueL);
+        } else {
+          valueR = rawValueR;
+        }
+        if (valueR < minValueR) minValueR = valueR;
+        if (valueR > maxValueR) maxValueR = valueR;
+        if (valueR < minValue) minValue = valueR;
+        if (valueR > maxValue) maxValue = valueR;
+      }
+      if (valueL === void 0 || valueR === void 0) {
+        continue;
+      }
+      const point = {
+        time: t,
+        valueL,
+        valueR
+      };
+      points.set(t, point);
+      const rawDiff = Math.abs(valueR - valueL);
+      if (rawDiff < minRawDiff) {
+        minRawDiff = rawDiff;
+      }
+      if (rawDiff > maxRawDiff) {
+        maxRawDiff = rawDiff;
+        maxDiffPoint = point;
+      }
+      diffCount++;
+      totalRawDiff += rawDiff;
+    }
+  }
+  function pct(x) {
+    return x * 100;
+  }
+  let minDiff;
+  let maxDiff;
+  let avgDiff;
+  if (minValueL === maxValueL && minValueR === maxValueR) {
+    const diff = pct(maxValueL !== 0 ? Math.abs((maxValueR - maxValueL) / maxValueL) : 1);
+    minDiff = diff;
+    maxDiff = diff;
+    avgDiff = diff;
+  } else {
+    const spread = maxValue - minValue;
+    minDiff = pct(spread > 0 ? minRawDiff / spread : 0);
+    maxDiff = pct(spread > 0 ? maxRawDiff / spread : 0);
+    const avgRawDiff = totalRawDiff / diffCount;
+    avgDiff = pct(spread > 0 ? avgRawDiff / spread : 0);
+  }
+  let validity;
+  if (datasetL && datasetR) {
+    validity = "both";
+  } else if (datasetL) {
+    validity = "left-only";
+  } else if (datasetR) {
+    validity = "right-only";
+  } else {
+    validity = "neither";
+  }
+  return {
+    datasetKey,
+    validity,
+    points,
+    minValue,
+    maxValue,
+    avgDiff,
+    minDiff,
+    maxDiff,
+    maxDiffPoint
+  };
+}
+function matchPrecision(x, baseline) {
+  const s = baseline.toString();
+  if (s.includes("e")) {
+    return x;
+  }
+  const parts = s.split(".");
+  if (parts.length < 2) {
+    return x;
+  }
+  const sigDigits = parts[1].replace(/0+$/, "").length;
+  if (sigDigits > 21) {
+    return x;
+  }
+  return parseFloat(x.toFixed(sigDigits));
+}
+function permutationsOf(inputArr) {
+  const result = [];
+  const permute = (arr, m = []) => {
+    if (arr.length === 0) {
+      result.push(m);
+    } else {
+      for (let i = 0; i < arr.length; i++) {
+        const curr = arr.slice();
+        const next = curr.splice(i, 1);
+        permute(curr.slice(), m.concat(next));
+      }
+    }
+  };
+  permute(inputArr);
+  return result;
+}
+
 // src/data/data-planner.ts
 var DataPlanner = class {
   /**
@@ -4557,10 +5133,10 @@ function scenarioPairUid(scenarioSpecL, scenarioSpecR) {
 }
 
 // src/check/check-runner.ts
-function runChecks(checkConfig, checkSpec, dataPlanner, refDataPlanner, simplifyScenarios) {
-  const modelSpec = checkConfig.bundle.model.modelSpec;
+function runChecks(checkConfig, checkSpec, dataPlanner, refDataPlanner, skipChecks) {
+  const modelSpec = checkConfig.bundle.modelSpec;
   const checkPlanner = new CheckPlanner(modelSpec);
-  checkPlanner.addAllChecks(checkSpec, simplifyScenarios);
+  checkPlanner.addAllChecks(checkSpec, skipChecks);
   const checkPlan = checkPlanner.buildPlan();
   const refDatasets = /* @__PURE__ */ new Map();
   for (const [dataRefKey, dataRef] of checkPlan.dataRefs.entries()) {
@@ -4573,11 +5149,15 @@ function runChecks(checkConfig, checkSpec, dataPlanner, refDataPlanner, simplify
   }
   const checkResults = /* @__PURE__ */ new Map();
   for (const [checkKey, checkTask] of checkPlan.tasks.entries()) {
-    dataPlanner.addRequest(void 0, checkTask.scenario.spec, checkTask.dataset.datasetKey, (datasets) => {
-      const dataset = datasets.datasetR;
-      const checkResult = runCheck(checkTask, dataset, refDatasets);
-      checkResults.set(checkKey, checkResult);
-    });
+    if (checkTask.skip === true) {
+      checkResults.set(checkKey, { status: "skipped" });
+    } else {
+      dataPlanner.addRequest(void 0, checkTask.scenario.spec, checkTask.dataset.datasetKey, (datasets) => {
+        const dataset = datasets.datasetR;
+        const checkResult = runCheck(checkTask, dataset, refDatasets);
+        checkResults.set(checkKey, checkResult);
+      });
+    }
   }
   return () => {
     return buildCheckReport(checkPlan, checkResults);
@@ -4642,21 +5222,73 @@ function runCheck(checkTask, dataset, refDatasets) {
 }
 
 // src/comparison/run/comparison-runner.ts
-function runComparisons(comparisonConfig, dataPlanner) {
+function runComparisons(comparisonConfig, dataPlanner, skipScenarios) {
+  function skipScenarioKey(title, subtitle) {
+    let key = title.toLowerCase();
+    if (subtitle) {
+      key += ` :: ${subtitle.toLowerCase()}`;
+    }
+    return key;
+  }
+  const skipScenariosSet = new Set(skipScenarios.map((scenario) => skipScenarioKey(scenario.title, scenario.subtitle)));
+  const allScenarios = [...comparisonConfig.scenarios.getAllScenarios()];
+  let baselineScenario;
+  const baselineScenarioIndex = allScenarios.findIndex((scenario) => {
+    const settings = scenario.settings;
+    return settings.kind === "all-inputs-settings" && settings.position === "at-default";
+  });
+  if (baselineScenarioIndex !== -1) {
+    baselineScenario = allScenarios.splice(baselineScenarioIndex, 1)[0];
+  }
   const testReports = [];
-  for (const scenario of comparisonConfig.scenarios.getAllScenarios()) {
+  const baselineDiffReports = /* @__PURE__ */ new Map();
+  function runComparisonsForScenario(scenario, isBaseline) {
     const datasetKeys = comparisonConfig.datasets.getDatasetKeysForScenario(scenario);
-    for (const datasetKey of datasetKeys) {
-      dataPlanner.addRequest(scenario.specL, scenario.specR, datasetKey, (datasets) => {
-        const diffReport = diffDatasets(datasets.datasetL, datasets.datasetR);
+    const shouldSkip = skipScenariosSet.has(skipScenarioKey(scenario.title, scenario.subtitle));
+    if (shouldSkip) {
+      for (const datasetKey of datasetKeys) {
         testReports.push({
           scenarioKey: scenario.key,
           datasetKey,
-          diffReport
+          diffReport: void 0
         });
+      }
+      return;
+    }
+    for (const datasetKey of datasetKeys) {
+      dataPlanner.addRequest(scenario.specL, scenario.specR, datasetKey, (datasets) => {
+        const diffReport = diffDatasets(datasets.datasetL, datasets.datasetR);
+        if (isBaseline) {
+          baselineDiffReports.set(datasetKey, diffReport);
+          testReports.push({
+            scenarioKey: scenario.key,
+            datasetKey,
+            diffReport
+          });
+        } else {
+          const baselineDiffReport = baselineDiffReports.get(datasetKey);
+          testReports.push({
+            scenarioKey: scenario.key,
+            datasetKey,
+            diffReport,
+            baselineDiffReport
+          });
+        }
       });
     }
   }
+  runComparisonsForScenario(
+    baselineScenario,
+    /*isBaseline=*/
+    true
+  );
+  for (const scenario of allScenarios) {
+    runComparisonsForScenario(
+      scenario,
+      /*isBaseline=*/
+      false
+    );
+  }
   return () => {
     return testReports;
   };
@@ -4664,74 +5296,52 @@ function runComparisons(comparisonConfig, dataPlanner) {
 
 // src/suite/suite-runner.ts
 var SuiteRunner = class {
-  constructor(config, callbacks) {
+  constructor(config, taskQueue, callbacks) {
     this.config = config;
+    this.taskQueue = taskQueue;
     this.callbacks = callbacks;
     this.perfStatsL = new PerfStats();
     this.perfStatsR = new PerfStats();
+    this.pendingTaskKeys = /* @__PURE__ */ new Set();
     this.stopped = false;
-    this.taskQueue = new TaskQueue({
-      process: (request) => {
-        return this.processRequest(request);
-      }
-    });
   }
   cancel() {
     if (!this.stopped) {
+      for (const taskKey of this.pendingTaskKeys) {
+        this.taskQueue.cancelTask(taskKey);
+      }
       this.stopped = true;
-      this.taskQueue.shutdown();
     }
   }
   start(options) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     (_b = (_a = this.callbacks).onProgress) == null ? void 0 : _b.call(_a, 0);
-    const modelSpec = this.config.check.bundle.model.modelSpec;
-    const dataPlanner = new DataPlanner(modelSpec.outputVars.size);
-    const refDataPlanner = new DataPlanner(modelSpec.outputVars.size);
+    const modelSpecR = this.config.check.bundle.modelSpec;
+    const dataPlanner = new DataPlanner(modelSpecR.outputVars.size);
+    const refDataPlanner = new DataPlanner(modelSpecR.outputVars.size);
     const checkSpecResult = parseTestYaml(this.config.check.tests);
     if (checkSpecResult.isErr()) {
       (_d = (_c = this.callbacks).onError) == null ? void 0 : _d.call(_c, checkSpecResult.error);
       return;
     }
     const checkSpec = checkSpecResult.value;
-    const simplifyScenarios = (options == null ? void 0 : options.simplifyScenarios) === true;
-    const buildCheckReport2 = runChecks(this.config.check, checkSpec, dataPlanner, refDataPlanner, simplifyScenarios);
+    const skipChecks = (options == null ? void 0 : options.skipChecks) || [];
+    const buildCheckReport2 = runChecks(this.config.check, checkSpec, dataPlanner, refDataPlanner, skipChecks);
     let buildComparisonTestReports;
     if (this.config.comparison) {
-      buildComparisonTestReports = runComparisons(this.config.comparison, dataPlanner);
+      const skipScenarios = (options == null ? void 0 : options.skipComparisonScenarios) || [];
+      buildComparisonTestReports = runComparisons(this.config.comparison, dataPlanner, skipScenarios);
     }
-    this.taskQueue.onIdle = (error) => {
-      var _a2, _b2, _c2, _d2;
-      if (this.stopped) {
-        return;
-      }
-      if (error) {
-        (_b2 = (_a2 = this.callbacks).onError) == null ? void 0 : _b2.call(_a2, error);
-      } else {
-        const checkReport = buildCheckReport2();
-        let comparisonReport;
-        if (this.config.comparison) {
-          comparisonReport = {
-            testReports: buildComparisonTestReports(),
-            perfReportL: this.perfStatsL.toReport(),
-            perfReportR: this.perfStatsR.toReport()
-          };
-        }
-        (_d2 = (_c2 = this.callbacks).onComplete) == null ? void 0 : _d2.call(_c2, {
-          checkReport,
-          comparisonReport
-        });
-      }
-    };
     const refDataPlan = refDataPlanner.buildPlan();
     const dataPlan = dataPlanner.buildPlan();
     const dataRequests = [...refDataPlan.requests, ...dataPlan.requests];
     const taskCount = dataRequests.length;
     if (taskCount === 0) {
+      const checkReport = buildCheckReport2();
       let comparisonReport;
       if (this.config.comparison) {
         comparisonReport = {
-          testReports: [],
+          testReports: buildComparisonTestReports(),
           perfReportL: this.perfStatsL.toReport(),
           perfReportR: this.perfStatsR.toReport()
         };
@@ -4739,26 +5349,54 @@ var SuiteRunner = class {
       this.cancel();
       (_f = (_e = this.callbacks).onProgress) == null ? void 0 : _f.call(_e, 1);
       (_h = (_g = this.callbacks).onComplete) == null ? void 0 : _h.call(_g, {
-        checkReport: {
-          groups: []
-        },
+        checkReport,
         comparisonReport
       });
       return;
     }
+    const buildReport = (error) => {
+      var _a2, _b2, _c2, _d2;
+      if (error) {
+        (_b2 = (_a2 = this.callbacks).onError) == null ? void 0 : _b2.call(_a2, error);
+      } else {
+        const checkReport = buildCheckReport2();
+        let comparisonReport;
+        if (this.config.comparison) {
+          comparisonReport = {
+            testReports: buildComparisonTestReports(),
+            perfReportL: this.perfStatsL.toReport(),
+            perfReportR: this.perfStatsR.toReport()
+          };
+        }
+        (_d2 = (_c2 = this.callbacks).onComplete) == null ? void 0 : _d2.call(_c2, {
+          checkReport,
+          comparisonReport
+        });
+      }
+    };
     let tasksCompleted = 0;
     let dataTaskId = 1;
     for (const dataRequest of dataRequests) {
-      this.taskQueue.addTask(`data${dataTaskId++}`, dataRequest, () => {
-        var _a2, _b2;
-        tasksCompleted++;
-        (_b2 = (_a2 = this.callbacks).onProgress) == null ? void 0 : _b2.call(_a2, tasksCompleted / taskCount);
-      });
+      const task = {
+        key: `suite-runner-${dataTaskId++}`,
+        kind: "suite-runner",
+        process: (bundleModels) => __async(this, null, function* () {
+          var _a2, _b2;
+          this.pendingTaskKeys.delete(task.key);
+          yield this.processRequest(dataRequest, bundleModels);
+          tasksCompleted++;
+          (_b2 = (_a2 = this.callbacks).onProgress) == null ? void 0 : _b2.call(_a2, tasksCompleted / taskCount);
+          if (tasksCompleted === taskCount) {
+            buildReport();
+          }
+        })
+      };
+      this.taskQueue.addTask(task);
+      this.pendingTaskKeys.add(task.key);
     }
   }
-  processRequest(request) {
+  processRequest(request, bundleModels) {
     return __async(this, null, function* () {
-      var _a, _b;
       const datasetKeySet = /* @__PURE__ */ new Set();
       for (const dataTask of request.dataTasks) {
         datasetKeySet.add(dataTask.datasetKey);
@@ -4773,8 +5411,8 @@ var SuiteRunner = class {
           }
         });
       }
-      const bundleModelL = (_a = this.config.comparison) == null ? void 0 : _a.bundleL.model;
-      const bundleModelR = ((_b = this.config.comparison) == null ? void 0 : _b.bundleR.model) || this.config.check.bundle.model;
+      const bundleModelL = bundleModels.L;
+      const bundleModelR = bundleModels.R;
       const [datasetsResultL, datasetsResultR] = yield Promise.all([
         getDatasets(bundleModelL, request.scenarioSpecL),
         getDatasets(bundleModelR, request.scenarioSpecR)
@@ -4798,22 +5436,29 @@ var SuiteRunner = class {
     });
   }
 };
-function runSuite(config, callbacks, options) {
-  const suiteRunner = new SuiteRunner(config, callbacks);
+function runSuiteWithTaskQueue(config, taskQueue, callbacks, options) {
+  const suiteRunner = new SuiteRunner(config, taskQueue, callbacks);
   suiteRunner.start(options);
   return () => {
     suiteRunner.cancel();
   };
 }
+function runSuite(config, callbacks, options) {
+  const taskQueue = TaskQueue.getInstance();
+  return runSuiteWithTaskQueue(config, taskQueue, callbacks, options);
+}
 
 // src/suite/suite-reporting.ts
-function suiteSummaryFromReport(suiteReport) {
+function suiteSummaryFromReport(suiteReport, elapsedMillis) {
   const checkSummary = checkSummaryFromReport(suiteReport.checkReport);
   let comparisonSummary;
   if (suiteReport.comparisonReport) {
     comparisonSummary = comparisonSummaryFromReport(suiteReport.comparisonReport);
   }
+  const date = (/* @__PURE__ */ new Date()).toISOString();
   return {
+    date,
+    elapsed: elapsedMillis,
     checkSummary,
     comparisonSummary
   };
@@ -4821,20 +5466,27 @@ function suiteSummaryFromReport(suiteReport) {
 export {
   CheckDataCoordinator,
   ComparisonDataCoordinator,
-  PerfRunner,
   PerfStats,
   categorizeComparisonTestSummaries,
   checkReportFromSummary,
   checkSummaryFromReport,
   comparisonSummaryFromReport,
+  createCheckDataCoordinator,
+  createCheckDataCoordinatorForTests,
+  createComparisonDataCoordinator,
   createConfig,
   datasetMessage,
+  decodeImplVars,
   diffDatasets,
   diffGraphs,
+  encodeImplVars,
   getScoresForTestSummaries,
   predicateMessage,
+  runPerf,
   runSuite,
+  runTrace,
   scenarioMessage,
-  suiteSummaryFromReport
+  suiteSummaryFromReport,
+  testSummaryFromReport
 };
 //# sourceMappingURL=index.js.map