@sdeverywhere/check-core 0.1.9 → 0.1.11

package/dist/index.js

@@ -322,13 +322,29 @@ var CheckDataCoordinator = class {
   constructor(taskQueue) {
     this.taskQueue = taskQueue;
   }
-  requestDataset(requestKey, scenarioSpec, datasetKey, onResponse) {
+  /**
+   * Request a dataset from the model.
+   *
+   * @param requestKey The unique key for the request.
+   * @param scenarioSpec The scenario spec that defines the inputs for the model run.
+   * @param datasetKey The key of the dataset to be fetched.
+   * @param options Optional configuration including constant and lookup overrides.
+   * @param onResponse The callback that will be called with the dataset.
+   */
+  requestDataset(requestKey, scenarioSpec, datasetKey, options, onResponse) {
     const task = {
       key: requestKey,
       kind: "check-data-coordinator",
       process: (bundleModels) => __async(null, null, function* () {
         const bundleModelR = bundleModels.R;
-        const result = yield bundleModelR.getDatasetsForScenario(scenarioSpec, [datasetKey]);
+        let getDatasetsOptions;
+        if ((options == null ? void 0 : options.constants) || (options == null ? void 0 : options.lookups)) {
+          getDatasetsOptions = {
+            constants: options.constants,
+            lookups: options.lookups
+          };
+        }
+        const result = yield bundleModelR.getDatasetsForScenario(scenarioSpec, [datasetKey], getDatasetsOptions);
         const dataset = result.datasetMap.get(datasetKey);
         onResponse(dataset);
       })
@@ -1596,9 +1612,25 @@ function inputValueAtPosition(inputVar, position) {
     case "at-default":
       return inputVar.defaultValue;
     case "at-minimum":
-      return inputVar.minValue;
+      switch (inputVar.kind) {
+        case "slider":
+          return inputVar.minValue;
+        case "switch":
+          return inputVar.offValue;
+        default:
+          assertNever4(inputVar);
+      }
+    // eslint-disable-next-line no-fallthrough
     case "at-maximum":
-      return inputVar.maxValue;
+      switch (inputVar.kind) {
+        case "slider":
+          return inputVar.maxValue;
+        case "switch":
+          return inputVar.onValue;
+        default:
+          assertNever4(inputVar);
+      }
+    // eslint-disable-next-line no-fallthrough
     default:
       assertNever4(position);
   }
@@ -2027,14 +2059,19 @@ var ComparisonDataCoordinator = class {
    * will be fetched from the "left" bundle's model, otherwise they will be fetched from
    * the "right" bundle's model.
    * @param scenarioSpecR The scenario used for the second ("right") model of the comparison.
-   * @param graphId The keys of the datasets to be fetched.
+   * @param datasetKeys The keys of the datasets to be fetched.
+   * @param options Optional configuration including constant and lookup overrides.
    * @param onResponse The callback that will be called with the dataset maps.
    */
-  requestDatasetMaps(requestKey, sourceL, scenarioSpecL, sourceR, scenarioSpecR, datasetKeys, onResponse) {
-    function fetchDatasets(bundleModel, scenarioSpec) {
+  requestDatasetMaps(requestKey, sourceL, scenarioSpecL, sourceR, scenarioSpecR, datasetKeys, options, onResponse) {
+    function fetchDatasets(bundleModel, scenarioSpec, constants, lookups) {
       return __async(this, null, function* () {
         if (scenarioSpec) {
-          return bundleModel.getDatasetsForScenario(scenarioSpec, datasetKeys);
+          let getDatasetsOptions;
+          if (constants || lookups) {
+            getDatasetsOptions = { constants, lookups };
+          }
+          return bundleModel.getDatasetsForScenario(scenarioSpec, datasetKeys, getDatasetsOptions);
         } else {
           return void 0;
         }
@@ -2049,12 +2086,12 @@ var ComparisonDataCoordinator = class {
         let resultL;
         let resultR;
         if (modelL === modelR) {
-          resultL = yield fetchDatasets(modelL, scenarioSpecL);
-          resultR = yield fetchDatasets(modelR, scenarioSpecR);
+          resultL = yield fetchDatasets(modelL, scenarioSpecL, options == null ? void 0 : options.constantsL, options == null ? void 0 : options.lookupsL);
+          resultR = yield fetchDatasets(modelR, scenarioSpecR, options == null ? void 0 : options.constantsR, options == null ? void 0 : options.lookupsR);
         } else {
           const results = yield Promise.all([
-            fetchDatasets(modelL, scenarioSpecL),
-            fetchDatasets(modelR, scenarioSpecR)
+            fetchDatasets(modelL, scenarioSpecL, options == null ? void 0 : options.constantsL, options == null ? void 0 : options.lookupsL),
+            fetchDatasets(modelR, scenarioSpecR, options == null ? void 0 : options.constantsR, options == null ? void 0 : options.lookupsR)
           ]);
           resultL = results[0];
           resultR = results[1];
@@ -3914,7 +3951,18 @@ function resolveInputVarAtPosition(inputVar, position) {
   };
 }
 function resolveInputVarAtValue(inputVar, value) {
-  if (value >= inputVar.minValue && value <= inputVar.maxValue) {
+  let inRange;
+  switch (inputVar.kind) {
+    case "slider":
+      inRange = value >= inputVar.minValue && value <= inputVar.maxValue;
+      break;
+    case "switch":
+      inRange = value === inputVar.offValue || value === inputVar.onValue;
+      break;
+    default:
+      assertNever10(inputVar);
+  }
+  if (inRange) {
     return {
       inputVar,
       value
@@ -3944,9 +3992,25 @@ function inputValueAtPosition2(inputVar, position) {
     case "at-default":
       return inputVar.defaultValue;
     case "at-minimum":
-      return inputVar.minValue;
+      switch (inputVar.kind) {
+        case "slider":
+          return inputVar.minValue;
+        case "switch":
+          return inputVar.offValue;
+        default:
+          assertNever10(inputVar);
+      }
+    // eslint-disable-next-line no-fallthrough
     case "at-maximum":
-      return inputVar.maxValue;
+      switch (inputVar.kind) {
+        case "slider":
+          return inputVar.maxValue;
+        case "switch":
+          return inputVar.onValue;
+        default:
+          assertNever10(inputVar);
+      }
+    // eslint-disable-next-line no-fallthrough
     default:
       assertNever10(position);
   }
@@ -4478,12 +4542,12 @@ function handleRenames(origCurrentBundle, renamedDatasetKeys) {
     var _a, _b, _c;
     return {
       modelSpec: origBundleModelR.modelSpec,
-      getDatasetsForScenario: (scenarioSpec, datasetKeys) => __async(null, null, function* () {
+      getDatasetsForScenario: (scenarioSpec, datasetKeys, options) => __async(null, null, function* () {
         const rightKeySet = /* @__PURE__ */ new Set();
         for (const key of datasetKeys) {
           rightKeySet.add(rightKeyForLeftKey(key));
         }
-        const result = yield origBundleModelR.getDatasetsForScenario(scenarioSpec, [...rightKeySet]);
+        const result = yield origBundleModelR.getDatasetsForScenario(scenarioSpec, [...rightKeySet], options);
         const resultMap = /* @__PURE__ */ new Map();
         for (const [rightKey, dataset] of result.datasetMap.entries()) {
           resultMap.set(rightKey, dataset);
@@ -4512,34 +4576,76 @@ function handleRenames(origCurrentBundle, renamedDatasetKeys) {
 import { assertNever as assertNever11 } from "assert-never";
 
 // src/perf/perf-stats.ts
+function percentile(sorted, p) {
+  if (sorted.length === 1) {
+    return sorted[0];
+  }
+  const rank = p * (sorted.length - 1);
+  const lo = Math.floor(rank);
+  const hi = Math.ceil(rank);
+  if (lo === hi) {
+    return sorted[lo];
+  }
+  const frac = rank - lo;
+  return sorted[lo] + (sorted[hi] - sorted[lo]) * frac;
+}
 var PerfStats = class {
   constructor() {
     this.times = [];
   }
+  /**
+   * Record a single run time sample.
+   *
+   * @param timeInMillis The run time in milliseconds.
+   */
   addRun(timeInMillis) {
     this.times.push(timeInMillis);
   }
+  /**
+   * Get the raw run time samples that have been recorded.
+   *
+   * @returns A copy of the recorded run times, in insertion order.
+   */
+  getTimes() {
+    return this.times.slice();
+  }
+  /**
+   * Produce a `PerfReport` summarizing the recorded samples.
+   *
+   * @returns The summary report.
+   */
   toReport() {
     if (this.times.length === 0) {
       return {
         minTime: 0,
         maxTime: 0,
         avgTime: 0,
+        medianTime: 0,
+        p95Time: 0,
+        stdDev: 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 sortedTimes = this.times.slice().sort((a, b) => a - b);
+    const n = sortedTimes.length;
+    const minTime = sortedTimes[0];
+    const maxTime = sortedTimes[n - 1];
+    const minIndex = Math.floor(n / 4);
+    const maxIndex = minIndex + Math.max(1, Math.ceil(n / 2));
     const middleTimes = sortedTimes.slice(minIndex, maxIndex);
-    const totalTime = middleTimes.reduce((a, b) => a + b, 0);
-    const avgTime = totalTime / middleTimes.length;
+    const avgTime = middleTimes.reduce((a, b) => a + b, 0) / middleTimes.length;
+    const medianTime = percentile(sortedTimes, 0.5);
+    const p95Time = percentile(sortedTimes, 0.95);
+    const mean = sortedTimes.reduce((a, b) => a + b, 0) / n;
+    const variance = sortedTimes.reduce((acc, t) => acc + (t - mean) * (t - mean), 0) / n;
+    const stdDev = Math.sqrt(variance);
     return {
       minTime,
       maxTime,
       avgTime,
+      medianTime,
+      p95Time,
+      stdDev,
       allTimes: sortedTimes
     };
   }
@@ -4981,8 +5087,12 @@ var DataPlanner = class {
    * 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.
+   * @param constantsL Optional constant overrides for the "left" model.
+   * @param constantsR Optional constant overrides for the "right" model.
+   * @param lookupsL Optional lookup overrides for the "left" model.
+   * @param lookupsR Optional lookup overrides for the "right" model.
    */
-  addRequest(scenarioSpecL, scenarioSpecR, datasetKey, dataAction) {
+  addRequest(scenarioSpecL, scenarioSpecR, datasetKey, dataAction, constantsL, constantsR, lookupsL, lookupsR) {
     if (scenarioSpecL === void 0 && scenarioSpecR === void 0) {
       console.warn("WARNING: Both scenario specs are undefined for DataPlanner request, skipping");
       return;
@@ -4991,17 +5101,17 @@ var DataPlanner = class {
     let uid;
     if (scenarioSpecL && scenarioSpecR) {
       taskSetsMap = this.taskSetsLR;
-      uid = scenarioPairUid(scenarioSpecL, scenarioSpecR);
+      uid = scenarioPairUid(scenarioSpecL, scenarioSpecR, constantsL, constantsR, lookupsL, lookupsR);
     } else if (scenarioSpecR) {
       taskSetsMap = this.taskSetsR;
-      uid = scenarioSpecR.uid;
+      uid = scenarioPairUid(void 0, scenarioSpecR, void 0, constantsR, void 0, lookupsR);
     } else {
       taskSetsMap = this.taskSetsL;
-      uid = scenarioSpecL.uid;
+      uid = scenarioPairUid(scenarioSpecL, void 0, constantsL, void 0, lookupsL, void 0);
     }
     let taskSet = taskSetsMap.get(uid);
     if (!taskSet) {
-      taskSet = new DataTaskSet(scenarioSpecL, scenarioSpecR);
+      taskSet = new DataTaskSet(scenarioSpecL, scenarioSpecR, constantsL, constantsR, lookupsL, lookupsR);
       taskSetsMap.set(uid, taskSet);
     }
     taskSet.addTask({
@@ -5020,26 +5130,33 @@ var DataPlanner = class {
     const lKeyMappings = /* @__PURE__ */ new Map();
     const rKeyMappings = /* @__PURE__ */ new Map();
     for (const lrUid of this.taskSetsLR.keys()) {
-      const [lUid, rUid] = lrUid.split("::");
-      if (!lKeyMappings.has(lUid)) {
-        lKeyMappings.set(lUid, lrUid);
+      const parsed = parsePairUid(lrUid);
+      const lKey = sideKey(parsed.lScenarioUid, parsed.lConstUid, parsed.lLookupUid);
+      const rKey = sideKey(parsed.rScenarioUid, parsed.rConstUid, parsed.rLookupUid);
+      if (parsed.lScenarioUid && !lKeyMappings.has(lKey)) {
+        lKeyMappings.set(lKey, lrUid);
       }
-      if (!rKeyMappings.has(rUid)) {
-        rKeyMappings.set(rUid, lrUid);
+      if (parsed.rScenarioUid && !rKeyMappings.has(rKey)) {
+        rKeyMappings.set(rKey, lrUid);
       }
     }
-    function merge(taskSetsLR, taskSetsForSide, keyMappingsForSide) {
-      for (const [keyForSide, taskSetForSide] of taskSetsForSide.entries()) {
-        const lrKey = keyMappingsForSide.get(keyForSide);
+    function merge(taskSetsLR, taskSetsForSide, keyMappingsForSide, side) {
+      for (const [pairUidForSide, taskSetForSide] of taskSetsForSide.entries()) {
+        const parsed = parsePairUid(pairUidForSide);
+        const scenarioUid = side === "L" ? parsed.lScenarioUid : parsed.rScenarioUid;
+        const constUid = side === "L" ? parsed.lConstUid : parsed.rConstUid;
+        const lookupUid = side === "L" ? parsed.lLookupUid : parsed.rLookupUid;
+        const sKey = sideKey(scenarioUid, constUid, lookupUid);
+        const lrKey = keyMappingsForSide.get(sKey);
         if (lrKey) {
           const taskSetLR = taskSetsLR.get(lrKey);
           taskSetLR.merge(taskSetForSide);
-          taskSetsForSide.delete(keyForSide);
+          taskSetsForSide.delete(pairUidForSide);
         }
       }
     }
-    merge(this.taskSetsLR, this.taskSetsL, lKeyMappings);
-    merge(this.taskSetsLR, this.taskSetsR, rKeyMappings);
+    merge(this.taskSetsLR, this.taskSetsL, lKeyMappings, "L");
+    merge(this.taskSetsLR, this.taskSetsR, rKeyMappings, "R");
     const requests = [];
     const batchSize = this.batchSize;
     function addRequests(taskSets) {
@@ -5056,9 +5173,13 @@ var DataPlanner = class {
   }
 };
 var DataTaskSet = class {
-  constructor(scenarioSpecL, scenarioSpecR) {
+  constructor(scenarioSpecL, scenarioSpecR, constantsL, constantsR, lookupsL, lookupsR) {
     this.scenarioSpecL = scenarioSpecL;
     this.scenarioSpecR = scenarioSpecR;
+    this.constantsL = constantsL;
+    this.constantsR = constantsR;
+    this.lookupsL = lookupsL;
+    this.lookupsR = lookupsR;
     this.modelTasks = /* @__PURE__ */ new Map();
     this.modelImplTasks = /* @__PURE__ */ new Map();
   }
@@ -5113,6 +5234,10 @@ var DataTaskSet = class {
       dataRequests.push({
         scenarioSpecL: this.scenarioSpecL,
         scenarioSpecR: this.scenarioSpecR,
+        constantsL: this.constantsL,
+        constantsR: this.constantsR,
+        lookupsL: this.lookupsL,
+        lookupsR: this.lookupsR,
         dataTasks
       });
     }
@@ -5127,6 +5252,10 @@ var DataTaskSet = class {
         dataRequests.push({
           scenarioSpecL: this.scenarioSpecL,
           scenarioSpecR: this.scenarioSpecR,
+          constantsL: this.constantsL,
+          constantsR: this.constantsR,
+          lookupsL: this.lookupsL,
+          lookupsR: this.lookupsR,
           dataTasks
         });
       }
@@ -5134,10 +5263,76 @@ var DataTaskSet = class {
     return dataRequests;
   }
 };
-function scenarioPairUid(scenarioSpecL, scenarioSpecR) {
+function constantsUid(constants) {
+  if (!constants || constants.length === 0) {
+    return "";
+  }
+  const sorted = [...constants].sort((a, b) => a.varId.localeCompare(b.varId));
+  return sorted.map((c) => `${c.varId}=${c.value}`).join(",");
+}
+function lookupsUid(lookups) {
+  if (!lookups || lookups.length === 0) {
+    return "";
+  }
+  const sorted = [...lookups].sort((a, b) => a.varId.localeCompare(b.varId));
+  return sorted.map((l) => {
+    if (l.points === void 0) {
+      return `${l.varId}=`;
+    }
+    return `${l.varId}=[${l.points.join(",")}]`;
+  }).join(";");
+}
+function sideKey(scenarioUid, constUid, lookupUid) {
+  let key = scenarioUid;
+  if (constUid) {
+    key += `##${constUid}`;
+  }
+  if (lookupUid) {
+    key += `%%${lookupUid}`;
+  }
+  return key;
+}
+function parsePairUid(pairUid) {
+  var _a, _b, _c, _d, _e, _f;
+  let rest = pairUid;
+  let lookupsPart = "";
+  const lookupsIdx = rest.indexOf("%%");
+  if (lookupsIdx >= 0) {
+    lookupsPart = rest.substring(lookupsIdx + 2);
+    rest = rest.substring(0, lookupsIdx);
+  }
+  let constantsPart = "";
+  const constantsIdx = rest.indexOf("##");
+  if (constantsIdx >= 0) {
+    constantsPart = rest.substring(constantsIdx + 2);
+    rest = rest.substring(0, constantsIdx);
+  }
+  const scenarioParts = rest.split("::");
+  const lScenarioUid = (_a = scenarioParts[0]) != null ? _a : "";
+  const rScenarioUid = (_b = scenarioParts[1]) != null ? _b : "";
+  const constantsParts = constantsPart.split("||");
+  const lConstUid = constantsPart ? (_c = constantsParts[0]) != null ? _c : "" : "";
+  const rConstUid = constantsPart ? (_d = constantsParts[1]) != null ? _d : "" : "";
+  const lookupsParts = lookupsPart.split("||");
+  const lLookupUid = lookupsPart ? (_e = lookupsParts[0]) != null ? _e : "" : "";
+  const rLookupUid = lookupsPart ? (_f = lookupsParts[1]) != null ? _f : "" : "";
+  return { lScenarioUid, rScenarioUid, lConstUid, rConstUid, lLookupUid, rLookupUid };
+}
+function scenarioPairUid(scenarioSpecL, scenarioSpecR, constantsL, constantsR, lookupsL, lookupsR) {
   const uidL = (scenarioSpecL == null ? void 0 : scenarioSpecL.uid) || "";
   const uidR = (scenarioSpecR == null ? void 0 : scenarioSpecR.uid) || "";
-  return `${uidL}::${uidR}`;
+  let uid = `${uidL}::${uidR}`;
+  const constUidL = constantsUid(constantsL);
+  const constUidR = constantsUid(constantsR);
+  if (constUidL || constUidR) {
+    uid += `##${constUidL}||${constUidR}`;
+  }
+  const lookupUidL = lookupsUid(lookupsL);
+  const lookupUidR = lookupsUid(lookupsR);
+  if (lookupUidL || lookupUidR) {
+    uid += `%%${lookupUidL}||${lookupUidR}`;
+  }
+  return uid;
 }
 
 // src/check/check-runner.ts
@@ -5428,10 +5623,14 @@ var SuiteRunner = class {
         datasetKeySet.add(dataTask.datasetKey);
       }
       const datasetKeys = [...datasetKeySet];
-      function getDatasets(bundleModel, scenarioSpec) {
+      function getDatasets(bundleModel, scenarioSpec, constants, lookups) {
         return __async(this, null, function* () {
           if (bundleModel && scenarioSpec) {
-            return bundleModel.getDatasetsForScenario(scenarioSpec, datasetKeys);
+            let options;
+            if (constants || lookups) {
+              options = { constants, lookups };
+            }
+            return bundleModel.getDatasetsForScenario(scenarioSpec, datasetKeys, options);
           } else {
             return void 0;
           }
@@ -5440,8 +5639,8 @@ var SuiteRunner = class {
       const bundleModelL = bundleModels.L;
       const bundleModelR = bundleModels.R;
       const [datasetsResultL, datasetsResultR] = yield Promise.all([
-        getDatasets(bundleModelL, request.scenarioSpecL),
-        getDatasets(bundleModelR, request.scenarioSpecR)
+        getDatasets(bundleModelL, request.scenarioSpecL, request.constantsL, request.lookupsL),
+        getDatasets(bundleModelR, request.scenarioSpecR, request.constantsR, request.lookupsR)
       ]);
       if (datasetsResultL == null ? void 0 : datasetsResultL.modelRunTime) {
         this.perfStatsL.addRun(datasetsResultL == null ? void 0 : datasetsResultL.modelRunTime);