@sdeverywhere/check-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2988 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CheckDataCoordinator: () => CheckDataCoordinator,
+  CompareDataCoordinator: () => CompareDataCoordinator,
+  DatasetManager: () => DatasetManager,
+  PerfRunner: () => PerfRunner,
+  PerfStats: () => PerfStats,
+  ScenarioManager: () => ScenarioManager,
+  allInputsAtPositionScenario: () => allInputsAtPositionScenario,
+  checkReportFromSummary: () => checkReportFromSummary,
+  checkSummaryFromReport: () => checkSummaryFromReport,
+  compareDatasets: () => compareDatasets,
+  compareSummaryFromReport: () => compareSummaryFromReport,
+  createConfig: () => createConfig,
+  datasetMessage: () => datasetMessage,
+  diffDatasets: () => diffDatasets,
+  diffGraphs: () => diffGraphs,
+  inputAtPositionScenario: () => inputAtPositionScenario,
+  inputAtValueScenario: () => inputAtValueScenario,
+  matrixScenarios: () => matrixScenarios,
+  positionSetting: () => positionSetting,
+  predicateMessage: () => predicateMessage,
+  runSuite: () => runSuite,
+  scenarioMessage: () => scenarioMessage,
+  settingsScenario: () => settingsScenario,
+  suiteSummaryFromReport: () => suiteSummaryFromReport,
+  valueSetting: () => valueSetting
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/_shared/scenario.ts
+var import_assert_never = require("assert-never");
+function positionSetting(inputVarId, position) {
+  return {
+    kind: "position",
+    inputVarId,
+    position
+  };
+}
+function valueSetting(inputVarId, value) {
+  return {
+    kind: "value",
+    inputVarId,
+    value
+  };
+}
+function settingsScenario(key, groupKey, settings) {
+  return {
+    kind: "settings",
+    key,
+    groupKey,
+    settings
+  };
+}
+function inputAtPositionScenario(inputVarId, groupKey, position) {
+  const key = keyForInputAtPosition(`input${inputVarId}`, position);
+  return settingsScenario(key, groupKey, [positionSetting(inputVarId, position)]);
+}
+function inputAtValueScenario(inputVarId, groupKey, value) {
+  const key = keyForInputAtValue(`input${inputVarId}`, value);
+  return settingsScenario(key, groupKey, [valueSetting(inputVarId, value)]);
+}
+function allInputsAtPositionScenario(position) {
+  return {
+    kind: "all-inputs",
+    key: keyForInputAtPosition("all_inputs", position),
+    groupKey: "all_inputs",
+    position
+  };
+}
+function matrixScenarios(inputVarIds) {
+  const scenarios = [];
+  scenarios.push(allInputsAtPositionScenario("at-default"));
+  scenarios.push(allInputsAtPositionScenario("at-minimum"));
+  scenarios.push(allInputsAtPositionScenario("at-maximum"));
+  for (const inputVarId of inputVarIds) {
+    scenarios.push(inputAtPositionScenario(inputVarId, inputVarId, "at-minimum"));
+    scenarios.push(inputAtPositionScenario(inputVarId, inputVarId, "at-maximum"));
+  }
+  return scenarios;
+}
+function keyForInputPosition(position) {
+  switch (position) {
+    case "at-default":
+      return "default";
+    case "at-minimum":
+      return "min";
+    case "at-maximum":
+      return "max";
+    default:
+      (0, import_assert_never.assertNever)(position);
+  }
+}
+function keyForInputAtPosition(inputKey, position) {
+  return `${inputKey}_at_${keyForInputPosition(position)}`;
+}
+function keyForInputAtValue(inputKey, value) {
+  return `${inputKey}_at_${value}`;
+}
+
+// src/_shared/task-queue.ts
+var TaskQueue = class {
+  constructor(processor) {
+    this.processor = processor;
+    this.taskKeyQueue = [];
+    this.taskMap = /* @__PURE__ */ new Map();
+    this.processing = false;
+    this.stopped = false;
+  }
+  addTask(key, input, onComplete) {
+    if (this.stopped) {
+      return;
+    }
+    if (this.taskMap.has(key)) {
+      throw new Error(`Task already added for key ${key}`);
+    }
+    this.taskKeyQueue.push(key);
+    this.taskMap.set(key, {
+      input,
+      onComplete
+    });
+    this.processTasksIfNeeded();
+  }
+  cancelTask(taskKey) {
+    const index = this.taskKeyQueue.indexOf(taskKey);
+    if (index >= 0) {
+      this.taskKeyQueue.splice(index, 1);
+    }
+    this.taskMap.delete(taskKey);
+  }
+  shutdown() {
+    this.stopped = true;
+    this.processing = false;
+    this.taskKeyQueue.length = 0;
+    this.taskMap.clear();
+  }
+  processTasksIfNeeded() {
+    if (!this.stopped && !this.processing) {
+      this.processing = true;
+      setTimeout(() => {
+        this.processNextTask();
+      });
+    }
+  }
+  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);
+      }
+      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);
+      }
+    }
+  }
+};
+
+// src/check/check-data-coordinator.ts
+var CheckDataCoordinator = class {
+  constructor(bundleModel) {
+    this.bundleModel = bundleModel;
+    this.taskQueue = new TaskQueue({
+      process: async (request) => {
+        const result = await this.bundleModel.getDatasetsForScenario(request.scenario, [request.datasetKey]);
+        const dataset = result.datasetMap.get(request.datasetKey);
+        return {
+          dataset
+        };
+      }
+    });
+  }
+  requestDataset(requestKey, scenario, datasetKey, onResponse) {
+    const request = {
+      scenario,
+      datasetKey
+    };
+    this.taskQueue.addTask(requestKey, request, (response) => {
+      onResponse(response.dataset);
+    });
+  }
+  cancelRequest(key) {
+    this.taskQueue.cancelTask(key);
+  }
+};
+
+// src/check/check-report.ts
+var import_assert_never3 = __toESM(require("assert-never"), 1);
+
+// src/check/check-predicate.ts
+var import_assert_never2 = __toESM(require("assert-never"), 1);
+function symbolForPredicateOp(op) {
+  switch (op) {
+    case "gt":
+      return ">";
+    case "gte":
+      return ">=";
+    case "lt":
+      return "<";
+    case "lte":
+      return "<=";
+    case "eq":
+      return "==";
+    case "approx":
+      return "\u2248";
+    default:
+      (0, import_assert_never2.default)(op);
+  }
+}
+
+// src/check/check-report.ts
+function buildCheckReport(checkPlan, checkResults) {
+  const groupReports = [];
+  for (const groupPlan of checkPlan.groups) {
+    const testReports = [];
+    for (const testPlan of groupPlan.tests) {
+      let testStatus = "passed";
+      const scenarioReports = [];
+      for (const scenarioPlan of testPlan.scenarios) {
+        let scenarioStatus = "passed";
+        if (scenarioPlan.checkScenario.scenario === void 0) {
+          testStatus = "error";
+          scenarioStatus = "error";
+        }
+        const datasetReports = [];
+        for (const datasetPlan of scenarioPlan.datasets) {
+          let datasetStatus = "passed";
+          if (datasetPlan.checkDataset.datasetKey === void 0) {
+            testStatus = "error";
+            scenarioStatus = "error";
+            datasetStatus = "error";
+          }
+          const predicateReports = [];
+          for (const predicatePlan of datasetPlan.predicates) {
+            const checkKey = predicatePlan.checkKey;
+            const checkResult = checkResults.get(checkKey);
+            if (checkResult) {
+              if (checkResult.status !== "passed") {
+                if (checkResult.status === "error") {
+                  testStatus = "error";
+                  scenarioStatus = "error";
+                  datasetStatus = "error";
+                } else if (checkResult.status === "failed" && testStatus !== "error") {
+                  testStatus = "failed";
+                  scenarioStatus = "failed";
+                  datasetStatus = "failed";
+                }
+              }
+              predicateReports.push(predicateReport(predicatePlan, checkKey, checkResult));
+            } else {
+              predicateReports.push(predicateReport(predicatePlan, checkKey, { status: "passed" }));
+            }
+          }
+          datasetReports.push({
+            checkDataset: datasetPlan.checkDataset,
+            status: datasetStatus,
+            predicates: predicateReports
+          });
+        }
+        scenarioReports.push({
+          checkScenario: scenarioPlan.checkScenario,
+          status: scenarioStatus,
+          datasets: datasetReports
+        });
+      }
+      testReports.push({
+        name: testPlan.name,
+        status: testStatus,
+        scenarios: scenarioReports
+      });
+    }
+    groupReports.push({
+      name: groupPlan.name,
+      tests: testReports
+    });
+  }
+  return {
+    groups: groupReports
+  };
+}
+function predicateReport(predicatePlan, checkKey, result) {
+  if (result.status === "error") {
+    return {
+      checkKey,
+      result,
+      opRefs: /* @__PURE__ */ new Map(),
+      opValues: []
+    };
+  }
+  const predicateSpec = predicatePlan.action.predicateSpec;
+  const opRefs = /* @__PURE__ */ new Map();
+  const opValues = [];
+  function addOp(op) {
+    var _a, _b;
+    const sym = symbolForPredicateOp(op);
+    const predOp = predicateSpec[op];
+    if (predOp !== void 0) {
+      let opRef;
+      let opValue;
+      if (typeof predOp === "number") {
+        const opConstantRef = {
+          kind: "constant",
+          value: predOp
+        };
+        opRef = opConstantRef;
+        opValue = `${sym} ${predOp}`;
+      } else {
+        const dataRef = (_a = predicatePlan.dataRefs) == null ? void 0 : _a.get(op);
+        if (!dataRef) {
+          return;
+        }
+        const opDataRef = {
+          kind: "data",
+          dataRef
+        };
+        opRef = opDataRef;
+        opValue = `${sym} '${dataRef.dataset.name}'`;
+        const refScenario = (_b = dataRef.scenario) == null ? void 0 : _b.scenario;
+        if (!refScenario) {
+          return;
+        }
+        if (predOp.scenario === "inherit") {
+          opValue += ` (w/ same scenario)`;
+        } else {
+          if (refScenario.kind === "all-inputs" && refScenario.position === "at-default") {
+            opValue += ` (w/ default scenario)`;
+          } else {
+            opValue += ` (w/ configured scenario)`;
+          }
+        }
+      }
+      if (op === "approx") {
+        const tolerance = predicateSpec.tolerance || 0.1;
+        opValue += ` \xB1${tolerance}`;
+      }
+      opRefs.set(op, opRef);
+      opValues.push(opValue);
+    }
+  }
+  addOp("gt");
+  addOp("gte");
+  addOp("lt");
+  addOp("lte");
+  addOp("eq");
+  addOp("approx");
+  if (opValues.length === 0) {
+    opValues.push("INVALID PREDICATE");
+  }
+  return {
+    checkKey,
+    result,
+    opRefs,
+    opValues,
+    time: predicateSpec.time,
+    tolerance: predicateSpec.tolerance
+  };
+}
+function scenarioMessage(scenario, bold) {
+  const checkScenario = scenario.checkScenario;
+  if (checkScenario.scenario === void 0) {
+    if (checkScenario.error) {
+      switch (checkScenario.error.kind) {
+        case "unknown-input-group":
+          return `error: input group ${bold(checkScenario.error.name)} is unknown`;
+        case "empty-input-group":
+          return `error: input group ${bold(checkScenario.error.name)} is empty`;
+        default:
+          (0, import_assert_never3.default)(checkScenario.error.kind);
+      }
+    } else {
+      const badInputNames = checkScenario.inputDescs.filter((d) => d.inputVar === void 0).map((d) => bold(d.name));
+      const label = badInputNames.length === 1 ? "input" : "inputs";
+      return `error: unknown ${label} ${badInputNames.join(", ")}`;
+    }
+  }
+  function positionName(position) {
+    switch (position) {
+      case "at-default":
+        return "default";
+      case "at-minimum":
+        return "minimum";
+      case "at-maximum":
+        return "maximum";
+      default:
+        (0, import_assert_never3.default)(position);
+    }
+  }
+  function inputMessage(inputDesc) {
+    let msg = bold(inputDesc.name);
+    if (inputDesc.position) {
+      msg += ` is at ${bold(positionName(inputDesc.position))}`;
+      if (inputDesc.value !== void 0) {
+        msg += ` (${inputDesc.value})`;
+      }
+    } else if (inputDesc.value !== void 0) {
+      msg += ` is ${bold(inputDesc.value.toString())}`;
+    }
+    return msg;
+  }
+  if (checkScenario.scenario.kind === "all-inputs") {
+    const position = checkScenario.scenario.position;
+    return `when ${bold("all inputs")} are at ${bold(positionName(position))}...`;
+  } else if (checkScenario.inputGroupName) {
+    let position = "at-default";
+    if (checkScenario.scenario.settings[0].kind === "position") {
+      position = checkScenario.scenario.settings[0].position;
+    }
+    const groupName = checkScenario.inputGroupName;
+    return `when all inputs in ${bold(groupName)} are at ${bold(positionName(position))}...`;
+  } else {
+    const inputMessages = checkScenario.inputDescs.map(inputMessage).join(" and ");
+    return `when ${inputMessages}...`;
+  }
+}
+function datasetMessage(dataset, bold) {
+  const checkDataset = dataset.checkDataset;
+  if (checkDataset.datasetKey === void 0) {
+    return `error: ${bold(checkDataset.name)} did not match any datasets`;
+  } else {
+    return `then ${bold(checkDataset.name)}...`;
+  }
+}
+function predicateMessage(predicate, bold) {
+  const result = predicate.result;
+  if (result.status === "error") {
+    if (result.message) {
+      return `error: ${predicate.result.message}`;
+    } else if (result.errorInfo) {
+      switch (result.errorInfo.kind) {
+        case "unknown-dataset":
+          return `error: referenced dataset ${bold(result.errorInfo.name)} is unknown`;
+        case "unknown-input":
+          return `error: referenced input ${bold(result.errorInfo.name)} is unknown`;
+        case "unknown-input-group":
+          return `error: referenced input group ${bold(result.errorInfo.name)} is unknown`;
+        case "empty-input-group":
+          return `error: referenced input group ${bold(result.errorInfo.name)} is empty`;
+        default:
+          (0, import_assert_never3.default)(result.errorInfo.kind);
+      }
+    } else {
+      return `unknown error`;
+    }
+  }
+  const predicateParts = predicate.opValues.map(bold).join(" and ");
+  let msg = `should be ${predicateParts}`;
+  if (predicate.time !== void 0) {
+    if (typeof predicate.time === "number") {
+      msg += ` in ${bold(predicate.time.toString())}`;
+    } else {
+      let minTime;
+      let maxTime;
+      let minIncl;
+      let maxIncl;
+      if (Array.isArray(predicate.time)) {
+        const timeSpec = predicate.time;
+        minTime = timeSpec[0];
+        maxTime = timeSpec[1];
+        minIncl = true;
+        maxIncl = true;
+      } else {
+        const timeSpec = predicate.time;
+        if (timeSpec.after_excl !== void 0) {
+          minTime = timeSpec.after_excl;
+          minIncl = false;
+        } else if (timeSpec.after_incl !== void 0) {
+          minTime = timeSpec.after_incl;
+          minIncl = true;
+        }
+        if (timeSpec.before_excl !== void 0) {
+          maxTime = timeSpec.before_excl;
+          maxIncl = false;
+        } else if (timeSpec.before_incl !== void 0) {
+          maxTime = timeSpec.before_incl;
+          maxIncl = true;
+        }
+      }
+      if (minTime !== void 0 && maxTime !== void 0) {
+        const prefix = minIncl ? "[" : "(";
+        const suffix = maxIncl ? "]" : ")";
+        const range = `${prefix}${minTime}, ${maxTime}${suffix}`;
+        msg += ` in ${bold(range)}`;
+      } else if (minTime !== void 0) {
+        const prefix = minIncl ? "in/after" : "after";
+        msg += ` ${prefix} ${bold(minTime.toString())}`;
+      } else if (maxTime !== void 0) {
+        const prefix = maxIncl ? "in/before" : "before";
+        msg += ` ${prefix} ${bold(maxTime.toString())}`;
+      }
+    }
+  }
+  if (predicate.result.status === "failed") {
+    if (predicate.result.failValue !== void 0) {
+      msg += ` but got ${bold(predicate.result.failValue.toString())}`;
+      if (predicate.result.failRefValue !== void 0) {
+        const failSym = symbolForPredicateOp(predicate.result.failOp);
+        const refValue = `${failSym} ${predicate.result.failRefValue.toString()}`;
+        msg += ` (expected ${bold(refValue)})`;
+      }
+    } else if (predicate.result.message) {
+      msg += ` but got ${bold(predicate.result.message)}`;
+    }
+    if (predicate.result.failTime !== void 0) {
+      msg += ` in ${bold(predicate.result.failTime.toString())}`;
+    }
+  } else if (predicate.result.status === "error" && predicate.result.message) {
+    msg += ` but got error: ${bold(predicate.result.message)}`;
+  }
+  return msg;
+}
+
+// src/check/check-summary.ts
+var import_assert_never6 = require("assert-never");
+
+// src/check/check-parser.ts
+var import_ajv = __toESM(require("ajv"), 1);
+var import_neverthrow = require("neverthrow");
+var import_yaml = __toESM(require("yaml"), 1);
+
+// src/check/check.schema.js
+var check_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "Model Check Test",
+  type: "array",
+  description: "A group of tests.",
+  items: {
+    $ref: "#/$defs/group"
+  },
+  $defs: {
+    group: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        describe: {
+          type: "string"
+        },
+        tests: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/test"
+          }
+        }
+      },
+      required: ["describe", "tests"]
+    },
+    test: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        it: {
+          type: "string"
+        },
+        scenarios: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/scenario"
+          },
+          minItems: 1
+        },
+        datasets: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/dataset"
+          },
+          minItems: 1
+        },
+        predicates: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/predicate"
+          },
+          minItems: 1
+        }
+      },
+      required: ["it", "datasets", "predicates"]
+    },
+    scenario: {
+      oneOf: [
+        { $ref: "#/$defs/scenario_with_input_at_position" },
+        { $ref: "#/$defs/scenario_with_input_at_value" },
+        { $ref: "#/$defs/scenario_with_multiple_input_settings" },
+        { $ref: "#/$defs/scenario_with_inputs_in_preset_at_position" },
+        { $ref: "#/$defs/scenario_with_inputs_in_group_at_position" },
+        { $ref: "#/$defs/scenario_preset" },
+        { $ref: "#/$defs/scenario_expand_for_each_input_in_group" }
+      ]
+    },
+    scenario_position: {
+      type: "string",
+      enum: ["min", "max", "default"]
+    },
+    scenario_with_input_at_position: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        with: {
+          type: "string"
+        },
+        at: {
+          $ref: "#/$defs/scenario_position"
+        }
+      },
+      required: ["with", "at"]
+    },
+    scenario_with_input_at_value: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        with: {
+          type: "string"
+        },
+        at: {
+          type: "number"
+        }
+      },
+      required: ["with", "at"]
+    },
+    scenario_input_at_position: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        input: {
+          type: "string"
+        },
+        at: {
+          $ref: "#/$defs/scenario_position"
+        }
+      },
+      required: ["input", "at"]
+    },
+    scenario_input_at_value: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        input: {
+          type: "string"
+        },
+        at: {
+          type: "number"
+        }
+      },
+      required: ["input", "at"]
+    },
+    scenario_input_setting: {
+      oneOf: [{ $ref: "#/$defs/scenario_input_at_position" }, { $ref: "#/$defs/scenario_input_at_value" }]
+    },
+    scenario_input_setting_array: {
+      type: "array",
+      items: {
+        $ref: "#/$defs/scenario_input_setting"
+      },
+      minItems: 1
+    },
+    scenario_with_multiple_input_settings: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        with: {
+          $ref: "#/$defs/scenario_input_setting_array"
+        }
+      },
+      required: ["with"]
+    },
+    scenario_with_inputs_in_preset_at_position: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        with_inputs: {
+          type: "string",
+          enum: ["all"]
+        },
+        at: {
+          $ref: "#/$defs/scenario_position"
+        }
+      },
+      required: ["with_inputs", "at"]
+    },
+    scenario_with_inputs_in_group_at_position: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        with_inputs_in: {
+          type: "string"
+        },
+        at: {
+          $ref: "#/$defs/scenario_position"
+        }
+      },
+      required: ["with_inputs_in", "at"]
+    },
+    scenario_preset: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        preset: {
+          type: "string",
+          enum: ["matrix"]
+        }
+      },
+      required: ["preset"]
+    },
+    scenario_expand_for_each_input_in_group: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        scenarios_for_each_input_in: {
+          type: "string"
+        },
+        at: {
+          $ref: "#/$defs/scenario_position"
+        }
+      },
+      required: ["scenarios_for_each_input_in", "at"]
+    },
+    dataset: {
+      oneOf: [{ $ref: "#/$defs/dataset_name" }, { $ref: "#/$defs/dataset_group" }, { $ref: "#/$defs/dataset_matching" }]
+    },
+    dataset_name: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        name: {
+          type: "string"
+        },
+        source: {
+          type: "string"
+        }
+      },
+      required: ["name"]
+    },
+    dataset_group: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        group: {
+          type: "string"
+        }
+      },
+      required: ["group"]
+    },
+    dataset_matching: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        matching: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            type: {
+              type: "string"
+            }
+          },
+          required: ["type"]
+        }
+      },
+      required: ["matching"]
+    },
+    predicate: {
+      type: "object",
+      oneOf: [
+        { $ref: "#/$defs/predicate_gt" },
+        { $ref: "#/$defs/predicate_gte" },
+        { $ref: "#/$defs/predicate_lt" },
+        { $ref: "#/$defs/predicate_lte" },
+        { $ref: "#/$defs/predicate_gt_lt" },
+        { $ref: "#/$defs/predicate_gt_lte" },
+        { $ref: "#/$defs/predicate_gte_lt" },
+        { $ref: "#/$defs/predicate_gte_lte" },
+        { $ref: "#/$defs/predicate_eq" },
+        { $ref: "#/$defs/predicate_approx" }
+      ]
+    },
+    predicate_gt: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        gt: { $ref: "#/$defs/predicate_ref" },
+        time: { $ref: "#/$defs/predicate_time" }
+      },
+      required: ["gt"]
+    },
+    predicate_gte: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        gte: { $ref: "#/$defs/predicate_ref" },
+        time: { $ref: "#/$defs/predicate_time" }
+      },
+      required: ["gte"]
+    },
+    predicate_lt: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        lt: { $ref: "#/$defs/predicate_ref" },
+        time: { $ref: "#/$defs/predicate_time" }
+      },
+      required: ["lt"]
+    },
+    predicate_lte: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        lte: { $ref: "#/$defs/predicate_ref" },
+        time: { $ref: "#/$defs/predicate_time" }
+      },
+      required: ["lte"]
+    },
+    predicate_gt_lt: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        gt: { $ref: "#/$defs/predicate_ref" },
+        lt: { $ref: "#/$defs/predicate_ref" },
+        time: { $ref: "#/$defs/predicate_time" }
+      },
+      required: ["gt", "lt"]
+    },
+    predicate_gt_lte: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        gt: { $ref: "#/$defs/predicate_ref" },
+        lte: { $ref: "#/$defs/predicate_ref" },
+        time: { $ref: "#/$defs/predicate_time" }
+      },
+      required: ["gt", "lte"]
+    },
+    predicate_gte_lt: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        gte: { $ref: "#/$defs/predicate_ref" },
+        lt: { $ref: "#/$defs/predicate_ref" },
+        time: { $ref: "#/$defs/predicate_time" }
+      },
+      required: ["gte", "lt"]
+    },
+    predicate_gte_lte: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        gte: { $ref: "#/$defs/predicate_ref" },
+        lte: { $ref: "#/$defs/predicate_ref" },
+        time: { $ref: "#/$defs/predicate_time" }
+      },
+      required: ["gte", "lte"]
+    },
+    predicate_eq: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        eq: { $ref: "#/$defs/predicate_ref" },
+        time: { $ref: "#/$defs/predicate_time" }
+      },
+      required: ["eq"]
+    },
+    predicate_approx: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        approx: { $ref: "#/$defs/predicate_ref" },
+        tolerance: { type: "number" },
+        time: { $ref: "#/$defs/predicate_time" }
+      },
+      required: ["approx"]
+    },
+    predicate_ref: {
+      oneOf: [{ $ref: "#/$defs/predicate_ref_constant" }, { $ref: "#/$defs/predicate_ref_data" }]
+    },
+    predicate_ref_constant: {
+      type: "number"
+    },
+    predicate_ref_data: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        dataset: { $ref: "#/$defs/predicate_ref_data_dataset" },
+        scenario: { $ref: "#/$defs/predicate_ref_data_scenario" }
+      },
+      required: ["dataset"]
+    },
+    predicate_ref_data_dataset: {
+      oneOf: [{ $ref: "#/$defs/dataset_name" }, { $ref: "#/$defs/predicate_ref_data_dataset_special" }]
+    },
+    predicate_ref_data_dataset_special: {
+      type: "string",
+      enum: ["inherit"]
+    },
+    predicate_ref_data_scenario: {
+      oneOf: [
+        { $ref: "#/$defs/scenario_with_input_at_position" },
+        { $ref: "#/$defs/scenario_with_input_at_value" },
+        { $ref: "#/$defs/scenario_with_multiple_input_settings" },
+        { $ref: "#/$defs/scenario_with_inputs_in_preset_at_position" },
+        { $ref: "#/$defs/scenario_with_inputs_in_group_at_position" },
+        { $ref: "#/$defs/predicate_ref_data_scenario_special" }
+      ]
+    },
+    predicate_ref_data_scenario_special: {
+      type: "string",
+      enum: ["inherit"]
+    },
+    predicate_time: {
+      oneOf: [
+        { $ref: "#/$defs/predicate_time_single" },
+        { $ref: "#/$defs/predicate_time_pair" },
+        { $ref: "#/$defs/predicate_time_gt" },
+        { $ref: "#/$defs/predicate_time_gte" },
+        { $ref: "#/$defs/predicate_time_lt" },
+        { $ref: "#/$defs/predicate_time_lte" },
+        { $ref: "#/$defs/predicate_time_gt_lt" },
+        { $ref: "#/$defs/predicate_time_gt_lte" },
+        { $ref: "#/$defs/predicate_time_gte_lt" },
+        { $ref: "#/$defs/predicate_time_gte_lte" }
+      ]
+    },
+    predicate_time_single: {
+      type: "number"
+    },
+    predicate_time_pair: {
+      type: "array",
+      items: [{ type: "number" }, { type: "number" }],
+      minItems: 2,
+      maxItems: 2
+    },
+    predicate_time_gt: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        after_excl: { type: "number" }
+      },
+      required: ["after_excl"]
+    },
+    predicate_time_gte: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        after_incl: { type: "number" }
+      },
+      required: ["after_incl"]
+    },
+    predicate_time_lt: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        before_excl: { type: "number" }
+      },
+      required: ["before_excl"]
+    },
+    predicate_time_lte: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        before_incl: { type: "number" }
+      },
+      required: ["before_incl"]
+    },
+    predicate_time_gt_lt: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        after_excl: { type: "number" },
+        before_excl: { type: "number" }
+      },
+      required: ["after_excl", "before_excl"]
+    },
+    predicate_time_gt_lte: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        after_excl: { type: "number" },
+        before_incl: { type: "number" }
+      },
+      required: ["after_excl", "before_incl"]
+    },
+    predicate_time_gte_lt: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        after_incl: { type: "number" },
+        before_excl: { type: "number" }
+      },
+      required: ["after_incl", "before_excl"]
+    },
+    predicate_time_gte_lte: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        after_incl: { type: "number" },
+        before_incl: { type: "number" }
+      },
+      required: ["after_incl", "before_incl"]
+    }
+  }
+};
+
+// src/check/check-parser.ts
+function parseTestYaml(yamlStrings) {
+  const groups = [];
+  const ajv = new import_ajv.default();
+  const validate = ajv.compile(check_schema_default);
+  for (const yamlString of yamlStrings) {
+    const parsed = import_yaml.default.parse(yamlString);
+    if (validate(parsed)) {
+      for (const group of parsed) {
+        groups.push(group);
+      }
+    } else {
+      let msg = "Failed to parse YAML tests";
+      for (const error of validate.errors || []) {
+        if (error.message) {
+          msg += `
+${error.message}`;
+        }
+      }
+      return (0, import_neverthrow.err)(new Error(msg));
+    }
+  }
+  const checkSpec = {
+    groups
+  };
+  return (0, import_neverthrow.ok)(checkSpec);
+}
+
+// src/check/check-planner.ts
+var import_assert_never5 = __toESM(require("assert-never"), 1);
+
+// src/check/check-func.ts
+var passed = {
+  status: "passed"
+};
+var gt = (a, b) => a > b;
+var gte = (a, b) => a >= b;
+var lt = (a, b) => a < b;
+var lte = (a, b) => a <= b;
+var eq = (a, b) => a === b;
+var approx = (tolerance) => {
+  const f = (a, b) => {
+    return a >= b - tolerance && a <= b + tolerance;
+  };
+  return f;
+};
+function checkFunc(spec) {
+  function addCheckValueFunc(op, compareFunc) {
+    const refSpec = spec[op];
+    if (refSpec === void 0) {
+      return;
+    }
+    if (typeof refSpec === "number") {
+      checkValueFuncs.push((value, time) => {
+        if (compareFunc(value, refSpec)) {
+          return passed;
+        } else {
+          return {
+            status: "failed",
+            failValue: value,
+            failTime: time
+          };
+        }
+      });
+    } else {
+      checkValueFuncs.push((value, time, refDatasets) => {
+        const refDataset = refDatasets == null ? void 0 : refDatasets.get(op);
+        if (refDataset === void 0) {
+          return {
+            status: "error",
+            message: "unhandled data reference"
+          };
+        }
+        const refValue = refDataset.get(time);
+        if (refValue !== void 0) {
+          if (compareFunc(value, refValue)) {
+            return passed;
+          } else {
+            return {
+              status: "failed",
+              failValue: value,
+              failOp: op,
+              failRefValue: refValue,
+              failTime: time
+            };
+          }
+        } else {
+          return {
+            status: "failed",
+            message: "no reference value",
+            failTime: time
+          };
+        }
+      });
+    }
+  }
+  const checkValueFuncs = [];
+  addCheckValueFunc("gt", gt);
+  addCheckValueFunc("gte", gte);
+  addCheckValueFunc("lt", lt);
+  addCheckValueFunc("lte", lte);
+  addCheckValueFunc("eq", eq);
+  if (spec.approx !== void 0) {
+    const tolerance = spec.tolerance || 0.1;
+    addCheckValueFunc("approx", approx(tolerance));
+  }
+  const checkValue = (value, time, refDatasets) => {
+    for (const f of checkValueFuncs) {
+      const result = f(value, time, refDatasets);
+      if (result.status !== "passed") {
+        return result;
+      }
+    }
+    return passed;
+  };
+  if (spec.time !== void 0 && typeof spec.time === "number") {
+    const time = spec.time;
+    return (dataset, refDatasets) => {
+      const value = dataset.get(time);
+      if (value !== void 0) {
+        return checkValue(value, time, refDatasets);
+      } else {
+        return {
+          status: "failed",
+          message: "no value",
+          failTime: time
+        };
+      }
+    };
+  } else {
+    let checkTime;
+    if (spec.time !== void 0) {
+      if (Array.isArray(spec.time)) {
+        const timeSpec = spec.time;
+        checkTime = (time) => time >= timeSpec[0] && time <= timeSpec[1];
+      } else {
+        const checkTimeFuncs = [];
+        const timeSpec = spec.time;
+        if (timeSpec.after_excl !== void 0) {
+          checkTimeFuncs.push((time) => time > timeSpec.after_excl);
+        }
+        if (timeSpec.after_incl !== void 0) {
+          checkTimeFuncs.push((time) => time >= timeSpec.after_incl);
+        }
+        if (timeSpec.before_excl !== void 0) {
+          checkTimeFuncs.push((time) => time < timeSpec.before_excl);
+        }
+        if (timeSpec.before_incl !== void 0) {
+          checkTimeFuncs.push((time) => time <= timeSpec.before_incl);
+        }
+        checkTime = (time) => {
+          for (const f of checkTimeFuncs) {
+            if (!f(time)) {
+              return false;
+            }
+          }
+          return true;
+        };
+      }
+    } else {
+      checkTime = () => true;
+    }
+    return (dataset, refDatasets) => {
+      for (const [time, value] of dataset) {
+        if (checkTime(time)) {
+          const result = checkValue(value, time, refDatasets);
+          if (result.status !== "passed") {
+            return result;
+          }
+        }
+      }
+      return passed;
+    };
+  }
+}
+
+// src/check/check-action.ts
+function actionForPredicate(predicateSpec) {
+  return {
+    predicateSpec,
+    run: checkFunc(predicateSpec)
+  };
+}
+
+// src/_shared/combo.ts
+function cartesianProductOf(arr) {
+  return arr.reduce((a, b) => {
+    return a.map((x) => b.map((y) => x.concat([y]))).reduce((v, w) => v.concat(w), []);
+  }, [[]]);
+}
+
+// src/check/check-dataset.ts
+function expandDatasets(modelSpec, datasetSpec) {
+  var _a;
+  let result;
+  if (datasetSpec.name) {
+    result = matchByName(modelSpec, datasetSpec.name, datasetSpec.source);
+  } else if (datasetSpec.group) {
+    result = matchByGroup(modelSpec, datasetSpec.group);
+  } else if ((_a = datasetSpec.matching) == null ? void 0 : _a.type) {
+    result = matchByType(modelSpec, datasetSpec.matching.type);
+  }
+  if (result.error) {
+    return [
+      {
+        name: result.error.name,
+        error: result.error.kind
+      }
+    ];
+  }
+  const matches = result.matches;
+  const checkDatasets = [];
+  for (const match of matches) {
+    if (match.outputVar) {
+      checkDatasets.push({
+        datasetKey: match.datasetKey,
+        name: match.outputVar.varName
+      });
+    } else if (match.implVar) {
+      const implVar = match.implVar;
+      if (implVar.dimensions.length > 0) {
+        const baseDatasetKey = match.datasetKey;
+        const subscripts = [...implVar.dimensions.map((dim) => dim.subscripts)];
+        const subscriptCombos = cartesianProductOf(subscripts);
+        for (const subscriptCombo of subscriptCombos) {
+          const subIdParts = subscriptCombo.map((sub) => `[${sub.id}]`).join("");
+          const subNameParts = subscriptCombo.map((sub) => sub.name).join(",");
+          checkDatasets.push({
+            datasetKey: `${baseDatasetKey}${subIdParts}`,
+            name: `${implVar.varName}[${subNameParts}]`
+          });
+        }
+      } else {
+        checkDatasets.push({
+          datasetKey: match.datasetKey,
+          name: implVar.varName
+        });
+      }
+    }
+  }
+  return checkDatasets;
+}
+function matchByName(modelSpec, datasetName, datasetSource) {
+  var _a;
+  const varNameToMatch = datasetName.toLowerCase();
+  const sourceToMatch = datasetSource == null ? void 0 : datasetSource.toLowerCase();
+  for (const [datasetKey, outputVar] of modelSpec.outputVars) {
+    if (((_a = outputVar.sourceName) == null ? void 0 : _a.toLowerCase()) === sourceToMatch && outputVar.varName.toLowerCase() === varNameToMatch) {
+      return {
+        matches: [
+          {
+            datasetKey,
+            outputVar
+          }
+        ]
+      };
+    }
+  }
+  for (const [datasetKey, implVar] of modelSpec.implVars) {
+    if (implVar.varName.toLowerCase() === varNameToMatch) {
+      return {
+        matches: [
+          {
+            datasetKey,
+            implVar
+          }
+        ]
+      };
+    }
+  }
+  return {
+    matches: [],
+    error: {
+      kind: "no-matches-for-dataset",
+      name: datasetName
+    }
+  };
+}
+function matchByGroup(modelSpec, groupName) {
+  const groupToMatch = groupName.toLowerCase();
+  let matchedGroupName;
+  let matchedGroupDatasetKeys;
+  for (const [group, datasetKeys] of modelSpec.datasetGroups) {
+    if (group.toLowerCase() === groupToMatch) {
+      matchedGroupName = group;
+      matchedGroupDatasetKeys = datasetKeys;
+      break;
+    }
+  }
+  if (matchedGroupName === void 0) {
+    return {
+      matches: [],
+      error: {
+        kind: "no-matches-for-group",
+        name: groupName
+      }
+    };
+  }
+  const matches = [];
+  for (const datasetKey of matchedGroupDatasetKeys) {
+    const outputVar = modelSpec.outputVars.get(datasetKey);
+    if (outputVar) {
+      matches.push({
+        datasetKey,
+        outputVar
+      });
+      continue;
+    }
+    const implVar = modelSpec.implVars.get(datasetKey);
+    if (implVar) {
+      matches.push({
+        datasetKey,
+        implVar
+      });
+      continue;
+    }
+    return {
+      matches: [],
+      error: {
+        kind: "no-matches-for-dataset",
+        name: datasetKey
+      }
+    };
+  }
+  if (matches.length === 0) {
+    return {
+      matches: [],
+      error: {
+        kind: "no-matches-for-group",
+        name: matchedGroupName
+      }
+    };
+  }
+  return {
+    matches
+  };
+}
+function matchByType(modelSpec, varTypeToMatch) {
+  const matches = [];
+  for (const [datasetKey, implVar] of modelSpec.implVars) {
+    if (implVar.varType === varTypeToMatch) {
+      matches.push({
+        datasetKey,
+        implVar
+      });
+    }
+  }
+  if (matches.length === 0) {
+    return {
+      matches: [],
+      error: {
+        kind: "no-matches-for-type",
+        name: varTypeToMatch
+      }
+    };
+  }
+  return {
+    matches
+  };
+}
+
+// src/check/check-scenario.ts
+var import_assert_never4 = __toESM(require("assert-never"), 1);
+function expandScenarios(modelSpec, scenarioSpecs, simplify) {
+  if (scenarioSpecs.length === 0) {
+    const scenarioSpec = {
+      with_inputs: "all",
+      at: "default"
+    };
+    return checkScenariosFromSpec(modelSpec, scenarioSpec, simplify);
+  }
+  const checkScenarios = [];
+  for (const scenarioSpec of scenarioSpecs) {
+    checkScenarios.push(...checkScenariosFromSpec(modelSpec, scenarioSpec, simplify));
+  }
+  return checkScenarios;
+}
+function inputPosition(position) {
+  switch (position) {
+    case "default":
+      return "at-default";
+    case "min":
+      return "at-minimum";
+    case "max":
+      return "at-maximum";
+    default:
+      return void 0;
+  }
+}
+function inputValueAtPosition(inputVar, position) {
+  switch (position) {
+    case "at-default":
+      return inputVar.defaultValue;
+    case "at-minimum":
+      return inputVar.minValue;
+    case "at-maximum":
+      return inputVar.maxValue;
+    default:
+      (0, import_assert_never4.default)(position);
+  }
+}
+function inputDescAtPosition(inputVar, position) {
+  return {
+    name: inputVar.varName,
+    inputVar,
+    position,
+    value: inputValueAtPosition(inputVar, position)
+  };
+}
+function inputDescAtValue(inputVar, value) {
+  return {
+    name: inputVar.varName,
+    inputVar,
+    value
+  };
+}
+function inputDescForVar(inputVar, at) {
+  if (typeof at === "number") {
+    const value = at;
+    return inputDescAtValue(inputVar, value);
+  } else {
+    const position = inputPosition(at);
+    return inputDescAtPosition(inputVar, position);
+  }
+}
+function inputDescForName(modelSpec, inputName, at) {
+  const inputNameToMatch = inputName.toLowerCase();
+  const inputVar = [...modelSpec.inputVars.values()].find((inputVar2) => {
+    return inputVar2.varName.toLowerCase() === inputNameToMatch;
+  });
+  if (inputVar) {
+    return inputDescForVar(inputVar, at);
+  } else {
+    return {
+      name: inputName
+    };
+  }
+}
+function groupForName(modelSpec, groupName) {
+  const groupToMatch = groupName.toLowerCase();
+  for (const [group, inputVars] of modelSpec.inputGroups) {
+    if (group.toLowerCase() === groupToMatch) {
+      return [group, inputVars];
+    }
+  }
+  return void 0;
+}
+function errorScenarioForInputGroup(kind, groupName) {
+  return {
+    inputDescs: [],
+    error: {
+      kind,
+      name: groupName
+    }
+  };
+}
+function checkScenarioWithAllInputsAtPosition(position) {
+  const scenario = allInputsAtPositionScenario(position);
+  return {
+    scenario,
+    inputDescs: []
+  };
+}
+function checkScenarioWithInputAtPosition(inputVar, position) {
+  const varId = inputVar.varId;
+  const scenario = inputAtPositionScenario(varId, varId, position);
+  return {
+    scenario,
+    inputDescs: [inputDescAtPosition(inputVar, position)]
+  };
+}
+function checkScenarioForInputDescs(groupName, inputDescs) {
+  let scenario;
+  if (inputDescs.every((desc) => desc.inputVar !== void 0)) {
+    const settings = [];
+    const keyParts = [];
+    for (const inputDesc of inputDescs) {
+      const varId = inputDesc.inputVar.varId;
+      if (inputDesc.position) {
+        settings.push(positionSetting(varId, inputDesc.position));
+        keyParts.push(keyForInputAtPosition(varId, inputDesc.position));
+      } else {
+        settings.push(valueSetting(varId, inputDesc.value));
+        keyParts.push(keyForInputAtValue(varId, inputDesc.value));
+      }
+    }
+    if (settings.length === 1) {
+      const scenarioKey = `input${keyParts[0]}`;
+      const groupKey = settings[0].inputVarId;
+      scenario = settingsScenario(scenarioKey, groupKey, settings);
+    } else if (settings.length > 1) {
+      let scenarioKey;
+      let groupKey;
+      if (groupName) {
+        scenarioKey = `group_${groupName.toLowerCase().replace(/ /g, "_")}`;
+        groupKey = scenarioKey;
+      } else {
+        scenarioKey = "multi" + keyParts.join("_");
+        groupKey = scenarioKey;
+      }
+      scenario = settingsScenario(scenarioKey, groupKey, settings);
+    }
+  } else {
+    scenario = void 0;
+  }
+  return {
+    scenario,
+    inputGroupName: groupName,
+    inputDescs
+  };
+}
+function checkScenarioForInputSpecs(modelSpec, inputSpecs) {
+  const inputDescs = inputSpecs.map((inputSpec) => {
+    return inputDescForName(modelSpec, inputSpec.input, inputSpec.at);
+  });
+  return checkScenarioForInputDescs(void 0, inputDescs);
+}
+function checkScenarioMatrix(modelSpec, simplify) {
+  const checkScenarios = [];
+  checkScenarios.push(checkScenarioWithAllInputsAtPosition("at-default"));
+  if (!simplify) {
+    checkScenarios.push(checkScenarioWithAllInputsAtPosition("at-minimum"));
+    checkScenarios.push(checkScenarioWithAllInputsAtPosition("at-maximum"));
+    for (const inputVar of modelSpec.inputVars.values()) {
+      checkScenarios.push(checkScenarioWithInputAtPosition(inputVar, "at-minimum"));
+      checkScenarios.push(checkScenarioWithInputAtPosition(inputVar, "at-maximum"));
+    }
+  }
+  return checkScenarios;
+}
+function checkScenarioWithAllInputsInGroupAtPosition(modelSpec, groupName, position) {
+  const result = groupForName(modelSpec, groupName);
+  if (result === void 0) {
+    return errorScenarioForInputGroup("unknown-input-group", groupName);
+  }
+  const [matchedGroupName, inputVars] = result;
+  if (inputVars.length === 0) {
+    return errorScenarioForInputGroup("empty-input-group", matchedGroupName);
+  }
+  const inputDescs = [];
+  for (const inputVar of inputVars) {
+    inputDescs.push(inputDescForVar(inputVar, position));
+  }
+  return checkScenarioForInputDescs(matchedGroupName, inputDescs);
+}
+function checkScenariosForEachInputInGroup(modelSpec, groupName, position) {
+  const result = groupForName(modelSpec, groupName);
+  if (result === void 0) {
+    return [errorScenarioForInputGroup("unknown-input-group", groupName)];
+  }
+  const [matchedGroupName, inputVars] = result;
+  if (inputVars.length === 0) {
+    return [errorScenarioForInputGroup("empty-input-group", matchedGroupName)];
+  }
+  const checkScenarios = [];
+  for (const inputVar of inputVars) {
+    const inputDesc = inputDescForVar(inputVar, position);
+    checkScenarios.push(checkScenarioForInputDescs(void 0, [inputDesc]));
+  }
+  return checkScenarios;
+}
+function checkScenariosFromSpec(modelSpec, scenarioSpec, simplify) {
+  if (scenarioSpec.preset === "matrix") {
+    return checkScenarioMatrix(modelSpec, simplify);
+  }
+  if (scenarioSpec.scenarios_for_each_input_in !== void 0) {
+    const groupName = scenarioSpec.scenarios_for_each_input_in;
+    const position = scenarioSpec.at;
+    return checkScenariosForEachInputInGroup(modelSpec, groupName, position);
+  }
+  if (scenarioSpec.with !== void 0) {
+    if (Array.isArray(scenarioSpec.with)) {
+      const inputSpecs = scenarioSpec.with;
+      return [checkScenarioForInputSpecs(modelSpec, inputSpecs)];
+    } else {
+      const inputSpec = {
+        input: scenarioSpec.with,
+        at: scenarioSpec.at
+      };
+      return [checkScenarioForInputSpecs(modelSpec, [inputSpec])];
+    }
+  }
+  if (scenarioSpec.with_inputs === "all") {
+    const position = inputPosition(scenarioSpec.at);
+    return [checkScenarioWithAllInputsAtPosition(position)];
+  }
+  if (scenarioSpec.with_inputs_in !== void 0) {
+    const groupName = scenarioSpec.with_inputs_in;
+    const position = scenarioSpec.at;
+    return [checkScenarioWithAllInputsInGroupAtPosition(modelSpec, groupName, position)];
+  }
+  throw new Error(`Unhandled scenario spec: ${JSON.stringify(scenarioSpec)}`);
+}
+
+// src/check/check-planner.ts
+var CheckPlanner = class {
+  constructor(modelSpec) {
+    this.modelSpec = modelSpec;
+    this.groups = [];
+    this.tasks = /* @__PURE__ */ new Map();
+    this.dataRefs = /* @__PURE__ */ new Map();
+    this.checkKey = 1;
+  }
+  addAllChecks(checkSpec, simplifyScenarios) {
+    for (const groupSpec of checkSpec.groups) {
+      const groupName = groupSpec.describe;
+      const planTests = [];
+      for (const testSpec of groupSpec.tests) {
+        const testName = testSpec.it;
+        const checkScenarios = expandScenarios(this.modelSpec, testSpec.scenarios || [], simplifyScenarios);
+        const checkDatasets = [];
+        for (const datasetSpec of testSpec.datasets) {
+          checkDatasets.push(...expandDatasets(this.modelSpec, datasetSpec));
+        }
+        const checkActions = [];
+        for (const predicateSpec of testSpec.predicates) {
+          checkActions.push(actionForPredicate(predicateSpec));
+        }
+        const planScenarios = [];
+        for (const checkScenario of checkScenarios) {
+          if (checkScenario.scenario === void 0) {
+            planScenarios.push({
+              checkScenario,
+              datasets: []
+            });
+            continue;
+          }
+          const planDatasets = [];
+          for (const checkDataset of checkDatasets) {
+            if (checkDataset.datasetKey === void 0) {
+              planDatasets.push({
+                checkDataset,
+                predicates: []
+              });
+              continue;
+            }
+            const planPredicates = [];
+            for (const checkAction of checkActions) {
+              const dataRefs = this.addDataRefs(checkAction.predicateSpec, checkScenario, checkDataset);
+              const key = this.checkKey++;
+              planPredicates.push({
+                checkKey: key,
+                action: checkAction,
+                dataRefs
+              });
+              this.tasks.set(key, {
+                scenario: checkScenario,
+                dataset: checkDataset,
+                action: checkAction,
+                dataRefs
+              });
+            }
+            planDatasets.push({
+              checkDataset,
+              predicates: planPredicates
+            });
+          }
+          planScenarios.push({
+            checkScenario,
+            datasets: planDatasets
+          });
+        }
+        planTests.push({
+          name: testName,
+          scenarios: planScenarios
+        });
+      }
+      this.groups.push({
+        name: groupName,
+        tests: planTests
+      });
+    }
+  }
+  buildPlan() {
+    return {
+      groups: this.groups,
+      tasks: this.tasks,
+      dataRefs: this.dataRefs
+    };
+  }
+  addDataRefs(predicateSpec, checkScenario, checkDataset) {
+    let dataRefs;
+    const addDataRef = (op) => {
+      const predOp = predicateSpec[op];
+      if (predOp === void 0 || typeof predOp === "number") {
+        return;
+      }
+      let refDataset;
+      if (typeof predOp.dataset === "string") {
+        switch (predOp.dataset) {
+          case "inherit":
+            refDataset = checkDataset;
+            break;
+          default:
+            (0, import_assert_never5.default)(predOp.dataset);
+        }
+      } else {
+        const refDatasetSpec = { name: predOp.dataset.name };
+        const matchedRefDatasets = expandDatasets(this.modelSpec, refDatasetSpec);
+        if (matchedRefDatasets.length === 1) {
+          refDataset = matchedRefDatasets[0];
+        } else {
+          refDataset = {
+            name: predOp.dataset.name
+          };
+        }
+      }
+      let refScenario;
+      if (typeof predOp.scenario === "string") {
+        switch (predOp.scenario) {
+          case "inherit":
+            refScenario = checkScenario;
+            break;
+          default:
+            (0, import_assert_never5.default)(predOp.scenario);
+        }
+      } else {
+        const refScenarioSpecs = predOp.scenario ? [predOp.scenario] : [];
+        const matchedRefScenarios = expandScenarios(this.modelSpec, refScenarioSpecs, true);
+        if (matchedRefScenarios.length === 1) {
+          refScenario = matchedRefScenarios[0];
+        }
+        if (refScenario === void 0) {
+          refScenario = {
+            inputDescs: []
+          };
+        }
+      }
+      let dataRefKey;
+      if (refScenario.scenario && refDataset.datasetKey) {
+        dataRefKey = `${refScenario.scenario.key}::${refDataset.datasetKey}`;
+      }
+      const dataRef = {
+        key: dataRefKey,
+        dataset: refDataset,
+        scenario: refScenario
+      };
+      if (dataRefKey) {
+        this.dataRefs.set(dataRefKey, dataRef);
+      }
+      if (dataRefs === void 0) {
+        dataRefs = /* @__PURE__ */ new Map();
+      }
+      dataRefs.set(op, dataRef);
+    };
+    addDataRef("gt");
+    addDataRef("gte");
+    addDataRef("lt");
+    addDataRef("lte");
+    addDataRef("eq");
+    addDataRef("approx");
+    return dataRefs;
+  }
+};
+
+// src/check/check-summary.ts
+function checkSummaryFromReport(checkReport) {
+  const predicateSummaries = [];
+  for (const group of checkReport.groups) {
+    for (const test of group.tests) {
+      for (const scenario of test.scenarios) {
+        for (const dataset of scenario.datasets) {
+          for (const predicate of dataset.predicates) {
+            switch (predicate.result.status) {
+              case "passed":
+                break;
+              case "failed":
+              case "error":
+                predicateSummaries.push({
+                  checkKey: predicate.checkKey,
+                  result: predicate.result
+                });
+                break;
+              default:
+                (0, import_assert_never6.assertNever)(predicate.result.status);
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    predicateSummaries
+  };
+}
+function checkReportFromSummary(checkConfig, checkSummary, simplifyScenarios) {
+  const checkSpecResult = parseTestYaml(checkConfig.tests);
+  if (checkSpecResult.isErr()) {
+    return void 0;
+  }
+  const checkSpec = checkSpecResult.value;
+  const checkPlanner = new CheckPlanner(checkConfig.bundle.model.modelSpec);
+  checkPlanner.addAllChecks(checkSpec, simplifyScenarios);
+  const checkPlan = checkPlanner.buildPlan();
+  const checkResults = /* @__PURE__ */ new Map();
+  for (const predicateSummary of checkSummary.predicateSummaries) {
+    checkResults.set(predicateSummary.checkKey, predicateSummary.result);
+  }
+  return buildCheckReport(checkPlan, checkResults);
+}
+
+// src/compare/compare-data-coordinator.ts
+var import_assert_never7 = require("assert-never");
+var CompareDataCoordinator = class {
+  constructor(bundleModelL, bundleModelR) {
+    this.bundleModelL = bundleModelL;
+    this.bundleModelR = bundleModelR;
+    this.taskQueue = new TaskQueue({
+      process: async (request) => {
+        switch (request.kind) {
+          case "dataset": {
+            const [resultL, resultR] = await Promise.all([
+              this.bundleModelL.getDatasetsForScenario(request.scenario, request.datasetKeys),
+              this.bundleModelR.getDatasetsForScenario(request.scenario, request.datasetKeys)
+            ]);
+            return {
+              kind: "dataset",
+              datasetMapL: resultL.datasetMap,
+              datasetMapR: resultR.datasetMap
+            };
+          }
+          case "graph-data": {
+            const bundleModel = request.bundle === "right" ? this.bundleModelR : this.bundleModelL;
+            const graphData = await bundleModel.getGraphDataForScenario(request.scenario, request.graphId);
+            return {
+              kind: "graph-data",
+              graphData
+            };
+          }
+          default:
+            (0, import_assert_never7.assertNever)(request);
+        }
+      }
+    });
+  }
+  requestDatasetMaps(requestKey, scenario, datasetKeys, onResponse) {
+    const request = {
+      kind: "dataset",
+      scenario,
+      datasetKeys
+    };
+    this.taskQueue.addTask(requestKey, request, (response) => {
+      if (response.kind === "dataset") {
+        onResponse(response.datasetMapL, response.datasetMapR);
+      }
+    });
+  }
+  requestGraphData(requestKey, bundle, scenario, graphId, onResponse) {
+    const request = {
+      kind: "graph-data",
+      bundle,
+      scenario,
+      graphId
+    };
+    this.taskQueue.addTask(requestKey, request, (response) => {
+      if (response.kind === "graph-data") {
+        onResponse(response.graphData);
+      }
+    });
+  }
+  cancelRequest(key) {
+    this.taskQueue.cancelTask(key);
+  }
+};
+
+// src/compare/compare-datasets.ts
+function diffDatasets(datasetL, datasetR) {
+  let minValueL = Number.MAX_VALUE;
+  let maxValueL = Number.MIN_VALUE;
+  let minValueR = Number.MAX_VALUE;
+  let maxValueR = Number.MIN_VALUE;
+  let minValue = Number.MAX_VALUE;
+  let maxValue = Number.MIN_VALUE;
+  let minRawDiff = Number.MAX_VALUE;
+  let maxRawDiff = -1;
+  let maxDiffPoint;
+  let diffCount = 0;
+  let totalRawDiff = 0;
+  if (datasetL && datasetR) {
+    const times = /* @__PURE__ */ new Set([...datasetL.keys(), ...datasetR.keys()]);
+    for (const t of times) {
+      const valueL = datasetL.get(t);
+      if (valueL !== void 0) {
+        if (valueL < minValueL)
+          minValueL = valueL;
+        if (valueL > maxValueL)
+          maxValueL = valueL;
+        if (valueL < minValue)
+          minValue = valueL;
+        if (valueL > maxValue)
+          maxValue = valueL;
+      }
+      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 (valueL === void 0 || valueR === void 0) {
+        continue;
+      }
+      const rawDiff = Math.abs(valueR - valueL);
+      if (rawDiff < minRawDiff) {
+        minRawDiff = rawDiff;
+      }
+      if (rawDiff > maxRawDiff) {
+        maxRawDiff = rawDiff;
+        maxDiffPoint = {
+          time: t,
+          valueL,
+          valueR
+        };
+      }
+      diffCount++;
+      totalRawDiff += rawDiff;
+    }
+  }
+  function pct(x) {
+    return x * 100;
+  }
+  let minDiff;
+  let maxDiff;
+  let avgDiff;
+  if (minValueL === maxValueL && minValueR === maxValueR) {
+    const diff = pct(maxValueL !== 0 ? Math.abs((maxValueR - maxValueL) / maxValueL) : 1);
+    minDiff = diff;
+    maxDiff = diff;
+    avgDiff = diff;
+  } else {
+    const spread = maxValue - minValue;
+    minDiff = pct(spread > 0 ? minRawDiff / spread : 0);
+    maxDiff = pct(spread > 0 ? maxRawDiff / spread : 0);
+    const avgRawDiff = totalRawDiff / diffCount;
+    avgDiff = pct(spread > 0 ? avgRawDiff / spread : 0);
+  }
+  let validity;
+  if (datasetL && datasetR) {
+    validity = "both";
+  } else if (datasetL) {
+    validity = "left-only";
+  } else if (datasetR) {
+    validity = "right-only";
+  } else {
+    validity = "neither";
+  }
+  return {
+    validity,
+    minValue,
+    maxValue,
+    avgDiff,
+    minDiff,
+    maxDiff,
+    maxDiffPoint
+  };
+}
+function compareDatasets(scenarioKey, datasetKey, datasetMapL, datasetMapR) {
+  const datasetL = datasetMapL.get(datasetKey);
+  const datasetR = datasetMapR.get(datasetKey);
+  const diffReport = diffDatasets(datasetL, datasetR);
+  return {
+    scenarioKey,
+    datasetKey,
+    diffReport
+  };
+}
+
+// src/compare/compare-graphs.ts
+function diffGraphs(graphL, graphR, scenarioKey, datasetSummaries) {
+  let inclusion;
+  if (graphL && graphR) {
+    inclusion = "both";
+  } else if (graphL) {
+    inclusion = "left-only";
+  } else if (graphR) {
+    inclusion = "right-only";
+  } else {
+    inclusion = "neither";
+  }
+  const metadataReports = [];
+  if ((graphL == null ? void 0 : graphL.metadata) && (graphR == null ? void 0 : graphR.metadata)) {
+    const metaKeys = /* @__PURE__ */ new Set();
+    for (const key of graphL.metadata.keys()) {
+      metaKeys.add(key);
+    }
+    for (const key of graphR.metadata.keys()) {
+      metaKeys.add(key);
+    }
+    for (const key of metaKeys) {
+      const valueL = graphL.metadata.get(key);
+      const valueR = graphR.metadata.get(key);
+      if (valueL !== valueR) {
+        metadataReports.push({
+          key,
+          valueL,
+          valueR
+        });
+      }
+    }
+  }
+  const datasetReports = [];
+  if (graphL && graphR) {
+    const datasetKeys = /* @__PURE__ */ new Set();
+    for (const dataset of graphL.datasets) {
+      datasetKeys.add(dataset.datasetKey);
+    }
+    for (const dataset of graphR.datasets) {
+      datasetKeys.add(dataset.datasetKey);
+    }
+    for (const datasetKey of datasetKeys) {
+      const summary = datasetSummaries.find((summary2) => summary2.d === datasetKey && summary2.s === scenarioKey);
+      const maxDiff = summary !== void 0 ? summary.md : void 0;
+      datasetReports.push({
+        datasetKey,
+        maxDiff
+      });
+    }
+  }
+  return {
+    inclusion,
+    metadataReports,
+    datasetReports
+  };
+}
+
+// src/compare/compare-summary.ts
+function compareSummaryFromReport(compareReport) {
+  const datasetSummaries = [];
+  for (const r of compareReport.datasetReports) {
+    if (r.diffReport.validity === "both" && r.diffReport.maxDiff > 0) {
+      datasetSummaries.push({
+        s: r.scenarioKey,
+        d: r.datasetKey,
+        md: r.diffReport.maxDiff
+      });
+    }
+  }
+  return {
+    datasetSummaries,
+    perfReportL: compareReport.perfReportL,
+    perfReportR: compareReport.perfReportR
+  };
+}
+
+// src/config/synchronized-model.ts
+function synchronizedBundleModel(sourceModel) {
+  var _a;
+  const promiseQueue = new PromiseQueue();
+  return {
+    modelSpec: sourceModel.modelSpec,
+    getDatasetsForScenario: (scenario, datasetKeys) => {
+      return promiseQueue.add(() => sourceModel.getDatasetsForScenario(scenario, datasetKeys));
+    },
+    getGraphsForDataset: (_a = sourceModel.getGraphsForDataset) == null ? void 0 : _a.bind(sourceModel),
+    getGraphDataForScenario: (scenario, graphId) => {
+      return promiseQueue.add(() => sourceModel.getGraphDataForScenario(scenario, graphId));
+    },
+    getGraphLinksForScenario: sourceModel.getGraphLinksForScenario.bind(sourceModel)
+  };
+}
+var PromiseQueue = class {
+  constructor() {
+    this.tasks = [];
+    this.runningCount = 0;
+  }
+  add(f) {
+    return new Promise((resolve, reject) => {
+      const run = async () => {
+        this.runningCount++;
+        const promise = f();
+        try {
+          const result = await promise;
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        } finally {
+          this.runningCount--;
+          this.runNext();
+        }
+      };
+      if (this.runningCount < 1) {
+        run();
+      } else {
+        this.tasks.push(run);
+      }
+    });
+  }
+  runNext() {
+    if (this.tasks.length > 0) {
+      const task = this.tasks.shift();
+      if (task) {
+        task();
+      }
+    }
+  }
+};
+
+// src/config/config.ts
+async function createConfig(options) {
+  var _a;
+  const origCurrentBundle = await loadSynchronized(options.current);
+  let currentBundle;
+  let compareConfig;
+  if (options.compare === void 0) {
+    currentBundle = origCurrentBundle;
+  } else {
+    const baselineBundle = await loadSynchronized(options.compare.baseline);
+    const renamedDatasetKeys = options.compare.datasets.renamedDatasetKeys;
+    const invertedRenamedKeys = /* @__PURE__ */ new Map();
+    renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.forEach((newKey, oldKey) => {
+      invertedRenamedKeys.set(newKey, oldKey);
+    });
+    const rightKeyForLeftKey = (leftKey) => {
+      return (renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.get(leftKey)) || leftKey;
+    };
+    const leftKeyForRightKey = (rightKey) => {
+      return invertedRenamedKeys.get(rightKey) || rightKey;
+    };
+    const origBundleModelR = origCurrentBundle.model;
+    const adjBundleModelR = {
+      modelSpec: origBundleModelR.modelSpec,
+      getDatasetsForScenario: async (scenario, datasetKeys) => {
+        const rightKeys = datasetKeys.map(rightKeyForLeftKey);
+        const result = await origBundleModelR.getDatasetsForScenario(scenario, rightKeys);
+        const mapWithRightKeys = result.datasetMap;
+        const mapWithLeftKeys = /* @__PURE__ */ new Map();
+        for (const [rightKey, dataset] of mapWithRightKeys.entries()) {
+          const leftKey = leftKeyForRightKey(rightKey);
+          mapWithLeftKeys.set(leftKey, dataset);
+        }
+        return {
+          datasetMap: mapWithLeftKeys,
+          modelRunTime: result.modelRunTime
+        };
+      },
+      getGraphsForDataset: (_a = origBundleModelR.getGraphsForDataset) == null ? void 0 : _a.bind(origBundleModelR),
+      getGraphDataForScenario: origBundleModelR.getGraphDataForScenario.bind(origBundleModelR),
+      getGraphLinksForScenario: origBundleModelR.getGraphLinksForScenario.bind(origBundleModelR)
+    };
+    currentBundle = __spreadProps(__spreadValues({}, origCurrentBundle), {
+      model: adjBundleModelR
+    });
+    compareConfig = {
+      bundleL: baselineBundle,
+      bundleR: currentBundle,
+      thresholds: options.compare.thresholds,
+      scenarios: options.compare.scenarios,
+      datasets: options.compare.datasets
+    };
+  }
+  const checkConfig = {
+    bundle: currentBundle,
+    tests: options.check.tests
+  };
+  return {
+    check: checkConfig,
+    compare: compareConfig
+  };
+}
+async function loadSynchronized(sourceBundle) {
+  const sourceModel = await sourceBundle.bundle.initModel();
+  const synchronizedModel = synchronizedBundleModel(sourceModel);
+  return {
+    name: sourceBundle.name,
+    version: sourceBundle.bundle.version,
+    model: synchronizedModel
+  };
+}
+
+// src/config/dataset-manager.ts
+var DatasetManager = class {
+  constructor(bundleL, bundleR, renamedDatasetKeys) {
+    this.bundleL = bundleL;
+    this.bundleR = bundleR;
+    this.renamedDatasetKeys = renamedDatasetKeys;
+    const invertedRenamedKeys = /* @__PURE__ */ new Map();
+    renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.forEach((newKey, oldKey) => {
+      invertedRenamedKeys.set(newKey, oldKey);
+    });
+    function leftKeyForRightKey(rightKey) {
+      return invertedRenamedKeys.get(rightKey) || rightKey;
+    }
+    const allOutputVarKeysSet = /* @__PURE__ */ new Set();
+    const modelOutputVarKeysSet = /* @__PURE__ */ new Set();
+    function addOutputVars(outputVars, handleRenames) {
+      outputVars.forEach((outputVar, key) => {
+        const remappedKey = handleRenames ? leftKeyForRightKey(key) : key;
+        allOutputVarKeysSet.add(remappedKey);
+        if (outputVar.sourceName === void 0) {
+          modelOutputVarKeysSet.add(remappedKey);
+        }
+      });
+    }
+    addOutputVars(bundleL.modelSpec.outputVars, false);
+    addOutputVars(bundleR.modelSpec.outputVars, true);
+    this.allOutputVarKeys = Array.from(allOutputVarKeysSet);
+    this.modelOutputVarKeys = Array.from(modelOutputVarKeysSet);
+  }
+  getDatasetKeysForScenario(scenario) {
+    if (scenario.kind === "all-inputs" && scenario.position === "at-default") {
+      return this.allOutputVarKeys;
+    } else {
+      return this.modelOutputVarKeys;
+    }
+  }
+  getDatasetInfo(datasetKey) {
+    var _a;
+    const modelSpecL = this.bundleL.modelSpec;
+    const modelSpecR = this.bundleR.modelSpec;
+    const datasetKeyL = datasetKey;
+    const datasetKeyR = ((_a = this.renamedDatasetKeys) == null ? void 0 : _a.get(datasetKeyL)) || datasetKeyL;
+    const outputVarL = modelSpecL.outputVars.get(datasetKeyL);
+    const outputVarR = modelSpecR.outputVars.get(datasetKeyR);
+    let varName;
+    let newVarName;
+    let sourceName;
+    let newSourceName;
+    if (outputVarL && outputVarR && outputVarL.varName != outputVarR.varName) {
+      varName = outputVarL.varName;
+      newVarName = outputVarR.varName;
+    } else {
+      const outputVar = outputVarR || outputVarL;
+      varName = (outputVar == null ? void 0 : outputVar.varName) || "Unknown";
+    }
+    if (outputVarL && outputVarR && outputVarL.sourceName != outputVarR.sourceName) {
+      sourceName = outputVarL.sourceName;
+      newSourceName = outputVarR.sourceName;
+    } else {
+      const outputVar = outputVarR || outputVarL;
+      sourceName = outputVar == null ? void 0 : outputVar.sourceName;
+    }
+    return {
+      varName,
+      newVarName,
+      sourceName,
+      newSourceName,
+      relatedItems: (outputVarR == null ? void 0 : outputVarR.relatedItems) || []
+    };
+  }
+};
+
+// src/config/scenario-manager.ts
+var import_assert_never8 = require("assert-never");
+var ScenarioManager = class {
+  constructor(bundleL, bundleR) {
+    this.bundleL = bundleL;
+    this.bundleR = bundleR;
+    this.scenarios = /* @__PURE__ */ new Map();
+    this.scenarioInfo = /* @__PURE__ */ new Map();
+    this.defaultInfoForGroup = /* @__PURE__ */ new Map();
+    this.groupInfo = /* @__PURE__ */ new Map();
+  }
+  getScenarios() {
+    return [...this.scenarios.values()];
+  }
+  getScenario(scenarioKey) {
+    return this.scenarios.get(scenarioKey);
+  }
+  getScenarioGroupInfo(groupKey) {
+    return this.groupInfo.get(groupKey);
+  }
+  getScenarioInfo(scenario, groupKey) {
+    if (scenario.key === "all_inputs_at_default") {
+      const defaultInfo = this.defaultInfoForGroup.get(groupKey);
+      if (defaultInfo) {
+        return defaultInfo;
+      }
+    }
+    return this.scenarioInfo.get(scenario.key);
+  }
+  setDefaultScenarioInfoForGroup(groupKey, scenarioInfo) {
+    this.defaultInfoForGroup.set(groupKey, scenarioInfo);
+  }
+  addScenario(scenario, scenarioInfo, groupInfo) {
+    this.scenarios.set(scenario.key, scenario);
+    if (!scenarioInfo) {
+      scenarioInfo = this.getInfoForScenario(scenario);
+    }
+    this.scenarioInfo.set(scenario.key, scenarioInfo);
+    if (!groupInfo) {
+      groupInfo = this.getGroupInfoForScenario(scenario);
+    }
+    this.groupInfo.set(scenario.groupKey, groupInfo);
+  }
+  addScenarioMatrix() {
+    const inputVarIdsL = Array.from(this.bundleL.modelSpec.inputVars.keys());
+    const inputVarIdsR = Array.from(this.bundleR.modelSpec.inputVars.keys());
+    const inputVarIds = /* @__PURE__ */ new Set([...inputVarIdsL, ...inputVarIdsR]);
+    this.addScenario(allInputsAtPositionScenario("at-default"));
+    this.addScenario(allInputsAtPositionScenario("at-minimum"));
+    this.addScenario(allInputsAtPositionScenario("at-maximum"));
+    for (const inputVarId of inputVarIds) {
+      this.addScenario(inputAtPositionScenario(inputVarId, inputVarId, "at-minimum"));
+      this.addScenario(inputAtPositionScenario(inputVarId, inputVarId, "at-maximum"));
+    }
+  }
+  getGroupInfoForScenario(scenario) {
+    switch (scenario.kind) {
+      case "all-inputs":
+        return {
+          title: "All Inputs",
+          relatedItems: []
+        };
+      case "settings":
+        if (scenario.settings.length === 1) {
+          const inputVar = this.getInputVarForSetting(scenario.settings[0]);
+          let relatedItems;
+          let subtitle;
+          if (inputVar == null ? void 0 : inputVar.relatedItem) {
+            relatedItems = [inputVar.relatedItem];
+            subtitle = inputVar.relatedItem.locationPath.join('&nbsp;<span class="related-sep">&gt;</span>&nbsp;');
+          } else {
+            relatedItems = [];
+            subtitle = void 0;
+          }
+          return {
+            title: (inputVar == null ? void 0 : inputVar.varName) || "Unknown Input",
+            subtitle,
+            relatedItems
+          };
+        } else {
+          return {
+            title: "Multiple Inputs",
+            relatedItems: this.getRelatedItemsForSettings(scenario.settings)
+          };
+        }
+      default:
+        (0, import_assert_never8.assertNever)(scenario);
+    }
+  }
+  getInfoForScenario(scenario) {
+    switch (scenario.kind) {
+      case "all-inputs":
+        return this.getInfoForPositionSetting(void 0, scenario.position);
+      case "settings":
+        if (scenario.settings.length === 1 && scenario.settings[0].kind === "position") {
+          const setting = scenario.settings[0];
+          return this.getInfoForPositionSetting(setting.inputVarId, setting.position);
+        } else {
+          return {
+            title: `PLACEHOLDER (scenario info not provided)`,
+            position: 1
+          };
+        }
+      default:
+        (0, import_assert_never8.assertNever)(scenario);
+    }
+  }
+  getInfoForPositionSetting(inputVarId, inputPosition2) {
+    const title = inputPosition2.replace("-", " ");
+    let subtitle;
+    if (inputVarId) {
+      const inputVarL = this.bundleL.modelSpec.inputVars.get(inputVarId);
+      const inputVarR = this.bundleR.modelSpec.inputVars.get(inputVarId);
+      const valueL = inputValue(inputVarL, inputPosition2);
+      const valueR = inputValue(inputVarR, inputPosition2);
+      if (valueL !== valueR) {
+        let values = "";
+        values += "(";
+        values += `<span class='dataset-color-0'>${valueL}</span>`;
+        values += "&nbsp;|&nbsp;";
+        values += `<span class='dataset-color-1'>${valueR}</span>`;
+        values += ")";
+        subtitle = values;
+      } else {
+        subtitle = `(${valueL})`;
+      }
+    } else {
+      subtitle = void 0;
+    }
+    let position;
+    switch (inputPosition2) {
+      case "at-default":
+        position = 0;
+        break;
+      case "at-minimum":
+        position = 1;
+        break;
+      case "at-maximum":
+        position = 2;
+        break;
+      default:
+        (0, import_assert_never8.assertNever)(inputPosition2);
+    }
+    return {
+      title,
+      subtitle,
+      position
+    };
+  }
+  getRelatedItemsForSettings(settings) {
+    const relatedItems = [];
+    for (const setting of settings) {
+      const inputVar = this.getInputVarForSetting(setting);
+      if (inputVar == null ? void 0 : inputVar.relatedItem) {
+        relatedItems.push(inputVar.relatedItem);
+      }
+    }
+    return relatedItems;
+  }
+  getInputVarForSetting(setting) {
+    const inputVarId = setting.inputVarId;
+    const inputVarL = this.bundleL.modelSpec.inputVars.get(inputVarId);
+    const inputVarR = this.bundleR.modelSpec.inputVars.get(inputVarId);
+    return inputVarR || inputVarL;
+  }
+};
+function inputValue(inputVar, position) {
+  if (inputVar) {
+    switch (position) {
+      case "at-default":
+        return inputVar.defaultValue.toString();
+      case "at-minimum":
+        return inputVar.minValue.toString();
+      case "at-maximum":
+        return inputVar.maxValue.toString();
+      default:
+        (0, import_assert_never8.assertNever)(position);
+    }
+  } else {
+    return "n/a";
+  }
+}
+
+// src/perf/perf-runner.ts
+var import_assert_never9 = require("assert-never");
+
+// src/perf/perf-stats.ts
+var PerfStats = class {
+  constructor() {
+    this.times = [];
+  }
+  addRun(timeInMillis) {
+    this.times.push(timeInMillis);
+  }
+  toReport() {
+    if (this.times.length === 0) {
+      return {
+        minTime: 0,
+        maxTime: 0,
+        avgTime: 0,
+        allTimes: []
+      };
+    }
+    const minTime = Math.min(...this.times);
+    const maxTime = Math.max(...this.times);
+    const sortedTimes = this.times.sort();
+    const minIndex = Math.floor(sortedTimes.length / 4);
+    const maxIndex = minIndex + Math.ceil(sortedTimes.length / 2);
+    const middleTimes = sortedTimes.slice(minIndex, maxIndex);
+    const totalTime = middleTimes.reduce((a, b) => a + b, 0);
+    const avgTime = totalTime / middleTimes.length;
+    return {
+      minTime,
+      maxTime,
+      avgTime,
+      allTimes: sortedTimes
+    };
+  }
+};
+
+// src/perf/perf-runner.ts
+var warmupCount = 5;
+var runCount = 100;
+var PerfRunner = class {
+  constructor(bundleModelL, bundleModelR, mode = "serial") {
+    this.bundleModelL = bundleModelL;
+    this.bundleModelR = bundleModelR;
+    this.mode = mode;
+    const scenario = allInputsAtPositionScenario("at-default");
+    this.taskQueue = new TaskQueue({
+      process: async (request) => {
+        switch (request.kind) {
+          case "left": {
+            const result = await bundleModelL.getDatasetsForScenario(scenario, []);
+            return {
+              runTimeL: result.modelRunTime
+            };
+          }
+          case "right": {
+            const result = await bundleModelR.getDatasetsForScenario(scenario, []);
+            return {
+              runTimeR: result.modelRunTime
+            };
+          }
+          case "both": {
+            const [resultL, resultR] = await Promise.all([
+              bundleModelL.getDatasetsForScenario(scenario, []),
+              bundleModelR.getDatasetsForScenario(scenario, [])
+            ]);
+            return {
+              runTimeL: resultL.modelRunTime,
+              runTimeR: resultR.modelRunTime
+            };
+          }
+          default:
+            (0, import_assert_never9.assertNever)(request.kind);
+        }
+      }
+    });
+  }
+  start() {
+    const statsL = new PerfStats();
+    const statsR = new PerfStats();
+    this.taskQueue.onIdle = (error) => {
+      var _a;
+      if (error) {
+        this.onError(error);
+      } else {
+        (_a = this.onComplete) == null ? void 0 : _a.call(this, statsL.toReport(), statsR.toReport());
+      }
+    };
+    const taskQueue = this.taskQueue;
+    function addTask(index, warmup, kind) {
+      const key = `${warmup ? "warmup-" : ""}${kind}-${index}`;
+      const request = {
+        kind
+      };
+      taskQueue.addTask(key, request, (response) => {
+        if (!warmup && response.runTimeL !== void 0) {
+          statsL.addRun(response.runTimeL);
+        }
+        if (!warmup && response.runTimeR !== void 0) {
+          statsR.addRun(response.runTimeR);
+        }
+      });
+    }
+    function addTasks(kind) {
+      for (let i = 0; i < warmupCount; i++) {
+        addTask(i, true, kind);
+      }
+      for (let i = 0; i < runCount; i++) {
+        addTask(i, false, kind);
+      }
+    }
+    if (this.mode === "parallel") {
+      addTasks("both");
+    } else {
+      addTasks("left");
+      addTasks("right");
+    }
+  }
+};
+
+// src/suite/suite-runner.ts
+var import_assert_never10 = __toESM(require("assert-never"), 1);
+
+// src/data/data-planner.ts
+var ScenarioTaskSet = class {
+  constructor(scenario) {
+    this.scenario = scenario;
+    this.modelTasks = /* @__PURE__ */ new Map();
+    this.modelImplTasks = /* @__PURE__ */ new Map();
+    this.requestKind = "check";
+  }
+  addTask(kind, datasetKey, dataFunc) {
+    if (kind === "compare") {
+      this.requestKind = "compare";
+    }
+    const dataTask = {
+      datasetKey,
+      dataFunc
+    };
+    let taskMap;
+    if (datasetKey.startsWith("ModelImpl")) {
+      taskMap = this.modelImplTasks;
+    } else {
+      taskMap = this.modelTasks;
+    }
+    let tasks = taskMap.get(datasetKey);
+    if (!tasks) {
+      tasks = [];
+      taskMap.set(datasetKey, tasks);
+    }
+    tasks.push(dataTask);
+  }
+  buildRequests(batchSize) {
+    const dataRequests = [];
+    if (this.modelTasks.size > 0) {
+      const dataTasks = [];
+      this.modelTasks.forEach((tasks) => dataTasks.push(...tasks));
+      dataRequests.push({
+        kind: this.requestKind,
+        scenario: this.scenario,
+        dataTasks
+      });
+    }
+    if (this.modelImplTasks.size > 0) {
+      const allKeys = [...this.modelImplTasks.keys()];
+      for (let i = 0; i < allKeys.length; i += batchSize) {
+        const batchKeys = allKeys.slice(i, i + batchSize);
+        const dataTasks = [];
+        for (const datasetKey of batchKeys) {
+          dataTasks.push(...this.modelImplTasks.get(datasetKey));
+        }
+        dataRequests.push({
+          kind: this.requestKind,
+          scenario: this.scenario,
+          dataTasks
+        });
+      }
+    }
+    return dataRequests;
+  }
+};
+var DataPlanner = class {
+  constructor(batchSize) {
+    this.batchSize = batchSize;
+    this.scenarioTaskSets = /* @__PURE__ */ new Map();
+  }
+  addRequest(kind, scenario, datasetKey, dataFunc) {
+    let scenarioTaskSet = this.scenarioTaskSets.get(scenario.key);
+    if (!scenarioTaskSet) {
+      scenarioTaskSet = new ScenarioTaskSet(scenario);
+      this.scenarioTaskSets.set(scenario.key, scenarioTaskSet);
+    }
+    scenarioTaskSet.addTask(kind, datasetKey, dataFunc);
+  }
+  buildPlan() {
+    const requests = [];
+    for (const taskSet of this.scenarioTaskSets.values()) {
+      requests.push(...taskSet.buildRequests(this.batchSize));
+    }
+    return {
+      requests
+    };
+  }
+};
+
+// src/check/check-runner.ts
+function runChecks(checkConfig, checkSpec, dataPlanner, refDataPlanner, simplifyScenarios) {
+  const modelSpec = checkConfig.bundle.model.modelSpec;
+  const checkPlanner = new CheckPlanner(modelSpec);
+  checkPlanner.addAllChecks(checkSpec, simplifyScenarios);
+  const checkPlan = checkPlanner.buildPlan();
+  const refDatasets = /* @__PURE__ */ new Map();
+  for (const [dataRefKey, dataRef] of checkPlan.dataRefs.entries()) {
+    refDataPlanner.addRequest("check", dataRef.scenario.scenario, dataRef.dataset.datasetKey, (datasets) => {
+      const dataset = datasets.datasetR;
+      if (dataset) {
+        refDatasets.set(dataRefKey, dataset);
+      }
+    });
+  }
+  const checkResults = /* @__PURE__ */ new Map();
+  for (const [checkKey, checkTask] of checkPlan.tasks.entries()) {
+    dataPlanner.addRequest("check", checkTask.scenario.scenario, checkTask.dataset.datasetKey, (datasets) => {
+      const dataset = datasets.datasetR;
+      const checkResult = runCheck(checkTask, dataset, refDatasets);
+      checkResults.set(checkKey, checkResult);
+    });
+  }
+  return () => {
+    return buildCheckReport(checkPlan, checkResults);
+  };
+}
+function runCheck(checkTask, dataset, refDatasets) {
+  if (dataset === void 0) {
+    return {
+      status: "error",
+      message: "no data available"
+    };
+  }
+  let opRefDatasets;
+  if (checkTask.dataRefs) {
+    opRefDatasets = /* @__PURE__ */ new Map();
+    for (const [op, dataRef] of checkTask.dataRefs.entries()) {
+      const refDataset = refDatasets == null ? void 0 : refDatasets.get(dataRef.key);
+      if (refDataset === void 0) {
+        if (dataRef.dataset.datasetKey === void 0) {
+          return {
+            status: "error",
+            errorInfo: {
+              kind: "unknown-dataset",
+              name: dataRef.dataset.name
+            }
+          };
+        } else if (dataRef.scenario.scenario === void 0) {
+          if (dataRef.scenario.error) {
+            return {
+              status: "error",
+              errorInfo: {
+                kind: dataRef.scenario.error.kind,
+                name: dataRef.scenario.error.name
+              }
+            };
+          } else {
+            let inputName;
+            if (dataRef.scenario.inputDescs.length > 0) {
+              inputName = dataRef.scenario.inputDescs[0].name;
+            } else {
+              inputName = "unknown";
+            }
+            return {
+              status: "error",
+              errorInfo: {
+                kind: "unknown-input",
+                name: inputName
+              }
+            };
+          }
+        } else {
+          return {
+            status: "error",
+            message: "unresolved data reference"
+          };
+        }
+      }
+      opRefDatasets.set(op, refDataset);
+    }
+  }
+  return checkTask.action.run(dataset, opRefDatasets);
+}
+
+// src/compare/compare-runner.ts
+function runCompare(compareConfig, dataPlanner, simplifyScenarios) {
+  const scenarios = simplifyScenarios ? [allInputsAtPositionScenario("at-default")] : compareConfig.scenarios.getScenarios();
+  const datasetReports = [];
+  for (const scenario of scenarios) {
+    const datasetKeys = compareConfig.datasets.getDatasetKeysForScenario(scenario);
+    for (const datasetKey of datasetKeys) {
+      dataPlanner.addRequest("compare", scenario, datasetKey, (datasets) => {
+        const diffReport = diffDatasets(datasets.datasetL, datasets.datasetR);
+        datasetReports.push({
+          scenarioKey: scenario.key,
+          datasetKey,
+          diffReport
+        });
+      });
+    }
+  }
+  return () => {
+    return datasetReports;
+  };
+}
+
+// src/suite/suite-runner.ts
+var SuiteRunner = class {
+  constructor(config, callbacks) {
+    this.config = config;
+    this.callbacks = callbacks;
+    this.perfStatsL = new PerfStats();
+    this.perfStatsR = new PerfStats();
+    this.stopped = false;
+    this.taskQueue = new TaskQueue({
+      process: (request) => {
+        return this.processRequest(request);
+      }
+    });
+  }
+  cancel() {
+    if (!this.stopped) {
+      this.stopped = true;
+      this.taskQueue.shutdown();
+    }
+  }
+  start(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    (_b = (_a = this.callbacks).onProgress) == null ? void 0 : _b.call(_a, 0);
+    const modelSpec = this.config.check.bundle.model.modelSpec;
+    const dataPlanner = new DataPlanner(modelSpec.outputVars.size);
+    const refDataPlanner = new DataPlanner(modelSpec.outputVars.size);
+    const checkSpecResult = parseTestYaml(this.config.check.tests);
+    if (checkSpecResult.isErr()) {
+      (_d = (_c = this.callbacks).onError) == null ? void 0 : _d.call(_c, checkSpecResult.error);
+      return;
+    }
+    const checkSpec = checkSpecResult.value;
+    const simplifyScenarios = (options == null ? void 0 : options.simplifyScenarios) === true;
+    const buildCheckReport2 = runChecks(this.config.check, checkSpec, dataPlanner, refDataPlanner, simplifyScenarios);
+    let buildCompareDatasetReports;
+    if (this.config.compare) {
+      buildCompareDatasetReports = runCompare(this.config.compare, dataPlanner, simplifyScenarios);
+    }
+    this.taskQueue.onIdle = (error) => {
+      var _a2, _b2, _c2, _d2;
+      if (this.stopped) {
+        return;
+      }
+      if (error) {
+        (_b2 = (_a2 = this.callbacks).onError) == null ? void 0 : _b2.call(_a2, error);
+      } else {
+        const checkReport = buildCheckReport2();
+        let compareReport;
+        if (this.config.compare) {
+          compareReport = {
+            datasetReports: buildCompareDatasetReports(),
+            perfReportL: this.perfStatsL.toReport(),
+            perfReportR: this.perfStatsR.toReport()
+          };
+        }
+        (_d2 = (_c2 = this.callbacks).onComplete) == null ? void 0 : _d2.call(_c2, {
+          checkReport,
+          compareReport
+        });
+      }
+    };
+    const refDataPlan = refDataPlanner.buildPlan();
+    const dataPlan = dataPlanner.buildPlan();
+    const dataRequests = [...refDataPlan.requests, ...dataPlan.requests];
+    const taskCount = dataRequests.length;
+    if (taskCount === 0) {
+      let compareReport;
+      if (this.config.compare) {
+        compareReport = {
+          datasetReports: [],
+          perfReportL: this.perfStatsL.toReport(),
+          perfReportR: this.perfStatsR.toReport()
+        };
+      }
+      this.cancel();
+      (_f = (_e = this.callbacks).onProgress) == null ? void 0 : _f.call(_e, 1);
+      (_h = (_g = this.callbacks).onComplete) == null ? void 0 : _h.call(_g, {
+        checkReport: {
+          groups: []
+        },
+        compareReport
+      });
+      return;
+    }
+    let tasksCompleted = 0;
+    let dataTaskId = 1;
+    for (const dataRequest of dataRequests) {
+      this.taskQueue.addTask(`data${dataTaskId++}`, dataRequest, () => {
+        var _a2, _b2;
+        tasksCompleted++;
+        (_b2 = (_a2 = this.callbacks).onProgress) == null ? void 0 : _b2.call(_a2, tasksCompleted / taskCount);
+      });
+    }
+  }
+  async processRequest(request) {
+    const datasetKeySet = /* @__PURE__ */ new Set();
+    for (const dataTask of request.dataTasks) {
+      datasetKeySet.add(dataTask.datasetKey);
+    }
+    const datasetKeys = [...datasetKeySet];
+    const scenario = request.scenario;
+    let datasetsResultL;
+    let datasetsResultR;
+    switch (request.kind) {
+      case "check": {
+        const bundleModel = this.config.check.bundle.model;
+        datasetsResultR = await bundleModel.getDatasetsForScenario(scenario, datasetKeys);
+        break;
+      }
+      case "compare": {
+        const bundleModelL = this.config.compare.bundleL.model;
+        const bundleModelR = this.config.compare.bundleR.model;
+        const [resultL, resultR] = await Promise.all([
+          bundleModelL.getDatasetsForScenario(scenario, datasetKeys),
+          bundleModelR.getDatasetsForScenario(scenario, datasetKeys)
+        ]);
+        datasetsResultL = resultL;
+        datasetsResultR = resultR;
+        break;
+      }
+      default:
+        (0, import_assert_never10.default)(request.kind);
+    }
+    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.dataFunc({
+        datasetL,
+        datasetR
+      });
+    }
+  }
+};
+function runSuite(config, callbacks, options) {
+  const suiteRunner = new SuiteRunner(config, callbacks);
+  suiteRunner.start(options);
+  return () => {
+    suiteRunner.cancel();
+  };
+}
+
+// src/suite/suite-summary.ts
+function suiteSummaryFromReport(suiteReport) {
+  const checkSummary = checkSummaryFromReport(suiteReport.checkReport);
+  let compareSummary;
+  if (suiteReport.compareReport) {
+    compareSummary = compareSummaryFromReport(suiteReport.compareReport);
+  }
+  return {
+    checkSummary,
+    compareSummary
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckDataCoordinator,
+  CompareDataCoordinator,
+  DatasetManager,
+  PerfRunner,
+  PerfStats,
+  ScenarioManager,
+  allInputsAtPositionScenario,
+  checkReportFromSummary,
+  checkSummaryFromReport,
+  compareDatasets,
+  compareSummaryFromReport,
+  createConfig,
+  datasetMessage,
+  diffDatasets,
+  diffGraphs,
+  inputAtPositionScenario,
+  inputAtValueScenario,
+  matrixScenarios,
+  positionSetting,
+  predicateMessage,
+  runSuite,
+  scenarioMessage,
+  settingsScenario,
+  suiteSummaryFromReport,
+  valueSetting
+});
+//# sourceMappingURL=index.cjs.map