@sdeverywhere/check-core 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,10 +1,54 @@
+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));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
 // src/_shared/task-queue.ts
 var TaskQueue = class {
   constructor(processor) {
     this.processor = processor;
+    /** The queue of task keys, most recent at front. */
     this.taskKeyQueue = [];
+    /** The map of tasks. */
     this.taskMap = /* @__PURE__ */ new Map();
+    /** Whether tasks are being processed. */
     this.processing = false;
+    /** Whether `shutdown` has been called. */
     this.stopped = false;
   }
   addTask(key, input, onComplete) {
@@ -42,39 +86,41 @@ var TaskQueue = class {
       });
     }
   }
-  async processNextTask() {
-    var _a, _b;
-    const taskKey = this.taskKeyQueue.shift();
-    if (!taskKey) {
-      return;
-    }
-    const task = this.taskMap.get(taskKey);
-    if (task) {
-      this.taskMap.delete(taskKey);
-    } else {
-      return;
-    }
-    let output;
-    try {
-      output = await this.processor.process(task.input);
-    } catch (e) {
-      if (!this.stopped) {
-        this.shutdown();
-        (_a = this.onIdle) == null ? void 0 : _a.call(this, e);
+  processNextTask() {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const taskKey = this.taskKeyQueue.shift();
+      if (!taskKey) {
+        return;
       }
-      return;
-    }
-    task.onComplete(output);
-    if (this.taskKeyQueue.length > 0) {
-      setTimeout(() => {
-        this.processNextTask();
-      });
-    } else {
-      this.processing = false;
-      if (!this.stopped) {
-        (_b = this.onIdle) == null ? void 0 : _b.call(this);
+      const task = this.taskMap.get(taskKey);
+      if (task) {
+        this.taskMap.delete(taskKey);
+      } else {
+        return;
       }
-    }
+      let output;
+      try {
+        output = yield this.processor.process(task.input);
+      } catch (e) {
+        if (!this.stopped) {
+          this.shutdown();
+          (_a = this.onIdle) == null ? void 0 : _a.call(this, e);
+        }
+        return;
+      }
+      task.onComplete(output);
+      if (this.taskKeyQueue.length > 0) {
+        setTimeout(() => {
+          this.processNextTask();
+        });
+      } else {
+        this.processing = false;
+        if (!this.stopped) {
+          (_b = this.onIdle) == null ? void 0 : _b.call(this);
+        }
+      }
+    });
   }
 };
 
@@ -83,13 +129,13 @@ var CheckDataCoordinator = class {
   constructor(bundleModel) {
     this.bundleModel = bundleModel;
     this.taskQueue = new TaskQueue({
-      process: async (request) => {
-        const result = await this.bundleModel.getDatasetsForScenario(request.scenarioSpec, [request.datasetKey]);
+      process: (request) => __async(this, null, function* () {
+        const result = yield this.bundleModel.getDatasetsForScenario(request.scenarioSpec, [request.datasetKey]);
         const dataset = result.datasetMap.get(request.datasetKey);
         return {
           dataset
         };
-      }
+      })
     });
   }
   requestDataset(requestKey, scenarioSpec, datasetKey, onResponse) {
@@ -1642,6 +1688,24 @@ var CheckPlanner = class {
       dataRefs: this.dataRefs
     };
   }
+  /**
+   * Record any references to additional datasets contained in the given predicate.
+   * For example, if the predicate is:
+   * ```
+   *   gt:
+   *     dataset:
+   *       name: 'XYZ'
+   *     scenario:
+   *       inputs: all
+   *       at: default
+   * ```
+   * this will add a reference to the scenario/dataset pair so that the data can
+   * be fetched in a later stage.
+   *
+   * @param predicateSpec The predicate spec.
+   * @param checkScenario The scenario in which the dataset is being checked.
+   * @param checkDataset The dataset that is being checked.
+   */
   addDataRefs(predicateSpec, checkScenario, checkDataset) {
     let dataRefs;
     const addDataRef = (op) => {
@@ -1770,7 +1834,7 @@ var ComparisonDataCoordinator = class {
     this.bundleModelL = bundleModelL;
     this.bundleModelR = bundleModelR;
     this.taskQueue = new TaskQueue({
-      process: async (request) => {
+      process: (request) => __async(this, null, function* () {
         switch (request.kind) {
           case "dataset":
             return this.processDatasetRequest(request);
@@ -1779,44 +1843,52 @@ var ComparisonDataCoordinator = class {
           default:
             assertNever7(request);
         }
-      }
+      })
     });
   }
-  async processDatasetRequest(request) {
-    async function fetchDatasets(bundleModel, scenarioSpec) {
-      if (scenarioSpec) {
-        return bundleModel.getDatasetsForScenario(scenarioSpec, request.datasetKeys);
-      } else {
-        return void 0;
+  processDatasetRequest(request) {
+    return __async(this, null, function* () {
+      function fetchDatasets(bundleModel, scenarioSpec) {
+        return __async(this, null, function* () {
+          if (scenarioSpec) {
+            return bundleModel.getDatasetsForScenario(scenarioSpec, request.datasetKeys);
+          } else {
+            return void 0;
+          }
+        });
       }
-    }
-    const [resultL, resultR] = 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
-    };
+      const [resultL, resultR] = yield Promise.all([
+        fetchDatasets(this.bundleModelL, request.scenarioSpecL),
+        fetchDatasets(this.bundleModelR, request.scenarioSpecR)
+      ]);
+      return {
+        kind: "dataset",
+        datasetMapL: resultL == null ? void 0 : resultL.datasetMap,
+        datasetMapR: resultR == null ? void 0 : resultR.datasetMap
+      };
+    });
   }
-  async processGraphDataRequest(request) {
-    async function fetchGraphData(bundleModel, scenarioSpec) {
-      if (scenarioSpec) {
-        return bundleModel.getGraphDataForScenario(scenarioSpec, request.graphId);
-      } else {
-        return void 0;
+  processGraphDataRequest(request) {
+    return __async(this, null, function* () {
+      function fetchGraphData(bundleModel, scenarioSpec) {
+        return __async(this, null, function* () {
+          if (scenarioSpec) {
+            return bundleModel.getGraphDataForScenario(scenarioSpec, request.graphId);
+          } else {
+            return void 0;
+          }
+        });
       }
-    }
-    const [graphDataL, graphDataR] = await Promise.all([
-      fetchGraphData(this.bundleModelL, request.scenarioSpecL),
-      fetchGraphData(this.bundleModelR, request.scenarioSpecR)
-    ]);
-    return {
-      kind: "graph-data",
-      graphDataL,
-      graphDataR
-    };
+      const [graphDataL, graphDataR] = yield Promise.all([
+        fetchGraphData(this.bundleModelL, request.scenarioSpecL),
+        fetchGraphData(this.bundleModelR, request.scenarioSpecR)
+      ]);
+      return {
+        kind: "graph-data",
+        graphDataL,
+        graphDataR
+      };
+    });
   }
   requestDatasetMaps(requestKey, scenarioSpecL, scenarioSpecR, datasetKeys, onResponse) {
     const request = {
@@ -1867,25 +1939,17 @@ function diffDatasets(datasetL, datasetR) {
     for (const t of times) {
       const valueL = datasetL.get(t);
       if (valueL !== void 0) {
-        if (valueL < minValueL)
-          minValueL = valueL;
-        if (valueL > maxValueL)
-          maxValueL = valueL;
-        if (valueL < minValue)
-          minValue = valueL;
-        if (valueL > maxValue)
-          maxValue = valueL;
+        if (valueL < minValueL) minValueL = valueL;
+        if (valueL > maxValueL) maxValueL = valueL;
+        if (valueL < minValue) minValue = valueL;
+        if (valueL > maxValue) maxValue = valueL;
       }
       const valueR = datasetR.get(t);
       if (valueR !== void 0) {
-        if (valueR < minValueR)
-          minValueR = valueR;
-        if (valueR > maxValueR)
-          maxValueR = valueR;
-        if (valueR < minValue)
-          minValue = valueR;
-        if (valueR > maxValue)
-          maxValue = valueR;
+        if (valueR < minValueR) minValueR = valueR;
+        if (valueR > maxValueR) maxValueR = valueR;
+        if (valueR < minValue) minValue = valueR;
+        if (valueR > maxValue) maxValue = valueR;
       }
       if (valueL === void 0 || valueR === void 0) {
         continue;
@@ -2044,9 +2108,6 @@ function restoreFromTerseSummaries(comparisonConfig, terseSummaries) {
   return allTestSummaries;
 }
 
-// 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) {
@@ -2060,7 +2121,33 @@ function getBucketIndex(diffPct, thresholds) {
   return thresholds.length + 1;
 }
 
+// src/comparison/report/comparison-group-scores.ts
+function getScoresForTestSummaries(testSummaries, thresholds) {
+  const diffCountByBucket = Array(thresholds.length + 2).fill(0);
+  const totalMaxDiffByBucket = Array(thresholds.length + 2).fill(0);
+  let totalDiffCount = 0;
+  for (const testSummary of 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 {
+    totalDiffCount,
+    totalMaxDiffByBucket,
+    diffCountByBucket,
+    diffPercentByBucket
+  };
+}
+
 // src/comparison/report/comparison-grouping.ts
+import { assertNever as assertNever8 } from "assert-never";
 function categorizeComparisonTestSummaries(comparisonConfig, terseSummaries) {
   const allTestSummaries = restoreFromTerseSummaries(comparisonConfig, terseSummaries);
   const groupsByScenario = groupComparisonTestSummaries(allTestSummaries, "by-scenario");
@@ -2068,6 +2155,7 @@ function categorizeComparisonTestSummaries(comparisonConfig, terseSummaries) {
   const groupsByDataset = groupComparisonTestSummaries(allTestSummaries, "by-dataset");
   const byDataset = categorizeComparisonGroups(comparisonConfig, [...groupsByDataset.values()]);
   return {
+    allTestSummaries,
     byScenario,
     byDataset
   };
@@ -2109,7 +2197,7 @@ function categorizeComparisonGroups(comparisonConfig, allGroups) {
   function addSummaryForGroup(group, root, validInL, validInR) {
     let scores;
     if (validInL && validInR) {
-      scores = getScoresForGroup(group, comparisonConfig.thresholds);
+      scores = getScoresForTestSummaries(group.testSummaries, comparisonConfig.thresholds);
     }
     const groupSummary = {
       root,
@@ -2167,29 +2255,6 @@ function categorizeComparisonGroups(comparisonConfig, allGroups) {
     withoutDiffs
   };
 }
-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 {
-    totalDiffCount,
-    totalMaxDiffByBucket,
-    diffCountByBucket,
-    diffPercentByBucket
-  };
-}
 function sortDatasetGroupSummaries(summaries) {
   return summaries.sort((a, b) => {
     var _a, _b;
@@ -2249,47 +2314,6 @@ function compareScores(a, b) {
   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";
@@ -2306,13 +2330,36 @@ var comparison_schema_default = {
     $ref: "#/$defs/top_level_array_item"
   },
   $defs: {
+    //
+    // TOP-LEVEL
+    //
     top_level_array_item: {
       oneOf: [
         { $ref: "#/$defs/scenario_array_item" },
         { $ref: "#/$defs/scenario_group_array_item" },
+        { $ref: "#/$defs/graph_group_array_item" },
         { $ref: "#/$defs/view_group_array_item" }
       ]
     },
+    //
+    // DATASETS
+    //
+    dataset: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        name: {
+          type: "string"
+        },
+        source: {
+          type: "string"
+        }
+      },
+      required: ["name"]
+    },
+    //
+    // SCENARIOS
+    //
     scenario_array_item: {
       type: "object",
       additionalProperties: false,
@@ -2329,7 +2376,9 @@ var comparison_schema_default = {
         { $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_with_inputs_in_group_at_position' }
         { $ref: "#/$defs/scenario_preset" }
+        // { $ref: '#/$defs/scenario_expand_for_each_input_in_group' }
       ]
     },
     scenario_position: {
@@ -2469,6 +2518,9 @@ var comparison_schema_default = {
       },
       required: ["preset"]
     },
+    //
+    // SCENARIO GROUPS
+    //
     scenario_group_array_item: {
       type: "object",
       additionalProperties: false,
@@ -2544,7 +2596,63 @@ var comparison_schema_default = {
       },
       required: ["scenario_group_ref"]
     },
+    //
+    // GRAPHS
+    //
+    graphs_preset: {
+      type: "string",
+      enum: ["all"]
+    },
+    graphs_array: {
+      type: "array",
+      items: {
+        type: "string"
+      },
+      minItems: 1
+    },
+    graph_group_ref: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        graph_group_ref: {
+          type: "string"
+        }
+      },
+      required: ["graph_group_ref"]
+    },
+    //
+    // GRAPH GROUPS
+    //
+    graph_group_array_item: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        graph_group: {
+          $ref: "#/$defs/graph_group"
+        }
+      },
+      required: ["graph_group"]
+    },
+    graph_group: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        id: {
+          type: "string"
+        },
+        graphs: {
+          $ref: "#/$defs/graphs_array"
+        }
+      },
+      required: ["id", "graphs"]
+    },
+    //
+    // VIEWS
+    //
     view: {
+      oneOf: [{ $ref: "#/$defs/view_with_scenario" }, { $ref: "#/$defs/view_with_rows" }]
+    },
+    view_with_scenario: {
       type: "object",
       additionalProperties: false,
       properties: {
@@ -2559,24 +2667,106 @@ var comparison_schema_default = {
         },
         graphs: {
           $ref: "#/$defs/view_graphs"
+        },
+        graph_order: {
+          $ref: "#/$defs/view_graph_order"
         }
       },
-      required: ["scenario_ref", "graphs"]
+      required: ["scenario_ref"]
     },
-    view_graphs: {
-      oneOf: [{ $ref: "#/$defs/view_graphs_preset" }, { $ref: "#/$defs/view_graphs_array" }]
+    view_with_rows: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        title: {
+          type: "string"
+        },
+        subtitle: {
+          type: "string"
+        },
+        rows: {
+          $ref: "#/$defs/view_rows_array"
+        }
+      },
+      required: ["title", "rows"]
     },
-    view_graphs_preset: {
-      type: "string",
-      enum: ["all"]
+    view_rows_array: {
+      type: "array",
+      items: {
+        $ref: "#/$defs/view_rows_array_item"
+      },
+      minItems: 1
     },
-    view_graphs_array: {
+    view_rows_array_item: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        row: {
+          $ref: "#/$defs/view_row"
+        }
+      }
+    },
+    view_row: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        title: {
+          type: "string"
+        },
+        subtitle: {
+          type: "string"
+        },
+        boxes: {
+          $ref: "#/$defs/view_boxes_array"
+        }
+      },
+      required: ["title", "boxes"]
+    },
+    view_boxes_array: {
       type: "array",
       items: {
-        type: "string"
+        $ref: "#/$defs/view_boxes_array_item"
       },
       minItems: 1
     },
+    view_boxes_array_item: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        box: {
+          $ref: "#/$defs/view_box"
+        }
+      }
+    },
+    view_box: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        title: {
+          type: "string"
+        },
+        subtitle: {
+          type: "string"
+        },
+        dataset: {
+          $ref: "#/$defs/dataset"
+        },
+        scenario_ref: {
+          $ref: "#/$defs/scenario_ref_id"
+        }
+      },
+      required: ["title", "dataset", "scenario_ref"]
+    },
+    view_graphs: {
+      oneOf: [{ $ref: "#/$defs/graphs_preset" }, { $ref: "#/$defs/graphs_array" }, { $ref: "#/$defs/graph_group_ref" }]
+    },
+    view_graph_order: {
+      type: "string",
+      enum: ["default", "grouped-by-diffs"]
+    },
+    //
+    // VIEW GROUPS
+    //
     view_group_array_item: {
       type: "object",
       additionalProperties: false,
@@ -2649,6 +2839,7 @@ var comparison_schema_default = {
 function parseComparisonSpecs(specSource) {
   const scenarios = [];
   const scenarioGroups = [];
+  const graphGroups = [];
   const viewGroups = [];
   const ajv = new Ajv2();
   const validate = ajv.compile(comparison_schema_default);
@@ -2669,6 +2860,8 @@ function parseComparisonSpecs(specSource) {
         scenarios.push(scenarioSpecFromParsed(specItem.scenario));
       } else if ("scenario_group" in specItem) {
         scenarioGroups.push(scenarioGroupSpecFromParsed(specItem.scenario_group));
+      } else if ("graph_group" in specItem) {
+        graphGroups.push(graphGroupSpecFromParsed(specItem.graph_group));
       } else if ("view_group" in specItem) {
         viewGroups.push(viewGroupSpecFromParsed(specItem.view_group));
       }
@@ -2686,9 +2879,17 @@ ${error.message}`;
   return ok2({
     scenarios,
     scenarioGroups,
+    graphGroups,
     viewGroups
   });
 }
+function datasetSpecFromParsed(parsedDataset) {
+  return {
+    kind: "dataset",
+    name: parsedDataset.name,
+    source: parsedDataset.source
+  };
+}
 function scenarioSpecFromParsed(parsedScenario) {
   if (parsedScenario.preset === "matrix") {
     return {
@@ -2781,13 +2982,50 @@ function scenarioGroupRefSpecFromParsed(parsedGroupRef) {
     groupId: parsedGroupRef.scenario_group_ref
   };
 }
+function graphGroupSpecFromParsed(parsedGraphGroup) {
+  return {
+    kind: "graph-group",
+    id: parsedGraphGroup.id,
+    graphIds: parsedGraphGroup.graphs
+  };
+}
 function viewSpecFromParsed(parsedView) {
+  let scenarioId;
+  let rows;
+  if (parsedView.scenario_ref !== void 0) {
+    scenarioId = parsedView.scenario_ref;
+  } else if (parsedView.rows !== void 0) {
+    rows = parsedView.rows.map((item) => viewRowSpecFromParsed(item.row));
+  }
+  let graphs;
+  if (parsedView.graphs !== void 0) {
+    graphs = viewGraphsSpecFromParsed(parsedView.graphs);
+  }
   return {
     kind: "view",
     title: parsedView.title,
     subtitle: parsedView.subtitle,
-    scenarioId: parsedView.scenario_ref,
-    graphs: viewGraphsSpecFromParsed(parsedView.graphs)
+    scenarioId,
+    rows,
+    graphs,
+    graphOrder: parsedView.graph_order
+  };
+}
+function viewRowSpecFromParsed(parsedRow) {
+  return {
+    kind: "view-row",
+    title: parsedRow.title,
+    subtitle: parsedRow.subtitle,
+    boxes: parsedRow.boxes.map((item) => viewBoxSpecFromParsed(item.box))
+  };
+}
+function viewBoxSpecFromParsed(parsedBox) {
+  return {
+    kind: "view-box",
+    title: parsedBox.title,
+    subtitle: parsedBox.subtitle,
+    dataset: datasetSpecFromParsed(parsedBox.dataset),
+    scenarioId: parsedBox.scenario_ref
   };
 }
 function viewGraphsSpecFromParsed(parsedGraphs) {
@@ -2796,11 +3034,18 @@ function viewGraphsSpecFromParsed(parsedGraphs) {
       kind: "graphs-preset",
       preset: "all"
     };
-  } else {
+  } else if (Array.isArray(parsedGraphs)) {
     return {
       kind: "graphs-array",
       graphIds: parsedGraphs
     };
+  } else if ("graph_group_ref" in parsedGraphs) {
+    return {
+      kind: "graph-group-ref",
+      groupId: parsedGraphs.graph_group_ref
+    };
+  } else {
+    throw new Error("Invalid graphs spec in comparison view");
   }
 }
 function viewGroupSpecFromParsed(parsedViewGroup) {
@@ -2836,6 +3081,57 @@ function viewGroupSpecFromParsed(parsedViewGroup) {
 // src/comparison/config/resolve/comparison-resolver.ts
 import { assertNever as assertNever11 } from "assert-never";
 
+// src/bundle/model-inputs.ts
+var ModelInputs = class {
+  constructor(modelSpec) {
+    /** All inputs keyed by lookup name (lowercase variable name or alias). */
+    this.inputsByLookupName = /* @__PURE__ */ new Map();
+    /** All input ID aliases. */
+    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);
+      }
+    }
+  }
+  /**
+   * Return the set of `id XYZ` aliases for all input variables.
+   */
+  getAllInputIdAliases() {
+    return [...this.inputIdAliases];
+  }
+  /**
+   * Return the `InputVar` that matches the requested name (either by variable name or alias).
+   *
+   * @param name The variable name or alias to match.
+   */
+  getInputVarForName(name) {
+    return this.inputsByLookupName.get(name.toLowerCase());
+  }
+};
+
 // src/comparison/config/resolve/comparison-scenario-specs.ts
 import { assertNever as assertNever10 } from "assert-never";
 function scenarioSpecsFromSettings(settings) {
@@ -2860,28 +3156,34 @@ function scenarioSpecFromInputs(inputs, side) {
     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));
-    }
+    settings.push(inputSettingFromResolvedInputState(state));
   }
   return inputSettingsSpec(settings);
 }
+function inputSettingFromResolvedInputState(state) {
+  const varId = state.inputVar.varId;
+  if (state.position) {
+    return positionSetting(varId, state.position);
+  } else {
+    return valueSetting(varId, state.value);
+  }
+}
 
 // src/comparison/config/resolve/comparison-resolver.ts
-function resolveComparisonSpecs(modelInputsL, modelInputsR, specs) {
+function resolveComparisonSpecs(modelSpecL, modelSpecR, specs) {
   let key = 1;
   const genKey = () => {
     return `${key++}`;
   };
+  const modelInputsL = new ModelInputs(modelSpecL);
+  const modelInputsR = new ModelInputs(modelSpecR);
+  const modelOutputs = new ModelOutputs(modelSpecL, modelSpecR);
   const resolvedScenarios = new ResolvedScenarios();
-  for (const scenarioSpec of specs.scenarios) {
+  for (const scenarioSpec of specs.scenarios || []) {
     resolvedScenarios.add(resolveScenariosFromSpec(modelInputsL, modelInputsR, scenarioSpec, genKey));
   }
   const partiallyResolvedScenarioGroups = [];
-  for (const scenarioGroupSpec of specs.scenarioGroups) {
+  for (const scenarioGroupSpec of specs.scenarioGroups || []) {
     const scenariosForGroup = [];
     for (const scenarioItem of scenarioGroupSpec.scenarios) {
       if (scenarioItem.kind === "scenario-ref") {
@@ -2904,7 +3206,7 @@ function resolveComparisonSpecs(modelInputsL, modelInputsR, specs) {
       if (scenarioItem.kind === "scenario-ref") {
         const referencedScenario = resolvedScenarios.getScenarioForId(scenarioItem.scenarioId);
         if (referencedScenario) {
-          const resolvedScenario = { ...referencedScenario };
+          const resolvedScenario = __spreadValues({}, referencedScenario);
           if (scenarioItem.title) {
             resolvedScenario.title = scenarioItem.title;
           }
@@ -2929,9 +3231,21 @@ function resolveComparisonSpecs(modelInputsL, modelInputsR, specs) {
       scenarios: scenariosForGroup
     });
   }
+  const resolvedGraphGroups = new ResolvedGraphGroups();
+  for (const graphGroupSpec of specs.graphGroups || []) {
+    resolvedGraphGroups.add(graphGroupSpec);
+  }
   const resolvedViewGroups = [];
-  for (const viewGroupSpec of specs.viewGroups) {
-    const resolvedViewGroup = resolveViewGroupFromSpec(resolvedScenarios, resolvedScenarioGroups, viewGroupSpec);
+  for (const viewGroupSpec of specs.viewGroups || []) {
+    const resolvedViewGroup = resolveViewGroupFromSpec(
+      modelSpecL,
+      modelSpecR,
+      modelOutputs,
+      resolvedScenarios,
+      resolvedScenarioGroups,
+      resolvedGraphGroups,
+      viewGroupSpec
+    );
     resolvedViewGroups.push(resolvedViewGroup);
   }
   return {
@@ -2940,9 +3254,40 @@ function resolveComparisonSpecs(modelInputsL, modelInputsR, specs) {
     viewGroups: resolvedViewGroups
   };
 }
+var ModelOutputs = class {
+  constructor(modelSpecL, modelSpecR) {
+    this.modelSpecL = modelSpecL;
+    this.modelSpecR = modelSpecR;
+  }
+  getDatasetForName(name, source) {
+    function findOutputVar(modelSpec) {
+      for (const outputVar of modelSpec.outputVars.values()) {
+        if (outputVar.varName === name && outputVar.sourceName === source) {
+          return outputVar;
+        }
+      }
+      return void 0;
+    }
+    const outputVarR = findOutputVar(this.modelSpecR);
+    if (outputVarR) {
+      const datasetKey = outputVarR.datasetKey;
+      const outputVarL = this.modelSpecL.outputVars.get(datasetKey);
+      return {
+        kind: "dataset",
+        key: datasetKey,
+        outputVarL,
+        outputVarR
+      };
+    } else {
+      return void 0;
+    }
+  }
+};
 var ResolvedScenarios = class {
   constructor() {
+    /** The array of all resolved scenarios. */
     this.resolvedScenarios = [];
+    /** The set of resolved scenarios that include an ID, keyed by ID. */
     this.resolvedScenariosById = /* @__PURE__ */ new Map();
   }
   add(scenarios) {
@@ -2992,6 +3337,20 @@ function resolveScenariosFromSpec(modelInputsL, modelInputsR, scenarioSpec, genK
         )
       ];
     }
+    case "scenario-with-distinct-inputs": {
+      return [
+        resolveScenarioForDistinctInputSpecs(
+          modelInputsL,
+          modelInputsR,
+          genKey(),
+          scenarioSpec.id,
+          scenarioSpec.title,
+          scenarioSpec.subtitle,
+          scenarioSpec.inputsL,
+          scenarioSpec.inputsR
+        )
+      ];
+    }
     default:
       assertNever11(scenarioSpec);
   }
@@ -3068,6 +3427,59 @@ function resolveScenarioForInputSpecs(modelInputsL, modelInputsR, key, id, title
     specR
   };
 }
+function resolveScenarioForDistinctInputSpecs(modelInputsL, modelInputsR, key, id, title, subtitle, inputSpecsL, inputSpecsR) {
+  const inputsWithErrors = [];
+  const settingsL = [];
+  const settingsR = [];
+  function resolveInputSpec(side, modelInputs, inputSpec) {
+    let inputState;
+    switch (inputSpec.kind) {
+      case "input-at-position":
+        inputState = resolveInputForNameInModel(modelInputs, inputSpec.inputName, inputSpec.position);
+        break;
+      case "input-at-value":
+        inputState = resolveInputForNameInModel(modelInputs, inputSpec.inputName, inputSpec.value);
+        break;
+      default:
+        assertNever11(inputSpec);
+    }
+    if (inputState.error !== void 0) {
+      inputsWithErrors.push({
+        requestedName: inputSpec.inputName,
+        stateL: side === "left" ? inputState : {},
+        stateR: side === "right" ? inputState : {}
+      });
+    } else {
+      const inputSetting = inputSettingFromResolvedInputState(inputState);
+      if (side === "left") {
+        settingsL.push(inputSetting);
+      } else {
+        settingsR.push(inputSetting);
+      }
+    }
+  }
+  inputSpecsL.forEach((inputSpec) => resolveInputSpec("left", modelInputsL, inputSpec));
+  inputSpecsR.forEach((inputSpec) => resolveInputSpec("right", modelInputsR, inputSpec));
+  let specL;
+  let specR;
+  if (inputsWithErrors.length === 0) {
+    specL = inputSettingsSpec(settingsL);
+    specR = inputSettingsSpec(settingsR);
+  }
+  return {
+    kind: "scenario",
+    key,
+    id,
+    title,
+    subtitle,
+    settings: {
+      kind: "input-settings",
+      inputs: inputsWithErrors
+    },
+    specL,
+    specR
+  };
+}
 function resolveInputForName(modelInputsL, modelInputsR, inputName, at) {
   return {
     requestedName: inputName,
@@ -3143,7 +3555,9 @@ function inputValueAtPosition2(inputVar, position) {
 }
 var ResolvedScenarioGroups = class {
   constructor() {
+    /** The array of all resolved scenario groups. */
     this.resolvedGroups = [];
+    /** The set of resolved scenario groups that include an ID, keyed by ID. */
     this.resolvedGroupsById = /* @__PURE__ */ new Map();
   }
   add(group) {
@@ -3162,33 +3576,73 @@ var ResolvedScenarioGroups = class {
     return this.resolvedGroupsById.get(id);
   }
 };
-function resolveGraphsFromSpec(graphsSpec) {
+var ResolvedGraphGroups = class {
+  constructor() {
+    /** The set of resolved graph groups, keyed by ID. */
+    this.resolvedGroupsById = /* @__PURE__ */ new Map();
+  }
+  add(group) {
+    if (this.resolvedGroupsById.has(group.id)) {
+      throw new Error(`Multiple graph groups defined with the same id (${group.id})`);
+    }
+    this.resolvedGroupsById.set(group.id, group);
+  }
+  getGroupForId(id) {
+    return this.resolvedGroupsById.get(id);
+  }
+};
+function resolveGraphsFromSpec(modelSpecL, modelSpecR, resolvedGraphGroups, graphsSpec) {
   switch (graphsSpec.kind) {
-    case "graphs-preset":
-      return "all";
+    case "graphs-preset": {
+      switch (graphsSpec.preset) {
+        case "all": {
+          const graphIds = /* @__PURE__ */ new Set();
+          const addGraphIds = (modelSpec) => {
+            if (modelSpec.graphSpecs) {
+              for (const graphSpec of modelSpec.graphSpecs) {
+                graphIds.add(graphSpec.id);
+              }
+            }
+          };
+          addGraphIds(modelSpecL);
+          addGraphIds(modelSpecR);
+          return [...graphIds];
+        }
+        default:
+          assertNever11(graphsSpec.preset);
+      }
+    }
+    // eslint-disable-next-line no-fallthrough
     case "graphs-array":
       return graphsSpec.graphIds;
+    case "graph-group-ref": {
+      const groupSpec = resolvedGraphGroups.getGroupForId(graphsSpec.groupId);
+      if (groupSpec === void 0) {
+        throw new Error(`No graph group found for id ${graphsSpec.groupId}`);
+      }
+      return groupSpec.graphIds;
+    }
     default:
       assertNever11(graphsSpec);
   }
 }
-function resolveViewForScenarioId(resolvedScenarios, viewTitle, viewSubtitle, scenarioId, graphs) {
+function resolveViewForScenarioId(resolvedScenarios, viewTitle, viewSubtitle, scenarioId, graphIds, graphOrder) {
   const resolvedScenario = resolvedScenarios.getScenarioForId(scenarioId);
   if (resolvedScenario) {
-    return resolveViewForScenario(viewTitle, viewSubtitle, resolvedScenario, graphs);
+    return resolveViewForScenario(viewTitle, viewSubtitle, resolvedScenario, graphIds, graphOrder);
   } else {
     return unresolvedViewForScenarioId(viewTitle, viewSubtitle, scenarioId);
   }
 }
-function resolveViewForScenarioRefSpec(resolvedScenarios, refSpec, graphs) {
+function resolveViewForScenarioRefSpec(resolvedScenarios, refSpec, graphIds, graphOrder) {
   const resolvedScenario = resolvedScenarios.getScenarioForId(refSpec.scenarioId);
   if (resolvedScenario) {
-    return resolveViewForScenario(refSpec.title, refSpec.subtitle, resolvedScenario, graphs);
+    return resolveViewForScenario(refSpec.title, refSpec.subtitle, resolvedScenario, graphIds, graphOrder);
   } else {
     return unresolvedViewForScenarioId(void 0, void 0, refSpec.scenarioId);
   }
 }
-function resolveViewForScenario(viewTitle, viewSubtitle, resolvedScenario, graphs) {
+function resolveViewForScenario(viewTitle, viewSubtitle, resolvedScenario, graphIds, graphOrder) {
   if (viewTitle === void 0) {
     viewTitle = resolvedScenario.title;
     if (viewTitle === void 0) {
@@ -3203,15 +3657,83 @@ function resolveViewForScenario(viewTitle, viewSubtitle, resolvedScenario, graph
     title: viewTitle,
     subtitle: viewSubtitle,
     scenario: resolvedScenario,
-    graphs
+    graphIds,
+    graphOrder
+  };
+}
+function resolveViewBoxForSpec(modelOutputs, resolvedScenarios, boxSpec) {
+  const resolvedDataset = modelOutputs.getDatasetForName(boxSpec.dataset.name, boxSpec.dataset.source);
+  if (resolvedDataset === void 0) {
+    return {
+      kind: "unresolved-view-box",
+      datasetName: boxSpec.dataset.name,
+      datasetSource: boxSpec.dataset.source
+    };
+  }
+  const resolvedScenario = resolvedScenarios.getScenarioForId(boxSpec.scenarioId);
+  if (resolvedScenario === void 0) {
+    return {
+      kind: "unresolved-view-box",
+      scenarioId: boxSpec.scenarioId
+    };
+  }
+  return {
+    kind: "view-box",
+    title: boxSpec.title,
+    subtitle: boxSpec.subtitle,
+    dataset: resolvedDataset,
+    scenario: resolvedScenario
+  };
+}
+function resolveViewRowForSpec(modelOutputs, resolvedScenarios, rowSpec) {
+  const resolvedBoxes = [];
+  for (const boxSpec of rowSpec.boxes) {
+    const box = resolveViewBoxForSpec(modelOutputs, resolvedScenarios, boxSpec);
+    if (box.kind === "view-box") {
+      resolvedBoxes.push(box);
+    } else {
+      return box;
+    }
+  }
+  return {
+    kind: "view-row",
+    title: rowSpec.title,
+    subtitle: rowSpec.subtitle,
+    boxes: resolvedBoxes
   };
 }
-function unresolvedViewForScenarioId(viewTitle, viewSubtitle, scenarioId) {
+function resolveViewWithRowSpecs(modelOutputs, resolvedScenarios, viewTitle, viewSubtitle, rowSpecs) {
+  const resolvedRows = [];
+  for (const rowSpec of rowSpecs) {
+    const row = resolveViewRowForSpec(modelOutputs, resolvedScenarios, rowSpec);
+    if (row.kind === "view-row") {
+      resolvedRows.push(row);
+    } else {
+      return unresolvedViewForScenarioId(viewTitle, viewSubtitle, row.scenarioId, row.datasetName, row.datasetSource);
+    }
+  }
+  if (viewTitle === void 0) {
+    viewTitle = "Untitled view";
+  }
+  return {
+    kind: "view",
+    title: viewTitle,
+    subtitle: viewSubtitle,
+    rows: resolvedRows,
+    // TODO: The schema doesn't currently allow for graphs in a view that is defined
+    // with rows.  Probably we should have different view types to make this more clear.
+    graphIds: [],
+    graphOrder: "default"
+  };
+}
+function unresolvedViewForScenarioId(viewTitle, viewSubtitle, scenarioId, datasetName, datasetSource) {
   return {
     kind: "unresolved-view",
     title: viewTitle,
     subtitle: viewSubtitle,
-    scenarioId
+    scenarioId,
+    datasetName,
+    datasetSource
   };
 }
 function unresolvedViewForScenarioGroupId(viewTitle, viewSubtitle, scenarioGroupId) {
@@ -3222,29 +3744,46 @@ function unresolvedViewForScenarioGroupId(viewTitle, viewSubtitle, scenarioGroup
     scenarioGroupId
   };
 }
-function resolveViewGroupFromSpec(resolvedScenarios, resolvedScenarioGroups, viewGroupSpec) {
+function resolveViewGroupFromSpec(modelSpecL, modelSpecR, modelOutputs, resolvedScenarios, resolvedScenarioGroups, resolvedGraphGroups, 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
-        );
+        if (viewSpec.scenarioId) {
+          let graphIds;
+          if (viewSpec.graphs) {
+            graphIds = resolveGraphsFromSpec(modelSpecL, modelSpecR, resolvedGraphGroups, viewSpec.graphs);
+          } else {
+            graphIds = [];
+          }
+          return resolveViewForScenarioId(
+            resolvedScenarios,
+            viewSpec.title,
+            viewSpec.subtitle,
+            viewSpec.scenarioId,
+            graphIds,
+            viewSpec.graphOrder || "default"
+          );
+        } else {
+          return resolveViewWithRowSpecs(
+            modelOutputs,
+            resolvedScenarios,
+            viewSpec.title,
+            viewSpec.subtitle,
+            viewSpec.rows
+          );
+        }
       });
       break;
     }
     case "view-group-with-scenarios": {
-      const graphs = resolveGraphsFromSpec(viewGroupSpec.graphs);
+      const graphIds = resolveGraphsFromSpec(modelSpecL, modelSpecR, resolvedGraphGroups, viewGroupSpec.graphs);
+      const graphOrder = viewGroupSpec.graphOrder || "default";
       views = [];
       for (const refSpec of viewGroupSpec.scenarios) {
         switch (refSpec.kind) {
           case "scenario-ref":
-            views.push(resolveViewForScenarioRefSpec(resolvedScenarios, refSpec, graphs));
+            views.push(resolveViewForScenarioRefSpec(resolvedScenarios, refSpec, graphIds, graphOrder));
             break;
           case "scenario-group-ref": {
             const resolvedGroup = resolvedScenarioGroups.getGroupForId(refSpec.groupId);
@@ -3255,7 +3794,7 @@ function resolveViewGroupFromSpec(resolvedScenarios, resolvedScenarioGroups, vie
                     views.push(unresolvedViewForScenarioId(void 0, void 0, scenario.scenarioId));
                     break;
                   case "scenario":
-                    views.push(resolveViewForScenario(void 0, void 0, scenario, graphs));
+                    views.push(resolveViewForScenario(void 0, void 0, scenario, graphIds, graphOrder));
                     break;
                   default:
                     assertNever11(scenario);
@@ -3283,10 +3822,11 @@ function resolveViewGroupFromSpec(resolvedScenarios, resolvedScenarioGroups, vie
 }
 
 // src/comparison/config/comparison-config.ts
-function resolveComparisonSpecsFromSources(modelInputsL, modelInputsR, specSources) {
+function resolveComparisonSpecsFromSources(modelSpecL, modelSpecR, specSources) {
   const combinedSpecs = {
     scenarios: [],
     scenarioGroups: [],
+    graphGroups: [],
     viewGroups: []
   };
   for (const specSource of specSources) {
@@ -3303,11 +3843,12 @@ function resolveComparisonSpecsFromSources(modelInputsL, modelInputsR, specSourc
     } else {
       specs = specSource;
     }
-    combinedSpecs.scenarios.push(...specs.scenarios);
-    combinedSpecs.scenarioGroups.push(...specs.scenarioGroups);
-    combinedSpecs.viewGroups.push(...specs.viewGroups);
+    combinedSpecs.scenarios.push(...specs.scenarios || []);
+    combinedSpecs.scenarioGroups.push(...specs.scenarioGroups || []);
+    combinedSpecs.graphGroups.push(...specs.graphGroups || []);
+    combinedSpecs.viewGroups.push(...specs.viewGroups || []);
   }
-  return resolveComparisonSpecs(modelInputsL, modelInputsR, combinedSpecs);
+  return resolveComparisonSpecs(modelSpecL, modelSpecR, combinedSpecs);
 }
 
 // src/comparison/config/comparison-datasets.ts
@@ -3315,7 +3856,14 @@ function getComparisonDatasets(modelSpecL, modelSpecR, datasetOptions) {
   return new ComparisonDatasetsImpl(modelSpecL, modelSpecR, datasetOptions);
 }
 var ComparisonDatasetsImpl = class {
+  /**
+   * @param modelSpecL The model spec for the "left" bundle being compared.
+   * @param modelSpecR The model spec for the "right" bundle being compared.
+   * @param datasetOptions The custom configuration for the datasets to be compared.
+   */
   constructor(modelSpecL, modelSpecR, datasetOptions) {
+    this.modelSpecL = modelSpecL;
+    this.modelSpecR = modelSpecR;
     this.datasetOptions = datasetOptions;
     const renamedDatasetKeys = datasetOptions == null ? void 0 : datasetOptions.renamedDatasetKeys;
     const invertedRenamedKeys = /* @__PURE__ */ new Map();
@@ -3353,12 +3901,15 @@ var ComparisonDatasetsImpl = class {
       });
     }
   }
+  // from ComparisonDatasets interface
   getAllDatasets() {
     return this.allDatasets.values();
   }
+  // from ComparisonDatasets interface
   getDataset(datasetKey) {
     return this.allDatasets.get(datasetKey);
   }
+  // from ComparisonDatasets interface
   getDatasetKeysForScenario(scenario) {
     var _a;
     if (((_a = this.datasetOptions) == null ? void 0 : _a.datasetKeysForScenario) !== void 0) {
@@ -3371,7 +3922,47 @@ var ComparisonDatasetsImpl = class {
       }
     }
   }
+  // from ComparisonDatasets interface
+  getReferencePlotsForDataset(datasetKey, scenario) {
+    var _a;
+    if (((_a = this.datasetOptions) == null ? void 0 : _a.referencePlotsForDataset) !== void 0) {
+      const dataset = this.getDataset(datasetKey);
+      if (dataset !== void 0) {
+        return this.datasetOptions.referencePlotsForDataset(dataset, scenario);
+      }
+    }
+    return [];
+  }
+  // from ComparisonDatasets interface
+  getContextGraphIdsForDataset(datasetKey, scenario) {
+    var _a;
+    const dataset = this.getDataset(datasetKey);
+    if (dataset === void 0) {
+      return [];
+    }
+    if (((_a = this.datasetOptions) == null ? void 0 : _a.contextGraphIdsForDataset) !== void 0) {
+      return this.datasetOptions.contextGraphIdsForDataset(dataset, scenario);
+    } else {
+      return getContextGraphIdsForDataset(this.modelSpecL, this.modelSpecR, dataset);
+    }
+  }
 };
+function getContextGraphIdsForDataset(modelSpecL, modelSpecR, dataset) {
+  const contextGraphIds = /* @__PURE__ */ new Set();
+  function addGraphs(modelSpec, outputVar) {
+    for (const graphSpec of modelSpec.graphSpecs || []) {
+      for (const graphDatasetSpec of graphSpec.datasets) {
+        if (graphDatasetSpec.datasetKey === (outputVar == null ? void 0 : outputVar.datasetKey)) {
+          contextGraphIds.add(graphSpec.id);
+          break;
+        }
+      }
+    }
+  }
+  addGraphs(modelSpecL, dataset.outputVarL);
+  addGraphs(modelSpecR, dataset.outputVarR);
+  return [...contextGraphIds];
+}
 
 // src/comparison/config/comparison-scenarios.ts
 function getComparisonScenarios(scenarios) {
@@ -3384,9 +3975,17 @@ var ComparisonScenariosImpl = class {
       this.scenarioDefs.set(scenario.key, scenario);
     }
   }
+  /**
+   * Return all `ComparisonScenario` instances that are available for comparisons.
+   */
   getAllScenarios() {
     return this.scenarioDefs.values();
   }
+  /**
+   * Return the scenario definition for the given key.
+   *
+   * @param key The key for the scenario.
+   */
   getScenario(key) {
     return this.scenarioDefs.get(key);
   }
@@ -3413,11 +4012,11 @@ var PromiseQueue = class {
   }
   add(f) {
     return new Promise((resolve, reject) => {
-      const run = async () => {
+      const run = () => __async(this, null, function* () {
         this.runningCount++;
         const promise = f();
         try {
-          const result = await promise;
+          const result = yield promise;
           resolve(result);
         } catch (e) {
           reject(e);
@@ -3425,7 +4024,7 @@ var PromiseQueue = class {
           this.runningCount--;
           this.runNext();
         }
-      };
+      });
       if (this.runningCount < 1) {
         run();
       } else {
@@ -3444,81 +4043,82 @@ var PromiseQueue = class {
 };
 
 // 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 {
-    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
+function createConfig(options) {
+  return __async(this, null, function* () {
+    var _a;
+    const origCurrentBundle = yield loadSynchronized(options.current);
+    let currentBundle;
+    let comparisonConfig;
+    if (options.comparison === void 0) {
+      currentBundle = origCurrentBundle;
+    } else {
+      const baselineBundle = yield loadSynchronized(options.comparison.baseline);
+      const renamedDatasetKeys = (_a = options.comparison.datasets) == null ? void 0 : _a.renamedDatasetKeys;
+      const invertedRenamedKeys = /* @__PURE__ */ new Map();
+      renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.forEach((newKey, oldKey) => {
+        invertedRenamedKeys.set(newKey, oldKey);
+      });
+      const rightKeyForLeftKey = (leftKey) => {
+        return (renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.get(leftKey)) || leftKey;
+      };
+      const leftKeyForRightKey = (rightKey) => {
+        return invertedRenamedKeys.get(rightKey) || rightKey;
+      };
+      const origBundleModelR = origCurrentBundle.model;
+      const adjBundleModelR = {
+        modelSpec: origBundleModelR.modelSpec,
+        getDatasetsForScenario: (scenarioSpec, datasetKeys) => __async(this, null, function* () {
+          const rightKeys = datasetKeys.map(rightKeyForLeftKey);
+          const result = yield origBundleModelR.getDatasetsForScenario(scenarioSpec, rightKeys);
+          const mapWithRightKeys = result.datasetMap;
+          const mapWithLeftKeys = /* @__PURE__ */ new Map();
+          for (const [rightKey, dataset] of mapWithRightKeys.entries()) {
+            const leftKey = leftKeyForRightKey(rightKey);
+            mapWithLeftKeys.set(leftKey, dataset);
+          }
+          return {
+            datasetMap: mapWithLeftKeys,
+            modelRunTime: result.modelRunTime
+          };
+        }),
+        getGraphDataForScenario: origBundleModelR.getGraphDataForScenario.bind(origBundleModelR),
+        getGraphLinksForScenario: origBundleModelR.getGraphLinksForScenario.bind(origBundleModelR)
+      };
+      currentBundle = __spreadProps(__spreadValues({}, origCurrentBundle), {
+        model: adjBundleModelR
+      });
+      const modelSpecL = baselineBundle.model.modelSpec;
+      const modelSpecR = currentBundle.model.modelSpec;
+      const comparisonDefs = resolveComparisonSpecsFromSources(modelSpecL, modelSpecR, 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
     };
-    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
+    return {
+      check: checkConfig,
+      comparison: comparisonConfig
     };
-  }
-  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
-  };
+function loadSynchronized(sourceBundle) {
+  return __async(this, null, function* () {
+    const sourceModel = yield sourceBundle.bundle.initModel();
+    const synchronizedModel = synchronizedBundleModel(sourceModel);
+    return {
+      name: sourceBundle.name,
+      version: sourceBundle.bundle.version,
+      model: synchronizedModel
+    };
+  });
 }
 
 // src/perf/perf-runner.ts
@@ -3568,22 +4168,22 @@ var PerfRunner = class {
     this.mode = mode;
     const scenarioSpec = allInputsAtPositionSpec("at-default");
     this.taskQueue = new TaskQueue({
-      process: async (request) => {
+      process: (request) => __async(this, null, function* () {
         switch (request.kind) {
           case "left": {
-            const result = await bundleModelL.getDatasetsForScenario(scenarioSpec, []);
+            const result = yield bundleModelL.getDatasetsForScenario(scenarioSpec, []);
             return {
               runTimeL: result.modelRunTime
             };
           }
           case "right": {
-            const result = await bundleModelR.getDatasetsForScenario(scenarioSpec, []);
+            const result = yield bundleModelR.getDatasetsForScenario(scenarioSpec, []);
             return {
               runTimeR: result.modelRunTime
             };
           }
           case "both": {
-            const [resultL, resultR] = await Promise.all([
+            const [resultL, resultR] = yield Promise.all([
               bundleModelL.getDatasetsForScenario(scenarioSpec, []),
               bundleModelR.getDatasetsForScenario(scenarioSpec, [])
             ]);
@@ -3595,7 +4195,7 @@ var PerfRunner = class {
           default:
             assertNever12(request.kind);
         }
-      }
+      })
     });
   }
   start() {
@@ -3643,13 +4243,31 @@ var PerfRunner = class {
 
 // src/data/data-planner.ts
 var DataPlanner = class {
+  /**
+   * @param batchSize The maximum number of impl vars that can be fetched
+   * with a single request; this is usually the same as the number of
+   * normal model outputs.
+   */
   constructor(batchSize) {
     this.batchSize = batchSize;
+    /** Tasks that need to access both "left" and "right" models in parallel. */
     this.taskSetsLR = /* @__PURE__ */ new Map();
+    /** Tasks that only need to access the "left" model. */
     this.taskSetsL = /* @__PURE__ */ new Map();
+    /** Tasks that only need to access the "right" model. */
     this.taskSetsR = /* @__PURE__ */ new Map();
     this.complete = false;
   }
+  /**
+   * Add a request to the plan for the given scenario(s) and data task.
+   *
+   * @param scenarioSpecL The input scenario used to configure the "left" model, or undefined if no data
+   * is needed from the left model.
+   * @param scenarioSpecR The input scenario used to configure the "right" model, or undefined if no data
+   * is needed from the right model.
+   * @param datasetKey The key for the dataset to be fetched from each model for the given scenario.
+   * @param dataAction The action to be performed with the fetched datasets.
+   */
   addRequest(scenarioSpecL, scenarioSpecR, datasetKey, dataAction) {
     if (scenarioSpecL === void 0 && scenarioSpecR === void 0) {
       console.warn("WARNING: Both scenario specs are undefined for DataPlanner request, skipping");
@@ -3677,6 +4295,9 @@ var DataPlanner = class {
       dataAction
     });
   }
+  /**
+   * Build a plan that minimizes the number of data fetches needed.
+   */
   buildPlan() {
     if (this.complete) {
       throw new Error("DataPlanner.buildPlan() can only be called once");
@@ -3727,6 +4348,12 @@ var DataTaskSet = class {
     this.modelTasks = /* @__PURE__ */ new Map();
     this.modelImplTasks = /* @__PURE__ */ new Map();
   }
+  /**
+   * Add a task that will be performed when the data is fetched for the scenario(s)
+   * associated with this task set.
+   *
+   * @param dataTask A task that performs an action using the fetched dataset(s).
+   */
   addTask(dataTask) {
     let taskMap;
     if (dataTask.datasetKey.startsWith("ModelImpl")) {
@@ -3741,6 +4368,11 @@ var DataTaskSet = class {
     }
     tasks.push(dataTask);
   }
+  /**
+   * Add all tasks from the given set into this set.
+   *
+   * @param otherTaskSet The other task set that will be merged into this one.
+   */
   merge(otherTaskSet) {
     for (const tasks of otherTaskSet.modelTasks.values()) {
       for (const task of tasks) {
@@ -3753,6 +4385,12 @@ var DataTaskSet = class {
       }
     }
   }
+  /**
+   * Create one or more data requests that can be used to fetch data for the configured scenario(s).
+   *
+   * @param batchSize The maximum number of impl vars that can be fetched with a single request.
+   * This is usually the same as the number of normal model outputs.
+   */
   buildRequests(batchSize) {
     const dataRequests = [];
     if (this.modelTasks.size > 0) {
@@ -3988,42 +4626,46 @@ 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];
-    async function getDatasets(bundleModel, scenarioSpec) {
-      if (bundleModel && scenarioSpec) {
-        return bundleModel.getDatasetsForScenario(scenarioSpec, datasetKeys);
-      } else {
-        return void 0;
-      }
-    }
-    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);
-    }
-    if (datasetsResultR == null ? void 0 : datasetsResultR.modelRunTime) {
-      this.perfStatsR.addRun(datasetsResultR == null ? void 0 : datasetsResultR.modelRunTime);
-    }
-    const datasetMapL = datasetsResultL == null ? void 0 : datasetsResultL.datasetMap;
-    const datasetMapR = datasetsResultR == null ? void 0 : datasetsResultR.datasetMap;
-    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.dataAction({
-        datasetL,
-        datasetR
-      });
-    }
+  processRequest(request) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const datasetKeySet = /* @__PURE__ */ new Set();
+      for (const dataTask of request.dataTasks) {
+        datasetKeySet.add(dataTask.datasetKey);
+      }
+      const datasetKeys = [...datasetKeySet];
+      function getDatasets(bundleModel, scenarioSpec) {
+        return __async(this, null, function* () {
+          if (bundleModel && scenarioSpec) {
+            return bundleModel.getDatasetsForScenario(scenarioSpec, datasetKeys);
+          } else {
+            return void 0;
+          }
+        });
+      }
+      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] = yield 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);
+      }
+      if (datasetsResultR == null ? void 0 : datasetsResultR.modelRunTime) {
+        this.perfStatsR.addRun(datasetsResultR == null ? void 0 : datasetsResultR.modelRunTime);
+      }
+      const datasetMapL = datasetsResultL == null ? void 0 : datasetsResultL.datasetMap;
+      const datasetMapR = datasetsResultR == null ? void 0 : datasetsResultR.datasetMap;
+      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.dataAction({
+          datasetL,
+          datasetR
+        });
+      }
+    });
   }
 };
 function runSuite(config, callbacks, options) {
@@ -4059,6 +4701,7 @@ export {
   datasetMessage,
   diffDatasets,
   diffGraphs,
+  getScoresForTestSummaries,
   predicateMessage,
   runSuite,
   scenarioMessage,