@sdeverywhere/check-core 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,93 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-
-// src/_shared/scenario.ts
-import { assertNever } from "assert-never";
-function positionSetting(inputVarId, position) {
-  return {
-    kind: "position",
-    inputVarId,
-    position
-  };
-}
-function valueSetting(inputVarId, value) {
-  return {
-    kind: "value",
-    inputVarId,
-    value
-  };
-}
-function settingsScenario(key, groupKey, settings) {
-  return {
-    kind: "settings",
-    key,
-    groupKey,
-    settings
-  };
-}
-function inputAtPositionScenario(inputVarId, groupKey, position) {
-  const key = keyForInputAtPosition(`input${inputVarId}`, position);
-  return settingsScenario(key, groupKey, [positionSetting(inputVarId, position)]);
-}
-function inputAtValueScenario(inputVarId, groupKey, value) {
-  const key = keyForInputAtValue(`input${inputVarId}`, value);
-  return settingsScenario(key, groupKey, [valueSetting(inputVarId, value)]);
-}
-function allInputsAtPositionScenario(position) {
-  return {
-    kind: "all-inputs",
-    key: keyForInputAtPosition("all_inputs", position),
-    groupKey: "all_inputs",
-    position
-  };
-}
-function matrixScenarios(inputVarIds) {
-  const scenarios = [];
-  scenarios.push(allInputsAtPositionScenario("at-default"));
-  scenarios.push(allInputsAtPositionScenario("at-minimum"));
-  scenarios.push(allInputsAtPositionScenario("at-maximum"));
-  for (const inputVarId of inputVarIds) {
-    scenarios.push(inputAtPositionScenario(inputVarId, inputVarId, "at-minimum"));
-    scenarios.push(inputAtPositionScenario(inputVarId, inputVarId, "at-maximum"));
-  }
-  return scenarios;
-}
-function keyForInputPosition(position) {
-  switch (position) {
-    case "at-default":
-      return "default";
-    case "at-minimum":
-      return "min";
-    case "at-maximum":
-      return "max";
-    default:
-      assertNever(position);
-  }
-}
-function keyForInputAtPosition(inputKey, position) {
-  return `${inputKey}_at_${keyForInputPosition(position)}`;
-}
-function keyForInputAtValue(inputKey, value) {
-  return `${inputKey}_at_${value}`;
-}
-
 // src/_shared/task-queue.ts
 var TaskQueue = class {
   constructor(processor) {
@@ -174,7 +84,7 @@ var CheckDataCoordinator = class {
     this.bundleModel = bundleModel;
     this.taskQueue = new TaskQueue({
       process: async (request) => {
-        const result = await this.bundleModel.getDatasetsForScenario(request.scenario, [request.datasetKey]);
+        const result = await this.bundleModel.getDatasetsForScenario(request.scenarioSpec, [request.datasetKey]);
         const dataset = result.datasetMap.get(request.datasetKey);
         return {
           dataset
@@ -182,9 +92,9 @@ var CheckDataCoordinator = class {
       }
     });
   }
-  requestDataset(requestKey, scenario, datasetKey, onResponse) {
+  requestDataset(requestKey, scenarioSpec, datasetKey, onResponse) {
     const request = {
-      scenario,
+      scenarioSpec,
       datasetKey
     };
     this.taskQueue.addTask(requestKey, request, (response) => {
@@ -197,10 +107,10 @@ var CheckDataCoordinator = class {
 };
 
 // src/check/check-report.ts
-import assertNever3 from "assert-never";
+import assertNever2 from "assert-never";
 
 // src/check/check-predicate.ts
-import assertNever2 from "assert-never";
+import assertNever from "assert-never";
 function symbolForPredicateOp(op) {
   switch (op) {
     case "gt":
@@ -216,7 +126,7 @@ function symbolForPredicateOp(op) {
     case "approx":
       return "\u2248";
     default:
-      assertNever2(op);
+      assertNever(op);
   }
 }
 
@@ -230,7 +140,7 @@ function buildCheckReport(checkPlan, checkResults) {
       const scenarioReports = [];
       for (const scenarioPlan of testPlan.scenarios) {
         let scenarioStatus = "passed";
-        if (scenarioPlan.checkScenario.scenario === void 0) {
+        if (scenarioPlan.checkScenario.spec === void 0) {
           testStatus = "error";
           scenarioStatus = "error";
         }
@@ -327,14 +237,14 @@ function predicateReport(predicatePlan, checkKey, result) {
         };
         opRef = opDataRef;
         opValue = `${sym} '${dataRef.dataset.name}'`;
-        const refScenario = (_b = dataRef.scenario) == null ? void 0 : _b.scenario;
-        if (!refScenario) {
+        const refScenarioSpec = (_b = dataRef.scenario) == null ? void 0 : _b.spec;
+        if (!refScenarioSpec) {
           return;
         }
         if (predOp.scenario === "inherit") {
           opValue += ` (w/ same scenario)`;
         } else {
-          if (refScenario.kind === "all-inputs" && refScenario.position === "at-default") {
+          if (refScenarioSpec.kind === "all-inputs" && refScenarioSpec.position === "at-default") {
             opValue += ` (w/ default scenario)`;
           } else {
             opValue += ` (w/ configured scenario)`;
@@ -369,7 +279,7 @@ function predicateReport(predicatePlan, checkKey, result) {
 }
 function scenarioMessage(scenario, bold) {
   const checkScenario = scenario.checkScenario;
-  if (checkScenario.scenario === void 0) {
+  if (checkScenario.spec === void 0) {
     if (checkScenario.error) {
       switch (checkScenario.error.kind) {
         case "unknown-input-group":
@@ -377,7 +287,7 @@ function scenarioMessage(scenario, bold) {
         case "empty-input-group":
           return `error: input group ${bold(checkScenario.error.name)} is empty`;
         default:
-          assertNever3(checkScenario.error.kind);
+          assertNever2(checkScenario.error.kind);
       }
     } else {
       const badInputNames = checkScenario.inputDescs.filter((d) => d.inputVar === void 0).map((d) => bold(d.name));
@@ -394,7 +304,7 @@ function scenarioMessage(scenario, bold) {
       case "at-maximum":
         return "maximum";
       default:
-        assertNever3(position);
+        assertNever2(position);
     }
   }
   function inputMessage(inputDesc) {
@@ -409,13 +319,13 @@ function scenarioMessage(scenario, bold) {
     }
     return msg;
   }
-  if (checkScenario.scenario.kind === "all-inputs") {
-    const position = checkScenario.scenario.position;
+  if (checkScenario.spec.kind === "all-inputs") {
+    const position = checkScenario.spec.position;
     return `when ${bold("all inputs")} are at ${bold(positionName(position))}...`;
   } else if (checkScenario.inputGroupName) {
     let position = "at-default";
-    if (checkScenario.scenario.settings[0].kind === "position") {
-      position = checkScenario.scenario.settings[0].position;
+    if (checkScenario.spec.settings[0].kind === "position") {
+      position = checkScenario.spec.settings[0].position;
     }
     const groupName = checkScenario.inputGroupName;
     return `when all inputs in ${bold(groupName)} are at ${bold(positionName(position))}...`;
@@ -448,7 +358,7 @@ function predicateMessage(predicate, bold) {
         case "empty-input-group":
           return `error: referenced input group ${bold(result.errorInfo.name)} is empty`;
         default:
-          assertNever3(result.errorInfo.kind);
+          assertNever2(result.errorInfo.kind);
       }
     } else {
       return `unknown error`;
@@ -1019,7 +929,7 @@ function parseTestYaml(yamlStrings) {
         groups.push(group);
       }
     } else {
-      let msg = "Failed to parse YAML tests";
+      let msg = "Failed to parse YAML check definitions";
       for (const error of validate.errors || []) {
         if (error.message) {
           msg += `
@@ -1193,9 +1103,12 @@ 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), []);
-  }, [[]]);
+  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
@@ -1286,14 +1199,16 @@ function matchByName(modelSpec, datasetName, datasetSource) {
   };
 }
 function matchByGroup(modelSpec, groupName) {
-  const groupToMatch = groupName.toLowerCase();
   let matchedGroupName;
   let matchedGroupDatasetKeys;
-  for (const [group, datasetKeys] of modelSpec.datasetGroups) {
-    if (group.toLowerCase() === groupToMatch) {
-      matchedGroupName = group;
-      matchedGroupDatasetKeys = datasetKeys;
-      break;
+  if (modelSpec.datasetGroups) {
+    const groupToMatch = groupName.toLowerCase();
+    for (const [group, datasetKeys] of modelSpec.datasetGroups) {
+      if (group.toLowerCase() === groupToMatch) {
+        matchedGroupName = group;
+        matchedGroupDatasetKeys = datasetKeys;
+        break;
+      }
     }
   }
   if (matchedGroupName === void 0) {
@@ -1370,6 +1285,65 @@ function matchByType(modelSpec, varTypeToMatch) {
 
 // src/check/check-scenario.ts
 import assertNever4 from "assert-never";
+
+// src/_shared/scenario-specs.ts
+import { assertNever as assertNever3 } from "assert-never";
+function positionSetting(inputVarId, position) {
+  return {
+    kind: "position",
+    inputVarId,
+    position
+  };
+}
+function valueSetting(inputVarId, value) {
+  return {
+    kind: "value",
+    inputVarId,
+    value
+  };
+}
+function inputSettingsSpec(settings) {
+  const uidParts = settings.map((setting) => {
+    switch (setting.kind) {
+      case "position":
+        return `${setting.inputVarId}_at_${keyForInputPosition(setting.position)}`;
+      case "value":
+        return `${setting.inputVarId}_at_${setting.value}`;
+      default:
+        assertNever3(setting);
+    }
+  });
+  const uid = `inputs_${uidParts.sort().join("_")}`;
+  return {
+    kind: "input-settings",
+    uid,
+    settings
+  };
+}
+function inputAtPositionSpec(inputVarId, position) {
+  return inputSettingsSpec([positionSetting(inputVarId, position)]);
+}
+function allInputsAtPositionSpec(position) {
+  return {
+    kind: "all-inputs",
+    uid: `all_inputs_at_${keyForInputPosition(position)}`,
+    position
+  };
+}
+function keyForInputPosition(position) {
+  switch (position) {
+    case "at-default":
+      return "default";
+    case "at-minimum":
+      return "min";
+    case "at-maximum":
+      return "max";
+    default:
+      assertNever3(position);
+  }
+}
+
+// src/check/check-scenario.ts
 function expandScenarios(modelSpec, scenarioSpecs, simplify) {
   if (scenarioSpecs.length === 0) {
     const scenarioSpec = {
@@ -1446,10 +1420,12 @@ function inputDescForName(modelSpec, inputName, at) {
   }
 }
 function groupForName(modelSpec, groupName) {
-  const groupToMatch = groupName.toLowerCase();
-  for (const [group, inputVars] of modelSpec.inputGroups) {
-    if (group.toLowerCase() === groupToMatch) {
-      return [group, inputVars];
+  if (modelSpec.inputGroups) {
+    const groupToMatch = groupName.toLowerCase();
+    for (const [group, inputVars] of modelSpec.inputGroups) {
+      if (group.toLowerCase() === groupToMatch) {
+        return [group, inputVars];
+      }
     }
   }
   return void 0;
@@ -1464,56 +1440,35 @@ function errorScenarioForInputGroup(kind, groupName) {
   };
 }
 function checkScenarioWithAllInputsAtPosition(position) {
-  const scenario = allInputsAtPositionScenario(position);
   return {
-    scenario,
+    spec: allInputsAtPositionSpec(position),
     inputDescs: []
   };
 }
 function checkScenarioWithInputAtPosition(inputVar, position) {
   const varId = inputVar.varId;
-  const scenario = inputAtPositionScenario(varId, varId, position);
   return {
-    scenario,
+    spec: inputAtPositionSpec(varId, position),
     inputDescs: [inputDescAtPosition(inputVar, position)]
   };
 }
 function checkScenarioForInputDescs(groupName, inputDescs) {
-  let scenario;
+  let spec;
   if (inputDescs.every((desc) => desc.inputVar !== void 0)) {
-    const settings = [];
-    const keyParts = [];
-    for (const inputDesc of inputDescs) {
+    const settings = inputDescs.map((inputDesc) => {
       const varId = inputDesc.inputVar.varId;
       if (inputDesc.position) {
-        settings.push(positionSetting(varId, inputDesc.position));
-        keyParts.push(keyForInputAtPosition(varId, inputDesc.position));
-      } else {
-        settings.push(valueSetting(varId, inputDesc.value));
-        keyParts.push(keyForInputAtValue(varId, inputDesc.value));
-      }
-    }
-    if (settings.length === 1) {
-      const scenarioKey = `input${keyParts[0]}`;
-      const groupKey = settings[0].inputVarId;
-      scenario = settingsScenario(scenarioKey, groupKey, settings);
-    } else if (settings.length > 1) {
-      let scenarioKey;
-      let groupKey;
-      if (groupName) {
-        scenarioKey = `group_${groupName.toLowerCase().replace(/ /g, "_")}`;
-        groupKey = scenarioKey;
+        return positionSetting(varId, inputDesc.position);
       } else {
-        scenarioKey = "multi" + keyParts.join("_");
-        groupKey = scenarioKey;
+        return valueSetting(varId, inputDesc.value);
       }
-      scenario = settingsScenario(scenarioKey, groupKey, settings);
-    }
+    });
+    spec = inputSettingsSpec(settings);
   } else {
-    scenario = void 0;
+    spec = void 0;
   }
   return {
-    scenario,
+    spec,
     inputGroupName: groupName,
     inputDescs
   };
@@ -1627,7 +1582,7 @@ var CheckPlanner = class {
         }
         const planScenarios = [];
         for (const checkScenario of checkScenarios) {
-          if (checkScenario.scenario === void 0) {
+          if (checkScenario.spec === void 0) {
             planScenarios.push({
               checkScenario,
               datasets: []
@@ -1736,8 +1691,8 @@ var CheckPlanner = class {
         }
       }
       let dataRefKey;
-      if (refScenario.scenario && refDataset.datasetKey) {
-        dataRefKey = `${refScenario.scenario.key}::${refDataset.datasetKey}`;
+      if (refScenario.spec && refDataset.datasetKey) {
+        dataRefKey = `${refScenario.spec.uid}::${refDataset.datasetKey}`;
       }
       const dataRef = {
         key: dataRefKey,
@@ -1792,14 +1747,14 @@ function checkSummaryFromReport(checkReport) {
     predicateSummaries
   };
 }
-function checkReportFromSummary(checkConfig, checkSummary, simplifyScenarios) {
+function checkReportFromSummary(checkConfig, checkSummary) {
   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, simplifyScenarios);
+  checkPlanner.addAllChecks(checkSpec, false);
   const checkPlan = checkPlanner.buildPlan();
   const checkResults = /* @__PURE__ */ new Map();
   for (const predicateSummary of checkSummary.predicateSummaries) {
@@ -1808,44 +1763,66 @@ function checkReportFromSummary(checkConfig, checkSummary, simplifyScenarios) {
   return buildCheckReport(checkPlan, checkResults);
 }
 
-// src/compare/compare-data-coordinator.ts
+// src/comparison/run/comparison-data-coordinator.ts
 import { assertNever as assertNever7 } from "assert-never";
-var CompareDataCoordinator = class {
+var ComparisonDataCoordinator = class {
   constructor(bundleModelL, bundleModelR) {
     this.bundleModelL = bundleModelL;
     this.bundleModelR = bundleModelR;
     this.taskQueue = new TaskQueue({
       process: async (request) => {
         switch (request.kind) {
-          case "dataset": {
-            const [resultL, resultR] = await Promise.all([
-              this.bundleModelL.getDatasetsForScenario(request.scenario, request.datasetKeys),
-              this.bundleModelR.getDatasetsForScenario(request.scenario, request.datasetKeys)
-            ]);
-            return {
-              kind: "dataset",
-              datasetMapL: resultL.datasetMap,
-              datasetMapR: resultR.datasetMap
-            };
-          }
-          case "graph-data": {
-            const bundleModel = request.bundle === "right" ? this.bundleModelR : this.bundleModelL;
-            const graphData = await bundleModel.getGraphDataForScenario(request.scenario, request.graphId);
-            return {
-              kind: "graph-data",
-              graphData
-            };
-          }
+          case "dataset":
+            return this.processDatasetRequest(request);
+          case "graph-data":
+            return this.processGraphDataRequest(request);
           default:
             assertNever7(request);
         }
       }
     });
   }
-  requestDatasetMaps(requestKey, scenario, datasetKeys, onResponse) {
+  async processDatasetRequest(request) {
+    async function fetchDatasets(bundleModel, scenarioSpec) {
+      if (scenarioSpec) {
+        return bundleModel.getDatasetsForScenario(scenarioSpec, request.datasetKeys);
+      } else {
+        return void 0;
+      }
+    }
+    const [resultL, resultR] = await 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
+    };
+  }
+  async processGraphDataRequest(request) {
+    async function fetchGraphData(bundleModel, scenarioSpec) {
+      if (scenarioSpec) {
+        return bundleModel.getGraphDataForScenario(scenarioSpec, request.graphId);
+      } else {
+        return void 0;
+      }
+    }
+    const [graphDataL, graphDataR] = await 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",
-      scenario,
+      scenarioSpecL,
+      scenarioSpecR,
       datasetKeys
     };
     this.taskQueue.addTask(requestKey, request, (response) => {
@@ -1854,16 +1831,16 @@ var CompareDataCoordinator = class {
       }
     });
   }
-  requestGraphData(requestKey, bundle, scenario, graphId, onResponse) {
+  requestGraphData(requestKey, scenarioSpecL, scenarioSpecR, graphId, onResponse) {
     const request = {
       kind: "graph-data",
-      bundle,
-      scenario,
+      scenarioSpecL,
+      scenarioSpecR,
       graphId
     };
     this.taskQueue.addTask(requestKey, request, (response) => {
       if (response.kind === "graph-data") {
-        onResponse(response.graphData);
+        onResponse(response.graphDataL, response.graphDataR);
       }
     });
   }
@@ -1872,7 +1849,7 @@ var CompareDataCoordinator = class {
   }
 };
 
-// src/compare/compare-datasets.ts
+// src/comparison/diff-datasets/diff-datasets.ts
 function diffDatasets(datasetL, datasetR) {
   let minValueL = Number.MAX_VALUE;
   let maxValueL = Number.MIN_VALUE;
@@ -1967,19 +1944,9 @@ function diffDatasets(datasetL, datasetR) {
     maxDiffPoint
   };
 }
-function compareDatasets(scenarioKey, datasetKey, datasetMapL, datasetMapR) {
-  const datasetL = datasetMapL.get(datasetKey);
-  const datasetR = datasetMapR.get(datasetKey);
-  const diffReport = diffDatasets(datasetL, datasetR);
-  return {
-    scenarioKey,
-    datasetKey,
-    diffReport
-  };
-}
 
-// src/compare/compare-graphs.ts
-function diffGraphs(graphL, graphR, scenarioKey, datasetSummaries) {
+// src/comparison/diff-graphs/diff-graphs.ts
+function diffGraphs(graphL, graphR, scenarioKey, testSummaries) {
   let inclusion;
   if (graphL && graphR) {
     inclusion = "both";
@@ -2021,8 +1988,8 @@ function diffGraphs(graphL, graphR, scenarioKey, datasetSummaries) {
       datasetKeys.add(dataset.datasetKey);
     }
     for (const datasetKey of datasetKeys) {
-      const summary = datasetSummaries.find((summary2) => summary2.d === datasetKey && summary2.s === scenarioKey);
-      const maxDiff = summary !== void 0 ? summary.md : void 0;
+      const testSummary = testSummaries.find((summary) => summary.d === datasetKey && summary.s === scenarioKey);
+      const maxDiff = testSummary == null ? void 0 : testSummary.md;
       datasetReports.push({
         datasetKey,
         maxDiff
@@ -2036,12 +2003,12 @@ function diffGraphs(graphL, graphR, scenarioKey, datasetSummaries) {
   };
 }
 
-// src/compare/compare-summary.ts
-function compareSummaryFromReport(compareReport) {
-  const datasetSummaries = [];
-  for (const r of compareReport.datasetReports) {
+// src/comparison/report/comparison-reporting.ts
+function comparisonSummaryFromReport(comparisonReport) {
+  const terseSummaries = [];
+  for (const r of comparisonReport.testReports) {
     if (r.diffReport.validity === "both" && r.diffReport.maxDiff > 0) {
-      datasetSummaries.push({
+      terseSummaries.push({
         s: r.scenarioKey,
         d: r.datasetKey,
         md: r.diffReport.maxDiff
@@ -2049,154 +2016,1319 @@ function compareSummaryFromReport(compareReport) {
     }
   }
   return {
-    datasetSummaries,
-    perfReportL: compareReport.perfReportL,
-    perfReportR: compareReport.perfReportR
+    testSummaries: terseSummaries,
+    perfReportL: comparisonReport.perfReportL,
+    perfReportR: comparisonReport.perfReportR
   };
 }
+function restoreFromTerseSummaries(comparisonConfig, terseSummaries) {
+  const existingSummaries = /* @__PURE__ */ new Map();
+  for (const summary of terseSummaries) {
+    const key = `${summary.s}::${summary.d}`;
+    existingSummaries.set(key, summary);
+  }
+  const allTestSummaries = [];
+  for (const scenario of comparisonConfig.scenarios.getAllScenarios()) {
+    const datasetKeys = comparisonConfig.datasets.getDatasetKeysForScenario(scenario);
+    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
+      });
+    }
+  }
+  return allTestSummaries;
+}
 
-// src/config/synchronized-model.ts
-function synchronizedBundleModel(sourceModel) {
-  var _a;
-  const promiseQueue = new PromiseQueue();
+// src/comparison/report/comparison-grouping.ts
+import { assertNever as assertNever8 } from "assert-never";
+
+// src/comparison/report/buckets.ts
+function getBucketIndex(diffPct, thresholds) {
+  if (diffPct === 0) {
+    return 0;
+  }
+  for (let i = 0; i < thresholds.length; i++) {
+    if (diffPct < thresholds[i]) {
+      return i + 1;
+    }
+  }
+  return thresholds.length + 1;
+}
+
+// src/comparison/report/comparison-grouping.ts
+function categorizeComparisonTestSummaries(comparisonConfig, terseSummaries) {
+  const allTestSummaries = restoreFromTerseSummaries(comparisonConfig, terseSummaries);
+  const groupsByScenario = groupComparisonTestSummaries(allTestSummaries, "by-scenario");
+  const byScenario = categorizeComparisonGroups(comparisonConfig, [...groupsByScenario.values()]);
+  const groupsByDataset = groupComparisonTestSummaries(allTestSummaries, "by-dataset");
+  const byDataset = categorizeComparisonGroups(comparisonConfig, [...groupsByDataset.values()]);
   return {
-    modelSpec: sourceModel.modelSpec,
-    getDatasetsForScenario: (scenario, datasetKeys) => {
-      return promiseQueue.add(() => sourceModel.getDatasetsForScenario(scenario, datasetKeys));
-    },
-    getGraphsForDataset: (_a = sourceModel.getGraphsForDataset) == null ? void 0 : _a.bind(sourceModel),
-    getGraphDataForScenario: (scenario, graphId) => {
-      return promiseQueue.add(() => sourceModel.getGraphDataForScenario(scenario, graphId));
-    },
-    getGraphLinksForScenario: sourceModel.getGraphLinksForScenario.bind(sourceModel)
+    byScenario,
+    byDataset
   };
 }
-var PromiseQueue = class {
-  constructor() {
-    this.tasks = [];
-    this.runningCount = 0;
+function groupComparisonTestSummaries(testSummaries, groupKind) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const testSummary of testSummaries) {
+    let groupKey;
+    switch (groupKind) {
+      case "by-dataset":
+        groupKey = testSummary.d;
+        break;
+      case "by-scenario":
+        groupKey = testSummary.s;
+        break;
+      default:
+        assertNever8(groupKind);
+    }
+    const group = groups.get(groupKey);
+    if (group) {
+      group.testSummaries.push(testSummary);
+    } else {
+      groups.set(groupKey, {
+        kind: groupKind,
+        key: groupKey,
+        testSummaries: [testSummary]
+      });
+    }
   }
-  add(f) {
-    return new Promise((resolve, reject) => {
-      const run = async () => {
-        this.runningCount++;
-        const promise = f();
-        try {
-          const result = await promise;
-          resolve(result);
-        } catch (e) {
-          reject(e);
-        } finally {
-          this.runningCount--;
-          this.runNext();
-        }
-      };
-      if (this.runningCount < 1) {
-        run();
+  return groups;
+}
+function categorizeComparisonGroups(comparisonConfig, allGroups) {
+  const allGroupSummaries = /* @__PURE__ */ new Map();
+  const withErrors = [];
+  const onlyInLeft = [];
+  const onlyInRight = [];
+  let withDiffs = [];
+  const withoutDiffs = [];
+  function addSummaryForGroup(group, root, validInL, validInR) {
+    let scores;
+    if (validInL && validInR) {
+      scores = getScoresForGroup(group, comparisonConfig.thresholds);
+    }
+    const groupSummary = {
+      root,
+      group,
+      scores
+    };
+    allGroupSummaries.set(group.key, groupSummary);
+    if (validInL && validInR) {
+      if (scores.totalDiffCount !== scores.diffCountByBucket[0]) {
+        withDiffs.push(groupSummary);
       } else {
-        this.tasks.push(run);
+        withoutDiffs.push(groupSummary);
       }
-    });
+    } else if (validInL) {
+      onlyInLeft.push(groupSummary);
+    } else if (validInR) {
+      onlyInRight.push(groupSummary);
+    } else {
+      withErrors.push(groupSummary);
+    }
   }
-  runNext() {
-    if (this.tasks.length > 0) {
-      const task = this.tasks.shift();
-      if (task) {
-        task();
+  for (const group of allGroups.values()) {
+    switch (group.kind) {
+      case "by-dataset": {
+        const dataset = comparisonConfig.datasets.getDataset(group.key);
+        const validInL = (dataset == null ? void 0 : dataset.outputVarL) !== void 0;
+        const validInR = (dataset == null ? void 0 : dataset.outputVarR) !== void 0;
+        addSummaryForGroup(group, dataset, validInL, validInR);
+        break;
+      }
+      case "by-scenario": {
+        const scenario = comparisonConfig.scenarios.getScenario(group.key);
+        const validInL = (scenario == null ? void 0 : scenario.specL) !== void 0;
+        const validInR = (scenario == null ? void 0 : scenario.specR) !== void 0;
+        addSummaryForGroup(group, scenario, validInL, validInR);
+        break;
       }
+      default:
+        assertNever8(group.kind);
     }
   }
-};
-
-// src/config/config.ts
-async function createConfig(options) {
-  var _a;
-  const origCurrentBundle = await loadSynchronized(options.current);
-  let currentBundle;
-  let compareConfig;
-  if (options.compare === void 0) {
-    currentBundle = origCurrentBundle;
-  } else {
-    const baselineBundle = await loadSynchronized(options.compare.baseline);
-    const renamedDatasetKeys = options.compare.datasets.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: async (scenario, datasetKeys) => {
-        const rightKeys = datasetKeys.map(rightKeyForLeftKey);
-        const result = await origBundleModelR.getDatasetsForScenario(scenario, 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
-        };
-      },
-      getGraphsForDataset: (_a = origBundleModelR.getGraphsForDataset) == null ? void 0 : _a.bind(origBundleModelR),
-      getGraphDataForScenario: origBundleModelR.getGraphDataForScenario.bind(origBundleModelR),
-      getGraphLinksForScenario: origBundleModelR.getGraphLinksForScenario.bind(origBundleModelR)
-    };
-    currentBundle = __spreadProps(__spreadValues({}, origCurrentBundle), {
-      model: adjBundleModelR
-    });
-    compareConfig = {
-      bundleL: baselineBundle,
-      bundleR: currentBundle,
-      thresholds: options.compare.thresholds,
-      scenarios: options.compare.scenarios,
-      datasets: options.compare.datasets
-    };
+  if (withDiffs.length > 1) {
+    if (withDiffs[0].group.kind === "by-dataset") {
+      withDiffs = sortDatasetGroupSummaries(withDiffs);
+    } else if (withDiffs[0].group.kind === "by-scenario") {
+      withDiffs = sortScenarioGroupSummaries(withDiffs);
+    }
   }
-  const checkConfig = {
-    bundle: currentBundle,
-    tests: options.check.tests
-  };
   return {
-    check: checkConfig,
-    compare: compareConfig
+    allGroupSummaries,
+    withErrors,
+    onlyInLeft,
+    onlyInRight,
+    withDiffs,
+    withoutDiffs
   };
 }
-async function loadSynchronized(sourceBundle) {
-  const sourceModel = await sourceBundle.bundle.initModel();
-  const synchronizedModel = synchronizedBundleModel(sourceModel);
+function getScoresForGroup(group, thresholds) {
+  const diffCountByBucket = Array(thresholds.length + 2).fill(0);
+  const totalMaxDiffByBucket = Array(thresholds.length + 2).fill(0);
+  let totalDiffCount = 0;
+  for (const testSummary of group.testSummaries) {
+    const bucketIndex = getBucketIndex(testSummary.md, thresholds);
+    diffCountByBucket[bucketIndex]++;
+    totalMaxDiffByBucket[bucketIndex] += testSummary.md;
+    totalDiffCount++;
+  }
+  let diffPercentByBucket;
+  if (totalDiffCount > 0) {
+    diffPercentByBucket = diffCountByBucket.map((count) => count / totalDiffCount * 100);
+  } else {
+    diffPercentByBucket = [];
+  }
   return {
-    name: sourceBundle.name,
-    version: sourceBundle.bundle.version,
-    model: synchronizedModel
+    totalDiffCount,
+    totalMaxDiffByBucket,
+    diffCountByBucket,
+    diffPercentByBucket
   };
 }
-
-// src/config/dataset-manager.ts
-var DatasetManager = class {
-  constructor(bundleL, bundleR, renamedDatasetKeys) {
-    this.bundleL = bundleL;
-    this.bundleR = bundleR;
-    this.renamedDatasetKeys = renamedDatasetKeys;
-    const invertedRenamedKeys = /* @__PURE__ */ new Map();
-    renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.forEach((newKey, oldKey) => {
-      invertedRenamedKeys.set(newKey, oldKey);
-    });
-    function leftKeyForRightKey(rightKey) {
-      return invertedRenamedKeys.get(rightKey) || rightKey;
+function sortDatasetGroupSummaries(summaries) {
+  return summaries.sort((a, b) => {
+    var _a, _b;
+    const scoreResult = compareScores(a.scores, b.scores);
+    if (scoreResult !== 0) {
+      return -scoreResult;
+    } else {
+      const aVar = a.root.outputVarL;
+      const bVar = b.root.outputVarR;
+      const aSource = ((_a = aVar.sourceName) == null ? void 0 : _a.toLowerCase()) || "";
+      const bSource = ((_b = bVar.sourceName) == null ? void 0 : _b.toLowerCase()) || "";
+      if (aSource !== bSource) {
+        return aSource.localeCompare(bSource);
+      } else {
+        const aName = aVar.varName.toLowerCase();
+        const bName = bVar.varName.toLowerCase();
+        return aName.localeCompare(bName);
+      }
     }
-    const allOutputVarKeysSet = /* @__PURE__ */ new Set();
-    const modelOutputVarKeysSet = /* @__PURE__ */ new Set();
-    function addOutputVars(outputVars, handleRenames) {
-      outputVars.forEach((outputVar, key) => {
+  });
+}
+function sortScenarioGroupSummaries(summaries) {
+  return summaries.sort((a, b) => {
+    var _a, _b;
+    const scoreResult = compareScores(a.scores, b.scores);
+    if (scoreResult !== 0) {
+      return -scoreResult;
+    } else {
+      const aScenario = a.root;
+      const bScenario = b.root;
+      const aTitle = aScenario.title.toLowerCase();
+      const bTitle = bScenario.title.toLowerCase();
+      if (aTitle !== bTitle) {
+        return aTitle.localeCompare(bTitle);
+      } else {
+        const aSubtitle = ((_a = aScenario.subtitle) == null ? void 0 : _a.toLowerCase()) || "";
+        const bSubtitle = ((_b = bScenario.subtitle) == null ? void 0 : _b.toLowerCase()) || "";
+        return aSubtitle.localeCompare(bSubtitle);
+      }
+    }
+  });
+}
+function compareScores(a, b) {
+  if (a.totalMaxDiffByBucket.length !== b.totalMaxDiffByBucket.length) {
+    return 0;
+  }
+  const len = a.totalMaxDiffByBucket.length;
+  for (let i = len - 1; i >= 0; i--) {
+    const aTotal = a.totalMaxDiffByBucket[i];
+    const bTotal = b.totalMaxDiffByBucket[i];
+    if (aTotal > bTotal) {
+      return 1;
+    } else if (aTotal < bTotal) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+// src/bundle/model-inputs.ts
+var ModelInputs = class {
+  constructor(modelSpec) {
+    this.inputsByLookupName = /* @__PURE__ */ new Map();
+    this.inputIdAliases = /* @__PURE__ */ new Set();
+    for (const inputVar of modelSpec.inputVars.values()) {
+      const varNameKey = inputVar.varName.toLowerCase();
+      this.inputsByLookupName.set(varNameKey, inputVar);
+      if (inputVar.inputId) {
+        const idAlias = `id ${inputVar.inputId}`;
+        this.inputIdAliases.add(idAlias);
+        const idKey = idAlias.toLowerCase();
+        this.inputsByLookupName.set(idKey, inputVar);
+      }
+    }
+    if (modelSpec.inputAliases) {
+      for (const [alias, varId] of modelSpec.inputAliases.entries()) {
+        const aliasKey = alias.toLowerCase();
+        if (this.inputsByLookupName.has(aliasKey)) {
+          console.warn(
+            `WARNING: Input variable already defined with a name that collides with alias '${alias}', skipping`
+          );
+          continue;
+        }
+        const inputVar = modelSpec.inputVars.get(varId);
+        if (inputVar === void 0) {
+          console.warn(`WARNING: No input variable found for '${varId}' associated with alias '${alias}', skipping`);
+          continue;
+        }
+        this.inputsByLookupName.set(aliasKey, inputVar);
+      }
+    }
+  }
+  getAllInputIdAliases() {
+    return [...this.inputIdAliases];
+  }
+  getInputVarForName(name) {
+    return this.inputsByLookupName.get(name.toLowerCase());
+  }
+};
+
+// src/comparison/config/parse/comparison-parser.ts
+import Ajv2 from "ajv";
+import assertNever9 from "assert-never";
+import { err as err2, ok as ok2 } from "neverthrow";
+import yaml2 from "yaml";
+
+// src/comparison/config/parse/comparison.schema.js
+var comparison_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Model Comparison Test",
+  type: "array",
+  description: "A group of model comparison scenarios and views.",
+  items: {
+    $ref: "#/$defs/top_level_array_item"
+  },
+  $defs: {
+    top_level_array_item: {
+      oneOf: [
+        { $ref: "#/$defs/scenario_array_item" },
+        { $ref: "#/$defs/scenario_group_array_item" },
+        { $ref: "#/$defs/view_group_array_item" }
+      ]
+    },
+    scenario_array_item: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        scenario: {
+          $ref: "#/$defs/scenario"
+        }
+      },
+      required: ["scenario"]
+    },
+    scenario: {
+      oneOf: [
+        { $ref: "#/$defs/scenario_with_input_at_position" },
+        { $ref: "#/$defs/scenario_with_input_at_value" },
+        { $ref: "#/$defs/scenario_with_multiple_input_settings" },
+        { $ref: "#/$defs/scenario_with_inputs_in_preset_at_position" },
+        { $ref: "#/$defs/scenario_preset" }
+      ]
+    },
+    scenario_position: {
+      type: "string",
+      enum: ["min", "max", "default"]
+    },
+    scenario_with_input_at_position: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: "string"
+        },
+        title: {
+          type: "string"
+        },
+        subtitle: {
+          type: "string"
+        },
+        with: {
+          type: "string"
+        },
+        at: {
+          $ref: "#/$defs/scenario_position"
+        }
+      },
+      required: ["with", "at"]
+    },
+    scenario_with_input_at_value: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: "string"
+        },
+        title: {
+          type: "string"
+        },
+        subtitle: {
+          type: "string"
+        },
+        with: {
+          type: "string"
+        },
+        at: {
+          type: "number"
+        }
+      },
+      required: ["with", "at"]
+    },
+    scenario_input_at_position: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        input: {
+          type: "string"
+        },
+        at: {
+          $ref: "#/$defs/scenario_position"
+        }
+      },
+      required: ["input", "at"]
+    },
+    scenario_input_at_value: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        input: {
+          type: "string"
+        },
+        at: {
+          type: "number"
+        }
+      },
+      required: ["input", "at"]
+    },
+    scenario_input_setting: {
+      oneOf: [{ $ref: "#/$defs/scenario_input_at_position" }, { $ref: "#/$defs/scenario_input_at_value" }]
+    },
+    scenario_input_setting_array: {
+      type: "array",
+      items: {
+        $ref: "#/$defs/scenario_input_setting"
+      },
+      minItems: 1
+    },
+    scenario_with_multiple_input_settings: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: "string"
+        },
+        title: {
+          type: "string"
+        },
+        subtitle: {
+          type: "string"
+        },
+        with: {
+          $ref: "#/$defs/scenario_input_setting_array"
+        }
+      },
+      required: ["with"]
+    },
+    scenario_with_inputs_in_preset_at_position: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: "string"
+        },
+        title: {
+          type: "string"
+        },
+        subtitle: {
+          type: "string"
+        },
+        with_inputs: {
+          type: "string",
+          enum: ["all"]
+        },
+        at: {
+          $ref: "#/$defs/scenario_position"
+        }
+      },
+      required: ["with_inputs", "at"]
+    },
+    scenario_preset: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        preset: {
+          type: "string",
+          enum: ["matrix"]
+        }
+      },
+      required: ["preset"]
+    },
+    scenario_group_array_item: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        scenario_group: {
+          $ref: "#/$defs/scenario_group"
+        }
+      },
+      required: ["scenario_group"]
+    },
+    scenario_group: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: "string"
+        },
+        title: {
+          type: "string"
+        },
+        scenarios: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/scenario_group_scenarios_array_item"
+          },
+          minItems: 1
+        }
+      },
+      required: ["title", "scenarios"]
+    },
+    scenario_group_scenarios_array_item: {
+      oneOf: [{ $ref: "#/$defs/scenario_array_item" }, { $ref: "#/$defs/scenario_ref_array_item" }]
+    },
+    scenario_ref_id: {
+      type: "string"
+    },
+    scenario_ref_object: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: "string"
+        },
+        title: {
+          type: "string"
+        },
+        subtitle: {
+          type: "string"
+        }
+      },
+      required: ["id"]
+    },
+    scenario_ref: {
+      oneOf: [{ $ref: "#/$defs/scenario_ref_id" }, { $ref: "#/$defs/scenario_ref_object" }]
+    },
+    scenario_ref_array_item: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        scenario_ref: {
+          $ref: "#/$defs/scenario_ref"
+        }
+      },
+      required: ["scenario_ref"]
+    },
+    scenario_group_ref: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        scenario_group_ref: {
+          type: "string"
+        }
+      },
+      required: ["scenario_group_ref"]
+    },
+    view: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        title: {
+          type: "string"
+        },
+        subtitle: {
+          type: "string"
+        },
+        scenario_ref: {
+          type: "string"
+        },
+        graphs: {
+          $ref: "#/$defs/view_graphs"
+        }
+      },
+      required: ["scenario_ref", "graphs"]
+    },
+    view_graphs: {
+      oneOf: [{ $ref: "#/$defs/view_graphs_preset" }, { $ref: "#/$defs/view_graphs_array" }]
+    },
+    view_graphs_preset: {
+      type: "string",
+      enum: ["all"]
+    },
+    view_graphs_array: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      minItems: 1
+    },
+    view_group_array_item: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        view_group: {
+          $ref: "#/$defs/view_group"
+        }
+      },
+      required: ["view_group"]
+    },
+    view_group: {
+      oneOf: [
+        { $ref: "#/$defs/view_group_with_views_array" },
+        { $ref: "#/$defs/view_group_shorthand_with_scenarios_array" }
+      ]
+    },
+    view_group_with_views_array: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        title: {
+          type: "string"
+        },
+        views: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/view_group_views_array_item"
+          },
+          minItems: 1
+        }
+      },
+      required: ["title", "views"]
+    },
+    view_group_views_array_item: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        view: {
+          $ref: "#/$defs/view"
+        }
+      }
+    },
+    view_group_shorthand_with_scenarios_array: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        title: {
+          type: "string"
+        },
+        scenarios: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/view_group_scenarios_array_item"
+          },
+          minItems: 1
+        },
+        graphs: {
+          $ref: "#/$defs/view_graphs"
+        }
+      },
+      required: ["title", "scenarios", "graphs"]
+    },
+    view_group_scenarios_array_item: {
+      oneOf: [{ $ref: "#/$defs/scenario_ref_array_item" }, { $ref: "#/$defs/scenario_group_ref" }]
+    }
+  }
+};
+
+// src/comparison/config/parse/comparison-parser.ts
+function parseComparisonSpecs(specSource) {
+  const scenarios = [];
+  const scenarioGroups = [];
+  const viewGroups = [];
+  const ajv = new Ajv2();
+  const validate = ajv.compile(comparison_schema_default);
+  let parsed;
+  switch (specSource.kind) {
+    case "json":
+      parsed = JSON.parse(specSource.content);
+      break;
+    case "yaml":
+      parsed = yaml2.parse(specSource.content);
+      break;
+    default:
+      assertNever9(specSource.kind);
+  }
+  if (validate(parsed)) {
+    for (const specItem of parsed) {
+      if ("scenario" in specItem) {
+        scenarios.push(scenarioSpecFromParsed(specItem.scenario));
+      } else if ("scenario_group" in specItem) {
+        scenarioGroups.push(scenarioGroupSpecFromParsed(specItem.scenario_group));
+      } else if ("view_group" in specItem) {
+        viewGroups.push(viewGroupSpecFromParsed(specItem.view_group));
+      }
+    }
+  } else {
+    let msg = "Failed to parse YAML comparison definitions";
+    for (const error of validate.errors || []) {
+      if (error.message) {
+        msg += `
+${error.message}`;
+      }
+    }
+    return err2(new Error(msg));
+  }
+  return ok2({
+    scenarios,
+    scenarioGroups,
+    viewGroups
+  });
+}
+function scenarioSpecFromParsed(parsedScenario) {
+  if (parsedScenario.preset === "matrix") {
+    return {
+      kind: "scenario-matrix"
+    };
+  }
+  if (parsedScenario.with !== void 0) {
+    let inputSpecs;
+    if (Array.isArray(parsedScenario.with)) {
+      const parsedInputs = parsedScenario.with;
+      inputSpecs = parsedInputs.map(inputSpecFromParsed);
+    } else {
+      inputSpecs = [
+        inputSpecFromParsed({
+          input: parsedScenario.with,
+          at: parsedScenario.at
+        })
+      ];
+    }
+    return {
+      kind: "scenario-with-inputs",
+      id: parsedScenario.id,
+      title: parsedScenario.title,
+      subtitle: parsedScenario.subtitle,
+      inputs: inputSpecs
+    };
+  }
+  if (parsedScenario.with_inputs === "all") {
+    return {
+      kind: "scenario-with-all-inputs",
+      id: parsedScenario.id,
+      title: parsedScenario.title,
+      subtitle: parsedScenario.subtitle,
+      position: parsedScenario.at
+    };
+  }
+  throw new Error(`Unable to convert parsed scenario: ${JSON.stringify(parsedScenario)}`);
+}
+function inputSpecFromParsed(parsedInput) {
+  if (typeof parsedInput.at === "number") {
+    const value = parsedInput.at;
+    return {
+      kind: "input-at-value",
+      inputName: parsedInput.input,
+      value
+    };
+  } else {
+    return {
+      kind: "input-at-position",
+      inputName: parsedInput.input,
+      position: parsedInput.at
+    };
+  }
+}
+function scenarioGroupSpecFromParsed(parsedScenarioGroup) {
+  const scenarioSpecs = parsedScenarioGroup.scenarios.map(
+    (parsedScenarioOrRef) => {
+      if ("scenario_ref" in parsedScenarioOrRef) {
+        return scenarioRefSpecFromParsed(parsedScenarioOrRef);
+      } else {
+        return scenarioSpecFromParsed(parsedScenarioOrRef.scenario);
+      }
+    }
+  );
+  return {
+    kind: "scenario-group",
+    id: parsedScenarioGroup.id,
+    title: parsedScenarioGroup.title,
+    scenarios: scenarioSpecs
+  };
+}
+function scenarioRefSpecFromParsed(parsedScenarioRef) {
+  if (typeof parsedScenarioRef.scenario_ref === "string") {
+    return {
+      kind: "scenario-ref",
+      scenarioId: parsedScenarioRef.scenario_ref
+    };
+  } else {
+    return {
+      kind: "scenario-ref",
+      scenarioId: parsedScenarioRef.scenario_ref.id,
+      title: parsedScenarioRef.scenario_ref.title,
+      subtitle: parsedScenarioRef.scenario_ref.subtitle
+    };
+  }
+}
+function scenarioGroupRefSpecFromParsed(parsedGroupRef) {
+  return {
+    kind: "scenario-group-ref",
+    groupId: parsedGroupRef.scenario_group_ref
+  };
+}
+function viewSpecFromParsed(parsedView) {
+  return {
+    kind: "view",
+    title: parsedView.title,
+    subtitle: parsedView.subtitle,
+    scenarioId: parsedView.scenario_ref,
+    graphs: viewGraphsSpecFromParsed(parsedView.graphs)
+  };
+}
+function viewGraphsSpecFromParsed(parsedGraphs) {
+  if (parsedGraphs === "all") {
+    return {
+      kind: "graphs-preset",
+      preset: "all"
+    };
+  } else {
+    return {
+      kind: "graphs-array",
+      graphIds: parsedGraphs
+    };
+  }
+}
+function viewGroupSpecFromParsed(parsedViewGroup) {
+  if (parsedViewGroup.views !== void 0) {
+    return {
+      kind: "view-group-with-views",
+      title: parsedViewGroup.title,
+      views: parsedViewGroup.views.map((item) => viewSpecFromParsed(item.view))
+    };
+  } else if (parsedViewGroup.scenarios !== void 0) {
+    const scenarios = parsedViewGroup.scenarios.map(
+      (parsedScenarioOrGroupRef) => {
+        if ("scenario_ref" in parsedScenarioOrGroupRef) {
+          return scenarioRefSpecFromParsed(parsedScenarioOrGroupRef);
+        } else if ("scenario_group_ref" in parsedScenarioOrGroupRef) {
+          return scenarioGroupRefSpecFromParsed(parsedScenarioOrGroupRef);
+        } else {
+          throw new Error("Invalid view group");
+        }
+      }
+    );
+    return {
+      kind: "view-group-with-scenarios",
+      title: parsedViewGroup.title,
+      scenarios,
+      graphs: viewGraphsSpecFromParsed(parsedViewGroup.graphs)
+    };
+  } else {
+    throw new Error("Invalid view group");
+  }
+}
+
+// src/comparison/config/resolve/comparison-resolver.ts
+import { assertNever as assertNever11 } from "assert-never";
+
+// src/comparison/config/resolve/comparison-scenario-specs.ts
+import { assertNever as assertNever10 } from "assert-never";
+function scenarioSpecsFromSettings(settings) {
+  switch (settings.kind) {
+    case "all-inputs-settings": {
+      const scenario = allInputsAtPositionSpec(settings.position);
+      return [scenario, scenario];
+    }
+    case "input-settings": {
+      const specL = scenarioSpecFromInputs(settings.inputs, "left");
+      const specR = scenarioSpecFromInputs(settings.inputs, "right");
+      return [specL, specR];
+    }
+    default:
+      assertNever10(settings);
+  }
+}
+function scenarioSpecFromInputs(inputs, side) {
+  const settings = [];
+  for (const input of inputs) {
+    const state = side === "left" ? input.stateL : input.stateR;
+    if (state.inputVar === void 0) {
+      return void 0;
+    }
+    const varId = state.inputVar.varId;
+    if (state.position) {
+      settings.push(positionSetting(varId, state.position));
+    } else {
+      settings.push(valueSetting(varId, state.value));
+    }
+  }
+  return inputSettingsSpec(settings);
+}
+
+// src/comparison/config/resolve/comparison-resolver.ts
+function resolveComparisonSpecs(modelInputsL, modelInputsR, specs) {
+  let key = 1;
+  const genKey = () => {
+    return `${key++}`;
+  };
+  const resolvedScenarios = new ResolvedScenarios();
+  for (const scenarioSpec of specs.scenarios) {
+    resolvedScenarios.add(resolveScenariosFromSpec(modelInputsL, modelInputsR, scenarioSpec, genKey));
+  }
+  const partiallyResolvedScenarioGroups = [];
+  for (const scenarioGroupSpec of specs.scenarioGroups) {
+    const scenariosForGroup = [];
+    for (const scenarioItem of scenarioGroupSpec.scenarios) {
+      if (scenarioItem.kind === "scenario-ref") {
+        scenariosForGroup.push(scenarioItem);
+      } else {
+        const scenarios = resolveScenariosFromSpec(modelInputsL, modelInputsR, scenarioItem, genKey);
+        resolvedScenarios.add(scenarios);
+        scenariosForGroup.push(...scenarios);
+      }
+    }
+    partiallyResolvedScenarioGroups.push({
+      spec: scenarioGroupSpec,
+      scenarios: scenariosForGroup
+    });
+  }
+  const resolvedScenarioGroups = new ResolvedScenarioGroups();
+  for (const partiallyResolvedGroup of partiallyResolvedScenarioGroups) {
+    const scenariosForGroup = [];
+    for (const scenarioItem of partiallyResolvedGroup.scenarios) {
+      if (scenarioItem.kind === "scenario-ref") {
+        const referencedScenario = resolvedScenarios.getScenarioForId(scenarioItem.scenarioId);
+        if (referencedScenario) {
+          const resolvedScenario = { ...referencedScenario };
+          if (scenarioItem.title) {
+            resolvedScenario.title = scenarioItem.title;
+          }
+          if (scenarioItem.subtitle) {
+            resolvedScenario.subtitle = scenarioItem.subtitle;
+          }
+          scenariosForGroup.push(resolvedScenario);
+        } else {
+          scenariosForGroup.push({
+            kind: "unresolved-scenario-ref",
+            scenarioId: scenarioItem.scenarioId
+          });
+        }
+      } else {
+        scenariosForGroup.push(scenarioItem);
+      }
+    }
+    resolvedScenarioGroups.add({
+      kind: "scenario-group",
+      id: partiallyResolvedGroup.spec.id,
+      title: partiallyResolvedGroup.spec.title,
+      scenarios: scenariosForGroup
+    });
+  }
+  const resolvedViewGroups = [];
+  for (const viewGroupSpec of specs.viewGroups) {
+    const resolvedViewGroup = resolveViewGroupFromSpec(resolvedScenarios, resolvedScenarioGroups, viewGroupSpec);
+    resolvedViewGroups.push(resolvedViewGroup);
+  }
+  return {
+    scenarios: resolvedScenarios.getAll(),
+    scenarioGroups: resolvedScenarioGroups.getAll(),
+    viewGroups: resolvedViewGroups
+  };
+}
+var ResolvedScenarios = class {
+  constructor() {
+    this.resolvedScenarios = [];
+    this.resolvedScenariosById = /* @__PURE__ */ new Map();
+  }
+  add(scenarios) {
+    for (const resolvedScenario of scenarios) {
+      this.resolvedScenarios.push(resolvedScenario);
+      if (resolvedScenario.id !== void 0) {
+        if (this.resolvedScenariosById.has(resolvedScenario.id)) {
+          throw new Error(`Multiple scenarios defined with the same id (${resolvedScenario.id})`);
+        }
+        this.resolvedScenariosById.set(resolvedScenario.id, resolvedScenario);
+      }
+    }
+  }
+  getAll() {
+    return this.resolvedScenarios;
+  }
+  getScenarioForId(id) {
+    return this.resolvedScenariosById.get(id);
+  }
+};
+function resolveScenariosFromSpec(modelInputsL, modelInputsR, scenarioSpec, genKey) {
+  switch (scenarioSpec.kind) {
+    case "scenario-matrix":
+      return resolveScenarioMatrix(modelInputsL, modelInputsR, genKey);
+    case "scenario-with-all-inputs": {
+      const position = inputPosition2(scenarioSpec.position);
+      return [
+        resolveScenarioWithAllInputsAtPosition(
+          genKey(),
+          scenarioSpec.id,
+          scenarioSpec.title,
+          scenarioSpec.subtitle,
+          position
+        )
+      ];
+    }
+    case "scenario-with-inputs": {
+      return [
+        resolveScenarioForInputSpecs(
+          modelInputsL,
+          modelInputsR,
+          genKey(),
+          scenarioSpec.id,
+          scenarioSpec.title,
+          scenarioSpec.subtitle,
+          scenarioSpec.inputs
+        )
+      ];
+    }
+    default:
+      assertNever11(scenarioSpec);
+  }
+}
+function resolveScenarioMatrix(modelInputsL, modelInputsR, genKey) {
+  const resolvedScenarios = [];
+  resolvedScenarios.push(
+    resolveScenarioWithAllInputsAtPosition(genKey(), void 0, void 0, void 0, "at-default")
+  );
+  const inputIdAliases = /* @__PURE__ */ new Set();
+  modelInputsL.getAllInputIdAliases().forEach((alias) => inputIdAliases.add(alias));
+  modelInputsR.getAllInputIdAliases().forEach((alias) => inputIdAliases.add(alias));
+  for (const inputIdAlias of inputIdAliases) {
+    const inputAtMin = {
+      kind: "input-at-position",
+      inputName: inputIdAlias,
+      position: "min"
+    };
+    const inputAtMax = {
+      kind: "input-at-position",
+      inputName: inputIdAlias,
+      position: "max"
+    };
+    resolvedScenarios.push(
+      resolveScenarioForInputSpecs(modelInputsL, modelInputsR, genKey(), void 0, void 0, void 0, [inputAtMin])
+    );
+    resolvedScenarios.push(
+      resolveScenarioForInputSpecs(modelInputsL, modelInputsR, genKey(), void 0, void 0, void 0, [inputAtMax])
+    );
+  }
+  return resolvedScenarios;
+}
+function resolveScenarioWithAllInputsAtPosition(key, id, title, subtitle, position) {
+  const settings = {
+    kind: "all-inputs-settings",
+    position
+  };
+  const [specL, specR] = scenarioSpecsFromSettings(settings);
+  return {
+    kind: "scenario",
+    key,
+    id,
+    title,
+    subtitle,
+    settings,
+    specL,
+    specR
+  };
+}
+function resolveScenarioForInputSpecs(modelInputsL, modelInputsR, key, id, title, subtitle, inputSpecs) {
+  const resolvedInputs = inputSpecs.map((inputSpec) => {
+    switch (inputSpec.kind) {
+      case "input-at-position":
+        return resolveInputForName(modelInputsL, modelInputsR, inputSpec.inputName, inputSpec.position);
+      case "input-at-value":
+        return resolveInputForName(modelInputsL, modelInputsR, inputSpec.inputName, inputSpec.value);
+      default:
+        assertNever11(inputSpec);
+    }
+  });
+  const settings = {
+    kind: "input-settings",
+    inputs: resolvedInputs
+  };
+  const [specL, specR] = scenarioSpecsFromSettings(settings);
+  return {
+    kind: "scenario",
+    key,
+    id,
+    title,
+    subtitle,
+    settings,
+    specL,
+    specR
+  };
+}
+function resolveInputForName(modelInputsL, modelInputsR, inputName, at) {
+  return {
+    requestedName: inputName,
+    stateL: resolveInputForNameInModel(modelInputsL, inputName, at),
+    stateR: resolveInputForNameInModel(modelInputsR, inputName, at)
+  };
+}
+function resolveInputForNameInModel(modelInputs, inputName, at) {
+  const inputVar = modelInputs.getInputVarForName(inputName);
+  if (inputVar) {
+    return resolveInputVar(inputVar, at);
+  } else {
+    return {
+      error: {
+        kind: "unknown-input"
+      }
+    };
+  }
+}
+function resolveInputVar(inputVar, at) {
+  if (typeof at === "number") {
+    const value = at;
+    return resolveInputVarAtValue(inputVar, value);
+  } else {
+    const position = inputPosition2(at);
+    return resolveInputVarAtPosition(inputVar, position);
+  }
+}
+function resolveInputVarAtPosition(inputVar, position) {
+  return {
+    inputVar,
+    position,
+    value: inputValueAtPosition2(inputVar, position)
+  };
+}
+function resolveInputVarAtValue(inputVar, value) {
+  if (value >= inputVar.minValue && value <= inputVar.maxValue) {
+    return {
+      inputVar,
+      value
+    };
+  } else {
+    return {
+      error: {
+        kind: "invalid-value"
+      }
+    };
+  }
+}
+function inputPosition2(position) {
+  switch (position) {
+    case "default":
+      return "at-default";
+    case "min":
+      return "at-minimum";
+    case "max":
+      return "at-maximum";
+    default:
+      return void 0;
+  }
+}
+function inputValueAtPosition2(inputVar, position) {
+  switch (position) {
+    case "at-default":
+      return inputVar.defaultValue;
+    case "at-minimum":
+      return inputVar.minValue;
+    case "at-maximum":
+      return inputVar.maxValue;
+    default:
+      assertNever11(position);
+  }
+}
+var ResolvedScenarioGroups = class {
+  constructor() {
+    this.resolvedGroups = [];
+    this.resolvedGroupsById = /* @__PURE__ */ new Map();
+  }
+  add(group) {
+    this.resolvedGroups.push(group);
+    if (group.id !== void 0) {
+      if (this.resolvedGroupsById.has(group.id)) {
+        throw new Error(`Multiple scenario groups defined with the same id (${group.id})`);
+      }
+      this.resolvedGroupsById.set(group.id, group);
+    }
+  }
+  getAll() {
+    return this.resolvedGroups;
+  }
+  getGroupForId(id) {
+    return this.resolvedGroupsById.get(id);
+  }
+};
+function resolveGraphsFromSpec(graphsSpec) {
+  switch (graphsSpec.kind) {
+    case "graphs-preset":
+      return "all";
+    case "graphs-array":
+      return graphsSpec.graphIds;
+    default:
+      assertNever11(graphsSpec);
+  }
+}
+function resolveViewForScenarioId(resolvedScenarios, viewTitle, viewSubtitle, scenarioId, graphs) {
+  const resolvedScenario = resolvedScenarios.getScenarioForId(scenarioId);
+  if (resolvedScenario) {
+    return resolveViewForScenario(viewTitle, viewSubtitle, resolvedScenario, graphs);
+  } else {
+    return unresolvedViewForScenarioId(viewTitle, viewSubtitle, scenarioId);
+  }
+}
+function resolveViewForScenarioRefSpec(resolvedScenarios, refSpec, graphs) {
+  const resolvedScenario = resolvedScenarios.getScenarioForId(refSpec.scenarioId);
+  if (resolvedScenario) {
+    return resolveViewForScenario(refSpec.title, refSpec.subtitle, resolvedScenario, graphs);
+  } else {
+    return unresolvedViewForScenarioId(void 0, void 0, refSpec.scenarioId);
+  }
+}
+function resolveViewForScenario(viewTitle, viewSubtitle, resolvedScenario, graphs) {
+  if (viewTitle === void 0) {
+    viewTitle = resolvedScenario.title;
+    if (viewTitle === void 0) {
+      viewTitle = "Untitled view";
+    }
+    if (viewSubtitle === void 0) {
+      viewSubtitle = resolvedScenario.subtitle;
+    }
+  }
+  return {
+    kind: "view",
+    title: viewTitle,
+    subtitle: viewSubtitle,
+    scenario: resolvedScenario,
+    graphs
+  };
+}
+function unresolvedViewForScenarioId(viewTitle, viewSubtitle, scenarioId) {
+  return {
+    kind: "unresolved-view",
+    title: viewTitle,
+    subtitle: viewSubtitle,
+    scenarioId
+  };
+}
+function unresolvedViewForScenarioGroupId(viewTitle, viewSubtitle, scenarioGroupId) {
+  return {
+    kind: "unresolved-view",
+    title: viewTitle,
+    subtitle: viewSubtitle,
+    scenarioGroupId
+  };
+}
+function resolveViewGroupFromSpec(resolvedScenarios, resolvedScenarioGroups, viewGroupSpec) {
+  let views;
+  switch (viewGroupSpec.kind) {
+    case "view-group-with-views": {
+      views = viewGroupSpec.views.map((viewSpec) => {
+        const graphs = resolveGraphsFromSpec(viewSpec.graphs);
+        return resolveViewForScenarioId(
+          resolvedScenarios,
+          viewSpec.title,
+          viewSpec.subtitle,
+          viewSpec.scenarioId,
+          graphs
+        );
+      });
+      break;
+    }
+    case "view-group-with-scenarios": {
+      const graphs = resolveGraphsFromSpec(viewGroupSpec.graphs);
+      views = [];
+      for (const refSpec of viewGroupSpec.scenarios) {
+        switch (refSpec.kind) {
+          case "scenario-ref":
+            views.push(resolveViewForScenarioRefSpec(resolvedScenarios, refSpec, graphs));
+            break;
+          case "scenario-group-ref": {
+            const resolvedGroup = resolvedScenarioGroups.getGroupForId(refSpec.groupId);
+            if (resolvedGroup) {
+              for (const scenario of resolvedGroup.scenarios) {
+                switch (scenario.kind) {
+                  case "unresolved-scenario-ref":
+                    views.push(unresolvedViewForScenarioId(void 0, void 0, scenario.scenarioId));
+                    break;
+                  case "scenario":
+                    views.push(resolveViewForScenario(void 0, void 0, scenario, graphs));
+                    break;
+                  default:
+                    assertNever11(scenario);
+                }
+              }
+            } else {
+              views.push(unresolvedViewForScenarioGroupId(void 0, void 0, refSpec.groupId));
+            }
+            break;
+          }
+          default:
+            assertNever11(refSpec);
+        }
+      }
+      break;
+    }
+    default:
+      assertNever11(viewGroupSpec);
+  }
+  return {
+    kind: "view-group",
+    title: viewGroupSpec.title,
+    views
+  };
+}
+
+// src/comparison/config/comparison-config.ts
+function resolveComparisonSpecsFromSources(modelInputsL, modelInputsR, specSources) {
+  const combinedSpecs = {
+    scenarios: [],
+    scenarioGroups: [],
+    viewGroups: []
+  };
+  for (const specSource of specSources) {
+    let specs;
+    if ("kind" in specSource) {
+      const parseResult = parseComparisonSpecs(specSource);
+      if (parseResult.isOk()) {
+        specs = parseResult.value;
+      } else {
+        const filenamePart = specSource.filename ? ` in ${specSource.filename}` : "";
+        console.error(`ERROR: Failed to parse comparison spec${filenamePart}, skipping`);
+        continue;
+      }
+    } else {
+      specs = specSource;
+    }
+    combinedSpecs.scenarios.push(...specs.scenarios);
+    combinedSpecs.scenarioGroups.push(...specs.scenarioGroups);
+    combinedSpecs.viewGroups.push(...specs.viewGroups);
+  }
+  return resolveComparisonSpecs(modelInputsL, modelInputsR, combinedSpecs);
+}
+
+// src/comparison/config/comparison-datasets.ts
+function getComparisonDatasets(modelSpecL, modelSpecR, datasetOptions) {
+  return new ComparisonDatasetsImpl(modelSpecL, modelSpecR, datasetOptions);
+}
+var ComparisonDatasetsImpl = class {
+  constructor(modelSpecL, modelSpecR, datasetOptions) {
+    this.datasetOptions = datasetOptions;
+    const renamedDatasetKeys = datasetOptions == null ? void 0 : datasetOptions.renamedDatasetKeys;
+    const invertedRenamedKeys = /* @__PURE__ */ new Map();
+    renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.forEach((newKey, oldKey) => {
+      invertedRenamedKeys.set(newKey, oldKey);
+    });
+    function leftKeyForRightKey(rightKey) {
+      return invertedRenamedKeys.get(rightKey) || rightKey;
+    }
+    const allOutputVarKeysSet = /* @__PURE__ */ new Set();
+    const modelOutputVarKeysSet = /* @__PURE__ */ new Set();
+    function addOutputVars(outputVars, handleRenames) {
+      outputVars.forEach((outputVar, key) => {
         const remappedKey = handleRenames ? leftKeyForRightKey(key) : key;
         allOutputVarKeysSet.add(remappedKey);
         if (outputVar.sourceName === void 0) {
@@ -2204,239 +3336,193 @@ var DatasetManager = class {
         }
       });
     }
-    addOutputVars(bundleL.modelSpec.outputVars, false);
-    addOutputVars(bundleR.modelSpec.outputVars, true);
+    addOutputVars(modelSpecL.outputVars, false);
+    addOutputVars(modelSpecR.outputVars, true);
     this.allOutputVarKeys = Array.from(allOutputVarKeysSet);
     this.modelOutputVarKeys = Array.from(modelOutputVarKeysSet);
-  }
-  getDatasetKeysForScenario(scenario) {
-    if (scenario.kind === "all-inputs" && scenario.position === "at-default") {
-      return this.allOutputVarKeys;
-    } else {
-      return this.modelOutputVarKeys;
+    this.allDatasets = /* @__PURE__ */ new Map();
+    for (const datasetKeyL of this.allOutputVarKeys) {
+      const datasetKeyR = (renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.get(datasetKeyL)) || datasetKeyL;
+      const outputVarL = modelSpecL.outputVars.get(datasetKeyL);
+      const outputVarR = modelSpecR.outputVars.get(datasetKeyR);
+      this.allDatasets.set(datasetKeyL, {
+        kind: "dataset",
+        key: datasetKeyL,
+        outputVarL,
+        outputVarR
+      });
     }
   }
-  getDatasetInfo(datasetKey) {
+  getAllDatasets() {
+    return this.allDatasets.values();
+  }
+  getDataset(datasetKey) {
+    return this.allDatasets.get(datasetKey);
+  }
+  getDatasetKeysForScenario(scenario) {
     var _a;
-    const modelSpecL = this.bundleL.modelSpec;
-    const modelSpecR = this.bundleR.modelSpec;
-    const datasetKeyL = datasetKey;
-    const datasetKeyR = ((_a = this.renamedDatasetKeys) == null ? void 0 : _a.get(datasetKeyL)) || datasetKeyL;
-    const outputVarL = modelSpecL.outputVars.get(datasetKeyL);
-    const outputVarR = modelSpecR.outputVars.get(datasetKeyR);
-    let varName;
-    let newVarName;
-    let sourceName;
-    let newSourceName;
-    if (outputVarL && outputVarR && outputVarL.varName != outputVarR.varName) {
-      varName = outputVarL.varName;
-      newVarName = outputVarR.varName;
-    } else {
-      const outputVar = outputVarR || outputVarL;
-      varName = (outputVar == null ? void 0 : outputVar.varName) || "Unknown";
-    }
-    if (outputVarL && outputVarR && outputVarL.sourceName != outputVarR.sourceName) {
-      sourceName = outputVarL.sourceName;
-      newSourceName = outputVarR.sourceName;
+    if (((_a = this.datasetOptions) == null ? void 0 : _a.datasetKeysForScenario) !== void 0) {
+      return this.datasetOptions.datasetKeysForScenario(this.allOutputVarKeys, scenario);
     } else {
-      const outputVar = outputVarR || outputVarL;
-      sourceName = outputVar == null ? void 0 : outputVar.sourceName;
+      if (scenario.settings.kind === "all-inputs-settings" && scenario.settings.position === "at-default") {
+        return this.allOutputVarKeys;
+      } else {
+        return this.modelOutputVarKeys;
+      }
     }
-    return {
-      varName,
-      newVarName,
-      sourceName,
-      newSourceName,
-      relatedItems: (outputVarR == null ? void 0 : outputVarR.relatedItems) || []
-    };
   }
 };
 
-// src/config/scenario-manager.ts
-import { assertNever as assertNever8 } from "assert-never";
-var ScenarioManager = class {
-  constructor(bundleL, bundleR) {
-    this.bundleL = bundleL;
-    this.bundleR = bundleR;
-    this.scenarios = /* @__PURE__ */ new Map();
-    this.scenarioInfo = /* @__PURE__ */ new Map();
-    this.defaultInfoForGroup = /* @__PURE__ */ new Map();
-    this.groupInfo = /* @__PURE__ */ new Map();
-  }
-  getScenarios() {
-    return [...this.scenarios.values()];
-  }
-  getScenario(scenarioKey) {
-    return this.scenarios.get(scenarioKey);
-  }
-  getScenarioGroupInfo(groupKey) {
-    return this.groupInfo.get(groupKey);
-  }
-  getScenarioInfo(scenario, groupKey) {
-    if (scenario.key === "all_inputs_at_default") {
-      const defaultInfo = this.defaultInfoForGroup.get(groupKey);
-      if (defaultInfo) {
-        return defaultInfo;
-      }
-    }
-    return this.scenarioInfo.get(scenario.key);
-  }
-  setDefaultScenarioInfoForGroup(groupKey, scenarioInfo) {
-    this.defaultInfoForGroup.set(groupKey, scenarioInfo);
-  }
-  addScenario(scenario, scenarioInfo, groupInfo) {
-    this.scenarios.set(scenario.key, scenario);
-    if (!scenarioInfo) {
-      scenarioInfo = this.getInfoForScenario(scenario);
-    }
-    this.scenarioInfo.set(scenario.key, scenarioInfo);
-    if (!groupInfo) {
-      groupInfo = this.getGroupInfoForScenario(scenario);
-    }
-    this.groupInfo.set(scenario.groupKey, groupInfo);
-  }
-  addScenarioMatrix() {
-    const inputVarIdsL = Array.from(this.bundleL.modelSpec.inputVars.keys());
-    const inputVarIdsR = Array.from(this.bundleR.modelSpec.inputVars.keys());
-    const inputVarIds = /* @__PURE__ */ new Set([...inputVarIdsL, ...inputVarIdsR]);
-    this.addScenario(allInputsAtPositionScenario("at-default"));
-    this.addScenario(allInputsAtPositionScenario("at-minimum"));
-    this.addScenario(allInputsAtPositionScenario("at-maximum"));
-    for (const inputVarId of inputVarIds) {
-      this.addScenario(inputAtPositionScenario(inputVarId, inputVarId, "at-minimum"));
-      this.addScenario(inputAtPositionScenario(inputVarId, inputVarId, "at-maximum"));
-    }
-  }
-  getGroupInfoForScenario(scenario) {
-    switch (scenario.kind) {
-      case "all-inputs":
-        return {
-          title: "All Inputs",
-          relatedItems: []
-        };
-      case "settings":
-        if (scenario.settings.length === 1) {
-          const inputVar = this.getInputVarForSetting(scenario.settings[0]);
-          let relatedItems;
-          let subtitle;
-          if (inputVar == null ? void 0 : inputVar.relatedItem) {
-            relatedItems = [inputVar.relatedItem];
-            subtitle = inputVar.relatedItem.locationPath.join('&nbsp;<span class="related-sep">&gt;</span>&nbsp;');
-          } else {
-            relatedItems = [];
-            subtitle = void 0;
-          }
-          return {
-            title: (inputVar == null ? void 0 : inputVar.varName) || "Unknown Input",
-            subtitle,
-            relatedItems
-          };
-        } else {
-          return {
-            title: "Multiple Inputs",
-            relatedItems: this.getRelatedItemsForSettings(scenario.settings)
-          };
-        }
-      default:
-        assertNever8(scenario);
+// src/comparison/config/comparison-scenarios.ts
+function getComparisonScenarios(scenarios) {
+  return new ComparisonScenariosImpl(scenarios);
+}
+var ComparisonScenariosImpl = class {
+  constructor(scenarios) {
+    this.scenarioDefs = /* @__PURE__ */ new Map();
+    for (const scenario of scenarios) {
+      this.scenarioDefs.set(scenario.key, scenario);
     }
   }
-  getInfoForScenario(scenario) {
-    switch (scenario.kind) {
-      case "all-inputs":
-        return this.getInfoForPositionSetting(void 0, scenario.position);
-      case "settings":
-        if (scenario.settings.length === 1 && scenario.settings[0].kind === "position") {
-          const setting = scenario.settings[0];
-          return this.getInfoForPositionSetting(setting.inputVarId, setting.position);
-        } else {
-          return {
-            title: `PLACEHOLDER (scenario info not provided)`,
-            position: 1
-          };
-        }
-      default:
-        assertNever8(scenario);
-    }
+  getAllScenarios() {
+    return this.scenarioDefs.values();
   }
-  getInfoForPositionSetting(inputVarId, inputPosition2) {
-    const title = inputPosition2.replace("-", " ");
-    let subtitle;
-    if (inputVarId) {
-      const inputVarL = this.bundleL.modelSpec.inputVars.get(inputVarId);
-      const inputVarR = this.bundleR.modelSpec.inputVars.get(inputVarId);
-      const valueL = inputValue(inputVarL, inputPosition2);
-      const valueR = inputValue(inputVarR, inputPosition2);
-      if (valueL !== valueR) {
-        let values = "";
-        values += "(";
-        values += `<span class='dataset-color-0'>${valueL}</span>`;
-        values += "&nbsp;|&nbsp;";
-        values += `<span class='dataset-color-1'>${valueR}</span>`;
-        values += ")";
-        subtitle = values;
+  getScenario(key) {
+    return this.scenarioDefs.get(key);
+  }
+};
+
+// 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.runningCount++;
+        const promise = f();
+        try {
+          const result = await promise;
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        } finally {
+          this.runningCount--;
+          this.runNext();
+        }
+      };
+      if (this.runningCount < 1) {
+        run();
       } else {
-        subtitle = `(${valueL})`;
+        this.tasks.push(run);
       }
-    } else {
-      subtitle = void 0;
-    }
-    let position;
-    switch (inputPosition2) {
-      case "at-default":
-        position = 0;
-        break;
-      case "at-minimum":
-        position = 1;
-        break;
-      case "at-maximum":
-        position = 2;
-        break;
-      default:
-        assertNever8(inputPosition2);
-    }
-    return {
-      title,
-      subtitle,
-      position
-    };
+    });
   }
-  getRelatedItemsForSettings(settings) {
-    const relatedItems = [];
-    for (const setting of settings) {
-      const inputVar = this.getInputVarForSetting(setting);
-      if (inputVar == null ? void 0 : inputVar.relatedItem) {
-        relatedItems.push(inputVar.relatedItem);
+  runNext() {
+    if (this.tasks.length > 0) {
+      const task = this.tasks.shift();
+      if (task) {
+        task();
       }
     }
-    return relatedItems;
-  }
-  getInputVarForSetting(setting) {
-    const inputVarId = setting.inputVarId;
-    const inputVarL = this.bundleL.modelSpec.inputVars.get(inputVarId);
-    const inputVarR = this.bundleR.modelSpec.inputVars.get(inputVarId);
-    return inputVarR || inputVarL;
   }
 };
-function inputValue(inputVar, position) {
-  if (inputVar) {
-    switch (position) {
-      case "at-default":
-        return inputVar.defaultValue.toString();
-      case "at-minimum":
-        return inputVar.minValue.toString();
-      case "at-maximum":
-        return inputVar.maxValue.toString();
-      default:
-        assertNever8(position);
-    }
+
+// src/config/config.ts
+async function createConfig(options) {
+  var _a;
+  const origCurrentBundle = await loadSynchronized(options.current);
+  let currentBundle;
+  let comparisonConfig;
+  if (options.comparison === void 0) {
+    currentBundle = origCurrentBundle;
   } else {
-    return "n/a";
+    const baselineBundle = await 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: async (scenarioSpec, datasetKeys) => {
+        const rightKeys = datasetKeys.map(rightKeyForLeftKey);
+        const result = await 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 = {
+      ...origCurrentBundle,
+      model: adjBundleModelR
+    };
+    const modelSpecL = baselineBundle.model.modelSpec;
+    const modelSpecR = currentBundle.model.modelSpec;
+    const modelInputsL = new ModelInputs(modelSpecL);
+    const modelInputsR = new ModelInputs(modelSpecR);
+    const comparisonDefs = resolveComparisonSpecsFromSources(modelInputsL, modelInputsR, options.comparison.specs);
+    comparisonConfig = {
+      bundleL: baselineBundle,
+      bundleR: currentBundle,
+      thresholds: options.comparison.thresholds,
+      scenarios: getComparisonScenarios(comparisonDefs.scenarios),
+      datasets: getComparisonDatasets(modelSpecL, modelSpecR, options.comparison.datasets),
+      viewGroups: comparisonDefs.viewGroups
+    };
   }
+  const checkConfig = {
+    bundle: currentBundle,
+    tests: options.check.tests
+  };
+  return {
+    check: checkConfig,
+    comparison: comparisonConfig
+  };
+}
+async function loadSynchronized(sourceBundle) {
+  const sourceModel = await sourceBundle.bundle.initModel();
+  const synchronizedModel = synchronizedBundleModel(sourceModel);
+  return {
+    name: sourceBundle.name,
+    version: sourceBundle.bundle.version,
+    model: synchronizedModel
+  };
 }
 
 // src/perf/perf-runner.ts
-import { assertNever as assertNever9 } from "assert-never";
+import { assertNever as assertNever12 } from "assert-never";
 
 // src/perf/perf-stats.ts
 var PerfStats = class {
@@ -2480,26 +3566,26 @@ var PerfRunner = class {
     this.bundleModelL = bundleModelL;
     this.bundleModelR = bundleModelR;
     this.mode = mode;
-    const scenario = allInputsAtPositionScenario("at-default");
+    const scenarioSpec = allInputsAtPositionSpec("at-default");
     this.taskQueue = new TaskQueue({
       process: async (request) => {
         switch (request.kind) {
           case "left": {
-            const result = await bundleModelL.getDatasetsForScenario(scenario, []);
+            const result = await bundleModelL.getDatasetsForScenario(scenarioSpec, []);
             return {
               runTimeL: result.modelRunTime
             };
           }
           case "right": {
-            const result = await bundleModelR.getDatasetsForScenario(scenario, []);
+            const result = await bundleModelR.getDatasetsForScenario(scenarioSpec, []);
             return {
               runTimeR: result.modelRunTime
             };
           }
           case "both": {
             const [resultL, resultR] = await Promise.all([
-              bundleModelL.getDatasetsForScenario(scenario, []),
-              bundleModelR.getDatasetsForScenario(scenario, [])
+              bundleModelL.getDatasetsForScenario(scenarioSpec, []),
+              bundleModelR.getDatasetsForScenario(scenarioSpec, [])
             ]);
             return {
               runTimeL: resultL.modelRunTime,
@@ -2507,7 +3593,7 @@ var PerfRunner = class {
             };
           }
           default:
-            assertNever9(request.kind);
+            assertNever12(request.kind);
         }
       }
     });
@@ -2555,46 +3641,126 @@ var PerfRunner = class {
   }
 };
 
-// src/suite/suite-runner.ts
-import assertNever10 from "assert-never";
-
 // src/data/data-planner.ts
-var ScenarioTaskSet = class {
-  constructor(scenario) {
-    this.scenario = scenario;
-    this.modelTasks = /* @__PURE__ */ new Map();
-    this.modelImplTasks = /* @__PURE__ */ new Map();
-    this.requestKind = "check";
-  }
-  addTask(kind, datasetKey, dataFunc) {
-    if (kind === "compare") {
-      this.requestKind = "compare";
+var DataPlanner = class {
+  constructor(batchSize) {
+    this.batchSize = batchSize;
+    this.taskSetsLR = /* @__PURE__ */ new Map();
+    this.taskSetsL = /* @__PURE__ */ new Map();
+    this.taskSetsR = /* @__PURE__ */ new Map();
+    this.complete = false;
+  }
+  addRequest(scenarioSpecL, scenarioSpecR, datasetKey, dataAction) {
+    if (scenarioSpecL === void 0 && scenarioSpecR === void 0) {
+      console.warn("WARNING: Both scenario specs are undefined for DataPlanner request, skipping");
+      return;
+    }
+    let taskSetsMap;
+    let uid;
+    if (scenarioSpecL && scenarioSpecR) {
+      taskSetsMap = this.taskSetsLR;
+      uid = scenarioPairUid(scenarioSpecL, scenarioSpecR);
+    } else if (scenarioSpecR) {
+      taskSetsMap = this.taskSetsR;
+      uid = scenarioSpecR.uid;
+    } else {
+      taskSetsMap = this.taskSetsL;
+      uid = scenarioSpecL.uid;
+    }
+    let taskSet = taskSetsMap.get(uid);
+    if (!taskSet) {
+      taskSet = new DataTaskSet(scenarioSpecL, scenarioSpecR);
+      taskSetsMap.set(uid, taskSet);
     }
-    const dataTask = {
+    taskSet.addTask({
       datasetKey,
-      dataFunc
+      dataAction
+    });
+  }
+  buildPlan() {
+    if (this.complete) {
+      throw new Error("DataPlanner.buildPlan() can only be called once");
+    }
+    this.complete = true;
+    const lKeyMappings = /* @__PURE__ */ new Map();
+    const rKeyMappings = /* @__PURE__ */ new Map();
+    for (const lrUid of this.taskSetsLR.keys()) {
+      const [lUid, rUid] = lrUid.split("::");
+      if (!lKeyMappings.has(lUid)) {
+        lKeyMappings.set(lUid, lrUid);
+      }
+      if (!rKeyMappings.has(rUid)) {
+        rKeyMappings.set(rUid, lrUid);
+      }
+    }
+    function merge(taskSetsLR, taskSetsForSide, keyMappingsForSide) {
+      for (const [keyForSide, taskSetForSide] of taskSetsForSide.entries()) {
+        const lrKey = keyMappingsForSide.get(keyForSide);
+        if (lrKey) {
+          const taskSetLR = taskSetsLR.get(lrKey);
+          taskSetLR.merge(taskSetForSide);
+          taskSetsForSide.delete(keyForSide);
+        }
+      }
+    }
+    merge(this.taskSetsLR, this.taskSetsL, lKeyMappings);
+    merge(this.taskSetsLR, this.taskSetsR, rKeyMappings);
+    const requests = [];
+    const batchSize = this.batchSize;
+    function addRequests(taskSets) {
+      for (const taskSet of taskSets) {
+        requests.push(...taskSet.buildRequests(batchSize));
+      }
+    }
+    addRequests(this.taskSetsLR.values());
+    addRequests(this.taskSetsL.values());
+    addRequests(this.taskSetsR.values());
+    return {
+      requests
     };
+  }
+};
+var DataTaskSet = class {
+  constructor(scenarioSpecL, scenarioSpecR) {
+    this.scenarioSpecL = scenarioSpecL;
+    this.scenarioSpecR = scenarioSpecR;
+    this.modelTasks = /* @__PURE__ */ new Map();
+    this.modelImplTasks = /* @__PURE__ */ new Map();
+  }
+  addTask(dataTask) {
     let taskMap;
-    if (datasetKey.startsWith("ModelImpl")) {
+    if (dataTask.datasetKey.startsWith("ModelImpl")) {
       taskMap = this.modelImplTasks;
     } else {
       taskMap = this.modelTasks;
     }
-    let tasks = taskMap.get(datasetKey);
+    let tasks = taskMap.get(dataTask.datasetKey);
     if (!tasks) {
       tasks = [];
-      taskMap.set(datasetKey, tasks);
+      taskMap.set(dataTask.datasetKey, tasks);
     }
     tasks.push(dataTask);
   }
+  merge(otherTaskSet) {
+    for (const tasks of otherTaskSet.modelTasks.values()) {
+      for (const task of tasks) {
+        this.addTask(task);
+      }
+    }
+    for (const tasks of otherTaskSet.modelImplTasks.values()) {
+      for (const task of tasks) {
+        this.addTask(task);
+      }
+    }
+  }
   buildRequests(batchSize) {
     const dataRequests = [];
     if (this.modelTasks.size > 0) {
       const dataTasks = [];
       this.modelTasks.forEach((tasks) => dataTasks.push(...tasks));
       dataRequests.push({
-        kind: this.requestKind,
-        scenario: this.scenario,
+        scenarioSpecL: this.scenarioSpecL,
+        scenarioSpecR: this.scenarioSpecR,
         dataTasks
       });
     }
@@ -2607,8 +3773,8 @@ var ScenarioTaskSet = class {
           dataTasks.push(...this.modelImplTasks.get(datasetKey));
         }
         dataRequests.push({
-          kind: this.requestKind,
-          scenario: this.scenario,
+          scenarioSpecL: this.scenarioSpecL,
+          scenarioSpecR: this.scenarioSpecR,
           dataTasks
         });
       }
@@ -2616,29 +3782,11 @@ var ScenarioTaskSet = class {
     return dataRequests;
   }
 };
-var DataPlanner = class {
-  constructor(batchSize) {
-    this.batchSize = batchSize;
-    this.scenarioTaskSets = /* @__PURE__ */ new Map();
-  }
-  addRequest(kind, scenario, datasetKey, dataFunc) {
-    let scenarioTaskSet = this.scenarioTaskSets.get(scenario.key);
-    if (!scenarioTaskSet) {
-      scenarioTaskSet = new ScenarioTaskSet(scenario);
-      this.scenarioTaskSets.set(scenario.key, scenarioTaskSet);
-    }
-    scenarioTaskSet.addTask(kind, datasetKey, dataFunc);
-  }
-  buildPlan() {
-    const requests = [];
-    for (const taskSet of this.scenarioTaskSets.values()) {
-      requests.push(...taskSet.buildRequests(this.batchSize));
-    }
-    return {
-      requests
-    };
-  }
-};
+function scenarioPairUid(scenarioSpecL, scenarioSpecR) {
+  const uidL = (scenarioSpecL == null ? void 0 : scenarioSpecL.uid) || "";
+  const uidR = (scenarioSpecR == null ? void 0 : scenarioSpecR.uid) || "";
+  return `${uidL}::${uidR}`;
+}
 
 // src/check/check-runner.ts
 function runChecks(checkConfig, checkSpec, dataPlanner, refDataPlanner, simplifyScenarios) {
@@ -2648,7 +3796,7 @@ function runChecks(checkConfig, checkSpec, dataPlanner, refDataPlanner, simplify
   const checkPlan = checkPlanner.buildPlan();
   const refDatasets = /* @__PURE__ */ new Map();
   for (const [dataRefKey, dataRef] of checkPlan.dataRefs.entries()) {
-    refDataPlanner.addRequest("check", dataRef.scenario.scenario, dataRef.dataset.datasetKey, (datasets) => {
+    refDataPlanner.addRequest(void 0, dataRef.scenario.spec, dataRef.dataset.datasetKey, (datasets) => {
       const dataset = datasets.datasetR;
       if (dataset) {
         refDatasets.set(dataRefKey, dataset);
@@ -2657,7 +3805,7 @@ function runChecks(checkConfig, checkSpec, dataPlanner, refDataPlanner, simplify
   }
   const checkResults = /* @__PURE__ */ new Map();
   for (const [checkKey, checkTask] of checkPlan.tasks.entries()) {
-    dataPlanner.addRequest("check", checkTask.scenario.scenario, checkTask.dataset.datasetKey, (datasets) => {
+    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);
@@ -2688,7 +3836,7 @@ function runCheck(checkTask, dataset, refDatasets) {
               name: dataRef.dataset.name
             }
           };
-        } else if (dataRef.scenario.scenario === void 0) {
+        } else if (dataRef.scenario.spec === void 0) {
           if (dataRef.scenario.error) {
             return {
               status: "error",
@@ -2725,16 +3873,15 @@ function runCheck(checkTask, dataset, refDatasets) {
   return checkTask.action.run(dataset, opRefDatasets);
 }
 
-// src/compare/compare-runner.ts
-function runCompare(compareConfig, dataPlanner, simplifyScenarios) {
-  const scenarios = simplifyScenarios ? [allInputsAtPositionScenario("at-default")] : compareConfig.scenarios.getScenarios();
-  const datasetReports = [];
-  for (const scenario of scenarios) {
-    const datasetKeys = compareConfig.datasets.getDatasetKeysForScenario(scenario);
+// src/comparison/run/comparison-runner.ts
+function runComparisons(comparisonConfig, dataPlanner) {
+  const testReports = [];
+  for (const scenario of comparisonConfig.scenarios.getAllScenarios()) {
+    const datasetKeys = comparisonConfig.datasets.getDatasetKeysForScenario(scenario);
     for (const datasetKey of datasetKeys) {
-      dataPlanner.addRequest("compare", scenario, datasetKey, (datasets) => {
+      dataPlanner.addRequest(scenario.specL, scenario.specR, datasetKey, (datasets) => {
         const diffReport = diffDatasets(datasets.datasetL, datasets.datasetR);
-        datasetReports.push({
+        testReports.push({
           scenarioKey: scenario.key,
           datasetKey,
           diffReport
@@ -2743,7 +3890,7 @@ function runCompare(compareConfig, dataPlanner, simplifyScenarios) {
     }
   }
   return () => {
-    return datasetReports;
+    return testReports;
   };
 }
 
@@ -2781,9 +3928,9 @@ var SuiteRunner = class {
     const checkSpec = checkSpecResult.value;
     const simplifyScenarios = (options == null ? void 0 : options.simplifyScenarios) === true;
     const buildCheckReport2 = runChecks(this.config.check, checkSpec, dataPlanner, refDataPlanner, simplifyScenarios);
-    let buildCompareDatasetReports;
-    if (this.config.compare) {
-      buildCompareDatasetReports = runCompare(this.config.compare, dataPlanner, simplifyScenarios);
+    let buildComparisonTestReports;
+    if (this.config.comparison) {
+      buildComparisonTestReports = runComparisons(this.config.comparison, dataPlanner);
     }
     this.taskQueue.onIdle = (error) => {
       var _a2, _b2, _c2, _d2;
@@ -2794,17 +3941,17 @@ var SuiteRunner = class {
         (_b2 = (_a2 = this.callbacks).onError) == null ? void 0 : _b2.call(_a2, error);
       } else {
         const checkReport = buildCheckReport2();
-        let compareReport;
-        if (this.config.compare) {
-          compareReport = {
-            datasetReports: buildCompareDatasetReports(),
+        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,
-          compareReport
+          comparisonReport
         });
       }
     };
@@ -2813,10 +3960,10 @@ var SuiteRunner = class {
     const dataRequests = [...refDataPlan.requests, ...dataPlan.requests];
     const taskCount = dataRequests.length;
     if (taskCount === 0) {
-      let compareReport;
-      if (this.config.compare) {
-        compareReport = {
-          datasetReports: [],
+      let comparisonReport;
+      if (this.config.comparison) {
+        comparisonReport = {
+          testReports: [],
           perfReportL: this.perfStatsL.toReport(),
           perfReportR: this.perfStatsR.toReport()
         };
@@ -2827,7 +3974,7 @@ var SuiteRunner = class {
         checkReport: {
           groups: []
         },
-        compareReport
+        comparisonReport
       });
       return;
     }
@@ -2842,34 +3989,25 @@ var SuiteRunner = class {
     }
   }
   async processRequest(request) {
+    var _a, _b;
     const datasetKeySet = /* @__PURE__ */ new Set();
     for (const dataTask of request.dataTasks) {
       datasetKeySet.add(dataTask.datasetKey);
     }
     const datasetKeys = [...datasetKeySet];
-    const scenario = request.scenario;
-    let datasetsResultL;
-    let datasetsResultR;
-    switch (request.kind) {
-      case "check": {
-        const bundleModel = this.config.check.bundle.model;
-        datasetsResultR = await bundleModel.getDatasetsForScenario(scenario, datasetKeys);
-        break;
-      }
-      case "compare": {
-        const bundleModelL = this.config.compare.bundleL.model;
-        const bundleModelR = this.config.compare.bundleR.model;
-        const [resultL, resultR] = await Promise.all([
-          bundleModelL.getDatasetsForScenario(scenario, datasetKeys),
-          bundleModelR.getDatasetsForScenario(scenario, datasetKeys)
-        ]);
-        datasetsResultL = resultL;
-        datasetsResultR = resultR;
-        break;
+    async function getDatasets(bundleModel, scenarioSpec) {
+      if (bundleModel && scenarioSpec) {
+        return bundleModel.getDatasetsForScenario(scenarioSpec, datasetKeys);
+      } else {
+        return void 0;
       }
-      default:
-        assertNever10(request.kind);
     }
+    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 [datasetsResultL, datasetsResultR] = await Promise.all([
+      getDatasets(bundleModelL, request.scenarioSpecL),
+      getDatasets(bundleModelR, request.scenarioSpecR)
+    ]);
     if (datasetsResultL == null ? void 0 : datasetsResultL.modelRunTime) {
       this.perfStatsL.addRun(datasetsResultL == null ? void 0 : datasetsResultL.modelRunTime);
     }
@@ -2881,7 +4019,7 @@ var SuiteRunner = class {
     for (const dataTask of request.dataTasks) {
       const datasetL = datasetMapL == null ? void 0 : datasetMapL.get(dataTask.datasetKey);
       const datasetR = datasetMapR == null ? void 0 : datasetMapR.get(dataTask.datasetKey);
-      dataTask.dataFunc({
+      dataTask.dataAction({
         datasetL,
         datasetR
       });
@@ -2896,43 +4034,34 @@ function runSuite(config, callbacks, options) {
   };
 }
 
-// src/suite/suite-summary.ts
+// src/suite/suite-reporting.ts
 function suiteSummaryFromReport(suiteReport) {
   const checkSummary = checkSummaryFromReport(suiteReport.checkReport);
-  let compareSummary;
-  if (suiteReport.compareReport) {
-    compareSummary = compareSummaryFromReport(suiteReport.compareReport);
+  let comparisonSummary;
+  if (suiteReport.comparisonReport) {
+    comparisonSummary = comparisonSummaryFromReport(suiteReport.comparisonReport);
   }
   return {
     checkSummary,
-    compareSummary
+    comparisonSummary
   };
 }
 export {
   CheckDataCoordinator,
-  CompareDataCoordinator,
-  DatasetManager,
+  ComparisonDataCoordinator,
   PerfRunner,
   PerfStats,
-  ScenarioManager,
-  allInputsAtPositionScenario,
+  categorizeComparisonTestSummaries,
   checkReportFromSummary,
   checkSummaryFromReport,
-  compareDatasets,
-  compareSummaryFromReport,
+  comparisonSummaryFromReport,
   createConfig,
   datasetMessage,
   diffDatasets,
   diffGraphs,
-  inputAtPositionScenario,
-  inputAtValueScenario,
-  matrixScenarios,
-  positionSetting,
   predicateMessage,
   runSuite,
   scenarioMessage,
-  settingsScenario,
-  suiteSummaryFromReport,
-  valueSetting
+  suiteSummaryFromReport
 };
 //# sourceMappingURL=index.js.map