@sdeverywhere/check-core 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -1,9 +1,26 @@
 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 });
@@ -17,10 +34,34 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 
 // src/index.ts
 var src_exports = {};
@@ -48,9 +89,13 @@ module.exports = __toCommonJS(src_exports);
 var TaskQueue = class {
   constructor(processor) {
     this.processor = processor;
+    /** The queue of task keys, most recent at front. */
     this.taskKeyQueue = [];
+    /** The map of tasks. */
     this.taskMap = /* @__PURE__ */ new Map();
+    /** Whether tasks are being processed. */
     this.processing = false;
+    /** Whether `shutdown` has been called. */
     this.stopped = false;
   }
   addTask(key, input, onComplete) {
@@ -88,39 +133,41 @@ var TaskQueue = class {
       });
     }
   }
-  async processNextTask() {
-    var _a, _b;
-    const taskKey = this.taskKeyQueue.shift();
-    if (!taskKey) {
-      return;
-    }
-    const task = this.taskMap.get(taskKey);
-    if (task) {
-      this.taskMap.delete(taskKey);
-    } else {
-      return;
-    }
-    let output;
-    try {
-      output = await this.processor.process(task.input);
-    } catch (e) {
-      if (!this.stopped) {
-        this.shutdown();
-        (_a = this.onIdle) == null ? void 0 : _a.call(this, e);
+  processNextTask() {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const taskKey = this.taskKeyQueue.shift();
+      if (!taskKey) {
+        return;
       }
-      return;
-    }
-    task.onComplete(output);
-    if (this.taskKeyQueue.length > 0) {
-      setTimeout(() => {
-        this.processNextTask();
-      });
-    } else {
-      this.processing = false;
-      if (!this.stopped) {
-        (_b = this.onIdle) == null ? void 0 : _b.call(this);
+      const task = this.taskMap.get(taskKey);
+      if (task) {
+        this.taskMap.delete(taskKey);
+      } else {
+        return;
       }
-    }
+      let output;
+      try {
+        output = yield this.processor.process(task.input);
+      } catch (e) {
+        if (!this.stopped) {
+          this.shutdown();
+          (_a = this.onIdle) == null ? void 0 : _a.call(this, e);
+        }
+        return;
+      }
+      task.onComplete(output);
+      if (this.taskKeyQueue.length > 0) {
+        setTimeout(() => {
+          this.processNextTask();
+        });
+      } else {
+        this.processing = false;
+        if (!this.stopped) {
+          (_b = this.onIdle) == null ? void 0 : _b.call(this);
+        }
+      }
+    });
   }
 };
 
@@ -129,13 +176,13 @@ var CheckDataCoordinator = class {
   constructor(bundleModel) {
     this.bundleModel = bundleModel;
     this.taskQueue = new TaskQueue({
-      process: async (request) => {
-        const result = await this.bundleModel.getDatasetsForScenario(request.scenarioSpec, [request.datasetKey]);
+      process: (request) => __async(this, null, function* () {
+        const result = yield this.bundleModel.getDatasetsForScenario(request.scenarioSpec, [request.datasetKey]);
         const dataset = result.datasetMap.get(request.datasetKey);
         return {
           dataset
         };
-      }
+      })
     });
   }
   requestDataset(requestKey, scenarioSpec, datasetKey, onResponse) {
@@ -1688,6 +1735,24 @@ var CheckPlanner = class {
       dataRefs: this.dataRefs
     };
   }
+  /**
+   * Record any references to additional datasets contained in the given predicate.
+   * For example, if the predicate is:
+   * ```
+   *   gt:
+   *     dataset:
+   *       name: 'XYZ'
+   *     scenario:
+   *       inputs: all
+   *       at: default
+   * ```
+   * this will add a reference to the scenario/dataset pair so that the data can
+   * be fetched in a later stage.
+   *
+   * @param predicateSpec The predicate spec.
+   * @param checkScenario The scenario in which the dataset is being checked.
+   * @param checkDataset The dataset that is being checked.
+   */
   addDataRefs(predicateSpec, checkScenario, checkDataset) {
     let dataRefs;
     const addDataRef = (op) => {
@@ -1816,7 +1881,7 @@ var ComparisonDataCoordinator = class {
     this.bundleModelL = bundleModelL;
     this.bundleModelR = bundleModelR;
     this.taskQueue = new TaskQueue({
-      process: async (request) => {
+      process: (request) => __async(this, null, function* () {
         switch (request.kind) {
           case "dataset":
             return this.processDatasetRequest(request);
@@ -1825,44 +1890,52 @@ var ComparisonDataCoordinator = class {
           default:
             (0, import_assert_never7.assertNever)(request);
         }
-      }
+      })
     });
   }
-  async processDatasetRequest(request) {
-    async function fetchDatasets(bundleModel, scenarioSpec) {
-      if (scenarioSpec) {
-        return bundleModel.getDatasetsForScenario(scenarioSpec, request.datasetKeys);
-      } else {
-        return void 0;
+  processDatasetRequest(request) {
+    return __async(this, null, function* () {
+      function fetchDatasets(bundleModel, scenarioSpec) {
+        return __async(this, null, function* () {
+          if (scenarioSpec) {
+            return bundleModel.getDatasetsForScenario(scenarioSpec, request.datasetKeys);
+          } else {
+            return void 0;
+          }
+        });
       }
-    }
-    const [resultL, resultR] = await Promise.all([
-      fetchDatasets(this.bundleModelL, request.scenarioSpecL),
-      fetchDatasets(this.bundleModelR, request.scenarioSpecR)
-    ]);
-    return {
-      kind: "dataset",
-      datasetMapL: resultL == null ? void 0 : resultL.datasetMap,
-      datasetMapR: resultR == null ? void 0 : resultR.datasetMap
-    };
+      const [resultL, resultR] = yield Promise.all([
+        fetchDatasets(this.bundleModelL, request.scenarioSpecL),
+        fetchDatasets(this.bundleModelR, request.scenarioSpecR)
+      ]);
+      return {
+        kind: "dataset",
+        datasetMapL: resultL == null ? void 0 : resultL.datasetMap,
+        datasetMapR: resultR == null ? void 0 : resultR.datasetMap
+      };
+    });
   }
-  async processGraphDataRequest(request) {
-    async function fetchGraphData(bundleModel, scenarioSpec) {
-      if (scenarioSpec) {
-        return bundleModel.getGraphDataForScenario(scenarioSpec, request.graphId);
-      } else {
-        return void 0;
+  processGraphDataRequest(request) {
+    return __async(this, null, function* () {
+      function fetchGraphData(bundleModel, scenarioSpec) {
+        return __async(this, null, function* () {
+          if (scenarioSpec) {
+            return bundleModel.getGraphDataForScenario(scenarioSpec, request.graphId);
+          } else {
+            return void 0;
+          }
+        });
       }
-    }
-    const [graphDataL, graphDataR] = await Promise.all([
-      fetchGraphData(this.bundleModelL, request.scenarioSpecL),
-      fetchGraphData(this.bundleModelR, request.scenarioSpecR)
-    ]);
-    return {
-      kind: "graph-data",
-      graphDataL,
-      graphDataR
-    };
+      const [graphDataL, graphDataR] = yield Promise.all([
+        fetchGraphData(this.bundleModelL, request.scenarioSpecL),
+        fetchGraphData(this.bundleModelR, request.scenarioSpecR)
+      ]);
+      return {
+        kind: "graph-data",
+        graphDataL,
+        graphDataR
+      };
+    });
   }
   requestDatasetMaps(requestKey, scenarioSpecL, scenarioSpecR, datasetKeys, onResponse) {
     const request = {
@@ -2298,7 +2371,9 @@ function compareScores(a, b) {
 // src/bundle/model-inputs.ts
 var ModelInputs = class {
   constructor(modelSpec) {
+    /** All inputs keyed by lookup name (lowercase variable name or alias). */
     this.inputsByLookupName = /* @__PURE__ */ new Map();
+    /** All input ID aliases. */
     this.inputIdAliases = /* @__PURE__ */ new Set();
     for (const inputVar of modelSpec.inputVars.values()) {
       const varNameKey = inputVar.varName.toLowerCase();
@@ -2328,9 +2403,17 @@ var ModelInputs = class {
       }
     }
   }
+  /**
+   * Return the set of `id XYZ` aliases for all input variables.
+   */
   getAllInputIdAliases() {
     return [...this.inputIdAliases];
   }
+  /**
+   * Return the `InputVar` that matches the requested name (either by variable name or alias).
+   *
+   * @param name The variable name or alias to match.
+   */
   getInputVarForName(name) {
     return this.inputsByLookupName.get(name.toLowerCase());
   }
@@ -2352,6 +2435,9 @@ var comparison_schema_default = {
     $ref: "#/$defs/top_level_array_item"
   },
   $defs: {
+    //
+    // TOP-LEVEL
+    //
     top_level_array_item: {
       oneOf: [
         { $ref: "#/$defs/scenario_array_item" },
@@ -2359,6 +2445,9 @@ var comparison_schema_default = {
         { $ref: "#/$defs/view_group_array_item" }
       ]
     },
+    //
+    // SCENARIOS
+    //
     scenario_array_item: {
       type: "object",
       additionalProperties: false,
@@ -2375,7 +2464,9 @@ var comparison_schema_default = {
         { $ref: "#/$defs/scenario_with_input_at_value" },
         { $ref: "#/$defs/scenario_with_multiple_input_settings" },
         { $ref: "#/$defs/scenario_with_inputs_in_preset_at_position" },
+        // { $ref: '#/$defs/scenario_with_inputs_in_group_at_position' }
         { $ref: "#/$defs/scenario_preset" }
+        // { $ref: '#/$defs/scenario_expand_for_each_input_in_group' }
       ]
     },
     scenario_position: {
@@ -2515,6 +2606,9 @@ var comparison_schema_default = {
       },
       required: ["preset"]
     },
+    //
+    // SCENARIO GROUPS
+    //
     scenario_group_array_item: {
       type: "object",
       additionalProperties: false,
@@ -2590,6 +2684,9 @@ var comparison_schema_default = {
       },
       required: ["scenario_group_ref"]
     },
+    //
+    // VIEWS
+    //
     view: {
       type: "object",
       additionalProperties: false,
@@ -2623,6 +2720,9 @@ var comparison_schema_default = {
       },
       minItems: 1
     },
+    //
+    // VIEW GROUPS
+    //
     view_group_array_item: {
       type: "object",
       additionalProperties: false,
@@ -2906,15 +3006,18 @@ function scenarioSpecFromInputs(inputs, side) {
     if (state.inputVar === void 0) {
       return void 0;
     }
-    const varId = state.inputVar.varId;
-    if (state.position) {
-      settings.push(positionSetting(varId, state.position));
-    } else {
-      settings.push(valueSetting(varId, state.value));
-    }
+    settings.push(inputSettingFromResolvedInputState(state));
   }
   return inputSettingsSpec(settings);
 }
+function inputSettingFromResolvedInputState(state) {
+  const varId = state.inputVar.varId;
+  if (state.position) {
+    return positionSetting(varId, state.position);
+  } else {
+    return valueSetting(varId, state.value);
+  }
+}
 
 // src/comparison/config/resolve/comparison-resolver.ts
 function resolveComparisonSpecs(modelInputsL, modelInputsR, specs) {
@@ -2950,7 +3053,7 @@ function resolveComparisonSpecs(modelInputsL, modelInputsR, specs) {
       if (scenarioItem.kind === "scenario-ref") {
         const referencedScenario = resolvedScenarios.getScenarioForId(scenarioItem.scenarioId);
         if (referencedScenario) {
-          const resolvedScenario = { ...referencedScenario };
+          const resolvedScenario = __spreadValues({}, referencedScenario);
           if (scenarioItem.title) {
             resolvedScenario.title = scenarioItem.title;
           }
@@ -2988,7 +3091,9 @@ function resolveComparisonSpecs(modelInputsL, modelInputsR, specs) {
 }
 var ResolvedScenarios = class {
   constructor() {
+    /** The array of all resolved scenarios. */
     this.resolvedScenarios = [];
+    /** The set of resolved scenarios that include an ID, keyed by ID. */
     this.resolvedScenariosById = /* @__PURE__ */ new Map();
   }
   add(scenarios) {
@@ -3038,6 +3143,20 @@ function resolveScenariosFromSpec(modelInputsL, modelInputsR, scenarioSpec, genK
         )
       ];
     }
+    case "scenario-with-distinct-inputs": {
+      return [
+        resolveScenarioForDistinctInputSpecs(
+          modelInputsL,
+          modelInputsR,
+          genKey(),
+          scenarioSpec.id,
+          scenarioSpec.title,
+          scenarioSpec.subtitle,
+          scenarioSpec.inputsL,
+          scenarioSpec.inputsR
+        )
+      ];
+    }
     default:
       (0, import_assert_never11.assertNever)(scenarioSpec);
   }
@@ -3114,6 +3233,59 @@ function resolveScenarioForInputSpecs(modelInputsL, modelInputsR, key, id, title
     specR
   };
 }
+function resolveScenarioForDistinctInputSpecs(modelInputsL, modelInputsR, key, id, title, subtitle, inputSpecsL, inputSpecsR) {
+  const inputsWithErrors = [];
+  const settingsL = [];
+  const settingsR = [];
+  function resolveInputSpec(side, modelInputs, inputSpec) {
+    let inputState;
+    switch (inputSpec.kind) {
+      case "input-at-position":
+        inputState = resolveInputForNameInModel(modelInputs, inputSpec.inputName, inputSpec.position);
+        break;
+      case "input-at-value":
+        inputState = resolveInputForNameInModel(modelInputs, inputSpec.inputName, inputSpec.value);
+        break;
+      default:
+        (0, import_assert_never11.assertNever)(inputSpec);
+    }
+    if (inputState.error !== void 0) {
+      inputsWithErrors.push({
+        requestedName: inputSpec.inputName,
+        stateL: side === "left" ? inputState : {},
+        stateR: side === "right" ? inputState : {}
+      });
+    } else {
+      const inputSetting = inputSettingFromResolvedInputState(inputState);
+      if (side === "left") {
+        settingsL.push(inputSetting);
+      } else {
+        settingsR.push(inputSetting);
+      }
+    }
+  }
+  inputSpecsL.forEach((inputSpec) => resolveInputSpec("left", modelInputsL, inputSpec));
+  inputSpecsR.forEach((inputSpec) => resolveInputSpec("right", modelInputsR, inputSpec));
+  let specL;
+  let specR;
+  if (inputsWithErrors.length === 0) {
+    specL = inputSettingsSpec(settingsL);
+    specR = inputSettingsSpec(settingsR);
+  }
+  return {
+    kind: "scenario",
+    key,
+    id,
+    title,
+    subtitle,
+    settings: {
+      kind: "input-settings",
+      inputs: inputsWithErrors
+    },
+    specL,
+    specR
+  };
+}
 function resolveInputForName(modelInputsL, modelInputsR, inputName, at) {
   return {
     requestedName: inputName,
@@ -3189,7 +3361,9 @@ function inputValueAtPosition2(inputVar, position) {
 }
 var ResolvedScenarioGroups = class {
   constructor() {
+    /** The array of all resolved scenario groups. */
     this.resolvedGroups = [];
+    /** The set of resolved scenario groups that include an ID, keyed by ID. */
     this.resolvedGroupsById = /* @__PURE__ */ new Map();
   }
   add(group) {
@@ -3361,6 +3535,11 @@ function getComparisonDatasets(modelSpecL, modelSpecR, datasetOptions) {
   return new ComparisonDatasetsImpl(modelSpecL, modelSpecR, datasetOptions);
 }
 var ComparisonDatasetsImpl = class {
+  /**
+   * @param modelSpecL The model spec for the "left" bundle being compared.
+   * @param modelSpecR The model spec for the "right" bundle being compared.
+   * @param datasetOptions The custom configuration for the datasets to be compared.
+   */
   constructor(modelSpecL, modelSpecR, datasetOptions) {
     this.datasetOptions = datasetOptions;
     const renamedDatasetKeys = datasetOptions == null ? void 0 : datasetOptions.renamedDatasetKeys;
@@ -3399,12 +3578,15 @@ var ComparisonDatasetsImpl = class {
       });
     }
   }
+  // from ComparisonDatasets interface
   getAllDatasets() {
     return this.allDatasets.values();
   }
+  // from ComparisonDatasets interface
   getDataset(datasetKey) {
     return this.allDatasets.get(datasetKey);
   }
+  // from ComparisonDatasets interface
   getDatasetKeysForScenario(scenario) {
     var _a;
     if (((_a = this.datasetOptions) == null ? void 0 : _a.datasetKeysForScenario) !== void 0) {
@@ -3430,9 +3612,17 @@ var ComparisonScenariosImpl = class {
       this.scenarioDefs.set(scenario.key, scenario);
     }
   }
+  /**
+   * Return all `ComparisonScenario` instances that are available for comparisons.
+   */
   getAllScenarios() {
     return this.scenarioDefs.values();
   }
+  /**
+   * Return the scenario definition for the given key.
+   *
+   * @param key The key for the scenario.
+   */
   getScenario(key) {
     return this.scenarioDefs.get(key);
   }
@@ -3459,11 +3649,11 @@ var PromiseQueue = class {
   }
   add(f) {
     return new Promise((resolve, reject) => {
-      const run = async () => {
+      const run = () => __async(this, null, function* () {
         this.runningCount++;
         const promise = f();
         try {
-          const result = await promise;
+          const result = yield promise;
           resolve(result);
         } catch (e) {
           reject(e);
@@ -3471,7 +3661,7 @@ var PromiseQueue = class {
           this.runningCount--;
           this.runNext();
         }
-      };
+      });
       if (this.runningCount < 1) {
         run();
       } else {
@@ -3490,81 +3680,84 @@ var PromiseQueue = class {
 };
 
 // src/config/config.ts
-async function createConfig(options) {
-  var _a;
-  const origCurrentBundle = await loadSynchronized(options.current);
-  let currentBundle;
-  let comparisonConfig;
-  if (options.comparison === void 0) {
-    currentBundle = origCurrentBundle;
-  } else {
-    const baselineBundle = await loadSynchronized(options.comparison.baseline);
-    const renamedDatasetKeys = (_a = options.comparison.datasets) == null ? void 0 : _a.renamedDatasetKeys;
-    const invertedRenamedKeys = /* @__PURE__ */ new Map();
-    renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.forEach((newKey, oldKey) => {
-      invertedRenamedKeys.set(newKey, oldKey);
-    });
-    const rightKeyForLeftKey = (leftKey) => {
-      return (renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.get(leftKey)) || leftKey;
-    };
-    const leftKeyForRightKey = (rightKey) => {
-      return invertedRenamedKeys.get(rightKey) || rightKey;
-    };
-    const origBundleModelR = origCurrentBundle.model;
-    const adjBundleModelR = {
-      modelSpec: origBundleModelR.modelSpec,
-      getDatasetsForScenario: async (scenarioSpec, datasetKeys) => {
-        const rightKeys = datasetKeys.map(rightKeyForLeftKey);
-        const result = await origBundleModelR.getDatasetsForScenario(scenarioSpec, rightKeys);
-        const mapWithRightKeys = result.datasetMap;
-        const mapWithLeftKeys = /* @__PURE__ */ new Map();
-        for (const [rightKey, dataset] of mapWithRightKeys.entries()) {
-          const leftKey = leftKeyForRightKey(rightKey);
-          mapWithLeftKeys.set(leftKey, dataset);
-        }
-        return {
-          datasetMap: mapWithLeftKeys,
-          modelRunTime: result.modelRunTime
-        };
-      },
-      getGraphDataForScenario: origBundleModelR.getGraphDataForScenario.bind(origBundleModelR),
-      getGraphLinksForScenario: origBundleModelR.getGraphLinksForScenario.bind(origBundleModelR)
-    };
-    currentBundle = {
-      ...origCurrentBundle,
-      model: adjBundleModelR
+function createConfig(options) {
+  return __async(this, null, function* () {
+    var _a;
+    const origCurrentBundle = yield loadSynchronized(options.current);
+    let currentBundle;
+    let comparisonConfig;
+    if (options.comparison === void 0) {
+      currentBundle = origCurrentBundle;
+    } else {
+      const baselineBundle = yield loadSynchronized(options.comparison.baseline);
+      const renamedDatasetKeys = (_a = options.comparison.datasets) == null ? void 0 : _a.renamedDatasetKeys;
+      const invertedRenamedKeys = /* @__PURE__ */ new Map();
+      renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.forEach((newKey, oldKey) => {
+        invertedRenamedKeys.set(newKey, oldKey);
+      });
+      const rightKeyForLeftKey = (leftKey) => {
+        return (renamedDatasetKeys == null ? void 0 : renamedDatasetKeys.get(leftKey)) || leftKey;
+      };
+      const leftKeyForRightKey = (rightKey) => {
+        return invertedRenamedKeys.get(rightKey) || rightKey;
+      };
+      const origBundleModelR = origCurrentBundle.model;
+      const adjBundleModelR = {
+        modelSpec: origBundleModelR.modelSpec,
+        getDatasetsForScenario: (scenarioSpec, datasetKeys) => __async(this, null, function* () {
+          const rightKeys = datasetKeys.map(rightKeyForLeftKey);
+          const result = yield origBundleModelR.getDatasetsForScenario(scenarioSpec, rightKeys);
+          const mapWithRightKeys = result.datasetMap;
+          const mapWithLeftKeys = /* @__PURE__ */ new Map();
+          for (const [rightKey, dataset] of mapWithRightKeys.entries()) {
+            const leftKey = leftKeyForRightKey(rightKey);
+            mapWithLeftKeys.set(leftKey, dataset);
+          }
+          return {
+            datasetMap: mapWithLeftKeys,
+            modelRunTime: result.modelRunTime
+          };
+        }),
+        getGraphDataForScenario: origBundleModelR.getGraphDataForScenario.bind(origBundleModelR),
+        getGraphLinksForScenario: origBundleModelR.getGraphLinksForScenario.bind(origBundleModelR)
+      };
+      currentBundle = __spreadProps(__spreadValues({}, origCurrentBundle), {
+        model: adjBundleModelR
+      });
+      const modelSpecL = baselineBundle.model.modelSpec;
+      const modelSpecR = currentBundle.model.modelSpec;
+      const modelInputsL = new ModelInputs(modelSpecL);
+      const modelInputsR = new ModelInputs(modelSpecR);
+      const comparisonDefs = resolveComparisonSpecsFromSources(modelInputsL, modelInputsR, options.comparison.specs);
+      comparisonConfig = {
+        bundleL: baselineBundle,
+        bundleR: currentBundle,
+        thresholds: options.comparison.thresholds,
+        scenarios: getComparisonScenarios(comparisonDefs.scenarios),
+        datasets: getComparisonDatasets(modelSpecL, modelSpecR, options.comparison.datasets),
+        viewGroups: comparisonDefs.viewGroups
+      };
+    }
+    const checkConfig = {
+      bundle: currentBundle,
+      tests: options.check.tests
     };
-    const modelSpecL = baselineBundle.model.modelSpec;
-    const modelSpecR = currentBundle.model.modelSpec;
-    const modelInputsL = new ModelInputs(modelSpecL);
-    const modelInputsR = new ModelInputs(modelSpecR);
-    const comparisonDefs = resolveComparisonSpecsFromSources(modelInputsL, modelInputsR, options.comparison.specs);
-    comparisonConfig = {
-      bundleL: baselineBundle,
-      bundleR: currentBundle,
-      thresholds: options.comparison.thresholds,
-      scenarios: getComparisonScenarios(comparisonDefs.scenarios),
-      datasets: getComparisonDatasets(modelSpecL, modelSpecR, options.comparison.datasets),
-      viewGroups: comparisonDefs.viewGroups
+    return {
+      check: checkConfig,
+      comparison: comparisonConfig
     };
-  }
-  const checkConfig = {
-    bundle: currentBundle,
-    tests: options.check.tests
-  };
-  return {
-    check: checkConfig,
-    comparison: comparisonConfig
-  };
+  });
 }
-async function loadSynchronized(sourceBundle) {
-  const sourceModel = await sourceBundle.bundle.initModel();
-  const synchronizedModel = synchronizedBundleModel(sourceModel);
-  return {
-    name: sourceBundle.name,
-    version: sourceBundle.bundle.version,
-    model: synchronizedModel
-  };
+function loadSynchronized(sourceBundle) {
+  return __async(this, null, function* () {
+    const sourceModel = yield sourceBundle.bundle.initModel();
+    const synchronizedModel = synchronizedBundleModel(sourceModel);
+    return {
+      name: sourceBundle.name,
+      version: sourceBundle.bundle.version,
+      model: synchronizedModel
+    };
+  });
 }
 
 // src/perf/perf-runner.ts
@@ -3614,22 +3807,22 @@ var PerfRunner = class {
     this.mode = mode;
     const scenarioSpec = allInputsAtPositionSpec("at-default");
     this.taskQueue = new TaskQueue({
-      process: async (request) => {
+      process: (request) => __async(this, null, function* () {
         switch (request.kind) {
           case "left": {
-            const result = await bundleModelL.getDatasetsForScenario(scenarioSpec, []);
+            const result = yield bundleModelL.getDatasetsForScenario(scenarioSpec, []);
             return {
               runTimeL: result.modelRunTime
             };
           }
           case "right": {
-            const result = await bundleModelR.getDatasetsForScenario(scenarioSpec, []);
+            const result = yield bundleModelR.getDatasetsForScenario(scenarioSpec, []);
             return {
               runTimeR: result.modelRunTime
             };
           }
           case "both": {
-            const [resultL, resultR] = await Promise.all([
+            const [resultL, resultR] = yield Promise.all([
               bundleModelL.getDatasetsForScenario(scenarioSpec, []),
               bundleModelR.getDatasetsForScenario(scenarioSpec, [])
             ]);
@@ -3641,7 +3834,7 @@ var PerfRunner = class {
           default:
             (0, import_assert_never12.assertNever)(request.kind);
         }
-      }
+      })
     });
   }
   start() {
@@ -3689,13 +3882,31 @@ var PerfRunner = class {
 
 // src/data/data-planner.ts
 var DataPlanner = class {
+  /**
+   * @param batchSize The maximum number of impl vars that can be fetched
+   * with a single request; this is usually the same as the number of
+   * normal model outputs.
+   */
   constructor(batchSize) {
     this.batchSize = batchSize;
+    /** Tasks that need to access both "left" and "right" models in parallel. */
     this.taskSetsLR = /* @__PURE__ */ new Map();
+    /** Tasks that only need to access the "left" model. */
     this.taskSetsL = /* @__PURE__ */ new Map();
+    /** Tasks that only need to access the "right" model. */
     this.taskSetsR = /* @__PURE__ */ new Map();
     this.complete = false;
   }
+  /**
+   * Add a request to the plan for the given scenario(s) and data task.
+   *
+   * @param scenarioSpecL The input scenario used to configure the "left" model, or undefined if no data
+   * is needed from the left model.
+   * @param scenarioSpecR The input scenario used to configure the "right" model, or undefined if no data
+   * is needed from the right model.
+   * @param datasetKey The key for the dataset to be fetched from each model for the given scenario.
+   * @param dataAction The action to be performed with the fetched datasets.
+   */
   addRequest(scenarioSpecL, scenarioSpecR, datasetKey, dataAction) {
     if (scenarioSpecL === void 0 && scenarioSpecR === void 0) {
       console.warn("WARNING: Both scenario specs are undefined for DataPlanner request, skipping");
@@ -3723,6 +3934,9 @@ var DataPlanner = class {
       dataAction
     });
   }
+  /**
+   * Build a plan that minimizes the number of data fetches needed.
+   */
   buildPlan() {
     if (this.complete) {
       throw new Error("DataPlanner.buildPlan() can only be called once");
@@ -3773,6 +3987,12 @@ var DataTaskSet = class {
     this.modelTasks = /* @__PURE__ */ new Map();
     this.modelImplTasks = /* @__PURE__ */ new Map();
   }
+  /**
+   * Add a task that will be performed when the data is fetched for the scenario(s)
+   * associated with this task set.
+   *
+   * @param dataTask A task that performs an action using the fetched dataset(s).
+   */
   addTask(dataTask) {
     let taskMap;
     if (dataTask.datasetKey.startsWith("ModelImpl")) {
@@ -3787,6 +4007,11 @@ var DataTaskSet = class {
     }
     tasks.push(dataTask);
   }
+  /**
+   * Add all tasks from the given set into this set.
+   *
+   * @param otherTaskSet The other task set that will be merged into this one.
+   */
   merge(otherTaskSet) {
     for (const tasks of otherTaskSet.modelTasks.values()) {
       for (const task of tasks) {
@@ -3799,6 +4024,12 @@ var DataTaskSet = class {
       }
     }
   }
+  /**
+   * Create one or more data requests that can be used to fetch data for the configured scenario(s).
+   *
+   * @param batchSize The maximum number of impl vars that can be fetched with a single request.
+   * This is usually the same as the number of normal model outputs.
+   */
   buildRequests(batchSize) {
     const dataRequests = [];
     if (this.modelTasks.size > 0) {
@@ -4034,42 +4265,46 @@ var SuiteRunner = class {
       });
     }
   }
-  async processRequest(request) {
-    var _a, _b;
-    const datasetKeySet = /* @__PURE__ */ new Set();
-    for (const dataTask of request.dataTasks) {
-      datasetKeySet.add(dataTask.datasetKey);
-    }
-    const datasetKeys = [...datasetKeySet];
-    async function getDatasets(bundleModel, scenarioSpec) {
-      if (bundleModel && scenarioSpec) {
-        return bundleModel.getDatasetsForScenario(scenarioSpec, datasetKeys);
-      } else {
-        return void 0;
+  processRequest(request) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const datasetKeySet = /* @__PURE__ */ new Set();
+      for (const dataTask of request.dataTasks) {
+        datasetKeySet.add(dataTask.datasetKey);
       }
-    }
-    const bundleModelL = (_a = this.config.comparison) == null ? void 0 : _a.bundleL.model;
-    const bundleModelR = ((_b = this.config.comparison) == null ? void 0 : _b.bundleR.model) || this.config.check.bundle.model;
-    const [datasetsResultL, datasetsResultR] = await Promise.all([
-      getDatasets(bundleModelL, request.scenarioSpecL),
-      getDatasets(bundleModelR, request.scenarioSpecR)
-    ]);
-    if (datasetsResultL == null ? void 0 : datasetsResultL.modelRunTime) {
-      this.perfStatsL.addRun(datasetsResultL == null ? void 0 : datasetsResultL.modelRunTime);
-    }
-    if (datasetsResultR == null ? void 0 : datasetsResultR.modelRunTime) {
-      this.perfStatsR.addRun(datasetsResultR == null ? void 0 : datasetsResultR.modelRunTime);
-    }
-    const datasetMapL = datasetsResultL == null ? void 0 : datasetsResultL.datasetMap;
-    const datasetMapR = datasetsResultR == null ? void 0 : datasetsResultR.datasetMap;
-    for (const dataTask of request.dataTasks) {
-      const datasetL = datasetMapL == null ? void 0 : datasetMapL.get(dataTask.datasetKey);
-      const datasetR = datasetMapR == null ? void 0 : datasetMapR.get(dataTask.datasetKey);
-      dataTask.dataAction({
-        datasetL,
-        datasetR
-      });
-    }
+      const datasetKeys = [...datasetKeySet];
+      function getDatasets(bundleModel, scenarioSpec) {
+        return __async(this, null, function* () {
+          if (bundleModel && scenarioSpec) {
+            return bundleModel.getDatasetsForScenario(scenarioSpec, datasetKeys);
+          } else {
+            return void 0;
+          }
+        });
+      }
+      const bundleModelL = (_a = this.config.comparison) == null ? void 0 : _a.bundleL.model;
+      const bundleModelR = ((_b = this.config.comparison) == null ? void 0 : _b.bundleR.model) || this.config.check.bundle.model;
+      const [datasetsResultL, datasetsResultR] = yield Promise.all([
+        getDatasets(bundleModelL, request.scenarioSpecL),
+        getDatasets(bundleModelR, request.scenarioSpecR)
+      ]);
+      if (datasetsResultL == null ? void 0 : datasetsResultL.modelRunTime) {
+        this.perfStatsL.addRun(datasetsResultL == null ? void 0 : datasetsResultL.modelRunTime);
+      }
+      if (datasetsResultR == null ? void 0 : datasetsResultR.modelRunTime) {
+        this.perfStatsR.addRun(datasetsResultR == null ? void 0 : datasetsResultR.modelRunTime);
+      }
+      const datasetMapL = datasetsResultL == null ? void 0 : datasetsResultL.datasetMap;
+      const datasetMapR = datasetsResultR == null ? void 0 : datasetsResultR.datasetMap;
+      for (const dataTask of request.dataTasks) {
+        const datasetL = datasetMapL == null ? void 0 : datasetMapL.get(dataTask.datasetKey);
+        const datasetR = datasetMapR == null ? void 0 : datasetMapR.get(dataTask.datasetKey);
+        dataTask.dataAction({
+          datasetL,
+          datasetR
+        });
+      }
+    });
   }
 };
 function runSuite(config, callbacks, options) {