@sdeverywhere/plugin-check 0.3.19 → 0.3.21

package/template-bundle/src/bundle.ts

@@ -4,25 +4,24 @@ import type {
   Bundle,
   BundleGraphData,
   BundleModel as CheckBundleModel,
-  Dataset,
   DatasetKey,
-  DatasetMap,
   DatasetsResult,
   LinkItem,
   ModelSpec,
   ScenarioSpec
 } from '@sdeverywhere/check-core'
 
-import type { InputValue, InputVarId, ModelRunner, Outputs, Point } from '@sdeverywhere/runtime'
+import type { InputVarId } from '@sdeverywhere/runtime'
 import { spawnAsyncModelRunner } from '@sdeverywhere/runtime-async'
 
-import type { Input } from './inputs'
-import { getInputVars, setInputsForScenario } from './inputs'
+import { getImplVars } from './impl-vars'
+import { type Input, getInputVars } from './inputs'
 import { getOutputVars } from './outputs'
 
-import { inputSpecs, outputSpecs, modelSizeInBytes, dataSizeInBytes } from 'virtual:model-spec'
+import { encodedImplVars, inputSpecs, outputSpecs, modelSizeInBytes, dataSizeInBytes } from 'virtual:model-spec'
 
 import modelWorkerJs from '@_model_worker_/worker.js?raw'
+import { BundleModelRunner } from './bundle-model-runner'
 
 // The current version of the check bundle format.  This should be
 // incremented when there is an incompatible change to the bundle format.
@@ -31,62 +30,18 @@ import modelWorkerJs from '@_model_worker_/worker.js?raw'
 const VERSION = 1
 
 export class BundleModel implements CheckBundleModel {
-  private readonly inputs: InputValue[]
-  private outputs: Outputs
-
   /**
    * @param modelSpec The spec for the bundled model.
-   * @param inputMap The model inputs.
-   * @param modelRunner The model runner.
+   * @param bundleModelRunner The bundle model runner.
    */
   constructor(
     public readonly modelSpec: ModelSpec,
-    private readonly inputMap: Map<InputVarId, Input>,
-    private readonly modelRunner: ModelRunner
-  ) {
-    // Derive an array of `InputValue` instances that can be passed to the runner
-    this.inputs = [...inputMap.values()].map(input => input.value)
-
-    // Create an `Outputs` instance that is initialized to hold output data
-    // produced by the Wasm model
-    this.outputs = modelRunner.createOutputs()
-  }
+    private readonly bundleModelRunner: BundleModelRunner
+  ) {}
 
   // from CheckBundleModel interface
   async getDatasetsForScenario(scenario: ScenarioSpec, datasetKeys: DatasetKey[]): Promise<DatasetsResult> {
-    const datasetMap: DatasetMap = new Map()
-
-    // Set the input values according to the given scenario
-    setInputsForScenario(this.inputMap, scenario)
-
-    // Run the JS model
-    this.outputs = await this.modelRunner.runModel(this.inputs, this.outputs)
-    const modelRunTime = this.outputs.runTimeInMillis
-
-    // Extract the data for each requested output variable and put it into a map
-    for (const datasetKey of datasetKeys) {
-      // Get the output variable for the given dataset key; if the variable doesn't
-      // exist in this version of the model/bundle, just skip it
-      const outputVar = this.modelSpec.outputVars.get(datasetKey)
-      if (!outputVar) {
-        continue
-      }
-
-      if (outputVar.sourceName === undefined) {
-        // See if we have data for the requested model output variable
-        const series = this.outputs.getSeriesForVar(outputVar.varId)
-        if (series) {
-          datasetMap.set(datasetKey, datasetFromPoints(series.points))
-        }
-      } else {
-        console.error('Static data sources not yet handled in default model check bundle')
-      }
-    }
-
-    return {
-      datasetMap,
-      modelRunTime
-    }
+    return this.bundleModelRunner.runModelForScenario(scenario, datasetKeys)
   }
 
   // from CheckBundleModel interface
@@ -107,28 +62,16 @@ export class BundleModel implements CheckBundleModel {
  * under different scenarios.
  */
 async function initBundleModel(modelSpec: ModelSpec, inputMap: Map<InputVarId, Input>): Promise<BundleModel> {
-  // Initialize the Wasm model asynchronously.  We inline the worker code in the
+  // Initialize the JS/Wasm model asynchronously.  We inline the worker code in the
   // rolled-up bundle so that we don't have to fetch a separate `worker.js` file
   const modelRunner = await spawnAsyncModelRunner({ source: modelWorkerJs })
 
-  // Return a `BundleModel` that wraps the underlying config and Wasm model
-  return new BundleModel(modelSpec, inputMap, modelRunner)
-}
+  // Create a `BundleModelRunner` that wraps the `ModelRunner` instance and takes
+  // care of translating `runtime` types to the types expected by `check-core`
+  const bundleModelRunner = new BundleModelRunner(modelSpec, inputMap, modelRunner)
 
-/**
- * Create a `Dataset` containing the given data points from the model.
- */
-export function datasetFromPoints(points: Point[]): Dataset {
-  const dataMap = new Map()
-  for (const point of points) {
-    // We omit points that have an undefined value.  SDE represents `:NA:` values as
-    // a special value (`-DBL_MAX`); the `runtime` package detects these and converts
-    // them to undefined instead.  We don't need them to appear in graphs, so omit them.
-    if (point.y !== undefined) {
-      dataMap.set(point.x, point.y)
-    }
-  }
-  return dataMap
+  // Return a `BundleModel` that wraps the underlying config and Wasm model
+  return new BundleModel(modelSpec, bundleModelRunner)
 }
 
 /**
@@ -140,12 +83,16 @@ export function createBundle(): Bundle {
   const inputVars = getInputVars(inputSpecs)
   const outputVars = getOutputVars(outputSpecs)
 
+  // Gather information about internal/implementation variables
+  const { implVars, implVarGroups } = getImplVars(encodedImplVars)
+
   const modelSpec: ModelSpec = {
     modelSizeInBytes,
     dataSizeInBytes,
     inputVars,
     outputVars,
-    implVars: new Map()
+    implVars,
+    implVarGroups
     // TODO: startTime and endTime are optional; the comparison graphs work OK if
     // they are undefined.  The main benefit of using these is to set a specific
     // range for the x-axis on the comparison graphs, so maybe we should find

package/template-bundle/src/empty-model-spec.ts

@@ -6,10 +6,14 @@
  * up using aliases in the Vite config file.)
  */
 
+import type { EncodedImplVars } from '@sdeverywhere/check-core'
+
 import type { InputSpec } from './inputs'
 import type { OutputSpec } from './outputs'
 
 export const inputSpecs: InputSpec[] = []
 export const outputSpecs: OutputSpec[] = []
+export const encodedImplVars: EncodedImplVars = undefined
+
 export const modelSizeInBytes = 0
 export const dataSizeInBytes = 0

package/template-bundle/src/impl-vars.ts

@@ -0,0 +1,59 @@
+// Copyright (c) 2022 Climate Interactive / New Venture Fund
+
+import type { DatasetKey, EncodedImplVars, ImplVar, ImplVarGroup } from '@sdeverywhere/check-core'
+import { decodeImplVars } from '@sdeverywhere/check-core'
+
+/** The properties related to impl variables that will be included in the bundle model spec. */
+export interface ImplSpec {
+  /** The map of all variables (both internal and exported) in this version of the model. */
+  implVars: Map<DatasetKey, ImplVar>
+  /** The groupings of internal/implementation variables in this version of the model. */
+  implVarGroups?: ImplVarGroup[]
+}
+
+/**
+ * Gather the set of internal/implementation variables used in this version of the model.
+ */
+export function getImplVars(encodedImplVars: EncodedImplVars): ImplSpec {
+  // Decode the encoded impl variables into the original `ImplVar` objects
+  const decodedImplVars = decodeImplVars(encodedImplVars)
+
+  const implVars: Map<DatasetKey, ImplVar> = new Map()
+  const implVarGroups: ImplVarGroup[] = []
+
+  function addGroup(fn: string, implVarInstances: ImplVar[]): void {
+    // Add the var instances for this group to the map
+    const datasetKeysForGroup: DatasetKey[] = []
+    for (const implVarInstance of implVarInstances) {
+      // TODO: For now, skip lookup and data variables because we have no way to
+      // access them in the model
+      if (implVarInstance.varType === 'lookup' || implVarInstance.varType === 'data') {
+        continue
+      }
+      const varId = implVarInstance.varId
+      const datasetKey = `ModelImpl_${varId}`
+      implVars.set(datasetKey, implVarInstance)
+      datasetKeysForGroup.push(datasetKey)
+    }
+
+    // Add the group info
+    implVarGroups.push({
+      title: fn,
+      fn,
+      datasetKeys: datasetKeysForGroup
+    })
+  }
+
+  addGroup('initConstants', decodedImplVars.constants || [])
+  // TODO: Include lookups and data variables
+  // addGroup('initLookups', decodedImplVars.lookupVars || [])
+  // addGroup('initData', decodedImplVars.dataVars || [])
+  addGroup('initLevels', decodedImplVars.initVars || [])
+  addGroup('evalLevels', decodedImplVars.levelVars || [])
+  addGroup('evalAux', decodedImplVars.auxVars || [])
+
+  return {
+    implVars,
+    implVarGroups
+  }
+}

package/template-report/index.html

@@ -23,6 +23,28 @@
       }
     </style>
 
+    <!--
+      XXX: Include no-op polyfills for these modules that are used in the Node-specific
+      implementation of threads.js.  This allows us to use one model-check bundle that
+      works in both Node and browser environments.  Without this importmap, loading a
+      remote bundle would fail with the following error when trying to import Node
+      modules like `worker_threads` that aren't available in the browser:
+        TypeError: The specifier “worker_threads” was a bare specifier, but was not
+        remapped to anything.
+    -->
+    <script type="importmap">
+      {
+        "imports": {
+          "events": "./polyfills/noop-polyfills.js",
+          "fs": "./polyfills/noop-polyfills.js",
+          "os": "./polyfills/noop-polyfills.js",
+          "path": "./polyfills/noop-polyfills.js",
+          "url": "./polyfills/noop-polyfills.js",
+          "worker_threads": "./polyfills/noop-polyfills.js"
+        }
+      }
+    </script>
+
     <script type="module" src="./src/index.ts"></script>
   </head>
 

package/template-report/src/{baselines → bundles}/unused.txt

@@ -1,2 +1,2 @@
-This file is not used but must remain present to ensure that the `template-report/src/baselines`
+This file is not used but must remain present to ensure that the `template-report/src/bundles`
 directory exists.  See `vite-config-for-report.ts` for details.

package/template-report/src/env.d.ts

@@ -2,6 +2,8 @@
 
 // These values are injected by Vite at build time, so we need to
 // declare types for them here
+declare const __SUITE_SUMMARY_JSON__: string
 declare const __BASELINE_NAME__: string
 declare const __CURRENT_NAME__: string
-declare const __SUITE_SUMMARY_JSON__: string
+declare const __CURRENT_BUNDLE_LAST_MODIFIED__: string
+declare const __REMOTE_BUNDLES_URL__: string