@sdeverywhere/check-core 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -78,6 +78,7 @@ __export(src_exports, {
   datasetMessage: () => datasetMessage,
   diffDatasets: () => diffDatasets,
   diffGraphs: () => diffGraphs,
+  getScoresForTestSummaries: () => getScoresForTestSummaries,
   predicateMessage: () => predicateMessage,
   runSuite: () => runSuite,
   scenarioMessage: () => scenarioMessage,
@@ -1986,25 +1987,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;
@@ -2163,9 +2156,6 @@ function restoreFromTerseSummaries(comparisonConfig, terseSummaries) {
   return allTestSummaries;
 }
 
-// src/comparison/report/comparison-grouping.ts
-var import_assert_never8 = require("assert-never");
-
 // src/comparison/report/buckets.ts
 function getBucketIndex(diffPct, thresholds) {
   if (diffPct === 0) {
@@ -2179,7 +2169,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
+var import_assert_never8 = require("assert-never");
 function categorizeComparisonTestSummaries(comparisonConfig, terseSummaries) {
   const allTestSummaries = restoreFromTerseSummaries(comparisonConfig, terseSummaries);
   const groupsByScenario = groupComparisonTestSummaries(allTestSummaries, "by-scenario");
@@ -2187,6 +2203,7 @@ function categorizeComparisonTestSummaries(comparisonConfig, terseSummaries) {
   const groupsByDataset = groupComparisonTestSummaries(allTestSummaries, "by-dataset");
   const byDataset = categorizeComparisonGroups(comparisonConfig, [...groupsByDataset.values()]);
   return {
+    allTestSummaries,
     byScenario,
     byDataset
   };
@@ -2228,7 +2245,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,
@@ -2286,29 +2303,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;
@@ -2368,57 +2362,6 @@ function compareScores(a, b) {
   return 0;
 }
 
-// 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/parse/comparison-parser.ts
 var import_ajv2 = __toESM(require("ajv"), 1);
 var import_assert_never9 = __toESM(require("assert-never"), 1);
@@ -2442,10 +2385,27 @@ var comparison_schema_default = {
       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: {
@@ -2685,9 +2645,62 @@ 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: {
@@ -2702,24 +2715,103 @@ 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_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_graphs_array: {
+    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
     //
@@ -2795,6 +2887,7 @@ var comparison_schema_default = {
 function parseComparisonSpecs(specSource) {
   const scenarios = [];
   const scenarioGroups = [];
+  const graphGroups = [];
   const viewGroups = [];
   const ajv = new import_ajv2.default();
   const validate = ajv.compile(comparison_schema_default);
@@ -2815,6 +2908,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));
       }
@@ -2832,9 +2927,17 @@ ${error.message}`;
   return (0, import_neverthrow2.ok)({
     scenarios,
     scenarioGroups,
+    graphGroups,
     viewGroups
   });
 }
+function datasetSpecFromParsed(parsedDataset) {
+  return {
+    kind: "dataset",
+    name: parsedDataset.name,
+    source: parsedDataset.source
+  };
+}
 function scenarioSpecFromParsed(parsedScenario) {
   if (parsedScenario.preset === "matrix") {
     return {
@@ -2927,13 +3030,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) {
@@ -2942,11 +3082,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) {
@@ -2982,6 +3129,57 @@ function viewGroupSpecFromParsed(parsedViewGroup) {
 // src/comparison/config/resolve/comparison-resolver.ts
 var import_assert_never11 = require("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
 var import_assert_never10 = require("assert-never");
 function scenarioSpecsFromSettings(settings) {
@@ -3020,17 +3218,20 @@ function inputSettingFromResolvedInputState(state) {
 }
 
 // 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") {
@@ -3078,9 +3279,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 {
@@ -3089,6 +3302,35 @@ 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. */
@@ -3382,33 +3624,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:
+          (0, import_assert_never11.assertNever)(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:
       (0, import_assert_never11.assertNever)(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) {
@@ -3423,15 +3705,83 @@ function resolveViewForScenario(viewTitle, viewSubtitle, resolvedScenario, graph
     title: viewTitle,
     subtitle: viewSubtitle,
     scenario: resolvedScenario,
-    graphs
+    graphIds,
+    graphOrder
   };
 }
-function unresolvedViewForScenarioId(viewTitle, viewSubtitle, scenarioId) {
+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 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) {
@@ -3442,29 +3792,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);
@@ -3475,7 +3842,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:
                     (0, import_assert_never11.assertNever)(scenario);
@@ -3503,10 +3870,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) {
@@ -3523,11 +3891,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
@@ -3541,6 +3910,8 @@ var ComparisonDatasetsImpl = class {
    * @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();
@@ -3599,7 +3970,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) {
@@ -3726,16 +4137,15 @@ function createConfig(options) {
       });
       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);
+      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
+        viewGroups: comparisonDefs.viewGroups,
+        reportOptions: options.comparison.report
       };
     }
     const checkConfig = {
@@ -4341,6 +4751,7 @@ function suiteSummaryFromReport(suiteReport) {
   datasetMessage,
   diffDatasets,
   diffGraphs,
+  getScoresForTestSummaries,
   predicateMessage,
   runSuite,
   scenarioMessage,